What’s the difference between continuous integration, continuous delivery, and continuous deployment?
- Continuous Integration is the practice where developers merge the changes to the code base to the main branch as often as possible. These changes are validated by creating a build and then running automated tests against the build. If these tests don’t pass, the changes aren’t merged, and developers avoid integration challenges that can happen.
- Continuous Delivery is an extension of CI since it enables automation to deploy all the code changes to an environment (dev, qa, stage, prod, etc.) after the changes have been merged. Continuous delivery usually means a developer’s changes to an application are automatically bug tested and uploaded to a repository (like GitHub or a container registry), where they can then be deployed to a live production environment by the operations team.
- Continuous Deployment takes the process one step further than continuous delivery. Here, all changes that pass the verification steps at each stage in the pipeline are released to production. This process is completely automated and only a failed verification step will prevent pushing the changes to production.
Benefits of CI/CD

Benefits of Continuous Integration:
- This process causes fewer bugs to be shipped to production as the issues are caught early and integration issues are solved before release.

Building the release is easy as all integration issues have been solved early.

Benefits of Continuous Delivery:

You can release more often, thus accelerating the feedback loop with your customers.
There is much less pressure on decisions for small changes, hence encouraging iterating faster.

Benefits of Continuous Deployment:

You can develop faster as there's no need to pause development for releases. Deployments pipelines are triggered automatically for every change.
Releases are less risky and easier to fix in case of problem as you deploy small batches of changes.
Customers see a continuous stream of improvements, and quality increases every day, instead of every month, quarter or year.

What is Jenkins Pipeline?

A pipeline is typically divided into multiple stages and steps, with each step representing a single task and each stage grouping together similar steps. For example, you may have “Build”, “Test”, and “Deploy” stages in your pipeline. Jenkins Pipeline code is written in a Jenkinsfile.

A Jenkins pipeline includes all the tools you need to orchestrate code committing, building, testing, merging, packaging, shipping, and code deployment.
How do you configure the job in Jenkins?

To configure a job in Jenkins, follow these steps:
- Go to the Jenkins dashboard and click on “New Item” to create a new job.
- Enter a name for the job and select the appropriate job type (e.g., Freestyle project, Pipeline).
- Configure the job settings, such as SCM (Source Code Management), build triggers, build steps, post-build actions, and build environment.
- Save the job configuration.
Where do you find errors in Jenkins?

In Jenkins, you can find errors in several places:
- Console output: When a job is running or has been completed, you can view the console output, which displays the detailed log of the job execution. Errors and other messages will be visible in the console output.
- Build history: Jenkins keeps a record of previous builds for each job. You can navigate to the build history and click on a specific build to view its details, including any errors or failures.
- Jenkins logs: Jenkins generates logs that capture information about its operation. These logs can be accessed from the Jenkins server’s file system or through the Jenkins web interface.
In Jenkins how can you find log files?
- Jenkins system logs, including information about the Jenkins master and agents, are stored in the logs subdirectory of the Jenkins home directory. Look for files like jenkins.log or other log files with relevant timestamps.
- For each job, Jenkins creates log files that capture the console output of the job. You can find these logs in the job's workspace directory. The workspace directory is typically located within the Jenkins home directory, under the jobs directory.
Jenkins workflow and write a script for this workflow?

Jenkins Workflow, also known as Jenkins Pipeline, is a powerful feature that allows you to define complex, multi-step workflows as code. Here’s an example of a simple Jenkins workflow script:
```
 pipeline {
     agent any
     stages {
         stage('Build') {
             steps {
                 // Perform build steps here
             }
         }
         stage('Test') {
             steps {
                 // Perform testing steps here
             }
         }
         stage('Deploy') {
             steps {
                 // Perform deployment steps here
             }
         }
     }
 }
```
In this example, we define three stages: Build, Test, and Deploy. Each stage contains a series of steps that will be executed sequentially. You can customize the steps based on your specific build, test, and deployment requirements.
How to create continuous deployment in Jenkins?

To create a continuous deployment in Jenkins, you need to set up a Jenkins pipeline that includes the necessary steps for deploying your application. These steps typically involve building the application, running tests, packaging artifacts, and deploying them to the target environment. You can use various plugins and tools within Jenkins to achieve this, such as the Docker plugin, Kubernetes plugin, or deployment scripts specific to your deployment environment.
How to build a job in Jenkins?

