DevOps
Index
Sr. No. Date Program List Pg. No Sign
Git and GitHub
practical
Creating a GitHub
1 12-02-2025 Repository and
Managing
Version Control
Using Command
Line
Jenkins
2 21-02-2025
Installation
Jenkins Pipeline
3 27-02-2025
Creation
Setting Up a
Simple Python
4 03-03-2025
Application with
Docker
Setting Up a
Simple Python
5 10-03-2025
Application with
Docker
Docker Compose:
6 16-03-2025
Multi-Container
DevOps 1
Sr. No. Date Program List Pg. No Sign
Install & Set Up
Ansible on
7 25-03-2025
Windows (via
WSL)
Kubernetes Setup
on Windows 11
8 12-04-2025
(Minikube +
Docker)
Grafana +
Prometheus
Setup on
9 24-04-2025
Windows 11
(Locally with
Docker)
Session 1 (Git and GitHub practical)
1. Prerequisites:
a. Install Git on your local machine: Download Git
b. Create a GitHub account: GitHub Signup
2. Step 1: Create a Repository on GitHub
a. Log in to your GitHub account.
b. Click on the "+" icon at the top right corner and select "New repository".
c. Fill in the repository details:
i. Repository Name: (e.g., my-project )
ii. Description: (optional)
iii. Public/Private: (choose based on your preference)
DevOps 2
iv. Initialize with a README: (uncheck this if you want to create locally)
d. Click "Create repository".
3. Step 2: Initialize Git in Your Local Project
a. Open a terminal (command line) in your project directory:
cd /path/to/your/project
b. Initialize the Git repository:
This command creates a hidden
.git directory that contains all the necessary metadata for the repository.
git init
4. Step 3: Add Remote Repository
a. Copy the URL of your GitHub repository (from the "Quick setup" page
after creating the repository on GitHub).
b. Add the remote repository URL:
Replace
yourusernameand my-project with your GitHub username and repository name,
respectively.
git remote add origin <https://github.com/yourusername/my-project.gi
t>
5. Step 4: Commit and Push Initial Project Files
a. Stage all files for the first commit:
git add .
The . tells Git to add all files in the current directory.
b. Commit the files:
DevOps 3
git commit -m "Initial commit"
The -m flag allows you to add a commit message.
c. Push the commit to GitHub:
git push -u origin master
The -u flag sets the upstream for the master branch, meaning future git
push commands will know where to push by default.
d. You could encounter the problem of setting your identity first before
uploading the code to your remote repository; the solution is
git config --global user.name "Your Github Name (Not UserName)"
git config --global user.email "Your Github email address"
e. Push the commit to GitHub:
git push -u origin master
The -u flag sets the upstream for the master branch, meaning future git
push commands will know where to push by default.
6. Step 5: Making Changes and Pushing Updates
Whenever you make changes to your code, follow these steps:
a. Check the status of your repository:
git status
This will show you which files have changed.
b. Stage the changed files:
git add .
DevOps 4
You can also stage specific files by replacing . with the filenames.
c. Commit the changes:
git commit -m "Describe your changes"
d. Push the changes to GitHub:
git push
7. Additional Useful Commands
a. Check the commit history:
git log
b. Clone an existing repository:
git clone <https://github.com/username/repository.git>
c. Create and switch to a new branch:
git checkout -b new-branch
d. Merge changes from another branch:
git merge branch-name
e. Pull the latest changes from the remote repository:
git pull
DevOps 5
Session 2 (Jenkins Installation)
1. Step 1: Install Java (JDK 11 or 17)
a. Jenkins requires Java to run.
i. Download:
1. Go to https://adoptium.net/
2. Download Temurin JDK 17 (LTS) for Windows (x64).
b. Install:
i. Run the installer and follow prompts.
ii. During installation, check "Set JAVA_HOME environment variable."
c. Verify Java Installation:
i. Open Command Prompt and run:
java -version
ii. You should see something like:
openjdk version "17.0.x"
2. Step 2: Download Jenkins
a. Go to:
i. https://www.jenkins.io/download/
b. Choose "Windows" > Download the .msi installer (Recommended for
beginners).
DevOps 6
3. Step 3: Install Jenkins
a. Run the .msi installer:
i. It will install Jenkins as a Windows Service.
DevOps 7
ii. Default installation path: C:\Program Files\Jenkins
DevOps 8
iii. Default port: 8080
DevOps 9
b. When prompted:
i. Leave the default port as 8080
ii. Select the installed Java path (should auto-detect)
DevOps 10
4. Step 4: Unlock Jenkins for First Use
a. After installation completes:
b. Open your browser and go to: http://localhost:8080
c. You’ll be asked for an unlock key.
d. Go to:
C:\Program Files\Jenkins\secrets\initialAdminPassword
e. Copy the password from that file and paste it into the browser.
DevOps 11
5. Step 5: Install Suggested Plugins
a. Select "Install suggested plugins"
b. Jenkins will install essential plugins like Git, Build tools, etc.
DevOps 12
6. Step 6: Create First Admin User
a. After plugin installation, you’ll be prompted to create:
i. Username
ii. Password
iii. Full name
iv. Email
7. Step 7: Jenkins Dashboard
a. Once setup is complete, you’ll be taken to the Jenkins Dashboard.
b. You’re now ready to create jobs, configure pipelines, etc.
DevOps 13
8. Verify Jenkins Service
a. You can verify Jenkins is running as a Windows Service:
b. Press Win + R , type services.msc , and press Enter.
c. Look for "Jenkins" in the list.
d. Make sure its status is 'Running' and startup type is 'Automatic'.
e. 🚀 Jenkins is Installed!
f. You can now access it via:
http://localhost:8080
Session 3 (Jenkins Pipeline Creation)
1. Step 1: Start Jenkins
a. Make sure Jenkins is running:
DevOps 14
b. Open browser → go to: http://localhost:8080
2. Step 2: Create a New Pipeline Job
a. On the Jenkins Dashboard, click "New Item".
b. Enter a name (e.g., MyFirstPipeline ).
c. Select “Pipeline”.
d. Click OK.
3. Step 3: Configure the Pipeline
a. You'll be taken to the project configuration page.
b. In the Pipeline section:
c. Definition: Choose Pipeline script (to write inline script)
4. Script: Paste the following example:
pipeline {
agent any
DevOps 15
stages {
stage('Build') {
steps {
echo 'Building the project...'
}
}
stage('Test') {
steps {
echo 'Running tests...'
}
}
stage('Deploy') {
steps {
echo 'Deploying application...'
}
}
}
}
5. Step 4: Save and Run the Pipeline
a. Click Save.
b. On the project page, click "Build Now".
6. Step 5: View the Pipeline Output
a. Click on the build number (e.g., #1 ) in the Build History.
b. Click “Console Output” to view logs.
c. Alternatively, go to “Pipeline Steps” to see the graphical stage view.
7. Example Pipeline Output:
Building the project...
Running tests...
Deploying application...
DevOps 16
Session 4 (Setting Up a Simple Python Application with
Docker)
1. Prerequisites
a. Install WSL (Windows Subsystem for Linux):
i. Run the following command to install WSL on your machine:
wsl --install
b. Download Docker Desktop:
i. Download Docker Desktop from the official Docker website.
c. Optional: Install Docker to a custom directory:
i. Open Command Prompt as Administrator and run:
C:\> cd C:\Users\varal\Downloads
C:\Users\varal\Downloads> start /w "" "Docker Desktop Installer.exe"
ii. Explanation:
1. cd C:\Users\varal\Downloads : Navigates to the folder where the Docker
installer is located.
2. start /w "" "Docker Desktop Installer.exe" install -accept-license --installation-
dir=D:\Docker : Runs the Docker installer with the following options:
a. install : Initiates the installation process.
b. accept-license : Automatically accepts Docker's End User License
Agreement.
DevOps 17
c. -installation-dir=D:\Docker: Specifies the custom installation
directory ( D:\Docker in this case). Docker will be installed in this
directory instead of the default path.
2. Step-by-Step Docker Setup
a. Create a Project Directory
i. Begin by creating and navigating to the project directory:
mkdir my-python-app
cd my-python-app
b. Create a Python Application ( app.py )
i. Inside the my-python-app directory, create a Python script ( app.py ). Here's
a simple example:
print("Hello, Docker!")
c. Create a Dockerfile
i. In the same directory, create a Dockerfile . This file will define the
instructions for building your Docker image.
FROM python:3.8-slim
WORKDIR /app
COPY . /app
CMD ["python", "app.py"]
ii. Explanation:
1. FROM python:3.8-slim: Base image with Python 3.8.
2. WORKDIR /app: Set the working directory inside the container.
3. COPY . /app: Copy the current directory contents into the /app
directory in the container.
4. CMD ["python", "app.py"]: Command to run the Python script
when the container starts.
DevOps 18
d. Build the Docker Image
i. With your Dockerfile and app.py in place, build the Docker image using
the following command:
docker build -t my-python-image .
ii. t my-python-image : Tags the image with the name my-python-image .
iii. . : The period refers to the current directory.
iv. The build process will take some time. Once completed, the image my-
python-image will be available locally.
e. Run the Docker Container
i. Create and start a Docker container from your newly built image:
docker run --name my-python-container my-python-image
ii. This command will execute the app.py script inside the container, and
you should see the output:
Hello, Docker!
DevOps 19
f. Start the container in the foreground (you can see the logs directly):
i. Start the container with logs too.
docker start -a my-python-container
ii. This will attach to the container’s output and you’ll be able to see the
logs. If the app finishes executing, the container will stop.
g. Stopping the Container (Optional)
i. To stop the container after running:
docker stop my-python-container
h. Remove the Container (Optional)
i. If you wish to remove the stopped container:
docker rm my-python-container
DevOps 20
i. Restart the Container (Optional)
i. To restart the container and view the output again:
docker restart my-python-container
Session 5 (Docker Compose: Multi-Container)
images.zip
1. Setting Up Each Image
a. HTML Service (Nginx)
i. Create html-image/ directory and add the following files:
ii. html-image/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-s
cale=1.0">
<title>HTML Container</title>
</head>
<body>
<h1>Hello from the HTML container!</h1>
DevOps 21
</body>
</html>
iii. html-image/Dockerfile
FROM nginx:latest
WORKDIR /usr/share/nginx/html
COPY index.html /usr/share/nginx/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
b. Java Service
i. Create java-image/ directory and add:
ii. java-image/Student.java
public class Student {
public static void main(String[] args) {
System.out.println("Java container running: I am a student");
}
}
iii. java-image/Dockerfile
FROM openjdk:latest
WORKDIR /app
COPY . /app
RUN javac Student.java
CMD ["java", "Student"]
c. JavaScript (Node.js) Service
i. Create js-image/ directory and add:
ii. js-image/index.js
DevOps 22
console.log("Node.js container running: I am a student");
iii. js-image/Dockerfile
FROM node:latest
WORKDIR /app
COPY . /app
CMD ["node", "index.js"]
d. Python Service
i. Create py-image/ directory and add:
ii. py-image/app.py
import os
print("Python container running: This is my first image.")
print("Current Directory:", os.getcwd())
iii. py-image/Dockerfile
FROM python:3.8-slim
WORKDIR /app
COPY . /app
CMD ["python", "app.py"]
2. Docker Compose Configuration
a. Now, create docker-compose.yml in the project root:
b. docker-compose.yml
version: '3.8'
services:
DevOps 23
java-app:
build: ./java-image
container_name: java-container
command: ["java", "Student"]
python-app:
build: ./py-image
container_name: python-container
command: ["python", "app.py"]
js-app:
build: ./js-image
container_name: js-container
command: ["node", "index.js"]
html-app:
build: ./html-image
container_name: html-container
ports:
- "8081:80"
c. What This Does:
i. Builds four services ( java-app , python-app , js-app , html-app ).
ii. No need to manually build images—Docker Compose handles it.
iii. The HTML container is exposed on localhost:8081 .
3. Steps to Build and Run Containers
a. Navigate to Project Directory
cd /path/to/practical-05
b. Build All Images
DevOps 24
docker compose build
c. or
docker compose up --build -d
d. This will build all images and start the containers in the background.
4. Verifying Running Containers
a. Check if all containers are running:
docker ps -a
b. Output:
DevOps 25
5. Viewing Logs
a. For each container:
docker logs java-container
docker logs python-container
docker logs js-container
b. Output:
DevOps 26
c. For HTML, open in a browser: http://localhost:8081/
DevOps 27
6. Stopping and Removing Containers
a. To stop all running containers:
docker compose down
DevOps 28
b. To remove all images (optional):
docker rmi java-image python-image js-image html-image
7. Restarting Containers
a. After stopping, restart with:
docker compose up -d
b. To restart a specific service (e.g., Python):
docker compose restart python-app
8. Removing Everything (Full Cleanup)
a. If you want to remove containers, images, and volumes:
docker compose down --rmi all --volumes
DevOps 29
9. Commands
Command Purpose
docker compose build Build all images
docker compose up -d Start containers in detached mode
docker ps List running containers
docker logs <container_name> View logs of a container
docker compose down Stop and remove containers
docker compose restart <service_name> Restart a specific service
docker compose down --rmi all --volumes Remove containers, images, and volumes
Session 6 (Install & Set Up Ansible on Windows (via
WSL))
1. Step 1: Enable WSL on Windows
a. Open PowerShell as Administrator
i. Run:
wsl --install
b. This installs WSL 2 and Ubuntu (default distro)
c. Restart your computer if prompted.
2. Step 2: Launch Ubuntu (Linux Terminal)
a. After reboot, open "Ubuntu" from Start Menu.
b. Let it set up.
DevOps 30
c. You will be asked to create a username and password.
3. Step 3: Update Ubuntu
a. In the Ubuntu terminal:
sudo apt update && sudo apt upgrade -y
4. Step 4: Install Ansible
a. Install required dependencies:
sudo apt install software-properties-common -y
b. Add Ansible PPA:
sudo add-apt-repository --yes --update ppa:ansible/ansible
c. Install Ansible:
sudo apt install ansible -y
DevOps 31
5. Step 5: Verify Installation
a. Command
ansible --version
b. You should see the installed version like:
ansible [core 2.15.x]
6. Step 6: Set Up Ansible Inventory (Hosts File)
a. Edit the inventory file:
sudo nano /etc/ansible/hosts
b. Add remote servers (example):
[web]
192.168.1.10
[db]
192.168.1.20
7. Step 7: Test Connection to Remote Machine
a. Ensure the remote Linux machine has SSH enabled.
b. On Ubuntu, test connection:
ansible all -m ping -u ubuntu --ask-pass
DevOps 32
Session 7 (Kubernetes Setup on Windows 11
(Minikube + Docker))
1. Step 1: Install Prerequisites
a. Enable Virtualization
i. Make sure virtualization is enabled in BIOS.
b. Install Docker Desktop
i. Download: https://www.docker.com/products/docker-desktop
ii. Install it and ensure WSL 2 is enabled in Docker Settings.
c. Install WSL (if not already)
wsl --install
d. Install kubectl (Kubernetes CLI)
choco install kubernetes-cli
e. Install Minikube
choco install minikube
f. (Install Chocolatey first if not installed)
2. Step 2: Start Minikube with Docker Driver
a. In PowerShell or Command Prompt:
minikube start --driver=docker
b. This launches a local Kubernetes cluster using Docker as the VM driver.
3. Step 3: Verify Kubernetes Is Running
a. Command
DevOps 33
kubectl get nodes
b. Expected output:
NAME STATUS ROLES AGE VERSION
minikube Ready control-plane Xs vX.X.X
4. Step 4: Access Kubernetes Dashboard (optional)
a. Command
minikube dashboard
b. This opens a browser with the Kubernetes Dashboard.
Session 8 (Grafana + Prometheus Setup on Windows
11 (Locally with Docker))
1. Step 1: Create a Project Directory
mkdir grafana-prometheus
cd grafana-prometheus
2. Step 2: Create Configuration Files
a. prometheus.yml
global:
scrape_interval: 15s
scrape_configs:
DevOps 34
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:9090']
3. Step 3: Create docker-compose.yml
version: '3.7'
services:
prometheus:
image: prom/prometheus
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
ports:
- "9090:9090"
grafana:
image: grafana/grafana
ports:
- "3000:3000"
volumes:
- grafana-storage:/var/lib/grafana
volumes:
grafana-storage:
4. Step 4: Start Services
a. In the same directory:
docker compose up -d
5. Step 5: Access Grafana & Prometheus
a. Grafana UI: http://localhost:3000
a. Username: admin , Password: admin
DevOps 35
b. Prometheus UI: http://localhost:9090
6. Step 6: Connect Prometheus as Grafana Data Source
a. Login to Grafana.
b. Go to Settings → Data Sources → Add data source.
c. Choose Prometheus.
d. Set URL: http://prometheus:9090
DevOps 36
