Deploying Application to Existing Environment – Customizing AWS Elastic Beanstalk

In this post we are going to deploy a new version of the application onto an existing AWS Elastic Beanstalk environment and it could be development, staging or the production environment.

The scripts production-deploy-new-app.sh and staging-deploy-new-app.sh are used to deploy the application to production and staging environments respectively. For the production environment this is the only script we use at hudku.com. We never want to terminate the production environment as we intend to serve the humanity and want to pay our taxes without fail as long as we survive.

We also do not need to create a production environment because always it is the staging environment that gets created newly and once the tests are satisfactory, the staging environment gets swapped into production and the previous production becomes staging. Once it is no longer needed then using staging-terminate.sh, the staging (or previous production) environment can be terminated.

I also would like to mention that we rarely need to create a new staging environment. Most of the time we reuse the environment and always deploy the new version of the application directly on to the production environment. Hence production-deploy-new-app.sh is the script that is heavily used. As ours is a Tomcat application, we run tomcat-start-secondary.sh before the deployment to keep the website functional and do a zero downtime deployment of the new application version. Here is the source code of production-deploy-new-app.sh.

#!/bin/bash
 
 
# Execute "export DEBUG=1" to debug this script.
# Set value to 2 to debug this script and the scripts called within this script.
# Set value to 3,4,5 and so on to increase the nesting level of the scripts to be debugged.
[[ $DEBUG -gt 0 ]] && set -x; export DEBUG=$(($DEBUG - 1))
 
 
#
# Deploys a new version of the application to the Elastic Beanstalk Production environment
#
 
 
# include all the utility scripts
source $ELASTICBEANSTALK_APP_SCRIPT_DIR/include/include.sh
 
 
if ([ ! -z "$TOMCAT_SECONDARY_INSTANCE_NAME" ]) then
    if ( ! $(isPortOpen 8109) ) then
        echo "Warning: Port 8109 is NOT open and tomcat secondary instance has not been started."
        answer=$(promptDefaultNo)
        if ([ "$answer" == "n" ]) then
            exit 3
        fi
    fi
fi
 
 
 
$ELASTICBEANSTALK_APP_SCRIPT_DIR/deployment/staging-deploy-new-app.sh $ROUTE53_RR_PRODUCTION_NAME

The script first checks whether the secondary tomcat instance is running before trying to deploy the application. If it is not a Tomcat application then the check is skipped. Then the script simply calls the other script of this post staging-deploy-new-app.sh with an appropriate parameter. If you had been noticing, all the staging scripts take arguments so that they can either operate on staging environment or development environment. The current script supports the production environment also.

Let us get our directory structure and see how the “deployment” directory is shaping up. Notice that after this post, we just need to cover the development environment scripts which I intend to do in the next blog post and that would bring us to the end of this “bash script-a-thon” to customize the AWS Elastic Beanstalk environment. Also please notice that all the scripts in the deployment folder have to be executed manually but they can be executed from any instance such as production, staging or development. In other words what matters is which script from the deployment directory is being executed and not where it is executed from.

Let us discuss the script staging-deploy-new-app.sh which is the one that contains all the code. This script does not make use of the tool dnscurl.pl and instead relies on the tool route53 written by Chris Moyer and it came pre-installed with the Beanstalk environment. Given the main URL of staging, development or production the script first extracts the host name and retrieves the Route53 hosted zone id. Then it obtains the value of the Route53 AliasTarget record which is supposed to contain the URL of the Elastic Load Balancer of the environment. Using the ELB URL, the script obtains the name of the Elastic Beanstalk environment and checks whether the name is in the expected format.

Then just like staging-create.sh, the script checks for the existence of a single war file (source bundle) in the “war” folder of the deployment directory in the Amazon S3 private bucket. The information of the war file is obtained and a check is made to ensure that the war file is not already deployed in the environment.

Then the war file is copied from Amazon S3 private bucket to the S3 bucket used by Elastic Beanstalk and using the command elastic-beanstalk-create-application-version an application version is created. If these steps are already done then they are skipped.

Next using the command elastic-beanstalk-update-environment, the war file is deployed to the existing Beanstalk environment. Once this step is executed successfully, we can watch the actual fun in the Amazon’s Elastic Beanstalk console where we can monitor the progress of the deployment and also see the event log.

Presenting the source code of staging-deploy-new-app.sh.

#!/bin/bash
 
 
# Execute "export DEBUG=1" to debug this script.
# Set value to 2 to debug this script and the scripts called within this script.
# Set value to 3,4,5 and so on to increase the nesting level of the scripts to be debugged.
[[ $DEBUG -gt 0 ]] && set -x; export DEBUG=$(($DEBUG - 1))
 
#
# Deploys a new version of the application to the Elastic Beanstalk Staging environment
#
 
 
# include all the utility scripts
source $ELASTICBEANSTALK_APP_SCRIPT_DIR/include/include.sh
 
 
display_usage()
{
    echo -e "\nUsage: $0 route53_RR_Name\n"
}
 
