DEVOPS AND

DOCKER
CONTAINERS
DONE BY:
B.VENKATESH
V.LAKSHMI ANUSHA
CONTENTS:
 PROBLEM STATEMENT
 INTRODUCTION
 TECHNOLOGIES USED
 REQUIRED SOFTWARE AND
HARDWARE
 HIGH LEVEL ARCHITECTURE
 SOLUTION APPROACH
 ADVANTAGES OF DEVOPS
 IMPORTANCE OF DEVOPS
 CONCLUSION
PROBLEM STATEMENT:

THE IDEA IS TO TRANSFORM

THEIR EXISTING
TRADITIONAL WEB
APPLICATION INTO SMALLER
MICROSERVICES.
INTRODUCTION:
DEVOPS
DOCKER
DOCKER IMAGES
DOCKER HUB
DOCKER REGISTERY
KUBERNETES
KUBERNETES CLUSTER
CI/CD PIPELINE
JENKINS
 WHAT IS DEVOPS:

DEVOPS IS A SET OF PRACTICES THAT

COMBINES SOFTWARE DEVELOPMENT
(DEV) AND INFORMATION-TECHNOLOGY
OPERATIONS(OPS) WHICH AIMS TO
SHORTEN THE SYSTEMS DEVELOPMENT
LIFE CYCLE AND PROVIDE CONTINUES
DELIVERY WITH HIGH SOFTWARE
WHAT IS DOCKER:

DOCKER IS AN OPEN
SOURCE SOFTWARE PLATFORM
TO CREATE, DEPLOY AND
MANAGE VIRTUALIZED
APPLICATION CONTAINERS ON A
COMMON OPERATING SYSTEM
WHAT IS DOCKER IMAGES:
A DOCKER IMAGE IS A FILE,
COMPRISED OF MULTIPLE LAYERS,
USED TO EXECUTE CODE IN A
DOCKER CONTAINER.
AN IMAGE IS ESSENTIALLY BUILT
FROM THE INSTRUCTIONS FOR A
COMPLETE AND EXECUTABLE
VERSION OF AN APPLICATION,
WHICH RELIES ON THE HOST
OS KERNAL.
WHAT IS DOCKER HUB:

DOCKER HUB IS A SERVICE

PROVIDED BY DOCKER FOR
FINDING AND SHARING
CONTAINER IMAGES WITH YOUR
TEAM.
IT PROVIDES THE FOLLOWING
MAJOR FEATURES:
REPOSITORIES: PUSH AND PULL
WHAT IS DOCKER REGISTERY:

A DOCKER REGISTRY IS A STORAGE AND

DISTRIBUTION SYSTEM FOR
NAMED DOCKER IMAGES.
THE SAME IMAGE MIGHT HAVE MULTIPLE
DIFFERENT VERSIONS, IDENTIFIED BY THEIR TAGS.
A DOCKER REGISTRY IS ORGANIZED
INTO DOCKER REPOSITORIES, WHERE A
REPOSITORY HOLDS ALL THE VERSIONS OF A
SPECIFIC IMAGE.
WHAT IS KUBERNETES:

AN OPEN SOURCE PLATFORM FROM GOOGLE FOR

RUNNING CONTAINERS (SEE OS VIRTUALIZATION) ACROSS
CLUSTERS OF SERVERS.
PRONOUNCED "KOO-BER-NET-EEZ," THE NAME IS GREEK
FOR "HELMSMAN OF A SHIP."
BASED ON GOOGLE'S OWN INFRASTRUCTURE FOR ITS
APPLICATIONS AND SEARCH FUNCTIONS, KUBERNETES
WAS MADE AVAILABLE TO THE PUBLIC IN 2014.
GOOGLE'S CONTAINER ENGINE, WHICH IS ONE OF THE
MANY SERVICES UNDER THE GOOGLE CLOUD PLATFORM, IS
BUILT ON KUBERNETES. SEE TECTONIC AND  GOOGLE
CLOUD PLATFORM.
WHAT IS KUBERNETES CLUSTER:

A KUBERNETES CLUSTER IS MADE OF A MASTER

NODE AND A SET OF WORKER NODES. IN A
PRODUCTION ENVIRONMENT THESE RUN IN A
DISTRIBUTED SETUP ON MULTIPLE NODES.
FOR TESTING PURPOSES, ALL THE COMPONENTS
CAN RUN ON THE SAME NODE (PHYSICAL OR
VIRTUAL) BY USING MINIKUBE.
KUBERNETES HAS SIX MAIN COMPONENTS THAT
FORM A FUNCTIONING CLUSTER:
 API SERVER
