An Internship Report

on

“DEVOPS TRAINING”

Submitted in Partial Fulfillment of the Requirements for the Award of the Degree

of

BACHELOR OF TECHNOLOGY
IN

COMPUTER SCIENCE AND ENGINEERING

(BATCH: 2022-2026 / 7th SEMESTER)

SUBMITTED BY

S. No. STUDENT NAME ENROLLMENT NO. ROLL NO.

01. Balwant Singh CVB2201664 R22ET1CSE0023

SUBMITTED TO
SAURAV SINGH
ASSISTANT PROFESSOR, CSE DEPARTMENT

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

DR. C.V. RAMAN UNIVERSITY, VAISHALI (BIHAR)
 ([Link])

Computer Science Engineering Department

Internship Certificate

This is to be certify that Balwant Singh (CVB2201664/R22ET1CSE0023) has successfully completed the INTERNSHIP PROJECT on
“DEVOPS TRAINING” Submitted in partial fulfillment for the award of the degree of Bachelor of Technology in COMPUTER SCIENCE &
ENGINEERING (Session 2022-2026) from Dr. C. V. Raman University, Vaishali.

Saurav Singh Ashutosh Ranjan

Internship Guide HOD External
 ACKNOWLEDGEMENT
I would like to express my heartfelt gratitude to CETPA Infotech Pvt. Ltd. for providing me
with the opportunity to undergo this six-week DevOps internship. The training experience
enhanced my practical knowledge and exposed me to real-world IT tools used in the
industry.

I would also like to thank my trainer Shailendra Shukla, who guided me throughout the
training with detailed explanations, demonstrations, and regular practical assignments. Their
guidance helped me understand how DevOps is applied in real organizations.

I am equally thankful to Dr. C.V. Raman University and my internship coordinator Saurav
Singh for their support and encouragement. This internship has been a significant step in my
technical and professional development.
 ABSTRACT
This internship report presents a comprehensive day-wise documentation of the work I
completed during a six-week DevOps training program. Throughout the internship, I received
both theoretical knowledge and practical exposure to essential DevOps tools and technologies
that are commonly used in the IT industry. The training curriculum covered multiple real-world
DevOps tools such as Git (version control), Jenkins (CI/CD automation), Docker
(containerization), Kubernetes (orchestration), Terraform (infrastructure as code), Puppet
and Ansible (configuration management), and Nagios (monitoring). Each tool was taught
with step-by-step explanations and practical sessions which helped me understand how
DevOps is implemented in real company environments.

The training focused on the DevOps lifecycle, starting from code development and version
control, followed by automation of builds, continuous integration, continuous deployment,
cloud-based implementation, configuration management, and infrastructure monitoring. I
successfully executed key DevOps processes such as building pipelines in Jenkins,
containerizing applications using Docker, deploying them on Kubernetes clusters,
provisioning infrastructure with Terraform, and monitoring system performance using
Nagios.

This report summarizes the learning outcomes, tools used, project implementation details,
and future scope of DevOps in the IT world. It has helped me understand how automation
plays a crucial role in modern software development and how DevOps transforms the way
technology companies operate today.
 TABLE OF CONTENTS
Chapter / Section Topic Name Page No.

— Internship Completion Certificate ____

— College Approval Certificate ____

— Acknowledgement ____

— Abstract ____

Chapter 1 Company Profile 1-2

Chapter 2 Introduction to DevOps 3-4

Chapter 3 Objectives of the Internship 5-6

Chapter 4 DevOps Fundamentals 7-8

Chapter 5 Day-Wise Training Report 9-29

Day 1 – Introduction to DevOps 10

Day 2 – Why DevOps is Needed 10

Day 3 – DevOps Delivery Pipeline 11

Day 4 – DevOps Tools Ecosystem 11

Day 5 – Cloud & AWS Overview 12

Day 6 – Introduction to Git 12

Day 7 – Git Commands & Local Repository 13

Day 8 – Working with GitHub 13

Day 9 – Branching & Merging 14

Day 10 – Introduction to Jenkins 14

Day 11 – Jenkins Setup & Plugins 15

Day 12 – Jenkins Build Automation 15

Day 13 – Jenkins Cron & Scheduling 16

Day 14 – Introduction to Maven 16

Day 15 – Maven + Jenkins Integration 17

