A Brief introduction to Amazon ECS, Dockerization of Spring boot application, CI/CD and notifications using Slack. This PPT also explains how CI/CD pipeline can be build using Jenkins. And

1. DOCKER ON ECS
- Deepak Kumar

2. Prerequisite:
● Basic Understanding of Docker
● We used spring boot as jar for the tutorial
● Removed System dependent paths
● Dockerized Spring boot application - docker-maven-plugin
● Permissions / Memory usage etc. Defined in Dockerfile.
● Containerized spring boot application . for details refer this link

3. ● New Relic in base level image
● New Relic Integration - for dev and prod
● Access logs on console
● Git tag in images - git-commit-id-plugin - dirty/non-dirty
● Support for multiple ECRs
● Distributed Tracing in New Relic - enable in newrelic.yml
● Generic image version -CI/CD
● Multiple ECR support -PROD/ DEV
Image Level Changes?

4. Agenda
● Dockerization of Microservice - Pending Parts
● Container Orchestration on AWS
● Service Discovery
● Service Load Balancing
● Logging
● Auto Scaling
● Storage
● Notifications
● Image Level Changes
● Continuous Integration & Delivery
● Live Deployment
● Comparison with kubernetes

5. ● Technologies which allow us to:
○ Create multi-node container clusters
○ Manage multiple containers easily
○ Automate container lifecycle
Examples: ECS, kubernetes,docker swarm, mesos etc.
What is Container Orchestration?

6. Why Do We Need Container Orchestration?
● Horizontal scalability across - multiple hosts
● Grouping of related containers
● Automatic failure detection and recovery
● Seamless updates

8. ● Docker container orchestration service by AWS
● Operates on top of EC2
● Built-in private Docker registry (ECR)
● Uses AWS architecture internally.
ECS - EC2 Container Service

9. Why Use ECS?
● Free private registry -ECR
● Built-in security
○ Assign IAM Roles to Docker containers
○ Docker registry authentication using IAM
● Native integration with ELB and Auto Scaling
● Full support from AWS
● Built on AWS architecture

10. ECS Components
● Cluster - a group of container instances
● Container Instance - an EC2 instance that hosts containers
● Task - a set of related Docker containers
● Task Definition - a template which defines a task
● Service - a group of identical tasks

11. Cluster
● A group of container instances
● Supports multiple Availability Zones
● Bound to a specific AWS region

12. Container Instance - EC2
instance● An EC2 instance running Docker with an ECS agent
● May be deployed from an official AWS AMI
● May be deployed using an Auto Scaling group
● Can be of any EC2 instance type / size

13. Task
● A set of one or more related containers
● Deployed to a cluster
● Containers within a task are placed on the same host

14. Task Definition
1. Serves as a “template” for tasks
2. Allows to define most of the Docker features accessible via
docker run (image, volumes, networking, env vars...)
3. Allows to define CPU and memory limits for the tasks
4. Can assign an IAM role to a task
5. Configurable using JSON Configurable- User

15. Service
● An abstraction above tasks
● Deploys multiple “copies” from a task definition
● Maintains the desired number of running tasks
● May bind to a load balancer

17. ECS - Summary & Best Practices
● Use ECS to easily manage containerized apps on AWS
● Deploy ECS instances in multiple AZs for high
availability
● Choose an instance type that is appropriate for your
apps
● Centralized logging is recommended

18. Question:
How does a client know where to
send a request when a service
runs on multiple nodes?

19. ● Cloud environments change all the time
● IP addresses and ports are assigned dynamically
● Auto Scaling launches and terminates instances
● Some instances might be under maintenance or upgrade
Service Discovery?
A mechanism which allows a client to find out the network location of a
service automatically
Need?

20. Service
Discovery

21. Service Discovery Using a Load Balancer

22. Auto Scaling in ECS
AutoScaling : Automatically adjusting the capacity of the
application’s infrastructure based on load.
● Service Auto Scaling - adjusting the number of running ECS
tasks for the given service
● Cluster Auto Scaling - adjusting the number of EC2
instances in the cluster
Note : Both types rely on CloudWatch metrics

