Building a CI/CD Pipeline with AWS, K8S, Docker, Ansible, Git, Github, Apache Maven, and Jenkins

In my previous article, I delved into the fascinating world of microservices - Microservice Architecture Patterns Part 1: Decomposition Patterns. This was the beginning of my comprehensive article series on microservices and their patterns.

Content Overview

• Motivation
• [Module 1]: AWS EC2 Virtual Server
• [Module 2]: Jenkins Server
• [Module 3]: Git and Github
• [Module 4]: Apache Maven
• [Module 5]: Docker
• [Module 6]: Ansible
• [Module 7]: Kubernetes
• Conclusion
• About the Author

Motivation

In this article, we aim to demystify the CI/CD process through practical application. We'll take you through a step-by-step tutorial, breaking it down module by module, where you'll build a CI/CD pipeline manually. To do this, we'll harness the power of contemporary DevOps tools like AWS, Docker, Kubernetes, Ansible, Git, Apache Maven, and Jenkins. So, let's begin this journey!

[Module 1]: AWS EC2 Virtual Server

Step 1: Create an AWS Account

Click the button Create an AWS Account.

Step 2: Sign In to your AWS Account

Go to //console.aws.amazon.com/console/home. Click the Sign In button.

Step 3: Find EC2 Virtual Server

Choose EC2 Virtual Server by clicking EC2 Service.

Click the button Launch Instance.

Step 4: Configure “Name and tags“ section

Go to the “Name and tags” section.

Provide a name for a new AWS EC2 Virtual Server instance in the “Name” section.

You can also add additional tags for your virtual server by clicking ”Add additional tags”.

Step 5: Configure “Application and OS Images (Amazon Machine Image)“ section

Go to the "Application and OS Images (Amazon Machine Image)" section.

Step 6: Configure “Instance type“ section

Go to the ”Instance type” section.

Step 7: Configure “Configure storage“ section

Go to the ”Configure storage” section.

Step 8: Configure “Network settings“ section

Go to the “Network settings“ section.

1. Click on the “Create security group” button.
2. Add the name of your new security group in the “Security group name” section.
3. Add a description of your new security group in the “Description” section.

By default, your virtual server is accessible via (Type - SSH, Protocol - TCP, Port - 22). If you need additional connection types, add them by adding additional inbound security group rules.

Step 9: Configure “Key pair (login)“ section

Go to the ”Key pair (Login)” section.

If you haven't created “key-pair” yet:

1. Click the “Create new key pair” button.
2. Give your new key-pair a name in the “Key pair name” section.
3. Select key-pair type RSA or ED25519. I choose the RSA type.
4. Select Private key file format. Choice of .pem and .ppk. I choose the .pem format.
5. Click on the “Create key pair” button.
6. You will get a pop-up window that will prompt you to download the Private key file. Agree and download the file to your computer.

Step 10: Launch the EC2 Virtual Server Instance

Launch the EC2 Virtual Server instance by clicking the button “Launch instance”.

Then you should go to the “Instances“ section by clicking “View all instances” button.

[Module 2]: Jenkins Server

Step 1: Create an AWS EC2 Virtual Server instance

Follow instructions from [Module 1]: AWS EC2 Virtual Server section of this tutorial to finish this step and create an EC2 virtual server instance with the name JenkinsServer.

Step 2: Connect to an AWS EC2 Virtual Server instance

Go to AWS Console home page → EC2 Management Console Dashboard → Instances.

Then you should choose JenkinsServer and then click the “Connect” button.

Then you will see this web page. You should again click the “Connect” button.

Step 3: Download the Jenkins repository

1. Go to Jenkins download .
2. You can see Stable (LTS) and Regular releases (Weekly) options. Choose LTS option.

   
   

3. Copy “sudo get..” command and execute it to download Jenkins files from the Jenkins repository on the Internet and save them to the specified location on your EC2 virtual server instance.

sudo wget -O /etc/yum.repos.d/jenkins.repo //pkg.jenkins.io/redhat-stable/jenkins.repo

Step 4: Import Jenkins key

To import the Jenkins key we need to copy the “sudo rpm..” command and execute it.

sudo rpm --import //pkg.jenkins.io/redhat-stable/jenkins.io-2023.key

Step 5: Install Java

To run Jenkins, we need to install Java on our EC2 virtual server instance.

To install Java, use this command.

sudo amazon-linux-extras install java-openjdk11 -y

Verify whether Java was installed correctly using this command:

java -version

Step 6: Install fontconfig

