Day 22: Docker in Cloud Environments

calendar_today July 13, 2025 schedule 12 min read

Learning Objectives: By the end of this lesson, you will be able to:

Deploy Docker containers to major cloud platforms (AWS, Azure, GCP)

Understand cloud-native container services and their benefits

Implement container orchestration using cloud-managed services

Configure auto-scaling and load balancing for cloud-based containers

Manage container storage, networking, and security in cloud environments

1. Welcome and Introduction (5 minutes)

Icebreaker Activity

“Your startup has grown from a single server in your garage to serving millions of users worldwide. You need to scale instantly during traffic spikes, deploy across multiple regions, and ensure 99.9% uptime. How would you leverage cloud platforms to run your containerized applications at global scale without managing the underlying infrastructure? Today we’ll explore how Docker integrates with cloud services.”

Lesson Overview

Duration: 90 minutes
Prerequisites: Docker fundamentals, basic cloud computing concepts, container orchestration basics
Materials Needed: Cloud account (AWS/Azure/GCP), Docker Desktop, kubectl, cloud CLI tools

2. Learning Objectives and Session Outline (5 minutes)

What We’ll Cover Today:

Cloud Container Services - Understanding managed container platforms
Container Deployment - Deploying to AWS ECS, Azure Container Instances, GCP Cloud Run
Kubernetes in the Cloud - Managed Kubernetes services
Cloud-Native Patterns - Serverless containers and microservices architecture
Monitoring and Operations - Cloud-native observability and management

Success Criteria:

By the end of this session, you should be able to deploy containerized applications to multiple cloud platforms, understand the trade-offs between different services, and implement cloud-native patterns for scalable, resilient applications.

3. Foundation Knowledge (15-20 minutes)

Core Concepts

Cloud Container Service Models

Cloud platforms offer different levels of container management:

Infrastructure as a Service (IaaS): You manage containers on virtual machines
Container as a Service (CaaS): Managed container orchestration platforms
Function as a Service (FaaS): Serverless container execution
Platform as a Service (PaaS): Full application platform with container support

Real-World Analogy: Think of cloud container services like different types of restaurants. IaaS is like renting a kitchen (you cook everything yourself), CaaS is like a meal kit service (ingredients and instructions provided), FaaS is like ordering takeout (just specify what you want), and PaaS is like a full-service restaurant (you just pick from the menu).

Why This Matters: Different service models offer different levels of control, complexity, and cost. Choosing the right model depends on your application requirements, team expertise, and business needs.

Cloud-Native Architecture Principles

Cloud-native applications are designed specifically for cloud environments:

Microservices: Decomposed into small, independent services
Containers: Packaged for consistency and portability
Dynamic Orchestration: Automatically managed by orchestration platforms
DevOps: Integrated development and operations practices

Multi-Cloud and Hybrid Strategies

Multi-Cloud: Using multiple cloud providers for different services
Hybrid Cloud: Combining on-premises and cloud infrastructure
Cloud Bursting: Scaling to cloud during peak demand
Edge Computing: Running containers closer to end users

Key Terminology

Container Registry: Cloud-hosted repository for container images
Load Balancer: Distributes traffic across multiple container instances
Auto Scaling: Automatically adjusts resources based on demand
Service Mesh: Infrastructure layer for service-to-service communication
Serverless Containers: Containers that run without managing servers

4. Detailed Explanation and Examples (25-30 minutes)

Understanding Cloud Container Services

Each major cloud provider offers different container services optimized for various use cases:

AWS Container Services

Amazon ECS: Fully managed container orchestration service
Amazon EKS: Managed Kubernetes service
AWS Fargate: Serverless compute for containers
AWS Lambda: Serverless functions (can use container images)
Amazon ECR: Fully managed container registry

Azure Container Services

Azure Container Instances (ACI): Simple container hosting
Azure Kubernetes Service (AKS): Managed Kubernetes
Azure Container Apps: Serverless container platform
Azure Service Fabric: Microservices platform
Azure Container Registry (ACR): Private container registry

Google Cloud Container Services

Google Cloud Run: Serverless container platform
Google Kubernetes Engine (GKE): Managed Kubernetes
Compute Engine: Virtual machines for container hosting
Container Registry: Private Docker registry
Anthos: Hybrid and multi-cloud platform

Deployment Patterns

Serverless Container Pattern

Serverless containers automatically scale to zero and handle traffic spikes:

# Cloud Run service configuration
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-app
  annotations:
    run.googleapis.com/ingress: all
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/minScale: "0"
        autoscaling.knative.dev/maxScale: "100"
        run.googleapis.com/cpu-throttling: "false"
    spec:
      containerConcurrency: 80
      containers:
      - image: gcr.io/my-project/my-app:latest
        ports:
        - containerPort: 8080
        env:
        - name: NODE_ENV
          value: production
        resources:
          limits:
            cpu: 1000m
            memory: 2Gi