Day 16 – Introduction to Docker 17

Day 17 – Running Docker Containers 18

Day 18 – Dockerfile & Custom Images 18

Day 19 – Docker Networking & Volumes 19

Day 20 – Introduction to Terraform 19

Day 21 – Kubernetes Overview 20

Day 22 – Kubernetes Cluster Setup 20

Day 23 – Pods & YAML Deployment 21

Day 24 – Kubernetes Services 21

Day 25 – Kubernetes Dashboard 22

Day 26 – Introduction to Puppet 22

Day 27 – Puppet Configuration 23

Day 28 – Introduction to Ansible 23

Day 29 – Ansible Playbooks 24

Day 30 – Ansible Automation 24

Day 31 – Introduction to Nagios 25

Day 32 – Nagios Configuration 25

Day 33 – Monitoring with Nagios 26

 Day 34 – Final DevOps Project Setup 26

Day 35 – CI/CD Project Execution 27

Day 36 – Internship Review 27

Day 37 – Resume Preparation 28

Day 38 – Interview Preparation 28

Day 39 – Final Revision 29

Day 40 – Internship Completion 29

Chapter 6 Tools & Technologies Learned 30-33

Chapter 7 Mini Project – CI/CD Pipeline 34-38

Chapter 8 Conclusion & Future Scope 39-41

 CHAPTER 1

COMPANY PROFILE

1
 CETPA INFOTECH PVT. LTD.
CETPA Infotech Pvt. Ltd. is one of the most reputed and trusted industrial training and
development organizations in India, specializing in a wide range of information technology
(IT) domains. It provides professional training in various emerging technologies such as
DevOps, Cloud Computing, Data Science, Python Programming, Artificial Intelligence,
Cybersecurity, Web Development, Networking, and Software Testing. The company offers
both online and offline training modes, making it suitable for students as well as working
professionals.

What makes CETPA different from other training institutes is its practical, industry-oriented
approach to learning. Instead of focusing only on theory, every topic is supported with live
demonstrations, hands-on lab sessions, real-time examples, and assignments that resemble
actual corporate working environments. This helps students understand how technologies
are used inside IT companies.

CETPA also focuses on career development and employability. As part of the training,
students are given guidance on resume preparation, interview techniques, project
presentation skills, and mock interview sessions that help in building confidence for
placement drives. The institute works with experienced trainers from top IT companies who
bring real industry insights and best practices into the training sessions.

CETPA also provides capstone projects where trainees work on real-world use cases. These
projects help in building strong portfolios and practical experience that can be shown in job
interviews. The organization has tie-ups with several placement partners, and it provides
ongoing support even after training—making it a reliable platform for building an IT career.

2
 CHAPTER 2

INTRODUCTION TO DEVOPS

3
DevOps is a combination of two words — Development (Dev) and Operations (Ops) —
which aims to improve collaboration between software developers and IT operations teams.
In traditional software development approaches, both teams worked separately, leading to
delays, miscommunication, and challenges in deployment. DevOps solves these problems by
bringing both teams together and using automation, continuous integration, and
continuous delivery to speed up software development and deployment.

The main objective of DevOps is to ensure faster delivery, higher quality, reliable updates,
and reduced manual errors in the software development lifecycle. DevOps is not just a tool
or technology — it is a culture, a mindset, and a way of working that focuses on teamwork,
automation, performance, and innovation.

Modern IT companies such as Netflix, Amazon, Google, Facebook, Paytm, and Flipkart use
DevOps practices to deploy hundreds of updates every day without affecting user
experience. This proves how powerful and efficient DevOps is in real-world scenarios.

DevOps covers various stages such as:

• Planning the application

• Writing the code

• Building and testing the application

• Deploying it to servers or cloud

• Monitoring performance in real-time

• Collecting feedback and improving it further

Through this internship, I learned how DevOps transforms software development and how
different tools work together to support automation and reliability in IT companies.

4
 CHAPTER 3

OBJECTIVES OF THE INTERNSHIP

5
The primary objective of this internship was to gain hands-on experience with DevOps tools
and practices that are used in real IT industries. The training helped me understand how
software development, deployment, testing, and monitoring can be automated using
different tools. The internship focused on both technical learning and professional
development.

The main objectives were:

1. To understand the concept and lifecycle of DevOps and its importance in modern IT
companies.

2. To get practical knowledge of Git, Jenkins, Docker, Kubernetes, Terraform, Puppet,

Ansible, and Nagios.

3. To build skills for automation, CI/CD pipelines, containerization, and monitoring.

4. To learn industry-level workflows and how development and operations teams

collaborate.

5. To understand cloud-based DevOps applications using platforms like AWS.

6. To develop problem-solving, documentation, and communication skills, which are

important for IT jobs.

7. To create a mini DevOps project that shows how applications are deployed and
monitored practically.

By the end of this internship, I gained a solid foundation in DevOps and felt more confident
about working in real company environments and applying for technical roles such as
DevOps Engineer, Cloud Engineer, or Site Reliability Engineer (SRE).

6
 CHAPTER 4
DEVOPS FUNDAMENTALS

7
The fundamentals of DevOps revolve around improving teamwork, automation, and
software delivery speed. DevOps follows a structured workflow known as the DevOps
Lifecycle, which includes the following stages:

1. Plan – Collect requirements and plan the software.

2. Code – Develop the application using version control tools like Git.
3. Build – Compile and package the application using tools like Maven.
4. Test – Test the code to ensure it works correctly.
5. Release – Prepare for deployment in a stable environment.
6. Deploy – Deploy application using servers, containers, or cloud platforms.
7. Monitor – Track performance using monitoring tools like Nagios or Prometheus.

To support each stage, different tools are used in the DevOps ecosystem:

• Git – Version control

• Jenkins – Continuous integration

• Docker – Containerization

• Kubernetes – Container orchestration

• Terraform – Infrastructure as code

• Puppet & Ansible – Configuration management

• Nagios – Monitoring

Another core part of DevOps is automation. Tasks that were previously done manually—
such as deployments, updates, configuration, and testing—are now done automatically
using scripts and tools. This reduces errors and makes the software ready faster.

DevOps also aligns closely with cloud computing, where servers and infrastructure can be
created, managed, and deleted using code. Tools like AWS and Terraform help in automating
infrastructure creation.

Overall, the DevOps fundamentals build the foundation for modern IT workflows, and
learning these concepts during the internship helped me understand how companies deploy
and maintain applications efficiently.

8
 CHAPTER 5
DAY-WISE TRAINING REPORT

9
DAY 1 – Introduction to DevOps

• The internship started with an orientation session where the trainer explained the
goals, roadmap, and importance of DevOps in the current IT industry. We were also
informed that this training would include both theory and practical implementation.

• We learned about the current trends in software development and why traditional IT
models like Waterfall and Agile face limitations in deployment speed, collaboration,
and scalability. This gave a strong reason for the rise of DevOps.

• We discussed how top companies like Netflix, Amazon, and Google use DevOps to
deploy updates daily with minimum downtime. Understanding these real-world
scenarios helped me relate DevOps with industry needs.

DAY 2 – Why DevOps?

• The trainer explained the problems faced before DevOps such as slow deployments,
communication gaps between teams, difficulty in rollback, and manual configuration
efforts. These issues caused delays and bugs in software delivery.

• I learned how DevOps creates a continuous workflow between Development and

Operations teams through automation, collaboration, and faster feedback. This
improves the software release cycle.

• A short task was assigned to write differences between traditional approach and
DevOps approach. This helped me clearly understand the shift in mindset from
manual work to automation.

10
DAY 3 – DevOps Delivery Pipeline

• Today, we studied the DevOps lifecycle and understood each stage of the pipeline:
Planning → Coding → Building → Testing → Releasing → Deploying → Monitoring.
This showed how DevOps supports continuous development.

• The trainer also mapped each stage with real tools such as Git for version control,
Jenkins for CI, Docker for containerization, Kubernetes for orchestration, and Nagios
for monitoring.

• I drew the entire DevOps pipeline in my notebook and noted which tool is used at
which stage. This was very helpful to visualize the complete journey of a software
application.

DAY 4 – DevOps Tools Ecosystem

• The trainer introduced the complete set of DevOps tools used in industries and
explained why companies use multiple tools together instead of one single software.

• I learned the basic purpose of each category:

o Git → Version Control

o Jenkins → Continuous Integration

o Docker → Containerization