SCHEDULAR
CONTROLLER MANAGER
KUBELET
WHAT IS CI/CD PIPELINE:

CI/CD PIPELINE HELPS YOU

AUTOMATE STEPS IN YOUR
SOFTWARE DELIVERY PROCESS, SUCH
AS INITIATING CODE BUILDS,
RUNNING AUTOMATED TESTS, AND
DEPLOYING TO A STAGING OR
PRODUCTION ENVIRONMENT.
AUTOMATED PIPELINES REMOVE
WHAT IS TECHNOLOGIES USED:

GIT :IT MANAGES A PROJECT,OR A SET OF FILES,AS THEY CHANGE OVER TIME.GIT
STORES THIS INFORMATION CALLED GIT REPOSITORY.

JENKINS :JENKINS IS A OPEN SOURCE AUTOMATION TOOL WRITTEN IN JAVA WITH

PLUGINS BUILT FOR CONTINUOUS INTEGRATION PURPOSE.

AWS :IT IS A SECURED CLOUD SERVICES PLATFORM,OFFERING COMPUTE POWER,DATA BASE

STORAGE,CONTENT DELIVERY AND OTHER FUNCTIONALITY TO HELP BUSINESS SCALE AND GROW.

DOCKER :DOCKER IS A TOOL DESIGNED TO MAKE IT IS EASIER TO CREATE,DEPLOY

AND RUN APPLICATIONS BY USING CONTAINERS.

KUBERNETES :KUBERNETES IS A PORTABLE,EXTENSIBLE,OPEN SOURCE PLATFORM

FOR MANAGING CONTAINARIZED WORKLOADS AND SERVICES,THAT FACILITATES BOTH
DECLARATIVE CONFIGURATION AND AUTOMATION.
WHAT IS JENKINS:

JENKINS IS AN OPEN-
SOURCE CONTINUES
INTEGRATION SOFTWARE TOOL
WRITTEN IN THE JAVA PROGRAMMING
LANGUAGE FOR TESTING AND
REPORTING ON ISOLATED CHANGES IN
A LARGER CODE BASE IN REAL TIME.
THE SOFTWARE ENABLES
REQUIRED SOFTWARE & HARDWARE:

GIT
ECLIPSE
HTTPD/ TOMCAT
32-64 OPERATING SYSTEM
4-8 GB RAM
HIGH LEVEL ARCHITECTURE:
SOLUTION APPROACH:

STEP-1: CREATE DOCKER FILE FOR SAMPLE WEB APPLICATION AS

WAR FILE.
 BEFORE CREATING DOCKER FILE WE NEED TO INSTALL THE DOCKER.
#YUM INSTALL DOCKER –Y
 AFTER
THAT ENABLE AND START DOCKER BY USING THE FOLLOWING
COMMANDS.
#SYSTEMCTL ENABLE DOCKER
#SYSTEMCTL START DOCKER

 
DOWNLOAD WEB APPLICATION AS WAR FILE AND
THEN CREATE DOCKER FOR WEB APPLICATION.
#VI WEBAPP
>FROM CENTOS:7
>RUN YUM INSTALL HTTPD –Y
>ADD HTTPS://GITHUB.COM/VURA-LAKSMI-
ANUSHA/ANJI.GIT
/VAR/WWW/HTML
>EXPOSE 80
>CMD ["HTTPD","-DFOREGROUND"]
STEP2:CREATE DOCKER FILE FOR DB SERVER.
BEFORE YOU CREATE DOCKER FIRST YOU CHECK THE STATUS OF
DOCKER. IF IT IS RUNNING STATE OR NOT.
#SERVICE DOCKER STATUS
AFTER THAT CREATE DOCKER FILE FOR DB SERVER.
#VI WEBAPP
>FROM CENTOS:8
>RUN YUM INSTALL SQL –Y
>ADD
HTTPS://GITHUB.COM/VURALAKSMIANUSHA/CRUDEAPP2.GIT
/VAR/WWW/HTML
>EXPOSE 80
>CMD ["HTTPD","-DFOREGROUND"]
STEP-3: ENSURE APPROPRIATE DB
CONNECTIONS.

IF WE ANY DATA ON WEB APPLICATION IT WAS

