Build Infrastructure
That Scales Without Limits

Docker Compose lets you define and manage multi-container application stacks (e.g. Web API + PostgreSQL Database + Redis Cache) in a single configuration file named docker-compose.yml. With one command (docker compose up), all services launch connected on a shared private network.

version: '3.8'
services:
  api:
    build: .
    ports:
      - "5000:5000"
    environment:
      - DB_HOST=db
      - REDIS_HOST=cache
    depends_on:
      - db
      - cache

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: teachcloud
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data

  cache:
    image: redis:7-alpine

volumes:
  pgdata:

Click button to start multi-container stack simulation.

Understanding core Docker internals empowers you to build lightning-fast container pipelines and manage persistent data cleanly.

Click button to evaluate layer caching efficiency.

Once built, share container images publicly on Docker Hub or privately in enterprise registries like Amazon ECR (Elastic Container Registry).

Click button to trigger registry authentication and layer push simulation.

📘 Docker: Definitions, Multi-OS Setup & Architecture Guide

📌 Core Definition: What is Docker?

Docker is an open-source containerization platform that packages applications and all their dependencies (code, runtime, libraries, environment variables) into isolated, portable units called containers. Unlike traditional Virtual Machines (VMs) that virtualize full guest hardware and OS kernels, Docker containers share the host operating system kernel, making them start in milliseconds, consume minimal memory, and execute identically across developer laptops, CI/CD pipelines, and cloud servers.

• Dockerfile: A text manifest defining base images, environment variables, working directories, dependency installations, and startup commands.
• Multi-Stage Builds: A technique to separate build environments (with compilers) from lean runtime containers to minimize image size and security attack surface.
• Docker Compose: A tool for defining and running multi-container applications (e.g., Web API + Database + Redis) via a single declarative docker-compose.yml file.

📐 System Design & Live Network Flow

