Revision management in GCP - Deep Dive

Overview - Revision management

What is it?

Revision management is the process of keeping track of different versions of your cloud resources or applications. It helps you save, organize, and restore previous states of your infrastructure or code. This way, you can easily go back to an earlier version if something goes wrong or if you want to compare changes.

Why it matters

Without revision management, fixing mistakes or understanding changes becomes very hard and risky. Imagine if you accidentally delete important settings or code and cannot get them back. Revision management protects your work and helps teams collaborate safely by knowing exactly what changed and when.

Where it fits

Before learning revision management, you should understand basic cloud resources and how to deploy them. After mastering revision management, you can explore advanced topics like continuous delivery, automated rollback, and infrastructure as code versioning.

Mental Model

Core Idea

Revision management is like a time machine for your cloud resources, letting you save and revisit past versions safely.

Think of it like...

Think of revision management like saving different drafts of a school essay. Each draft is a snapshot you can return to if you don’t like the latest changes.

┌───────────────┐
│ Current State │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Revision 3   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Revision 2   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│  Revision 1   │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What is a revision in cloud

Concept: Introduce the idea of a revision as a saved version of cloud resources or code.

A revision is a snapshot of your cloud setup at a certain time. It records all settings and files so you can restore or compare later. For example, when you update a cloud function, a new revision saves the new code without losing the old one.

Result

You understand that revisions are saved states you can return to anytime.

Knowing that revisions are snapshots helps you see how changes are tracked safely over time.

2

Foundation

Why revisions matter in cloud

Concept: Explain the importance of revisions for safety and collaboration.

Cloud environments change often. Revisions let you undo mistakes by going back to a previous version. They also let teams work together without overwriting each other's work. Without revisions, fixing errors or understanding changes would be risky and confusing.

Result

You see revisions as a safety net and teamwork tool.

Understanding the safety and collaboration role of revisions motivates their use in real projects.

3

Intermediate

How GCP manages revisions

🤔Before reading on: do you think GCP stores all revisions automatically or only when you ask? Commit to your answer.

Concept: Learn how Google Cloud Platform saves and handles revisions for services like Cloud Run and Cloud Functions.

GCP services like Cloud Run automatically create a new revision each time you deploy changes. Each revision is immutable, meaning it cannot be changed once saved. You can list, view, and roll back to any previous revision easily using the console or command line.

Result

You know that GCP automatically saves revisions and how to access them.

Knowing that revisions are automatic and immutable in GCP helps you trust the system and use rollbacks confidently.

4

Intermediate

Using revisions for rollback

🤔Before reading on: do you think rollback replaces the current version or creates a new revision? Commit to your answer.

Concept: Understand how to revert to a previous revision to fix problems or test older versions.

Rollback means switching your live service to use an earlier revision. In GCP, rollback does not delete newer revisions; it just points traffic back to the chosen revision. This lets you test or fix issues without losing any history.

Result

You can safely undo changes by rolling back to a stable revision.

Understanding rollback as traffic redirection, not deletion, prevents accidental data loss.

5

Intermediate

Revision labels and metadata

Concept: Learn how to add labels or notes to revisions for easier tracking.

You can tag revisions with labels or descriptions to remember what changed. For example, label a revision 'bug fix' or 'feature v2'. This helps when you have many revisions and need to find a specific one quickly.

Result

You can organize and identify revisions clearly.

Using labels improves revision management by making history easier to understand and navigate.

6

Advanced

Revision management in Infrastructure as Code

🤔Before reading on: do you think code versioning and cloud revision management are the same or different? Commit to your answer.

Concept: Explore how revision management applies to infrastructure code using tools like Terraform with GCP.

Infrastructure as Code (IaC) means writing cloud setup as code files. These files are stored in version control systems like Git, which track changes over time. This complements GCP's own revision system by managing the code that defines your cloud resources, allowing safe updates and rollbacks at the code level.

Result

You see how code versioning and cloud revisions work together for safe cloud management.

Knowing the difference and connection between code versioning and cloud revisions helps build reliable, repeatable cloud setups.

7

Expert

Revision management challenges and best practices

🤔Before reading on: do you think keeping every revision forever is good or bad? Commit to your answer.

Concept: Understand the limits and strategies for managing many revisions in production environments.

Keeping all revisions forever can waste storage and cause confusion. Best practices include cleaning up old unused revisions, using meaningful labels, automating rollback tests, and integrating revision management with CI/CD pipelines. Also, be aware of service-specific limits on revision counts and retention policies.

Result

You can manage revisions efficiently and avoid common pitfalls in large projects.

Knowing how to balance revision retention and cleanup prevents resource waste and operational headaches.

Under the Hood

When you deploy a new version of a cloud service in GCP, the platform creates a new immutable revision object that stores the exact configuration and code at that moment. Traffic routing rules then point user requests to a specific revision. The system keeps all revisions separately, allowing switching between them without changing the stored data. This separation ensures stability and easy rollback.

