Jenkins

https://www.jenkins.io/doc/book/
Admin
Jenkins is an open-source automation server that enables developers to build, test, and deploy...
Tokens:259,813
Snippets:2,270
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start a local Jenkins instance

Source: https://www.jenkins.io/doc/book/managing/script-console

Starts a local Jenkins instance for testing Script Console examples. Sets JENKINS_HOME to a local directory and launches the Jenkins WAR file. Use CTRL+C to stop Jenkins; running Script Console examples on a production Jenkins controller is not recommended.

```shell
export JENKINS_HOME="./my_jenkins_home"
java -jar jenkins.war
```

--------------------------------

### Helm install output

Source: https://www.jenkins.io/doc/book/installing/kubernetes

Example output from the helm install command showing the release name, deployment timestamp, namespace, status, and revision.

```bash
NAME: jenkins
LAST DEPLOYED: Wed Sep 16 11:13:10 2020
NAMESPACE: jenkins
STATUS: deployed
REVISION: 1
```

--------------------------------

### Start Docker Compose services

Source: https://www.jenkins.io/doc/book/installing/docker

Starts the Docker Compose services defined in the example. The init container imports certificates from the custom-certs directory before Jenkins starts.

```bash
docker compose up -d
```

--------------------------------

### Jenkins initial setup log output

Source: https://www.jenkins.io/doc/book/installing/kubernetes

Example output from the Jenkins pod logs showing the initial setup message and the generated admin password. The password is a long alphanumeric string (e.g., 94b73ef6578c4b4692a157f768b2cfef) and is also stored at /var/jenkins_home/secrets/initialAdminPassword.

```text
*************************************************************
*************************************************************
*************************************************************

Jenkins initial setup is required.
An admin user has been created and a password generated.
Please use the following password to proceed to installation:

94b73ef6578c4b4692a157f768b2cfef

This may also be found at:
/var/jenkins_home/secrets/initialAdminPassword

*************************************************************
*************************************************************
*************************************************************
```

--------------------------------

### Start Jenkins with --prefix command line argument

Source: https://www.jenkins.io/doc/book/system-administration/reverse-proxy-configuration-troubleshooting/index.html

Use the --prefix argument to set the context path when starting Jenkins from the command line, as shown in the example for a reverse proxy forwarding to /foobar.

```bash
java -jar jenkins.war --prefix=/foobar
```

--------------------------------

### Expected java -version Output

Source: https://www.jenkins.io/doc/book/installing/linux

Example output of java -version after a successful OpenJDK 21 installation on Debian/Ubuntu.

```bash
openjdk 21.0.8 2025-07-15
OpenJDK Runtime Environment (build 21.0.8+9-Debian-1)
OpenJDK 64-Bit Server VM (build 21.0.8+9-Debian-1, mixed mode, sharing)
```

--------------------------------

### Example Task Scheduler command with real values

Source: https://www.jenkins.io/doc/book/managing/nodes

Example command with actual paths and values for the Windows Task Scheduler. Uses a full path to agent.jar and example Jenkins URL, secret, and agent name.

```java
java \
    -jar D:\Scripts\jenkins\agent.jar \
    -url http://jenkinshost.example.com \
    -secret d6a84df1fc4f45ddc9c6ab34b08f13391983ffffffffffb3488b7d5ac77fbc7 \
    -name buildNode1
```

--------------------------------

### Start Jenkins service

Source: https://www.jenkins.io/doc/book/installing/linux

Starts the Jenkins service.

```bash
sudo systemctl start jenkins
```

--------------------------------

### Install Jenkins from RPM repository

Source: https://www.jenkins.io/doc/book/installing/linux

Add the Jenkins repository and install Jenkins with its dependencies using yum.

```bash
sudo wget -O /etc/yum.repos.d/jenkins.repo \
    https://pkg.jenkins.io/rpm/jenkins.repo
sudo rpm --import https://pkg.jenkins.io/rpm/jenkins.io-2023.key
sudo yum upgrade
# Add required dependencies for the jenkins package
sudo yum install fontconfig java-21-openjdk
sudo yum install jenkins
```

--------------------------------

### Install Jenkins with Helm

Source: https://www.jenkins.io/doc/book/installing/kubernetes

Run the helm install command with the jenkins-values.yaml override file to deploy Jenkins in the jenkins namespace.

```bash
chart=jenkinsci/jenkins
helm install jenkins -n jenkins -f jenkins-values.yaml $chart
```

--------------------------------

### Show Jenkins WAR file help

Source: https://www.jenkins.io/doc/book/installing/war-file

Displays help for command line arguments that can adjust Jenkins startup.

```bash
java -jar jenkins.war --help
```

--------------------------------

### Install and enable Jenkins on OpenIndiana Hipster

