DEV Community: Pragnesh Patel

Day 15: Best Practices, Troubleshooting, and Next Steps in AWS ECS

Pragnesh Patel — Mon, 25 Aug 2025 04:35:37 +0000

We've reached the end! Recap from Day 14 and the series.

Best Practices

Use Fargate for simplicity.
Implement least privilege IAM.
Enable logging/monitoring.
Use blue/green deployments (new in 2025 for safer releases).
Cost: Monitor with Cost Explorer; use Spot for non-prod.

Category	Tip
Security	Scan images, use private ECR.
Performance	Right-size CPU/memory.
Cost	Auto-scale, delete unused.

Troubleshooting

Permissions: Check IAM errors.
Networking: Verify SGs, subnets.
Logs: Use CloudWatch for container crashes.
Common: "No Container Instances" – add capacity.

Next Steps

Explore ECS Anywhere for on-prem.
Try Kubernetes with EKS.
Build a full app: Add DB with RDS.

Cheat Sheet:

Cluster: aws ecs create-cluster
Task: aws ecs register-task-definition
Service: aws ecs create-service

Thanks for following! Links to all days: Day 1, ..., Day 14.

What's your ECS project? Comment below!

Day 14: Advanced ECS Features: Secrets Management, Volumes, and Fargate Spot

Pragnesh Patel — Sun, 24 Aug 2025 03:44:56 +0000

Building on Day 13, add pro features.

Secrets Management

Use AWS Secrets Manager: Create secret, reference in task def:

"secrets": [
  { "name": "MY_SECRET", "valueFrom": "arn:aws:secretsmanager:region:account:secret:my-secret" }
]

Access in code: process.env.MY_SECRET

Volumes

For persistence, use EFS: Create file system, mount in task:

"volumes": [
  { "name": "efs-vol", "efsVolumeConfiguration": { "fileSystemId": "fs-id" } }
],
"mountPoints": [{ "sourceVolume": "efs-vol", "containerPath": "/data" }]

Fargate Spot

For cost savings: In service, use capacity provider strategy with Fargate Spot.

Pros: Up to 70% cheaper; Cons: Interruptible.

Today’s Takeaway

Advanced and optimized!

What’s Next?
In Day 15, we’ll wrap up with best practices.

Day 13: CI/CD for ECS: Integrating with AWS CodePipeline or GitHub Actions

Pragnesh Patel — Sat, 23 Aug 2025 03:14:09 +0000

From Day 12, automate deployments.

Option 1: GitHub Actions (Free Tier Friendly)

In repo .github/workflows/deploy.yml:

name: Deploy to ECS
on: [push]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Configure AWS
      uses: aws-actions/configure-aws-credentials@v4
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: us-west-2
    - name: Login to ECR
      id: login-ecr
      uses: aws-actions/amazon-ecr-login@v2
    - name: Build, tag, push
      env:
        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
        ECR_REPOSITORY: my-app-repo
        IMAGE_TAG: latest
      run: |
        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
        docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
    - name: Update ECS
      run: |
        aws ecs update-service --cluster my-cluster --service my-service --force-new-deployment

Add secrets in GitHub.

Option 2: CodePipeline

Console: CodePipeline > Create > Source: GitHub, Build: CodeBuild (Docker build spec), Deploy: ECS.

Today’s Takeaway

Automated pipelines!

What’s Next?
In Day 14, we’ll explore advanced ECS features.

Day 12: Monitoring and Logging with CloudWatch and ECS Insights

Pragnesh Patel — Fri, 22 Aug 2025 04:02:34 +0000

Continuing Day 11, monitor health.

Enable CloudWatch Logs

In task def, add:

"logConfiguration": {
  "logDriver": "awslogs",
  "options": {
    "awslogs-group": "/ecs/my-task",
    "awslogs-region": "us-west-2",
    "awslogs-stream-prefix": "ecs"
  }
}

Create log group first.

Metrics and Dashboards

Console: CloudWatch > Metrics > ECS.

Create dashboard for CPU/Memory.

ECS Container Insights

Enable in ECS console for advanced metrics.

Alerts: CloudWatch > Alarms > Create (e.g., CPU > 80%).

Query logs: fields @timestamp, @message | filter @message like /error/

Today’s Takeaway

Monitored and logged!

What’s Next?
In Day 13, we’ll set up CI/CD.

Day 11: Scaling ECS: Auto Scaling and Capacity Providers

Pragnesh Patel — Thu, 21 Aug 2025 04:05:53 +0000

From Day 10, scale dynamically.

Service Auto Scaling

