Jenkins plugins for DevOps are one of the top reasons DevOps engineers use this platform for app development. Plugins are available on Jenkins that equips it with additional features or functionalities you require in the SDLC. Jenkins is a popular open-source platform that facilitates CI/CD and deployment. It enforces automation in app development and offers regular monitoring throughout the life cycle of a Jenkins build job.
Jenkins plugins extend its efficacy by integrating Jenkins with every tool present in the DevOps toolchain to ensure CI/CD. But its vast collection of plugins may confuse any beginner, as you never know which plugin will suit your project until you’re testing each. Since it’s a tedious job, we’ve curated this list of the top Jenkins plugins with features.
Jenkins plugins in DevOps are the main components that allow you to customize a Jenkins environment in a way that meets the unique requirements of a company or individual user. More than 1,800 plugins are available to install on Jenkins to integrate different build tools, analytic tools, and other cloud providers. These Jenkin plugins example cover everything from managing the source code to app administration, platform support, determining UI/UX, and building management.
You can install plugins in Jenkins and their dependencies from the update center. For a DevOps engineer, it’s important to have complete knowledge of the most-used plugins. Only then can you deliver apps faster. Best DevOps training processes help you learn everything.
As mentioned, 1800+ free Jenkins plugins are available in the Jenkins plugin repository, and each performs different tasks. Here we’ve mentioned a list of mostly-used plugins with their features. Check out the list:
Git is one of the most installed Jenkins add-ons available on its repository. It allows you to integrate Jenkins with GitHub and transfer GitHub repository data to the Jenkins machine easily. The key features of this plugin are listed below:
Kubernetes is another widely used plugin in Jenkins. It allows you to run all the dynamic agents in a Kubernetes cluster. This plugin creates a Kubernetes Pod for each agent getting started and stopped once the build is finished. You can find a plethora of advanced features of this plugin, such as:
The Jira plugin integrates Jenkins with Atlassian Jira Software. You can work with both the Cloud and Server versions with this Jenkins plugin. But you need to use a Jira service account instead of a Jira personal account to install this plugin. This plugin comes with the below features:
The Jenkins cloud plugin for Docker is the most effective solution for DevOps engineers to integrate Jenkins with Docker. It allows you to dynamically provision the Docker containers and run those as Jenkins agent nodes. Its notable features are:
Jenkins has native Maven support, although you may need deeper integration if you use it. This Jenkins plugin is available independently and offers greater Jenkins integration for Apache Maven projects. Some of the more sophisticated features of the plugin are:
According to the Blue Ocean functionalities, Jenkins' interface was recently updated. Blue Ocean, designed in tandem with Jenkins Pipeline and compatible with the Freestyle jobs, provides you with several useful features, such as:
Amazon EC2 plugin lets Jenkins start up new EC2 or Eucalyptus agents on demand and shut them down when they are no longer needed.
If your build cluster becomes overcrowded, this plugin will launch EC2 instances and configure those as Jenkins agents. Unused EC2 instances will be stopped when the load decreases. Some of the most useful features of Amazon EC2 plugins include the following:
The Jenkins 2.0 version came with the Jenkins Pipeline plugin. It's an extremely useful tool for DevOps teams. A pipeline is, in fact, a collection of plugins that are used to make pipelines for continuous integration.
The plugin allows you to script the build pipeline available for one or multiple build jobs present in a single workflow. This helps the team to check all the upstream and downstream connected jobs in a single view. Thus, it becomes much easier to define manual triggers for jobs that need further intervention before execution. Some of the best features that can define the Pipeline Plugin are
SonarQuobe is an open-source tool used for continuous code quality inspection. The Jenkins monitoring plugin allows you to integrate SonarQube into Jenkins so that you can easily analyze a code while running a Jenkins job that comes with SonarQuobe execution. Developers can use this plugin to identify vulnerabilities, bugs, and the possibility of duplication while building codes on the Jenkins automation server. Some of the best features of this plugin include the following:
Metrics is a Java library that offers a toolkit to measure the performance metrics of the critical components in your production environment. The Metrics Jenkins plugin exhibits the same API of Metrics as all the other Jenkins plugins. It offers additional metrics through columns in Jenkins' list view.
Metrics are available as a Dropwizard Metrics API, which offers health check contracts. It comes with a simple return message that shows the PASS/FAIL status with an optional message. The key features of the Metrics plugin on Jenkins include:
The Azure Container Service plugin seamlessly integrates Jenkins with Azure Kubernetes Service (AKS) and Azure Container Instances (ACI). This plugin is indispensable for teams leveraging Azure's cloud infrastructure, offering scalable and reliable container management.
Integration: Connects Jenkins with Azure Kubernetes Service (AKS) and Azure Container Instances (ACI).
Functionality: Enables direct deployment to AKS or ACI from Jenkins.
Benefits: Simplifies container management and deployment orchestration in Azure, providing seamless continuous delivery and integration with Azure's container services.
The Dashboard View plugin is essential for teams requiring a comprehensive overview of their Jenkins jobs. Teams can craft multiple dashboards tailored to different projects or teams, concisely and clearly visualize job performance and health, and facilitate quick issue identification and CI/CD pipeline monitoring.
Purpose: Provides a consolidated view of Jenkins jobs.
Functionality: Allows creation of customized dashboards displaying job status, trends, and other critical metrics.
Benefits: Multiple dashboards tailored to different projects or teams offer a clear overview of job statuses, helping to quickly identify issues and monitor the CI/CD pipeline's overall health.
The Performance Publisher plugin is pivotal for teams conducting performance testing. By visualizing performance trends, teams can make informed decisions to optimize their applications effectively.
Integration: Works with performance testing tools like JMeter and Gatling.
Functionality: Collects and displays performance test reports.
Benefits: Identifies performance bottlenecks and ensures the application meets performance requirements before production, aiding in informed decision-making to optimize applications.
The Job DSL plugin offers a powerful mechanism to automate the creation and maintenance of Jenkins jobs. It enables jobs to be defined as code, allowing for version control and easy replication across different environments. This plugin is ideal for teams practicing Infrastructure as Code (IaC), ensuring consistent job configurations and simplifying the management of complex job setups.
Purpose: Automates the creation and maintenance of Jenkins jobs.
Functionality: Uses a Groovy-based DSL (Domain Specific Language) to define jobs as code.
Benefits: Facilitates version control, easier replication of job configurations across environments, and simplifies managing complex job setups, aligning with Infrastructure as Code (IaC) practices.
The Disk-Usage plugin is crucial for managing disk space consumed by Jenkins jobs and builds. It provides detailed reports on disk usage for each job, workspace, and build artifact.
Purpose: Manages disk space used by Jenkins jobs and builds.
Functionality: Provides detailed reports on disk usage for each job, workspace, and build artifact.
Benefits: Essential for maintaining the Jenkins server's health, especially in environments with limited disk space, by identifying excessive disk usage and enabling proactive cleanup.
Integration: Connects Jenkins with Subversion, a popular version control system.
Functionality: Pulls code from Subversion repositories, triggers builds based on code changes, and tags builds.
Benefits: Offers robust support for Subversion features, ensuring seamless CI/CD pipeline automation for teams using Subversion.
The SCM API plugin provides a unified API for integrating various source control management (SCM) systems with Jenkins. It supports multiple SCM systems, including Git, Subversion, and Mercurial, by abstracting their differences. This standardization is critical for teams using multiple SCM systems or transitioning from one to another, ensuring smooth plugin interactions with different SCM systems.
The JUnit plugin is essential for processing and reporting test results generated by JUnit, a prevalent testing framework for Java applications. It parses test result files, generates detailed reports, and visualizes test trends. This plugin aids in tracking test failures, identifying flaky tests, and maintaining code quality through continuous testing, thus supporting high standards of software quality.
Purpose: Provides advanced visualization of test results in Jenkins.
Functionality: Aggregates test data from multiple builds and displays it in a user-friendly format, highlighting trends and anomalies.
Benefits: Beneficial for teams running extensive test suites, helping to quickly identify test regressions and understand overall test coverage and reliability.
The Build Pipeline plugin is critical for visualizing and managing complex build workflows in Jenkins. It allows users to define and visualize sequences of interconnected jobs representing various stages of the build pipeline. This plugin offers a clear view of the entire build process, from code commits to deployment, helping track progress and status at each stage. By visualizing dependencies and execution order, teams can optimize their CI/CD pipelines for smooth and efficient build processes.
Jenkins plugin download involves a few steps and is pretty easy to follow through. Here is how to install plugin in Jenkins,
With its powerful plugin system, Jenkins allows you to create plugins to control all the aspects of Jenkins's behavior. Jenkins plugins can be expanded in several different ways; some of the more obvious ones include source code management implementations. It allows Jenkins to interact with source code management systems like Git, Subversion, or Perforce. Thus developers can build step implementations to create features like a graphical user interface for configuring build tools and email notifications.
Here we have discussed the steps you can follow to create Jenkins plugins.
Step 1: Download and install a Java Development Kit
Jenkins is built on Java. Thus, to build a Jenkins plugin, you need to install a Java Development Kit on your system. The latest version of Java, i.e., Java 21, is recommended. We will also use the same reference here in this guide.
Step 2: Download and install Maven
To build Jenkins plugins, you need to install Jenkins build automation tool. Maven is the most popular one that Java developers use for Java projects. Not only use Java, but you can also use Maven to build and manage C#, Scala, and Ruby projects. Follow the steps below to download and install Maven,
With this command, you will get details such as the current Java and Maven versions. Jenkins setup requires the latest Java version. Thus, you need to verify whether Java 21 is installed and provide a path to the installation directory.
Step 3: Set up a productive environment with your IDE
There are several integrated development environments available that you can choose from depending on the nature of your project or the type of Jenkins plugin you are trying to develop.
NetBeans
Thanks to the included support for the Maven framework as NetBeans user you can simply open the project in the IDE and begin working with it.
While navigating through the code you can command NetBeans to attach the source code JAR files while you browse the code. Select the "Attach" button at the top of the main content window.
It will let you check the Jenkins source code while developing the plugins.
The NetBeans plugin is recommended for Jenkins/Stapler development. This has numerous functions that are exclusive to Jenkins. Follow the path to create a new plugin in Jenkins,
New Project » Maven » Jenkins Plugin followed by Run Project to test your plugin.
IntelliJ IDEA
Any developer with IntelliJ installed can just launch the project and run it without any further Jenkins configuration. That's why the IntelliJ IDEA plugin is recommended for Jenkins Development. You can find its features in the plugin's documentation. Each of Jenkins' pre-existing plugin types can serve as a starting point for your own custom plugin.
Eclipse
Eclipse is an open source integrated development environment for Java developers. While developing Jenkins in continuation of the above step you can o[pen the project in Eclipse as an existing Maven project.
Once you prepare the environment it's time to create a new plugin. Here are the steps you need to perform under this section, Build the Project Layout using Sample Plugin Archetype
Go to the directory you want to save the Jenkins plugin from the Command Prompt and run the following command:
mvn -U archetype:generate -Dfilter="io.jenkins.archetypes:"
The above command will let you create multiple Jenkins related project archetypes. Here we have used the hello-world archetype. Thus, for reference you need to select the same.
$ mvn -U archetype:generate -Dfilter="io.jenkins.archetypes:" …
Choose archetype:
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 4
Choose io.jenkins.archetypes:hello-world-plugin version:
1: 1.1
2: 1.2
3: 1.3
4: 1.4
5: 1.5
6: 1.6
7: 1.7
8: 1.8
9: 1.9
10: 1.10
11: 1.11
12: 1.12
13: 1.13
14: 1.14
Choose a number: 14: 14
…
[INFO] Using property: groupId = unused [INFO] Using property: package = io.jenkins.plugins.sample [INFO] Using property: hostOnJenkinsGitHub = true Define value for property 'artifactId': demo Define value for property 'version' 1.0-SNAPSHOT: : Confirm properties configuration: groupId: unused package: io.jenkins.plugins.sample hostOnJenkinsGitHub: true artifactId: demo version: 1.0-SNAPSHOT Y: : y
Here in this guide we have used the name demo.
However, if you are willing to publish your plugin then you have to ensure a unique name for it. It must not be taken before by anyone else, and make sure the name is future-proof. You can't change the artifactId once you publish your first release. You must not use words such as plugins or Jenkins in the ID. A better name describes the nature of the plugin or how it works.
You don't need to use a different version number now since you are just starting by default it will be Version 1.0 of the development version.
$ mv demo demo-plugin $ cd demo-plugin $ mvn verify
[INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------ [INFO] Total time: 47.141 s [INFO] Finished at: 2022-10-01T14:04:29-07:00 [INFO] ------------------------------------------------------------------------
You need to use the Maven HPI plugin on Jenkins to build and package any new plugins. Maven also offers an easy way to run a Jenkins instance through the following command,
mvn hpi:run
It will create a Jenkins instance on http://localhost:8080/jenkins/. You need to wait for the output and then open a browser and check what the particular plugin you built does.
Started by user anonymous
Building in workspace /Users/mrjenkins/demo/work/workspace/testjob
Hello, Jenkins!
Finished: SUCCESS
You can follow this step on a simple text editor. However, it will be easier to work on this using a Java IDE with Maven support. By following these steps you can extend the plugin and add new features to it.
Record the name
Initially, create a new class named HelloWorldAction within the same repository as HelloWorldBuilder. That class has to implement an Action.
A fundamental component of Jenkins's extensibility is actions, which may be associated with and stored alongside a wide variety of model objects and, if desired, added to the UI of those items.
.png&w=3840&q=75)
.png&w=3840&q=75)
.png&w=3840&q=75)
package io.jenkins.plugins.sample;
import hudson.model.Action;
public class HelloWorldAction implements Action {
@Override
public String getIconFileName() {
return null;
}
@Override
public String getDisplayName() {
return null;
}
@Override
public String getUrlName() {
return null;
}
} If you want to store the name we have already used in the greeting, you need to add a field that is greater to this class. Then, add a constructor that takes the name as an argument.
(...)
public class HelloWorldAction implements Action {
private String name;
public HelloWorldAction(String name) {
this.name = name;
}
public String getName() {
return name;
}
(...) Now, you must create an instance of this class while executing the build steps. Also, you will have to extend the perform steps in the HelloWorldBuilder class to put an instance of the action that is created for the build that is running.
(...)
@Override
public void perform(Run<?, ?> run, FilePath workspace, Launcher launcher, TaskListener listener) throws InterruptedException, IOException {
run.addAction(new HelloWorldAction(name));
if (useFrench) {
listener.getLogger().println("Bonjour, " + name + "!");
} else {
listener.getLogger().println("Hello, " + name + "!");
}
}
(...) mvn hpi:run
However, you can always check and confirm it simply from the build.xml file related to the build in the directory work/jobs/JOBNAME/builds/BUILDNUMBER/.
If you check the following build, there are two actions. One that suggests the build causes that are also stored as actions. Here an anonymous user has started the build.
And the second one is the action we created, it's the name that we have used while creating the build.
<build> <actions> <hudson.model.CauseAction> *1 <causes> <hudson.model.Cause_-UserIdCause/> </causes> </hudson.model.CauseAction> <io.jenkins.plugins.sample.HelloWorldAction plugin="demo@1.0-SNAPSHOT"> *2 <name>Jenkins</name> *3 </io.jenkins.plugins.sample.HelloWorldAction> </actions> (...) </build>
Now that you have recorded the name it's time to add a view that reflects the name. Follow the further steps mentioned in this section.
Add a view that shows the name
First go back to the HelloWorldAction and define an icon, URL name and title:
@Override
public String getIconFileName() {
return "document.png";
}
@Override
public String getDisplayName() {
return "Greeting";
}
@Override
public String getUrlName() {
return "greeting";
} \http://JENKINS/job/JOBNAME/BUILDNUMBER/greeting/.
<?jelly escape-by-default='true'?>
<j:jelly xmlns:j="jelly:core" xmlns:l="/lib/layout" xmlns:st="jelly:stapler">
<l:layout title="Greeting">
<l:main-panel>
<h1>
Name: ${it.name}
</h1>
</l:main-panel>
</l:layout>
</j:jelly> The page will look like the following image.
Now that we have added a view for the build it's time to put it in the side-panel. Follow the steps further and get the job done.
Add the side panel for the build
The above output does not contain a side panel view. We can simply get a reference for the particular build in action and then include it to the build's side panel view.
To get a reference for the Run that the HelloWorldAction comes from, you have to alter the present class and let it proceed with RunAction2. The interface includes two processes one is onAttached(Run) and the other is onLoad(Run).
(...)
import hudson.model.Run;
import jenkins.model.RunAction2;
public class HelloWorldAction implements RunAction2 {
private transient Run run;
@Override
public void onAttached(Run<?, ?> run) {
this.run = run;
}
@Override
public void onLoad(Run<?, ?> run) {
this.run = run;
}
public Run getRun() {
return run;
}
(...) After its done you have to extend the view to add the side panel view fragment of the build:
(...)
<l:layout title="Greeting">
<l:side-panel>
<st:include page="sidepanel.jelly" it="${it.run}" optional="true" />
</l:side-panel>
<l:main-panel>
(...)
</l:main-panel>
</l:layout>
(...) Once you make the changes the view integrates with the Jenkins user interface and appears the same as the other built-in pages related to the builds.
Now you have created and extended a Jenkins plugin successfully.
However, if you still find it difficult to build a Jenkins plugin after skimming through this guide, KnowledgeHut Jenkins Full Course will help you understand the process better.
While Jenkins installs plugins, you might face certain instances when you have issues with the installation. Depending on the nature of the problem, several error messages are shown. Here are a few common installation errors you may encounter while installing Jenkins plugins.
There might be two primary explanations for this problem. (1) The plugin is incompatible with an older version of Jenkins. (2) due to firewall or network issues. In both cases, the most up-to-date versions of Jenkins and the plugin proxy source will need to be downloaded and updated, respectively.
The reason for this problem can be the same as the above. If you are receiving this error message while searching a specific plugin then you can download it from the official website for the Jenkins plugins https://plugins.jenkins.io/. Once it's downloaded you can manually upload it and install it on Jenkins.
We have covered the top 20 Jenkins plugins that you can use in 2024. From building tools and version control to cloud integrations you will get a plugin to streamline nearly every aspect of your software delivery pipeline. We also have covered the installation process that will help you sett-up the plugins. Now you have all the required information about the Jenkins Plugins.
Also, following the plugin-building methods, you can create your plugin and publish it. If you want to learn about other advantages of Jenkins and how to use them for your project, sign up for Jenkins Full Course.
You can have the whole list of Jenkins plugins that are installed on your system from the Manage Jenkins tab under the Jenkins dashboard. Follow the steps below to check the complete list of Jenkins plugins available on your system,
While installing Jenkins, if you have skipped the default plugin install page, you need to do that manually after installing Jenkins. Here is the list of the default Jenkins plugins you need to install for Jenkins version 2.60.3:
You can manage Jenkins Plugins from the Jenkins Dashboard. Under the Jenkins Dashboard, click on the Manage Jenkins tab. Then, open the Manage Plugins button to manage Jenkins plugins.
| Name | Date | Fee | Know more |
|---|