23. ECS Resource Allocation
● Each container gets a portion of the CPU and memory of the
host on which it runs
● This capacity is reserved for each container
● The remaining capacity is shared among all containers
● Resource allocation is configured in the task definition

24. CPU Resource Allocation
● Each ECS instance has 1024 CPU units per CPU core
● A container gets a relative amount of CPU cycles based on the
configured units
● The configured units are reserved for the container
● CPU allocation is only relevant when there is competition on
host resources
● The remaining CPU capacity may be used by other containers

25. Memory Resource Allocation
● Soft limit - the amount is reserved for the container
but may be exceeded if capacity is available
● Hard limit - container is killed when trying to
exceed the reserved amount
● Must use one limit type but may use both together

26. Service Auto Scaling
● Adding more containers to handle an increasing load
● Configured inside ECS
● Use CPU and memory usage to trigger scaling events
● May use custom CloudWatch metrics too
● “Do we have enough compute power?”

27. Cluster Auto Scaling
● Adding more instances to accommodate an increasing
number of containers
● Configured via EC2 Auto Scaling
● Use CPU and memory reservation to trigger scaling events
● “Do we have room for more containers?”

29. Auto Scaling - Summary & Best Practices
● Configure both Service Auto Scaling and Cluster Auto Scaling
● Scale services based on utilization
● Scale clusters based on reservation
● Service Auto Scaling is much faster than Cluster Auto Scaling
● Leave some spare capacity on each host
○ Allows the cluster to scale in time
Ref: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cloudwatch-
metrics.html

30. Static Port
Problem

31. Persist data among containers on
multiple hosts?
Storage

32. Notifications:

34. Current Logging:
● Saw: Group logging
○ Install Saw https://github.com/TylerBrock/saw
○ saw watch hotelier_logs --expand
● Dokr
○ pip install dokr https://pypi.org/project/dokr/
○ Per Task logging
■ Install ecs-cli first
■ dokr log
■ dokr deploy {cluster_name} {service_name} {tag}
■ Dokr
● ECS Monitor
○ Install ecs-monitor https://github.com/tombolaltd/ecs-
monitor

35. ● New Relic in base level image
● New Relic Integration - for dev and prod
● Access logs on console
● Git tag in images - git-commit-id-plugin - dirty/non-dirty
● Support for multiple ECRs
● Distributed Tracing in New Relic - enable in newrelic.yml
● Generic image version -CI/CD
● Multiple ECR support -PROD/ DEV
Image Level Changes?

36. CI/CD + Jenkins + ECS

37. CI/CD with ECS - Workflow
1. Checkout source from version control to Jenkins server
2. Login into ECS (use dokr plugin)
3. Clean older images
4. Build a new Docker image
5. Push the new image to ECR
6. Update the task definition & service
7. ECS updates the containers on the cluster
8. Send Deployment Notifications

38. CI/CD with ECS
● ECS can use Docker images from ECR or any other registry
● You can specify which images to deploy using task definitions
● ECS allows you to perform rolling updates to running services
● Updates can be triggered automatically using the ECS API
● Jenkins can be used to automate the process

40. Failure Case

41. Success Case

42. Tagging Strategy
● It is important to implement a proper tagging strategy when
using Docker for CI/CD
● Common tag values:
○ Application version (“1.3”)
○ CI/CD build number (“136”)
○ Git SHA value (“c31dxes”)
● Using one of the above will make sure your tags are unique

43. CI/CD - Summary & Best Practices
● Build new Docker images and push them to ECR using
jenkins only
● Use Jenkins to trigger rolling updates on ECS
● Implement a proper tagging strategy
● Don’t Use “latest” Tag when deploying on Production.

44. ECS Monitor : plugin link

45. Tools Used
● Jenkins
● Slack
● Cloudwatch for monitoring
● dokr (pypi) - Must for prod deployment and logs
● ecs-cli (aws)
● ecs-deploy (pypi)
● ecs-monitor (React)
● New Relic

46. Questions?