https://github.com/julien-muke/aws-cicd-devops-web-app
Building a CI/CD pipeline for a Node.js web application using AWS CI/CD services is a robust approach to streamline and automate the software development process.
https://github.com/julien-muke/aws-cicd-devops-web-app
aws-codebuild aws-codedeploy aws-codepipeline aws-elastic-beanstalk
Last synced: 3 months ago
JSON representation
Building a CI/CD pipeline for a Node.js web application using AWS CI/CD services is a robust approach to streamline and automate the software development process.
- Host: GitHub
- URL: https://github.com/julien-muke/aws-cicd-devops-web-app
- Owner: julien-muke
- Created: 2024-07-04T15:29:32.000Z (almost 2 years ago)
- Default Branch: main
- Last Pushed: 2024-07-10T07:59:04.000Z (almost 2 years ago)
- Last Synced: 2024-07-10T18:37:08.880Z (almost 2 years ago)
- Topics: aws-codebuild, aws-codedeploy, aws-codepipeline, aws-elastic-beanstalk
- Homepage:
- Size: 13.7 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
#  Building end-to-end AWS DevOps CI/CD pipeline with Node.js.
AWS CodePipeline is a fully managed continuous delivery service that helps you automate your release pipelines for fast and reliable application and infrastructure updates.
In this demo, we are going to learn how to build a CI/CD pipeline for a Node.js web application using AWS CI/CD services (CodeBuild, CodeDeploy, CodePipeline). We will start from scratch and proceed to the end. First, we will explore the architecture, and then we will build the pipeline.
## Architecture overview
The architecture of the CI/CD pipeline is as follows:
* Users start by pushing a new commit to the GitHub repository.
* This triggers the pipeline, which consists of three stages: Source, Build, and Deploy.
* The Source stage pulls the source code from the GitHub repository.
* The Build stage uses AWS CodeBuild to Test the Node.js web application.
* The Deploy stage uses AWS CodeDeploy to deploy the Node.js web application to an Elaastic Beanstalk environment.
## ☑️ Steps
The procedure for deploying this architecture on AWS consists of the following steps:
Step 1: Create a Instance role Elastic Beanstalk
Step 2: Creating an Elastic Beanstalk environment
Step 3: Create a Pipeline to Deploy Node.js Application
## :octocat: Clone example repository
Clone the [example repository](https://github.com/julien-muke/aws-cicd-devops-web-app-sample.git) for this tutorial, which contains the Node.js Application.
```bash
git clone https://github.com/julien-muke/aws-cicd-devops-web-app-sample.git
```
Change into the repository directory.
```bash
cd aws-cicd-devops-web-app-sample
```
## ➡️ Step 1 - Create a Instance role Elastic Beanstalk
An instance profile is a container for an AWS Identity and Access Management (IAM) role that you can use to pass role information to an Amazon EC2 instance when the instance starts.
If your AWS account doesn’t have an EC2 instance profile, you must create one using the IAM service. You can then assign the EC2 instance profile to new environments that you create. The Create environment wizard provides information to guide you through the IAM service, so that you can create an EC2 instance profile with the required permissions. After creating the instance profile, you can return to the console to select it as the EC2 instance profile and continue the steps to create your environment.
To create an instance profile:
1. Open the [Roles](https://console.aws.amazon.com/iam/home#roles) page in the IAM console.
2. Choose Create role.
3. Under Trusted entity type, choose AWS service.
4. Under Use case, choose EC2.
5. Choose Next.
6. Attach the appropriate managed policies provided by Elastic Beanstalk and any additional policies that provide permissions that your application needs.
7. Choose Next.
8. Enter a name for the role `aws-cicd-web-app-role`.
9. Choose Create role.
## ➡️ Step 2 - Creating an Elastic Beanstalk environment
An AWS Elastic Beanstalk environment is a collection of AWS resources running an application version. You can deploy multiple environments when you need to run multiple versions of an application. For example, you might have development, integration, and production environments.
To launch an environment with a sample application (console):
1. Open the [Elastic Beanstalk console](https://console.aws.amazon.com/elasticbeanstalk), and in the Regions list, select your AWS Region.
2. In the navigation pane, choose Applications, and then choose create application, name your app `My-First-App`.
3. On the application overview page, choose Create new environment.
This launches the Create environment wizard. The wizard provides a set of steps for you to create a new environment.
4. For environment tier, choose the Web server environment.
5. For Platform, select the platform and platform branch that match the language your application uses, in my case it's `Node.js`
6. For Application code, choose Sample application.
7. For Configuration presets, choose Single instance.
8. Choose Next.
9. Choose Use an existing service role for Service Role.
10. Next, we'll focus on the EC2 instance profile dropdown list. The values displayed in this dropdown list may vary, depending on whether you account has previously created a new environment.
Choose one of the following, based on the values displayed in your list:
* If `aws-elasticbeanstalk-ec2-role` displays in the dropdown list, select it from the EC2 instance profile dropdown list.
* If another value displays in the list, and it’s the default EC2 instance profile intended for your environments, select it from the EC2 instance profile dropdown list `aws-cicd-web-app-role`.
* If the EC2 instance profile dropdown list doesn't list any values to choose from, expand the procedure that follows, Create IAM Role for EC2 instance profile.
11. Choose Next.
12. Review configuration then choose Next.
13. The Elastic Beanstalk Environment will take few munites to launch.
14. Once the environment is successfully launched, click on the URL Domain to test the application.
## ➡️ Step 3 - Create a Pipeline to Deploy Node.js Application
To create a pipeline in the console, you must provide the source file location and information about the providers you will use for your actions.
We will create a pipeline to deploy the Node.js web application to an Elastic Beanstalk environment. We will use AWS CodePipeline to create a pipeline that automates the deployment process.
To create a pipeline in the console:
1. Open the CodePipeline console at http://console.aws.amazon.com/codesuite/codepipeline/home.
2. On the Welcome page, choose Create pipeline.
3. Choose pipeline settings page, in Pipeline name, enter the name for your pipeline `devops-web-app-pipeline`
4. In Execution mode, choose Queued (Pipeline type V2 required)
5. In Service role, Choose New service role to allow CodePipeline to create a new service role in IAM.
6. Choose Next.
7. Add source stage page, in Source provider, choose the type of repository where your source code is stored, specify its required options, in my case i will choose GitHub (Version 2).
* Under Connection, choose an existing connection or create a new one. To create or manage a connection for your GitHub source action, see [GitHub connections](https://docs.aws.amazon.com/codepipeline/latest/userguide/connections-github.html).
* Choose the repository you want to use as the source location for your pipeline.
* GitHub Apps create a link for your connection with GitHub. To start, install a new app and
save this connection.
* Select your GitHub repository `julien-muke/aws-cicd-devops-web-app-sample`
* Choose again a repository in your GitHub Account, then choose `main` as default branch
* Enter `main` branch to trigger the pipeline, then choose Next.
7. On the Add build stage page, From Build provider, choose a custom action provider of build services, and provide the configuration details for that provider, choose `AWS CodeBuild`
8. In Project name, choose your build project. If you have already created a build project in CodeBuild, choose it. Or you can create a build project in CodeBuild and then return to this task. Follow the instructions in Create a Pipeline That Uses CodeBuild in the CodeBuild User Guide.
* Choose Create project
* Enter the Project name `devops-web-app`
* Under Build specifications, choose Use a buildspec file to Store build commands in a YAML-formatted buildspec file.
* Scroll down and Choose Continue to CodePipeline.
* Once the is created, go back to the build page, and choose Next.
9. On the Add deploy stage page, In Deploy provider, choose a custom action that you have created for a deployment provider which is `AWS Elastic Beanstalk`
10. In Application name, enter or choose the name of an existing Elastic Beanstalk application `My-First-App`
11. n Environment name, enter an environment for the application `My-First-App-env`. Choose Next.
12. Review page, review your pipeline configuration, and then choose Create pipeline.
Note: The Pipeline will be triggered automatically. But we need to modify one setting to run the Pipeline Successfully. Since we are not building any Binaries or Docker Images, we are not using BuildArtifacts Option. So we also need to update that setting in Deploy Stage.
Artifacts are the files that are worked on by actions in the pipeline. See the action configuration for each action for details about artifact parameters. For example, the S3 source action artifact is a file name (or file path), and the files are generally provided as a ZIP file.
13. Let's edit the pipiline, in the codePipeline console, click Edit
14. Scroll down to Edit: Deploy and choose Edit stage.
15. Click on the edit icon
16. Under Input artifacts, choose `SourceArtifacts`
17. Back to CodePipeline console, choose Save
Note: If You are not changing the BuildArtifact to SourceArtifact, you’ll run into some errors, make sure to edit the input artifacts to SourceArtifact as shown above.
Now, let's trigger the Pipeline by making a Changes in Respository.
1. For example, i'll open GitHub Respository, open `index.html` and edit the title by adding `in 2024` at the end of the title.
2. Then click Commit changes.
As you can see below the CI/CD CodePipeline, went through the Source > Build > Deploy stage successfully.
Once the deployment is successful, you can view the application by navigating to the Elastic Beanstalk environment URL as shown below.
## 💡 Conclusion
Building a CI/CD pipeline for a Node.js web application using AWS CI/CD services is a robust approach to streamline and automate the software development process. By leveraging tools such as AWS CodePipeline, AWS CodeBuild, and AWS CodeDeploy, you can ensure continuous integration and continuous delivery, enhancing the efficiency, reliability, and scalability of your application deployments.
This pipeline not only accelerates the development cycle but also minimizes manual intervention, reduces the risk of human error, and facilitates consistent, repeatable processes. Ultimately, integrating these AWS services into your CI/CD pipeline empowers your development team to deliver high-quality software faster and with greater confidence, paving the way for continuous innovation and improvement.
## 💰 Cost
All services used are eligible for the AWS Free Tier. However, charges will incur at some point so it's recommended that you shut down resources after completing this tutorial.