Aria Automation Content Staging

Introduction

The majority of enterprise companies today rely on CI/CD pipelines to validate and promote content between their environments. This is mostly applicable for those developing software applications, but the same process can be applied for other systems. In this blog post tutorial I will show an example how to stage Aria Automation content leveraging Aria Suite Lifecycle, Aria Automation Pipelines and GitLab repositories.

I will use the opportunity to deep dive into a more complex scenario, where the production environment is air-gapped and doesn’t have network connectivity to any of the other environments, as shown in the diagram below.

My first task is to prepare the GitLab repositories, then I will move on to the Aria Suite Lifecycle content management configurations and the final step will be to automate everything with Aria Automation Pipelines.

Let’s get started.

Configure the source and target GitLab projects

The source GitLab project will be used to store Aria Automation content captured from the development and staging environments and the target one will be used to store content that will be later released to production.

Note: The GitLab project content will be synchronised offline via file or project exports, because of the missing network connectivity.

Create the project in the source GitLab instance
- Login to the source GitLab instance
- Click Create New Project
- Provide the project details and click Create

Generate new access token, which will be used to integrate the source GitLab project in the source Aria Suite Lifecycle instance
- Open the source GitLab project
- Navigate to Settings > Access Tokens
- Provide the token details and click Create project access token
  
  Note: Write down the source GitLab project access token for later usage

Create the project in the target GitLab instance
- Login to the target GitLab instance
- Click Create New Project
- Provide the project details and click Create

Generate new access token, which will be used to integrate the target GitLab project in the target Aria Suite Lifecycle instance
- Open the target GitLab project
- Navigate to Settings > Access Tokens
- Provide the token details and click Create project access token.
  
  Note: Write down the target GitLab project access token for later usage.

Configure the Aria Suite Lifecycle source and target instances

To integrate the source and target Aria Suite Lifecycle instances with other systems, I need to configure those as content management endpoints.

Configure the Aria Suite Lifecycle authentication via Identity Manager 
- Login to the source Aria Suite Lifecycle instance with the admin@local user
- Navigate to Identity and Tenant Management > User Management
- Click Add User/Group
- Select some user or group, which will be used to provide the Identity Manager User authentication.
- Select the content roles
- Click Submit.

Repeat the same steps in the target Aria Suite Lifecycle instance.
Configure the GitLab servers in the source and target Aria Suite Lifecycle instances
- Login to the source Aria Suite Lifecycle instance with the Identity Manager user configured previously. 
- Navigate to Content Management > Content Settings > Source Control Access.
- Click Add Source Control Server and provide the source GitLab server, which will be used to store the captured Aria Automation content from the development and staging environments.
- Click the Edit icon next to the new Source Control Server endpoint and provide the source GitLab project access key created earlier.
- Login to the target Aria Suite Lifecycle instance with the Identity Manager user configured previously. 
- Navigate to Content Management > Content Settings > Source Control Access.
- Click Add Source Control Server and provide the target GitLab server, which will be used to release content to the production Aria Automation instance.
- Click the Edit icon next to the new target Control Server endpoint and provide the target GitLab project access key created earlier.

Configure the Aria Suite Lifecycle content management endpoints in the source and target instances
- Login to the source Aria Suite Lifecycle instance with the Identity Manager user configured previously. 
- Navigate to Content Management > Endpoints
- Click New Endpoint
- Select Automation
- Provide the development Aria Automation/Orchestrator access details and click Test Connection.
- Click Next
- Click Submit
- Click New Endpoint
- Select Source Control
- Enter the source GitLab project details
- Click Next
- Click Submit
- Login to the target Aria Suite Lifecycle instance with the Identity Manager user configured previously. 
- Navigate to Content Management > Endpoints
- Click New Endpoint
- Select Automation
- Provide the production Aria Automation/Orchestrator access details and click Test Connection
- Click Next
- Click Submit
- Click New Endpoint
- Select Source Control
- Enter the target GitLab project details
- Click Next
- Click Submit

Manual content staging between the development and production Aria Automation environments using GitLab as persistent storage

The required configurations to promote content manually between the development and production environments are now ready. Let’s see how to do this with Aria Suite Lifecycle.

Configure some demo content in the Aria Automation environment.
- Login to the development Aria Automation instance with a cloud admin user.
- Navigate to Assembler > Design
- Click New From > Blank Canvas and enter the Cloud Template details
  Note:  Create a simple Cloud Template with single or multiple resources.

