Amazon ECS Deploy Script -- for public use

1) build_and_push.sh

#!/usr/bin/env bash

set -e

status() {
  echo -e "[DEPLOY]: ${1}"
}

# Set the version to the branch name by default
ver_tag=${CIRCLE_BRANCH}
sha_tag=$(echo $CIRCLE_SHA1 | cut -c -8)

# This is a build destined for release
if [ -n "$CIRCLE_TAG" ]; then
  ver_tag=${CIRCLE_TAG}
fi

# Build Docker Registry namespace
namespace="hustle/${CIRCLE_PROJECT_REPONAME}"

# A string reference to the new image
sha_image="${ECR_REPO}/${namespace}:git-${sha_tag}"
ver_image="${ECR_REPO}/${namespace}:${ver_tag}"
echo ${sha_image}
echo ${ver_image}

configure_aws_cli() {
  aws configure set default.region us-east-1
  aws configure set default.output json
  eval $(aws ecr get-login --no-include-email --region us-east-1)
}

build() {
  docker build -f Dockerfile.prod -t backend:prod .
}

tag() {
  docker tag backend:prod ${sha_image}
  docker tag backend:prod ${ver_image}
}

push() {
  docker push ${sha_image}
  docker push ${ver_image}
}

configure_aws_cli
build
tag
push

exit 0

1.1) deploy.sh

#!/usr/bin/env bash

# Hustle ECS Deploy Script v1.0.0
# Requires docker + jq + aws-cli

set -e

usage() {
  echo "Usage: $0 -c <cluster name> -s <services>"
}

status() {
  echo -e "[DEPLOY]: ${1}"
}

while getopts ":c:s:" o; do
  case "${o}" in
    c)
      cluster=${OPTARG}
      ;;
    s)
      services=${OPTARG}
      ;;
    *)
      usage
      ;;
  esac
done

if [ -z "${cluster}" ]; then
    usage;
    exit -1;
fi

if [ -z "${services}" ]; then
    usage;
    exit -1;
fi

