Introduction
Introduction
IntroductionInstall CloudBees CD/RO within KubernetesConfigure Helm chartsKubernetes platform-specific configurationsKubernetes configuration optionsConfigure IP protocols for Helm chart componentsConfigure GitOps with Helm chartsVerify Helm chartsCreate custom Docker imagesVerify Docker images
IntroductionInstallation user requirementsInstallation typesDefault installation directoriesVerify installation binariesAgent security recommendations
IntroductionInstall a default configurationInstall a custom configurationRun an express agent GUI installationRun an express GUI installation (agent-only installer)Run an advanced GUI installation (agent-only installer)Install CloudBees Analytics
IntroductionRun an express server command-line installationRun an advanced command-line installationRun an express agent command-line installationExpress agent command-line installation (agent-only installer)Advanced command-line installation (agent-only installer)Install the CloudBees Analytics server with the interactive command-line installer
IntroductionRun a silent installationSilent installation argumentsLinux silent installation examplesWindows silent installation examplesCloudBees Analytics server unattended installation
IntroductionUNIX agent interactive command-line installationSilent installation method for UNIX or macOS agents
IntroductionPrerequisitesPermissions to install or upgrade remote agentsInstall remote agents using the web interfaceInstall via the API
CloudBees Tools installation
Move the artifact repository in LinuxMove the artifact repository in Windows
Connect CloudBees CD/RO to a Microsoft SQL server
Install the MySQL JDBC connector
IntroductionUninstall CloudBees CD/RO on Linux, Unix, or macOSUninstall on WindowUninstall the CloudBees Analytics server on LinuxUninstall the CloudBees Analytics server on Windows
IntroductionZones and gatewaysConfigure custom CAs and CRLs in non-clustered environmentsConfigure custom CAs and CRLs in clustered environmentsConfigure agent environment variablesLicensesCreate and manage usersEdit user settingsCreate and manage groupsPersonasConfigure an external databaseConfigure CloudBees CD/RO to use an alternate databaseInstall services for non-root/non-sudo Linux installationsConfigure autostart for non-root/non-sudo Linux installationsConfigure universal access to the plugins directoryConfigure an environment proxy serverSystem health monitoringIncrease file descriptors on Linux and Linux Docker containersAdjust swappiness on LinuxSet variables on Windows agent machinesServer propertiesServer settingsSource code synchronization
IntroductionConfigure initial events for Workload InsightsConfigure OpenSearch Dashboards to work with CloudBees Analytics
IntroductionArchitecture of a CloudBees CD/RO clusterResource, agent, and procedure considerationsSoftware for clusteringDependencies for clusteringConfigure clusteringSeparate agents from CloudBees CD/RO serversPrepare your cluster resourcesInstall and configure a load balancerInstall ZooKeeperConfigure a multi-ZooKeeper clusterInstall CloudBees CD/RO softwareConfigure repository serversConfigure machines to operate in clustered modeRun a cluster in single-server modeAdd the configuration to ZooKeeperUpload configuration files to ZooKeeperGet cluster information from ZooKeeperAdd a node to an existing clusterConfigure web server propertiesConfigure repository server propertiesConfigure CloudBees CD/RO agentsConfigure the cluster workspaceConfigure CloudBees CD/RO repositoriesAdd trusted agents to clustersVerify CloudBees CD/RO servicesAccess CloudBees CD/RO with clusteringHealth check for the CloudBees CD/RO clusterAdditional ways to improve a clusterInstall the CloudBees Analytics server in cluster modeUse self-signed certificates in CloudBees CD/RO on KubernetesConfigure Disaster Recovery and recover from a disaster
Sign in to CloudBees CD/ROAccess the Home pageMy work dashboardGuided tutorialsLearn about the object modelSearch and filter
IntroductionIntrinsic properties listed by object typeReserved words in CloudBees CD/ROObject types in CloudBees CD/ROSpecial characters in CloudBees CD/RO object namesContext-relative shortcuts to property pathsProperty error codesConfigure properties or property sheetsProperty BrowserProperty reference use case
IntroductionResource poolsCreate or edit resource pools
IntroductionView workspacesCreate or edit workspacesWorkspace file
IntroductionCreate a projectSchedules
IntroductionPipeline stages and gatesPipeline access controlPipeline tasksUse the CloudBees CD/RO API to define tasksDefine manual tasksEntry and exit gatesPipeline conditionsPipeline start and end stages and stage skippingWait dependenciesNative CI integrationPipeline UIAuthor and run pipelinesDefine stage gate rulesPipeline objects and conditionsPipeline stage summaryCredentials in pipelinesRun pipelinesView pipeline runsExample: Create a manual task in a pipelineExample: Plugin pipeline tasksExample: Integrate test automation in release pipelinesExample: Leverage test data management and service virtualization in release pipelines
IntroductionRelease planning, scheduling, and trackingRelease and environment reservations calendarVisibility and status of release pipelinesRelease definitionDeploy with Argo RolloutsRelease dashboardPlanned versus actual view for pipeline statusPath to production viewRelease summaryRun and end releases
Introduction
IntroductionManage procedure runsProcedure run detailsUsing CloudBees CD/RO in your environmentJob step executionPostprocessors: Collecting data for reports
IntroductionWorkflow listsCreate or edit workflow definitionsWorkflow definition detailsRun workflowWorkflow detailsWorkflow LogTransition workflow
Introduction
IntroductionCreate and manage applicationsApplication process run detailsCreate application processesAdd process stepsProcess branchingConfigure plugin process stepsDefine manual stepsExample: Manual step with runtime parametersAttach credentials to processesFull-stack dependency viewApplication deployment optionsConfiguration drift
IntroductionMaster component examplesMaster components list
Introduction
IntroductionStage artifactsCapture snapshotsApplication rollbackManage dependencies
IntroductionCreate environmentsDefine environment tier mapsInventory trackingEnvironment inventoryGlobal environment inventoryEnvironment reservationsLock environmentsModel dynamic environmentsAutomated environment discoveryCreate a deployment task to trigger third-party toolsGenerate a deployment packageExample: Dynamic environment with Amazon and ChefExample: Deploy and troubleshoot applicationsExample: Deploy applications with provisioned cloud resourcesExample: Implement deployment strategies
IntroductionArtifactsArtifact versionsRepositories
Create object tagsCreate object schedules
IntroductionConfigure webhook triggersConfigure polling triggers
IntroductionConfigure email notificationsSelect and edit email messages for application or microservice processes
Introduction
IntroductionInstall CloudBees CD/RO pluginsCreate plugin configurationsManage pluginsCreate pluginsManage the plugin catalog

