AWS ECS: Container Service

# Install AWS CLI
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Konfigurasi AWS CLI dengan credentials
aws configure
# AWS Access Key ID: YOUR_ACCESS_KEY
# AWS Secret Access Key: YOUR_SECRET_KEY
# Default region name: ap-southeast-1
# Default output format: json

# Verifikasi instalasi
aws sts get-caller-identity
aws ecs list-clusters

# Membuat ECS cluster dengan Fargate capacity provider
aws ecs create-cluster \
  --cluster-name my-fargate-cluster \
  --capacity-providers FARGATE FARGATE_SPOT \
  --default-capacity-provider-strategy \
    capacityProvider=FARGATE,weight=1 \
    capacityProvider=FARGATE_SPOT,weight=1

# Lihat cluster yang sudah dibuat
aws ecs describe-clusters --clusters my-fargate-cluster

# List semua cluster
aws ecs list-clusters

{
  "family": "web-app",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::123456789:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::123456789:role/ecsTaskRole",
  "containerDefinitions": [
    {
      "name": "web",
      "image": "123456789.dkr.ecr.ap-southeast-1.amazonaws.com/web-app:latest",
      "portMappings": [
        {
          "containerPort": 3000,
          "hostPort": 3000,
          "protocol": "tcp"
        }
      ],
      "environment": [
        { "name": "NODE_ENV", "value": "production" },
        { "name": "DB_HOST", "value": "mydb.cluster-xxx.rds.amazonaws.com" }
      ],
      "secrets": [
        {
          "name": "DB_PASSWORD",
          "valueFrom": "arn:aws:secretsmanager:ap-southeast-1:123456789:secret:db-password"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/web-app",
          "awslogs-region": "ap-southeast-1",
          "awslogs-stream-prefix": "ecs"
        }
      },
      "healthCheck": {
        "command": ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"],
        "interval": 30,
        "timeout": 5,
        "retries": 3,
        "startPeriod": 60
      }
    }
  ]
}

{
  "family": "web-with-sidecar",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "containerDefinitions": [
    {
      "name": "app",
      "image": "my-app:latest",
      "portMappings": [{ "containerPort": 3000 }],
      "dependsOn": [
        { "containerName": "envoy", "condition": "START" }
      ]
    },
    {
      "name": "envoy",
      "image": "envoyproxy/envoy:latest",
      "portMappings": [
        { "containerPort": 8080 },
        { "containerPort": 9901 }
      ],
      "essential": true
    },
    {
      "name": "log-router",
      "image": "amazon/aws-for-fluent-bit:latest",
      "essential": true,
      "firelensConfiguration": {
        "type": "fluentbit"
      }
    }
  ]
}

# Register task definition dari file JSON
aws ecs register-task-definition --cli-input-json file://task-def.json

# Register task definition baru (new revision)
aws ecs register-task-definition --cli-input-json file://task-def-v2.json

# List semua revisi task definition
aws ecs list-task-definitions --family-prefix web-app --sort DESC

# Deskripsi task definition tertentu
aws ecs describe-task-definition --task-definition web-app:3

# Membuat ECS service dengan Fargate
aws ecs create-service \
  --cluster my-fargate-cluster \
  --service-name web-service \
  --task-definition web-app:1 \
  --desired-count 2 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={
    subnets=[subnet-0abc123,subnet-0def456],
    securityGroups=[sg-0123abc],
    assignPublicIp=ENABLED
  }" \
  --load-balancers "targetGroupArn=arn:aws:elasticloadbalancing:...,containerName=web,containerPort=3000"

# Update service (misalnya scale ke 4 task)
aws ecs update-service \
  --cluster my-fargate-cluster \
  --service-name web-service \
  --desired-count 4

# Update service dengan task definition baru (rolling deployment)
aws ecs update-service \
  --cluster my-fargate-cluster \
  --service-name web-service \
  --task-definition web-app:2 \
  --force-new-deployment

# Lihat service events (berguna untuk debugging)
aws ecs describe-services \
  --cluster my-fargate-cluster \
  --services web-service \
  --query 'services[0].events[:10]'

# List task yang berjalan di service
aws ecs list-tasks \
  --cluster my-fargate-cluster \
  --service-name web-service

# Lihat detail task
aws ecs describe-tasks \
  --cluster my-fargate-cluster \
  --tasks <task-arn>

# Lihat log container di CloudWatch
aws logs get-log-events \
  --log-group-name /ecs/web-app \
  --log-stream-name ecs/web/<task-id>

# Membuat cluster dengan EC2 capacity provider
aws ecs create-cluster \
  --cluster-name my-ec2-cluster \
  --capacity-providers EC2_MY_ASG \
  --default-capacity-provider-strategy \
    capacityProvider=EC2_MY_ASG,weight=1

# Mengaitkan Auto Scaling Group dengan capacity provider
aws ecs put-cluster-capacity-providers \
  --cluster my-ec2-cluster \
  --capacity-providers FARGATE FARGATE_SPOT EC2_MY_ASG \
  --default-capacity-provider-strategy \
    capacityProvider=FARGATE,weight=1 \
    capacityProvider=FARGATE_SPOT,weight=2

