Building Micro-services and a CI/CD Pipeline with AWS

1: Planning the design and estimating cost

1.1: Create an architecture diagram

1.2: Develop a cost estimate

2: Analyzing the infrastructure of the monolithic application

2.1: Verify that the monolithic application is available

2.2: Test the monolithic web application

2.3: Analyze how the monolithic application runs

3: Creating a development environment and checking code into a Git repository

3.1: Create an AWS Cloud9 IDE as your work environment

3.2: Copy the application code to your IDE

3.3: Create working directories with starter code for the two microservices

3.4: Create a Git repository for the microservices code and push the code to CodeCommit

4: Configuring the application as two microservices and testing them in Docker containers

4.1: Adjust the AWS Cloud9 instance security group settings

4.2: Modify the source code of the customer microservice

4.3: Create the customer microservice Dockerfile and launch a test container

4.4: Modify the source code of the employee microservice

4.5: Create the employee microservice Dockerfile and launch a test container

4.6: Adjust the employee microservice port and rebuild the image

4.7: Check code into CodeCommit

5: Creating ECR repositories, an ECS cluster, definitions, and AppSpec files

5.1: Create ECR repositories and upload the Docker images

5.2: Create an ECS cluster

5.3: Create a CodeCommit repository to store deployment files

5.4: Create definition files for each microservice and register them with Amazon ECS

5.5: Create AppSpec files for CodeDeploy for each microservice

5.6: Update files and check them into CodeCommit

6: Creating target groups and an Application Load Balancer

6.1: Create four target groups

6.2: Create a security group and an Application Load Balancer, and configure rules to route traffic

7: Creating two Amazon ECS services

7.1: Create the ECS service for the customer microservice

7.2: Create the Amazon ECS service for the employee microservice

8: Configuring CodeDeploy and CodePipeline

8.1: Create a CodeDeploy application and deployment groups

8.2: Create a pipeline for the customer microservice

8.3: Test the CI/CD pipeline for the customer microservice

8.4: Create a pipeline for the employee microservice

8.5: Test the CI/CD pipeline for the employee microservice

8.6: Observe how CodeDeploy modified the load balancer listener rules

9: Adjusting the microservice code to cause a pipeline to run again

9.1: Limit access to the employee microservice

9.2: Adjust the UI for the employee microservice and push the updated image to Amazon ECR

9.3: Confirm that the employee pipeline ran and the microservice was updated

9.4: Test access to the employee microservice

9.5: Scale the customer microservice

Project overview and objectives

Return to table of contents

In this project, you’re challenged to use at least 11 AWS offerings, including some that might be new to
you, to build a microservices and continuous integration and continuous development (CI/CD) solution.
Throughout various AWS Academy courses, you have completed hands-on labs. You have used different
AWS services and features to build a variety of solutions.

In many parts of the project, step-by-step guidance is not provided. This is intentional. These specific
sections of the project are meant to challenge you to practice skills that you have acquired throughout
your learning experiences prior to this project. In some cases, you might be challenged to use resources
to independently learn new skills.

By the end of this project, you should be able to do the following:

 Recognize how a Node.js web application is coded and deployed to run and connect to a relational
database where the application data is stored.
 Create an AWS Cloud9 integrated development environment (IDE) and a code repository (repo) in which
to store the application code.
 Split the functionality of a monolithic application into separate containerized microservices.
 Use a container registry to store and version control containerized microservice Docker images.
 Create code repositories to store microservice source code and CI/CD deployment assets.
 Create a serverless cluster to fulfill cost optimization and scalability solution requirements.
 Configure an Application Load Balancer and multiple target groups to route traffic between microservices.
 Create a code pipeline to deploy microservices containers to a blue/green cluster deployment.
 Use the code pipeline and code repository for CI/CD by iterating on the application design.

The lab environment and monitoring your budget

