Anas Ansari's Blog

Building and Deploying Applications with Jenkins CI/CD

Anas Ansari's photo
Anas Ansari
·

5 min read

Building and Deploying Applications with Jenkins CI/CD

What is CI/CD?

Continuous Integration (CI) and Continuous Deployment (CD) are essential practices in modern software development. They automate the integration of code changes and their deployment to production environments, ensuring a smooth, efficient, and reliable development process.

Continuous Integration (CI)

CI ensures that all developers' code changes are regularly merged into a central repository. This frequent integration helps catch and resolve conflicts and errors early, making the final product more stable and easier to maintain. Tools like Jenkins facilitate this by automatically building, testing, and reviewing the code with each integration.

Continuous Delivery (CD)

CD takes CI a step further by ensuring that the integrated code is always ready to be deployed into a production-like environment. This process automates the deployment of code, allowing for quick and safe releases. Continuous Delivery ensures that every change is thoroughly tested in a staging environment, mirroring the production environment to avoid surprises.

Continuous Deployment (CD)

Continuous Deployment is an extension of Continuous Delivery. It automates the entire process from code integration to deployment in production without any manual intervention. This means every change that passes the automated tests is immediately released to the customers, ensuring quick updates and fixes.

What is Build Job?

In Jenkins, a build job is a critical component of the CI pipeline. It automates the process of compiling source code, running tests, and generating artifacts (useful files). Here's what a typical build job involves:

  1. Source Code Retrieval: Fetching the latest code from a version control system like Git.

  2. Build Process: Compiling the code, packaging applications, or generating documentation.

  3. Testing: Running automated tests to ensure the code quality.

  4. Artifact Generation: Creating files such as binaries or deployment packages.

  5. Notifications: Informing team members about the build status.

  6. Logging and Reporting: Keeping detailed logs of the build process for troubleshooting and improvements.

What is Freestyle Project?

A Jenkins Freestyle Project is a versatile job that allows you to define a series of build steps and post-build actions. It offers flexibility to configure build triggers, security, and plugins to extend its functionality.

Create a Jenkins Project to Build and Run a Docker Container

  1. Create an Agent for Your App:

    • Ensure your Jenkins agent (machine with Docker installed) is set up.

  2. Create a New Jenkins Freestyle Project:

    • Go to the Jenkins dashboard and click "New Item."

    • Name the project (e.g., "MyAppDockerBuild") and select "Freestyle project."

  3. Configure the Build Steps:

    • Add a build step to run docker build -t myapp-image . to build the Docker image.

    • Add another step to run docker run -d --name myapp-container -p 8080:80 myapp-image to start the container.

  4. Save and Run the Build:

    • Save the configuration and trigger a build by clicking "Build Now."

Create a Jenkins Project to Manage Multiple Docker Containers Using Docker Compose

  1. Create a New Jenkins Freestyle Project:

    • Go to the Jenkins dashboard and click "New Item."

    • Name the project (e.g., "MyAppDockerCompose") and select "Freestyle project."

  2. Configure the Build Steps:

    • Add a build step to run docker-compose up -d to start the containers.

  3. Set Up Cleanup Step:

    • In the "Post-build Actions" section, add a step to run docker-compose down to stop and remove the containers.

  4. Save the Configuration and Trigger the Build:

    • Save the configuration and trigger a build by clicking "Build Now."

Jenkins CI/CD Project

Step 1: Connect Jenkins to GitHub

    • Open your Jenkins dashboard.

      • Go to your Jenkins job configuration (click on the job you want to configure, then click on "Configure").

      • Find the "Source Code Management" section and select "Git".

      • Enter your GitHub repository URL in the "Repository URL" field.

      • Save your changes by clicking "Save" or "Apply".

  2. Set Up GitHub Webhooks:

    • Go to your GitHub repository and click on "Settings".

    • In the left sidebar, select "Webhooks".

    • Click "Add webhook".

    • In the "Payload URL" field, enter the URL of your Jenkins server's webhook endpoint (you can find this URL in your Jenkins job's configuration under "Build Triggers").

    • Choose "application/json" as the content type.

    • Select the events you want to trigger the webhook (e.g., "Just the push event").

    • Click "Add webhook" to save.

  3. Verify CI/CD Setup:

    • Make a change to your code in the forked GitHub repository.

    • Push the changes to GitHub.

    • Check Jenkins to see if it automatically starts a build when you push changes. Ensure the build completes successfully.

Now your Jenkins job is connected to your GitHub repository via GitHub integration, and CI/CD is set up with GitHub Webhooks. You're all set to automate your CI/CD pipeline for the node-todo-cicd project!

  1. Create a Docker Compose File:

    • Open a text editor and create a new file named docker-compose.yml.

    • Define the services for your app. Here’s a basic example to get you started:

          version: '3.8'
    services:
      app:
        image: node:latest
        ports:
          - "3000:3000"
        volumes:
          - .:/app
        environment:
          - NODE_ENV=development
        command: npm start

    • Save the file in the root directory of your project.

  2. Run the Application:

    • Open a terminal and navigate to the directory where your docker-compose.yml file is located.

    • Run the command: docker-compose up -d. This command will start your application in the background.

  3. Verify Everything:

    • Open your web browser and go to localhost:3000 to see if your Node.js application is running properly.

Conclusion:

Implementing CI/CD practices with Jenkins significantly enhances the software development lifecycle by automating code integration, testing, and deployment processes. By setting up Jenkins projects to build and manage Docker containers, developers can ensure consistent and reliable application delivery. Integrating Jenkins with GitHub through webhooks further streamlines the workflow, enabling automatic builds and deployments upon code changes. This setup not only improves efficiency but also reduces the risk of errors, ensuring that applications are always in a deployable state. Embracing these practices leads to faster release cycles, higher quality software, and a more agile development process.

JenkinsCI/CD