STORED SQL
SEVER. IN THAT WE ENTER STUDENT DETAILS ARE
STUDENT ID,
FIRST NAME, LAST NAME , COURSE , YEAR THAT
WAS STORED
IN SQL SERVER.
STEP-4: CREATE THE ABOVE 2 DOCKER IMAGES.
BEFORE CREATE DOCKER IMAGES FIRST CHECK
STATUS OF
DOCKER. BY USING THE FOLLOWING COMMAND.
#SERVICE DOCKER STATUS
IF IT IS RUNNING THEN BUILD THE DOCKER IMAGES
FOR
WEB APPLICATION AND DB SERVER.
#DOCKER BUILD –F WEBAPP .
#DOCKER BUILD –F DBSERVER .
THE ABOVE COMMANDS CREATE TWO DOCKER IMAGES ARE
CENTOS:7 AND CENTOS:8.
STEP-5: CREATE DOCKER CONTAINERS IN
KUBERNETES ENVIRONMENT.
 FIRST SETUP KUBERNETES CLUSTER IN UBUNTU SERVER.
 DEPLOY NGX CONTAINER ON KUBERNETES.
AFTER DONE THE ABOVE TWO IT CREATE 1 MASTER SERVER
AND 2-WORKER NODES.
 AFTER THAT CREATE TWO FILE IN UBUNTU SERVER THAT
ARE
PROJECT.YML AND DEPLOYMENT.YML.
 AFTER SAVE THE FILES THE DEPLOY FILES INTO JENKINS
