We will learn how to create new EC2 instances using the Ansible playbook and automate using Jenkins Pipeline. in the end, we will play the game of 2048.

Launch an Ubuntu(22.04) T2 medium Instance

Launch an AWS T2 medium Instance. Use the image as Ubuntu. You can create a new key pair or use an existing one. Enable HTTP and HTTPS settings in the Security Group.

Install Jenkins and Trivy

To Install Jenkins

Connect to your console, and enter these commands to Install Jenkins

vi jenkins.sh

#!/bin/bash
sudo apt update -y
wget -O - https://packages.adoptium.net/artifactory/api/gpg/key/public | tee /etc/apt/keyrings/adoptium.asc
echo "deb [signed-by=/etc/apt/keyrings/adoptium.asc] https://packages.adoptium.net/artifactory/deb $(awk -F= '/^VERSION_CODENAME/{print$2}' /etc/os-release) main" | tee /etc/apt/sources.list.d/adoptium.list
sudo apt update -y
sudo apt install temurin-17-jdk -y
/usr/bin/java --version
curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | sudo tee \
                  /usr/share/keyrings/jenkins-keyring.asc > /dev/null
echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
                  https://pkg.jenkins.io/debian-stable binary/ | sudo tee \
                              /etc/apt/sources.list.d/jenkins.list > /dev/null
sudo apt-get update -y
sudo apt-get install jenkins -y
sudo systemctl start jenkins
sudo systemctl status jenkins

sudo chmod 777 jenkins.sh
./jenkins.sh    # this will installl jenkins

Once Jenkins is installed, you will need to go to your AWS EC2 Security Group and open Inbound Port 8080, since Jenkins works on Port 8080.

Now, grab your Public IP Address

<EC2 Public IP Address:8080>
sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Unlock Jenkins using an administrative password and install the suggested plugins.

Jenkins will now get installed and install all the libraries.

Create a user click on save and continue.

Jenkins Getting Started Screen.

Install Trivy

vi trivy.sh

sudo apt-get install wget apt-transport-https gnupg lsb-release -y
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb $(lsb_release -sc) main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy -y

Install Ansible

connect to your Jenkins machine using Putty or Mobaxtreme

Now we are going to run the below commands on the Jenkins machine

Step1:Update your system packages:

sudo apt-get update

Step 2: First Install Required packages to install Ansible.

sudo apt install software-properties-common

Step3: Add the ansible repository via PPA

sudo add-apt-repository --yes --update ppa:ansible/ansible

Install Python3 on Jenkins for Ansible

sudo apt install python3

Install Ansible on Ubuntu 22.04 LTS

sudo apt install ansible -y

sudo apt install ansible-core

Step2: To check version :

ansible --version

Install Python-pip3:

sudo apt install python3-pip -y
( this is just comment -  Package manager for python)Install Boto Framework - AWS SDKsudo pip3 install boto boto3

Install Boto Framework – AWS SDK

sudo pip3 install boto boto3

Ansible will access AWS resources using Boto SDK.

sudo apt-get install python3-boto -y
pip list boto | grep boto

(the above command should display the below output)

let’s create and attach an IAM role to Jenkins machines for the provision of a new ec2 instance

Navigate to AWS CONSOLE

Click the “Search” field.

Type “IAM enter“

Click “Roles”

Click “Create role”

Click “AWS service”

Click “Choose a service or use case”

Click “EC2”

Click “Next”

Click the “Search” field.

Add permissions policies

AmazonEC2FullAccess

click Next

Click the “Role name” field.

Type “Jenkins-cicd”

Click “Create role”

Click “EC2”

go to the Jenkins instance and add this role to the Ec2 instance.

select Jenkins instance –> Actions –> Security –> Modify IAM role

Add a newly created Role and click on Update IAM role.

Let’s go to the Jenkins machine and add the Ansible Plugin

Manage Jenkins –> Plugins –> Available Plugins

search for Ansible and install

Give this command in your Jenkins machine to find the path of your ansible which is used in the tool section of Jenkins.

which ansible

Copy that path and add it to the tools section of Jenkins at ansible installations.

Ansible Playbook

---
- name: Provisioning a new EC2 instance and security group
  hosts: localhost
  connection: local
  gather_facts: False
  tags: provisioning
  pre_tasks:
    - name: Gather facts
      setup:
    - name: Print python version
      debug:
        msg: "Using Python {{ ansible_python_version }}"
    - name: Install dependencies
      shell: "/usr/bin/python3.10 -m pip install {{ item }}"
      loop:
       - boto3
       - botocore
  vars:
    ansible_python_interpreter: /usr/bin/python3.10
    keypair: Mumbai
    instance_type: t2.micro
    image_id: ami-0f5ee92e2d63afc18
    wait: yes
    group: webserver
    count: 1
    region: ap-south-1
    security_group: ec2-security-group
    tag_name:
      Name: Aj-ec2
  tasks:
    - name: Create a security group
      amazon.aws.ec2_group:
        name: "{{ security_group }}"
        description: Security Group for webserver Servers
        region: "{{ region }}"
        rules:
          - proto: tcp
            from_port: 22
            to_port: 22
            cidr_ip: 0.0.0.0/0
          - proto: tcp
            from_port: 8080
            to_port: 8080
            cidr_ip: 0.0.0.0/0
          - proto: tcp
            from_port: 3000
            to_port: 3000
            cidr_ip: 0.0.0.0/0
          - proto: tcp
            from_port: 80
            to_port: 80
            cidr_ip: 0.0.0.0/0
          - proto: tcp
            from_port: 443
            to_port: 443
            cidr_ip: 0.0.0.0/0
        rules_egress:
          - proto: all
            cidr_ip: 0.0.0.0/0
      register: basic_firewall
    - name: Launch the new EC2 Instance
      amazon.aws.ec2_instance:
        security_group: "{{ security_group }}"
        instance_type: "{{ instance_type }}"
        image_id: "{{ image_id }}"
        wait: "{{ wait }}"
        region: "{{ region }}"
        key_name: "{{ keypair }}"
        count: "{{ count }}"
        tags: "{{ tag_name }}"
        user_data: |
          #!/bin/bash
          sudo apt update -y
          sudo apt install docker.io -y
          sudo systemctl start docker
          sudo systemctl enable docker
          sudo docker run -d --name 2048 -p 3000:3000 sevenajay/2048:latest
      register: ec2

Write a sample pipeline for Provision

pipeline {
    agent any
    tools{
        ansible 'ansible'
    }
    stages {
        stage('cleanws') {
            steps {
                cleanWs()
            }
        }
        stage('checkout'){
            steps{
                git branch: 'main', url: 'https://github.com/Aj7Ay/ANSIBLE.git'
            }
        }
        stage('TRIVY FS SCAN') {
            steps {
                sh "trivy fs . > trivyfs.txt"
            }
        }
        stage('ansible provision') {
          steps {
             // To suppress warnings when you execute the playbook
             sh "pip install --upgrade requests==2.20.1"
             ansiblePlaybook playbook: 'ec2.yaml'
            }
        }
    }
}

stage view

Provision Ec2-instance

copy the Public IP of the provisioned instance

<public-ip:3000>

Play Game 2048

Delete the instances.

Continuous improvement is not just about doing the same thing better. It’s about reimagining what’s possible and striving for excellence in every line of code, every pipeline, and every deployment. In the world of Jenkins and Ansible, automation is the key to unlocking innovation. So, keep coding, keep automating, and keep pushing the boundaries of what’s achievable. Your journey has just begun.

Thanks for Reading my Blog.