Source: https://www.jenkins.io/doc/book/installing/other

Installs the Jenkins package and enables the SMF service. The packaging creates a 'jenkins' user, sets up the service to listen on port 8080, and logs to /var/svc/log/network-http:jenkins.log.

```bash
pkg install jenkins
svcadm enable jenkins
```

--------------------------------

### Install a plugin with the Jenkins CLI install-plugin command

Source: https://www.jenkins.io/doc/book/managing/plugins

Use the Jenkins CLI to install a plugin from a local file, URL, or update center. The command supports -deploy to install immediately, -name to override the short name, and -restart to restart Jenkins after success. The second block is the CLI help output describing the SOURCE argument and options.

```bash
java -jar jenkins-cli.jar -s http://localhost:8080/ install-plugin SOURCE ... [-deploy] [-name VAL] [-restart]

```

```text
Installs a plugin either from a file, an URL, or from update center.

 SOURCE    : If this points to a local file, that file will be installed. If
             this is an URL, Jenkins downloads the URL and installs that as a
             plugin.Otherwise the name is assumed to be the short name of the
             plugin in the existing update center (like "findbugs"),and the
             plugin will be installed from the update center.
 -deploy   : Deploy plugins right away without postponing them until the reboot.
 -name VAL : If specified, the plugin will be installed as this short name
             (whereas normally the name is inferred from the source name
             automatically).
 -restart  : Restart Jenkins upon successful installation.

```

--------------------------------

### Run Jenkins WAR file

Source: https://www.jenkins.io/doc/book/installing/war-file

Starts Jenkins from the WAR file. By default, Jenkins listens on port 8080 and does not install any plugins automatically.

```bash
java -jar jenkins.war
```

--------------------------------

### Show build command help and trigger a build

Source: https://www.jenkins.io/doc/book/managing/cli

The first block shows the help output for the build command, including its options. The second block triggers a build with -f and -v, following the build progress and printing console output.

```shell
% ssh -l kohsuke -p 53801 localhost help build

java -jar jenkins-cli.jar build JOB [-c] [-f] [-p] [-r N] [-s] [-v] [-w]
Starts a build, and optionally waits for a completion.  Aside from general
scripting use, this command can be used to invoke another job from within a
build of one job.  With the -s option, this command changes the exit code based
on the outcome of the build (exit code 0 indicates a success) and interrupting
the command will interrupt the job.  With the -f option, this command changes
the exit code based on the outcome of the build (exit code 0 indicates a
success) however, unlike -s, interrupting the command will not interrupt the
job (exit code 125 indicates the command was interrupted).  With the -c option,
a build will only run if there has been an SCM change.
 JOB : Name of the job to build
 -c  : Check for SCM changes before starting the build, and if there's no
       change, exit without doing a build
 -f  : Follow the build progress. Like -s only interrupts are not passed
       through to the build.
 -p  : Specify the build parameters in the key=value format.
 -s  : Wait until the completion/abortion of the command. Interrupts are passed
       through to the build.
 -v  : Prints out the console output of the build. Use with -s
 -w  : Wait until the start of the command
% ssh -l kohsuke -p 53801 localhost build build-all-software -f -v
Started build-all-software #1
Started from command line by admin
Building in workspace /tmp/jenkins/workspace/build-all-software
[build-all-software] /bin/sh -xe /tmp/hudson1100603797526301795.sh
+ echo hello world
hello world
Finished: SUCCESS
Completed build-all-software #1 : SUCCESS
%

```

--------------------------------

### quietPeriod option example

Source: https://www.jenkins.io/doc/book/pipeline/syntax

Set the quiet period in seconds for the Pipeline, overriding the global default. Use this option to control the delay before a build starts.

```groovy
options { quietPeriod(30) }
```

--------------------------------

### Create Jenkins deployment with kubectl apply

Source: https://www.jenkins.io/doc/book/installing/kubernetes

Creates the Jenkins deployment from the manifest file jenkins-03-deployment.yaml.

```bash
kubectl apply -f jenkins-03-deployment.yaml
```

--------------------------------

### Run Jenkins WAR file with custom port

Source: https://www.jenkins.io/doc/book/installing/war-file

Starts Jenkins on a custom port by specifying the --httpPort option. This example makes Jenkins accessible through port 9090.

```bash
java -jar jenkins.war --httpPort=9090
```

--------------------------------

### disableConcurrentBuilds option examples

Source: https://www.jenkins.io/doc/book/pipeline/syntax

Disallow concurrent executions of the Pipeline. Use the first form to queue a build when another is executing, and the second form to abort the running build and start a new one.

```groovy
options { disableConcurrentBuilds() }
```

```groovy
options { disableConcurrentBuilds(abortPrevious: true) }
```

--------------------------------

### List all available metrics using Jenkins Metrics Plugin

