AWS App Runner vs. Google Cloud Run: Services Compared

Are you looking to deploy your container application into AWS App Runner or GCP Cloud Run?

This article is part of our series comparing cloud hosting services for container web applications.

Using AWS App Runner vs. GCP Cloud Run

AWS App Runner and GCP Cloud Run allow teams to deploy containerized applications without the need to manage infrastructure.

Both services offer powerful scalability and automation capabilities.

AWS App Runner offers fully managed services with easy deployments and limited customization options. In contrast, GCP Cloud Run provides more freedom allowing users to customize their environment with extra settings as needed.

Article Highlights

1. Pricing: AWS App Runner charges based on vCPU-hour and GB-hour, while GCP Cloud Run charges based on vCPU-seconds, GiB-seconds, and the number of requests. Cloud Run offers a generous free tier.
2. Deployment: AWS App Runner and GCP Cloud Run support deploying containerized applications using Dockerfiles. They integrate with popular container registries like Docker Hub and their respective cloud provider registries (Amazon ECR and Google Container Registry).
3. Scaling: Both services provide autoscaling mechanisms, adjusting the number of running instances based on traffic and performance metrics. Cloud Run also offers concurrency control to optimize resource utilization and cost.
4. Monitoring and Logging: AWS App Runner integrates with Amazon CloudWatch, while GCP Cloud Run uses Google Cloud Monitoring and Logging for application monitoring, logging, and troubleshooting.
5. Security: Both services use their respective cloud provider’s identity and access management (IAM) services for access control and permissions. They also utilize secure environments through Amazon VPC and Google VPC.
6. CI/CD Integration: AWS App Runner and GCP Cloud Run can be integrated into CI/CD pipelines, automatically building and deploying new application versions when changes are detected in source code repositories.
7. When to use: Choose AWS App Runner if you already use AWS services, prioritize deployment simplicity, and want managed CI/CD integration. Choose GCP Cloud Run if you already use GCP services, require concurrency control, or need a generous free tier.

Table of Contents

• Cloud-Native Hosting Services
• What is AWS App Runner
• What is GCP Cloud Run
• Differences Between Services
• Costs of Services
• How the Services Work
• Container Deployment
• When to Use

Cloud-Native App Container Hosting Options

Hosting options for application containers include cloud-native container services such as Amazon ECS, Google Kubernetes Engine (GKE), and Microsoft Azure Kubernetes Service (AKS). Additionally, cloud-specific services like AWS App Runner and GCP Cloud Run are available. 

Example Cloud-Native App Container Services

• Amazon ECS
• Google Kubernetes Engine (GKE)
• Microsoft Azure Kubernetes Service (AKS)
• AWS App Runner
• GCP Cloud Run

What is AWS APP Runner

AWS App Runner is a cloud-native container service offered by Amazon Web Services that allows developers to quickly and easily build, deploy, and manage containerized applications.

It automates the process of provisioning compute resources, deploying apps, scaling up and out, and providing ongoing maintenance while ensuring high availability. AWS App Runner simplifies end-to-end cloud application delivery with an intuitive console and integrated tools such as monitoring and logging services.

• AWS App Runner is a cloud-native container service from Amazon Web Services
• Automates the process of provisioning compute resources, deploying apps and scaling
• Provides ongoing maintenance and high availability
• Intuitive console and integrated tools such as monitoring and logging services

What is GCP Cloud Run

GCP Cloud Run is a serverless compute platform from Google Cloud Platform that allows developers to quickly and easily deploy and manage containerized applications.

It automates scaling up or down depending on demand, updates the application without any downtime, provides monitoring and logging tools, and allows users to run code in response to events using cloud events.

• GCP Cloud Run is a serverless compute platform from Google Cloud Platform
• Automates scaling up/down depending on-demand updates applications without downtime, and provides monitoring and logging tools.
• Allows users to run code in response to events using cloud events

What are the Major Differences Between App Runner & Cloud Run

The major differences between App Runner and Cloud Run are the underlying services that power them. App Runner is an all-in-one service powered by AWS Fargate, while Cloud Run is a serverless computing platform built on Kubernetes.

App Runner vs Cloud Run Comparison Table