To build a job in Jenkins, follow these steps:
- Go to the Jenkins dashboard and navigate to the job you want to build.
- Click on the job name to access the job’s details page.
- Click on the “Build Now” button to start a build of the job.
- Monitor the build progress through the build console output and job status.
- Once the build is completed, you can view the build results, including any test reports or artifacts generated during the build process.
Why we use pipeline in Jenkins?

Pipelines in Jenkins provide a powerful way to define, manage, and visualize complex software delivery workflows. Some key reasons for using pipelines include:
- Reproducibility: Pipelines allow you to define your entire delivery process as code, ensuring reproducibility and eliminating manual configuration errors.
- Visibility: Pipelines provide a clear visual representation of the entire software delivery workflow, making it easy to track the progress and identify bottlenecks.
- Scalability: With pipelines, you can scale your software delivery process by incorporating parallelism and distributed execution across multiple agents or nodes.
- Versioning and Collaboration: Pipelines can be version-controlled, enabling collaboration and allowing multiple developers to work on the pipeline definition simultaneously.
- Flexibility: Jenkins pipelines offer a wide range of plugins and integrations, allowing you to integrate with other tools and customize the pipeline according to your specific needs.
Is Only Jenkins enough for automation?

While Jenkins is a powerful tool for automation, it is not the only tool you might need in a complete automation ecosystem. Jenkins specializes in continuous integration and delivery, but for comprehensive automation, you may need to integrate it with other tools such as configuration management systems (e.g., Ansible, Chef), infrastructure-as-code tools (e.g., Terraform), testing frameworks, and monitoring systems. The choice of additional tools depends on the specific requirements and complexities of your automation environment.
How will you handle secrets?

Handling secrets securely in Jenkins is crucial to protect sensitive information such as passwords, API keys, and SSH credentials. Jenkins provides several mechanisms to handle secrets, including:
- Using the Jenkins Credentials plugin to store and manage secrets securely.
- Leveraging environment variables to pass secrets to build steps without exposing them in the Jenkins job configuration.
- Utilizing external secret management systems such as HashiCorp Vault or AWS Secrets Manager and integrating them with Jenkins through plugins.
Explain diff stages in CI-CD setup.

The stages in a typical CI/CD setup can vary depending on the specific requirements of the application and the organization. However, a common set of stages includes:
- Code Checkout: The first stage involves checking out the source code from the version control system, such as GitHub.
- Build: The code is then built, compiled, and packaged into an executable form.
- Test: The built code is then tested using various automated testing frameworks and tools to ensure that it meets the specified quality standards.
- Release: Releasing the software to end-users or customers, which may involve additional validation and approval processes.
- Deploy: The built and tested code is then deployed to the target environment, such as development, staging, or production.
Name some of the plugins in Jenkin?

Jenkins provides a vast ecosystem of plugins to extend its functionality. Some popular plugins include:
- Git Plugin: Integrates Jenkins with Git repositories for source code management.
- Maven Plugin: Enables Jenkins to build Maven project.
- SSH Plugin: It enables Jenkins server to connect with other servers via SSH. This is helpful for sending artifacts or Connecting agents.
- Role-based Authorization Strategy: It enables Jenkins to add a new role-based mechanism to manage users' permissions.
- Pipeline Plugin: Enables the creation and execution of Jenkins pipelines.
- Docker Plugin: Integrates Jenkins with Docker to build, test, and deploy applications in containers.
- SonarQube Plugin: Integrates Jenkins with SonarQube for code quality and static analysis.
- JUnit Plugin: Collects and reports JUnit test results in Jenkins.
- Email Extension Plugin: Extends Jenkins email notifications with customizable content.
- Blue Ocean Plugin: Provides a modern and intuitive user interface for Jenkins pipelines.

I hope you learned something from this blog. If you have, don’t forget to follow and click on like 🤍button below to show your support 😄. Subscribe to my blogs so that you won’t miss any future posts.

I Hope you find this article useful. If you have any questions or feedback, feel free to leave a comment below. Thanks for reading and have an amazing day ahead!

Stay connected on Linkedin

Day 29 of #90DaysOfDevOps

Subscribe to my newsletter

Basavaraj Teli

Basavaraj Teli