[Link] (CSE).
III Year – I Semester
DevOps Lab Manual
Prepared By:
L Suresh
[Link].(CSE)
CJITS, Jangaon
Page No: 1
LIST OF EXPERIMENTS
[Link]. Name of the Experiment
1. Write code for a simple user registration formfor an event.
2. Explore Git and GitHub commands
Practice Source code management on GitHub. Experiment
3.
with the source code written in exercise 1
4. Jenkins installation and setup, explore the environment
Demonstrate continuous integration and development using
5.
Jenkins.
6. Explore Docker commands for content management.
7. Develop a simple containerized application using Docker
8. Integrate Kubernetes and Docker
Automate the process of running containerized application
9.
developed in exercise 7 using Kubernetes
10. Install and Explore Selenium for automated testing
11. Write a simple program in JavaScript and perform testing using Selenium
12. Develop test cases for the above containerized application using selenium.
Page No: 2
EXPERIMENT NO: 1. Write code for a simple user registration
form for an event.
Aim: Write code for a simple user registration form for an event.
DESCRIPTION:
Program Structure:
exp1/
├── [Link]
├── templates/
│ ├── [Link]
│ └── [Link]
├── [Link]
└── Dockerfile
1. [Link] Code (Flask Back End):
from flask import Flask, render_template, request, redirect, url_for
app = Flask(__name__)
# Temporary storage (replace with a database in production)
users = []
@[Link]('/')
def home():
return redirect(url_for('register'))
@[Link]('/register', methods=['GET', 'POST'])
def register():
if [Link] == 'POST':
username = [Link]['username']
email = [Link]['email']
password = [Link]['password']
[Link]({'username': username, 'email': email})
return redirect(url_for('success'))
return render_template('[Link]')
@[Link]('/success')
def success():
return render_template('[Link]')
Page No: 3
if __name__ == '__main__':
[Link](host='[Link]', debug=True)
2. templates/[Link] (Registration Form):
<html>
<head>
<title>Register</title>
</head>
<body>
<h1>Register</h1>
<form method="POST">
<input type="text" name="username" placeholder="Username"
required><br>
<input type="email" name="email" placeholder="Email"
required><br>
<input type="password" name="password"
placeholder="Password" required><br>
<button type="submit">Register</button>
</form>
</body>
</html>
3. templates/[Link] (Success Page) :
<html>
<head>
<title>Success</title>
</head>
<body>
<h1>Registration Successful!</h1>
<p>Thank you for registering.</p>
</body>
</html>
4. [Link] (Dependencies) :
Flask==2.3.2
5. Dockerfile (Containerization) :
FROM python:3.9-slim
WORKDIR /app
Page No: 4
COPY . .
RUN pip install --no-cache-dir -r [Link]
EXPOSE 5000
CMD ["python", "[Link]"]
How to Run It
1. Build and Run with Docker:
docker build -t exp1 .
docker run -p 5000:5000 exp1
2. Access the App:
Open [Link] in your browser.
Explanation of Program
Flask is a lightweight Python web framework used for building web
applications and APIs quickly and efficiently. It's known for its simplicity,
flexibility, and minimalistic design, making it ideal for small to medium
projects and microservices.
[Link]:
1. Import Statements
from flask import Flask, render_template, request, redirect,
url_for
Flask: Main Flask class to create the application instance
render_template: Renders HTML templates from the templates/ folder
request: Handles HTTP request data (form submissions)
redirect: Redirects to another route
url_for: Generates URLs for Flask routes
2. Flask Application Setup
app = Flask(__name__)
Creates a Flask application instance
Page No: 5
__name__ tells Flask where to look for templates/static files.
3. Temporary Storage
users = []
In-memory list to store registered users (For demo only - use a database in
production)
4. Home Route
@[Link]('/')
def home():
return redirect(url_for('register'))
@[Link]('/'): Maps the root URL (/) to this function
redirect(url_for('register')): Redirects to the /register route
5. Registration Route (GET/POST)
@[Link]('/register', methods=['GET', 'POST'])
def register():
methods=['GET', 'POST']: Accepts both GET (page load) and POST (form
submission) requests
POST Request Handling:
if [Link] == 'POST':
username = [Link]['username']
email = [Link]['email']
password = [Link]['password']
[Link]: Accesses form data submitted via POST
Extracts username, email, and password from the form
[Link]({'username': username, 'email': email})
Stores user data in the users list (without password for demo safety)
Page No: 6
return redirect(url_for('success'))
Redirects to the success page after registration
GET Request Handling
return render_template('[Link]')
Renders the registration form template for GET requests
6. Success Route
@[Link]('/success')
def success():
return render_template('[Link]')
Displays a success page after registration
7. Application Entry Point
if __name__ == '__main__':
[Link](host='[Link]', debug=True)
host='[Link]': Makes the server accessible outside the local machine
(required for Docker)
debug=True: Enables auto-reloader and debugger (disable in production!)
Page No: 7
EXPERIMENT NO: 2. Explore Git and GitHub commands
Aim: Explore Git and GitHub commands.
Description:
1. What is Git?
Git is a distributed version control system (DVCS) that:
Tracks changes in your code over time.
Allows branching/merging for parallel development.
Works offline (all history is stored locally).
Key Git Concepts:
Repository (Repo): A folder where Git tracks files.
Commit: A snapshot of changes at a point in time.
Branch: Isolated line of development (e.g., main, feature/login).
Merge: Combines changes from different branches.
2. What is GitHub?
GitHub is a cloud-based platform that:
Hosts Git repositories remotely.
Enables collaboration via pull requests, issues, and projects.
Provides additional tools like GitHub Actions (CI/CD) and Pages.
Install Git: from [Link] (for Windows OS)
Create GitHub account : [Link]
Git and GitHub are two of the most popular tools used for version control
and collaboration in software development.
Here are some common Git and GitHub commands:
Initializing a Git repository: $ git init
Checking the status of your repository: $ git status
Adding files to the stage: $ git add <file-name>
Committing changes: $ git commit -m "commit message"
Checking the commit history: $ git log
Undoing changes: $ git checkout <file-name>
Creating a new branch: $ git branch <branch-name>
Switching to a different branch: $ git checkout <branch-name>
Merging two branches: $ git merge <branch-name>
Page No: 8
Pushing changes to a remote repository: $ git push origin <branch-
name>
Cloning a repository from GitHub: $ git clone <repository-url>
Creating a pull request on GitHub: Go to the repository on GitHub,
select the branch you want to merge and click the "New pull request"
button.
These are just a few of the many Git and GitHub commands available. There
are many other Git commands and functionalities that you can explore to
suit your needs.
Page No: 9
EXPERIMENT NO: 3. Practice Source code management on GitHub.
Experiment with the source code written in exercise 1
Aim: Practice Source code management on GitHub.
Experiment with the source code written in exercise 1
Description:
To practice source code management on GitHub, you can follow these steps:
Create a GitHub account if you don't already have one.
Create a new repository on GitHub.
Clone the repository to your local machine: $ git clone <repository- url>
Move to the repository directory: $ cd <repository-name>
Create a new file in the repository and add the source code written in exercise 1.
Stage the changes: $ git add <file-name>
Commit the changes: $ git commit -m "Added source code for a simple user
registration form"
Push the changes to the remote repository: $ git push origin master
Verify that the changes are reflected in the repository on GitHub. These steps
demonstrate how to use GitHub for source code management.
You can use the same steps to manage any source code projects on GitHub.
Additionally, you can also explore GitHub features such as pull requests, code
review, and branch management to enhance your source code
management workflow.
1. Initialize Git in Your Local Folder
$ cd path/to/your-folder
# Initialize Git repository
$ git init
2. Stage and Commit Files
# Stage all files (or use `git add <filename>` for specific files)
$ git add .
# Commit with a message
$ git commit -m "Initial commit"
3. Create a New Repository on GitHub
Page No: 10
Go to [Link]/new
Enter a repository name (e.g., exp1)
Do not initialize with README/.gitignore (keep it empty)
Click "Create repository"
4. Link Local Repository to GitHub
# Copy the remote repository URL (HTTPS or SSH) from GitHub
$ git remote add origin [Link]
[Link]
5. Push to GitHub
$ git push -u origin master
6. Verify on GitHub
Refresh your GitHub repository page. Your files should now appear!
Summary
1. git init → git add . → git commit
2. Connect to GitHub with git remote add origin
3. git push -u origin main
Your local folder is now on GitHub!
Page No: 11
EXPERIMENT NO: 4. Jenkins installation and setup,
explore the environment.
Aim: Jenkins installation and setup, explore the environment
DESCRIPTION:
Jenkins: The Ultimate DevOps Automation Tool
Jenkins is an open-source automation server used for CI/CD (Continuous
Integration & Continuous Delivery). It automates building, testing, and
deploying software, making DevOps workflows faster and more reliable.
Download and install Jenkins:
Download the Jenkins package for your operating system from the
o Jenkins website. -- > [Link]
Follow the installation instructions for your operating system to
install Jenkins.
Start the Jenkins service:
On Windows, use the Windows Services Manager to start the Jenkins
service.
Access the Jenkins web interface:
Open a web browser and navigate to [Link] to access
the Jenkins web interface. If the Jenkins service is running, you will
see the Jenkins login page.
Initialize the Jenkins environment:
Follow the instructions on the Jenkins setup wizard to initialize the
Jenkins environment. This process involves installing
recommended plugins, setting up security, and creating the first
admin user.
Explore the Jenkins environment:
Once the Jenkins environment is set up, you can explore the various
features and functionalities available in the web interface.
Jenkins has a rich user interface that provides access to features such
as build history, build statistics, and system information.
These are the basic steps to install and set up Jenkins. Depending on
your use case, you may need to customize your Jenkins environment
further. For example, you may need to configure build agents, set up
build pipelines, or integrate with other tools. However, these steps
should give you a good starting point for using Jenkins for CI/CD in
your software development projects.
Page No: 12
EXPERIMENT NO: 5. Demonstrate continuous integration and
development using Jenkins.
Aim: Demonstrate continuous integration and development
using
Jenkins.
DESCRIPTION
Continuous Integration (CI) and Continuous Development (CD)
are important practices in software development that can be achieved using
Jenkins. Here's an example of how you can demonstrate CI/CD using
Jenkins:
Create a simple Java application that you want to integrate with
Jenkins.
The application should have some basic functionality, such as
printing "Hello World" or performing simple calculations.
Commit the code to a Git repository:
Create a Git repository for the application and commit the code to the
repository.
Make sure that the Git repository is accessible from the Jenkins
server.
Create a Jenkins job:
Log in to the Jenkins web interface and create a new job.
Configure the job to build the Java application from the Git
repository.
Specify the build triggers, such as building after every commit to the
repository.
Build the application:
Trigger a build of the application using the Jenkins job.
The build should compile the code, run any tests,and produce an
executable jar file.
Monitor the build:
Monitor the build progress in the Jenkins web interface.
The build should show the build log, test results, and the status of the
build.
Page No: 13
Deploy the application:
If the build is successful, configure the Jenkins job to deploy the
application to a production environment.
The deployment could be as simple as copying the jar file to a
production server or using a more sophisticated deployment process,
such as using a containerization technology like Docker.
Repeat the process:
Repeat the process for subsequent changes to the application.
Create a Simple Java Application
Let’s create a basic Java app that prints "Hello, World!" and performs a
simple addition.
1. Open Visual Studio Code:
Press Ctrl + Shift + P
Select Java: Create Java Project
Select Folder to create Java Project.
Type Project Name: SimpleJavaApp
Select Left side src folder change name [Link] to [Link]
Remove code and type below code:
[Link]:
public class Main {
public static void main(String[] args) {
[Link]("Hello, World!");
int a = 5, b = 7;
int sum = a + b;
[Link]("Sum: " + sum);
}
}
[Link]:
echo Building Java App...
mkdir out 2>nul
javac -d out src\[Link]
echo Running Java App...
cd out
Page No: 14
java Main
echo Build and run completed.
Debug the Project
Open the [Link] website and login your account and
create a new repository.
Goto your project folder in local system.
D:\Project_Folder\
Run cmd in addressbar.
Type below commands:
1. git init
2. git add .
3. git config --global [Link] "cjits25"
4. git config --global [Link] "cjitsjn@[Link]"
5. git commit –m “Intiated Project commited”
6. git push –u origin master
Open the Chrome Browser type the URL : [Link]
Set Up Jenkins Job
Step-by-Step in Jenkins UI:
1. Login to Jenkins
2. Click "New Item"
3. Enter item name: SimpleJavaApp-Build
4. Choose "Freestyle project"
5. Click OK
Configure Source Code Management:
Select Git
Enter your Git repository URL (e.g., [Link]
username/[Link])
Configure Build:
o Click "Add build step" → "Execute Windows batch
command".
Page No: 15
Archive .class Files as Build Artifacts
Steps:
1. Go to your Jenkins job → Configure
2. Scroll to Post-build Actions
3. Click Add post-build action → Archive the artifacts
4. In Files to archive, enter:
Click Save.
Click Build Now.
Output in Console Output of the build log.
Page No: 16
EXPERIMENT NO.: 6. Explore Docker commands for
content management.
AIM: Explore Docker commands for content management.
DESCRIPTION
Docker is a containerization technology that is widely used for managing
application containers. Here are some commonly used Docker commands
for content management:
Goto the run : type the command ‘cmd’.
Docker Basics on Windows :
1. Check Docker is Running:
C:\> docker version
Displays the installed Docker version on your system (client and server).
C:\> docker info
Shows detailed information like running containers, images, volumes, and Docker
configuration.
Image Management Commands:
2. List all images:
C:\> docker images
Lists all the Docker images downloaded on your system, including:
Repository name
Tag (version)
Image ID
Creation time
Size
C:\> docker pull <image-name>
Downloads a Docker image from Docker Hub (or another registry) to your
local machine.
Example: c:\> docker pull nginx pulls the latest NGINX image.
Page No: 17
C:\> docker rmi <image-id or image-name>
Removes a Docker image from your local system to free up space.
Example: docker rmi nginx or docker rmi abc123456789
Container Management Commands:
C:\>docker ps -a
Lists all containers, including:
Running containers
Stopped or exited containers
Use docker ps without -a to see only running containers.
C:\>docker start <container-id or name>
Starts a stopped container.
You must have created the container earlier.
Example: docker start myweb
C:\>docker stop <container-id or name>
Gracefully stops a running container.
C:\>docker run -it --name mycontainer ubuntu
Runs a new Ubuntu container interactively:
-i: keep STDIN open
-t: allocate a terminal
--name: gives the container a name
Example: you get a terminal shell inside Ubuntu.
C:\>docker run -d --name myweb nginx
Runs a container in detached mode (background).
-d: detached mode
Container runs independently until stopped
C:\>docker rm <container-id or name>
Removes a stopped container.
You must stop the container first.
Example: docker rm myweb
Page No: 18
::VIVA::
What is Docker?
Docker is an open-source platform used to build, ship, and run
applications inside containers.
It allows you to package an application and its dependencies into a
single lightweight unit called a container.
Containers run the same regardless of the underlying OS or hardware.
What is a Container?
A container is a lightweight, standalone executable package that includes:
The application code
Runtime (e.g., Java, Python, Node)
Libraries and dependencies
Configuration files
Think of it as a mini virtual environment, but faster and lighter than virtual
machines.
How Docker Works:
Docker uses:
Docker Engine: Runs and manages containers.
Dockerfile: Script to define how to build a container image.
Docker Hub: A public registry where you can find and share container
images.
Docker CLI: Command-line tool to interact with Docker.
Page No: 19
EXPERIMENT NO.: 7. Develop a simple containerized
application using Docker
AIM: Develop a simple containerized application using Docker
DESCRIPTION
Here's an example of how you can develop a simple
containerized application using Docker:
Choose an application:
• Choose a simple application that you want to containerize.
For example, a Python script that prints "Hello World".
Write a Dockerfile:
• Create a file named "Dockerfile" in the same directory as the
application.
In the Dockerfile, specify the base image, copy the application into the
container, and specify the command to run the application. Here's
an example Dockerfile for a Python script:
[Link]:
from flask import Flask
app = Flask(__name__)
@[Link]('/')
def home():
return "Hello, Docker World!"
if __name__ == '__main__':
[Link](host='[Link]', port=5000)
[Link]
flask
Dockerfile:
# Use an official Python image
FROM python:3.11-slim
# Set working directory
WORKDIR /app
Page No: 20
# Copy app files
COPY [Link] [Link]
COPY [Link] [Link]
# Install dependencies
RUN pip install -r [Link]
# Expose the port Flask runs on
EXPOSE 5000
# Command to run the app
CMD ["python", "[Link]"]
• Build the Docker image:
Run the following command to build the Docker image:
$ docker build -t myimage .
This command builds a new Docker image using the
Dockerfile and tags the image with the name "myimage”.
• Run the Docker container:
Run the following command to start a new container based on the image:
$ docker run --name mycontainer myimage
This command starts a new container named "mycontainer" based on
the
"myimage" image and runs the Python script inside
the container.
• Verify the output:
Run the following command to verify the output of the container:
$ docker logs mycontainer
This command displays the logs of the container and should
show the "Hello World" output.
This is a simple example of how you can use Docker to containerize an
application. In a real-world scenario, you would likely have more
complex requirements, such as running multiple containers, managing
network connections, and persisting data. However, this example should
give you a good starting point for using Docker to containerize your
applications.
Page No: 21
EXPERIMENT NO.: 8. Integrate Kubernetes and Docker
AIM: Integrate Kubernetes and Docker
DESCRIPTION:
Kubernetes and Docker are both popular technologies for managing
containers, but they are used for different purposes. Kubernetes is an
orchestration platform that provides higher-level abstractions for
managing containers, while Docker is a containerization technology that
provides a lower-level runtime for containers.
To integrate Kubernetes and Docker, you need to use Docker to build and
package your application as a container image, and then use Kubernetes
to manage and orchestrate the containers.
Here's a high-level overview of the steps to integrate Kubernetes
and Docker:
Build a Docker image:
Use Docker to build a Docker image of your application. You
can use a Dockerfile to specify the base image, copy the
application into the container, and specify the command to
run the application.
• Push the Docker image to a registry:
Push the Docker image to a container registry, such as Docker Hub or
Google Container Registry, so that it can be easily accessed by
Kubernetes. Deploy the Docker image to a Kubernetes cluster:
Use Kubernetes to deploy the Docker image to a cluster. This involves
creating a deployment that specifies the number of replicas and the
Page No: 22
image to be used, and creating a service that exposes the deployment to
the network. Monitor and manage the containers:
Use Kubernetes to monitor and manage the containers. This includes
scaling the number of replicas, updating the image, and rolling out
updates to the containers.
• Continuously integrate and deploy changes:
Use a continuous integration and deployment (CI/CD) pipeline to
automatically build, push, and deploy changes to the Docker image and
the Kubernetes cluster.
This makes it easier to make updates to the application and
ensures that the latest version is always running in the cluster.
By integrating Kubernetes and Docker, you can leverage the
strengths ofboth technologies to manage containers in a scalable, reliable,
and efficient manner
Page No: 23
EXPERIMENT NO.: 9. Automate the process of running containerized
application developed in exercise 7 using Kubernetes
AIM: Automate the process of running containerized application
developed in exercise 7 using Kubernetes
DESCRIPTION
To automate the process of running the containerized application
developed in exercise 7 using Kubernetes, you can follow these steps:
• Create a Kubernetes cluster:
Create a Kubernetes cluster using a cloud provider, such as Google
Cloud or
Amazon Web Services, or using a local installation of Minikube.
• Push the Docker image to a registry:
Push the Docker image of your application to a container registry,
such as
Docker Hub or Google Container Registry.
• Create a deployment:
Create a deployment in Kubernetes that specifies the number of replicas
and the Docker image to use. Here's an example of a deployment YAML
file: apiVersion: apps/v1
kind: Deployment metadata:
name: myappspec:
replicas: 3
selector: matchLabels: app: myapp template:
metadata
labels:
app: myapp spec:
Page No: 24
containers:
- name: myapp image: myimage ports:
- containerPort: 80
• Create a service:
Create a service in Kubernetes that exposes the deployment to the network. Here's an
example of a service YAML file:
apiVersion: v1kind: Service metadata:
name: myapp-service
spec:
selector:
app: myapp ports:
- name: http
port: 80 targetPort: 80
type: ClusterIP
• Apply the deployment and service to the cluster:
Apply the deployment and service to the cluster using the kubectl command- line tool.
For example:
$ kubectl apply -f [Link]
$ kubectl apply -f [Link]
• Verify the deployment:
Verify the deployment by checking the status of the pods and the service. For example:
$ kubectl get pods
$ kubectl get services
This is a basic example of how to automate the process of running a
containerized application using Kubernetes. In a real-world scenario,
you would likely have more complex requirements, such as managing
persistent data, scaling, and rolling updates, but this example should give
you a good starting point for exploring Selenium.
Page No: 25
EXPERIMENT NO.: 10. Install and Explore Selenium for automated testing
AIM: Install and Explore Selenium for automated testing
DESCRIPTION:
To install and explore Selenium for automated testing, you can follow
these steps:
Install Java Development Kit (JDK):
• Selenium is written in Java, so you'll need to install JDK in order to
run it. You can download and install JDK from the official Oracle
website.
• Install the Selenium WebDriver:
• You can download the latest version of the Selenium WebDriver from
the Selenium website. You'll also need to download the appropriate
driver for your web browser of choice (e.g. Chrome Driver for
Google Chrome).
Install an Integrated Development Environment (IDE):
• To write and run Selenium tests, you'll need an IDE. Some popular
choices include Eclipse, IntelliJ IDEA, and Visual Studio Code.
• Write a simple test:
• Once you have your IDE set up, you can write a simple test using
theSelenium WebDriver. Here's an example in Java:
import [Link];
import [Link];
public class Main {
public static void main(String[] args) {
[Link]("[Link]",
"path/to/chromedriver"); WebDriver driver = new ChromeDriver();
[Link]("[Link]
[Link]([Link]());
[Link]();
}
Page No: 26
• Run the test:
Run the test using your IDE or from the command line using the
following
command:
$ javac [Link]
$ java Main
This is a basic example of how to get started with Selenium for automated
testing. In a real-world scenario, you would likely write more complex tests
and organize your code into test suites and test cases, but this example
should give you a good starting point for exploring Selenium.
Page No: 27
EXPERIMENT NO.: 11. Write a simple program in JavaScript and
perform testing using Selenium
AIM: Write a simple program in JavaScript and perform testing
usingSelenium
PROGRAM:
• Simple JavaScript program that you can test using Selenium
<!DOCTYPE html>
<html>
<head>
<title>Simple JavaScript Program</title>
</head>
<body>
<p id="output">0</p>
<button id="increment-button">Increment</button>
<script>
const output = [Link]("output");
const incrementButton = [Link]("increment-button");
let count = 0;
[Link]("click", function() {
count += 1;
[Link] = count;
});
</script>
</body>
</html>
Page No: 28
12. Develop test cases for the above containerized application using selenium.
import [Link];
import [Link];
import [Link];
import [Link]; import
[Link]; import
[Link];
public class Main {
private WebDriver driver;
@Before
public void setUp() {
[Link]("[Link]", "path/to/chromedriver");
driver = new ChromeDriver();
}
@Test
public void testIncrementButton() {
[Link]("[Link]
[Link]([Link]("increment-button")).click();
String result = [Link]([Link]("output")).getText();
assert [Link]("1");
}
Page No: 29