Request-based auto scaling in GCP - Mini Project: Build & Apply

Request-based Auto Scaling on Google Cloud Run

📖 Scenario: You are managing a web application deployed on Google Cloud Run. The app needs to automatically adjust the number of container instances based on incoming HTTP request load to save costs and maintain performance.

🎯 Goal: Build a Cloud Run service configuration that enables request-based auto scaling by setting the maximum number of container instances and concurrency limits.

📋 What You'll Learn

Create a Cloud Run service configuration dictionary with the exact service name and image URL

Add a configuration variable for maximum container instances

Set the concurrency limit to control how many requests each container handles

Complete the service configuration with the auto scaling settings

💡 Why This Matters

🌍 Real World

Cloud Run automatically adjusts the number of container instances based on request load, saving costs and improving performance.

💼 Career

Understanding request-based auto scaling is essential for cloud engineers and developers managing scalable web applications on Google Cloud.

1

Create initial Cloud Run service configuration

Create a dictionary called cloud_run_service with these exact entries: "name": "projects/my-project/locations/us-central1/services/my-service" and "image": "gcr.io/my-project/my-app-image:latest".

GCP

# Create the cloud_run_service dictionary with name and image
# Your code here

Hint

Use a Python dictionary with keys name and image exactly as shown.

2

Add maximum container instances configuration

Add a key max_instances to the cloud_run_service dictionary and set it to 5.

GCP

cloud_run_service = {
    "name": "projects/my-project/locations/us-central1/services/my-service",
    "image": "gcr.io/my-project/my-app-image:latest"
}
# Add max_instances key with value 5 to cloud_run_service
# Your code here

Hint

Add the max_instances key with the value 5 inside the dictionary.

3

Set concurrency limit for request handling

Add a key concurrency to the cloud_run_service dictionary and set it to 80 to control how many requests each container can handle simultaneously.

GCP

cloud_run_service = {
    "name": "projects/my-project/locations/us-central1/services/my-service",
    "image": "gcr.io/my-project/my-app-image:latest",
    "max_instances": 5
}
# Add concurrency key with value 80 to cloud_run_service
# Your code here

Hint

Add the concurrency key with the value 80 inside the dictionary.

4

Complete the Cloud Run service configuration with auto scaling settings

Add a nested dictionary under the key autoscaling in cloud_run_service with the exact entry "target_concurrency": 80.

GCP

cloud_run_service = {
    "name": "projects/my-project/locations/us-central1/services/my-service",
    "image": "gcr.io/my-project/my-app-image:latest",
    "max_instances": 5,
    "concurrency": 80
}
# Add autoscaling dictionary with target_concurrency 80
# Your code here

Hint

Inside cloud_run_service, add the autoscaling key with a dictionary value containing "target_concurrency": 80.

Practice

1. What does request-based auto scaling primarily adjust in a cloud service?

easy

A. The number of server instances based on incoming requests

B. The amount of storage space available

C. The network bandwidth allocation

D. The security settings of the service

Solution

1. Step 1: Understand the purpose of request-based auto scaling

   Request-based auto scaling changes resources based on the number of incoming requests to handle load efficiently.

2. Step 2: Identify what is adjusted

   The main resource adjusted is the number of server instances to match demand.

3. Final Answer:

   The number of server instances based on incoming requests -> Option A

4. Quick Check:

   Scaling adjusts instances = A [OK]

Hint: Auto scaling changes instance count, not storage or security [OK]

Common Mistakes:

• Confusing scaling with storage or bandwidth changes
• Thinking it adjusts security settings
• Assuming it changes fixed resources regardless of requests

2. Which of the following is the correct way to set the minimum number of instances in a GCP service YAML configuration for request-based auto scaling?

easy

A. min-instances: 2

B. minInstances: 2

C. minimum_instances: 2

D. min_instances: 2

Solution

