A Deployment provides declarative updates for Pods and ReplicaSets.
a Deployment is an object that manages the deployment and scaling of a set of pods.

Steps:

1. Create EC2 instance.
   Requirements:-
   - 2 CPUs or more
   - 2GB of free memory

2. Install docker, minikube, kubectl.

3. Clone the repository to your local.

4. Build docker image from a dockerfile given in the github repository. Now verify if the image is created.

   

5. Now push this image to the docker hub.

6. Now create the deployment.yml file. I have mentioned the YAML file image below.

   

7. Let's create this deployment. Run this command

    kubectl apply -f deployment.yml
   

8. Let us verify if any pods are created. Run this command

    kubectl get pods
   

9. Let us test if the container we created is working or not so login to kubernetes cluster. Run this command

    minikube ssh
   

10. Then connect to the application using the container's IP. Run this command

    curl -L http://<container_ip>:8001
    

So the deployment I created and working successfully.
Now check the auto-healing and autoscaling features by deleting one pod

kubectl get pods
kubectl delete pod <podname>

You can observe that one pod is created , proving that those came up automatically after the deletion of pods. This is the feature of k8s: auto-scaling and auto-healing.

11. Let's create service.yaml file. We will use the service NodePort.
    I have mentioned the service.yaml below.

    

    12. Now let's apply this service to the K8s cluster using the:

        kubectl apply -f service.yaml
        

Then verify if the service is created:

    kubectl get service

13. To access the pod outside we would need service url:

minikube service todo-app --url

This command will give us service url.

Now we can access pod outside the minikube:

curl -L <service url>

14. Now we will edit "/etc/hosts" for host IP allocation :

    sudo vim /etc/hosts
    

    Now paste sevice IP ( 192. 168.49.2 ) <space> <give a name to your IP>

    192. 168.49.2 todo-app . com
    

    Now check todo-app. com :

    curl -L http: // todo-app. com: 30007
    

GitLab Runner is an application that works with GitLab CI/CD to run jobs in a pipeline.

How to install Gitlab-runner on linux (Ubuntu) 64-bit machine ?

Step 1. Run this command on your Linux terminal:

sudo curl -L --output /usr/local/bin/gitlab-runner https://s3.dualstack.us-east-1.amazonaws.com/gitlab-runner-downloads/latest/binaries/gitlab-runner-linux-amd64

Step 2. Give it permissions to execute:

sudo chmod +x /usr/local/bin/gitlab-runner

Step 3.Create a GitLab CI user:

sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash

Step 4.Install and run as service:

sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner

sudo gitlab-runner start

Step 5.Generate runner authentication token

How to generate runner authentication token on gitlab ?

To create an instance runner:

1. On the left sidebar, at the bottom, select Admin Area.

2. Select CI/CD > Runners.

3. Select New instance runner.

4. Select the operating system where GitLab Runner is installed.

5. In the Tags section, in the Tags field, enter the job tags to specify jobs the runner can run. If there are no job tags for this runner, select Run untagged.

6. Optional. In the Runner description field, to add a runner description that displays in GitLab, enter a runner description.

7. Optional. In the Configuration section, add additional configurations.

8. Select Create runner.

   

Step 6. Register a runner.

Prerequisites:

• Obtain a runner authentication token. You can either:

  • Create a shared, group, or project runner.

sudo gitlab-runner register

Enter Gitlab instance URL :- https://gitlab.com/

Then Enter Gitlab Runner Authentication Token and select executor.

Please follow this document to setup executors during registering a runner**.**

https://docs.gitlab.com/runner/executors/

Step 7. How to configure gitlab-runner on gitlab pipeline ?

When you register a runner, you can add tags to it.

When a CI/CD job runs, it knows which runner to use by looking at the assigned tags. Tags are the only way to filter the list of available runners for a job.

For example, if a runner has the build tag, you would add this code to your project’s .gitlab-ci.yml file:

In gitlab project Navigate to gitlab.ci.yml configure this command:

tags:
 - Build

Example:-