Capture the demo content from the development Aria Automation environment to the source Aria Suite Lifecycle and then push the captured content to the source GitLab project.
- Login to the source Aria Suite Lifecycle instance with the Identity Manager user created previously.
- Navigate to Content Management > Contents
- Click Add Content > Automation
- Select Capture and Check In options and click Proceed
- Populate the Capture Details. Select the Cloud Template created previously in the development environment
- Populate the CheckIn Details and select the source GitLab project
- Review and submit the request.
- Click on the new content pipeline and wait until it is finished
- Verify the captured content in the source Aria Suite Lifecycle instance
- Verify the content stored in the source GitLab project repository

Clone the captured Demo Cloud Template content to the target GitLab Project manually via offline export.

Release the demo content from the target GitLab Project to the production Aria Automation environment
- Login to the target Aria Suite Lifecycle instance with the Identity Manager user created previously.
- Navigate to Content Management > Contents
- Click Add Content > Source Control
- Select Capture and Deploy options and click Proceed
- Populate the Capture Details. Select the target GitLab project and the Demo Cloud Template captured content. Click Next
- Populate the Deploy Details. Select the production Aria Automation instance. Click Next
- Review and submit the content pipeline request.
- Click on the new content pipeline and wait until it is finished
- Verify the check-out content in the target Aria Suite Lifecycle instance
- Login to the production Aria Automation instance with a cloud admin user.
- Navigate to Assembler > Design
- Validate that the Demo Cloud Template is present in the list of Cloud Templates

Configure the source and target Aria Automation Pipelines instances

In this section, I will cover the steps required to prepare for an automated content staging between the development and production environments

Configurations required in the development Aria Automation Pipelines instance:

Source Docker Host 
Source Git endpoint
Source Docker endpoint
Source GitLab web-hook
Source Custom Integrations
Source Pipelines

Configurations required in the production Aria Automation Pipelines instance:

Target Docker Host 
Target Git endpoint
Target Docker endpoint
Target GitLab webhook
Target Custom Integrations
Target Pipelines

Install and configure the source and target Docker Hosts.

The docker hosts will provide the required python3 runtime to execute Aria Automation Pipelines Custom Integrations python scripts and to clone the source/target GitLab repositories.

Note: For the purpose of this demo I will use Ubuntu LTS Server 10.x as docker host OS.

Docker Host installation steps:

SSH login to the Ubuntu server with a privileged account
Update the system

sudo apt update

Install the basic dependencies

sudo apt install ca-certificates curl gnupg

Remove existing docker installations (if any)

sudo apt remove docker docker-engine docker.io containerd runc

Import the GPG key for the docker repository

sudo install -m 0755 -d /etc/apt/keyrings 

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg –dearmor -o /etc/apt/trusted.gpg.d/docker-archive-keyring.gpg

Add the docker repository

echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" |   sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Update the system

sudo apt update

Install docker CE

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Enable and start the docker service

sudo systemctl start docker
sudo systemctl enable docker

Enable the docker host remote api
Create the docker certificate folders

mkdir /root/docker
mkdir /root/docker/server

Create the following openssl.conf file in /root/docker/openssl.conf

[req] 
req_extensions = v3_req 
distinguished_name = req_distinguished_name 
[req_distinguished_name] 
[ v3_req ] 
basicConstraints = CA:FALSE 
keyUsage = nonRepudiation, digitalSignature, keyEncipherment 
extendedKeyUsage = serverAuth, clientAuth
[alt_names] 
DNS.1 = ${UBUNTU SERVER FQDN} 
IP.1 = ${UBUNTU SERVER IP ADDRESS} 
IP.2 = 127.0.0.1

Generate the required certificates

sudo openssl genrsa -out /root/docker/ca-key.pem 2048 

sudo openssl req -x509 -new -nodes -key /root/docker/ca-key.pem -days 10000 -out /root/docker/ca.pem -subj '/CN=${UBUNTU SERVER FQDN}' 

sudo openssl genrsa -out /root/docker/server/key.pem 2048  

sudo openssl req -new -key /root/docker/server/key.pem -out /root/docker/server/cert.csr -subj '/CN=${UBUNTU SERVER FQDN}' -config /root/docker/openssl.conf  

sudo openssl x509 -req -in /root/docker/server/cert.csr -CA /root/docker/ca.pem -CAkey /root/docker/ca-key.pem -CAcreateserial -out /root/docker/server/cert.pem -days 365 -extensions v3_req -extfile /root/docker/openssl.conf