Source: https://www.jenkins.io/doc/book/scaling/architecting-for-manageability

Run this Groovy script on the Jenkins script console to get a full list of available metrics for your controller. The exact list varies depending on installed plugins.

```groovy
for (j in Jenkins.instance.getExtensionList(jenkins.metrics.api.MetricProvider.class)) {
     for (m in j.getMetricSet()) {
          for (i in m.metrics)
               { println i.getKey() }
     }
}
```

--------------------------------

### Enable debug logging with logging.properties

Source: https://www.jenkins.io/doc/book/system-administration/viewing-logs/index.html

Example `logging.properties` file for enabling debug logging in Jenkins. Set the system property `-Djava.util.logging.config.file=<pathTo>/logging.properties` when starting the JVM. The default level is INFO; debug logging is not advised for production.

```properties
handlers = java.util.logging.ConsoleHandler

# see https://docs.oracle.com/en/java/javase/17/docs/api/java.logging/java/util/logging/SimpleFormatter.html
java.util.logging.SimpleFormatter.format = [%1$tF %1$tT][%4$-6s][%2$s] %5$s %6$s %n

# Keep this level to ALL or FINEST or it will be filtered before applying other levels
java.util.logging.ConsoleHandler.level = ALL

# Default level
.level= INFO

# High verbosity for a dedicated package com.myplugin.*
com.myplugin.level = ALL
```

--------------------------------

### Jenkins systemd override.conf example with JAVA_OPTS, JENKINS_OPTS, and CASC_JENKINS_CONFIG

Source: https://www.jenkins.io/doc/book/system-administration/systemd-services/index.html

Example content for the Jenkins systemd drop-in unit (override.conf). Customizations must be placed in a [Service] section to take effect. The file only contains customizations, not the original defaults, and is not overwritten on upgrades. Note that the drop-in unit does not perform shell expansion.

```ini
[Unit]
Description=My Company Jenkins Controller

[Service]
# Add JVM configuration options
Environment="JAVA_OPTS=-Djava.awt.headless=true -XX:+UseStringDeduplication"

# Arbitrary additional arguments to pass to Jenkins.
# Full option list: java -jar jenkins.war --help
Environment="JENKINS_OPTS=--prefix=/jenkins --javaHome=/opt/jdk-21"

# Configuration as code directory
Environment="CASC_JENKINS_CONFIG=/var/lib/jenkins/configuration-as-code/"
```

--------------------------------

### Declarative Pipeline with secret file credential

Source: https://www.jenkins.io/doc/book/pipeline/jenkinsfile

Declarative Pipeline using a secret file credential named 'my-kubeconfig'. The credentials() method assigns the path to a temporary file to the MY_KUBECONFIG environment variable. The example uses it with kubectl to get pods.

```groovy
pipeline {
    agent {
        // Define agent details here
    }
    environment {
        // The MY_KUBECONFIG environment variable will be assigned the value of a temporary file.
        // For example:
        //   /home/user/.jenkins/workspace/cred_test@tmp/secretFiles/546a5cf3-9b56-4165-a0fd-19e2afe6b31f/kubeconfig.txt
        MY_KUBECONFIG = credentials('my-kubeconfig')
    }
    stages {
        stage('Example stage 1') {
            steps {
                sh("kubectl --kubeconfig $MY_KUBECONFIG get pods")
            }
        }
    }
}
```

--------------------------------

### Declarative Pipeline parameters example

Source: https://www.jenkins.io/doc/book/pipeline/syntax

Declares five parameter types (string, text, booleanParam, choice, password) and accesses their values via the params object. The first choice value is the default. Parameter values are exported as environment variables when the build starts.

```groovy
pipeline {
    agent any
    parameters {
        string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')

        text(name: 'BIOGRAPHY', defaultValue: '', description: 'Enter some information about the person')

        booleanParam(name: 'TOGGLE', defaultValue: true, description: 'Toggle this value')

        choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')

        password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'Enter a password')
    }
    stages {
        stage('Example') {
            steps {
                echo "Hello ${params.PERSON}"

                echo "Biography: ${params.BIOGRAPHY}"

                echo "Toggle: ${params.TOGGLE}"

                echo "Choice: ${params.CHOICE}"

                echo "Password: ${params.PASSWORD}"
            }
        }
    }
}
```

--------------------------------

### Java httpclient 4.3.x example for preemptive authentication

Source: https://www.jenkins.io/doc/book/system-administration/authenticating-scripted-clients

Uses Apache HttpClient 4.3.x to issue authentication preemptively. Sets up credentials provider and auth cache with BasicScheme, then executes a GET request with the auth cache in the context. Returns the response entity as a string.