o Kubernetes → Orchestration

o Terraform → Infrastructure as Code

o Puppet / Ansible → Configuration Management

o Nagios → Monitoring

• I was asked to prepare a chart matching tools with their functions and this activity
helped build a clearer understanding of the DevOps ecosystem.

11
DAY 5 – DevOps on Cloud & AWS Account Setup

• Today we discussed why cloud computing is important for DevOps. The trainer
explained the pay-as-you-go model and how cloud reduces hardware cost and
increases flexibility.

• We compared On-Premise vs Cloud-based deployment models. AWS was chosen as

our cloud platform for practical implementation during this internship.

• I created my AWS account and explored services like EC2, S3, IAM, and VPC. This
helped me understand how DevOps is implemented in real cloud environments.

DAY 6 – Introduction to Git (Practical Session)

• Git was installed on my system and configured using global settings.

• git config --global [Link] "Your Name"

• git config --global [Link] "youremail@[Link]"

• I learned how to initialize a repository using git init and explored the working
directory and staging area concepts. The trainer explained how Git tracks file changes
efficiently.

• This was the first practical exercise in the training, and I successfully created my first
Git project and viewed its structure using ls -a.

12
DAY 7 – Git Commands and Local Repository

• Today was fully practical. We learned important Git commands such as:

• git add .

• git status

• git commit -m "Initial commit"

• git log

• git diff

• I practiced adding, modifying, and deleting files in Git. I understood how Git tracks
each change, which is essential for collaborative work.

• By the end of the session, I was confident using Git in terminal and managing a
simple repository.

DAY 8 – GitHub & Remote Repository

• Trainer explained how GitHub is used for storing projects online and for team
collaboration. I created a GitHub account and set up SSH authentication.

• I connected my local repository to GitHub using the following command:

• git remote add origin <repository-url>

• git push -u origin main

• I uploaded my first project successfully to GitHub. Seeing my work online helped me

understand real collaboration workflows used in companies.

13
DAY 9 – Branching & Merging in Git

• Today I learned advanced concepts like branching and merging, which are essential in
team-based development. Branches were created using:

• git branch feature1

• git checkout feature1

• I worked on separate branches and later merged them into the main branch using git
merge feature1. The trainer also explained how merge conflicts occur and how to
resolve them.

• A small assignment was given to create two branches, make changes, and combine
them. This made me feel like working in a real software development environment.

DAY 10 – Introduction to Jenkins

• The session started with an explanation of Continuous Integration (CI) and how
Jenkins helps automate software building and testing without manual effort.

• The trainer explained Jenkins architecture, including Master Node and Slave Node
concept. I understood that Jenkins acts as a CI server which executes automated
tasks through jobs and pipelines.

• We downloaded Jenkins and learned how to start it using:

• java -jar [Link]

• At the end of the session, I successfully accessed Jenkins from the browser at
localhost:8080.

14
DAY 11 – Jenkins Setup & Configuration

• I completed the post-installation setup, created an admin user, and unlocked Jenkins
using the initial password. The plugin installation was successfully performed.

• The trainer explained plugin management and how tools like Git, Maven, Docker,
and Kubernetes can be integrated with Jenkins. Plugins extend Jenkins functionality.

• I explored system configuration settings and learned how to allocate workspace and
configure Git credentials.

• Assignment: Explore “Manage Jenkins” section and prepare notes on frequently used
plugins.

DAY 12 – Creating First Jenkins Job

• I created my first Freestyle Jenkins Job and integrated Git repository with Jenkins
using the repository URL.

• The trainer showed how Jenkins pulls source code directly from GitHub when a build
is triggered.

• I performed an automated build and observed build logs and console output, which
helped me understand real-time CI implementation.

• Commands used inside Jenkins build:

• git pull

• mvn clean install

• This was my first automated CI pipeline experience.

15
DAY 13 – Build Automation Using Scheduler

• I learned how to schedule builds using Cron syntax in Jenkins. The trainer explained
how jobs can run automatically at specific intervals.

• Example Cron used:

• H/5 * * * * (runs every 5 minutes)

• This helped me understand automation and periodic testing in real development.

• I also learned how to view build history and how Jenkins stores execution logs.

DAY 14 – Introduction to Maven

• Maven was introduced as a build automation and dependency management tool.