Console: Service > Update > Scaling > Set min/max/desired.

Policy: Target tracking on CPU (e.g., 70%).

CLI example:

aws application-autoscaling register-scalable-target --service-namespace ecs --resource-id service/my-cluster/my-service --scalable-dimension ecs:service:DesiredCount --min-capacity 1 --max-capacity 10

aws application-autoscaling put-scaling-policy --policy-name cpu70 --service-namespace ecs --resource-id service/my-cluster/my-service --scalable-dimension ecs:service:DesiredCount --policy-type TargetTrackingScaling --target-tracking-scaling-policy-configuration '{ "TargetValue": 70, "PredefinedMetricSpecification": { "PredefinedMetricType": "ECSServiceAverageCPUUtilization" } }'

Capacity Providers (EC2)

For EC2 launch type: Create ASG, then capacity provider.

For Fargate, auto-handled.

Test: Use tools like Apache Bench to load test.

Today’s Takeaway

Scalable services!

What’s Next?
In Day 12, we’ll monitor with CloudWatch.

Day 10: Networking in ECS: VPCs, Security Groups, and Load Balancers

Pragnesh Patel — Wed, 20 Aug 2025 04:06:49 +0000

After Day 9, let's secure and balance traffic.

Step 1: VPC Setup

If not default, create VPC: Console > VPC > Create VPC > Resources: VPC and more.

Subnets: Public for internet access.

Step 2: Security Groups

Create SG: Allow inbound TCP 3000 from anywhere (for testing).

Attach to service.

Step 3: Application Load Balancer (ALB)

Create ALB: EC2 > Load Balancers > Create > ALB.

Target group: IP targets, port 3000.

In service creation/update, add load balancer.

Test: ALB DNS name.

Today’s Takeaway

Networked and load-balanced!

What’s Next?
In Day 11, we’ll scale ECS services.

Day 9: ECS Services: Deploying and Managing Tasks

Pragnesh Patel — Tue, 19 Aug 2025 04:03:27 +0000

From Day 8, tasks are one-off. Services run tasks continuously.

Creating a Service

Console: ECS > Clusters > my-cluster > Create service > Fargate, task def: my-task, desired tasks: 1.

CLI:

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

Access via public IP (from task details).

Managing Services

Update: aws ecs update-service --cluster my-cluster --service my-service --desired-count 2

Rollback: Via console revisions.

Delete: aws ecs delete-service --cluster my-cluster --service my-service --force

Today’s Takeaway

Services deployed!

What’s Next?
In Day 10, we’ll explore networking.

Day 8: ECS Task Definitions: Defining Your Containers

Pragnesh Patel — Mon, 18 Aug 2025 04:42:21 +0000

Building on Day 7, today: Task definitions—the blueprint for containers.

Key Parameters

Container definitions: Image, ports, CPU/memory.
Volumes, networking, etc.

Step 1: Create Task Definition

JSON example for our app:

{
  "family": "my-task",
  "containerDefinitions": [
    {
      "name": "my-container",
      "image": "<account-id>.dkr.ecr.us-west-2.amazonaws.com/my-app-repo:latest",
      "cpu": 256,
      "memory": 512,
      "portMappings": [{ "containerPort": 3000, "hostPort": 3000 }],
      "essential": true
    }
  ],
  "requiresCompatibilities": ["FARGATE"],
  "networkMode": "awsvpc",
  "cpu": "256",
  "memory": "512"
}

Step 2: Run a Task

Console: ECS > Clusters > my-cluster > Tasks > Run new task > Select definition.

CLI:

aws ecs run-task --cluster my-cluster --task-definition my-task --launch-type FARGATE --network-configuration "awsvpcConfiguration={subnets=[subnet-id],securityGroups=[sg-id],assignPublicIp=ENABLED}"

Check logs in console.

Today’s Takeaway

Tasks defined and running!

What’s Next?
In Day 9, we’ll deploy ECS services.

Day 7: ECS Fundamentals: Clusters and Launch Types

Pragnesh Patel — Sun, 17 Aug 2025 03:41:50 +0000

After Day 6, images are in ECR. Today: ECS clusters and launch types.

What is an ECS Cluster?

A logical grouping of tasks/services. Infrastructure-agnostic.

Launch Types Comparison

Aspect	Fargate	EC2
Management	Serverless, AWS handles servers	You manage EC2 instances
Pricing	Pay per vCPU/memory	Pay for instances + reservations
Use Case	Simple, quick setups	Custom hardware, cost control
Scaling	Auto via service	Auto Scaling groups