Why designed this way?

Immutable revisions prevent accidental changes to past versions, ensuring reliability and auditability. Automatic revision creation simplifies developer workflows by removing manual versioning steps. Separating revisions from traffic routing allows flexible deployment strategies like gradual rollouts or quick rollbacks without downtime.

┌───────────────┐       ┌───────────────┐
│   Revision 1  │◄──────│ Traffic Rule  │
└───────────────┘       └───────────────┘
       ▲                        ▲
       │                        │
┌───────────────┐       ┌───────────────┐
│   Revision 2  │──────►│ Traffic Rule  │
└───────────────┘       └───────────────┘
       ▲                        ▲
       │                        │
┌───────────────┐       ┌───────────────┐
│   Revision 3  │──────►│ Traffic Rule  │
└───────────────┘       └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think rolling back deletes newer revisions? Commit yes or no.

Common Belief: Rolling back removes all newer revisions and deletes their data.

Reality: Rolling back only changes which revision receives traffic; all revisions remain stored and intact.

Why it matters: Believing rollback deletes revisions can cause fear of losing work and prevent using rollback safely.

Quick: Do you think revisions are only for code, not infrastructure? Commit yes or no.

Common Belief: Revisions only apply to application code, not cloud infrastructure settings.

Reality: Revisions also apply to infrastructure configurations, especially when using Infrastructure as Code tools integrated with version control.

Why it matters: Ignoring infrastructure revisions risks untracked changes and harder recovery from misconfigurations.

Quick: Do you think all revisions should be kept forever? Commit yes or no.

Common Belief: Keeping every revision forever is best for safety and history.

Reality: Storing too many revisions wastes resources and complicates management; cleaning up unused revisions is necessary.

Why it matters: Not cleaning revisions can lead to higher costs and slower operations.

Quick: Do you think revision labels are optional and unimportant? Commit yes or no.

Common Belief: Labels on revisions are just extra and don’t affect management.

Reality: Labels are crucial for organizing and quickly identifying revisions, especially in large projects.

Why it matters: Ignoring labels leads to confusion and mistakes when selecting revisions to deploy or rollback.

Expert Zone

1

Revisions in GCP are immutable, but traffic routing is flexible, allowing complex deployment strategies like canary releases.

2

Infrastructure as Code versioning complements cloud service revisions but requires synchronization to avoid drift between code and deployed state.

3

Automated cleanup of old revisions must balance between retaining rollback safety and controlling resource costs.

When NOT to use

Revision management is not a substitute for proper testing and monitoring. For rapid iterative development, feature flags or blue-green deployments may be better. Also, for very large binary assets, specialized versioning systems outside cloud revisions are preferred.

Production Patterns

In production, teams use revision management combined with CI/CD pipelines to automate deployments and rollbacks. They tag revisions with meaningful metadata, monitor traffic shifts during rollouts, and schedule cleanup jobs to remove stale revisions safely.

Connections

Version Control Systems (Git)

Revision management in cloud builds on the same idea of tracking changes over time as Git does for code.

Understanding Git helps grasp how cloud revisions track and manage changes safely and collaboratively.

Continuous Integration/Continuous Deployment (CI/CD)

Revision management is a key part of CI/CD pipelines to automate safe deployments and rollbacks.

Knowing revision management enables smoother automation and faster recovery in software delivery.

Library Book Borrowing System

Both systems track versions or states over time and allow returning to previous states safely.

Seeing revision management like borrowing and returning books helps understand the importance of tracking and restoring past states.

Common Pitfalls

#1 Trying to manually edit a saved revision to fix a bug.

Wrong approach:

Editing an existing revision directly in the cloud console or code repository without creating a new revision.

Correct approach:

Create a new revision with the fix and deploy it, leaving old revisions unchanged.

Root cause:

Misunderstanding that revisions are immutable snapshots, not editable files.

#2 Ignoring cleanup and keeping all revisions forever.

Wrong approach:

Never deleting old revisions, leading to clutter and high storage costs.

Correct approach:

Regularly delete unused revisions after confirming they are no longer needed.

Root cause:

Belief that more history is always better without considering resource limits.

#3 Rolling back by deleting newer revisions instead of redirecting traffic.

Wrong approach:

Deleting recent revisions to revert to an older version.

Correct approach:

Use rollback commands or settings to redirect traffic to the desired revision without deletion.

Root cause:

Confusing rollback with deletion, risking data loss.

Key Takeaways

Revision management saves snapshots of your cloud resources so you can safely track and restore changes.

GCP automatically creates immutable revisions for services like Cloud Run, enabling easy rollback and history tracking.

Rollback switches traffic to a previous revision without deleting newer versions, preserving all history.

Using labels and cleaning up old revisions helps keep your cloud environment organized and cost-effective.

Revision management works best combined with code versioning and CI/CD pipelines for reliable cloud operations.