Important note: Tag should be same in runner and gitlab.ci.yml.

To begin, launch an EC2 server and make sure to enable inbound rules for ports 22, 8080, and 8000. These ports are crucial for successful configuration.

Step 2: Connect to the Server via SSH

Next, establish a connection to the server using the SSH command. This will allow you to interact with the server's command line.

Step 3: Install Java JDK and Jenkins Using Shell Script

To install Java JDK and Jenkins, follow these steps:

1. Install Java JDK

    sudo apt-get install openjdk-17-jdk
   

2. Install Jenkins

    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
    sudo apt-get install jenkins
   

3. Grant Jenkins access to build and run Docker images:

    sudo usermod -aG docker jenkins
    sudo reboot
   

4. Access Jenkins by entering your EC2 instance's public IP followed by port 8080 in your browser. Obtain the initialAdminPassword by running:

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

   Copy and paste the password in the provided tab and install all the necessary plugins.

5. Install Docker

    Sudo apt-get install docker.io
   

Step 4: Creating a Declarative Pipeline

Now, let's create a declarative pipeline in Jenkins:

1. Click on "New Item" and name it "my-note-app-cicd-pipeline".

2. Under the configuration settings, select the GitHub project and provide the repository URL:

    https://github.com/LondheShubham153/django-notes-app
   

   Set the name to "Django notes app".

   

3. In the "Pipeline" section, choose "Pipeline Script" and add the following script:

    pipeline{
   
        agent any
   
            stages{
                stage("Cloning Code"){
                    steps{
                        echo "Cloning the code from github"
                        git url: "https://github.com/LondheShubham153/django-notes-app.git" , branch: "main"
                    }
                }
                stage("Build Docker Image"){
                    steps{
                        echo "Building Docker Image"
                        sh "docker build -t ritik3311/django-notes-app:0.1 ."
                    }
                }
   
                stage("Push to Dockerhub"){
                    steps{
                        echo "Pushing Docker image to Dockerhub"
                        withCredentials([usernamePassword(credentialsId:"dockerhub" ,passwordVariable:"dockerhubPass", usernameVariable:"dockerhubUser")]){
                            sh "docker login -u ${env.dockerhubUser} -p ${env.dockerhubPass}"
                            sh "docker push ritik3311/django-notes-app:0.1"
                        }
                    }
                }
   
                stage("Deploy"){
                    steps{
                        echo "Deploying Django Notes App on AWS EC2"
                        sh "docker run -d -p 8000:8000 ritik3311/django-notes-app:0.1"
                    }
                }
            }
    }
   

   

   Before building, make sure to follow these additional steps:

   1. Add DockerHub credentials in the global credentials section with the ID as "dockerHub" along with the username and password.

      

Once everything is set up, you can manually trigger the pipeline by clicking the build button in the Jenkins interface.

Congratulations Our Django Notes App is Successfully Deployed!

Congratulations! Our Notes App is now deployed and ready to use. Enjoy the benefits of automation and continuous integration.

Creating EC2 Instances

Create two EC2 Instances

1st for Jenkins and Docker

2nd for SonarQube

Setting Security Group

Under the security details for instance, click on security groups and then click on "Edit Inbound rules".

Generally, there is only one rule present for port 22 for SSH.
We have to add some more rules as:

In 1st Instance

• Port 8080, for Jenkins

• Port 8000, for exposing our web application

  Set the source to "Anywhere-IPv4" i.e. 0.0.0.0/0

  Now, click on save rules to save your changes.

In 2nd Instance

• Port 9000, for SonarQube

  Set the source to "Anywhere-IPv4" i.e. 0.0.0.0/0

  Now, click on save rules to save your changes

Setting up Instances

Now install Jenkins and Docker on 1st instance and

Install SonarQube on 2nd instance

To install Jenkins, Docker and SonarQube on instances, firstly you have to ssh to your instance in your terminal by selecting that instance and then clicking on connect.

Now install Jenkins https://www.jenkins.io/doc/book/installing/linux/