To run Jenkins, you need to install fontconfig on our EC2 virtual server instance.

sudo yum install fontconfig java-11-openjdk -y

Step 7: Install Jenkins

sudo yum install jenkins -y

Step 8: Start Jenkins

sudo systemctl start jenkins

sudo systemctl status jenkins

Step 9: Access Jenkins

//<your-ec2-ip>:8080

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Step 10: Create new Jenkins pipeline

Now, as Jenkins is working fine, you can start creating the Jenkins pipeline. To create Jenkins pipeline you need to create a new “Freestyle project”. To create a new “Freestyle project” you need to go to the Jenkins dashboard and click the “New Item” button.

Enter the name of the Github “Freestyle project” (“pipeline” name is going to be used further) and then click the button “OK”.

Then provide the Description of the pipeline.

[Module 3]: Git and Github

Step 1: Install Git

sudo yum install git -y

git --version

Step 2: Open Jenkins dashboard

Step 3: Open Jenkins Plugin Manager

Click the button “Manage Jenkins” and then click the button “Manage Plugins”.

Step 4: Find Github Jenkins plugin

Click the button “Available plugins”.

Find the Github plugin Search box.

Select Github plugin.

Step 5: Install Github Jenkins plugin

Select Github plugin. And then click the button “Install without restart”.

Step 6: Configure Github Jenkins Plugin

Then on the main page, you need to click the button “Manage Jenkins” and then click the button “Global tool configuration”.

Then click the “Apply” and “Save” buttons**.**

Step 7: Integrate Git into the pipeline

Just copy and paste it to the “Repository URL” input. Then click the “Apply” and “Save” buttons to finish the integration Git with the pipeline.

Step 8: Test Git integrated into the pipeline

cd /var/lib/jenkins/workspace/{your pipeline name}

[Module 4]: Apache Maven

Step 1: Download Apache Maven

To download Apache Maven go to the “/opt” directory.

cd /opt

sudo wget //dlcdn.apache.org/maven/maven-3/3.9.4/binaries/apache-maven-3.9.4-bin.tar.gz

Step 2: Extract Apache Maven from the archive

sudo tar -xvzf apache-maven-*.tar.gz

Step 3: Add JAVA_HOME and M2_HOME

cd ~

Edit .bash_profile file using this command.

vi .bash_profile

Add JAVA_HOME and M2_HOME variables.

Assign the path to JDK11 for JAVA_HOME and path to the maven directory for M2_HOME variable.

sudo find / -name java

source .bash_profile

To verify $PATH, use this command.

echo $PATH

To verify Apache Maven, use this command.

mvn -v

Step 4: Install Apache Maven Jenkins plugin

To achieve this, follow these steps:

1. Navigate to “Dashboard“ → “Manage Jenkins“ → “Manage Plugins“ → “Available”.
2. In the search box, enter “Maven”.
3. Choose “Maven Integration” plugin.

And then click the button “Go back to the top page”.

Step 5: Configure Apache Maven Jenkins plugin

To do so, follow these steps:

1. Go to “Dashboard“ → “Manage Jenkins“ → “Global Tool Coonfiguration“ → “JDK”
2. Click the button “Add JDK”.
3. Uncheck “Install automatically”.

Then go to “Maven” section. Click the button “Add Maven”. Uncheck “Install automatically”.

Then add name and MAVEN_HOME path.

Click the “Apply” and “Save” buttons.

Step 6: Integrate Apache Maven into the pipeline

To integrate Apache Maven into the pipeline you need to follow these steps:

1. Navigate to “Dashboard“ → “CI_CD_Pipeline“ → “Configure“ → “Build Steps”.
2. Click “Add build step” button.
3. Choose “Invoke top-level Maven targets” option.
4. Choose “Apache-Maven” as “Maven Version”.
5. Add “clean package” command to “Goals” input.
6. Click “Advanced“ button.
7. Add “pom.xml” to “POM” input.

Finally, you should click “Apply” and “Save” buttons to finish the integration of Apache Maven with the pipeline.

Step 7: Test Apache Maven integrated into the pipeline

cd /var/lib/jenkins/workspace/{your pipeline name}/target

[Module 5]: Docker

Step 1: Launch an AWS EC2 Virtual Server instance

Use instructions from “Launch an AWS EC2 Virtual Server instance” section of this tutorial to finish this step. Do not forget to add a security group setup. It allows Docker and SSH to work on ports 8080 and 22 respectively.