# Check argument count
if ([ $# -gt 1 ]) then
    display_usage
    exit 2
fi
 
 
# Deploy new app to staging entry unless another entry is supplied
route53RRName=$ROUTE53_RR_STAGING_NAME
if ([ ! -z $1 ]) then
    route53RRName=$1
fi
 
 
# Extract host name from the dns entry name
hostName=$(echo $route53RRName | grep -o "[^\.]*\.[^\.]*\.$")
 
# Get Route53 hosted zone ID
route53HostedZoneID=$(route53 ls | sed -n -e '/'"$hostName"'/{g;1!p;};h' | awk '{print $3}')
if ([ -z "$route53HostedZoneID" ]) then
    echo "Could not find zone '$hostName' in Route53"
    exit 1
fi
 
# Retrieve the AliasTarget record
aliasTargetRecord=$(route53 get $route53HostedZoneID | grep "^$route53RRName" | grep "ALIAS")
if ([ -z "$aliasTargetRecord" ]) then
    echo "Could not obtain AliasTarget record for '$route53RRName' in Route53"
    exit 1
fi
 
# Extract Load Balancer URL from AliasTarget record
elbURL=$(echo $aliasTargetRecord | awk '{print $6}')
if ([ -z "$elbURL" ]) then
    echo "Error: Could not obtain elbURL from AliasTarget record $aliasTargetRecord of $route53RRName"
    exit 1
fi
 
# Obtain the environment name using the Load Balancer URL
envName=$($ELASTICBEANSTALK_APP_SCRIPT_DIR/util/elastic-beanstalk-get-env-name-from-elb-url.sh $elbURL)
if ([ -z "$envName" ]) then
    echo "Error: Could not obtain environment name for $route53RRName and URL $elbURL"
    exit 1
fi
 
# Check envName format
testEnvName=$(echo $envName | grep "^env-[0-9]\{8\}-[0-9]\{4\}$")
if ([ -z "$testEnvName" ]) then
    echo "Environment Name is '$envName' whose format is unknown. Not trying to move the environment to staging"
    exit 1
fi
 
 
warFileDirInPrivateBucket=$ELASTICBEANSTALK_APP_PRIVATE_S3_BUCKET/$ELASTICBEANSTALK_APP_DEPLOY_DIR/war
 
if [ $(s3cmd ls s3://$warFileDirInPrivateBucket/ | grep "\.war" | wc -l) -gt 1 ]; then
    echo "Error: Found more than one war file in 's3://$warFileDirInPrivateBucket/'"
    echo -e "Files found are\n$(s3cmd ls s3://$warFileDirInPrivateBucket/ | grep "\.war")"
    exit 1
fi
 
warFileInfo=$(s3cmd ls s3://$warFileDirInPrivateBucket/ | grep "\.war")
if ([ -z "$warFileInfo" ]) then
    echo "Error: Could not find war files in 's3://$warFileDirInPrivateBucket/'"
    exit 1
fi
 
warFileName=$(echo ${warFileInfo} | awk '{print $4}' | sed "s|^s3:.*/||g")
 
filename=$(basename "$warFileName")
extension="${filename##*.}"
filename="${filename%.*}"
 
 
# Get the UTC datetime of war file
warFileDateTime=$(echo ${warFileInfo} | awk '{print $1," ",$2}')
 
# Convert datetime in UTC to IST which is what gets displayed in S3 console
warFileDateTime=$(date +'%Y%m%d-%H%M' -d "${warFileDateTime} -05:30")
 
appNewVersionFileName="${filename}-${warFileDateTime}.${extension}"
 
# Check if this war file is already deployed in the current environment
existingURL=$($ELASTICBEANSTALK_APP_SCRIPT_DIR/util/elastic-beanstalk-get-elb-url-from-app-version.sh lbl_$appNewVersionFileName)
if ([ ! -z "$existingURL" ]) then
    tmp=$(echo "$elbURL" | grep -i "^$existingURL$")
    if ([ ! -z "$tmp"  ]) then
        echo "ERROR: The war file ${warFileName} is already deployed in the current environment $envName"
        exit 1
    fi
fi
 
 
# Copy war file and create an application version if it is not already present
if ([ -z "$existingURL" ]) then
    # Copy war file to beanstalk bucket
 s3cmd --config=/root/.s3cfg cp s3://$warFileDirInPrivateBucket/$warFileName s3://${ELASTICBEANSTALK_S3_BUCKET}/$appNewVersionFileName
  
    # Create the application version from the copied war file
 elastic-beanstalk-create-application-version -a $ELASTICBEANSTALK_APP_NAME -l lbl_${appNewVersionFileName} -d desc_${appNewVersionFileName} -s ${ELASTICBEANSTALK_S3_BUCKET}/${appNewVersionFileName}
fi
 
 
# Deploy the application to the beanstalk environment
elastic-beanstalk-update-environment -e $envName -l lbl_${appNewVersionFileName}