The trainer explained how projects are structured and compiled using Maven.

• Maven was installed and environment variables were configured in system path. I
verified installation using:

• mvn --version

• We explored Maven project structure:

• src/

• └── main/

• └── java/

• └── test/

• [Link]

• Understood the importance of [Link] file for dependencies.

16
DAY 15 – Jenkins + Git + Maven Integration

• Today we worked on integrating Git → Jenkins → Maven, where Git pushed changes
and Jenkins automatically compiled the project using Maven.

• Inside Jenkins build step, the trainer executed:

• mvn clean package

• A complete CI workflow was achieved and I understood how real companies ensure
quality code using automated builds and tests.

• This session made me realize how Jenkins pipelines play a huge role in production
environments.

DAY 16 – Introduction to Docker

• The trainer explained the difference between Virtual Machines and Containers.

• I understood that Docker allows lightweight container-based deployment with less

resource usage than VMs.

• Docker architecture was explained:

o Docker Engine

o Docker Images

o Docker Containers

o Docker Hub

• Installation of Docker was done on Linux, and we verified it using:

• docker --version

17
DAY 17 – Running Containers in Docker

• I ran my first container using:

• docker run hello-world

• Learned how to pull images from Docker Hub with:

• docker pull ubuntu

• docker pull nginx

• Understood how containers are temporary environments and how they can be
started, stopped, and removed.

• Commands practiced:

• docker ps

• docker ps -a

• docker stop <container_id>

• docker rm <container_id>

DAY 18 – Dockerfile & Custom Images

• Trainer introduced Dockerfile and explained how to build custom images.

• I wrote my first Dockerfile:

• FROM ubuntu

• RUN apt-get update

• CMD ["echo", "My first custom image"]

• Built image using:

• docker build -t myimage:v1 .

• I realized how companies package their applications using custom Docker images.

18
DAY 19 – Docker Networking & Volumes

• Learned how containers communicate using networks and how ports are exposed:

• docker run -p 8080:80 nginx

• Trainer explained the importance of volumes for storing persistent data:

• docker volume create mydata

• docker run -v mydata:/data ubuntu

• Understood why networking & storage are critical in deployment environments.

DAY 20 – Terraform Introduction

• I was introduced to Terraform, a tool used for Infrastructure as Code (IaC).

• Understood the concept of managing servers using code instead of manual cloud
setup.

• Terraform files use .tf extension and contain configuration for cloud resources.

• Practiced basic Terraform commands:

• terraform init

• terraform plan

• terraform apply

• I learned its importance in AWS automation & DevOps.

19
DAY 21 – Introduction to Kubernetes

• The trainer explained why Docker alone is not enough for production-level
deployment. Kubernetes was introduced as a container orchestration platform used
to manage multiple containers efficiently.

• We studied the architecture of Kubernetes including Master Node, Worker Node,

Pods, and the role of Kubelet and API Server. This helped me understand how large-
scale applications are handled in the industry.

DAY 22 – Kubernetes Cluster Setup

• Practical session started with creating a Kubernetes cluster on virtual machines using
Ubuntu. A master and a worker node were configured using kubeadm.

• Commands used during setup:

• kubeadm init

• kubectl get nodes

• kubectl get pods --all-namespaces

• Successfully connected worker node with master node to form a real cluster
environment.

20
DAY 23 – Working with Pods, Deployments & YAML

• I learned how to deploy applications in Kubernetes using YAML configuration files.

The trainer explained Pod, ReplicaSet, and Deployment concepts.

• Example YAML used:

• apiVersion: v1

• kind: Pod

• metadata:

• name: mypod

• spec:

• containers:

• - name: mycontainer

• image: nginx

• Deployed the pod using kubectl apply -f [Link] and accessed it using command
line.

DAY 24 – Kubernetes Services & Networking

• We learned how services expose pods to users using NodePort and LoadBalancer. I
understood how containers communicate through networking.

• Commands practiced:

• kubectl expose deployment mydeploy --type=NodePort --port=80

• kubectl get svc

• This made me understand how users access applications deployed inside Kubernetes.

21
DAY 25 – Kubernetes Dashboard

• The trainer guided us to install Kubernetes Dashboard for GUI-based monitoring.

• I deployed an application through the dashboard and viewed logs, resources, and
pod status visually.