Managed Kubernetes Pattern

Kubernetes provides powerful orchestration capabilities:

# Kubernetes deployment for cloud-managed cluster
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: myregistry.azurecr.io/web-app:v1.0.0
        ports:
        - containerPort: 80
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 500m
            memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: web-app-service
spec:
  selector:
    app: web-app
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

Cloud Storage and Networking

Persistent Storage Options

Cloud platforms provide various storage solutions for containers:

Block Storage: AWS EBS, Azure Disk, GCP Persistent Disk
File Storage: AWS EFS, Azure Files, GCP Filestore
Object Storage: AWS S3, Azure Blob, GCP Cloud Storage
Database Services: Managed databases that containers can access

Networking Considerations

Virtual Private Cloud (VPC): Isolated network environments
Load Balancers: Application, Network, and Gateway load balancers
CDN Integration: Content delivery networks for global distribution
Service Discovery: DNS-based service location and health checking

Common Misconceptions

Misconception: Cloud containers are always more expensive than on-premises Reality: Total cost of ownership often favors cloud due to reduced operational overhead
Misconception: Serverless containers can’t handle stateful applications Reality: With proper design patterns, many stateful applications can benefit from serverless

5. Live Coding Demonstration (20-25 minutes)

Example 1: Deploying to AWS ECS with Fargate

# docker-compose.yml for AWS ECS
version: '3.8'

services:
  web:
    image: nginx:alpine
    ports:
      - "80:80"
    logging:
      driver: awslogs
      options:
        awslogs-group: /ecs/my-app
        awslogs-region: us-west-2
        awslogs-stream-prefix: web
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

  api:
    build: ./api
    environment:
      - NODE_ENV=production
      - DATABASE_URL=${DATABASE_URL}
    logging:
      driver: awslogs
      options:
        awslogs-group: /ecs/my-app
        awslogs-region: us-west-2
        awslogs-stream-prefix: api
    deploy:
      resources:
        limits:
          memory: 1024M
        reservations:
          memory: 512M

networks:
  default:
    external: true
    name: my-app-network

ECS Task Definition:

{
  "family": "my-app",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::account:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::account:role/ecsTaskRole",
  "containerDefinitions": [
    {
      "name": "web",
      "image": "my-account.dkr.ecr.us-west-2.amazonaws.com/my-app:latest",
      "portMappings": [
        {
          "containerPort": 80,
          "protocol": "tcp"
        }
      ],
      "essential": true,
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/my-app",
          "awslogs-region": "us-west-2",
          "awslogs-stream-prefix": "web"
        }
      },
      "healthCheck": {
        "command": ["CMD-SHELL", "curl -f http://localhost/ || exit 1"],
        "interval": 30,
        "timeout": 5,
        "retries": 3
      }
    }
  ]
}

Deployment Commands:

# Build and push to ECR
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin my-account.dkr.ecr.us-west-2.amazonaws.com

docker build -t my-app .
docker tag my-app:latest my-account.dkr.ecr.us-west-2.amazonaws.com/my-app:latest
docker push my-account.dkr.ecr.us-west-2.amazonaws.com/my-app:latest

# Create ECS cluster and service
aws ecs create-cluster --cluster-name my-app-cluster

aws ecs register-task-definition --cli-input-json file://task-definition.json

aws ecs create-service \
  --cluster my-app-cluster \
  --service-name my-app-service \
  --task-definition my-app:1 \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[subnet-12345678],securityGroups=[sg-87654321],assignPublicIp=ENABLED}"

Example 2: Azure Container Instances Deployment

# azure-container-group.yml
apiVersion: 2019-12-01
location: eastus
name: my-app-group
properties:
  containers:
  - name: web-frontend
    properties:
      image: myregistry.azurecr.io/frontend:latest
      resources:
        requests:
          cpu: 1
          memoryInGb: 1
      ports:
      - port: 80
        protocol: TCP
      environmentVariables:
      - name: API_URL
        value: http://localhost:3000
      - name: NODE_ENV
        value: production

  - name: api-backend
    properties:
      image: myregistry.azurecr.io/backend:latest
      resources:
        requests:
          cpu: 0.5
          memoryInGb: 0.5
      ports:
      - port: 3000
        protocol: TCP
      environmentVariables:
      - name: DATABASE_URL
        secureValue: postgresql://user:pass@db.postgres.database.azure.com:5432/mydb

  osType: Linux
  ipAddress:
    type: Public
    ports:
    - protocol: TCP
      port: 80
    dnsNameLabel: my-app-demo

  imageRegistryCredentials:
  - server: myregistry.azurecr.io
    username: myregistry
    password: myregistrypassword

  restartPolicy: Always

