In this exercise, you will learn how to deploy an application to a production environment using a CI/CD pipeline. This exercise will cover the following steps:

1. Setting Up the Production Environment
2. Configuring the Deployment Pipeline
3. Deploying the Application
4. Verifying the Deployment

Before deploying an application, you need to set up the production environment. This typically involves provisioning servers, configuring network settings, and ensuring that all necessary software dependencies are installed.

1. Provision an EC2 Instance:

   • Log in to the AWS Management Console.
   • Navigate to the EC2 Dashboard.
   • Click on "Launch Instance."
   • Choose an Amazon Machine Image (AMI), such as Amazon Linux 2.
   • Select an instance type (e.g., t2.micro for small applications).
   • Configure instance details, add storage, and configure security groups.
   • Review and launch the instance.

2. Install Necessary Software:

   • Connect to the EC2 instance using SSH.
   • Update the package manager and install necessary software (e.g., Nginx, Node.js).

   sudo yum update -y
   sudo yum install -y nginx
   sudo amazon-linux-extras install -y nodejs
   

3. Configure Network Settings:

   • Ensure that the security group allows HTTP/HTTPS traffic.
   • Configure Nginx to serve your application.

   sudo systemctl start nginx
   sudo systemctl enable nginx
   

Next, you need to configure your CI/CD pipeline to deploy the application to the production environment. This involves setting up a deployment job in your CI/CD tool.

1. Create a New Jenkins Job:

   • Open Jenkins and click on "New Item."
   • Enter a name for the job and select "Pipeline."
   • Click "OK."

2. Configure the Pipeline Script:

   • In the job configuration, scroll down to the "Pipeline" section.
   • Select "Pipeline script" and enter the following script:

   pipeline {
       agent any
   
       stages {
           stage('Build') {
               steps {
                   sh 'npm install'
                   sh 'npm run build'
               }
           }
           stage('Test') {
               steps {
                   sh 'npm test'
               }
           }
           stage('Deploy') {
               steps {
                   sshagent(['your-ssh-credentials-id']) {
                       sh '''
                       scp -r ./build/* ec2-user@your-ec2-instance-public-dns:/var/www/html/
                       ssh ec2-user@your-ec2-instance-public-dns 'sudo systemctl restart nginx'
                       '''
                   }
               }
           }
       }
   }
   

Once the pipeline is configured, you can trigger a deployment by running the pipeline. This will build, test, and deploy your application to the production environment.

1. Trigger the Pipeline:

   • Go to the Jenkins job you created.
   • Click on "Build Now."

2. Monitor the Pipeline:

   • Click on the build number to view the build details.
   • Monitor the console output to ensure that each stage completes successfully.

After the deployment is complete, you need to verify that the application is running correctly in the production environment.

1. Access the Application:

   • Open a web browser and navigate to the public DNS of your EC2 instance.

2. Check Application Functionality:

   • Verify that the application loads correctly.
   • Test key features to ensure they are working as expected.

• Incorrect SSH Configuration: Ensure that your SSH credentials are correctly configured in Jenkins and that the EC2 instance allows SSH access.
• Firewall Issues: Verify that the security group for your EC2 instance allows HTTP/HTTPS traffic.
• Application Errors: Check the application logs on the EC2 instance if the application does not work as expected.

In this exercise, you learned how to deploy an application to a production environment using a CI/CD pipeline. You set up a production server, configured a deployment pipeline in Jenkins, deployed the application, and verified the deployment. This process is crucial for ensuring that your application is reliably and consistently delivered to end-users.