• This was the first time I experienced a graphical orchestration system, making
Kubernetes easier to understand.

DAY 26 – Introduction to Puppet (Configuration Management)

• Puppet was introduced as a configuration management tool used to automatically

configure servers.

• We learned Puppet architecture: Puppet Master, Agent, Manifests, and Modules.

• Installed Puppet and understood how servers can be managed using scripts rather
than manual commands.

22
DAY 27 – Puppet Practical Session

• Today we configured Puppet Master and Puppet Agent on different machines.

• Wrote a sample Puppet manifest:

• file { '/tmp/[Link]':

• ensure => 'present',

• content => 'This file is created by Puppet.'

• }

• Applied the manifest using:

• puppet apply [Link]

• This showed how Puppet automatically configures servers without manual work.

DAY 28 – Introduction to Ansible

• Ansible was introduced as a lightweight configuration management tool and an

alternative to Puppet.

• The trainer explained that Ansible uses SSH and works without agents, making it easy
for system administrators.

• Installed Ansible and explored configuration files at /etc/ansible/hosts.

23
DAY 29 – Ansible Playbooks & Roles

• Today I learned how to write Ansible Playbooks for automation.

• Sample playbook created:

• - hosts: all

• tasks:

• - name: install apache

• apt:

• name: apache2

• state: present

• Executed it using ansible-playbook [Link] and Apache server successfully

installed on the target machine.

DAY 30 – Adhoc Commands & Remote Automation

• Practiced Ansible ad-hoc commands:

• ansible all -m ping

• ansible all -m shell -a "uptime"

• These commands helped me manage multiple machines remotely.

• I understood how Ansible works in real companies for system administration.

24
DAY 31 – Introduction to Nagios (Monitoring)

• The trainer explained why monitoring is important in DevOps to ensure system

health and quick issue detection.

• Nagios was introduced as a monitoring tool that tracks services, CPU usage, ports,
and server uptime.

• Installed Nagios Core and understood the role of NRPE plugin.

DAY 32 – Nagios Implementation

• Configured host monitoring using Nagios and added plugins to check server status.

• Commands executed:

• service nagios restart

• tail -f /var/log/[Link]

• I observed real-time monitoring and alerts which made me understand how

production servers are maintained.

25
DAY 33 – Monitoring Multiple Servers

• Today we added another machine in Nagios monitoring using NRPE.

• Tested monitoring for CPU, memory, and HTTP service using:

• check_http

• check_cpu

• check_mem

• I understood how DevOps teams ensure the system stays healthy with 24/7
monitoring.

DAY 34 – Final DevOps Project Preparation

• The trainer explained how to combine Git, Jenkins, Docker, Kubernetes, and Ansible
into a complete DevOps pipeline.

• Started a mini project where code from Git was built using Jenkins, containerized
using Docker, deployed using Kubernetes, and monitored using Nagios.

• This helped me see the real use of DevOps in industry-level automation.

26
DAY 35 – Final Project Execution

• Successfully ran the DevOps pipeline with all integrated tools.

• It was a complete CI/CD experience from code commit to deployment and

monitoring.

• Learned how teams work collaboratively in DevOps environments.

DAY 36 – Internship Review & Feedback

• Trainer took feedback regarding the overall internship.

• Discussed job profiles, interview requirements, and industry expectations from

DevOps engineers.

• Understood how DevOps roles are evolving with cloud computing.

27
DAY 37 – Resume Preparation Session

• A special session was conducted where we learned how to prepare DevOps-focused

resumes.

• Trainer guided us to list tools clearly and include practical project details.

• Learned how to present technical skills during placements.

DAY 38 – Interview Preparation & Mock Test

• Conducted a mock interview for DevOps including Git, Docker, Jenkins, and
Kubernetes questions.

• Trainer shared frequently asked interview questions for DevOps engineer roles.

• This improved my confidence and communication.

28
DAY 39 – Final Revision Session

• We revised all tools: Git, Jenkins, Maven, Docker, Kubernetes, Puppet, Ansible,
Terraform, Nagios.

• Trainer explained real-time DevOps workflows followed inside IT industries.

• Understood how DevOps solves problems related to manual deployment.

DAY 40 – Internship Conclusion

• Submitted mini project and practical assignments.