```java
import java.io.IOException;
import java.net.URI;

import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class JenkinsScraper {

    public String scrape(String urlString, String username, String password)
        throws ClientProtocolException, IOException {
        URI uri = URI.create(urlString);
        HttpHost host = new HttpHost(uri.getHost(), uri.getPort(), uri.getScheme());
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(new AuthScope(uri.getHost(), uri.getPort()),
            new UsernamePasswordCredentials(username, password));
        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate BASIC scheme object and add it to the local auth cache
        BasicScheme basicAuth = new BasicScheme();
        authCache.put(host, basicAuth);
        CloseableHttpClient httpClient =
            HttpClients.custom().setDefaultCredentialsProvider(credsProvider).build();
        HttpGet httpGet = new HttpGet(uri);
        // Add AuthCache to the execution context
        HttpClientContext localContext = HttpClientContext.create();
        localContext.setAuthCache(authCache);

        HttpResponse response = httpClient.execute(host, httpGet, localContext);

        return EntityUtils.toString(response.getEntity());
    }

}

```

--------------------------------

### Build and push Docker image with docker.build() and push()

Source: https://www.jenkins.io/doc/book/pipeline/docker

Builds a Docker image and publishes it to Docker Hub or a custom registry using the push() method.

```groovy
node {
    checkout scm
    def customImage = docker.build("my-image:${env.BUILD_ID}")
    customImage.push()
}

```

--------------------------------

### Import certificate response with keytool -import

Source: https://www.jenkins.io/doc/book/installing/initial-settings

Imports the certificate response (a .p7b bundle) into the keystore. The output confirms that the certificate reply was installed.

```text
C:\>keytool -import ^
-alias jenkins ^
-trustcacerts ^
-file response_from_digicert.p7b ^
-keystore keystore
Enter keystore password:
Certificate reply was installed in keystore
```

--------------------------------

### Perl LWP example to trigger Jenkins job with token

Source: https://www.jenkins.io/doc/book/system-administration/authenticating-scripted-clients

Uses LWP to start a Jenkins job via a 'Trigger builds remotely' token. Sets authorization_basic on the request object for BASIC HTTP authorization, which handles preemptive authentication. Prints the response status and headers, and indicates success or failure.

```perl
#
# Use LWP to run a Jenkins job
# set authorization_basic on the request object
# to make use of BASIC HTTP authorization, apparently
# already handling the preemptive part correctly this
# way.
#
use strict;
use warnings;

use LWP;

my $server = 'srvname';
my $srvurl = "http://$server/jenkins";
my $uagent = LWP::UserAgent->new;
my $req = HTTP::Request->new(
  GET => "$srvurl/job/test/build?token=theTokenConfiguredForThisJob&cause=LWP+Test"
);
$req->authorization_basic('username@mydomain.com', 'apiToken');
my $res = $uagent->request($req);

# Check the outcome of the response
print "Result: " . $res->status_line . "\n";
print $res->headers->as_string;
print "\n";
if (!$res->is_success) {
  print "Failed\n";
}
else {
  print "Success!\n";
  # print $res->content, "\n";
}

```

--------------------------------

### Docker Compose with init container for custom CA certificates

Source: https://www.jenkins.io/doc/book/installing/docker

Docker Compose setup that uses an init container to copy the system truststore and import custom CA certificates before Jenkins starts. The Jenkins container mounts the prepared truststore read-only and sets JAVA_OPTS to use it. Requires a custom-certs directory with .crt or .pem files.

```yaml
services:
  # Init container: prepares truststore with custom CA certificates
  cert-init:
    image: jenkins/jenkins:lts-jdk21
    user: root
    volumes:
      - ./custom-certs:/certs:ro
      - jenkins-cacerts:/cacerts-volume
    command: >
      bash -c '
        cp "$${JAVA_HOME}/lib/security/cacerts" /cacerts-volume/cacerts &&
        for cert in /certs/*.crt /certs/*.pem; do
          [ -f "$$cert" ] || continue;
          alias="custom-$$(basename "$${cert%.*}")";
          "$${JAVA_HOME}/bin/keytool" -importcert -noprompt \
            -keystore /cacerts-volume/cacerts \
            -storepass changeit \
            -alias "$$alias" \
            -file "$$cert" || true;
        done &&
        echo "Custom CA certificates imported successfully"
      '

  # Main Jenkins container
  jenkins:
    image: jenkins/jenkins:lts-jdk21
    depends_on:
      cert-init:
        condition: service_completed_successfully
    restart: on-failure
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - jenkins_home:/var/jenkins_home
      - jenkins-cacerts:/cacerts:ro
    environment:
      JAVA_OPTS: "-Djavax.net.ssl.trustStore=/cacerts/cacerts -Djavax.net.ssl.trustStorePassword=changeit"

volumes:
  jenkins_home:
  jenkins-cacerts:
```
Tokens:
Raw