===========================
Application Architecture
===========================
1) Frontend : User Interface (UI)
2) Backend : Business logic
3) Database : Storage
=============================
Tech Stack of Application
=============================
Frontend : Angular 16
Backend : Java 17
Database : MySQL Server 8.5
Webserver : Tomcat 9.0
Note: If we want to run our application code, then we need to setup all required
dependencies in the machine.
Note: dependencies nothing but the softwares which are required to run our
application
Ex: java + Angular + MySQL + Tomcat server
==========================
Application Environments
==========================
=> In realtime we will use several environments to test our application.
1) DEV
2) SIT
3) UAT
4) PILOT
5) PROD (final delivery)
=> Dev env used by developers for code integration testing
=> SIT env used by Testers for system integration testing
=> UAT env used by client side team for acceptance testing (Go or No Go)
=> Pilot env used for pre-production testing
=> Prod env used for live deployment (end users can access our app)
=> As a devops enginner we are responsible to setup infrastructure to run our
application
=> We need to install all required softwares (dependencies) to run our application
Note: We need to setup dependencies in all environments to run our application.
Note: There is a chance of doing mistakes in dependencies installation process
(version compatability issues can occur)
=> To simplify application execution in any machine we can use Docker.
==================
What is Docker ?
==================
=> Docker is a free & open source software
=> Docker is used for containerization
=> With the help of docker, we can run our application in any machine.
Container = package (app code + app dependencies)
=> Docker will take care of dependencies installation required for app execution.
=> We can make our application portable using Docker.
=====================
Docker Architecture
=====================
1) Dockerfile
2) Docker Image
3) Docker Registry
4) Docker Container
=> Dockerfile is used to specify where is app code and what dependencies are
required for our application execution.
Note: Dockerfile is required to build docker image.
=> Docker Image is a package which contains code + dependencies
=> Docker Registry is used to store Docker Images.
Note: When we run docker image then Docker container will be created. Docker
container is a linux virtual machine.
=> Docker Container is used to run our application.
=============================
Install Docker in Linux VM
=============================
Step-1 : Create EC2 VM (amazon linux) & connect with that vm using ssh client
Step-2 : Execute below commands
# Install Docker
sudo yum update -y
sudo yum install docker -y
sudo service docker start
# Add ec2-user user to docker group
sudo usermod -aG docker ec2-user
# Exit from terminal and Connect again
exit
# Verify Docker installation
docker -v
==================
Docker commands
==================
docker images : To display docker images available in our system
docker ps : To display running docker containers
docker logs <container-id> : To display container logs
docker ps -a : To display running + stopped containers
docker pull <image-id/name> : To download docker image from docker hub
docker rmi <image-id/name> : To delete docker image
docker run <image-id/name> : To create/run docker container
docker stop <container-id> : To stop running docker container
docker start <container-id> : To start docker container which is in stopped state
docker rm <container-id> : To delete docker container
# delete stopped containers + unused images + build cache
docker system prune -a
=======================================================
Running Real-world applications using docker images
=======================================================
docker pull ashokit/spring-boot-rest-api
docker run -d ashokit/spring-boot-rest-api
docker run -d -p 9090:9090 ashokit/spring-boot-rest-api
URL : http://public-ip:host-port/welcome/{name}
docker pull ashokit/python-flask-app
docker run -d ashokit/python-flask-app
docker run -d -p 5000:5000 ashokit/python-flask-app
Note: Here -d represents detached mode.
Note: Here -p represents port mapping. (host-port:container-port)
Note: host port and container port no need to be same.
Note: In one machine we can use 65k port numbers.
Note: To access application running in the container we will use below URL
URL : http://host-vm-public-ip:host-port/
Note: Host port number we need to enable in ec2-vm security group inbound rules to
allow the traffic.
=============
Dockerfile
=============
=> Dockerfile contains set of instructions to build docker image
Filename : Dockerfile
=> To write dockerfile we will use below keywords
1) FROM
2) MAINTAINER
3) RUN
4) CMD
5) COPY
6) ADD
7) WORKDIR
8) EXPOSE
9) ENTRYPOINT
10) USER
====
FROM
=====
=> It is used to specify base image for our application
Ex:
FROM openjdk:17
FROM python:3.3
FROM node:19.5
FROM mysql:8.5
FROM tomcat:9.0
============
MAINTAINER
============
=> MAINTAINER is used to specify who is author of this Dockerfile
Ex :
MAINTAINER Ashok<ashok.b@oracle.com>
=====
RUN
=====
=> RUN keyword is used to specify instructions to execute at the time of docker
image creation.
Ex:
RUN 'git clone <url>'
RUN 'mvn clean package'
Note: We can write multiple RUN instructions in single docker file and all those
instructions will be processed in the order.
=====
CMD
=====
=> CMD keyword is used to specify instructions to execute at the time of docker
container creation.
Ex:
CMD 'java -jar app.jar'
CMD 'app.py'
Note: We can write multiple CMD instructions in single docker file but docker will
process only last CMD instruction.
===========
ENTRYPOINT
===========
=> Entrypoint is used to execute instructions when docker container is creating.
Ex:
ENTRYPOINT["java", "-jar", "app.jar"]
ENTRYPOINT["python", "app.py"]
Note: CMD instruction we can override using command line arguments where ENTRYPOINT
instruction we can't override.
========
COPY
=========
=> It is used to copy files from host machine to container machine
Ex:
COPY target/app.jar /usr/app/app.jar
COPY target/app.war /usr/app/tomcat/webapps/app.war
COPY app.py /usr/app/app.py
=============
ADD Keyword
=============
=> It is also used to copy files from source to destination.
Ex:
ADD target/app.jar /usr/app/app.jar
ADD <http-url> /usr/app/app.jar
==========
WORKDIR
==========
=> It is used to set working directory (directory navigation)
COPY target/app.jar /usr/app/app.jar
WORKDIR /usr/app
CMD 'java -jar app.jar'
======
USER
======
=> It is used to set USER to run commands
========
EXPOSE
========
=> It is used to specify on which port number our application will run in container
Ex:
EXPOSE 8080
Note: It is only to provide inforation. We can't change container port using
EXPOSE.
==================
Sample Dockerfile
==================
FROM ubuntu
MAINTAINER Ashok <ashok.b@oracle.com>
RUN echo 'hello from run instruction-1'
RUN echo 'hello from run instruction-2'
CMD echo 'hi from cmd-1'
CMD echo 'hi from cmd-2'
-----------------------
# create docker image using dockerfile
$ docker build -t img-1 .
# Run docker image to create docker container
$ docker run img-1
==================================================
how to push docker image into docker hub account
==================================================
# login into docker hub account
$ docker login
# tag docker image
$ docker tag <image-name> <tag-name>
Ex : docker tag img-1 ashokit/img-1
$ push docker image to docker hub
$ docker push <tag-name>
===========================
Dockerizing java web app
===========================
=> Java web app will be packaged as war file
Note: war file will be created inside target directory
=> To deploy war file we need web server (Ex: tomcat)
=> Inside tomcat server webapps directory we need to place our war file to run the
application.
######### Dockerfile to run java web app ############
FROM tomcat:latest
MAINTAINER Ashok
EXPOSE 8080
COPY target/app.war /usr/local/tomcat/webapps/
========================================================
@@ Java Web App Git Repo : https://github.com/ashokitschool/maven-web-app.git
$ sudo yum install git
$ sudo yum install maven
$ git clone https://github.com/ashokitschool/maven-web-app.git
$ cd maven-web-app
$ mvn clean package
$ ls -l target
$ docker build -t <img-name> .
$ docker images
$ docker run -d -p <host-port:container-port> <img-name>
=> Enable host port number in security group inbound rules and access our
application
URL : http://public-ip:host-port/war-file-name/
===================================================================
=========================================
Dockerizing Java Spring Boot Application
=========================================
=> Every SpringBoot application will be packaged as jar file only
=> To run spring boot application we need to execute jar file.
Syntax : java -jar <jar-file-name>
Note: When we run springboot application jar file then springboot will start tomcat
server with 8080 port number (embedded tomcat server).
=============== Dockerfile for Spring Boot Application =============
FROM openjdk:17
MAINTAINER Ashok
COPY target/app.jar /usr/app/
WORKDIR /usr/app/
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]
====================================================================
## Java Spring Boot App Git Repo : https://github.com/ashokitschool/spring-boot-
docker-app.git
$ git clone https://github.com/ashokitschool/spring-boot-docker-app.git
$ cd spring-boot-docker-app
$ mvn clean package
$ ls -l target
$ docker build -t sb-app .
$ docker run -d -p 8080:8080 sb-app
Note: Once container created check logs of container
$ docker logs <container-id>
Note: Access our application using host-vm public and host port
URL : http://localhost:host-port/
=====================================
Dockerize Python Flask Application
=====================================
=> Python is a scripting language
=> We don't need any build tool for python app
=> Directley we can run python programs
Ex : python app.py
=> Flask is a python library which is to develop rest apis in python.
=> To download flask library we will use 'python pip software'
Note: We will configure dependencies in "requirements.txt"
=============== Dockerfile for Python Flask App =================
FROM python:3.6
MAINTAINER Ashok
COPY . /usr/app/
WORKDIR /usr/app/
RUN pip install -r requirements.txt
EXPOSE 5000
ENTRYPOINT ["python", "app.py"]
===================================================================
Python App Git Repo : https://github.com/ashokitschool/python-flask-docker-app.git
$ git clone https://github.com/ashokitschool/python-flask-docker-app.git
$ cd python-flask-docker-app
$ docker build -t <img-name> .
$ docker run -d -p 5000:5000 <img-name>
$ docker ps
Note: Enable 5000 port in security group inbound rules.
=> Access application with URL
URL : http://public-ip:host-port/
============================================
Can we get into docker container machine ?
============================================
Yes, using below commands
# display running docker containers info
$ docker ps
# get into container using container id
$ docker exec -it <container-id> /bin/bash
# check files in pwd
$ ls -l
# come out from container vm to host vm
$ exit
===================================================
Task-1: Run jenkins server using docker
Task-2: setup mysql db using docker
Task-3: Write docker file to execute reactjs app
====================================================
================
Docker Network
================
=> Network is all about communication
=> Docker network is used to provide isolated network for containers
=> If we run 2 containers under same network then one contianer can communicate
with another container.
=> By default we have 3 networks in Docker
1) bridge
2) host
3) none
=> Bridge network is used to run standalone containers. It will assign one IP for
container. It is the default network for docker container.
=> Host network is also used to run standalone containers. This will not assign any
ip for our container.
=> None means no network will be available.
=> We can use 2 other networks also in docker
1) Overlay
2) MacvLan
=> Overlay network is used for Orchestration purpose (Docker Swarm)
=> Macvlan network will assign physical Ip for our container.
# display docker networks
$ docker network ls
# create docker network
$ docker network create ashokit-nw
# inspect docker network
$ docker network inspect ashokit-nw
# create docker container with custom network
$ docker run -d -p 8080:8080 --network ashokit-nw sb-app-image
# delete docker network
$ docker network rm ashokit-nw
===============
Docker Compose
===============
=> Earlier ppl developed projects using Monolithic Architecture (everthing in
single app)
=> Now a days projects are developing based on Microservices architecture.
=> Microservices means multiple backend apis will be avialable
Ex:
hotels-api
flights-api
trains-api
cabs-api...
=> For every API we need to create seperate container.
Note: When we have multiple containers like this management will become very
difficult (create / stop / start)
=> To overcome these problems we will use Docker Compose.
=> Docker Compose is used to manage Multi - Container Based applications.
=> In docker compose, using single command we can create / stop / start multiple
containers at a time.
===================================
What is docker-compose.yml file ?
===================================
=> docker-compose.yml file is used to specify containers information.
=> The default file name is docker-compose.yml (we can change it).
=> docker-compose.yml file contains below 4 sections
version : It represents compose yml version
services: It represents containers information (image-name, port-mapping etc..)
networks: Represents docker network to run our containers
volumes: Represents containers storage location
======================
Docker Compose Setup
======================
# install docker compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.24.0/docker-
compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
# Check docker compose is installed or not
$ docker-compose --version
================================================
Spring Boot with MySQL DB using Docker-Compose
================================================
version: "3"
services:
application:
image: spring-boot-mysql-app
ports:
- "8080:8080"
networks:
- springboot-db-net
depends_on:
- mysqldb
volumes:
- /data/springboot-app
mysqldb:
image: mysql:5.7
networks:
- springboot-db-net
environment:
- MYSQL_ROOT_PASSWORD=root
- MYSQL_DATABASE=sbms
volumes:
- /data/mysql
networks:
springboot-db-net:
================================
Application Execution Process
================================
# clone git repo
$ git clone https://github.com/ashokitschool/spring-boot-mysql-docker-compose.git
# go inside project directory
$ cd spring-boot-mysql-docker-compose
# build project using maven
$ mvn clean package
# build docker image
$ docker build -t spring-boot-mysql-app .
# check docker images
$ docker images
# create docker containers using docker-compose
$ docker-compose up -d
# check docker containers running
$ docker-compose ps
# stop docker containers running
$ docker-compose stop
# start docker containers running
$ docker-compose start
# delete docker containers using docker-compose
$ docker-compose down
====================================
Stateful Vs Stateless Containers
====================================
Stateless Container : Data will be deleted after container deletion.
Statefull Container : Data will be available permanently
Note: Docker containers are stateless by default.
Note: In spring-boot-mysql app, we are using mysqldb as docker container to store
application data. When we re-create containers db also got recreated hence we lost
data (this is not accepted in realtime).
=> To maintain data permanently, we need to make docker container as statefull.
=> To make container as statefull, we need to use Docker volumes concept.
================
Docker Volumes
================
=> Volumes are used to persist data which is generated by docker container.
=> Volumes are used to avoid data loss
=> Using volumes we can make container as statefull
=> We have 3 types of volumes in docker
1) Anonymous volume (no name)
2) Named Volume
3) Bind mounts
# display docker volumes
$ docker volume ls
# docker volume create
$ docker volume create <vol-name>
# inspect docker volume
$ docker volume inspect <vol-name>
# Remove docker volume
$ docker volume rm <vol-name>
# Remove all docker volumes
$ docker system prune --volumes
=================================
Making docker container stateful
=================================
=> Create mount directory on host machine (path : /home/ec2-user/)
$ mkdir app
=> Map this 'app' directory in docker-compose.yml like below
======================docker-compose.yml===============
version: "3"
services:
application:
image: spring-boot-mysql-app
ports:
- "8080:8080"
networks:
- springboot-db-net
depends_on:
- mysqldb
volumes:
- /data/springboot-app
mysqldb:
image: mysql:5.7
networks:
- springboot-db-net
environment:
- MYSQL_ROOT_PASSWORD=root
- MYSQL_DATABASE=sbms
volumes:
- .app:/var/lib/mysql
networks:
springboot-db-net:
=========================================================
=============
Docker Swarm
=============
=> It is an Orchestration platform
=> Orchestration means Managing the process (containers)
=> Docker swarm is used to setup docker cluster
=> Cluster means group of servers
============================
Docker Swarm Cluster Setup
============================
-> Create 3 EC2 instances (ubuntu) & install docker in all 3 instances using below
2 commands
$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh
Note: Enable 2377 port in security group for Swarm Cluster Communications
1 - Master Node
2 - Worker Nodes
-> Connect to Master Machine and execute below command
# Initialize docker swarm cluster
$ sudo docker swarm init --advertise-addr <private-ip-of-master-node>
Ex : $ sudo docker swarm init --advertise-addr 172.31.41.217
# Get Join token from master (this token is used by workers to join with master)
$ sudo docker swarm join-token worker
Note: Copy the token and execute in all worker nodes with sudo permission
Ex: sudo docker swarm join --token SWMTKN-1-
4pkn4fiwm09haue0v633s6snitq693p1h7d1774c8y0hfl9yz9-8l7vptikm0x29shtkhn0ki8wz
172.31.37.100:2377
-> In Docker swarm we need to deploy our application as a service.
====================
Docker Swarm Service
====================
-> Service is collection of one or more containers of same image
-> There are 2 types of services in docker swarm
1) Replica (default mode)
2) global
$ sudo docker service create --name <serviceName> -p <hostPort>:<containerPort>
<imageName>
Ex : $ sudo docker service create --name java-web-app -p 8080:8080
ashokit/javawebapp
Note: By default 1 replica will be created
Note: We can access our application using below URL pattern
URL : http://master-node-public-ip:8080/java-web-app/
# check the services created
$ sudo docker service ls
# we can scale docker service
$ docker service scale <serviceName>=<no.of.replicas>
# inspect docker service
$ sudo docker service inspect --pretty <service-name>
# see service details
$ sudo docker service ps <service-name>
# Remove one node from swarm cluster
$ sudo docker swarm leave
# remove docker service
$ sudo docker service rm <service-name>
================
Docker Summary
================
1) What is application architecture
2) Application Tech stack
3) Application Environements
4) Challenges in app deployment process
5) Containerization
6) Docker Introduction
7) Docker Architecture
8) Dockerfile Keywords
9) Docker Images
10) Docker Containers
11) Port Mapping & Detached Mode
12) Dockerizing Java Web App (war file)
13) Dockerizing Java Spring Boot App (jar file)
14) Dockerization Python App (.py file)
15) Docker Network
16) Docker Compose
17) Docker Swarm