TOMCAT FILES.
FILE FOR PROJECT.YML
APIVERSION: EXTENSIONS/V1BETA1
KIND:DEPLOYMENT
METADATA:
NAME: CENTOS:7
NAMESPACE: JENKINS-DEMO
SPEC:
REPLICAS: 1
TEMPLATE:
METADATA:
LABELS:
APP: CENTOS:7
SPEC:
CONTAINERS:
-NAME: HELLOWHALE-1
-IMAGE: GITLAB.BSS.DEV.JIO.COM:5001/ROOT/SIT-PROJECT/CENTOS:7
IMAGEPULLPOLICY: IFNOTPRESENT
-PORTS:
-- CONTAINERPORT: 80
- IMAGEPULLSECRETS:
-- NAME: GITLEO-REGISTRY-SIT
FILE FOR DEPLOYMENT.YML
APIVERSION: EXTENSIONS/V1BETA1
KIND:DEPLOYMENT
METADATA:
NAME: CENTOS:7
NAMESPACE: JENKINS-DEMO
SPEC:
REPLICAS: 1
TEMPLATE:
METADATA:
LABELS:
APP: CENTOS:7
SPEC:
CONTAINERS:
-NAME: HELLOWHALE-1
-IMAGE: GITLAB.BSS.DEV.JIO.COM:5001/ROOT/SIT-PROJECT/CENTOS:7
IMAGEPULLPOLICY: IFNOTPRESENT
-PORTS:
-- CONTAINERPORT: 80
- IMAGEPULLSECRETS:
-- NAME: GITLEO-REGISTRY-SIT
STEP-6: CREATE THE CI/CD PIPELINE USING
KUBERNETES PLUGIN IN JENKINS.
FIRST INSTALL JAVA IT MUST BE 1.8 OR ABOVE VERSION
AND THEN INSTALL JENKINS.
#YUM INSTALL JAVA –Y
#SUDO WGET –O/ETC/YUM.REPOS.D/JENKINS.REPO
HTTPS://PKG.JENKINS.IO/REDHAT-STABLE/JENKINS.REPO
#SUDO RPM –IMPORT
HTTPS://PKG.JENKINS.IO/REDHAT-STABLE
#YUM INSTALL JENKINS –Y
START JENKINS AND CONFIGURE NEW PROJECT USING
JENKINS AND THEN SELECT PIPELINE PROJECT. THEN
WRITE SCRIPT IN STAGE WISE.
PIPELINE {
AGENT ANY
// TOOLS {
// MAVEN "MAVEN360“
// }
STAGES {
STAGE("GITCLONE") {
STEPS {
GIT BRANCH: 'MASTER',
CREDENTIALSID: ‘1234',
URL: 'HTTPS://GITHUB.COM/NARESHSREE/DOCKER-TOMCAT-
TUTORIAL.GIT'
}
}
 /STAGE("BUILD") {
// STEPS {
// SH 'MVN -F DEMO/POM.XML CLEAN INSTALL'
// }
//}
STAGE ("DEPLOY"){
STEPS {
//SH '/ROOT/NEW.SH'
SH 'DOCKER BUILD -T TOMCATDIP .'
SH 'DOCKER RUN -ITD -P 8085:8080 TOMCATDIP'
}
}
}
}

AFTER THAT BUILD THE PIPELINE

STEP-7: SETUP ECLIPSE IDE AND CREATE
PROJECT WITH SAMPLE WEB APPLICATION
SOURCE CODE.
FIRST CREATE PROJECT WITH JAVA BASED WEB
APPLICATION BY USING THE ECLIPSE IDE.
 THEN COMMIT THE PROJECT TO VCS(GIT) SYSTEM.BY

USING THE FOLLOWING COMMAND.

#GIT ADD .
#GIT COMMIT –M “AFTER CHANGE”
#GIT PUSH
STEP-8: ENSURE POSSIBLE SECURITY ASPECTS ARE
IMPLEMENTED ACROSS IN ALL AREAS.

FIRST LOGIN AWS ACCOUNT AND THEN

SELECT THE SERVER THEN GO TO SECURITY
GROUP. ADD RULE MYIP ADDRESS. IT MEANS
THE APPLICATION RUNS ONLY IN YOUR IP
ADDRESS.
STEP-9: IF CODE COMMIT IN VCS THEN CREATE
DOCKER IMAGE AND THEN ROLLED OUT INTO
CONTAINERS IN KUBERNETES ENVIRONMENT.
FIRST WE NEED TO INSTALL ANSIBLE PLAYBOOK
.
NEXT WE NEED TO WRITE ANSIBLE SCRIPT FOR
DOCKER IMAGES AND CLUSTERS.
THEN AUTOMATICALLY CREATE DOCKER
IMAGES AND THEN ROLLED INTO CLUSTERS.
THEN RUN THE IP ADDRESS OF THE SERVER IN
BROWSER.
ADVANTAGE OF DEVOPS:
CLOUD  BASED DEVOPS SIMPLIFIES COLLABORATION AND PLACES
ALL TOOLS IN THE CLOUD FOR CUSTOMERS ANYWHERE TO ACCESS.
DEVOPS INDICATES FAST TESTING AND DEVELOPMENT AS A
SERVICE. USING CLOUD SERVICES GENERALLY ALLOWS THE FREQUENC
Y OF LAUNCH. IT ALSO PROVIDES MORE COMPUTER ENERGY AND DATA 
STORAGE FOR DESIGNERS IF THEY WANT TO.
A MORE INFORMATION DRIVEN METHOD IS THE USE OF CLOUD 
SERVICES, IN WHICH ALL UTILIZES THE SAME DATA. THIS PROVIDES STR
ONGER DOCUMENTATION AND ENHANCED QUALITY CONTROL.
IMPORTANCE OF DEVOPS:

SHORTER DEVELOPMENT CYCLES, FASTER

INNOVATION
REDUCED DEPLOYMENT FAILURES,
ROLLBACKS, AND TIME TO RECOVER.
IMPROVED COMMUNICATION AND
COLLABORATION
REDUCED COSTS AND IT HEADCOUNT.
CONCLUSION:

THE INDUSTRY TODAY IS MOVING TOWARDS AUTOMATION. WE

WANT TO GET RID OF MANUAL WORK WHICH IS PRONE TO ERRORS,
INEFFICIENT AND EXPENSIVE. THIS IS EXACTLY WHAT DEVOPS
FOCUSES ON. WITH THE WIDE RANGE OF TOOLS PROVIDED,
EVERYTHING IS ORGANIZED AND AUTOMATED.
A SMALL TEAM OF SKILLED EMPLOYEES CAN TAKE THE
RESPONSIBILITY WHICH PREVIOUSLY REQUIRED TEAMS OF EVEN 100
PEOPLE! DEVOPS ALSO BRINGS TOGETHER THE DEVELOPMENT AND
OPERATIONS TEAM UNDER ONE UMBRELLA. THIS MEANS, THEY NOW
SHARE IDEAS AND UNDERSTAND EACH OTHER'S RESPONSIBILITIES
BETTER. ALL THIS GIVES BETTER OUTPUT AT A QUICKER PACE WITH
LESSER ITERATIONS.