• Trainer appreciated efforts and shared further learning roadmap for DevOps career.

• Overall, this internship strengthened my technical knowledge and practical skills.

29
 CHAPTER 2
TOOLS & TECHNOLOGIES LEARNED

30
During the DevOps internship, I learned and practically implemented multiple tools that are
used in real IT industry for development, deployment, automation, orchestration, and
monitoring. Below is the summary of all major tools and skills learned during the training:

1. Git – Version Control

• Learned how to track code changes using Git and manage repositories locally as well
as remotely.

• Practiced commands such as git init, git add, git commit, git push, git pull, git branch,
and git merge.

• Understood branching, merging, conflict resolution, and used GitHub to upload

projects and collaborate like real developers.

2. Jenkins – Continuous Integration

• Learned how automated builds work using Jenkins as a CI server.

• Configured Jenkins, installed plugins, created freestyle jobs, and linked GitHub
repositories for auto-builds.

• Used Cron syntax for scheduled builds and created first CI pipeline using Jenkins and
Maven.

3. Maven – Build Automation

• Understood why Maven is used for Java-based projects.

• Learned how dependencies are automatically handled inside [Link] file.

• Practiced mvn clean install, mvn package, and used Maven inside Jenkins job for
automated builds.

4. Docker – Containerization

31
 • Understood the concept of containers vs virtual machines.

• Installed Docker and practiced pulling images, creating containers, exposing ports,
and managing lifecycle.

• Created custom Docker image using Dockerfile and published it on Docker Hub.

• Learned about volumes, networking, and running web apps inside containers.

5. Kubernetes – Orchestration

• Learned how Kubernetes manages containerized applications at large scale.

• Set up a Kubernetes master and worker node and deployed applications using YAML
files.

• Practiced kubectl get pods, kubectl apply, kubectl expose commands and deployed
an app using Kubernetes Dashboard.

6. Terraform – Infrastructure as Code (IaC)

• Learned how to create AWS infrastructure using Terraform scripts instead of manual
cloud setup.

• Practiced terraform init, terraform plan, terraform apply commands.

• Created an EC2 instance using Terraform and managed cloud resources through .tf
configuration files.

32
7. Puppet – Configuration Management

• Learned how Puppet automates configuration of servers.

• Practiced Puppet manifests and modules to create files and install packages
automatically.

• Understood Master-Agent concept and node classification for centralized server

management.

8. Ansible – Automation & Remote Execution

• Understood how Ansible works without agents and uses SSH for automation.

• Practiced adhoc commands and wrote sample playbooks to install packages on

remote machines.

• Successfully automated server tasks using YAML-based configurations.

9. Nagios – Monitoring

• Learned the importance of monitoring in DevOps.

• Installed Nagios Core and used NRPE plugins to track server health, CPU usage, and
services.

• Understood how alerts and notifications help DevOps teams prevent system failure.

SOFT SKILLS DEVELOPED

Apart from technical skills, this internship also helped in improving:

• Problem solving ability

• Communication and teamwork skills

• Time management, Interview preparation and resume building.

33
 CHAPTER 3

PRACTICAL IMPLEMENTATION / MINI PROJECT

34
During the internship, I worked on a mini DevOps implementation to understand how
different tools are connected in real industry workflows. The project involved creating a
basic CI/CD pipeline with Git, Jenkins, Docker, Kubernetes, and monitoring using Nagios.

PROJECT TITLE:

Automated CI/CD Pipeline Deployment Using Jenkins, Docker & Kubernetes

OBJECTIVE OF THE PROJECT

• To automate code integration, build, deployment, and monitoring.

• To understand the real use of CI/CD workflow in DevOps.

• To create a pipeline that requires minimum manual work.

• To deploy an application inside Docker containers using Kubernetes.

• To monitor the application using Nagios.

TOOLS USED IN THE PROJECT

Tool Purpose

Git Version control for source code

Jenkins CI pipeline automation

Maven Build automation

Docker Containerization

Kubernetes Orchestration

Terraform Infrastructure provisioning

Ansible Remote configuration

35
 Nagios Monitoring

PROJECT WORKFLOW (STEP-BY-STEP)

1. Git & Version Control

• Created a Git repository and committed the application code.

• Pushed the repository to GitHub for remote access.

Command Example:

git init

git add .