# Split services by comma into array
servicesArray=(${services//,/ })

# Set the version to the branch name by default
tag=$(echo $CIRCLE_SHA1 | cut -c -8)

# Build Docker Registry namespace
ecr_repo=${ECR_REPO}
namespace="hustle/${CIRCLE_PROJECT_REPONAME}"

# A string reference to the new image
image="${ecr_repo}/${namespace}:git-${tag}"

configure_aws_cli() {
  aws configure set default.region us-east-1
  aws configure set default.output json
  eval $(aws ecr get-login --region us-east-1)
}

get_task_arn() {
  # get ARN of task running on the service
  active_task_arn=$(
    aws ecs describe-services \
      --cluster ${cluster} \
      --services ${service} \
      --output text \
      --query 'services[?serviceName==`'"${service}"'`].taskDefinition'
  )
}

get_task_def() {
  # get task definition - selecting only the fields we need
  task_definition=$(
    aws ecs describe-task-definition \
      --task-definition ${active_task_arn} \
      --query 'taskDefinition' \
    | jq '{containerDefinitions, volumes, family}'
  )
}

update_task_def() {
  # modify task definition to use new image
  new_task_definition=$(echo ${task_definition} | jq ".containerDefinitions[0].image = \"${image}\"")
}

register_task_def() {
  # create a new version (same other than pointing to the latest docker image)
  new_task_arn=$(
    aws ecs register-task-definition \
        --output text \
        --query 'taskDefinition.taskDefinitionArn' \
        --cli-input-json "${new_task_definition}"
  )
}

update_service() {
  status "Updating service '${service}' to task definition revision (${new_task_arn})"
  updated_service=$(
    aws ecs update-service \
      --cluster ${cluster} \
      --service ${service} \
      --task-definition ${new_task_arn}
  )
}

wait_for_service() {
  status "Waiting for ECS service '${service}' to become stable on ${cluster} cluster..."
  aws ecs wait services-stable --cluster ${cluster} --service ${service}
  status "Done!"
}

deploy_service() {
  get_task_arn
  get_task_def
  update_task_def
  register_task_def
  update_service
}

deploy() {
  for service in "${servicesArray[@]}"; do
    status "Deploying '${service}' service on ${cluster} cluster"
    deploy_service
  done

  for service in "${servicesArray[@]}"; do
    status "Waiting for '${service}' service on ${cluster} cluster..."
    wait_for_service
  done
}

configure_aws_cli
deploy

exit 0

2) ecs-deployment-1.sh

#!/usr/bin/env bash
#
# DESCRIPTION: ECS Deployment Script
# MAINTAINER: Justin Kulesza <[email protected]
# DEPENDENCIES: bash (>= 4.4.12), python (~> 2.7.13), awscli (~> 1.11.91), docker-ce (>= 17.03.1)
# FROM: https://github.com/atomicobject/ecs-deployment
#

set -e

# BEGIN CUSTOMIZATIONS #
ECS_REGION='us-west-2'
ECS_CLUSTER_NAME='name-of-ecs-cluster'
ECS_SERVICE_NAME='NameOfService'
ECS_TASK_DEFINITION_NAME='NameOfTaskDefinition'
ECR_NAME='name-of-ecr'
ECR_URI='account-number.dkr.ecr.us-west-2.amazonaws.com'
VERSION=$(date +%s)
AWSCLI_VER_TAR=1.11.91
# END CUSTOMIZATIONS #

# BEGIN OTHER VAR DEFINITIONS #
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
ORIGINAL_BRANCH="$(git rev-parse --abbrev-ref HEAD)"
ENVIRONMENT=""
BRANCH=""
AWSCLI_VER=$(aws --version 2>&1 | cut -d ' ' -f 1 | cut -d '/' -f 2)
# END OTHER VAR DEFINITIONS #

if [[ ${AWSCLI_VER} < ${AWSCLI_VER_TAR} ]]
then echo "ERROR: Please upgrade your AWS CLI to version ${AWSCLI_VER_TAR} or later!"
  exit 1
fi

usage() {
  echo "Usage: $0 -e <environment> [-b <branch>]"
  echo " <environment> must be either 'staging' or 'production'"
  echo " <branch> must be a valid ref. If no branch is provided, you will be prompted for one."
  exit 1
}

while getopts ":e:b:h" o; do
    case "${o}" in
        e)
            ENVIRONMENT=${OPTARG}
            (("${ENVIRONMENT}" == "staging" || "${ENVIRONMENT}" == "production")) || usage
            ;;
        b)
            BRANCH=${OPTARG}
            git rev-parse --abbrev-ref "${BRANCH}" || usage
            ;;
        *)
            usage
            ;;
    esac
done
shift $((OPTIND-1))

if [[ -z "${ENVIRONMENT}" ]] ; then
    usage
fi

if [[ -z "${BRANCH}" ]] ; then
  echo -n "Which branch to deploy from [$(git rev-parse --abbrev-ref HEAD)] ? "
  read -r line
  if [[ -z "${line}" ]]; then
    BRANCH="$(git rev-parse --abbrev-ref HEAD)"
  else
    git rev-parse --abbrev-ref "${line}" || exit 1
    BRANCH="${line}"
  fi
fi

echo "You are deploying ${BRANCH} to ${ENVIRONMENT}."

# Git operations
(
  cd "${DIR}/.."

  # Fetch latest from git origin
  git fetch --all

  # Checkout the git branch
  git checkout "${BRANCH}"
)


# Docker operations
(
  cd "${DIR}/.."

  # Build the Docker image (to do asset and template compilation, etc.)
  docker build --pull -t "${ECR_NAME}:latest" -f ./docker/Dockerfile .

  # Tag the new Docker image to the remote repo (by date)
  docker tag "${ECR_NAME}:latest" "${ECR_URI}/${ECR_NAME}:${ENVIRONMENT}-${VERSION}"

  # Tag the new Docker staging image to the remote repo (by 'latest-${ENVIRONMENT}')
  docker tag "${ECR_NAME}:latest" "${ECR_URI}/${ECR_NAME}:latest-${ENVIRONMENT}"

  # Login to ECR
  $(aws ecr get-login --region "${ECS_REGION}")

  # Push to the remote repo (by date)
  docker push "${ECR_URI}/${ECR_NAME}:${ENVIRONMENT}-${VERSION}"

  # Push to the remote repo (by 'latest-staging')
  docker push "${ECR_URI}/${ECR_NAME}:latest-${ENVIRONMENT}"
)