As of 2025, Fargate offers better isolation; EC2 for flexibility.

Step 1: Create a Cluster

Console: ECS > Clusters > Create > Fargate (networking only).

CLI:

aws ecs create-cluster --cluster-name my-cluster

Delete after to avoid costs: aws ecs delete-cluster --cluster my-cluster

Today’s Takeaway

Clusters ready! Next, task definitions.

What’s Next?
In Day 8, we’ll define ECS tasks.

Day 6: Integrating Docker with AWS ECR: Build, Tag, and Push Images

Pragnesh Patel — Sat, 16 Aug 2025 03:18:43 +0000

From Day 5, we have an ECR repo. Today, build on Day 3's app: build, tag, and push to ECR.

Step 1: Authenticate Docker to ECR

Get login command:

aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin <account-id>.dkr.ecr.us-west-2.amazonaws.com

Step 2: Build and Tag the Image

In my-app dir:

docker build -t my-app .
docker tag my-app:latest <account-id>.dkr.ecr.us-west-2.amazonaws.com/my-app-repo:latest

Step 3: Push to ECR

docker push <account-id>.dkr.ecr.us-west-2.amazonaws.com/my-app-repo:latest

Verify in ECR console.

Troubleshooting: Check IAM permissions (AmazonEC2ContainerRegistryFullAccess).

Automation Tip

Use a script:

#!/bin/bash
REPO_URI=<account-id>.dkr.ecr.us-west-2.amazonaws.com/my-app-repo
docker build -t my-app .
docker tag my-app:latest $REPO_URI:latest
aws ecr get-login-password | docker login --username AWS --password-stdin $REPO_URI
docker push $REPO_URI:latest

Today’s Takeaway

Your image is in the cloud! Ready for ECS.

What’s Next?
In Day 7, we’ll explore ECS fundamentals.

Day 5: AWS ECR: Creating and Managing Container Registries

Pragnesh Patel — Thu, 14 Aug 2025 14:09:40 +0000

Continuing from Day 4, today we explore Amazon Elastic Container Registry (ECR), AWS's managed Docker registry. We'll create a repo and manage it.

Why ECR?

ECR stores Docker images securely, integrates with ECS, and handles authentication automatically.

Step 1: Create an ECR Repository

Via Console:

Search for ECR in AWS Console.
Click "Create repository."
Choose private/public, name it (e.g., my-app-repo).
Create.

Via CLI:

aws ecr create-repository --repository-name my-app-repo --region us-west-2

Step 2: Managing Repositories

Public vs. Private: Private for internal use; public for sharing.
Lifecycle Policies: To clean old images, add policy via console (e.g., expire untagged images after 30 days).

{
  "rules": [
    {
      "rulePriority": 1,
      "description": "Expire untagged images",
      "selection": {
        "tagStatus": "untagged",
        "countType": "sinceImagePushed",
        "countUnit": "days",
        "countNumber": 30
      },
      "action": { "type": "expire" }
    }
  ]
}

Verify: aws ecr describe-repositories

Today’s Takeaway

ECR is set up! Tomorrow, push images to it.

What’s Next?
In Day 6, we’ll integrate Docker with ECR.

Day 4: Introduction to AWS: Account Setup and IAM Basics

Pragnesh Patel — Wed, 13 Aug 2025 14:19:24 +0000

Back for more? In Day 3, we built Docker images locally. Today, we shift to AWS: setting up an account and understanding IAM for secure access. This is crucial for ECS.

Step 1: Sign Up for AWS

Go to aws.amazon.com and click "Create an AWS Account."
Enter email, password, and account name.
Provide billing info (Free Tier eligible for 12 months).
Verify identity via phone/email.
Choose support plan (Basic is free).

Enable MFA on root user for security.

Step 2: AWS Regions and Billing

AWS has global regions—choose one close to you (e.g., us-east-1). Set up billing alerts: Navigate to Billing > Billing preferences > Alert preferences.

Step 3: IAM Basics

IAM (Identity and Access Management) controls access.

In AWS Console, search for IAM.
Create a user: Users > Create user > Attach policies (e.g., AdministratorAccess for learning).
Create a access key ID and secret (for CLI). Select User > Security Credentials > Create access key.

Install AWS CLI: curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" (or equivalent), unzip, install.

Configure: aws configure with keys, region (e.g., us-west-2), output (json).

Best practice: Use least privilege—create roles/policies as needed.

Today’s Takeaway

Your AWS account is ready, with secure IAM setup. Tomorrow, ECR for image storage.

What’s Next?
In Day 5, we’ll create and manage an AWS ECR repository.