This environment is long lived. When the session timer runs to 0:00, the session will end, but any data
and resources that you created in the AWS account will be retained. If you later launch a new session (for
example, the next day), you will find that your work is still in the lab environment. Also, at any point before
the session timer reaches 0:00, you can choose Start Lab again to extend the current session time.

Important: Monitor your lab budget in the lab interface. When you have an active lab session, the latest
known remaining budget information displays at the top of this screen. The remaining budget that you see
might not reflect your most recent account activity. If you exceed your lab budget, your lab account will be
disabled, and all progress and resources will be lost. If you exceed the budget, please contact your
educator for assistance.

If you ever want to reset the lab environment to the original state, before you started the lab, use the
Reset option above these instructions. Note that this won't reset your budget. Warning: If you reset the
environment, you will permanently delete everything that you have created or stored in this AWS account.

AWS service restrictions

In this lab environment, access to AWS services and service actions are restricted to the ones that are
needed to complete the project. You might encounter errors if you attempt to access other services or
perform actions beyond the ones that are described in this lab.

Scenario

The owners of a café corporation with many franchise locations have noticed how popular their gourmet
coffee offerings have become.

Customers (the café franchise location managers) cannot seem to get enough of the high-quality coffee
beans that are needed to create amazing cappuccinos and lattes in their cafés.

Meanwhile, the employees in the café corporate office have been challenged to consistently source the
highest-quality coffee beans. Recently, the leaders at the corporate office learned that one of their favorite
coffee suppliers wants to sell her company. The café corporate managers jumped at the opportunity to
buy the company. The acquired coffee supplier runs a coffee supplier listings application on an AWS
account, as shown in the following image.

The coffee suppliers application currently runs as a monolithic application. It has reliability and
performance issues. That is one of the reasons that you have recently been hired to work in the café
corporate office. In this project, you perform s that are associated with software development engineer
(SDE), app developer, and cloud support engineer roles.
 You have been ed to split the monolithic application into microservices, so that you can scale the services
independently and allocate more compute resources to the services that experience the highest demand,
with the goal of avoiding bottlenecks. A microservices design will also help avoid single points of failure,
which could bring down the entire application in a monolithic design. With services isolated from one
another, if one microservice becomes temporarily unavailable, the other microservices might remain
available.

You have also been challenged to develop a CI/CD pipeline to automatically deploy updates to the
production cluster that runs containers, using a blue/green deployment strategy.

Solution requirements

The solution must meet the following requirements:

 R1 - Design: The solution must have an architecture diagram.

 R2 - Cost optimized: The solution must include a cost estimate.
 R3 - Microservices-based architecture: Ensure that the solution is functional and deploys a microservice-
based architecture.
 R4 - Portability: The solution must be portable so that the application code isn't tied to running on a
specific host machine.
 R5 - Scalability/resilience: The solution must provide the ability to increase the amount of compute
resources that are dedicated to serving requests as usage patterns change, and the solution must use
routing logic that is reliable and scalable.
 R6 - Automated CI/CD: The solution must provide a CI/CD pipeline that can be automatically invoked
when code is updated and pushed to a version-controlled code repository.

Detail Solution re

1 Create an architecture diagram and cost estimate for the solution. R1, R2

2 Analyze the design of the monolithic application and test the application. R3

3 Create a development environment on AWS Cloud9, and check the monolithic source code into CodeCommit. R3

4 Break the monolithic design into microservices, and launch test Docker containers. R3, R4

Create ECR repositories to store Docker images. Create an ECS cluster, ECS definitions, and CodeDeploy
5 R3
application specification files.

6 Create target groups and an Application Load Balancer that routes web traffic to them. R5

7 Create ECS services. R5

Configure applications and deployments groups in CodeDeploy, and create two CI/CD pipelines by using
8 R5, R6
CodePipeline.

Modify your microservices and scale capacity, and use the pipelines that you created to deploy iterative
9 R5, R6
improvements to production by using a blue/green deployment strategy.