How to _docker

Development and
delivery environment
using Docker

Presentation Agenda
Introduction to docker -
what, why etc.
Installation and Configuration
- DEV environment
Modifying Cellostics in DEV
and modifying Docker Image
Why we use Docker -
Benefits
How Docker Works
Installing and Running
Cellostics on Docker - DEV
environment
Deploying Cellostics Docker
Image (created from DEV) to
Production
Building Microservices in
Docker Image
Redeploying Docker Image in
prod with modification

Introduction to Docker - what?
What is Docker
● Open platform for developers and
sysadmins to build, ship, and run distributed
applications
● It is a lightweight container platform and it
is fast
● Available on most linux distros
● Also runs on windows and mac os
● Can run thousands of containers

Introduction to docker why, what?
Traditional VM vs. Docker
Hardware
Host OS
Hypervisor
RHEL
Bins/Libs
uniVerge
CentOS OS
Bins/Libs
Celloscope Cellostics
Bins/Libs
Guest OS
Docker Engine
Linux Kernel/Host OS
Hardware
Bins/Libs Bins/Libs Bins/Libs
uniVerge CellosticsCelloscope
VM Docker

The issue with traditional VM’s
Many different stacks
❏ Languages (Java, C#, Python, R)
❏ Frameworks (Angular, River, Spring)
❏ Databases (Postgres, Oracle, NoSQL) Many different targets
❏ Individual development environments
❏ Pre-production, QA, staging ….
❏ Production: on premises, cloud, hybrid
Deployment becomes very complex

Why Docker, its benefits
A Clean, Safe and portable runtime environment for Your App
No worries about missing dependencies, package and other pain points during
subsequent developments.
Run each app in its own isolated container, accumulated with various versions and
libraries and other dependencies for each app
Automate testing, integration, packaging, anything
you can script.
Reduce/Eliminate concerns about compatibility on
different platforms
Cheap, zero-penalty containers to deploy services.
A VM without the overhead of VM. Instant
replay and reset of image snapshot. That's the
It’s Fast and lightweight
Minimal overhead/resource
usage
Run thousands of containers
Easy to run your whole
production stack locally

Introduction to docker why, what, etc ?
VM

How docker works
Docker Client
Image 1Container 1
Container 2 Image 2
Image 3Container 3
Host Docker Registry
● Isolated Application
Platform
● Contains everything needed
to run your application
● Based on images
● Read Only Template used
to create containers
● Built by you or other
Docker users
● Stored in the Docker Hub
or your local Registry
Container Image

Installation and configuration
Images
Container
1-Pull
2-
run
3 - Stop, Start,
restart
4-Commit
5 - Push
build
Local Docker instance

1.Installing docker
> sudo apt-get install docker-engine # For Debian and Ubuntu
> sudo yum install docker-engine # For RHEL, CentOS,
Fedora
2. Starting docker service
> sudo systemctl start docker
3.Verify docker is installed correctly by running
> sudo docker run --rm hello-world
4. Installing Docker Image
> docker pull image_name
> docker images # Will show existing images
> docker ps -l # Will show all running container

5. Showing Docker network
> docker network inspect network_name
6. Kill all running container
> docker kill $(docker ps -q)
7. Deleting unused docker container
> sudo docker rm ‘docker ps --no-trunc -aq’
8. Delete all stopped containers (including data-only containers)
> docker rm $(docker ps -a -q)
9. Delete all 'untagged/dangling' (<none>) images
> docker rmi $(docker images -q -f dangling=true)
> docker volume is -f dangling=true

10. For connecting docker postgres console
> docker exec -ti testcellostics_db_1 psql -h db -U postgres
> docker run -it --rm --link db_ap:postgres postgres psql -h postgres -U postgres
> docker run --name auth_data -e POSTGRES_PASSWORD=mysecret -d postgres
> docker run -it --rm --link db_ap:postgres postgres psql -h postgres -U postgres
11. Giving an image a new name
> sudo docker tag <oldname> <newname>

Installing and running Cellostics on Docker dev environment
FROM python:3.5
ENV PYTHONUNBUFFERED 1
RUN mkdir /app
WORKDIR /app
ADD requirements.txt /app/
RUN pip install -r requirements.txt
ADD . /app/
Dockerfile

Installing and running on Docker dev environment
version: “2”
service
nginx:
image: "nginx:latest"
ports:
- "8080:8000"
volumes:
- "./src:/src"
- "./config/nginx:/etc/nginx/conf.d"
cellostics-server:
build: .
hostname: cellostics-server
command: bash -c "gunicorn project.wsgi:application -b 0.0.0.0:8000"
volumes:
- .:/app
ports:
- "8000:8000"
depends_on:
- db
docker-compose.yml

Installing and running on Docker dev environment
db:
image: postgres:9.5
hostname: db
environment:
- POSTGRES_USER=postgres
- POSTGRES_PASSWORD=postgres
- POSTGRES_DB=postgres
Docker-compose.yml (contd.)

Deploying Cellostics Docker image(created from Dev) to prod
1. Push the images to the docker hub
> docker push username/imagename:tag
2. Pull the image from docker hub or other sources
> docker login username
> docker pull image_name:tag
> docker images
> docker run image_name:tag
3. Run from configuration file (the directory where docker compose file located)
> docker-compose up

Modifying and redeploying image in production environment
1. Run the docker image which will run as a container
> docker run -it image_name command_to_execute
2. Modified container will save as image
> docker commit container_name image_name
3. Redeploying modified Image and run as a container
> docker run image_id

Building Microservice Application
Traditional Style Monolithic Architecture
UI
Backend
Other Service
User Reverse Proxy Application Server
RDBMS

Microservice Application using docker
Microservice Architecture
Container
Web Front end
DB
Container
Map Service
Container
Log Server
Container
Message client

Microservice Application using docker
● Each Service can be developed and upgraded independently
● Easier to developer for understand
● If one service goes down, then the application should still run,
although with the reduced functions
● Application is easier to troubleshoot and maintain
● The whole application doesn’t have to be committed to one
technology dependent stack

Implementation
❏ Create a Docker File
❏ Create a Docker Compose File
❏ Build Docker file
❏ Docker Compose File Up
❏ Restore data for Postgres docker container
❏ Create image for Nginx
❏ Docker Login
❏ Docker Push

Sources and references
http://slidedeck.io/lodelestra-edu/docker-slides
http://www.slideshare.net/dotCloud/why-docker
https://denibertovic.com/talks/supercharge-development-env-using-docker/#/12
https://docs.docker.com/engine/tutorials/dockerizing/
http://view.dckr.info:9090/#24
https://github.com/smancke/docker-intro

docker run -d -p 9000:9000 --privileged -v /var/run/docker.sock:/var/run/docker.sock uifd/ui-for-docker

How to _docker

Recommended

More Related Content

What's hot (20)

Similar to How to _docker (20)

Recently uploaded (20)

How to _docker

Editor's Notes