Jenkins Tutorial - A Beginner Guide

Agenda:

1. Introduction to Jenkins
2. Setting Up Jenkins
3. Jenkins Basics
4. Jenkins Pipeline
5. Advanced Jenkins Pipeline
6. Integrating Jenkins with Other Tools
7. Jenkins Plugins
8. Jenkins Administration
9. Jenkins Best Practices
10. Jenkins Troubleshooting

1. Introduction to Jenkins

What is Jenkins?

• Jenkins is an open-source automation server written in Java. It helps automate the parts of software development related to building, testing, and deploying, facilitating continuous integration and continuous delivery (CI/CD).

Key Features and Benefits:

• Extensible with plugins.
• Easy configuration via web interface.
• Support for distributed builds.
• Integration with various tools (SCM, build tools, testing frameworks).

Jenkins Architecture:

• Master: The central server that manages the build environment.
• Slave/Agent: Machines that perform the build tasks.

2. Setting Up Jenkins

Installation:

• Windows:

? Download the Jenkins installer from the official website.

? Run the installer and follow the setup instructions.

• Linux:

wget -q -O - https://pkg.jenkins.io/debian/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
sudo apt update
sudo apt install jenkins        

• macOS:

Initial Configuration:

• Access Jenkins through https://localhost:8080 .
• Unlock Jenkins using the initial admin password provided.
• Install suggested plugins.
• Create the first admin user.

User Interface Overview:

• Dashboard
• Manage Jenkins
• Job and Build History

3. Jenkins Basics

Creating Your First Job:

• Click on "New Item".
• Enter a name for the job and select "Freestyle project".
• Configure the job and save.

Freestyle Project vs Pipeline:

• Freestyle Project: Basic build job with a predefined set of steps.
• Pipeline: More complex and flexible, defined using a Jenkinsfile.

Running and Monitoring Jobs:

• Trigger builds manually or automatically (e.g., SCM change).
• Monitor build status, console output, and artifacts.

4. Jenkins Pipeline

Introduction to Jenkins Pipelines:

• Pipelines define a series of steps to be executed.
• Written using a domain-specific language (DSL).

Declarative vs Scripted Pipelines:

• Declarative: Simplified syntax, recommended for most users.
• Scripted: More flexible, using Groovy.

Creating a Simple Pipeline:

• Use the Blue Ocean interface or the classic UI.
• Define stages and steps in a Jenkinsfile.

Using the Jenkinsfile:

• Place the Jenkinsfile in the root of your repository.
• Example:

5. Advanced Jenkins Pipeline

Stages and Steps:

• Organize your pipeline into multiple stages.
• Define individual steps within each stage.

Parallel Execution:

• Run multiple stages or steps in parallel.
• Example:

Pipeline Libraries and Shared Libraries:

• Reuse common pipeline code across multiple projects.

Pipeline Syntax and Best Practices:

• Use descriptive stage names.
• Handle errors and retries.
• Use environment variables for configuration.

6. Integrating Jenkins with Other Tools

Source Code Management:

• Git : Configure Git repository in job settings.
• Subversion : Use the Subversion plugin to integrate with SVN.

Build Tools:

• Maven : Use the Maven integration plugin.
• Gradle : Use the Gradle integration plugin.

Testing and Code Quality Tools:

• JUnit : Publish JUnit test results.
• SonarQube : Integrate with SonarQube for code quality analysis.

Deployment Tools:

• Docker : Build and push Docker images.
• Kubernetes : Deploy applications to a Kubernetes cluster.

7. Jenkins Plugins

What are Jenkins Plugins?

• Plugins extend Jenkins functionality.

Installing and Managing Plugins:

• Go to "Manage Jenkins" -> "Manage Plugins".
• Browse and install desired plugins.

Must-Have Plugins:

• Git Plugin
• Pipeline Plugin
• Blue Ocean Plugin
• Credentials Plugin

Plugin Configuration and Use Cases:

• Configure each plugin as needed.
• Use plugins for SCM, build tools, testing, deployment, and more.

8. Jenkins Administration

Managing Jenkins Nodes and Executors:

• Configure master and slave nodes.
• Set up executors on nodes.

Securing Jenkins:

• Authentication: Use Jenkins user database or integrate with LDAP/AD.
• Authorization: Set permissions for users and groups.
• Backup and Restore: Use plugins or scripts for backup.

Monitoring and Maintaining Jenkins:

• Monitor system logs and job logs.
• Regularly update Jenkins and plugins.

9. Jenkins Best Practices

Optimizing Jenkins Performance:

• Use multiple nodes.
• Clean up old jobs and builds.
• Monitor resource usage.

Structuring Your Jobs and Pipelines:

• Use folders to organize jobs.
• Use pipeline libraries for shared code.

Managing Credentials Securely:

• Use the Credentials Plugin.
• Store credentials securely and use them in jobs.

Jenkinsfile Best Practices:

• Use version control for Jenkinsfiles.
• Keep Jenkinsfiles simple and readable.

10. Jenkins Troubleshooting

Common Issues and Solutions:

• Job failures, plugin issues, performance problems.

Debugging Jenkins Jobs and Pipelines:

• Use the console output.
• Add debug statements in the Jenkinsfile.

Using Logs and System Information:

• Check system logs (/var/log/jenkins/jenkins.log).
• Use the "Manage Jenkins" -> "System Information" page.

By following this agenda and detailed tutorial, you will gain a solid understanding of Jenkins, from basic setup and job creation to advanced pipeline configuration and integration with other tools.

Happy Learning !