1. Step 1: Recall GCP YAML syntax for scaling parameters

   GCP uses kebab-case for configuration keys like min-instances.

2. Step 2: Identify the correct key format

   The correct key to set minimum instances is min-instances, not camelCase or underscored.

3. Final Answer:

   min-instances: 2 -> Option A

4. Quick Check:

   Use kebab-case keys like min-instances [OK]

Hint: Use kebab-case keys like min-instances in GCP YAML [OK]

Common Mistakes:

• Using camelCase or underscores instead of kebab-case
• Misspelling the key name
• Confusing min-instances with max-instances

3. Given this snippet of a GCP service configuration for request-based auto scaling:

concurrency: 10
min-instances: 1
max-instances: 5

What happens when the service receives 50 simultaneous requests?

medium

A. The service scales down to 0 instances to save cost

B. The service stays at 1 instance because min-instances is set

C. The service scales up to 10 instances because concurrency is 10

D. The service scales up to 5 instances to handle the load

Solution

1. Step 1: Understand concurrency and instance limits

   Concurrency 10 means each instance can handle 10 requests at once. Max-instances is 5, min-instances is 1.

2. Step 2: Calculate needed instances for 50 requests

   50 requests / 10 concurrency = 5 instances needed, which matches max-instances.

3. Final Answer:

   The service scales up to 5 instances to handle the load -> Option D

4. Quick Check:

   Requests/concurrency = instances needed = 5 [OK]

Hint: Divide requests by concurrency, respect max-instances limit [OK]

Common Mistakes:

• Ignoring max-instances limit
• Confusing concurrency with max-instances
• Assuming scaling down when load increases

4. You configured a GCP service with:

concurrency: 5
min-instances: 2
max-instances: 4

But the service never scales above 2 instances even under heavy load. What is the most likely cause?

medium

A. The concurrency value is too high, limiting scaling

B. The max-instances value is too low to allow scaling beyond 2

C. The min-instances value is preventing scaling down

D. The service needs a restart to apply scaling changes

Solution

1. Step 1: Analyze max-instances and min-instances settings

   Max-instances is set to 4, min-instances is 2. Scaling cannot exceed max-instances.

2. Step 2: Understand why scaling stops at 2

   If the service never goes above 2 instances, max-instances might be set too low or misinterpreted.

3. Final Answer:

   The max-instances value is too low to allow scaling beyond 2 -> Option B

4. Quick Check:

   Max-instances limits max scale = B [OK]

Hint: Check max-instances to allow scaling beyond min-instances [OK]

Common Mistakes:

• Confusing min-instances with max-instances
• Assuming concurrency limits scaling up
• Forgetting to check applied config values

5. You want to optimize cost and performance for a GCP service that experiences unpredictable traffic spikes. Which configuration best balances fast scaling up and cost savings during idle times?

hard

A. Set concurrency to 1, min-instances to 0, max-instances to 10

B. Set concurrency to 50, min-instances to 5, max-instances to 5

C. Set concurrency to 10, min-instances to 1, max-instances to 10

D. Set concurrency to 100, min-instances to 10, max-instances to 20

Solution

1. Step 1: Understand concurrency and instance settings impact

   Lower concurrency means more instances needed; min-instances controls baseline cost; max-instances limits scale.

2. Step 2: Evaluate options for balancing cost and performance

   Set concurrency to 10, min-instances to 1, max-instances to 10 uses moderate concurrency (10), low min-instances (1) to save cost, and high max-instances (10) to handle spikes.

3. Final Answer:

   Set concurrency to 10, min-instances to 1, max-instances to 10 -> Option C

4. Quick Check:

   Moderate concurrency + low min + high max = balanced scaling [OK]

Hint: Moderate concurrency with low min and high max balances cost and spikes [OK]

Common Mistakes:

• Setting concurrency too low causing many instances
• Setting min-instances too high increasing cost
• Setting max-instances too low limiting scaling