Deployment Script:

#!/bin/bash

# Azure CLI deployment
az group create --name my-app-rg --location eastus

az container create \
  --resource-group my-app-rg \
  --file azure-container-group.yml

# Monitor deployment
az container show \
  --resource-group my-app-rg \
  --name my-app-group \
  --query "{FQDN:ipAddress.fqdn,ProvisioningState:provisioningState}" \
  --out table

# View logs
az container logs \
  --resource-group my-app-rg \
  --name my-app-group \
  --container-name web-frontend

Example 3: Google Cloud Run Deployment

# Optimized Dockerfile for Cloud Run
FROM node:16-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:16-alpine AS runtime
RUN addgroup -g 1001 -S nodejs && adduser -S nextjs -u 1001 -G nodejs

WORKDIR /app
COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
COPY --chown=nextjs:nodejs . .

USER nextjs

# Cloud Run expects the container to listen on $PORT
ENV PORT=8080
EXPOSE 8080

CMD ["npm", "start"]

Cloud Run Service Configuration:

# service.yaml
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-app
  annotations:
    run.googleapis.com/ingress: all
    run.googleapis.com/ingress-status: all
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/minScale: "1"
        autoscaling.knative.dev/maxScale: "100"
        run.googleapis.com/cloudsql-instances: my-project:us-central1:my-db
        run.googleapis.com/cpu-throttling: "false"
    spec:
      containerConcurrency: 80
      timeoutSeconds: 300
      containers:
      - image: gcr.io/my-project/my-app:latest
        ports:
        - name: http1
          containerPort: 8080
        env:
        - name: NODE_ENV
          value: production
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              key: url
              name: database-secret
        resources:
          limits:
            cpu: 1000m
            memory: 2Gi
          requests:
            cpu: 100m
            memory: 256Mi

Deployment Commands:

# Build and deploy to Cloud Run
gcloud builds submit --tag gcr.io/my-project/my-app

gcloud run deploy my-app \
  --image gcr.io/my-project/my-app:latest \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated \
  --set-env-vars NODE_ENV=production \
  --set-secrets DATABASE_URL=database-secret:latest \
  --max-instances 100 \
  --memory 2Gi \
  --cpu 1

# Custom domain setup
gcloud run domain-mappings create \
  --service my-app \
  --domain my-app.example.com \
  --region us-central1

Example 4: Multi-Cloud Deployment Strategy

# terraform/main.tf - Infrastructure as Code
provider "aws" {
  region = "us-west-2"
}

provider "azurerm" {
  features {}
}

provider "google" {
  project = var.gcp_project_id
  region  = "us-central1"
}

# AWS ECS Cluster
resource "aws_ecs_cluster" "main" {
  name = "my-app-cluster"
  
  setting {
    name  = "containerInsights"
    value = "enabled"
  }
}

# Azure Container Group
resource "azurerm_container_group" "main" {
  name                = "my-app-aci"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
  ip_address_type     = "public"
  os_type             = "Linux"

  container {
    name   = "my-app"
    image  = "myregistry.azurecr.io/my-app:latest"
    cpu    = "0.5"
    memory = "1.5"

    ports {
      port     = 80
      protocol = "TCP"
    }
  }
}

# Google Cloud Run Service
resource "google_cloud_run_service" "main" {
  name     = "my-app"
  location = "us-central1"

  template {
    spec {
      containers {
        image = "gcr.io/${var.gcp_project_id}/my-app:latest"
        
        env {
          name  = "NODE_ENV"
          value = "production"
        }
      }
    }
  }

  traffic {
    percent         = 100
    latest_revision = true
  }
}

6. Hands-On Practice (30-40 minutes)

Exercise 1: Deploy to Multiple Cloud Platforms (20 minutes)

Objective: Deploy the same containerized application to AWS, Azure, and GCP

Instructions:

Create a simple web application with health checks
Build and push the image to each cloud’s container registry
Deploy to AWS ECS, Azure Container Instances, and Google Cloud Run
Configure load balancing and auto-scaling on each platform
Compare the deployment experience and capabilities

Starter Application (app.js):

const express = require('express');
const app = express();
const port = process.env.PORT || 8080;

app.get('/', (req, res) => {
  res.json({
    message: 'Hello from the cloud!',
    platform: process.env.CLOUD_PLATFORM || 'unknown',
    instance: process.env.HOSTNAME || 'local',
    timestamp: new Date().toISOString()
  });
});

app.get('/health', (req, res) => {
  res.status(200).json({ status: 'healthy' });
});