Step 2: Connect to an AWS EC2 Virtual Server instance

sudo chown ansible-admin:ansible-admin /opt/docker

Step 3: Install Docker on the Ansible EC2 virtual server.

sudo mkdir /opt/docker

sudo yum install docker -y

Step 4: Add current user to Docker group on Ansible EC2 virtual server

You need to add the current user “ansible-admin” to the Docker group on the “AnsibleServer” EC2 virtual server to give Docker admin privileges.

sudo usermod -a -G docker ansible-admin

id ansible-admin

Step 5: Launch Docker

sudo systemctl start docker

sudo systemctl status docker

Step 6: Create Dockerfile

If you used the project “Hello” which was offered in “[Module 3]: Git and Github” module, then you don’t need to create a new Dockerfile as this project repository has already contained Dockerfile.

FROM eclipse-temurin:17-jre-jammy
ENV HOME=/opt/app
WORKDIR $HOME
ADD hello-0.0.1-SNAPSHOT.jar $HOME
ENTRYPOINT ["java", "-jar", "/opt/app/hello-0.0.1-SNAPSHOT.jar" ]

sudo touch Dockerfile

vim Dockerfile

Step 7: Login Docker

Now that your Dockerfile is prepared for use, proceed by copying your project's JAR artifact from the **"JenkinsServer"**EC2 instance and pasting it onto the "AnsibleServer" EC2 instance. It is important to note that this transfer will be automated through the pipeline further.

docker login

With this, you have completed the process of logging into Docker and are now ready to proceed with testing.

Step 8: Testing the Docker environment and Dockerfile

docker build -t hello:latest .

docker tag hello:latest zufarexplainedit/hello:latest

docker push zufarexplainedit/hello:latest

[Module 6]: Ansible

Step 1: Create an AWS EC2 Virtual Server instance

Follow instructions from [Module 1]: AWS EC2 Virtual Server section of this tutorial to finish this step and create an EC2 virtual server instance for Ansible.

Step 2: Connect to an AWS EC2 Virtual Server instance

Then click the “Connect” button.

Then you will see this web page. You should again click the “Connect” button.

Step 3: Change the hostname of “AnsibleServer” AWS EC2 Virtual Server instance

sudo vi /etc/hostname

Replace this hostname with “ansible-server”. Then, reboot it.

sudo init 6

Step 4: Add and configure a new user in “AnsibleServer” AWS EC2 Virtual Server instance

Now let’s add a new ansible-admin user to the AWS EC2 Virtual Server instance.

sudo useradd ansible-admin

Then, set the password for ansible-admin user.

sudo passwd ansible-admin

Also, you need to configure user privileges by editing the sudoers file.

sudo visudo

Add “ansible-admin ALL=(ALL) ALL” to this sudoers file.

Also, you need to edit /etc/ssh/sshd_config file to enable PasswordAuthentication.

sudo vi /etc/ssh/sshd_config

sudo service sshd reload

sudo su - ansible-admin

Step 5: Generate key in an AWS EC2 Virtual Server instance

ssh-keygen

Step 6: Install Ansible

Now you can install Ansible on your “AnsibleServer” EC2 virtual server instance.

sudo amazon-linux-extras install ansible2

ansible --version

Step 7: Install Jenkins “Publish over SSH“ plugin on JenkinsServer EC2 instance

As Ansible is installed on your “AnsibleServer” EC2 virtual server instance, you can configure Jenkins to integrate it with Ansible. You need to install the “Publish over SSH” plugin to integrate Jenkins with the EC2 Virtual Server instance where Ansible is installed and with other EC2 Virtual Server instances where Kubernetes is installed.

Go to “Dashboard” → “Manage Jenkins” → “Configure System” → “Available plugins”.

Then enter “Publish over SSH“ in the search box.

Click the button “Install without restart”. Wait for the end of the downloading process.

Step 8: Configure Jenkins “Publish over SSH“ plugin

To do so, follow these steps:

Go to “Dashboard“ → “Manage Jenkins” → “Configure System” → “Publish over SSH”.

Then click the “Apply” and “Save” buttons.

Here you have finished configuring the “Publish over SSH“ Jenkins plugin.

Step 9: Create new Docker directory in AnsibleServer

Go to “/opt” folder in AnsibleServer EC2 instance.

cd /opt

Create a new folder “docker” there.

sudo mkdir docker

Give privileges to this “docker” folder.

sudo chown ansible-admin:ansible-admin docker

Now, check the “docker” folder privileges by executing this command.

ll