Practice

1. What is the main purpose of revision management in Google Cloud services?

easy

A. To track and control different versions of your cloud services

B. To increase the storage capacity of your cloud database

C. To monitor network traffic between services

D. To automatically scale the number of virtual machines

Solution

1. Step 1: Understand revision management concept

   Revision management is about keeping track of different versions of your cloud services.

2. Step 2: Identify the main goal

   The main goal is to control versions for safe updates and rollbacks.

3. Final Answer:

   To track and control different versions of your cloud services -> Option A

4. Quick Check:

   Revision management = version control [OK]

Hint: Revision management means version control of services [OK]

Common Mistakes:

• Confusing revision management with scaling
• Thinking it manages storage or network
• Mixing it with monitoring tools

2. Which gcloud command is used to list all revisions of a Cloud Run service named my-service?

easy

A. gcloud run revisions list --service=my-service

B. gcloud run services list --revisions=my-service

C. gcloud revisions describe my-service

D. gcloud run deploy revisions --service=my-service

Solution

1. Step 1: Identify correct command structure

   The command to list revisions uses gcloud run revisions list with the service flag.

2. Step 2: Match service name parameter

   Using --service=my-service correctly specifies the service.

3. Final Answer:

   gcloud run revisions list --service=my-service -> Option A

4. Quick Check:

   List revisions = gcloud run revisions list --service [OK]

Hint: List revisions with 'gcloud run revisions list --service' [OK]

Common Mistakes:

• Using 'services list' instead of 'revisions list'
• Mixing 'describe' with listing
• Wrong command order or flags

3. Given the following commands, what will be the output of gcloud run revisions list --service=my-app after deploying twice?

gcloud run deploy my-app --image=image:v1 --no-traffic
gcloud run deploy my-app --image=image:v2 --no-traffic

medium

A. One revision with image:v2

B. No revisions because traffic is zero

C. Two revisions: one with image:v1 and one with image:v2

D. Error because --no-traffic disables revisions

Solution

1. Step 1: Understand deployment with --no-traffic

   Deploying with --no-traffic creates a new revision but does not route traffic to it.

2. Step 2: Analyze multiple deployments

   Deploying twice with different images creates two separate revisions.

3. Final Answer:

   Two revisions: one with image:v1 and one with image:v2 -> Option C

4. Quick Check:

   Each deploy creates a revision even with no traffic [OK]

Hint: Each deploy creates a revision, traffic doesn't affect revision count [OK]

Common Mistakes:

• Assuming no traffic means no revision
• Thinking only latest revision exists
• Confusing traffic routing with revision creation

4. You deployed a new revision but it is not receiving traffic. Which command fixes this by routing 100% traffic to the latest revision named my-app-00002?

medium

A. gcloud run revisions set-traffic my-app-00002 --percent=100

B. gcloud run services update-traffic my-app --to-revisions my-app-00002=100

C. gcloud run services update my-app --traffic my-app-00002=100

D. gcloud run services update-traffic my-app --to-revision my-app-00002=100

Solution

1. Step 1: Identify correct command to update traffic

   The command to update traffic routing is gcloud run services update-traffic.

2. Step 2: Use correct syntax for traffic split

   The syntax --to-revisions my-app-00002=100 routes 100% traffic to that revision.

3. Final Answer:

   gcloud run services update-traffic my-app --to-revisions my-app-00002=100 -> Option B

4. Quick Check:

   Update traffic with 'services update-traffic' and '--to-revisions' [OK]

Hint: Use 'gcloud run services update-traffic' with '--to-revisions' [OK]

Common Mistakes:

• Using 'update' instead of 'update-traffic'
• Wrong flag names like '--percent'
• Trying to set traffic on revision directly

5. You want to roll back your Cloud Run service web-app to a previous revision web-app-00003 safely without downtime. Which sequence of commands achieves this?

hard

A. gcloud run deploy web-app --image=web-app-00003

B. gcloud run services update web-app --revision web-app-00003

C. gcloud run revisions delete web-app-00004 && gcloud run services update-traffic web-app --to-revisions web-app-00003=100

D. gcloud run services update-traffic web-app --to-revisions web-app-00003=100

Solution

1. Step 1: Understand rollback via traffic routing

   Rolling back means routing traffic back to an existing previous revision.

2. Step 2: Use traffic update command

   Use gcloud run services update-traffic to send 100% traffic to the old revision.

3. Step 3: Avoid deleting revisions or redeploying

   Deleting or redeploying is unnecessary and may cause downtime.

4. Final Answer:

   gcloud run services update-traffic web-app --to-revisions web-app-00003=100 -> Option D

5. Quick Check:

   Rollback by routing traffic to old revision [OK]

Hint: Rollback by updating traffic to old revision, no redeploy needed [OK]

Common Mistakes:

• Trying to redeploy old revision as image
• Deleting newer revisions unnecessarily
• Using wrong commands to update revision