GKE vs Cloud Run decision in GCP - Hands-On Comparison

GKE vs Cloud Run Decision Guide

📖 Scenario: You are a cloud architect helping a small company decide how to deploy their containerized applications on Google Cloud Platform. They want to understand when to use Google Kubernetes Engine (GKE) versus Cloud Run.

🎯 Goal: Build a simple Python dictionary that lists application types and their recommended deployment option (GKE or Cloud Run). Then add a configuration variable for workload size, write logic to select the deployment based on workload, and finally complete the decision guide with a summary statement.

📋 What You'll Learn

Create a dictionary named app_deployments with exact keys and values for application types and deployment options

Add a variable named workload_size with a string value representing workload size

Write a function named choose_deployment that takes an application type and workload size and returns the recommended deployment

Add a final variable named decision_summary that stores a summary string using the function

💡 Why This Matters

🌍 Real World

This project helps beginners understand how to decide between GKE and Cloud Run for deploying containerized applications based on workload and application complexity.

💼 Career

Cloud architects and developers often need to choose the right Google Cloud service for deployment. This exercise builds foundational decision-making skills for cloud infrastructure.

1

Create the application deployment dictionary

Create a dictionary called app_deployments with these exact entries: 'microservice': 'Cloud Run', 'batch job': 'Cloud Run', 'complex app': 'GKE', 'stateful app': 'GKE'

GCP

# Create the app_deployments dictionary with exact entries
# Your code here

Hint

Use curly braces to create a dictionary with the exact keys and values.

2

Add workload size configuration

Add a variable called workload_size and set it to the string 'small'

GCP

app_deployments = {
    'microservice': 'Cloud Run',
    'batch job': 'Cloud Run',
    'complex app': 'GKE',
    'stateful app': 'GKE'
}
# Add workload_size variable below
# Your code here

Hint

Assign the string 'small' to the variable workload_size.

3

Write deployment decision function

Write a function called choose_deployment that takes parameters app_type and workload. It should return 'GKE' if workload is 'large', otherwise return the deployment from app_deployments[app_type]

GCP

app_deployments = {
    'microservice': 'Cloud Run',
    'batch job': 'Cloud Run',
    'complex app': 'GKE',
    'stateful app': 'GKE'
}
workload_size = 'small'
# Define choose_deployment function below
# Your code here

Hint

Use an if-else statement inside the function to check workload size.

4

Add final decision summary

Add a variable called decision_summary that stores the string "For a microservice with small workload, deploy to " plus the result of choose_deployment('microservice', workload_size)

GCP

app_deployments = {
    'microservice': 'Cloud Run',
    'batch job': 'Cloud Run',
    'complex app': 'GKE',
    'stateful app': 'GKE'
}
workload_size = 'small'

def choose_deployment(app_type, workload):
    if workload == 'large':
        return 'GKE'
    else:
        return app_deployments[app_type]

# Add decision_summary variable below
# Your code here

Hint

Use string concatenation with the function call to build the summary.

Practice

1. Which service should you choose if you want to avoid managing servers and focus only on deploying containers?

easy

A. Compute Engine

B. Google Kubernetes Engine (GKE)

C. App Engine Standard

D. Cloud Run

Solution

1. Step 1: Understand server management needs

   Cloud Run is serverless, so it handles server management automatically.

2. Step 2: Compare with GKE

   GKE requires managing Kubernetes clusters and nodes, which means more management effort.

3. Final Answer:

   Cloud Run -> Option D

4. Quick Check:

   Serverless = Cloud Run [OK]

Hint: Serverless means no server management needed [OK]

Common Mistakes:

• Confusing GKE as serverless
• Choosing Compute Engine which is VM-based
• Thinking App Engine Standard is container-focused

2. Which of the following is the correct way to deploy a container image to Cloud Run using gcloud CLI?

easy

A. gcloud run deploy SERVICE --image IMAGE_URL --platform managed

