Demo Configure and Explore JCasC

Jenkins Configuration as Code (JCasC) lets you define Jenkins master and plugin settings in human-readable YAML. By treating configuration as declarative code you make Jenkins setups reproducible, auditable, and easier to automate across environments.

JCasC is ideal for automating Jenkins bootstrap and day‑to‑day configuration. Use YAML files to manage core settings, tool installations, credentials (via encrypted values), and many plugin configurations.

In this walkthrough you’ll:

Task	What you’ll learn
Install JCasC plugin	How to install and where to find the JCasC UI
Inspect effective configuration	How to view the generated YAML representing the running instance
Persist and apply YAML	Save a YAML file on the controller and point JCasC at it
Use JSON schema	Where to find the JCasC JSON schema and documentation

Install and open Configuration as Code

Install the Configuration as Code plugin from Manage Jenkins → Manage Plugins. Note: installing the plugin requires a Jenkins restart.
After restart, log back in and navigate to Manage Jenkins → Configuration as Code.

The Configuration as Code page allows you to:

View the effective configuration (a generated YAML file representing the current running instance).
Load or replace configuration from a local file, URL, or Git repository.
Download or reload the current configuration.
Access JCasC documentation and the JSON schema.

A screenshot of the Jenkins web UI on the "Download progress" plugins page, showing preparation steps and plugin install statuses (success/failure) for items like SnakeYAML, Prism API, and Configuration as Code. The left sidebar shows plugin navigation (Updates, Available plugins, Installed plugins) and a restart option is visible.

Inspect the effective configuration (YAML)

Click “View Configuration” (or equivalent) to generate the effective configuration YAML. It is a comprehensive document that maps Jenkins core and plugin settings to a declarative structure. Below are trimmed, representative excerpts to illustrate common sections. Example — global and UI-related settings:

providerFilter: "none"
typeFilter: "none"
appearance:
  pipelineGraphView:
    showGraphOnBuildPage: true
    showGraphOnJobPage: true
prism:
  theme: PRISM
themeManager:
  disableUserThemes: false
  theme: "darkSystem"
security:
  apiToken:
    creationOfLegacyTokenEnabled: false
    tokenGenerationOnCreationEnabled: false
    usageStatisticsEnabled: true
copyartifact:
  mode: PRODUCTION
cps:
  hideSandbox: false
githooks:
  allowedOnAgents: false
  allowedOnController: false
  gitHostKeyVerificationConfiguration:
    sshHostKeyVerificationStrategy: "knownHostsFileVerificationStrategy"
ssh:
  port: -1
unclassified:
  audit-trail:
    displayUserName: true
    logBuildCause: true
    logCredentialsUsage: true

Example — tool installations (Maven, Node.js, SonarQube scanner):

name: "Default"
maven:
  installations:
    - name: "M398"
      properties:
        - installSource:
            installers:
              - maven:
                  id: "3.9.8"
mavenGlobalConfig:
  globalSettingsProvider: "standard"
  settingsProvider: "standard"
nodejs:
  installations:
    - name: "nodejs-22-6-0"
      properties:
        - installSource:
            installers:
              - nodeJSInstaller:
                  id: "22.6.0"
  npmPackagesRefreshHours: 72
sonarRunnerInstallation:
  installations:
    - name: "sonarqube-scanner-610"
      properties:
        - installSource:
            installers:
              - sonarRunnerInstaller:
                  id: "6.1.0.4477"

Example — credentials section (sensitive values appear as encrypted/encoded strings):

credentials:
  system:
    domainCredentials:
    - credentials:
      - usernamePassword:
          description: "Gitea Server Credentials"
          id: "gitea-server-creds"
          password: "{AQAABAAAAAQ4e7WfYLRu0yZL9NsHsLaqohKKpJFtItDGTyKUsxqC0U=}"
          scope: GLOBAL
          username: "gitea-admin"
      - usernamePassword:
          description: "Credentials for MongoDB"
          id: "mongo-db-credentials"
          password: "{AQAABAAAAAQFPgIHj2LB26zTPKnU+rDyr/G7Vm9oaLUK8x8Rcp0iE0=}"
          scope: GLOBAL
          username: "superuser"
      - string:
          description: "Mongo Database Username"
          id: "mongo-db-username"
          scope: GLOBAL
          secret: "{AQAABAAAAAQF0khJH3hOKSatkFUUT2Y0YBQsY4d8tgCGOfp0B0k0=}"
      - string:
          description: "Mongo Database Password"
          id: "mongo-db-password"
          scope: GLOBAL
          secret: "{AQAABAAAAAQpXMp0KYcy2Hmc9hOVksHvChkKdK8C9zO7YLPCyZ30t64=}"
      - string:
          description: "Sonarqube Server Token"
          id: "sonar-qube-token"
          scope: GLOBAL