# ECS operations
(
  cd "${DIR}/.."

  # Store revision
  REVISION=$(git rev-parse "${BRANCH}")

  # Get previous task definition from ECS
  PREVIOUS_TASK_DEF=$(aws ecs describe-task-definition --region "${ECS_REGION}" --task-definition "${ECS_TASK_DEFINITION_NAME}-${ENVIRONMENT}")

  # Create the new ECS container definition from the last task definition
  NEW_CONTAINER_DEF=$(echo "${PREVIOUS_TASK_DEF}" | python <(cat <<-EOF
import sys, json
definition = json.load(sys.stdin)['taskDefinition']['containerDefinitions']
definition[0]['environment'].extend([
  {
    'name' : 'REVISION',
    'value' : '${REVISION}'
  },
  {
    'name' : 'RELEASE_VERSION',
    'value' : '${VERSION}'
  },
  {
    'name' : 'ENVIRONMENT',
    'value' : '${ENVIRONMENT}'
  }])
definition[0]['image'] = '${ECR_URI}/${ECR_NAME}:${ENVIRONMENT}-${VERSION}'
print json.dumps(definition)
EOF
  ))

  # Create the new task definition
  aws ecs register-task-definition --region "${ECS_REGION}" --family "${ECS_TASK_DEFINITION_NAME}-${ENVIRONMENT}" --container-definitions "${NEW_CONTAINER_DEF}"

  # Update the service to use the new task defintion
  aws ecs update-service --region "${ECS_REGION}" --cluster "${ECS_CLUSTER_NAME}" --service "${ECS_SERVICE_NAME}-${ENVIRONMENT}"  --task-definition "${ECS_TASK_DEFINITION_NAME}-${ENVIRONMENT}"
)

# Return to original branch
(
  cd "${DIR}/.."

  # Checkout the original branch
  git checkout "${ORIGINAL_BRANCH}"
)

3) ecs-deployment-2.sh

#!/usr/bin/env bash
###
# Updates a pre-configured Amazon EC2 Container Service (ECS) cluster.
#
# Build a docker image in CWD, tag it and push it to hub.docker.com.
# Then Update an ECS services to run that newly available images.
#
# This script receives as a input a filename (Relative to this directory).
#
# That file must set the following Environment variables .
# DOCKER_USER         : Docker username for hub.docker.com
# DOCKER_PASSWORD     : Docker password for hub.docker.com
# DOCKER_EMAIL        : The email address used for registration with hub.docker.com
# DOCKER_IMAGE_TAG    : The Docker image & tag we want to build & deploy Example : "daiglej/repo:MyTag"
# ECS_CLUSTER         : The Name of the ECS cluster
# ECS_SERVICE         : The name of the ECS service (Must exists within the cluster)
# ECS_FAMILY          : Also know as the task name
# ECS_TASK_DEFINITION : A json string that holds the Task definition.
#
# NOTE : ECS Deploys strategy requires that the cluster is able to run one task during an update of the task.
# We assume that your cluster is not configured to be able to have 1 extra task running during the deploy.
# Therefore, we adopted the strategy of decreasing by 1 the number of running task before we trigger the update.
# If you are only running 1 instance of the task, this means you will have a DOWNTIME of approximately 30-60 seconds.
# Therefore, unless thats not an issue, we reccomend you have 2 instances of the task.
#
# This script was inspired/based on : https://github.com/circleci/circle-ecs/blob/master/deploy.sh
###

set -e
set -u
set -o pipefail
#set -o xtrace # Uncomment for debugging
JQ="jq --raw-output --exit-status"
JQ="jq --raw-output" # Comment for debugging