Feature	AWS App Runner	GCP Cloud Run
Service Type	AWS ECS + Fargate	Kubernetes
Networking & Load Balancing	Always	When Selected
Security	Extensive	Limited
Integration	AWS	GCP

Which is Cheaper AWS App Runner vs GCP Cloud Run

App Runner. App Runner is generally more cost-effective than Cloud Run due to its lower compute cost. Additionally, its scalability does not require any additional cloud services.

App Runner vs Cloud Run Price Highlights

• Both services charge based on compute time and memory usage, but App Runner costs less per vCPU/GB RAM over Cloud Run.
• App Runner enables developers to bring their container images and does not require additional cloud services, while Cloud Run does require additional cloud services for scalability.

How Does AWS Charge for the App Runner Service

AWS App Runner charges you based on the total amount of CPU & RAM you use. You can maximize your costs by watching your autoscaling rules to limit the total amount of containers running simultaneously.

1. Compute and Memory: AWS App Runner pricing is based on the amount of vCPU and memory resources allocated to your services. You can select from a predefined configuration set that specifies the desired vCPU and memory combination. The cost is determined per vCPU and GB of memory per hour, billed in one-second increments.
2. Duration: AWS App Runner charges are based on the actual time your service instances are running. Billing begins when instances start and end when instances stop or are terminated. You are billed for the total duration of all instances of your service in one-second increments.
3. Requests: AWS App Runner does not charge based on the number of requests your application receives. However, you should know the data transfer costs associated with requests.
4. Data Transfer: App Runner services’ data transfer costs depend on the data transferred in and out of your service instances. Data transfer costs include both data sent and received by your service instances. Data transferred between services within the same AWS Region is generally free, but data transferred between AWS Regions or across the public internet may incur additional charges.
5. Custom Domains and SSL Certificates: You can associate custom domain names and SSL certificates with your App Runner services. AWS does not charge you for using custom domains and SSL certificates; however, additional costs may be associated with registering domain names or purchasing SSL certificates from third-party providers.
6. AWS App Runner Service Integrations: If you integrate App Runner with other AWS services like Amazon ECR, Aurora, Elasticache, etc., additional charges may apply for using those services.

