HOLY MARY INSTITUTE OF TECHNOLOGY & SCIENCE

(UGC-Autonomous)
(Approved by AICTE, New Delhi, and Permanent Affiliation to JNTUH, Accredited by NAAC-A)
Bogaram (V), Keesara (M), Medchal (Dist), Hyderabad, Telangana State

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

Name: DEVOPS LAB MANUAL

Course Code: A2CS505PC

Year & Semester: III-I

III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENTNO:
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:

Simple user registration form using Flask and Docker in DevOps:

• Create a Docker file with the following content to create a Docker

image for your Flask application:

FROM python:3.8

WORKDIR /app

COPY . .

RUN pip install--no-cache-dir-rrequirements.txt

EXPOSE 5000

CMD["python","app.py"]
• Create a requirements.txt file with the following content to list the
dependencies of your Flask application: Flask==1.1.2
• Create a app.py file with the following code for a simple user
registration form in Flask:
From flask import Flask,request,render_template

app = Flask(name)

@app.route('/register',methods=['GET','POST'])
def register():
If request.method == 'POST':
name=request.form['name']
email =request.form['email']
password =request.form['password']
#Storetheuserdatainadatabaseorfile return

render_template('success.html')

HITS- CSE 1
III-I- B.TECH CSE
DEVOPS LAB
return render_template('register.html')

if name =='main':
app.run(host='0.0.0.0')
• Create a templates folder and add the following two files:
register.html and success.html.
register.html
<form method="post">
<input type="text" name="name" placeholder="Name">
<input type="email" name="email" placeholder="Email">
<input type="password "name="password" placeholder="Password">
<input type="submit" value="Submit">
</form>success.ht
ml
<h2>Registration Successful</h2>
• Build the Docker image for your Flask application using the
following command: docker build -t simple-flask-app .
• Run a Docker container from the image using the following
command: docker run -p 5000:5000 simple-flask-app
• Open a web browser and access the registration form at
http://localhost:5000/register.
This example demonstrates how to build a simple user registration form in
Flask and run it in a Docker container in DevOps. Note that this code is only
meant to demonstrate the basic structure of a user registration form and does
not include any security measures or proper error handling. It is highly
recommended to add security measures such as password hashing and
validation before using it in a production environment.

VIVAQUESTIONS
Define Flask in devops

HITS-CSE 2
III-I- B.TECH CSE
DEVOPS LAB
EXPERIMENT NO: 2.Explore Git and Git Hub commands
Aim:Explore Git and GitHub commands
DESCRIPTION:
Git and GitHub are two of the most popular tools used for version control
and collaboration in software development.
Here are some common Git andGitHub commands:
• Initializing a Git repository:$gitinit
• Checking the status of your repository:$git status
• Adding files to the stage:$gitadd<file-name>
• Committing changes:$gitcommit-m" commit message"
• Checking the commit history:$gitlog
• Undoing changes:$gitcheckout<file-name>
• Creating a new branch:$gitbranch<branch-name>
• Switching to a different branch:$gitcheckout<branch-name>
• Merging two branches:$gitmerge <branch-name>
• Pushing changes to a remote repository:$gitpushorigin<branch-
name>
• Cloning a repository from GitHub:$gitclone<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.

VIVAQUESTIONS

1.Define Git
2.What is
3.GitHub
4.Difference between Git & GitHub

HITS-CSE 3
III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENTNO: 3.Practice Source code management on GitHub.

Experiment with the source code written in exercise1

Aim: Practice Source code management on GitHub.

Experiment with the source code written in exercise1

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:$gitclone<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:$gitadd <file-name>
• Commit the changes:$gitcommit-m"Added source code for a simple
user registration form"
• Push the changes to the remote repository:$gitpush 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.

VIVAQUESTIONS

What is GitHub management

HITS-CSE 4
III-I- B.TECH CSE
DEVOPS LAB
EXPERIMENTNO: 4.Jenkins installation and setup, explore the
environment
Aim: Jenkins installation and setup, explore the environment

DESCRIPTION

Jenkins is a popular open-source tool for Continuous Integration and

Continuous Deployment (CI/CD) in software development. Here are the
steps to install and set up Jenkins:
Download and install Jenkins:
• Download the Jenkins package for your operating system from the
Jenkins website.
• 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.
• On Linux, use the following command to start the Jenkins service:
$sudo service jenkins start
Access the Jenkins web interface:
• Open a web browser and navigate to http://localhost:8080toaccess
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 youruse
case, you may need to customize your Jenkins environment further. For
example, you may need to configure build agents, set up build pipelines, or

HITS-CSE 5
III-I- B.TECH CSE
DEVOPS LAB

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.

VIVAQUESTIONS
Define Jenkins

HITS-CSE 6
 III-I- B.TECH CSE
DEVOPS LAB

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:
• 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:
• Login 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 ofthe
build.