# Menghapus cluster
aws ecs delete-cluster --cluster my-fargate-cluster

# Mengaktifkan Container Insights untuk monitoring
aws ecs update-cluster-settings \
  --cluster my-fargate-cluster \
  --settings name=containerInsights,value=enabled

# Membuat Application Load Balancer
aws elbv2 create-load-balancer \
  --name my-ecs-alb \
  --subnets subnet-0abc123 subnet-0def456 \
  --security-groups sg-0123abc \
  --scheme internet-facing \
  --type application

# Membuat target group untuk ECS service
aws elbv2 create-target-group \
  --name my-ecs-tg \
  --protocol HTTP \
  --port 3000 \
  --target-type ip \
  --vpc-id vpc-0abc123 \
  --health-check-path /health \
  --health-check-interval-seconds 30 \
  --healthy-threshold-count 2 \
  --unhealthy-threshold-count 3

# Membuat listener
aws elbv2 create-listener \
  --load-balancer-arn <alb-arn> \
  --protocol HTTP \
  --port 80 \
  --default-actions Type=forward,TargetGroupArn=<tg-arn>

# Route /api/* ke API service
aws elbv2 create-rule \
  --listener-arn <listener-arn> \
  --priority 10 \
  --conditions Field=path-pattern,Values='/api/*' \
  --actions Type=forward,TargetGroupArn=<api-tg-arn>

# Route /auth/* ke Auth service
aws elbv2 create-rule \
  --listener-arn <listener-arn> \
  --priority 20 \
  --conditions Field=path-pattern,Values='/auth/*' \
  --actions Type=forward,TargetGroupArn=<auth-tg-arn>

# Membuat private DNS namespace
aws servicediscovery create-private-dns-namespace \
  --name my-internal.local \
  --vpc vpc-0abc123

# Membuat service dengan service discovery
aws ecs create-service \
  --cluster my-cluster \
  --service-name api-service \
  --task-definition api:1 \
  --desired-count 2 \
  --service-registries "registryArn=<sd-service-arn>,containerName=api,containerPort=3000"

# Sekarang service bisa diakses via DNS:
# api-service.my-internal.local

# Register scalable target
aws application-autoscaling register-scalable-target \
  --service-namespace ecs \
  --scalable-dimension ecs:service:DesiredCount \
  --resource-id service/my-cluster/web-service \
  --min-capacity 2 \
  --max-capacity 20

# Target tracking: jaga CPU rata-rata di 60%
aws application-autoscaling put-scaling-policy \
  --service-namespace ecs \
  --scalable-dimension ecs:service:DesiredCount \
  --resource-id service/my-cluster/web-service \
  --policy-name cpu-target-tracking \
  --policy-type TargetTrackingScaling \
  --target-tracking-scaling-policy-configuration '{
    "TargetValue": 60.0,
    "PredefinedMetricSpecification": {
      "PredefinedMetricType": "ECSServiceAverageCPUUtilization"
    },
    "ScaleInCooldown": 300,
    "ScaleOutCooldown": 60
  }'

# Step scaling: scale out berdasarkan custom metric
aws application-autoscaling put-scaling-policy \
  --service-namespace ecs \
  --scalable-dimension ecs:service:DesiredCount \
  --resource-id service/my-cluster/web-service \
  --policy-name request-count-scaling \
  --policy-type StepScaling \
  --step-scaling-policy-configuration '{
    "AdjustmentType": "ChangeInCapacity",
    "StepAdjustments": [
      { "MetricIntervalLowerBound": 0, "MetricIntervalUpperBound": 500, "ScalingAdjustment": 1 },
      { "MetricIntervalLowerBound": 500, "MetricIntervalUpperBound": 1000, "ScalingAdjustment": 2 },
      { "MetricIntervalLowerBound": 1000, "ScalingAdjustment": 4 }
    ],
    "Cooldown": 60
  }'

# Rolling update deployment
aws ecs create-service \
  --cluster my-cluster \
  --service-name web-service \
  --task-definition web-app:2 \
  --desired-count 4 \
  --deployment-configuration '{
    "maximumPercent": 200,
    "minimumHealthyPercent": 50
  }'

# minimumHealthyPercent 50 = minimal 2 task sehat saat deploy
# maximumPercent 200 = maksimal 8 task saat deploy (4 lama + 4 baru)

# Blue/Green membutuhkan AWS CodeDeploy
# Konfigurasi di appspec.yml untuk ECS
version: 0.0
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "arn:aws:ecs:region:account:task-definition/web-app:2"
        LoadBalancerInfo:
          ContainerName: "web"
          ContainerPort: 3000

# Deployment controller di service
aws ecs create-service \
  --cluster my-cluster \
  --service-name web-service \
  --task-definition web-app:1 \
  --desired-count 2 \
  --deployment-controller type=CODE_DEPLOY \
  --load-balancers "targetGroupArn=...,containerName=web,containerPort=3000"