app.listen(port, () => {
  console.log(`Server running on port ${port}`);
});

Exercise 2: Implement Cloud-Native Monitoring (15 minutes)

Objective: Set up comprehensive monitoring across cloud platforms

Requirements:

Centralized logging for all deployments
Metrics collection and alerting
Distributed tracing across services
Cost monitoring and optimization

Hints:

Use cloud-native monitoring services (CloudWatch, Azure Monitor, Cloud Monitoring)
Implement structured logging in your applications
Set up alerts for key performance indicators

Exercise 3: Design a Multi-Region Architecture (5 minutes)

Objective: Create a globally distributed application architecture

Challenge: Design an architecture that:

Serves users from multiple geographic regions
Implements disaster recovery across regions
Optimizes for performance and cost
Handles data consistency across regions

Extension Ideas:

Implement edge computing with containers
Design for compliance with data residency requirements
Create automated failover mechanisms

7. Common Pitfalls and Troubleshooting (10 minutes)

Frequent Cloud Deployment Issues

Problem: Container startup failures in cloud environments Cause: Missing environment variables, incorrect port configuration, or resource limits Solution: Test containers locally with cloud-like configurations and implement proper health checks
Problem: Unexpected cloud costs from over-provisioned resources Cause: Lack of resource optimization and monitoring Solution: Implement cost monitoring, right-size resources, and use auto-scaling
Problem: Network connectivity issues between cloud services Cause: Incorrect security group/firewall rules or VPC configuration Solution: Review network security policies and test connectivity systematically

Cloud-Specific Debugging

# AWS ECS debugging
aws ecs describe-services --cluster my-cluster --services my-service
aws ecs describe-tasks --cluster my-cluster --tasks task-id
aws logs get-log-events --log-group-name /ecs/my-app --log-stream-name stream-name

# Azure Container Instances debugging
az container show --resource-group my-rg --name my-container
az container logs --resource-group my-rg --name my-container
az container exec --resource-group my-rg --name my-container --exec-command "/bin/bash"

# Google Cloud Run debugging
gcloud run services describe my-service --region us-central1
gcloud logging read "resource.type=cloud_run_revision AND resource.labels.service_name=my-service"
gcloud run services update my-service --port 8080 --region us-central1

Performance Optimization

Cold Start Optimization: Minimize container startup time for serverless platforms
Resource Right-Sizing: Monitor and adjust CPU/memory allocations
Caching Strategies: Implement appropriate caching at multiple levels
Network Optimization: Use CDNs and regional deployments effectively

8. Best Practices and Professional Tips (5 minutes)

Cloud Migration Strategy

Lift and Shift: Move existing applications with minimal changes
Re-platforming: Optimize applications for cloud container services
Re-architecting: Redesign applications as cloud-native microservices
Hybrid Approach: Gradually migrate while maintaining on-premises components

Cost Optimization

Resource Monitoring: Continuously monitor and optimize resource usage
Reserved Instances: Use reserved capacity for predictable workloads
Spot Instances: Leverage spot/preemptible instances for non-critical workloads
Auto-scaling: Implement intelligent scaling based on actual demand

Security Best Practices

Identity and Access Management: Use cloud IAM services for fine-grained access control
Network Security: Implement defense-in-depth networking strategies
Secrets Management: Use cloud-native secret management services
Compliance: Understand and implement required compliance controls

9. Summary and Review (5 minutes)

Key Takeaways

Service Selection: Choose the right cloud container service based on your requirements
Multi-Cloud Strategy: Consider benefits and challenges of multi-cloud deployments
Cloud-Native Patterns: Leverage cloud-specific features for scalability and resilience
Cost Optimization: Monitor and optimize costs continuously

Quick Review Questions

What are the key differences between AWS ECS, Azure Container Instances, and Google Cloud Run?
How would you design a disaster recovery strategy for cloud-deployed containers?
What factors should influence your choice between serverless containers and managed Kubernetes?

For Instructors

Teaching Tips

Use hands-on cloud console demonstrations alongside command-line examples
Emphasize cost considerations and monitoring throughout the lesson
Show real-world architectural patterns and trade-offs
Demonstrate both successful deployments and troubleshooting scenarios

Assessment Ideas

Deploy applications to multiple cloud platforms and compare experiences
Design cloud architectures for given business requirements
Troubleshoot cloud deployment issues using platform-specific tools

Adaptation Notes

Beginners: Focus on single cloud platform deployment before covering multi-cloud
Advanced: Cover advanced topics like service mesh, edge computing, and compliance
Budget Constraints: Use free tier resources and emphasize cost monitoring
Platform Preference: Adapt examples to the primary cloud platform used in your organization