[Developer / App Code] ──▶ (CLI / REST API: unix:///var/run/docker.sock)
       │
       ▼
[Docker Engine Daemon (dockerd)] ──▶ (Build Layers / Namespace Isolation)
       │
       ▼ (Virtual Ethernet Bridge: docker0)
[Live Network & Port Forwarding NAT]
       ├── Port Forwarding: Host :5000 ➔ Container :5000
       └── Inter-Container DNS: http://db:5432 & http://redis:6379

1. App Layer: Developer writes Dockerfile & docker-compose.yml defining container ports and runtime scripts.
2. Server Daemon: dockerd executes build layers in isolated Linux namespaces (PID, NET, IPC) and mounts Overlay2 filesystems.
3. Live Network: Docker creates a virtual bridge (docker0) with iptables NAT rules forwarding host traffic to container endpoints.

1. Enable WSL 2 (Windows Subsystem for Linux) in PowerShell (Admin):
   wsl --install
2. Download & run the official Docker Desktop for Windows Installer.
3. Or install via Winget package manager:
   winget install Docker.DockerDesktop
4. Restart your PC and verify WSL2 backend integration in Docker Desktop Settings.

1. Install using Homebrew:
   brew install --cask docker
2. Or download the DMG installer:
   • Apple Silicon (M-Series): Select "Mac with Apple Chip" DMG
   • Intel Mac: Select "Mac with Intel Chip" DMG
3. Launch Docker.app from Applications and follow the setup wizard.

1. Ubuntu / Debian / Linux Mint (apt):

2. Fedora / RHEL / CentOS / Rocky Linux (dnf / yum):

3. Arch Linux / Manjaro (pacman):

4. Alpine Linux (apk):

Services expose your Pod endpoints to internal and external networks, while Ingress controllers handle HTTP/HTTPS domain routing and TLS termination.

apiVersion: v1
kind: Service
metadata:
  name: teachcloud-svc
spec:
  type: LoadBalancer
  selector:
    app: backend
  ports:
    - port: 80
      targetPort: 5000
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: teachcloud-ingress
spec:
  rules:
  - host: api.teachcloud.io
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: teachcloud-svc
            port:
              number: 80

Click "▶️ Run Service Routing Sandbox" to compute endpoints.

Decouple environment configuration and sensitive credentials from container images, while organizing resources across environment Namespaces (dev, staging, prod).

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
  namespace: production
data:
  LOG_LEVEL: "INFO"
  MAX_WORKERS: "4"
---
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  DB_PASSWORD: c2VjcmV0cGFzc3dvcmQ= # Base64 encoded
---
# Health Probes in Container Spec:
livenessProbe:
  httpGet: { path: /healthz, port: 5000 }
  initialDelaySeconds: 5
readinessProbe:
  httpGet: { path: /ready, port: 5000 }

Click "▶️ Run Kubelet Probe Sandbox" to simulate probes.

Package Kubernetes applications into versioned Helm Charts and dynamically scale Pod count (HPA) or CPU/memory resources (VPA) based on real-time application load.

Click button to trigger high CPU load and monitor HPA replica expansion (2 -> 7 Pods).

📘 Kubernetes (K8s): Definitions, Multi-OS Setup & Architecture Guide

📌 Core Definition: What is Kubernetes?

The industry standard for container orchestration. Deploy, scale, and manage containerised workloads with self-healing, rolling updates, and service discovery built in.

• Pods, Deployments & ReplicaSets: Core workload objects that declare target states, manage container life-cycles, and ensure zero-downtime updates.
• Services, Ingress & Load Balancers: Abstractions for routing internal/external network traffic and handling domain HTTPS termination.
• ConfigMaps, Secrets & Namespaces: Environment variable decoupling, base64 secret storage, and multi-tenant resource isolation.
• Helm Charts & Auto-scaling (HPA/VPA): Reusable package management and dynamic workload scaling based on real-time metrics.

📐 System Design & Live Network Flow

[Developer / CI/CD] ──▶ (kubectl POST /api/v1/namespaces/default/deployments)
       │
       ▼
[K8s Control Plane (kube-apiserver)] ◄──► [etcd Store]
       │
       ▼ (Reconciliation Loop & Scheduling)
[Worker Node (Kubelet Agent)] ──▶ [containerd Engine]
       │
       ▼ (CNI Network Overlay: Calico / Flannel)
[Live Network Routing: Ingress ➔ Service ClusterIP ➔ Pod IP (10.244.x.x:5000)]

1. App Spec: Developer applies declarative YAML manifests via kubectl.
2. Control Plane: kube-apiserver validates state, saves to etcd, and schedules Pods across worker nodes.
3. Live Network: CNI network plugins assign flat Pod IPs, while kube-proxy load-balances HTTP requests to healthy Pods.

1. Install kubectl CLI via Winget in PowerShell:
   winget install Kubernetes.kubectl
2. Install local cluster engine Minikube:
   winget install Kubernetes.minikube && winget install Helm.Helm

1. Install kubectl, Minikube & Helm using Homebrew:
   brew install kubectl minikube helm
2. Start local Kubernetes cluster:
   minikube start --driver=docker

1. Ubuntu / Debian (apt & snap):

2. Fedora / RHEL / CentOS (dnf):

3. Arch Linux / Manjaro (pacman):

4. Alpine Linux (apk):

Automate deployments to Amazon EKS Kubernetes clusters using AWS CodePipeline and CodeBuild.

version: 0.2
phases:
  post_build:
    commands:
      - aws eks update-kubeconfig --name teachcloud-eks-prod --region eu-west-1
      - kubectl set image deployment/api-server api=123456789012.dkr.ecr.eu-west-1.amazonaws.com/teachcloud-backend:7f8a9b0 -n production

Click button to trigger deployment.

Perform zero-downtime production releases with automated rollback triggered by CloudWatch error alarm threshold breaches.

import time
def shift_traffic_alb(target_group_green, target_group_blue, weight_green=100):
    print(f"Shifting router traffic: Green ({weight_green}%), Blue ({100-weight_green}%)")
    if check_cloudwatch_alarms():
        print("⚠️ CloudWatch 5xx alarm breached! Rolling back to Blue (v1.0)...")
        return "ROLLED_BACK"
    return "PROMOTED_TO_GREEN"

Click button to evaluate traffic switching.

Amazon Web Services — the world's most comprehensive cloud platform. Provision resizable virtual servers (EC2) inside isolated virtual private networks (VPC) protected by stateful firewalls (Security Groups).

import boto3
ec2 = boto3.client('ec2', region_name='eu-west-1')
response = ec2.run_instances(
    ImageId='ami-0c55b159cbfafe1f0', InstanceType='t3.micro',
    MinCount=1, MaxCount=1,
    SecurityGroupIds=['sg-0123456789abcdef0'], SubnetId='subnet-0987654321fedcba0'
)
print("EC2 Instance Launched:", response['Instances'][0]['InstanceId'])

Click button to simulate EC2 instance provisioning.

Store static assets in Amazon S3, secure requests with IAM policies, and accelerate downloads globally via CloudFront CDN.

import boto3
s3, cloudfront = boto3.client('s3'), boto3.client('cloudfront')
s3.upload_file('app.js', 'my-cdn-bucket', 'static/app.js')
invalidation = cloudfront.create_invalidation(
    DistributionId='ED1234567890',
    InvalidationBatch={'Paths': {'Quantity': 1, 'Items': ['/static/*']}, 'CallerReference': 'v1.2'}
)
print("CDN Cache Invalidated:", invalidation['Invalidation']['Id'])

Click button to trigger S3 & CloudFront CDN simulation.

Connect to managed SQL databases (RDS PostgreSQL), fast NoSQL tables (DynamoDB), and in-memory Redis caching (ElastiCache).

import boto3, redis
table = boto3.resource('dynamodb').Table('users')
table.put_item(Item={'user_id': 'usr_102', 'email': 'user@teachcloud.io'})
cache = redis.Redis(host='prod-cache.abc.0001.euw1.cache.amazonaws.com', port=6379)
cache.setex('session:usr_102', 3600, 'active_jwt_token')
print("DynamoDB Put & Redis Cache SET Complete")

Click button to evaluate database operations.

Write event-driven serverless functions with AWS Lambda and API Gateway HTTP endpoints scaling down to zero.

import json
def lambda_handler(event, context):
    user = event.get('queryStringParameters', {}).get('name', 'Developer')
    return {
        'statusCode': 200,
        'body': json.dumps({'message': f"Hello {user}! AWS Lambda execution successful."})
    }

Click button to execute Lambda function handler.

Deploy Docker containers to serverless Amazon ECS Fargate or managed Amazon EKS Kubernetes.

Click button to simulate ECS/EKS container deployment.

📘 Amazon Web Services (AWS): Definitions, Multi-OS Setup & Architecture Guide

📌 Core Definition: What is AWS Cloud Platform?

Amazon Web Services — the world's most comprehensive cloud platform. From EC2 and S3 to Lambda, RDS, and EKS, we guide you through the services Python developers use most.

• EC2, VPC & Security Groups: Virtual compute instances, isolated subnets, and stateful security group firewalls.
• S3, IAM & CloudFront CDN: Object storage buckets, fine-grained access policies, and global CDN edge distribution.
• RDS, DynamoDB & ElastiCache: Managed relational SQL, high-throughput NoSQL, and in-memory Redis caching.
• Lambda & Serverless Patterns: Event-driven serverless computing with API Gateway HTTP integration.
• ECS / EKS Container Workloads & Registries: Amazon ECR container registries, serverless Fargate tasks, and Amazon EKS Kubernetes clusters.
• Blue/Green Deployments & CI/CD Pipelines: GitHub Actions, AWS CodePipeline, and zero-downtime release rollbacks.

📐 System Design & Live Network Flow

[Developer / App Code] ──▶ (boto3 SDK / AWS CLI v2 / OIDC IAM Roles)
       │
       ├── 1. EC2 / VPC ➔ Virtual Compute Instances & Private Network Subnets
       ├── 2. S3 & CloudFront ➔ Object Storage & Global CDN Edge Locations
       ├── 3. RDS / DynamoDB / Redis ➔ Relational SQL, NoSQL & Memory Caching
       ├── 4. Lambda & API Gateway ➔ Serverless HTTP Function Events
       ├── 5. ECS / EKS ➔ Docker Fargate Container Tasks & Managed Kubernetes
       └── 6. CI/CD Pipelines ➔ GitHub Actions ECR Push & Blue/Green Rollouts

1. Authentication: Keyless OIDC IAM roles or AWS access keys authorize API calls securely.
2. Resource Allocation: AWS cloud services execute compute tasks, stream logs to CloudWatch, and auto-scale load.
3. CI/CD Delivery: GitHub Actions & CodePipeline trigger automated tests and zero-downtime Blue/Green releases.

1. Install AWS CLI v2 via Winget in PowerShell:
   winget install Amazon.AWSCLI

1. Install via Homebrew:
   brew install awscli

Parameterize infrastructure with input variables and extract database endpoints via outputs.

Click button to evaluate module.

Manage remote S3 backend state with DynamoDB lock tables to prevent concurrent infrastructure drift.

Click button to simulate plan.

📘 Terraform: Definitions, Multi-OS Setup & Architecture Guide

📌 Core Definition: What is Terraform?

Terraform is an open-source Infrastructure as Code (IaC) tool created by HashiCorp. It allows engineers to define, provision, version, and destroy cloud infrastructure (VPCs, EC2 instances, S3 buckets, RDS databases, K8s clusters) declaratively using HashiCorp Configuration Language (HCL).

• HCL (HashiCorp Configuration Language): Human-readable, structured configuration language for declaring cloud resources.
• State File (`terraform.tfstate`): A JSON file mapping declared HCL code to real-world cloud resources, enabling change tracking and plan generation.
• Plan & Apply: `terraform plan` previews changes before execution, while `terraform apply` executes actions idempotently.
• Remote State & Locking: Storing state in Amazon S3 with DynamoDB table locks to prevent concurrent team execution drift.

📐 System Design & Live Network Flow

[Developer / HCL Config] ──▶ (terraform apply execution)
       │
       ▼
[Terraform Core Engine]
       ├── Acquire DynamoDB State Lock over HTTPS
       └── Fetch tfstate from Amazon S3 Bucket
       │
       ▼ (HTTPS REST API / AWS Signature V4 Auth)
[AWS Cloud APIs (ec2.amazonaws.com / vpc endpoints)]
       ├── POST /CreateVpc ➔ Returns vpc-0a1b2c3d
       └── Update Remote S3 State File & Release DynamoDB Lock

1. App Code: Developer writes HCL code declaring target VPC, subnet, and EC2 instances.
2. State & Engine: Terraform Core downloads remote state from S3 and locks DynamoDB to prevent concurrent writes.
3. Live Network: Provider plugins send signed REST HTTPS calls to cloud provider APIs to provision live infrastructure.

1. Install via Winget in PowerShell:
   winget install Hashicorp.Terraform
2. Or via Chocolatey:
   choco install terraform

1. Install using official HashiCorp Homebrew tap:
   brew tap hashicorp/tap && brew install hashicorp/tap/terraform

1. Ubuntu / Debian (apt):

2. Fedora / RHEL / CentOS (dnf / yum):

3. Arch Linux (pacman):

4. Alpine Linux (apk):

Set up threshold alerts for high CPU utilization and HTTP 5xx error rate spikes.

Click button to test alert engine.

Format application logs as JSON payloads for ELK/Loki aggregation and create status health endpoints.

Click button to execute logger.

📘 Monitoring & Observability: Definitions, Multi-OS Setup & Architecture Guide

📌 Core Definition: What is Cloud Observability?

Cloud Observability is the practice of inferring the internal state and health of distributed systems based on external output signals. Built on the Three Pillars of Observability (Metrics, Logs, and Traces), observability allows platform engineers to proactively detect anomalies, alert on SLO breaches, and diagnose performance bottlenecks.

• Prometheus: An open-source, pull-based time-series database (TSDB) and monitoring system that scrapes HTTP /metrics endpoints.
• Grafana: A visualization and alerting dashboard platform that queries metrics from Prometheus, CloudWatch, and Elasticsearch.
• Structured JSON Logging: Formatting log messages as machine-readable JSON objects for central indexing in ELK (Elasticsearch, Logstash, Kibana) or Grafana Loki.
• Health Probes: HTTP endpoints (e.g., GET /health) returning component health statuses (database, cache, memory) for load balancer and orchestrator readiness checks.

📐 System Design & Live Network Flow

[Microservice App Code] ──▶ Exposes GET /metrics & stdout JSON logs
       │
       ▼ (HTTP Scraping Pull - Interval: 15s)
[Prometheus Time-Series Database (TSDB)]
       │
       ▼ (PromQL Query API Endpoint)
[Grafana Dashboards & Alert Engine]
       │
       ▼ (Webhook HTTPS POST / TLS)
[Live Alerting Network (Slack / PagerDuty / Email Alertmanager)]

1. App Metrics: Microservice exposes Prometheus text metrics at http://app:5000/metrics.
2. Collector Daemon: Prometheus scrapes endpoints every 15s and stores metric points in TSDB block files.
3. Live Network: Grafana queries Prometheus via PromQL and triggers HTTPS Webhook alerts if error rate thresholds cross limits.

1. Recommended: Run Prometheus & Grafana via Docker Desktop:
   docker run -d -p 9090:9090 --name=prometheus prom/prometheus
   docker run -d -p 3000:3000 --name=grafana grafana/grafana
2. Or install via Winget in PowerShell:
   winget install Prometheus.Prometheus && winget install GrafanaLabs.Grafana

1. Install using Homebrew:
   brew install prometheus grafana
2. Start background services:
   brew services start prometheus && brew services start grafana

1. Ubuntu / Debian (apt):

2. Fedora / RHEL / CentOS (dnf):

3. Arch Linux (pacman):

4. Alpine Linux (apk):