flash sale banner

HomeBlogDevOpsTop 10 Jenkins Plugins with Features for 2023

Top 10 Jenkins Plugins with Features for 2023

05th Sep, 2023
view count loader
Read it in
24 Mins
Top 10 Jenkins Plugins with Features for 2023

Jenkins plugins are one of the top reasons DevOps engineers use this platform for app development. A comprehensive list of 1,800+ plugins is available on Jenkins that equips it with additional features or functionalities you require in the software development life cycle (SDLC). Jenkins is a popular open-source platform that facilitates continuous integration (CI), continuous delivery (CD), and deployment. It enforces automation in app development and offers regular monitoring throughout the life cycle of a Jenkins build job.  

Any software development process comprises different phases, i.e., integration of new codes, testing, delivery, and deployment. These phases are called ‘CI/CD pipeline’ altogether. Jenkins enables you to harness the full potential of this pipeline, and its plugins extend its efficacy by integrating Jenkins with every tool present in the DevOps toolchain to ensure CI/CD.  

In simpler words, if you want to deliver software faster while maintaining excellent quality, Jenkins is the best CI/CD solution. 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 20 Jenkins plugins with features that are must-haves for app development. Have a look. If you want to learn about other advantages of Jenkins and how to use them for your project, sign up for Jenkins Full Course.  

What are Plugins in Jenkins?

Jenkins plugins 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 plugins 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. However, always check the build version of the plugin you’re downloading and only download the latest one. The update center contains all the plugins created and maintained by the Jenkins developers’ community. 

There are dedicated plugins available to meet different project requirements. For example, if you want to integrate Jira, you need to find the dedicated Jenkins plugin available for that. On the other hand, for tools like Maven, you need to install a respective plugin. 

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 10 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 it out now.  

1. 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 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/

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 11, 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 11 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. 

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. 

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.


That’s all. 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. For further information, check the FAQs section or post your query in the comment section.

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