git commit -m "Initial project"

git push origin main

2. Jenkins CI Setup

• Created a Jenkins Freestyle Job and connected it with Git repository.

• Whenever new code is pushed to GitHub, Jenkins pulls it automatically and builds it.

Cron Job Example:

H/5 * * * * (build every 5 minutes)

3. Maven Build Automation

• Maven was used to build the code automatically in Jenkins.

Command used:

mvn clean install

36
4. Docker Containerization

• Dockerfile was created to package the application as a container.

FROM ubuntu

RUN apt-get update

CMD ["echo", "App running inside Docker"]

• Built and pushed image to Docker Hub:

docker build -t myapp:v1 .

docker push myapp:v1

5. Kubernetes Deployment

• App was deployed in Kubernetes using YAML configuration.

apiVersion: apps/v1

kind: Deployment

metadata:

name: myapp

spec:

replicas: 2

selector:

matchLabels:

app: myapp

template:

metadata:

labels:

37
 app: myapp

spec:

containers:

- name: myapp

image: myapp:v1

• Exposed service:

kubectl expose deployment myapp --type=NodePort --port=80

6. Monitoring Using Nagios

• Nagios was installed to monitor server status and container health.

• Set up alerts for CPU, Memory, and HTTP services.

• Understood how real companies prevent downtime using continuous monitoring.

RESULT OF THE PROJECT

• Successfully created a complete CI/CD pipeline using industry tools.

• Understood end-to-end automation from code push → build → deploy → monitor.

• This activity helped in understanding real DevOps workflow used in IT companies.

LEARNING OUTCOMES

• Practical experience with core DevOps tools.

• Hands-on understanding of CI/CD pipelines.

• Industry-level exposure to automation and deployment.

• Confidence in handling real DevOps tasks and interviews.

38
 CHAPTER 4

CONCLUSION & FUTURE SCOPE

39
4.1 Conclusion

This DevOps internship at CETPA Infotech Pvt. Ltd. provided a strong foundation in both
theoretical concepts and practical implementation of modern DevOps practices. Over the
course of six weeks, I was able to work with industry-standard tools such as Git, Jenkins,
Maven, Docker, Kubernetes, Terraform, Puppet, Ansible, and Nagios, which improved my
technical knowledge and enhanced my understanding of real industry workflows.

Through daily hands-on activities, I successfully implemented CI/CD concepts, learned

containerization using Docker, deployed applications using Kubernetes, and monitored
services using Nagios. Performing these practical tasks made me realize how DevOps
accelerates software delivery, enhances automation, and reduces manual efforts in any IT
organization.

This internship also helped me develop essential professional skills such as problem-solving,
documentation, time management, teamwork, and communication, which are highly
valuable in any technical career. The training experience has increased my confidence in
working with real DevOps pipelines and prepared me to continue learning advanced
technologies.

4.2 Future Scope of DevOps

The future of DevOps is promising, as it continues to evolve and integrate with new
technologies such as Cloud Computing, Artificial Intelligence, Microservices, Serverless
Architecture, and Edge Computing. Modern IT companies now rely on DevOps for faster
deployment, scalability, cost management, and security automation.

Some key future trends in DevOps include:

• Increasing integration with AWS, Azure, and Google Cloud services

• Use of AI/ML with DevOps (AIOps) for predictive monitoring

• Adoption of GitOps and DevSecOps for improved security

• Widespread use of Infrastructure as Code (IaC)

40
 • Serverless deployment for reduced hardware dependency

• Container orchestration at large scale using Kubernetes

• Focus on Performance monitoring and incident recovery

With the rise of automation and Cloud-native technologies, DevOps will remain a high-
demand skill in the IT industry. This internship has motivated me to explore advanced
concepts and prepare for certifications such as:

• AWS Certified DevOps Engineer

• Docker Certified Associate

• Certified Kubernetes Administrator (CKA)

• Red Hat Ansible / Puppet Certifications

4.3 Final Reflection

This internship was a valuable experience that helped me build both strong technical skills
and practical confidence. It allowed me to understand how DevOps tools work together as
one pipeline, and how teamwork, automation, and monitoring are essential in modern
software development.

I believe this internship has been a major step toward my career in DevOps and Cloud
Computing, and I look forward to continuing my learning journey in this field.

41