Capture snapshots

5 minute readReferenceAutomation

In a software release process, the goal is to have a consistent deployment process that can be run often throughout the release life cycle. When the deployments are run in production, there are no unexpected results. Snapshots are used to implement these deployments.

A snapshot captures both the component versions and the process that were used for deployments. These snapshots make the deployments repeatable and stable.

CloudBees CD/RO supports these types of snapshots:

  • Environment snapshot—An environment snapshot is created from an environment where the application is deployed and tested. A snapshot captures the exact artifact versions, process versions, configuration parameters, and so on used for the deployment to ensure repeatability. This is considered the reliable version of a snapshot for reliability and repeatability.

  • Application snapshot—A snapshot is created directly from the application model and does not depend on any environment deployment. When a snapshot is captured from the application model, it locks the architecture, components, and process versions. If you specify the “Latest” artifact version as part of the component definition in the snapshot, the latest artifact versions will be used every time it is used for deployment. The main purpose of an application-based snapshot is to allow the creation of user-defined versions of the models. The application snapshot name can be used to indicate a specific user-defined version.

For example, in a software delivery process, the developer checks in code, the components are built automatically by a continuous integration system, and the objects in the resulting build are published to a binary artifact management system. When the full complement of component artifacts is available, a release candidate pipeline is initiated. The first stage is to deploy to a development environment. From this deployment, a snapshot is created and used as the model for subsequent deployments to other environments.

There will be some differences between the development, QA and production environments, such as database connection strings, credentials, and debug-vs-production artifacts. CloudBees CD/RO can manage these differences in the application using parameters and properties in templates, only modifying the deployment process flow in a controlled manner.