Notes about common top-level JCasC keys:

Key	Purpose
`credentials`	Stores system and domain credentials (sensitive values are encrypted).
`jenkins`	Core Jenkins settings such as system message, number of executors, labels.
`globalCredentialsConfiguration`	Additional global credentials configuration.
`appearance`	UI and theme settings for Jenkins.
`security`	Security-related configuration, including API token settings.
`unclassified`	Plugin-specific global configuration nodes exposed by many plugins.
`tools`	Tool installers and configuration (Maven, JDKs, NodeJS, etc.).

Never store plain-text secrets or private keys in a public repository. If you keep configuration files in Git, use a secrets manager or Jenkins credentials provider (and avoid committing the raw secret values).

Persist a JCasC YAML file on the controller and apply it

To have Jenkins load a persistent JCasC file from disk:

Choose a location accessible by the Jenkins process. Example:

/var/lib/jenkins/JENKINS_BACKUP

Create the YAML file and paste your JCasC content:

cd /var/lib/jenkins/JENKINS_BACKUP
vi jenkins-casc.yaml
# paste your YAML configuration and save

In Manage Jenkins → Configuration as Code, set the configuration path to the file you created (for example):

/var/lib/jenkins/JENKINS_BACKUP/jenkins-casc.yaml

Click “Apply new configuration”. JCasC will validate the YAML and report any validation errors. On success, the configuration is applied and the UI shows a timestamp and source path indicating where the config was loaded from.

After applying your file, refresh the Jenkins UI to confirm changes (system message, tool installations, plugin settings, etc.).

JSON schema and documentation

Official plugin page: https://plugins.jenkins.io/configuration-as-code/
Source and examples: https://github.com/jenkinsci/configuration-as-code-plugin

JCasC publishes a JSON schema useful for editor validation and tooling. Use the schema when authoring or validating complex configurations. Example (trimmed):

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "description": "Jenkins Configuration as Code",
  "type": "object",
  "properties": {
    "security": {
      "type": "object",
      "title": "Configuration base for the security classifier"
    }
  }
}

Consult the repository for the full schema and plugin-specific fragments to enable robust linting and IDE autocompletion.

Conclusion

Jenkins Configuration as Code simplifies managing Jenkins at scale. With JCasC you can:

Capture your running instance as YAML,
Persist reusable, versionable configuration files,
Apply configuration deterministically across controllers and environments.

Next steps: practice authoring smaller JCasC fragments for plugins you use, integrate JCasC files into your Git workflows, and adopt secrets management practices to keep credentials safe.

Introduction and Basics

Jenkins Setup and Interface

Extending Jenkins and Administration

Jenkins Pipelines

Automation and Security

Setting up CI Pipeline

Code Quality and Testing

Containerization and Deployment

Kubernetes and GitOps

AWS Lambda and Advanced Deployment Techniques

Jenkins Administration and Monitoring - Part 1

Shared Libraries in Jenkins

Agents and Nodes in Jenkins

Pipeline Enhancement and Caching

Pipeline Structure and Scripted vs Declarative

Jenkins Administration and Monitoring - Part 2

Backup and Configuration Management

Demo Configure and Explore JCasC

Install and open Configuration as Code

Inspect the effective configuration (YAML)

Persist a JCasC YAML file on the controller and apply it

JSON schema and documentation

Conclusion

Watch Video

​Install and open Configuration as Code

​Inspect the effective configuration (YAML)

​Persist a JCasC YAML file on the controller and apply it

​JSON schema and documentation

​Conclusion

Watch Video

Install and open Configuration as Code

Inspect the effective configuration (YAML)

Persist a JCasC YAML file on the controller and apply it

JSON schema and documentation

Conclusion