HITS-CSE 7
 III-I- B.TECH CSE
DEVOPS LAB

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.
• Jenkins should automatically build and deploy the changes to the
production environment

This is a basic example of how you can use Jenkins to demonstrate CI/CD in
software development. In a real-world scenario, you would likely have more
complex requirements, such as multiple environments, different types of
tests, and a more sophisticated deployment process. However, this example
should give you a good starting point for using Jenkins for CI/CD in your
software development projects.

VIVAQUESTIONS
Define CD &CI

HITS-CSE 8
 III-I- B.TECH CSE
DEVOPS LAB

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:

• Docker run: Run a command in a new container.

For example:$docker run--namemycontainer-itubuntu:16.04
/bin/bash This command runs a new container based on the Ubuntu
16.04imageandstartsashellsessioninthecontainer.

• Docker start: Start one or more stopped

containers. For example:$docker start my container
This command starts the container named "mycontainer".

• Docker stop: Stop one or more running

containers. For example:$docker stop my container
This command stops the container named "mycontainer".

• Docker rm: Remove one or more containers.

For example: $ docker rm mycontainer
This command removes the container named "mycontainer".

• Docker ps:List containers.

For example: $ docker ps
This command lists all running containers.

• Docker images: List images.

For example: $ docker images
This command lists all images stored locally on the host.

• Docker pull: Pull an image or a repository from a

registry.

HITS-CSE 9
 III-I- B.TECH CSE
DEVOPS LAB

• For example: $ docker pull ubuntu:16.04

This command pulls theUbuntu16.04imagefromtheDockerHub registry.

• Docker push:Push an image or a repository to a

registry. For example: $ docker push my image
This command pushes the image named "myimage" to the Docker Hub
registry.

These are some of the basic Docker commands for managing containers and
images. There are many other Docker commands and options that you can
use for more advanced use cases, such as managing networks, volumes, and
configuration. However, these commands should give you a good starting
point for using Docker for content management.

VIVAQUESTIONS

Give briefly about Docker commands

HITS-CSE 10
 III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENT NO.:7.Develop a simple containerized application using

Docker

AIM:Develop a simple containerize dapplication 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 Docker file:

• Create a file named "Docker file" in the same directory as the

application.
In the Docker file, specify the base image, copy the application into the
container, and specify the command to run the application. Here's anexample
Docker
file for a Python script:

# Use the official Python image as the base image

FROM python:3.9

#Copy the Python script in to the container

COPY hello.py /app/

HITS-CSE 11
III-I- B.TECH CSE
DEVOPS LAB

#Set the working directory to/app/

WORKDIR /app/

#Run the Python script when the container starts

CMD ["python", "hello.py"]

• Build the Docker image:

Run the following command to build the Docker image:
$docker build –tmy image.
This command builds a new Docker image using the Docker file 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:
$dockerrun—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.

VIVAQUESTIONS

Name the applications using Docker

HITS-CSE 12
 III-I- B.TECH CSE
DEVOPS LAB

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 ahigher-level abstractions formanaging
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 andDocker:

• Build a Docker image:

Use Docker to build a Docker image of your application. You can use a
Docker file tospecify the base image, copy the application into the container,
and specify the command to run the application.

HITS-CSE 13
III-I- B.TECH CSE
DEVOPS LAB

• Push the Docker image to a registry:

Push the Docker image to a container registry, such as Docker Hub or

Google Container Registry, sothatitcan 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 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.
• Continuouslyintegrateanddeploychanges:

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 of
both technologies to manage containers in a scalable, reliable, and efficient
manner.
Viva questions:

Define integrate Kubernetes

What is Docker

HITS-CSE 14
III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENT NO.:9. Automate the process of running containerized

application developed in exercise7 using Kubernetes

AIM: Automate the process of running containerized application

developed in exercise7 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 Cloudor
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 replicasand
the Docker image to use. Here's an example of a deployment YAML file:
apiVersion: apps/v1
kind:Deployment
metadata:

HITS-CSE 15
III-I- B.TECH CSE
DEVOPS LAB

name:myapp
spec:
replicas:3
selector:
matchLabels:
app:myapp
template:
metadata:
labels:
app:myapp
spec:
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:v1
kind: Service
metadata:
name:myapp-service
spec:
selector:
app:myapp
ports:
- name:http
port: 80

HITS-CSE 16
III-I- B.TECH CSE
DEVOPS LAB

targetPort:80
type: ClusterIP
• Apply the deployment and service to the cluster:
Apply the deployment and service to the cluster using the kubect l command-
line tool. For example:
$kubectl apply-fdeployment.yaml
$kubectl apply-fservice.yaml
• Verifythe deployment:
Verify the deployment by checking the status of the pods and the service.For
example:
$kubectlget pods
$kubectlget 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 using Kubernetes to manage your containers.