Now install Docker "sudo apt-get install docker.io"

Now, copy the public IPv4 address of Jenkins, paste it into your browser, and put the port number 8080 after it in the format i.e <ip_address>:8080

To unlock jenkins paste the secret key to Administrator password, you can get it with the following command:

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

After unlocking Jenkins click on "Install suggested plugins" and then provide the basic details on the "Create First Admin User" page and get to the Jenkins dashboard after completing all the required steps.

Installing SonarQube on 2nd EC2 Instance

To install SonarQube to your instance run the following command in your terminal:

sudo apt update
sudo apt install openjdk-17-jre
wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-10.0.0.68432.zip

To unzip the zip file, run the following command:

sudo apt install unzip
unzip sonarqube-10.0.0.68432.zip

Now, head over to the Linux directory to execute the installation file:

cd /home/ubuntu/sonarqube-10.0.0.68432/bin/linux-x86-64
./sonar.sh console
#this will start the SonarQube on port 9000

Integrating SonarQube For Jenkins

Copy the Public IP of SonarQube and paste it on the browser and put port 9000 after it in such format <public IP>:9000
For ex:- 54.174.102.233 :9000

Now, login with username - admin & password - admin

After login and changing your password, you'll land on the SonarQube dashboard.

Click "Manually" icon.

Give a name to your Project and provide the name of the branch you want to analyze.

Now, we have many options to select for Continuous Integration tools. For now, we will move forward with Jenkins.

On the next page, we'll choose GitHub for the DevOps platform.

Now, it will ask for configuration. Click continue up to the 3rd step and select other as we are going to deploy our application. Copy the code that it is providing and save it somewhere safe as we will going to use it later.

Click on Finish this tutorial to save it, and after saving it move to My Accounts>Security>Generate Tokens

Now, create a Token for integrating with Jenkins.

Copy the token and save it somewhere safe, as we are going to use it later.

Now open Jenkins

Now, head over to Jenkins Dashboard, by pasting the Public IP of Jenkins and put port 8080 after it in such fromat <Public IP>:8080

We have to install some plugins on Jenkins for setting up SonarQube.

On Jenkins Dashboard, click on Manage Jenkins>>Manage Plugins>>Available Plugins

Now, in Available Plugins, search for SonarQube Scanner .
After selecting them click on "Install without restart".

On Jenkins Dashboard click on Manage Jenkins>>Global Tool Configuration and search for SonarQube Scanner under it.

After clicking on "Add SonarQube Scanner", give a suitable name to it and check on Install automatically for its installation, and then save it.

Now, on Manage Jenkins>>Configure system, search for SonarQube servers and click on "Add SonarQube"

Name it accordingly, copy the Public IP of SonarQube and paste it, and put port 9000 after it in such format http://<Public IP>:9000 . Apply & save it.

Create a Jenkins Job for Deploying our Web Application

On the Jenkins Dashboard, click on "Create a Job".

Give it a name, select the type of pipeline you want to create, and then click "OK".

Under the configuration setting, select "Git" for Source Code Management. Copy and paste the git link from the GitHub repository.

Specify the branch you want to build and deploy.

Configuring Pipeline for SonarQube

Search for Build Steps and click on "Add build step" and select "SonarQube Scanner".

Now, paste the code in the Analysis Properties field, which you copied from SonarQube which we kept saved.

Apply and save it, and head over to Jenkins Dashboard>>Manage Plugins>>Configure System and add server authentication token for SonarQube by clicking on "Add", and selecting Jenkins.

Change Kind to secret text and paste the secret token key which we copied earlier and saved it. Give it an ID name accordingly.

Now, for the server authentication token, from the scroll bar select the ID name, the one which you just created.

Configuring Pipeline for Docker

Under the CI-CD Pipeline on Jenkins Dashboard click on "Configure", search for Build Steps, and select Execute shell.

Apply and save it.

Now, under the CI-CD Pipeline, click "Build Now".
If everything works fine, then you'll see success. Here is our live website working on Port 8000 on Docker.

Now check SonarQube