HomeBlogDevOpsTop 20 Jenkins Plugins with Features for 2024

Top 20 Jenkins Plugins with Features for 2024

20th Jun, 2024
view count loader
Read it in
24 Mins
In this article
    Top 20 Jenkins Plugins with Features for 2024

    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. 

    What are Jenkin Plugins?

    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.  

    Top 20 Jenkins Plugins and Their Features

    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: 

    1. Git Plugin
    2. Kubernetes Plugin
    3. Jira Plugin
    4. Docker Plugin
    5. Maven Integration Plugin
    6. Blue Ocean Plugin
    7. Amazon EC2 Plugin
    8. Pipeline Plugin
    9. SonarQuobe
    10. Metrics Plugin
    11. Azure Container Service
    12. Dashboard View
    13. Performance Publisher
    14. Job DSL
    15. Disk-Usage
    16. Subversion
    17. SCM API
    18. JUnit
    19. Test Results Analyzer
    20. Build Pipeline

    1. Git Plugin

    Git Plugin

    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: 

    • The Git plugin performs fundamental Git operations like polling, branching, merging, fetching, tagging, listing, and pushing repositories. 
    • It helps you to schedule your builds and automatically triggers each build after each commit.  
    • The Git plugin adds the functionality and flexibility any DevOps engineer will require for better project delivery.  
    • This plugin allows you to access GitHub as a Source Code Management (SCM) system. 
    • Link: https://plugins.jenkins.io/git/ 

    2. Kubernetes Plugin

    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: 

    • This plugin integrates Jenkins with Kubernetes. 
    • With this plugin, you can automatically scale the running process of Jenkins agents in the Kubernetes environment.  
    • It creates individual Kubernetes Pods for each agent on the Docker image.  
    • The Kubernetes plugin also terminates the Kubernetes Pods automatically once you finish the build.  
    • Link: https://plugins.jenkins.io/kubernetes/ 

    3. Jira Plugin

    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 Jira plugin enables you to get better visibility into the development pipeline. 
    • You can display the builds inside Jira with this plugin. 
    • It also automatically sends development and build-related data from Jenkins to Jira. 
    • Above all, this Jira plugin can help you track Jira issues inside Jenkins.  
    • Link: https://plugins.jenkins.io/jira/ 

    4. Docker Plugin

    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: 

    • The Docker plugin enables you to create Docker containers and automatically run builds on them.  
    • It is a cloud implementation, so you need to add Docker as a new cloud type on Jenkins. 
    • You can run Jenkins agent runtime with a Docker image 
    • Docker Swarm Standalone is available to run multiple docker hosts as Jenkins nodes. 
    • Link: https://plugins.jenkins.io/docker-plugin/ 

    5. Maven Integration Plugin

    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: 

    • Automated report add-on installation. 
    • Disseminate and take in snapshots and have them instantly activate other processes. 
    • Modules are built in parallel on several Jenkins nodes or executors. 
    • The automatic post-build binary deployment when the project passes all the necessary checks. 
    • Link: https://plugins.jenkins.io/maven-plugin/ 

    6. Blue Ocean Plugin

    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: 

    • Offers an easy understanding of the current phase of a software development cycle thanks to its sophisticated visualizations of CD pipelines. 
    • The Blue Ocean UI highlights exactly which pipeline stage needs your attention for better exception handling and production. 
    • Allows you to create a pipeline with the pipeline editor. 
    • It includes built-in features like branching and pulling requests, making it easier for developers to work on codes with others and save development time. 
    • Link: https://plugins.jenkins.io/blueocean/ 

    7. Amazon EC2 Plugin

    Amazon EC2 plugin
    Doyle Wilson - Medium 

    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: 

    • Using the EC2 plugin, you can meet high build and test demands with a small in-house cluster. 
    • Comes with the Amazon IAM feature that lets you create a separate account for Jenkins. 
    • Offers strong strategies to ensure that the instances you have connected to are the expected ones. This keeps your builds safe from the man-in-the-middle attack. 
    • Link: https://plugins.jenkins.io/ec2/ 

    8. Pipeline Plugin

    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 

    • The Pipeline plugin comes integrated with SCM. 
    • It lets you build your pipeline definition script. 
    • It helps teams to easily monitor which parts of the build pipeline are running and which are still in the queue. 
    • With the Pipeline plugin, you can check historical changes, audit and perform code reviews. 
    • Link: https://plugins.jenkins.io/workflow-aggregator/ 

    9. SonarQuobe


    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:

    • It's easy to integrate and manage on Jenkins. 
    • Offers necessary security feedback at the time of code review. 
    • Allows navigating any problem from the vulnerability source to the code location quickly. 
    • Link: https://plugins.jenkins.io/sonar/#documentation 

    10. Metrics Plugin

    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: 

    • A MetricsRegistry class container that saves all your Jenkins applications metrics. 
    • Offers Histograms to measure all the statistical distribution values in the data stream. 
    • The metrics-healthchecks module lets you centralize your services' health checks. 
    • Link: https://plugins.jenkins.io/metrics/

    11. Azure Container Service 

    Azure Container Service
    Microsoft Azure 

    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. 

    12. Dashboard View 

    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. 

    13. Performance Publisher 

    Performance Publisher plugin

    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. 

    14. Job DSL 

    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. 

    15. Disk-Usage 

    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. 

    16. Subversion 

    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. 

    17. SCM API 

    SCM API plugin

    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. 

    18. JUnit 

    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. 

    19. Test Results Analyzer 

    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. 

    20. Build Pipeline 

    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. 

    How to Get a Plugin for Jenkins?

    Jenkins plugin download involves a few steps and is pretty easy to follow through. Here is how to install plugin in Jenkins, 

    • First, log in to Jenkins and open the Jenkins Dashboard. 
    • Now, on the left menu bar, click on the Manage Jenkins option. 
    • Then, under the Manage Jenkins window, select the Manage Plugins button. 
    • Next, click on the Available tab above and search for the plugin you are looking for in the search box beside the Filter option. 
    • Now, from the search result, select the plugin and click on the Install without restart button below. 
    • Finally, select the Go back to the top page link once the installation is done. 

    Jenkins Plugin Development

    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. 

    1. Preparing for Plugin Development

    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, 

    • First, go to the Apache Maven website to download Maven. Make sure you download one of the binary archives. 
    • Then extract Maven and remember the location where you are extracting the file.  
    • Now, extract the Maven files directly into the destination directory (e.g., C:Program Files (x86)Maven) rather than extracting them elsewhere and then copying them. 
    • Add the extracted bin/ subdirectory's complete path (such as /Applications/apache-maven/bin or C:Program filesMavenbin) to the operating system's PATH environment variable. If you do this, you'll be able to use the mvn command to launch Maven. 
    • For the rest of this guide we will presume that Maven is already installed and is accessible through the PATH variable. 
    • Enter the following command to ensure Maven is properly installed: mvn -version 

    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.  


    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. 

    • Select Create from archetype and then Add an archetype to develop a Maven project.  
    • Then choose the GroupId and ArtifactId as before and select the RELEASE as version option.  
    • On the next page choose io.jenkins.plugins as the groupID and provide a suitable artifactId (Project name) and Version. 
    • A new maven project will be generated from the given artifact (e.g., empty-plugin). 


    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.

    2. Create a Plugin

    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: 

    1. remote -> io.jenkins.archetypes:empty-plugin (Skeleton of a Jenkins plugin with a POM and an empty source tree.) 
    2. remote -> io.jenkins.archetypes:global-configuration-plugin (Skeleton of a Jenkins plugin with a POM and an example piece of global configuration.) 
    3. remote -> io.jenkins.archetypes:global-shared-library (Uses the Jenkins Pipeline Unit mock library to test the usage of a Global Shared Library) 
    4. remote -> io.jenkins.archetypes:hello-world-plugin (Skeleton of a Jenkins plugin with a POM and an example build step.) 
    5. remote -> io.jenkins.archetypes:scripted-pipeline (Uses the Jenkins Pipeline Unit mock library to test the logic inside a Pipeline script.) 

    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  
    • At the first step, put the number 4 for the hello-world-plugin archetype. 
    • Since we have prepared this guide based on the hello-world-plugin archetype version 1.14 you need to enter 14 to select it. 
    • groupID is different for different projects thus you can find a specific project using the groupID. A groupID needs to comply with the Java package name rule. It will start with a reversed domain name. e.g. io.jeckins.plugins 
    • artifactId is also mandatory and lets you find your plugin in Jenkins. It is an unique name for the basic artifact that gets created by the particular Maven project. 

    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. 

    • Once you add all the values Maven will reflect them all over again. Review them again and confirm your selection. 
    • Once you follow all the steps it will create a directory with the same plugin artifactId. Also, it adds the basic structure for a plugin that works. 
    $ mv demo demo-plugin  
    $ cd demo-plugin 
    $ mvn verify 
    • Now Maven will create the project structure within a directory as per the name you choose for your plugin. We are going to rename it to match the usual repository name for GitHub @jenkinsci 
    • After this Maven will download some other dependencies and follow through the already configured build lifecycle. It will also run some tests and static analysis till it shows something like below: 
    [INFO] ------------------------------------------------------------------------ 
    [INFO] ------------------------------------------------------------------------ 
    [INFO] Total time: 47.141 s 
    [INFO] Finished at: 2022-10-01T14:04:29-07:00 
    [INFO] ------------------------------------------------------------------------ 

    3. Build and Run the Plugin

    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.  

    • INFO: Jenkins is fully up and running 
    • Then, build a new freestyle project and add a name to it. 
    • Next enter the "Say hello world" build step. It will be similar to the following image.
    • Now, you need to put a name in the assigned box and save the project. You can start a new build after that. 
    • Then, go to the build on the user interface and select Console Output to check the build log. It will show a message containing the just configured build step: 

    Started by user anonymous 

    Building in workspace /Users/mrjenkins/demo/work/workspace/testjob 

    Hello, Jenkins!  

    Finished: SUCCESS

    4. Extend the Plugin

    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. 

    • Don't just note down the name used in the greeting in the build log; instead, create a suitable data structure to keep track of it. 
    • Add a new page to the build that contains the name used in the greeting. 
    • Since the configuration can be updated at any time, it is crucial that we record the name that was in use throughout the build's execution. 

    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. 

    package io.jenkins.plugins.sample; 
    import hudson.model.Action; 
    public class HelloWorldAction implements Action { 
    public String getIconFileName() { 
    return null; 
    public String getDisplayName() { 
    return null; 
    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. 

    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 + "!"); 
    • Once done save the changes and run the plugin again. Use the following command for that, 
    mvn hpi:run
    • After that, while running the build with the build step this action will be entered in the build data. 

    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. 

    <hudson.model.CauseAction> *1 
    <io.jenkins.plugins.sample.HelloWorldAction plugin="demo@1.0-SNAPSHOT"> *2 
    <name>Jenkins</name> *3 

    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: 

    public String getIconFileName() { 
    return "document.png";  
    public String getDisplayName() { 
    return "Greeting";  
    public String getUrlName() { 
    return "greeting";  
    • As you make the above changes the action will reflect in the side panel of the build. The link to the URL: 


    • Then, you need to define the page that opens as you follow the URL. This type of views on Jenkins are made with Apache Commons Jelly since it lets you define XML and XHTML output in XML. 
    • Now, in the src/main/resources/io/jenkins/plugins/sample/ directory create a new directory named HelloworldAction/. This directory is correlated to the HelloWorldAction class and also has related resources. 
    • In the next step create a file as index.jelly in the directory src/main/resources/io/jenkins/plugins/sample/HelloWorldAction/
    • It will be showed at URL \http://JENKINS/job/JOBNAME/BUILDNUMBER/greeting/ 
    • Then add the code written bellow, 
    <?jelly escape-by-default='true'?> 
    <j:jelly xmlns:j="jelly:core" xmlns:l="/lib/layout" xmlns:st="jelly:stapler"> 
    <l:layout title="Greeting">  
    Name: ${it.name}  

    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;  
    public void onAttached(Run<?, ?> run) { 
    this.run = run;  
    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"> 
    <st:include page="sidepanel.jelly" it="${it.run}" optional="true" />  

    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. 

    Troubleshooting Jenkins Plugins Installation

    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. 

    1. Jenkins plugin shows problem while initializing

    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. 

    2. The Plugin cannot be found

    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.  

    Frequently Asked Questions (FAQs)

    1How do I get a list of Jenkins plugins?

    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, 

    • Open the Jenkins dashboard and from the left menu bar, click on the Manage Jenkins button. 
    • Then, scroll down and select Manage Plugins. 
    • Now, as the Jenkins Plugin Manager window opens, click on the Installed button to find the list of installed plugins. 
    • Also, you can select the Available tab to check the list of plugins available for installation. 
    2What are the default plugins installed in Jenkins?

    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: 

    1. Folders 
    2. Structs 
    3. OWASP Markup Formatter 
    4. Token Macro 
    5. Pipeline: Step API 
    6. Build Timeout 
    7. Trilead API 
    8. Credentials 
    9. Plain Credentials 
    10. SSH Credentials 
    11. Credentials Binding 
    12. Pipeline: API 
    13. SCM API 
    14. Timestamp 
    15. Script Security 
    16. Matrix Project 
    17. JUnit 
    18. Resource Disposer 
    19. Pipeline: Supporting APIs 
    20. Workspace Cleanup 
    21. Pipeline: Nodes and Processes 
    22. Ant 
    23. Pipeline: SCM Step 
    24. Pipeline: Groovy 
    25. Durable Task 
    26. Pipeline: Job 
    27. Display URL API 
    28. Pipeline: Basic Steps 
    29. Mailer 
    30. Gradle 
    31. Pipeline: Milestone Step 
    32. Jackson 2 API 
    33. Snakeyaml API 
    34. Pipeline: Input Step 
    35. Pipeline Graph Analysis 
    36. Pipeline: Stage Step 
    37. Pipeline: REST API 
    38. Pipeline: Build Step 
    39. Pipeline: Stage View 
    40. Pipeline: Model API 
    41. Pipeline: Declarative Extension Points API 
    42. Git client 
    43. JSch dependency 
    44. GIT server 
    45. Pipeline: Shared Groovy Libraries 
    46. Branch API 
    47. Pipeline: Multibranch 
    48. Pipeline: Stage Tags Metadata 
    49. Lockable Resources 
    50. Pipeline: Declarative 
    51. Pipeline 
    52. GitHub API 
    53. OkHttp 
    54. Git 
    55. GitHub 
    56. GitHub Branch Source 
    57. Pipeline: GitHub Groovy Libraries 
    58. SSH Build Agents 
    59. Subversion 
    60. Matrix Authorization Strategy 
    61. PAM Authentication 
    62. Email Extension 
    63. LDAP 
    3How do I manage Jenkins plugins?

    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. 


    Srijani Ghosh


    Srijani is a science graduate from the University of Calcutta. She believes in read-learn-share-repeat. Her keen interest in technology and passion for writing has brought her into this field. She has more than 4 years of experience working as a technical writer. Always open to new experiences.

    Share This Article
    Ready to Master the Skills that Drive Your Career?

    Avail your free 1:1 mentorship session.

    Your Message (Optional)

    Upcoming DevOps Batches & Dates

    NameDateFeeKnow more
    Course advisor icon
    Course Advisor
    Whatsapp/Chat icon