Deploying an Application to a Cloud Provider Using a CI-CD Pipeline

In modern software development, Continuous Integration and Continuous Deployment (CI/CD) pipelines play a pivotal role in automating code delivery processes, improving deployment efficiency, and minimizing human error. This article demonstrates how to deploy an application to a cloud provider using a CI/CD pipeline. We'll focus on deploying to AWS EC2 as the target environment.

Introduction to CI/CD Pipelines

A CI/CD pipeline automates the steps of integrating, building, testing, and deploying code changes to production environments. A well-structured pipeline ensures:

1. Faster and more reliable deployments.
2. Automated testing and error detection.
3. Consistency in application delivery.

For this article, the objective is to automate the deployment of a sample web application to AWS EC2 using Jenkins as the CI/CD tool.

Prerequisites

To successfully set up and deploy the application, the following prerequisites must be met:

1. Jenkins Setup:

   • Jenkins must be installed and running (locally or on a server).
   • Required plugins:
     • Pipeline
     • Git
     • SSH Agent

2. Cloud Environment:

   • An AWS EC2 instance created and accessible via SSH.
   • Necessary dependencies (e.g., Node.js, Python, or Docker) installed on the EC2 instance.

3. Application Code:

   • The repository should include build, test, and deployment scripts:
     • build.sh: Script to build the application.
     • test.sh: Script to run tests.
     • deploy.sh: Script to deploy the application.

4. Jenkins Credentials:

   • SSH key configured in Jenkins for accessing the EC2 instance.
   • AWS CLI configured on the Jenkins server for optional deployment methods.

Setting Up the CI/CD Pipeline

Below is a step-by-step guide to configure and automate the CI/CD pipeline:

Step 1: Create a New Pipeline Job in Jenkins

1. Open the Jenkins dashboard.
2. Click on New Item, enter the job name, and select Pipeline.
3. Click OK to create the pipeline job.

Step 2: Define the CI/CD Pipeline Script

Add the following script to the Pipeline section of your Jenkins job configuration:

pipeline { agent any environment { SSH_KEY = credentials('aws-ec2-key') // Replace with your SSH key ID in Jenkins EC2_USER = 'ec2-user' // Default username for Amazon Linux EC2_HOST = 'YOUR_EC2_PUBLIC_IP' // Replace with the EC2 instance public IP } stages { stage('Clone Repository') { steps { git 'https://github.com/your-repo/sample-app.git' // Replace with your repo URL } } stage('Install Dependencies') { steps { sh 'npm install' // Example for Node.js application } } stage('Build Application') { steps { sh './build.sh' // Build script } } stage('Run Tests') { steps { sh './test.sh' // Test script } } stage('Deploy to AWS EC2') { steps { sshagent(['aws-ec2-key']) { // Use SSH credentials stored in Jenkins sh ''' scp -o StrictHostKeyChecking=no -r ./build/ ${EC2_USER}@${EC2_HOST}:/var/www/html ssh -o StrictHostKeyChecking=no ${EC2_USER}@${EC2_HOST} "sudo systemctl restart nginx" ''' } } } } post { success { echo 'Deployment successful!' } failure { echo 'Deployment failed. Check logs for details.' } } } 

Explanation of Key Stages

1. Clone Repository:
   Pulls the latest code from the repository.

2. Install Dependencies:
   Installs required packages for the application (e.g., npm install for Node.js).

3. Build Application:
   Executes the build process, generating the application artifacts.

4. Run Tests:
   Runs automated tests to validate the application.

5. Deploy to AWS EC2:

   • Uses scp to transfer the build artifacts to the EC2 instance.
   • Restarts the web server (e.g., Nginx) to reflect the changes.

Optional Enhancements

1. Using AWS CLI for Deployment

Instead of manual SSH-based deployment, automate using the AWS CLI:

stage('Deploy to AWS EC2') { steps { sh ''' aws s3 cp ./build s3://your-app-bucket --recursive aws deploy create-deployment \ --application-name your-app-name \ --deployment-group-name your-deployment-group \ --s3-location bucket=your-app-bucket,key=build.zip,bundleType=zip ''' } } 

2. Manual Approval for Production Deployment

Add a manual approval step before deploying to production:

stage('Deploy to Production') { steps { input message: 'Deploy to production?' sh './deploy-production.sh' } } 

3. Artifact Archiving

Store build artifacts for future use:

post { success { archiveArtifacts artifacts: '**/build/*', fingerprint: true } } 

4. Docker Integration

Containerize the application using Docker and push the image to a container registry:

stage('Build Docker Image') { steps { sh 'docker build -t sample-app:latest .' sh 'docker push sample-app:latest' } } 

Testing and Validation

1. Trigger the Pipeline:
   Commit changes to the repository or manually trigger the pipeline from the Jenkins dashboard.

2. Verify Deployment:

   • Access the application using the EC2 instance's public IP or domain.
   • Check server logs for troubleshooting (e.g., /var/log/nginx/).

3. Monitor Performance:
   Use monitoring tools like AWS CloudWatch to observe application performance.

Outcome

By the end of this exercise, you will have:

• A fully functional CI/CD pipeline.
• Automated deployment to a cloud environment (AWS EC2).
• Improved development efficiency with reliable, consistent deployments.

Tasks

1. Set Up Jenkins: Install Jenkins and configure required plugins.
2. Prepare the Application: Ensure the repository contains build, test, and deployment scripts.
3. Deploy to AWS: Automate deployment to AWS EC2 using the provided pipeline script.
4. Enhance the Pipeline: Add optional features such as artifact archiving, Dockerization, or manual approval.
5. Monitor the Application: Validate the deployment and monitor performance.

With these steps, you’ll achieve a robust CI/CD pipeline capable of automating deployments to the cloud.

Happy Learning !!!