B. gcloud container clusters create SERVICE --image IMAGE_URL

C. gcloud compute instances create SERVICE --image IMAGE_URL

D. gcloud app deploy --image IMAGE_URL

Solution

1. Step 1: Identify Cloud Run deployment command

   The correct command uses gcloud run deploy with the service name and image URL.

2. Step 2: Eliminate other commands

   Other options relate to Kubernetes clusters, VM instances, or App Engine, which are incorrect for Cloud Run.

3. Final Answer:

   gcloud run deploy SERVICE --image IMAGE_URL --platform managed -> Option A

4. Quick Check:

   Cloud Run deploy uses gcloud run deploy [OK]

Hint: Cloud Run deploy always uses 'gcloud run deploy' [OK]

Common Mistakes:

• Using 'gcloud container clusters create' for Cloud Run
• Confusing Compute Engine commands with Cloud Run
• Using App Engine deploy command for Cloud Run

3. You deploy a containerized app to GKE with autoscaling enabled. What happens when traffic suddenly spikes?

medium

A. Cloud Run automatically pauses the service until traffic decreases.

B. GKE automatically adds more pods to handle the increased load.

C. GKE shuts down pods to save resources during high traffic.

D. Cloud Run requires manual scaling to handle traffic spikes.

Solution

1. Step 1: Understand GKE autoscaling behavior

   GKE uses Horizontal Pod Autoscaler to add pods automatically when traffic increases.

2. Step 2: Compare with Cloud Run behavior

   Cloud Run scales automatically but does not pause services; manual scaling is not required.

3. Final Answer:

   GKE automatically adds more pods to handle the increased load. -> Option B

4. Quick Check:

   GKE autoscaling adds pods on traffic spike [OK]

Hint: GKE autoscaling adds pods automatically on load [OK]

Common Mistakes:

• Thinking Cloud Run pauses services on high traffic
• Believing GKE shuts down pods during spikes
• Assuming Cloud Run needs manual scaling

4. You tried deploying a container to Cloud Run but got an error about missing CPU allocation. What is the likely cause?

medium

A. You did not specify the CPU limit in the deployment command.

B. Cloud Run does not support containers with CPU requirements.

C. You deployed to GKE instead of Cloud Run by mistake.

D. The container image is not compatible with Cloud Run.

Solution

1. Step 1: Understand Cloud Run CPU allocation

   Cloud Run requires CPU allocation settings; missing these can cause errors.

2. Step 2: Check deployment command

   If CPU limits are not specified, Cloud Run deployment fails with CPU allocation errors.

3. Final Answer:

   You did not specify the CPU limit in the deployment command. -> Option A

4. Quick Check:

   Missing CPU limit causes deployment error [OK]

Hint: Always specify CPU limits when deploying to Cloud Run [OK]

Common Mistakes:

• Assuming Cloud Run ignores CPU settings
• Confusing GKE deployment with Cloud Run
• Blaming container image compatibility without checking CPU

5. Your team needs to run a complex microservices app with custom networking, persistent storage, and fine-grained control over scaling. Which service is best?

hard

A. Cloud Run because it handles all scaling automatically

B. Cloud Functions because it runs code without servers

C. GKE because it supports complex orchestration and custom setups

D. App Engine because it is fully managed and simple

Solution

1. Step 1: Analyze app requirements

   The app needs complex orchestration, custom networking, persistent storage, and detailed scaling control.

2. Step 2: Match requirements to services

   GKE supports Kubernetes features for complex setups, while Cloud Run is simpler and serverless but less customizable.

3. Final Answer:

   GKE because it supports complex orchestration and custom setups -> Option C

4. Quick Check:

   Complex control needs = GKE [OK]

Hint: Complex apps with custom needs use GKE [OK]

Common Mistakes:

• Choosing Cloud Run for complex networking
• Confusing App Engine with container orchestration
• Using Cloud Functions for microservices orchestration