For up-to-date pricing details, it’s recommended to visit the official AWS App Runner Pricing page (https://aws.amazon.com/apprunner/pricing/).

How Does GCP Charge for Cloud Run

Google Cloud Run is a fully managed serverless platform that enables you to run containerized applications without worrying about infrastructure management. 

1. Compute and Memory: GCP Cloud Run charges are based on the amount of vCPU and memory resources allocated to your services. You can configure the desired vCPU and memory settings, with the cost determined per vCPU and per GB of memory per second. Billing is done in 100 millisecond increments with a minimum of 200 milliseconds.
2. Duration: Cloud Run bills you for the actual time your service instances are running, from when an instance starts processing a request until the request is completed. You are billed for the total duration of all instances of your service in 100-millisecond increments.
3. Requests: GCP Cloud Run charges based on the number of requests your application receives. The cost is determined per million requests, including successful and unsuccessful requests.
4. Data Transfer: Cloud Run services’ data transfer costs depend on the data transferred in and out of your service instances. Data transfer costs include both data sent and received by your service instances. Data transfer between services within the same GCP Region is generally free, but data transferred between GCP Regions or across the public internet may incur additional charges.
5. Custom Domains and SSL Certificates: You can associate custom domain names and SSL certificates with your Cloud Run services. While Google Cloud Run does not charge you for using custom domains and SSL certificates, additional costs may be associated with registering domain names or purchasing SSL certificates from third-party providers.
6. Google Cloud Run Service Integrations: If you choose to integrate Cloud Run with other Google Cloud services, such as Google Cloud Storage, Cloud Pub/Sub, or Cloud Build, additional charges may apply for using those services.

GCP Cloud Run Free Tier

Google Cloud offers an Always Free Tier for Cloud Run, which includes a specific number of vCPU hours, memory, and monthly requests for new users. This can help you test the service before incurring additional charges.

For up-to-date pricing details, it’s recommended to visit the official Google Cloud Run Pricing page (https://cloud.google.com/run/pricing).

Feature	AWS App Runner	GCP Cloud Run
Compute and Memory	Per vCPU and per GB memory/hour	Per vCPU and per GB memory/second
Billing Increment	1 second	100 milliseconds
Duration	Billed for instance duration	Billed for request processing time
Requests	No charge for requests	Charged per million requests
Data Transfer	Charges based on data transfer	Charges based on data transfer
Custom Domains & SSL	No additional charge	No additional charge
Service Integrations	Charges for integrated services	Charges for integrated services

Sample Cost Estimate of 10 Million Monthly Requests in App Runner vs Cloud Run

To provide a price estimate for AWS App Runner and GCP Cloud Run for 10 million requests in a month, let’s consider the same example scenario:

• Average request processing duration: 500 milliseconds
• 1 vCPU and 1 GB of memory allocated per instance

AWS App Runner

Compute and Memory cost for 10 million requests:

• 10 million requests * 0.5 seconds/request = 5,000,000 seconds
• 5,000,000 seconds * ($0.064 / vCPU-hour) * (1 vCPU-hour / 3600 seconds) = $88.89 for vCPU
• 5,000,000 seconds * ($0.007 / GB-hour) * (1 GB-hour / 3600 seconds) = $9.72 for memory

Total AWS App Runner cost: $88.89 (vCPU) + $9.72 (memory) = $98.61

GCP Cloud Run

Compute and Memory cost for 10 million requests, considering the free tier:

• 10 million requests – 2 million free requests = 8 million billed requests
• 8 million requests * 0.5 seconds/request = 4,000,000 seconds

vCPU cost:

• Free tier: 180,000 vCPU-seconds
• Billed usage: 4,000,000 seconds – 180,000 seconds = 3,820,000 vCPU-seconds
• Cost: 3,820,000 vCPU-seconds * $0.00002400 / vCPU-second = $91.68

Memory cost:

• Free tier: 360,000 GiB-seconds
• Billed usage: 4,000,000 seconds – 360,000 seconds = 3,640,000 GiB-seconds
• Cost: 3,640,000 GiB-seconds * $0.00000250 / GiB-second = $9.10

Request cost:

• 8 million billed requests * $0.40 / million requests = $3.20

Total GCP Cloud Run cost: $91.68 (vCPU) + $9.10 (memory) + $3.20 (requests) = $103.98

Winner: App Runner

In this scenario, using AWS App Runner would be slightly more cost-effective for 10 million requests with a total cost of $98.61, compared to GCP Cloud Run’s total cost of $103.98.

However, it’s important to consider that pricing may vary depending on factors like request processing duration, vCPU, and memory allocation, and data transfer costs.

Always refer to the respective pricing pages for detailed cost calculations.

How AWS App Runner Works & GCP Cloud Run Work Under the Hood

App Runner and Google Cloud Run are two solutions from Google that enable developers to rapidly deploy container applications and services in the cloud.

App Runner is a container-based solution that allows for the easy deployment of individual web applications. At the same time, Cloud Run provides a complete platform with integrated storage options like Google Memorystore, Bigtable, and BigQuery. 

How App Runner Works

App Runner orchestrates various AWS services to manage the infrastructure, networking, scaling, and monitoring required for your applications. Here’s an overview of how AWS App Runner works and the services that power it:

1. Source code and containerization: AWS App Runner supports two sources for your application: a container image in a registry like Amazon ECR or a source code repository (e.g., AWS CodeCommit, GitHub, or Bitbucket). App Runner will automatically build the container image using an AWS CodeBuild project if you provide a source code repository.
2. Infrastructure and orchestration: App Runner provisions and manages the necessary infrastructure to run your application. Under the hood, it uses AWS Fargate, a serverless compute engine for containers that removes the need to manage underlying EC2 instances. App Runner automatically handles networking, security, and load balancing using AWS services like Amazon VPC, Application Load Balancer, and AWS Security Groups.
3. Scaling: AWS App Runner employs a custom autoscaling mechanism to adjust the number of instances based on incoming traffic and performance metrics. It monitors your application’s CPU and memory usage and scales the number of running instances up or down as needed.
4. Monitoring and logging: App Runner integrates with Amazon CloudWatch to provide monitoring and logging for your application. CloudWatch collects and processes metrics, logs, and events from your App Runner service, enabling you to monitor performance, set alarms, and troubleshoot issues.
5. Security and access control: AWS App Runner uses AWS Identity and Access Management (IAM) for access control and permissions. You can create IAM roles and policies to define the permissions required for your application to interact with other AWS services. Additionally, App Runner deploys your application in a secure environment using Amazon VPC and AWS Security Groups to isolate and protect your application resources.
6. CI/CD integration: App Runner can be integrated into your CI/CD pipelines, enabling seamless deployment of new application versions when changes are detected in the source code repository. You can configure App Runner to automatically build and deploy new container images whenever code is updated in AWS CodeCommit, GitHub, or Bitbucket repositories.

How Cloud Run Works

Cloud Run leverages various Google Cloud services to manage the infrastructure, networking, scaling, and monitoring required for your applications. Here’s an overview of how GCP Cloud Run works and the services that power it:

1. Containerization: GCP Cloud Run requires you to package your application and its dependencies into a container image using a Dockerfile. You can then push the container image to a registry like Google Container Registry (GCR) or Docker Hub.
2. Infrastructure and orchestration: Cloud Run provisions and manages the necessary infrastructure to run your application. It uses Google Cloud’s serverless compute platform, which abstracts away the underlying infrastructure, removing the need to manage virtual machines or clusters. Cloud Run automatically handles networking, security, and load balancing using Google Cloud services like Google VPC and Serverless VPC Access.
3. Scaling: GCP Cloud Run employs an autoscaling mechanism to adjust the number of instances based on incoming traffic and performance metrics. It monitors your application’s CPU and memory usage and scales the running instances up or down as needed, even scaling down to zero when there’s no traffic.
4. Concurrency: Cloud Run supports concurrency, which allows multiple requests to be processed simultaneously by a single instance. You can configure the maximum number of concurrent requests per instance to optimize resource utilization and cost.
5. Monitoring and logging: Cloud Run integrates with Google Cloud Monitoring and Google Cloud Logging to monitor and log your application. These services collect and process metrics, logs, and events from your Cloud Run service enabling you to monitor performance, set alerts, and troubleshoot issues.
6. Security and access control: GCP Cloud Run uses Google Cloud Identity and Access Management (IAM) for access control and permissions. You can create IAM roles and policies to define the permissions required for your application to interact with other Google Cloud services. Additionally, Cloud Run deploys your application in a secure environment using Google VPC and Serverless VPC Access to isolate and protect your application resources.
7. CI/CD integration: Cloud Run can be integrated into your CI/CD pipelines, enabling seamless deployment of new application versions when changes are detected in the source code repository. You can configure Google Cloud Build or other CI/CD tools to automatically build and deploy new container images whenever code is updated in repositories like GitHub, GitLab, or Bitbucket.

Deploying Container Apps into App Runner vs. Cloud Run

Deploying a web container application on AWS App Runner and GCP Cloud Run is straightforward and efficient, thanks to their serverless and fully managed nature.

I’ll go over some of my notes for the two services.

Deploying App Containers AWS App Runner

AWS App Runner simplifies deploying and scaling containerized applications by managing the infrastructure and orchestration for you.

I like AWS App Runner because it automates your entire deployment pipeline.

Steps to Setup and Deploy a Container App into Cloud Run

1. Create a container image: Package your application and its dependencies into a container image using a Dockerfile. The Dockerfile specifies the base image, application code, runtime, system tools, libraries, and dependencies.
2. Push the container image to a registry: Upload the container image to Amazon Elastic Container Registry (ECR).
3. Create an App Runner service: Set up an App Runner service using the AWS Management Console, AWS CLI, or SDKs. Configure the service by specifying the container image, instance size (vCPU and memory), scaling settings, and environment variables.
4. Configure custom domains and SSL (optional): You can associate custom domain names and SSL certificates with your App Runner service.
5. Monitor and manage the service: Once the service is running, you can monitor its performance and logs using Amazon CloudWatch, and manage its lifecycle using the AWS Management Console, AWS CLI, or SDKs.

Deploying Apps to GCP Cloud Run

GCP Cloud Run also provides a fully managed serverless platform for deploying and scaling containerized applications.

Steps to Setup and Deploy a Container App into Cloud Run

1. Create a container image: Package your application and its dependencies into a container image using a Dockerfile, just as you would with AWS App Runner.
2. Push the container image to a registry: Upload the container image to a container registry, such as Google Container Registry (GCR) or Docker Hub.
3. Create a Cloud Run service: Set up a Cloud Run service using the Google Cloud Console, Cloud SDK (gcloud), or client libraries. Configure the service by specifying the container image, instance size (vCPU and memory), concurrency settings, and environment variables.
4. Configure custom domains and SSL (optional): You can associate custom domain names and SSL certificates with your Cloud Run service.
5. Monitor and manage the service: Once the service is running, you can monitor its performance and logs using Google Cloud Monitoring and Logging and manage its lifecycle using the Google Cloud Console, Cloud SDK (gcloud), or client libraries.

Comparison

AWS App Runner and GCP Cloud Run provide similar capabilities and ease of use when deploying a web container application. Key similarities and differences include:

• Containerization: Both platforms require you to package your application and dependencies into a container image using a Dockerfile.
• Container registry: AWS App Runner supports Amazon ECR and other registries, while GCP Cloud Run supports Google Container Registry and other registries.
• Configuration: Both platforms offer a range of configuration options, including instance size, scaling settings, and environment variables. However, GCP Cloud Run also allows you to set concurrency settings, which controls the maximum number of simultaneous requests per instance.
• Custom domains and SSL: Both platforms support custom domain names and certificates.
• Monitoring and management: Both platforms offer monitoring and logging capabilities through their respective cloud monitoring services (Amazon CloudWatch and Google Cloud Monitoring).

When to Use App Runner vs Cloud Run

AWS App Runner and GCP Cloud Run provide a serverless platform for deploying and scaling containerized applications. 

Here is a guide to help you decide when to use AWS App Runner or GCP Cloud Run.

Factors	AWS App Runner	GCP Cloud Run
Cloud Ecosystem	Already using AWS services and infrastructure	Already using GCP services and infrastructure
Integration	Seamless integration with various AWS services	Seamless integration with various GCP services
CI/CD Capabilities	Automated deployment from Github and ECR	CI/CD using Google Cloud Build or other CI/CD tools
Concurrency Control	Not available	Allows fine-grained control with concurrency settings
API and Compatibility	AWS-specific APIs	Knative-compatible, suitable for multi-platform use
Free Tier	No free tier	180,000 vCPU-seconds, 360,000 GiB-seconds, and 2 million requests per month
Deployment Simplicity	Prioritize simplicity in deployment	More control over instance scaling and resource allocation

Choosing Between AWS App Runner and GCP Cloud Run

AWS App Runner and GCP Cloud Run both provide powerful, serverless platforms for deploying, scaling, and managing containerized applications. They offer similar capabilities with slight variations in configuration options, pricing models, and cloud ecosystems.

When deciding between AWS App Runner and GCP Cloud Run, consider factors such as your existing infrastructure, application requirements, and preferred cloud provider.

If you are already invested in either AWS or GCP, choosing the respective service for seamless integration and consistency might make sense.

Additionally, consider the specific features, such as concurrency control and deployment simplicity, to better align with your application’s needs.

In terms of pricing, GCP Cloud Run offers a generous free tier, which might be more appealing for small-scale or low-traffic applications. However, always assess your application’s workload and usage patterns to estimate costs accurately on both platforms.

Ultimately, AWS App Runner and GCP Cloud Run deliver efficient and easy-to-use solutions for deploying containerized applications. 

Cloud Hosting Article Series

This article is part of our series on cloud hosting for your web applications. Check out the following articles to dig further into your options.

• Best Cloud PHP Hosting Providers for Apps Compared
• Hosting PHP Website Apps in AWS Cloud
• Hosting PHP Web Apps in Azure Cloud
• Hosting PHP Web Apps in Google Cloud
• Is Azure Easy to Learn?
• What is AWS App Runner
• PHP in AWS Lambda
• App Runner vs. Elastic Beanstalk
• App Runner vs Google Cloud Run
• AWS App Runner vs. Azure App Service
• Serverless in Azure
• Azure App Service vs Elastic Beanstalk
• Azure App Service vs Google Cloud Run
• Google Cloud Run vs Heroku
• Host & Deploy a Laravel App to AWS Elastic Beanstalk