You can see that the “docker” folder is accessible with the “ansible-admin” user.

Step 10: Integrate “Publish over SSH“ Github plugin into the pipeline

Now as “Publish over SSH“ Github plugin is installed and configured, you're now able to integrate it into the pipeline which you created in the “[module 2]: Jenkins Server” to transfer a project jar artifact from “JenkinsServer” to “AnsibleServer”.

Well, to integrate “Publish over SSH“ Github plugin into the pipeline you need to follow these steps:

1. Navigate to “Dashboard“ → “CI_CD_Pipeline“ → “Configure“ → “Post-build Actions”.
2. Click “Add post-build action” button.
3. Choose “Send build artifacts over SSH” option.
4. Add “AnsibleServer” into “Name” input in “SSH Server” section**.**
5. Add  “target/*.jar” into “Source files” input in “Transfer Set” section**.**
6. Add  “target/” into “Remove prefix” input in “Transfer Set” section**.**
7. Add  “//opt/docker/” into “Remote directory” input in “Transfer Set” section**.**
8. For now, simply put an empty string in the 'Exec command' input under the 'Transfer Set' section.

Finally, you should click “Apply” and “Save” buttons to finish the integration “Publish over SSH“ plugin with the pipeline.

Step 11: Test “Publish over SSH“ Github plugin integrated into the pipeline

Now you can use your updated pipeline to transfer a project jar artifact from “JenkinsServer” to “AnsibleServer”. To do that you need to click the “Build Now” button. As a result you will see a successful job result in the build history.

If you open your “AnsibleServer” AWS EC2 terminal. You can check that the pipeline works well.

cd /opt/docker

Step 12: Configure Ansible hosts

1. Specify hosts directly in the playbook: In your playbook, you can set the hosts parameter to a list of IP addresses or hostnames.
2. Use an inventory file: Ansible allows you to define a list of hosts in an inventory file and reference this file when running your playbook. The default inventory file is /etc/ansible/hosts.

By editing /etc/ansible/hosts, you can easily manage groups of hosts without having to write out their IP addresses each time you run a playbook.

sudo ifconfig

sudo vi /etc/ansible/hosts

Step 13: Configure Passwordless SSH authentication to localhost for Ansible

sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected]

Now you can see “Number of key(s) added: 1”. It means that the passwordless SSH authentication installation was successfully completed.

Step 14: Create a new Ansible playbook for Docker tasks

1. Start by creating a new Ansible playbook file. Just use this command.

touch hello-app.yml

2. Then, edit the newly made hello-app.yml file. Open it up for editing with this command.

vi hello-app.yml

3. Inside the file, type in the following stuff.

---
- hosts: ansible
  user: root

  tasks:
    - name: create docker image
      command: docker build -t hello:latest .
      args:
        chdir: /opt/docker

    - name: create tag to push image onto dockerhub
      command: docker tag hello:latest zufarexplainedit/hello:latest

    - name: push docker image onto dockerhub
      command: docker push zufarexplainedit/hello:latest

Step 13: Test the Ansible playbook with Docker tasks

cd /opt/docker

sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml

Step 14: Integrate Ansible Docker tasks into the pipeline

Now as “Publish over SSH“ Github plugin, Ansible and Docker are installed and configured, you're now able to integrate them all into the pipeline which you created in the “[module 2]: Jenkins Server” to transfer a project jar artifact from “JenkinsServer” to “AnsibleServer” and then build a new Docker image from your project and then push this Docker image onto Dockerhub.

To achieve it you need to follow these steps:

1. Navigate to “Dashboard“ → “CI_CD_Pipeline“ → “Configure“ → “Post-build Actions” → “Send build artifacts over SSH” .
2. Add “sudo -u ansible-admin ansible-playbook /opt/docker/hello-app.yml” command into “Exec command” input.

Finally, click “Apply” and “Save” buttons to finish the integration Ansible Docker tasks with the pipeline.

Step 15: Test “Ansible playbook with Docker tasks“ integrated into the pipeline

Now you can test your upgraded pipeline to seamlessly transfer a project jar artifact from “JenkinsServer” to “AnsibleServer” then build a new Docker image from your project and then push this Docker image onto Dockerhub. To do that you need to click the “Build Now” button. As a result you will see a successful job result in the build history.

[Module 7]: Kubernetes

Now let’s configure K8s on the EC2 instance. You are going to create a new EC2 instance and install their kubectl command-line tool for interacting with a Kubernetes cluster further.

Step 1: Launch an AWS EC2 Virtual Server instance

Use instructions from “Launch an AWS EC2 Virtual Server instance” section of this tutorial to finish this step.

Step 2: Connect to an AWS EC2 Virtual Server instance

Step 3: Change the hostname of “KubernetesServer” AWS EC2 Virtual Server instance

sudo vi /etc/hostname

Replace this hostname with “kubernetes-server” and then reboot it.

sudo init 6

Step 4: Check AWS CLI version

Use this command to check the AWS version.

aws --version

If you can see version aws-cli/1.18, you should download the latest version.

Step 5: Update AWS CLI

Copy-paste the curl command.

curl "//awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

unzip awscliv2.zip

sudo ./aws/install

aws --version

Step 6: Install kubectl

Now you need to install kubectl command-line tool for interacting with a Kubernetes cluster further. To that you need to go to AWS → Documentation → Amazon EKS → User Guide → Installing or updating kubectl → Linux.

curl -O //s3.us-west-2.amazonaws.com/amazon-eks/1.27.1/2023-04-19/bin/linux/amd64/kubectl

chmod +x kubectl

sudo mv kubectl /usr/local/bin

kubectl version --output=yaml

Step 7: Install eksctl

curl --silent --location "//github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp

sudo mv /tmp/eksctl /usr/local/bin

eksctl version

Step 8: Create IAM Role for eksctl

You need to create an IAM role and attach it to your “KubernetesServer” EC2 instance.

Go to IAM Dashboard → Roles.

Click the button “Create role” on the IAM roles web page.

Then choose “AWS service” , “EC2”. And the click “Next” button.

Then, find “AmazonEC2FullAccess”, “AmazonEC2FullAccess“, “IAMFullAccess“, “AWSCloudFormationFullAccess“ in the search box and then click the “Add permissions” button.

And then click the “Next” button.

Then type “Eksctl_Role” into “Role name” input.

And the click “Create role” button.

Step 9: Connect IAM Role with eksctl

Go to the AWS EC2 instance web page. Choose “KuberbetesServer”. Then click “Actions” → “Security” → “Modify IAM Role”.

Choose “Eksctl_Role” and then click the “Update IAM role” button.

Now your IAM Role is connected with your “EKS_Server” and eksctl tool.

Step 10: Create eksctl cluster

To achieve this, follow these steps:

1. Modify the following command with your specific information.

eksctl create cluster --name cluster-name  \
--region region-name \
--node-type instance-type \
--nodes-min 2 \
--nodes-max 2 \ 
--zones <AZ-1>,<AZ-2>

eksctl create cluster --name zufarexplainedit  \
--region eu-north-1 \
--node-type t3.micro

2. Execute the modified command and patiently await the completion of the cluster creation process. You will notice that the EKS cluster status is indicated as "creating" on the AWS CloudFormation web page.

   
   

Furthermore, you can verify the successful EKS cluster creation status on the AWS CloudFormation web page.

Step 11: Create Kubernetes Deployment yaml file

touch hello-app-deployment.yaml

vi hello-app-deployment.yaml

apiVersion: apps/v1 
kind: Deployment
metadata:
  name: zufarexplainedit-hello-app
  labels: 
     app: hello-app

spec:
  replicas: 2 
  selector:
    matchLabels:
      app: hello-app

  template:
    metadata:
      labels:
        app: hello-app
    spec:
      containers:
      - name: hello-app
        image: zufarexplainedit/hello
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1

Step 12: Create Kubernetes Service yaml file

touch hello-app-service.yaml

vi hello-app-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: zufarexplainedit-hello-app-service
  labels:
    app: hello-app 
spec:
  selector:
    app: hello-app 

  ports:
    - port: 8080
      targetPort: 8080

  type: LoadBalancer

Step 13: Test Kubernetes cluster using kubectl

1. Apply Deployment.

   Use the following command to apply the deployment configuration.

kubectl apply -f hello-app-deployment.yaml

2. Apply Service.

kubectl apply -f hello-app-service.yaml

3. Check LoadBalancer Status.

   Monitor the status of your service using.

kubectl get service zufarexplainedit-hello-app-service

4. Access Your Application.

   Using a web browser, enter the assigned external IP address followed by :8080. After a brief moment, the page will load, displaying the "HelloWorld" message. Keep in mind that the initial loading might take a few seconds.

   
   

   

   
   

kubectl delete deployments --all

kubectl delete pods --all

kubectl delete services --all

eksctl delete cluster --name {your cluster name} --region {your region name} 

eksctl delete cluster --name zufarexplainedit --region eu-north-1

Step 14: Add and configure a new user in “KubernetesServer” AWS EC2 Virtual Server instance

Now let’s add a new ansible-admin user to “KubernetesServer” AWS EC2 Virtual Server instance.

sudo useradd ansible-admin

Then, set the password for ansible-admin user.

sudo passwd ansible-admin

Also, you need to configure user privileges by editing the sudoers file.

sudo visudo

Add “ansible-admin ALL=(ALL) ALL” to this sudoers file.

Also, you need to edit /etc/ssh/sshd_config file to enable PasswordAuthentication.

sudo vi /etc/ssh/sshd_config

sudo service sshd reload

sudo su - ansible-admin

Step 15: Generate key in an AWS EC2 Virtual Server instance

You are planning to manage remote servers such as K8s EC2 virtual server instance further in this article. That is why you need to set up SSH keys.

ssh-keygen

Step 16: Configure Passwordless SSH authentication to localhost for Ansible

sudo ssh-copy-id -i /home/{your user name}/.ssh/id_rsa.pub {your user name}@{your host address}

sudo ssh-copy-id -i /home/ansible-admin/.ssh/id_rsa.pub [email protected]

Now you can see “Number of key(s) added: 1”. It means that the passwordless SSH authentication installation was successfully completed.

Step 17: Configure Ansible hosts in AnsibleServer EC2 instance

When you run an Ansible playbook, you specify the hosts it should run on. In this step you need to specify KubernetesServer EC2 instance host. To do that you need to repeat the same steps which you passed in “[Module 6]: Ansible”.

sudo ifconfig

sudo vi /etc/ansible/hosts

Step 18: Create a new Ansible playbook for Kubernetes tasks

1. Start by creating a new Ansible playbook file. Just use this command.

touch kubernetes-hello-app.yml

2. Then, edit the newly made hello-app.yml file. Open it up for editing with this command.

vi kubernetes-hello-app.yml

3. Inside the file, type in the following:

---
- hosts: kubernetes

  tasks:
    - name: deploy regapp on kubernetes
      command: kubectl apply -f hello-app-deployment.yaml

    - name: create service for regapp
      command: kubectl apply -f hello-app-service.yaml

    - name: update deployment with new pods if image updated in docker hub
      command: kubectl rollout restart deployment.apps/zufarexplainedit-hello-app

Step 19: Integrate a new Ansible playbook for Kubernetes tasks with Jenkins

1. Go to JenkinsServer → Jenkins dashboard → New Item.
2. Create new Jenkins Freestyle project with the name “CD-Job”.

   
   

   

   
   

3. Click “OK” button.
4. Go to “Post-build Actions” section.
5. Click the “Add post-build action” button.
6. Choose “Send build artifacts over SSH” option.
7. Choose “AnsibleServer” as SSH Server.
8. Add this command to “exec command” input.

   
   

sudo -u ansible-admin ansible-playbook /opt/docker/kubernetes-hello-app.yml

9. Click “Apply” and “Save” buttons.
10. Go to Jenkins dashboard → “CI_CD_Pipeline” → Configure → “Post-build Actions” section.
11. Click the “Add post-build action” button.
12. Choose “Build other projects” option.
13. Go to “Build other projects” section.
14. Choose “Trigger only if build is stable” option.
15. Add “CD-Job” to “Project to build” input.

    
    

    
    

    

    
    

16. Click “Apply” and “Save” buttons.

    
    

Step 20: Testing the Final Pipeline Version

Conclusion

About the author

Zufar Sunagatov is an experienced senior software engineer who is passionate about designing modern software systems.

• Developed high-performance distributed systems using Java, Kotlin, AWS, Docker, and Kubernetes for companies like Citi (London), MTS (Moscow) and others ().
• Founded Ice Latte, an open-source online marketplace from scratch (you can join Zufar’s team and contribute to his project on GitHub: ).
• Established the ZufarExplainedIT community to share his knowledge and experience with others (you can follow Zufar's IT Telegram community: ).
• Mentored for over 3000 minutes and conducted 60 sessions on ADPlist, nurturing aspiring talents ().
• Engaged audiences as a speaker at conferences and IT YouTube channels, sharing invaluable insights (examples of his YouTube videos include: , ).
• Authored highly popular IT articles with 7000+ views each (examples of his articles are: “Microservice Architecture Patterns Part 1: Decomposition Patterns”, ).