Introduction
IntroductionPre-installation requirementsInstallVerify Docker imagesUninstall
IntroductionPre-installation requirementsInstallVerify Docker imagesUninstall
IntroductionPre-installation requirementsInstallVerify Docker imagesUninstall
IntroductionPre-installation requirementsInstallVerify Docker imagesUninstall
IntroductionPre-installation requirementsInstallVerify Docker imagesUninstall
IntroductionPre-installation requirementsInstallVerify Docker imagesUninstall
IntroductionSystem requirementsVerify Docker imagesInstall operations centerInstall client controllersVerify build componentsVerify WAR files
IntroductionHA fundamentalsGet ready for HAInstall HA on modern cloud platformsInstall HA on traditional platformsHA considerationsHigh Availability (active/passive) installation for CloudBees CI on traditional platforms
IntroductionWhat is FIPS and FIPS 140 compliance?Install CloudBees CI on modern cloud platforms in FIPS modeCAP plugin support in a FIPS 140-3 environmentConfigure the Apache™ Ant plugin for FIPS complianceConfigure the Pipeline Maven API plugin for FIPS complianceKnown FIPS incompatibilities with CloudBees CI on modern cloud platformsJenkins core: FIPS 140-3 compliant artifacts with caveatsJenkins core: Non-compliant classes and libraries
Introduction
IntroductionPipeline termsPipeline project typesCloudBees Pipeline benefits
IntroductionUsing Pipeline development utilitiesDetermining plugin compatibilityPipeline best practices
IntroductionPrerequisitesCreating your first PipelineSelecting agentsCreating Pipelines in SCMCreating Pipelines in Web UIUsing Pipeline as Code
IntroductionConfig Adv ScriptedConfig Build StageConfig Deploy StageConfig Optional Step ArgsConfig Test StageCreating JenkinsfileCustomizing ParametersHandling FailuresString InterpolationUsing Multiple AgentsWorking With The EnvReusing Configuration Files
IntroductionManaging artifactsTracing artifactsTriggering jobs with a simple webhookRestoring filesVisualizing PipelineInserting checkpointsSecuring PipelinesConfiguring Pipelines with user-scoped credentialsUsing Pipeline PoliciesSpecifying a matrix of one or more dimensionsConverting a Freestyle project to a Declarative PipelinePipeline builds and HA (active/active)
IntroductionRestarting aborted buildsLong-running buildsSkip next buildConsolidated Build View pluginCloudBees Quiet Start pluginCloudBees Template pluginCloudBees Workspace Caching
IntroductionTrigger a job with a notification event using Cross Team CollaborationEnable external notification events with external HTTP endpointsCluster-wide copy artifactsCluster-wide job triggers
IntroductionSetting up a Pipeline Template CatalogDefining Pipeline Template CatalogsSetting Up A Pipeline TemplateUsing parameters in template.yamlManaging multibranch Pipeline options in template.yamlManaging Pipeline Template Catalogs in bulkExample full Maven/Java app Jenkinsfile
IntroductionUsing Declarative Pipeline syntaxUsing Scripted Pipeline syntax
IntroductionBranch SourceBitbucketGitHubGitBranch Property StrategyExamples
CloudBees Docker Build and Publish pluginCloudBees Docker TraceabilityDocker Pipeline pluginCloudBees Docker Hub/Registry Notification plugin
Introduction
Introduction
IntroductionGet startedNavigate the operations center interfaceProvision managed controllers in multiple Kubernetes clustersProvision agents in a separate Kubernetes cluster from a managed controllerProvision a controller in a different namespaceProvision a controller in a different OpenShift project than the operations centerManage controllersManage controllers in specific Kubernetes namespacesMigrate an existing managed controller to High Availability (HA)Manage agentsManage SSH credentialsShared agentsShared configurationsShared cloud configurationTrigger restrictionsChange NFS storage locationQuiet startMove/Copy/PromoteCluster operationsInbound agentsUse Kaniko with CloudBees CIUse Buildkit with CloudBees CIUsing self-signed certificates in CloudBees CI on KubernetesSidecar injector for self-signed certificates on OpenShiftAuto-scale nodes on EKSEnable auto-scaling nodes on GKECloudBees Amazon Web Services Deploy EngineAWS CLI pluginCloud Foundry CLI PluginIntegrate OpenShift CLICloudBees CI ServiceNow integrationCreate projects based on a GitHub repository structureUse GitHub App authenticationCreate Multibranch Projects and Organization Folders with large repositoriesWikiText pluginController Lifecycle Notifications Plugin
IntroductionGet startedNavigate the operations center interfaceManage client controllersMigrate from High Availability (active/passive) to High Availability (active/active) on CloudBees CI on traditional platformsManaging agentsManage SSH credentialsShared agentsShared configurationsShared cloud configurationTrigger restrictionsQuiet startMove/Copy/PromoteCluster operationsInbound agentsCloudBees CI ServiceNow integrationCreate projects based on a GitHub repository structureUse GitHub App authenticationCreate Multibranch Projects and Organization Folders with large repositoriesWikiText plugin
Introduction
Trust model
Pod Security Admission
Centrally manage security for controllers
CyberArk Credential Provider Plugin
CloudBees HashiCorp Vault Plugin
Enable advanced use cases: Cross-controller triggers and bulk operations
Restrict access and delegate administration with Role-Based Access Control
Example RBAC configurations
Create secure folders with Role-Based Access Control Auto Configurer
Restrict job triggers
Set up operations center-level access controls
Set up access controls on connected controllers
Test the SSH connection to an agent
Configure restricted credentials with the CloudBees Restricted Credentials plugin
Folders plugin
Folders Plus plugin
Inject secrets into builds
Manage build agents with the Nodes Plus plugin
Extended security settings
Enhanced credentials masking
Understand Beekeeper security warnings
Prevent unauthorized interaction between builds
Security recommendations
Use single sign-on (SSO) in the operations center
CloudBees CI integration with Microsoft Entra ID
Operations center specific permissions
Authentication mapping
Delegate administration
Data collection for the CloudBees Analytics Plugin
Modern DevOps external secrets management
Replace an expired certificate
List of URLs that need access
Block access to URL patterns using the CloudBees Request Filter Plugin
Serve resources from Jenkins
Verify Helm charts with a signature
Introduction
Introduction$JENKINS_HOME directoryBest practices for backup and restoreBack up $JENKINS_HOME manuallyBackup a Role-Based Access Control configurationRestore backup files manuallyRestore credentialsConfigure backups using the CloudBees Backup pluginSchedule backups in the CloudBees Backup pluginRestore backups created with the CloudBees Backup pluginBackup and restore on KubernetesBackup and restore on AWSBackup and restore Kubernetes cluster resources using VeleroRun backups using cluster operations
IntroductionConfigure multiple client controllers with the Jenkins CLI toolConfigure an alias for the Jenkins CLI toolConfigure Jenkins CLI tool with non-TrustStore TLS certificates
CloudBees Inactive Items Plugin
Jenkins Health Advisor by CloudBees
CloudBees Pull Request Builder for GitHub plugin
Count and monitor user licenses with the CloudBees User Activity Monitoring plugin
CloudBees CI Catalog Plugin - Catalog tool
Introduction
CasC fundamentals
CasC requirements
CasC permissions
IntroductionGetting startedCreating a bundleConfiguring the operations center on modern platformsConfiguring the operations center on traditional platformsRetrieving bundles using SCMUpdating a bundleBundle update timing for the operations centerViewing the operations center update logCreating itemsConfiguring RBACDetermining plugin compatibilityTroubleshooting
IntroductionGetting startedCreating a bundleAdding controller bundles to the operations centerUpdating a bundleBundle update timing for controllersViewing the controller update logConfiguring bundle availabilitySetting up a client controllerSetting up a managed controllerSet up a managed controller using the CasC Bundle ServiceCreating itemsConfiguring RBACDetermining plugin compatibilityAdvanced topicsTroubleshooting
Plugin management with CasC
Create an alternate plugin download site
CasC CLI commands
CasC HTTP API
Support policies