VIVAQUESTIONS
DefineKubernetes

HITS-CSE 17
III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENTNO.: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 Web Driver:

• You can download the latest version of the Selenium WebDriverfrom

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 Developmen tEnvironment(IDE):

• To write and run Selenium tests, you'll need an IDE. Some popular
choices include Eclipse, IntelliJ IDEA, and Visual Studio Code.

HITS-CSE 18
III-I- B.TECH CSE
DEVOPS LAB
• Write a simple test:

• Once you have your IDE setup,you can write a simple test using the
Selenium WebDriver. Here's an example in Java:

importorg.openqa.selenium.WebDriver;
importorg.openqa.selenium.chrome.ChromeDriver;

publicclassMain{
public static void main(String[] args) {
System.setProperty("webdriver.chrome.driver","path/to/chromedriver");
WebDriver driver = new ChromeDriver();
driver.get("https://www.google.com");
System.out.println(driver.getTitle());
driver.quit();
}
}

• Runthe test:
Run the test using your IDE or from the command line using the following
command:

$javac Main.java
$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.

VIVA QUESTIONS

HITS-CSE 19
III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENTNO.:11.Write a simple program in JavaScript and

perform testing using Selenium

AIM: Write a simple program in JavaScript and perform testing using

Selenium

PROGRAM:
• SimpleJavaScriptprogramthatyoucantestusingSelenium
<!DOCTYPEhtml>
<html>
<head>
<title>SimpleJavaScriptProgram</title>
</head>
<body>
<pid="output">0</p>
<buttonid="increment-button">Increment</button>
<script>
constoutput=document.getElementById("output");
const incrementButton
=document.getElementById("increment-
button");

HITS-CSE 20
III-I- B.TECH CSE
DEVOPS LAB

letcount=0;
incrementButton.addEventListener("click",function(){
count+=1;
output.innerHTML=count;
});
</script>
</body>
</html>

• Write a testcase for this program using Selenium

importorg.openqa.selenium.By;
importorg.openqa.selenium.WebDriver;
importorg.openqa.selenium.chrome.ChromeDriver;
import org.junit.After;
importorg.junit.Before;
import org.junit.Test;

publicclassMain{
privateWebDriver driver;

@Before
publicvoid setUp(){
System.setProperty("webdriver.chrome.driver","path/to/chromedriver");
driver = new ChromeDriver();
}

@Test
public void testIncrementButton() {
driver.get("file:///path/to/program.html");
driver.findElement(By.id("increment-button")).click();
Stringresult=driver.findElement(By.id("output")).getText();
assert result.equals("1");
}

HITS-CSE 21
III-I- B.TECH CSE
DEVOPS LAB

@After
Public void tear Down(){
driver.quit();
}
}
You can run the test case using the following command:
$javac Main.java
$java Main
The output of the test case should be:
.
Time:0.189
OK(1test)

This output indicates that the test case passed, and the increment button was
successfully clicked, causing the output to be incremented by 1.
VIVAQUESTIONS

How can java can be useful using selenium

HITS-CSE 22
III-I- B.TECH CSE
DEVOPS LAB

EXPERIMENTNO.:12.Develop test cases for the above containerized

application using selenium

AIM:Develop test cases for the above containerized application using

selenium

PROGRAM:

Here is an example of how you could write test cases for the containerized
application using Selenium

import org.openqa.selenium.By;
importorg.openqa.selenium.WebDriver;
importorg.openqa.selenium.chrome.ChromeDriver;
import org.junit.After;
importorg.junit.Before;
import org.junit.Test;

publicclassMain {
privateWebDriver driver;

@Before
publicvoid setUp(){
System.setProperty("webdriver.chrome.driver","path/to/chromedriver");
driver = new ChromeDriver();

HITS-CSE 23
III-I- B.TECH CSE
DEVOPS LAB

@Test
publicvoidtestHomePageLoads()
{
driver.get("http://localhost:8080");
String title = driver.getTitle();
asserttitle.equals("MyContainerizedApplication");
}

@Test
public void test SubmitForm() {
driver.get("http://localhost:8080");
driver.findElement(By.name("name")).send Keys("JohnDoe");
driver.findElement(By.name("email")).sendKeys("[email protected]
m");
driver.findElement(By.name("submit")).click();
String result=driver.find Element(By.id("result")).getText();
assert result.equals("Form submitted successfully!");
}

@After
Public void tear Down(){
driver.quit();
}
}
You can run the test cases using the following command:
$javac Main.java
$java Main
The output of the test cases should be:

Time:1.135

OK(2tests)
This output indicates that both test cases passed, and the containerized
application is functioning as expected.

VIVAQUESTIONS

1. Define selenium
2. Name the test cases used in selenium

HITS-CSE 24
III-I- B.TECH CSE
DEVOPS LAB