##
# Main function
##
function main() {
    echo -e "\n\n$(date "+%Y-%m-%d %H:%M:%S") Executing $1"
    my_dir="$(dirname "$0")"
    source "$my_dir/$1"

    echo "$(date "+%Y-%m-%d %H:%M:%S") Building, tagging & pushing docker image ($DOCKER_IMAGE_TAG)"
    docker_build_and_push "$DOCKER_IMAGE_TAG";
    echo -e "\n\n"

    get_ecs_status;
    DESIRED_COUNT=$CURRENT_DESIRED_COUNT

    if [[ $DESIRED_COUNT>0 ]]; then
        echo "$(date "+%Y-%m-%d %H:%M:%S") Decrease the desired numberof running task instances by one ($DESIRED_COUNT - 1 =$(expr $DESIRED_COUNT - 1))"
        echo "Otherwise, the deploy will fail if cluster is not able to support one additional instance (We assume this is not the case)."
        update_ecs_service $CURRENT_TASK_REVISION $(expr $DESIRED_COUNT - 1)
    else
        echo -e "$(date "+%Y-%m-%d %H:%M:%S") Service has currently 0 desired running instances. Setting the desired running task instance to 1"
        DESIRED_COUNT=1
    fi

    echo "$(date "+%Y-%m-%d %H:%M:%S") Update the Task definition (Includes the new docker images to use)"
    revision=$(update_ecs_task_def "$ECS_TASK_DEFINITION")

    echo "$(date "+%Y-%m-%d %H:%M:%S") Update the service to use the newly created task revision ($CURRENT_TASK_REVISION)"
    update_ecs_service "$CURRENT_TASK_REVISION" "$(expr $DESIRED_COUNT - 1)"

    echo "$(date "+%Y-%m-%d %H:%M:%S") Waiting for the number of running task instance to decrease to $(expr $DESIRED_COUNT - 1)"
    wait_ecs_nb_task $(expr $DESIRED_COUNT - 1)

    echo "$(date "+%Y-%m-%d %H:%M:%S") Done ... Now we can now re-set the original desired number task instance ($DESIRED_COUNT)"
    update_ecs_service "$CURRENT_TASK_REVISION" "$DESIRED_COUNT"

    echo "$(date "+%Y-%m-%d %H:%M:%S") Waiting for the number of running task to reach the original desired number of instances ($DESIRED_COUNT)"
    wait_ecs_nb_task $DESIRED_COUNT

    echo "$(date "+%Y-%m-%d %H:%M:%S") Waiting for stale task to be replaced by their new revision"
    wait_ecs_no_stale_task

    echo "$(date "+%Y-%m-%d %H:%M:%S") Deploy completed successfully. "
    echo "THANK YOU COME AGAIN!"
}

##
# Log in to hub.docker.com, build the docker image, tag it and push it to hub.docker.com
#
# @params string $1               The Name of the docker image & tag Example daiglej/repo:TAG
# @reads  string $DOCKER_EMAIL    hub.docker.com registration email
# @reads  string $DOCKER_PASSWORD hub.docker.com password
# @reads  string $DOCKER_USER     hub.docker.com registration username
##
function docker_build_and_push() {
    docker login -u "$DOCKER_USERNAME" -p "$DOCKER_PASSWORD" -e "$DOCKER_EMAIL"
    docker build -t $1 .
    docker push $1
}

##
# Read various status info about the ECS services and set/update status variables accordingly.
#
# @reads string $ECS_CLUSTER           The name of the ECS cluster
# @reads string $ECS_SERVICE           The name of the ECS service (Inside the cluster)
# @reads string $AWS_ACCESS_KEY_ID     AWS Access key
# @reads string $AWS_DEFAULT_REGION    AWS Default Region
# @reads string $AWS_SECRET_ACCESS_KEY AWS Secret access key
# @sets  int    $CURRENT_DESIRED_COUNT The number of tasks that should be running
# @sets  int    $CURRENT_RUNNING_TASK  The number of task that are running
# @sets  int    $CURRENT_STALE_TASK    The number of running task, that are not of the current revision
# @sets  string $CURRENT_TASK_REVISION The current task revision/version (Full ARN)
##
function get_ecs_status() {
    DECRIBED_SERVICE=$(aws ecs describe-services --cluster $ECS_CLUSTER \
                                                 --services $ECS_SERVICE);

    CURRENT_DESIRED_COUNT=$(echo $DECRIBED_SERVICE | $JQ ".services[0].desiredCount")
    CURRENT_TASK_REVISION=$(echo $DECRIBED_SERVICE | $JQ ".services[0].taskDefinition")
    CURRENT_RUNNING_TASK=$(echo $DECRIBED_SERVICE | $JQ ".services[0].runningCount")
    CURRENT_STALE_TASK=$(echo $DECRIBED_SERVICE | $JQ ".services[0].deployments | .[] | select(.taskDefinition != \"$CURRENT_TASK_REVISION\") | .taskDefinition")
    if [[ -z "$CURRENT_STALE_TASK" ]]; then
        CURRENT_STALE_TASK=0
    fi
}