Reconfigure the docker service

sudo systemctl edit docker.service

Add the following configuration between the comments below and save it

### Anything between here and the comment below will become the new contents of the file  

[Service] 

ExecStart= 

ExecStart=/usr/bin/dockerd -H fd:// -H unix:///var/run/docker.sock -H tcp://${UBUNTU SERVER IP ADDRESS}:2375 --tls --tlscacert=/root/docker/ca.pem --tlscert=/root/docker/server/cert.pem --tlskey=/root/docker/server/key.pem

 ### Lines below this comment will be discarded

Create new rule to allow access to the docker API from external systems and restart the firewall and docker services

sudo ufw allow from any to any port 2375 
sudo ufw reload 
sudo systemctl daemon-reload 
sudo systemctl restart docker.service

Validate the docker API

curl --insecure --cert /root/docker/server/cert.pem --key /root/docker/server/key.pem https://${UBUNTU SERVER IP ADDRESS}:2375/version

Create new python 3 runtime image for use by Aria Automation Pipelines
Create the docker image directory

mkdir /root/docker/codestream-python3/

Create the docker file in /root/docker/codestream-python3/Dockerfile

FROM ubuntu:latest 
ENV DEBIAN_FRONTEND=noninteractive 
RUN apt-get update \ 
&& apt-get install -y curl wget python3-pip python3-dev git unzip openssl \ 
&& cd /usr/local/bin \ 
&& ln -s /usr/bin/python3 python \ 
&& pip3 --no-cache-dir install --upgrade pip \ 
&& rm -rf /var/lib/apt/lists/* \ 
&& mkdir /shareDirectory 
ENTRYPOINT [""]

Build the docker image

cd /root/docker/codestream-python3/ 
docker build -t codestream-python3 /root/docker/codestream-python3/Dockerfile

Validate the new image

docker images

Example

root@UbuntuServer:/root/docker/codestream-python3# docker images  
REPOSITORY            TAG     IMAGE ID        CREATED            SIZE  
codestream-python3    latest  805d17e89e2e    2 minutes ago      460MB

Note down the new image id:  805d17e89e2e . This will be need for the Aria Automation Pipelines configuration later on

Repeat the same steps to prepare the target Docker Host for the production Aria Automation Pipelines instance.

Validate the new image

docker images

Example

root@UbuntuServer:~# docker images  
REPOSITORY         TAG       IMAGE ID       CREATED         SIZE  
codestream-python3 latest    9feac15eba5b   2 minutes ago   460MB

Create the Docker Host endpoints in the development and production Aria Automation Pipelines environments

Login to the development Aria Automation Pipelines instance with a cloud admin user.
Navigate to Pipelines > Configure > Endpoints
Click New Endpoint
Populate the source docker host details
Note: the CA certificate is the one generated in /root/docker/ca.pem, the client certificate is the one generated in /root/docker/server/cert.pem and the client key is the one generated in /root/docker/server/key.pem
Click Create
Login to the production Aria Automation Pipelines instance with a cloud admin user.
Navigate to Pipelines > Configure > Endpoints
Click New Endpoint
Populate the target docker host details
Note: the CA certificate is the one generated in /root/docker/ca.pem, the client certificate is the one generated in /root/docker/server/cert.pem and the client key is the one generated in /root/docker/server/key.pem
Click Create

Import the required Pipelines and Custom Integrations scripts in the development and production Aria Automation Pipelines environments

Download the Aria Automation configuration files: Aria Automation Pipelines

I will start with the required steps in the development environment first

Login to the development Aria Automation Pipelines instance with a cloud admin user.
Navigate to Pipelines > Configure > Variables
Click New Variable
Populate the password for the Aria Suite Lifecycle Identity Manager User configured previously
Navigate to Pipelines > Custom Integrations
Click Import
Select operation type Create and click Read From File
Browse the file Source Aria Pipelines > Custom Integrations > Capture Content.yaml
Click Import
Click Close

Note: This custom integration script will generate the api call body needed by the Aria Suite Lifecycle capture content pipeline.
Click Import
Select operation type Create and click Read From File
Browse the file Source Aria Pipelines > Custom Integrations > Deploy Content.yaml
Click Import
Click Close

Note: This custom integration script will generate the api call body needed by the Aria Suite Lifecycle deploy content pipeline. The destination Aria Automation endpointId, and the content selection tags are based on the deploy pipeline inputs: deployPipelineEndpointId, deployPipelineContentTags
Navigate to Pipelines > Pipelines
Click Import
Select operation type Create and click Read From File
Browse the file Source Aria Pipelines > Pipelines > Capture Content.yaml
Click Import
Click Close
Open the Capture Content pipeline
Navigate to the Workspace tab and update the Docker Host endpoint and the python3 container image id created earlier.
Click Actions > Enable.
Important: To remove the exclamation marks from the pipeline steps, click on each of them and then move to the next one. Click Save and then Enable.
Note: The Capture Content pipeline has 4 steps:
- Get LCM Token is a REST task that will generate new token to authenticate against Aria Suite Lifecycle.
- Process LCM Pipeline Strategy is custom integration python 3 task that will use the lcmCapture.json information to generate the body needed for the Aria Suite Lifecycle pipeline request
- LCM Pipeline Request is a REST task that will initiate the call to Aria Suite Lifecycle to create new pipeline to capture and check-in the content defined in the lcmCapture.json
- LCM Pipeline Result is a REST poll task that will wait until the Aria Suite Lifecycle pipeline request is completed and report the result.
Click Save
Click Close

Note: This pipeline will capture and check-in Aria Automation content based on a GitLab web-hook event and the data defined in a custom file lcmCapture.json stored in the source GitLab repository.
Navigate to Pipelines > Pipelines
Click Import
Select operation type Create and click Read From File
Browse the file Source Aria Pipelines > Pipelines > Deploy Content.yaml
Click Import
Click Close
Open the Deploy Content pipeline
Navigate to the Workspace tab and update the Docker Host endpoint and the python3 container image id created earlier.
Click Actions > Enable.
Important: To remove the exclamation marks from the pipeline steps, click on each of them and then move to the next one. Click Save and then Enable.
Note: The Deploy Content pipeline has 5 steps:
- Get LCM Token is a REST task that will generate new token to authenticate against Aria Suite Lifecycle.
- Get LCM Content is a REST task that will get Aria Automation captured content based on its Aria Suite Lifecycle tags provided as pipeline input.
- Prepare Deploy Pipeline is a custom integration python 3 task that will generate the body needed for the Aria Suite Lifecycle deploy pipeline request. It will use the Ids discovered from the Get LCM Content task output.
- Deploy Content is a REST task that will initiate the call to Aria Suite Lifecycle to create new pipeline to deploy the content defined in the Prepare Deploy Pipeline task output.
- LCM Pipeline Result is a REST poll task that will wait until the Aria Suite Lifecycle pipeline request is completed and report the result.
Click Save
Click Close

Note: This pipeline is an example of how to deploy previously captured Aria Automation/Orchestrator content to another environment, based on provided pipeline inputs, the target Aria Automation endpoint Id and the Aria Suite Lifecycle content capture tags.
Navigate to Pipelines > Configure > Endpoints to create the source GitLab project endpoint and its webhook
Click New Endpoint
Populate the source GitLab project details
Click Create
Navigate to Pipelines > Triggers > Git
Click Webhooks for Git
Click New Webhook for Git
Populate the web-hook details to trigger the Capture Content pipeline, when a file called lcmCapture.json is modified in the source GitLab project repository
Click Create

Next, I will complete the same steps in the production environment:

Login to the production Aria Automation Pipelines Instance with a cloud admin user.
Navigate to Pipelines > Configure > Variables
Click New Variable
Populate the password for the Aria Suite Lifecycle Identity Manager User configured previously
Navigate to Pipelines > Custom Integrations
Click Import
Select operation type Create and click Read From File
Browse the file Target Aria Pipelines > Custom Integrations > Release Content.yaml
Click Import
Click Close
Navigate to Aria Automation Pipelines > Pipelines
Click Import
Select operation type Create and click Read From File
Browse the file Target Aria Pipelines > Pipelines > Release Content.yaml
Click Import
Click Close
Open the Release Content pipeline
Navigate to the Workspace tab and update the Docker Host endpoint and the python3 container image id created earlier.
Click Actions > Enable
Important: To remove the exclamation marks from the pipeline steps, click on each of them and then move to the next one. Click Save and then Enable.

Note: The Release Content pipeline have 4 steps:
- Get LCM Token is a REST task that will generate new token to authenticate against Aria Suite Lifecycle.
- Process LCM Pipeline Strategy is a custom integration python3 script task that will use the lcmRelease.json information to generate the body needed for the Aria Suite Lifecycle pipeline request
- LCM Pipeline Request is a REST task that will initiate the call to Aria Suite Lifecycle to create new pipeline to check-out and release the content defined in the lcmRelease.json
- LCM Pipeline Result is a REST poll task that will wait until the Aria Suite Lifecycle pipeline request is completed and report the result.

Click Save
Navigate to Pipelines > Configure > Endpoints to create the target GitLab project endpoint and its webhook
Click New Endpoint
Populate the target GitLab project details
Click Create
Navigate to Pipelines > Triggers > Git
Click Webhooks for Git
Click New Webhook for Git
Populate the webhook details to trigger the Release Content pipeline, when a file called lcmRelease.json is modified in the target GitLab project repository
Click Create

Manual content staging between the development and staging environments

In this section I will demonstrate how to stage content manually between different Aria Automation environments configured in the same Aria Suite Lifecycle instance. The most typical scenario is when development content must be promoted to the staging environment for user acceptance testing and additional validations.

Note: To select the correct content, I will rely on the tags specified in the content capture step. This will help me to select and deploy the same content items with one pipeline execution.

Login to the development Aria Automation Pipelines instance with a cloud admin user.
- Navigate to Aria Automation Pipelines > Pipelines
- Open the Deploy Content pipeline
- Modify the deployPipelineName, deployPipelineComment, deployPipelineEndpointId, deployPipelineContentTags default variable values. The deployPipelineEndpointId should contain the staging Aria Automation content endpointId.
- Click Save
- Click Close
- Click Run and if needed update the pipeline inputs.
- Verify the new pipeline execution is successful
- Verify the Aria Suite Lifecycle deploy pipeline request is successful
- Verify the content promotion to the staging Aria Automation environment is successful

Automated content staging with Aria Automation Pipelines

I am now ready to automate the whole content staging process using GitOps based pipelines. For this purpose I need to create and push custom json file in each GitLab project. The Git web-hooks configured previously in the Aria Automation Pipelines instances will use them to trigger the required pipeline and capture or release the specified Aria Automation content.

Note: To add more supported Aria Automation content types, the custom integrations scripts need to be extended. The examples below show how this can be done for Cloud Templates.

Prepare the Aria Automation development environment

Create the lcmCapture.json file in the source GitLab project

{
	"stages": {
		"capture": {
			"name": "${capture_name}",
			"comment": "${capture_comment}",
			"vroSharedPackageName": "",
			"vROSharedPackageVersionId":"",
			"includeDependencies": false,
			"endpointId": "${development_aria_automation_endpoint_id}",
			"tags": [
				"${tag_name}"
			],
			"contents": [
				{
					"contentType":"Automation-CloudTemplate",
					"name": "${cloud_template_name}",
					"id": "${cloud_template_id}",
					"project": "${cloud_template_project_name}"
				}
			]
		},
		"deploy":{
			"name": "${check_in_pipeline_name}",
			"endpointId": "${source_gitlab_instance_endpoint_id}",
			"comment": "${check_in_pipeline_comment}",
			"tags": [
                "${tag_name}"
            ]
		}
	}
}

Example:

{
	"stages": {
		"capture": {
			"name": "Demo capture 1",
			"comment": "capture cloud template from development 1",
			"vroSharedPackageName": "",
			"vROSharedPackageVersionId":"",
			"includeDependencies": false,
			"endpointId": "838fc248-05e0-469e-8719-1ac464fcc132",
			"tags": [
				"demo-capture-1"
			],
			"contents": [
				{      
					"contentType":"Automation-CloudTemplate",
					"name": "Demo Cloud Template",
					"id": "e5ec69f0-cc46-4efe-8809-ed6e3083861f",
					"project": "Demo"     
				}
			]
		},
		"deploy":{
			"name": "Demo check-in 1",
			"endpointId": "01450352-7495-415f-bdc2-a819f16cbaf3",
			"comment": "checkin cloud template from development 1",
			"tags": [
                "demo-check-in-1"
            ]
		}
	}

}

The development Aria Automation endpoint id can be obtained either via API call or via the Aria Suite Lifecycle UI.

The source GitLab project endpoint id can be obtained either via API call or via the Aria Suite Lifecycle UI.

The Aria Automation Cloud Template name, id and project can be obtained either via API call or via the Cloud Assembler service UI.

Push the lcmCapture.json file to the source GitLab project
Verify that new pipeline execution was successfully created

Note: The pipeline workspace will create new Docker container from the previously configured python3 image. Then it will check-out the source-content-project repository and use the information from the lcmCapture.json to start the Aria Suite Lifecycle content pipeline, which will capture and store the specified Aria Automation content.
Login to the source Docker Host and verify that the docker container was successfully created
Verify that the Aria Suite Lifecycle content capture and check-in pipeline completed successfully
Verify that the Aria Suite Lifecycle content capture created new version of the content defined in the lcmCapture.json file
Verify that the Aria Automation Pipeline completed successfully
Verify that a new Merge request was created in the source GitLab project with the captured Aria Automation content.
Review and then Click Merge to commit the captured content.

Clone the captured content from the source GitLab project to the target GitLab project.

Prepare the Aria Automation production environment

The next step is to rename the lcmCapture.json to lcmRelease.json in the target GitLab project and to prepare the file contents to trigger the desired Aria Suite Lifecycle content pipeline.

Prepare the lcmRelease.json file contents

{
	"stages": {
		"capture": {
			"name": "${check_out_pipeline_name}",
			"comment": "${check_out_pipeline_comment}",
			"vroSharedPackageName": "",
			"vROSharedPackageVersionId":"",
			"includeDependencies": false,
			"endpointId": "${target_gitlab_instance_endpoint_id}",
			"tags": [
				"${tag_name}"
			],
			"contents": [
				{
					"contentType":"Automation-CloudTemplate",
					"name": "${cloud_template_name}",
					"id": "${cloud_template_id}",
					"project": "${cloud_template_project_name}"
				}
			]
		},
		"deploy":{
			"name": "${deploy_pipeline_name}",
			"endpointId": "${production_aria_automation_instance_endpoint_id}",
			"comment": "${deploy_pipeline_comment}",
			"tags": [
                "${tag_name}"
            ]
		}
	}
}

Example:

{
	"stages": {
		"capture": {
			"name": "Demo check-out 1",
			"comment": "check-out cloud template from production 1",
			"vroSharedPackageName": "",
			"vROSharedPackageVersionId":"",
			"includeDependencies": false,
			"endpointId": "e0b52944-0a2d-4929-9025-15ba962db6bc",
			"tags": [
				"demo-release-1"
			],
			"contents": [
				{   	
				    "contentType":"Automation-CloudTemplate",
					"name": "Demo Cloud Template",
					"id": "e5ec69f0-cc46-4efe-8809-ed6e3083861f",
					"project": "Demo"     
				}
			]
		},
		"deploy":{
			"name": "Demo deploy 1",
			"endpointId": "ed631bf3-f3b8-465e-bb29-149ff19dfc60",
			"comment": "deploy cloud template to production 1",
			"tags": [
                "demo-release-1"
            ]
		}
	}
}

The endpoint id of the target GitLab instance can be obtained either via API call or via the Aria Suite Lifecycle UI.

The production Aria Automation endpoint id can be obtained either via API call or via the Aria Suite Lifecycle UI.

Note: The Aria Automation Cloud Template name is already populated as part of the lcmCapture.json and that is everything needed to release it to the production environment. The Cloud Template Id and project name will be omitted as they are not needed.

Push the new lcmRelease.json file to the target GitLab project
Verify that a new Aria Automation pipeline was initiated by the configured GitLab webhook
Note: The pipeline workspace will create new Docker container from the previously configured python3 image. Then it will check-out the target-content-project repository and use the information from the lcmRelease.json to start the Aria Suite Lifecycle content pipeline, which will check-out and release the specified Aria Automation content to production.
Login to the target Docker Host and verify that the docker container was successfully created
Verify that new User Operation was created by the release pipeline
Approve the User Operation to resume the release pipeline
Verify that the Aria Suite Lifecycle content release pipeline completed successfully
Verify that the Aria Automation content capture from the target GitLab project is now available in Aria Suite Lifecycle
Verify that the Aria Automation pipeline completed successfully
Verify that the Aria Automation Cloud Template was successfully release to production

This is the end of our journey today.

I hope the information in this blog post article was helpful for everyone looking to automate or simplify their Aria Automation content staging as well as for those interested to explore some of the basic CI/CD Aria Automation Pipelines capabilities.

Stay well and until next time!