Configuration as Code (CasC) fundamentals

3 minute readScalabilityAutomation

Built over the Jenkins Configuration as Code plugin, CloudBees Configuration as Code is a method of simplifying the configuration of the operations center or controllers by capturing the configuration of the CloudBees CI instance in human-readable declarative YAML files that can be used in a reproducible way.

The set of YAML files that describe a CloudBees CI instance configuration is a Bundle, and in addition to the features provided by the Jenkins Configuration as Code plugin, CloudBees CasC offers the following features:

  • Bundles can contain additional configuration information for:

    • Items like folders, pipelines, freestyle jobs, etc.

    • Plugins to be installed under the CloudBees Assurance Program (CAP) or using plugin catalogs.

    • Role-Based Access Control (RBAC) configurations with users, groups, and roles.

    • Bundle Inheritance is possible when your operations center provides CasC configuration bundles to your controllers.

CasC advantages

The use of CloudBees CasC provides the following advantages to your organization:

  • Portability: Storing all your CasC configuration bundles makes moving your CloudBees CI cluster to a new infrastructure easier.

  • Auditability and Traceability: Using an SCM as a single source of truth for your CasC configuration bundles adds traceability to any change.

  • Manageability: Using your operations center, you can manage the configuration bundles applied to the different controllers in your cluster. CloudBees CasC even allows you to validate a bundle before applying it (pre-validation).

  • Scalability: When you create new controllers in your cluster to match an increasing workload, CloudBees CasC makes this horizontal scaling easier, allowing you to create a new controller with the required configuration stored in a configuration bundle.