The process described in the example avoids some pitfalls encountered in traditional release scenarios. For example, configuration teams often perform their own builds. This means that the binaries supplied by the CM team may be different than what has already been tested. Release teams may also manually edit configuration files to adjust for differences in the deployment environments. Both of these practices are prone to error and can negatively impact the quality of the final software release.

In CloudBees CD/RO, you can deploy snapshots for more reliable and repeatable software releases. Here are some of the use cases snapshots can serve:

  • You can model and save a version of your software release with specific artifact versions and rerun it later, even if the latest release version of it has changed.

  • If you save snapshots during development and test phases, you can ensure that the components that were deployed and tested are the same as those in the release candidate. You can redeploy the snapshot any time.

  • You can create and save more than one snapshot for different deployment scenarios.

  • You can use an application snapshot to capture a version of the model. This can be used to define a future or desired state of the application model as well.

  • You can view the snapshots in the Snapshot List. From this list, you can manage all your snapshots, compare two snapshots, or get more information about them.

  • Comparing snapshots helps you to deploy releases with reliable and repeatable results during ongoing software release cycles. You can build and test releases using snapshots and do not have to design new applications for each release. Comparing snapshots also allows you to compare a future or desired state of the application model to any saved version of the model. Refer to Comparing Snapshots and Comparing Results for more information.

  • You can use snapshots to refine and optimize applications that fit your deployment scenario and ensure that this version is properly developed, tested, and released.

Example: Creating, deploying, and comparing snapshots

This example shows how to create application and environment snapshots, deploy snapshots, and compare them during the software release life cycle.

Creating application snapshots

  1. In the Applications List, select an application, and then select Snapshots.

    The Snapshot List displays.

  2. To add a new snapshot, select There are no Snapshots. Add one +.

    The New Snapshot dialog box displays.

  3. Enter the snapshot name and an optional description.

    The snapshot name must be unique within the application.

    You can use this name to indicate the user-defined version of the model. For example, in the figure below, refer to HeatClinic v1.2.

    You can use Application snapshots for various purposes, including creating a baseline version of the model or to model a future or desired state of the model.

  4. Select Next. The New/Preview dialog box opens.

  5. Toggle between the Component and App Process views to view the components and application processes for the selected application.

    In the Component view, change the version of the Config component to Latest.

  6. Select OK.

    A message displays stating that the snapshot has been created, and the snapshot list is updated.

Deploying application snapshots

  1. In the Applications List, choose an application, and then select Run process.

  2. Select New Run.

    The dialog box to select the settings for the application run opens.

  3. Select these settings for the application run:

    • In the Select Process field, select Run.

    • In the Select Environment field, select heatclinic-qe.

    • In the Select a Snapshot field, select HeatClinic v1.2.

      Selecting the arrow next to Compare shows the comparison of the selected snapshot to last deployment of the Run process in the heatclinic-qe environment.

  4. To deploy the snapshot, select OK.

Creating environment snapshots

  1. Open an environment inventory from the Environments list.

    environment inventory snapshot

  2. Choose an application and select Add snapshot. The New Snapshot dialog box opens.

  3. Enter the name and a description of the snapshot. Enter something like Heatclinic_QE2.

  4. Select Next. The New/Preview dialog box opens. You can view the snapshot settings in the Component and App Process tabs but cannot change them because the application has been deployed to the heatclinic-qe environment.

  5. Select OK.

Comparing snapshots

This example shows how to compare an application snapshot to an environment snapshot.

In the Snapshot list, select two snapshots that you want to compare, and then select Compare. The Snapshot Comparison page opens.

Comparing results

In the Snapshot Comparison page, the Component and App Process views show the differences between the snapshots, Heatclinic v1.2 (the application snapshot) and Heatclinic_QE2 (the environment snapshot). Heatclinic_QE2 is the more reliable, repeatable, and up-to-date version of the application.

The Component view shows that the Config component is different. Heatclinic v1.2 uses the Latest version of the artifact that may not be the same as the artifact version in Heatclinic_QE2, the more reliable and repeatable version of the snapshots.

snapshots compare tasks

The App Process shows one difference. Heatclinic v1.2 has one less application process than Heatclinic_QE2.

snapshot compare process
Selecting the drop-down next to the snapshot name allows you to select a different snapshot.
Stage artifacts
Application rollback