⚙️ Compute Services - Provider Comparison

Introduction

Compute services are the core of cloud applications. Each provider offers multiple options from managed servers to fully serverless, each with different trade-offs in control, management, and cost.

Quick Comparison Table

Virtual Machines

AWS EC2

# Launch an EC2 instance
aws ec2 run-instances   --image-id ami-0c55b159cbfafe1f0   --instance-type t3.micro   --key-name my-key

• **Best for:** Full control, legacy applications

• **Cost:** $0.012/hour (t3.micro)

• **Scaling:** Auto Scaling Groups

GCP Compute Engine

# Create a VM instance
gcloud compute instances create my-instance   --image-family=ubuntu-2004-lts   --image-project=ubuntu-os-cloud   --machine-type=e2-micro

• **Best for:** Fast deployment, sustained use discounts

• **Cost:** $0.008/hour (e2-micro)

• **Scaling:** Instance Groups

Azure Virtual Machines

# Create a VM
az vm create   --resource-group myResourceGroup   --name myVM   --image UbuntuLTS   --admin-username azureuser

• **Best for:** Hybrid scenarios, Windows workloads

• **Cost:** $0.013/hour (B1s)

• **Scaling:** Virtual Machine Scale Sets

Managed Containers

AWS ECS

• No Kubernetes learning curve

• Integrated with AWS services

• Pay only for compute resources

• Best for: Simple containerized applications

GCP Cloud Run

// Deploy Node.js app to Cloud Run
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello from Cloud Run!');
});

const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

• Fully serverless (no infrastructure management)

• Auto-scaling out of the box

• Pay per request

• Best for: APIs, event-driven workloads

Azure Container Instances

• Quickest way to run containers

• No VM management required

• Good for: Batch jobs, short-lived tasks

Kubernetes (Orchestration)

AWS EKS

• Fully managed Kubernetes

• Integrates with AWS Load Balancers

• Pay for master + worker nodes

• Best for: Complex microservices

GCP GKE

• Google manages the control plane

• Integrated cluster upgrade

• Automatic node repair

• Best for: Kubernetes-native deployments

Azure AKS

• Managed Kubernetes service

• Integrated with Azure DevOps

• No master node cost

• Best for: Enterprise Kubernetes

Serverless Functions

AWS Lambda

exports.handler = async (event) => {
  console.log('Event:', event);
  return {
    statusCode: 200,
    body: JSON.stringify('Hello from Lambda!')
  };
};

GCP Cloud Functions

exports.helloWorld = (req, res) => {
  res.send('Hello from Cloud Functions!');
};

Azure Functions

module.exports = async function (context, req) {
  context.res = {
    body: 'Hello from Azure Functions!'
  };
};

Firebase Cloud Functions

const functions = require('firebase-functions');

exports.hello = functions.https.onRequest((req, res) => {
  res.send('Hello from Firebase!');
});

Platform Services

AWS Elastic Beanstalk

• Deploys web applications automatically

• Handles load balancing, scaling, monitoring

• Best for: Traditional web apps

GCP App Engine

• Fully managed application platform

• Auto-scales based on traffic

• Free tier available

• Best for: Web applications, APIs

Azure App Service

• Deploy apps without managing infrastructure

• Supports multiple languages and frameworks

• Built-in CI/CD with Azure DevOps

• Best for: Web apps, APIs, mobile backends

Pricing Comparison (Per Month)

Choosing the Right Service

Choose Virtual Machines if:

• You need full OS control

• Running legacy applications

• Complex software requirements

Choose Managed Containers if:

• Building modern containerized apps

• Want some infrastructure control

• Using Docker/container workflows

Choose Kubernetes if:

• Running complex microservices

• Need advanced orchestration

• Team has Kubernetes expertise

Choose Serverless if:

• Event-driven workloads

• Variable traffic patterns

• Want minimal operations overhead

Migration Paths

VM to Containers: Extract application into Docker image

Containers to Serverless: Refactor into functions (if possible)

VM to Platform Service: Repackage app for target platform

Key Takeaways

• **AWS EC2** = Most control, most popular

• **GCP Cloud Run** = Most serverless-friendly

• **Azure App Service** = Best for .NET/Windows

• **Firebase Functions** = Tightly integrated with Firebase

• **Pricing varies:** GCP often cheapest, AWS most flexible

Decision Tree

1. Need Kubernetes? → Use EKS, GKE, or AKS

2. Need serverless? → Use Lambda, Cloud Functions, or Firebase

3. Need simple containers? → Use ECS, Cloud Run, or Container Instances

4. Need managed platform? → Use Elastic Beanstalk, App Engine, or App Service

5. Need full control? → Use VMs (EC2, Compute Engine, VMs)

Next Steps

• Compare specific workloads on each platform

• Test cost calculators for your use case

• Review provider's getting started guides

• Experiment with free tiers

Recommendation: Start with the managed service (Cloud Run, App Service, Elastic Beanstalk) and move to VMs/Kubernetes only if needed.