Effective DevOps with AWS

Implement continuous delivery and integration in the AWS environment, 2nd Edition

Yogesh Raheja, Giuseppe Borgese, Nathaniel Felsen

• Editorial: Packt Publishing
• Año: 2018
• ISBN:
  9781789539691
• Edición: 2
• Categoría: Ciencia de la computación
• Categoría: Computación en la nube

Scale and maintain outstanding performance in your AWS-based infrastructure using DevOps principles

Key Features

• Implement continuous integration and continuous deployment pipelines on AWS
• Gain insight from an expert who has worked with Silicon Valley's most high-profile companies
• Implement DevOps principles to take full advantage of the AWS stack and services

Book Description

The DevOps movement has transformed the way modern tech companies work. Amazon Web Services (AWS), which has been at the forefront of the cloud computing revolution, has also been a key contributor to the DevOps movement, creating a huge range of managed services that help you implement DevOps principles.

Effective DevOps with AWS, Second Edition will help you to understand how the most successful tech start-ups launch and scale their services on AWS, and will teach you how you can do the same. This book explains how to treat infrastructure as code, meaning you can bring resources online and offline as easily as you control your software. You will also build a continuous integration and continuous deployment pipeline to keep your app up to date. Once you have gotten to grips will all this, we'll move on to how to scale your applications to offer maximum performance to users even when traffic spikes, by using the latest technologies, such as containers. In addition to this, you'll get insights into monitoring and alerting, so you can make sure your users have the best experience when using your service. In the concluding chapters, we'll cover inbuilt AWS tools such as CodeDeploy and CloudFormation, which are used by many AWS administrators to perform DevOps. By the end of this book, you'll have learned how to ensure the security of your platform and data, using the latest and most prominent AWS tools.

What you will learn

• Implement automatic AWS instance provisioning using CloudFormation
• Deploy your application on a provisioned infrastructure with Ansible
• Manage infrastructure using Terraform
• Build and deploy a CI/CD pipeline with Automated Testing on AWS
• Understand the container journey for a CI/CD pipeline using AWS ECS
• Monitor and secure your AWS environment

Who this book is for

Effective DevOps with AWS is for you if you are a developer, DevOps engineer, or you work in a team which wants to build and use AWS for software infrastructure. Basic computer science knowledge is required to get the most out of this book.

Running Containers in AWS

In Chapter 6, Scaling Your Infrastructure, our architecture changed quite a bit. We explored different ways to scale our applications in AWS, but one of the major technologies that we left out was containers. Containers are at the heart of the software development life cycle (SDLC) of many major technology companies.

So far, we have used our personal computers to develop our applications. This works well for simple projects, such as our Hello World application. However, when it comes to more complex projects with many dependencies, it's a different story. Have you ever heard of situations in which a certain feature works on a developer's laptop but does not work for the rest of the organization-or-even worse, does not work in production? A lot of these issues stem from the differences between environments. When we build our staging and production environments, we rely on CloudFormation, Terraform, and Ansible, to keep those environments consistent. Unfortunately, we can't easily replicate that to our local development environment.

Containers address this issue. With them, we can package an application and include the operating system, the application code, and everything in between. Containers can also help at a later stage, when it's time to break out the monolithic approach.

In this chapter, we will look at Docker, the most popular container technology. After a brief explanation of what Docker is and how to use its basic functionalities, we will Dockerize our application. This will help us to understand the value of using Docker as a developer. In this chapter, we will cover the following topics:

• Dockerizing our Hello World application
• Using the EC2 container service
• Updating our CI/CD pipeline to utilize ECS

This book covers ECS, but also offers further options for using Docker in AWS. You can also take a look at CoreOS Tectonic (https://tectonic.com/), Mesosphere DC/OS (https://mesosphere.com), or Docker Datacenter (https://www.docker.com/products/docker-datacenter).

Technical requirements

The technical requirements for this chapter are as follows:

• Docker
• Dockerfile
• EC2 Container Registry (ECR)
• Elastic Container Service (ECS)
• Application Load Balancer (ALB)
• CodeBuild
• CodePipeline

The GitHub links for the code used in this chapter are as follows:

• https://github.com/yogeshraheja/helloworld/blob/master/helloworld.js
• https://github.com/yogeshraheja/helloworld/blob/master/package.json
• https://github.com/yogeshraheja/helloworld/blob/master/Dockerfile
• https://github.com/yogeshraheja/EffectiveDevOpsTemplates/blob/master/ecr-repository-cf-template.py
• https://github.com/yogeshraheja/EffectiveDevOpsTemplates/blob/master/ecs-cluster-cf-template.py
• https://github.com/yogeshraheja/EffectiveDevOpsTemplates/blob/master/helloworld-ecs-alb-cf-template.py

• https://github.com/yogeshraheja/EffectiveDevOpsTemplates/blob/master/helloworld-ecs-service-cf-template.py
• https://github.com/yogeshraheja/EffectiveDevOpsTemplates/blob/master/helloworld-codebuild-cf-template.py
• https://raw.githubusercontent.com/yogeshraheja/EffectiveDevOpsTemplates/master/helloworld-ecs-service-cf-template.py
• https://github.com/yogeshraheja/EffectiveDevOpsTemplates/blob/master/helloworld-codepipeline-cf-template.py

Dockerizing our Hello World application

Docker, and containers in general, are very powerful tools, worth exploring. By combining resource isolation features, including union capable filesystem (UCF), Docker allows for the creation of packages called containers, which include everything that is needed to run an application. Containers, like virtual machines, are self-contained, but they virtualize the OS itself, instead of virtualizing the hardware. In practice, this makes a huge difference. As you have probably noticed by now, starting a virtual machine, such as an EC2 instance, takes time. This comes from the fact that in order to start a virtual machine, the hypervisor (that's the name of the technology that creates and runs virtual machines) has to simulate all of the motions involved in starting a physical server, loading an operating system, and going through the different run-levels. In addition, virtual machines have a much larger footprint on the disk and in the memory. With Docker, the added layer is hardly noticeable, and the size of the containers can stay very small. In order to better illustrate this, we will first install Docker and explore its basic usage a bit.

Getting started with Docker

Before we start to use Docker, it might be useful to better understand Docker's concept and architecture. First, we will discuss Docker's fundamental changes with regards to the SDLC. Following that introduction, we will install Docker on our computers and look at some of the most common commands needed to use Docker.

Docker fundamentals

The best way to understand how Docker works is to compare how using Docker differs from what we've done so far:

The preceding diagram can be explained as follows:

• The first stack on the left represents what we did so far. Using the EC2 service, we picked an AMI providing AWS Linux, and, with the help of the user data field, we installed Ansible to configure our system. When Ansible kicks in, it installs and configures the system, so that later, CodeDeploy can deploy and run our application.
• The middle stack represents what it means to use Docker on top of EC2. The process starts the same way with an AMI running AWS Linux. However, this time, instead of relying on Ansible and CodeDeploy, we will simply install the Docker server application. After that, we will deploy Docker containers, wh...