CasC bundles

The main element when using CasC to configure your CloudBees CI instance (operations center or controller) is the CasC bundle. A CasC bundle is a collection of YAML files that describes the configuration of a CloudBees CI instance.

Typically, these files may be part of a CasC bundle:

  • bundle.yaml: This index file that describes the bundle and references the other files in the bundle.

  • jenkins.yaml: This file contains the Jenkins configuration, as defined by the Configuration as Code plugin.

  • plugins.yaml: (Optional) This file contains a list of all plugins that should be installed.

  • plugin-catalog.yaml: (Optional) This file contains the plugin catalog definitions that should be created on the controller. It’s only part of a CasC bundle for bundles describing a controller configuration.

  • items.yaml: (Optional) This file contains the items to be created.

  • rbac.yaml: (Optional) This file contains all RBAC groups and roles defined at the root level.

  • variables.yaml: (Optional) This file defines the variables that can be used in the jenkins.yaml, items.yaml, and rbac.yaml files.

CasC bundles can be created in two ways:

  • Manually, creating from scratch the files listed above.

  • Exporting from a CloudBees CI instance by means of the CloudBees Configuration as Code export and update screen in the UI, or an API HTTP request.

To learn about these files, refer to:

Once the CasC bundles are created, manually or by exporting the configuration for a running CloudBees CI instance, to configure an instance using them, bundles can be placed:

  • In a local folder within the instance you want to configure using the bundle.

  • In an SCM that will provide the bundle to configure your instance.

CasC use cases

CloudBees CasC can be used in many different scenarios and ways. Some common use cases are described below:

  • You can easily add a new controller to your CloudBees CI cluster using the same configuration as other controllers in your cluster. A 1-to-many configuration.

  • You can easily reuse your current CloudBees CI cluster configuration when moving your cluster to a new infrastructure with higher capacities.

  • When many controllers are configured using the same CasC bundle, you can easily update them all at once, propagating those changes from the operations center serving the bundle to all the controllers using it.

  • You can speed up onboarding for new teams in your organization by having controller bundles with all they need ready to be used.

  • Using the bundle inheritance feature, you can create new CasC bundles based on others.

  • You can store CasC bundles to recover your CloudBees CI instance in case of disaster.

  • In a CloudBees CI on modern cloud platforms, you can even configure your whole cluster in a single step by using CasC bundles for the operations center containing information about the CasC bundles needed for all the managed controllers. It’s a One-Shot configuration.

Introduction
CasC requirements