##
# Set the task definition revision/version and the desired task number of instances that the service should run.
#
# @params string $1                     Version/revision the task definition (full ARN)
# @params int    $2                     The desired number of task instances to be run.
# @reads string  $ECS_CLUSTER           The name of the ECS cluster
# @reads string  $ECS_SERVICE           The name of the ECS service
# @reads string  $AWS_ACCESS_KEY_ID     AWS Access key
# @reads string  $AWS_DEFAULT_REGION    AWS Default Region
# @reads string  $AWS_SECRET_ACCESS_KEY AWS Secret access key
##
function update_ecs_service() {
    output=$(aws ecs update-service --cluster $ECS_CLUSTER \
                                    --service $ECS_SERVICE \
                                    --task-definition $1 \
                                    --desired-count $2)

    if [[ $(echo $output | $JQ '.service.taskDefinition') != $1  ]] || [[ $(echo $output | $JQ '.service.desiredCount') != $2  ]];  then
        echo -e "\n$(date "+%Y-%m-%d %H:%M:%S") Error, in setting service"
        exit 2
    fi
}

##
# Push/Update the task definition to ECS and set the newly created task revision full arn ($CURRENT_TASK_REVISION)
#
# @params string $1                     Task Definition (JSON)
# @reads  string $ECS_FAMILY            The task family (aka name)
# @reads  string $AWS_ACCESS_KEY_ID     AWS Access key
# @reads  string $AWS_DEFAULT_REGION    AWS Default Region
# @reads  string $AWS_SECRET_ACCESS_KEY AWS Secret access key
# @sets   string $CURRENT_TASK_REVISION The task revision/version (Full ARN)
##
function update_ecs_task_def() {
    if CURRENT_TASK_REVISION=$(aws ecs register-task-definition --container-definitions "$1" \
                                                                --family $ECS_FAMILY  \
                    | $JQ '.taskDefinition.taskDefinitionArn'); then
        echo -e "\n$(date "+%Y-%m-%d %H:%M:%S") Successfully register task definition :\n\tfamily : $ECS_FAMILY\n\tRevision : $CURRENT_TASK_REVISION\n"
        return 0
    fi

    echo -e "\n$(date "+%Y-%m-%d %H:%M:%S") Failed to register task definition :\n\tfamily : $ECS_FAMILY"
    exit 1
}

##
# Wait until the service has reached The desired number of running task instances
#
# @uses get_ecs_status()
##
function wait_ecs_nb_task() {
    for attempt in {1..120}; do
        get_ecs_status
    if [ $CURRENT_RUNNING_TASK -ne $CURRENT_DESIRED_COUNT ]; then
        sleep 1
    else
        return 0
    fi
    done

    echo -e "\n\n$(date "+%Y-%m-%d %H:%M:%S") Waiting for running count to reach $CURRENT_DESIRED_COUNT took to long. Current running task : $CURRENT_RUNNING_TASK\n\n"
    exit 3
}

##
# Wait for all stale task to disappear.
#
# Stale task = Task of not the current version/revision
#
# @param string $1 The current task revision
# @uses get_ecs_status()
##
function wait_ecs_no_stale_task() {
    for attempt in {1..240}; do
        get_ecs_status;
        echo "$(date "+%Y-%m-%d %H:%M:%S") Running : $CURRENT_RUNNING_TASK, Desired : $CURRENT_DESIRED_COUNT, Stale : $CURRENT_STALE_TASK"

        if [[ $CURRENT_STALE_TASK>0 ]]; then
            sleep 2
        else
            return 0
        fi
    done

    echo "\n\nService update took too long.\n\n"
    exit 4
}

main "$@"
exit 0