Dev Ops Lab Manual
Dev Ops Lab Manual
Dev Ops-lab-Manual
Subject Code :
Regulation : R18/JNTUH
Year : 2022-2023
Modern tool usage: Create, select, and apply appropriate techniques, resources, and modern
PO5 engineering and IT tools including prediction and modeling to complex engineering activities
with an understanding of the limitations.
The engineer and society: Apply reasoning informed by the contextual knowledge to assess
PO6 societal, health, safety, legal and cultural issues and the consequent responsibilities relevant to
the professional engineering practices.
Environment and sustainability: Understand the impact of the professional engineering
PO7 Solutions in societal and environmental contexts, and demonstrate the knowledge of, and need
for sustainable development.
Ethics: Apply ethical principles and commit to professional ethics and responsibilities and
PO8
norms of the engineering practice.
Individual and team work: Function effectively as an individual, and as a member or leader
PO9
in diverse teams, and in multi-disciplinary settings.
Communication: Communicate effectively on complex engineering activities with the
PO10 engineering community and with society at large, such as, being able to comprehend and write
effective reports and design documentation, make effective presentations, and give and receive
clear instructions.
Project management and finance: Demonstrate knowledge and understanding of the
PO11 Engineering and management principles and apply these to one’s own work, as a member and
leader in a team, to manage projects and in multidisciplinary environments.
Life-long learning: Recognize the need for, and have the preparation and ability to engage in
PO12
independent and life-long learning in the broadest context of technological change.
Problem Solving Skills – Graduate will be able to apply computational techniques and
PSO1
software principles to solve complex engineering problems pertaining to software engineering.
Professional Skills – Graduate will be able to think critically, communicate effectively, and
PSO2
collaborate in teams through participation in co and extra-curricular activities.
Successful Career – Graduates will possess a solid foundation in computer science and
PSO3 engineering that will enable them to grow in their profession and pursue lifelong learning
through post-graduation and professional development.
Experiment No: 1. Write a code for a simple user registration form for an event.
Aim: Write a code for a simple user registration form for an event.
DESCRIPTION: Here’s an example of a 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:
Create a [Link] with the following content to list the dependencies of your
Flask application:Flask==1.1.2
Create a [Link] file with the following code for a simple user registration form is Flask:
Create an templates folder and add the following two files: [Link] and [Link].
[Link]
<form method =” post”>
<input type = “text” name = “name” placeholder = “n=Name”>
<input type =”email” name =”email” placeholder = “Email”>
<input type =”password” name = ”password” placeholder=”Password”>
<input type =”submit” value = ”Submit”>
</form>
[Link]
<h2> Registration Successful </h2>
Build a 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 the web browser access 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. Notes that this code is only meant to demonstrates the basic structure of user
registration form and does not include any security measure or proper error handling. It is highly
recommended to add security measures or proper error handling. It is highly recommended to add
security measure such as password hashing and validation before using it in a production environment.
VIVA QUESTIONS
Description: Git and Git Hub are two of the most popular tools used for version control and
collaboration in software development.
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.
VIVA QUESTIONS
1. What is GitHub
2. Difference between Git and GitHub
Experiment no3. 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 this step:
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.
VIVA QUESTIONS
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:
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.
VIVA QUESTIONS
1. Define Jenkins
Description: continuous integration (CI) and continuous development (CD) are important practice
in software development that can be achieved using Jenkins. Here’s the 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.
This is basic example of how you can use Jenkins to demonstrate CI/CD in software development. In real
world scenario, you would likely have more complex requirements, such as multiple environments,
different types of tests, and more sophisticated deployment process. However, this example should give you
a good starting point for using Jenkins CI/CD in your software development projects.
VIVA QUESTIONS
1. Define CD & CI
Description: Docker is a containerization technology that is widely used for managing application
containers. Here are some commonly used Docker commands for content management:
These are some of the basic Docker commands for managing containers and images. There are many
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 a good starting point for
using Docker for content management.
VIVA QUESTIONS
Description: Here 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 for a Python script:
The command builds a new Docker image using the Dockerfile and tag the image with the
name “myimage”
This is the simple example of how you can use Docker to containerize an application. In the
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.
VIVA QUESTIONS
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 a higher-level abstraction
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 you
application as a container image, and then use Kubernetes to manage and orchestrate the
containers.
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 expose the deployment to
the network.
Monitor and manage the containers: Use Kubernetes to monitor and manage the containers. This
includes the scaling the number of replicas, update 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 Kubernetes cluster.
This makes it easier to make updates to the application and ensure that the latest version is always
running in the cluster. By integrating Kubernetes and docker, you can leverage the strength of both
technologies to manage container in a scalable, reliable and efficient manner.
VIVA QUESTIONS
1. What is docker?
Experiment no:9. 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 that cloud provided such as google cloud or
amazon web services, or using local installation of Minikube.
Push the Docker image to 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:myapp
spec:
replicas:3
selector:
matchLabels:
app:myapp
template:
metadata:
labels:
app:myapp
spec:
container:
-name: myapp
image: myimage
ports:
-container Port: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
targetPort:80
Type: clusterIP
Apply the deployment and service to the cluster: Applying the deployment and service to the cluster
using the kubect1 command- line tool. For example:
$ kubect1 apply -f [Link]
$ kubect1 apply -f [Link]
Verify the deployment: Verify the deployment by checking the status of the pods and the service. For
example:
$ kubect1 get pods
$ kubect1 get services
This is the basic example of how to automate the process of running a containerized application using
Kubernetes. In the real-world scenarios, you would likely have more complex requirements. Such as
managing persistent data, scaling and rolling updates, but this example gives you a good starting point
for using Kubernetes to manage your containers.
VIVA QUESTIONS
1. Define Kubernetes
Description: To install and explore selenium for automated testing, you can follow the steps:
Selenium is written in Java, so you will need to install JDK in order to run it. You can download and
install JDK form the official Oracle website
Install the Selenium WebDriver:
You can download the latest version of Selenium WebDriver from the selenium website. You will also
need to download the appropriate driver for your web browser of choice (e.g: Chrome Driver for
Google Chrome)
To write and run Selenium tests, you will need an IDE. Some popular choices include Eclipse, IntelliJ
IDEA, and Visual Studio Code.
Write a simple test:
Once you have an IDE setup, you can write a simple test using the Selenium WebDriver. Here’s an
example in Java:
import [Link],WebDriver;
import [Link];
public class Main {
public static void main (string [] arg) {
[Link](“[Link]”, “path/to/chromedriver”);
WebDriver driver = new ChromeDriver();
[Link]([Link]
[Link]([Link]());
[Link]();
Run the test: Run the test using your IDE or from the command line using the following command:
$ javac [Link]
$ javac 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
Experiment no: 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: 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>
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”);
}
@After
Public void tearDown()
{
[Link]();
}
}
You can run the test case using the following commands:
$ javac [Link]
$ javac Main
The output of the test case should be:
Time: 0.189
OK (1 test)
This output indicates the test case passed, and the increment button was successfully clicked, causing the output
to be incremented by 1.
VIVA QUESTIONS
Experiment: 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 [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
@Before
Public void setUp() {
[Link](“[Link]”, “path/to/chromedriver”);
driver= new ChromeDriver();
}
@Test
Public void testHomePageLoad() {
[Link]([Link]
String title = driver getTitle();
assert [Link](“ My Conternerized Application”);
}
@Test
Public void testSubmitForm() {
[Link]([Link]
[Link]([Link](“name”)).sendKeys(“John Deo”);
[Link]([Link](“email”)).sendkeys(“[Link]@[Link]”);
[Link]([Link](“submit”)).click();
String result = [Link]([Link](“result”)).getText();
assert [Link](“Form submitted successfully!”);
}
@After
Public void tearDown(){
[Link]();
}
}
You can run the test cases using the following command:
$ [Link]
$ [Link]
The output of test cases should be:
..
Time: 1.135
OK (2 test)
This output indicates that both test case passed, and the containerized application is functioning as expected.
VIVA QUESTIONS
1. Define selenium
2. Name the test case used in selenium