0% found this document useful (0 votes)
26 views23 pagesDevops Lab Manual
The document is a DevOps lab manual for B-TECH CSE (AIML) students, detailing various experiments related to user registration forms, Git and GitHub commands, Jenkins setup, Docker commands, and Kubernetes integration. Each experiment includes aims, descriptions, and steps to complete tasks such as building applications, managing source code, and automating deployments. Additionally, it includes viva questions to assess understanding of the concepts covered.
Uploaded by
mailtoamith8Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF or read online on Scribd
0% found this document useful (0 votes)
26 views23 pagesDevops Lab Manual
The document is a DevOps lab manual for B-TECH CSE (AIML) students, detailing various experiments related to user registration forms, Git and GitHub commands, Jenkins setup, Docker commands, and Kubernetes integration. Each experiment includes aims, descriptions, and steps to complete tasks such as building applications, managing source code, and automating deployments. Additionally, it includes viva questions to assess understanding of the concepts covered.
Uploaded by
mailtoamith8Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF or read online on Scribd
/ 23
IlI-Il B-TECH CSE (AIML)
DEVOPS LAB MANUAL
DEVOPS LAB MANUAL
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.
DESCRIPTIO!
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:
FROM python:3.8
WORKDIR /app
COPY..
RUN pip install --no-cache-dir -r requirements.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—=I.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']
# Store the user data in a database or file
return render_template('success.htm|')
—_————————<$<__ _ _ _
MRITS Page 1
@ scanned with OKEN Scanner III-I] B-TECH CSE (AIML)
DEVOPS LAB MANUAL
return render_template('register: html)
if _name_ main_':
app.run(host="0.0.0.0')
* Create an templates folder and add the following two files:
register:html and success.html.
register.html
success.html
Committing changes: $ git commit -m "commit message"
Checking the commit history: $ git log
Undoing changes: $ git checkout
Creating a new branch: § git branch
Switching to a different branch: $ git checkout
Merging two branches: S git merge
Pushing changes to a remote repository: $ git push origin
Cloning a repository from GitHub: § git clone
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 functionali
ies that you can explore to suit
your needs.
VIVA QUESTIONS
Define Git
What is Git Hub
Difference between Git & Git Hub
MRITS
Page 3
@ scanned with OKEN Scanner TII-I] B-TECH CSE (AIML)
DEVOPS LAB MANUAL
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
* Move to the repository directory: $ cd
© Create a new file in the repository and add the source code written in
exercise 1.
© Stage the changes: $ git add
* 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.
VIVA QUESTIONS
What is Git Hub management
@ scanned with OKEN Scanner Il-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL
EXPERIMENT NO: 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 (CCD) 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:8080 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
SE
MRITS Page 5
@ scanned with OKEN Scanner III-I B-TECH CSE (AIML)
DEVOPS LAB MANUAL
integrate with other tools. However, these steps should give you a good
starting point for using Jenkins for CCD in your software development
projects.
VIVA QUESTIONS
Define Jenkins
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:
MRITS Page 6
@ scanned with OKEN Scanner III-IIl B-TECH CSE (AIML)
DEVOPS LAB MANUAL
* 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 calculati
S.
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.
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.
MRITS Page 7
@ scanned with OKEN Scanner III-Il B-TECH CSE (AIML)
DEVOPS LAB MANUAL,
* 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 CCD in your
software development projects.
VIVA QUESTIONS
Define CD & CI
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 --name mycontainer -it ubuntu:16.04 /bin/bash
This command runs a new container based on the Ubuntu 16.04
image and starts a shell session in the container.
* Docker start: Start one or more stopped containers.
For example: § docker start mycontainer
This command starts the container named "mycontainer".
* Docker stop: Stop one or more running containers.
For example: $ docker stop mycontainer
This command stops the container named "mycontainer".
* Docker mm: Remove one or more containers.
For example: $ docker rm mycontainer
This command removes the container named "mycontainer".
—_—_——
MRITS Page &
@ scanned with OKEN Scanner II-I B-TECH CSE (AIML)
DEVOPS LAB MANUAL
* 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.
For example: $ docker pull ubuntu:16.04
This command pulls the Ubuntu 16.04 image from the Docker Hub registry.
* Docker push: Push an image or a repository to a registry.
For example: $ docker push myimage
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.
VIVA QUESTIONS
Give briefly about Docker commands
MRITS Page 9
@ scanned with OKEN Scanner IlI-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL
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:
# Use the official Python image as the base image
FROM python:3.9
# Copy the Python script into the container
COPY hello.py /app/
————- oro —_—— ——
MRITS Page 10
@ scanned with OKEN Scanner I1I-Il B-TECH CSE (AIML)
DEVOPS LAB MANUAL
# 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 -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.
VIVA QUESTIONS
Name the applications using Docker
MRITS Page 11
@ scanned with OKEN Scanner III-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL
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 a 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:
@ scanned with OKEN Scanner TII-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL,
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 image to
be used, and creating a service that exposes the deployment to the network.
Monitor and manage the containers:
Use Kubemetes 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 (CV/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.
MRITS Page 13
@ scanned with OKEN Scanner III-I1 B-TECH CSE (AIML)
DEVOPS LAB MANUAL
Viva questions:
Define integrate Kubernetes
What is Docker
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
MRITS Page 14
@ scanned with OKEN Scanner III-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL
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
MRITS Page 15
@ scanned with OKEN Scanner Ifl-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL
targetPort: 80
type: ClusterlP
* Apply the deployment and service to the cluster:
Apply the deployment and service to the cluster using the kubeet! command-
line tool. For example:
§ kubectl apply -f deployment.yaml
$ kubect! apply -f service.yaml
* Verify the deployment:
Verify the deployment by checking the status of the pods and the service. For
example:
S kubectl got 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 using Kubernetes to manage your containers.
VIVA QUESTIONS
Define Kubernetes
MRITS Page 16
@ scanned with OKEN Scanner MII-II B-TECH CSE (AIML)
DEVOPS LAB MANUAL
EXPERIMENT NO.: 10. Install and Explore Sel
im 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.
MRITS Page 17
@ scanned with OKEN Scanner III-I1 B-TECH CSE (AIML)
DEVOPS LAB MANUAL.
© Write a simple test:
* Once you have your IDE set up, you can write a simple test using the
Selenium WebDriver. Here's an example in Java:
import org.openga.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
public class Main {
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.printIn(driver.getTitle());
driver.quit();
© Run the 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
MRITS Page 18
@ scanned with OKEN Scanner IlI-IT B-TECH CSE (AIML)
DEVOPS LAB MANUAL.
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
Simple JavaScript Program
utput">0