Academy PRO: Docker. Lecture 3

Orchestration Basics
AcademyPRO

Today’s
agenda
Docker Networking Basics
Compose
Scaling out with Swarm Mode

Default Networks
When you install Docker, it creates three networks automatically. You can list
these networks using the docker network ls command:
docker network ls
NETWORK ID NAME DRIVER
7fca4eb8c647 bridge bridge
9f904ee27bf5 none null
cf03ee007fb4 host host
These three networks are built into Docker. When you run a container, you can
use the --network flag to specify which networks your container should
connect to.

Create network
A bridge - default networking mode which will enable the connectivity to the
other interfaces of the host machine as well as among containers.
A none will not configure any IP for the container and doesn’t have any access
to the external network as well as for other containers
A host container will share the host’s network stack and all interfaces from the
host will be available to the container
docker network create isolated_nw
docker network inspect isolated_nw

Create network
After you create the network, you can launch containers on it using the docker
run --network=<NETWORK> option.
$ docker run --network=isolated_nw -itd --name=container1
busybox
$ docker network inspect isolated_nw

Network
The containers you launch into this network must reside on the same Docker
host. Each container in the network can immediately communicate with other
containers in the network. Though, the network itself isolates the containers
from external networks.

Published ports
Within a user-defined network, linking is not supported. You can expose and
publish container ports on containers in this network. This is useful if you want
to make a portion of the network available to an outside network.

Let’s try!
docker run -d --net isolated_nw -p 27017:27017 --name
mongo_container mongo
docker run -d --net isolated_nw -p 3000:3000 --name
node_container oleksandrkovalov/node_example_2

Docker Compose
Compose is a tool for defining and running multi-container Docker applications.
With Compose, you use a Compose file to configure your application’s services.
Then, using a single command, you create and start all the services from your
configuration.

Compose usage
Using Compose is basically a three-step process.
Define your app’s environment with a Dockerfile so it can be reproduced
anywhere.
Define the services that make up your app in docker-compose.yml so
they can be run together in an isolated environment.
Lastly, run docker-compose up and Compose will start and run your entire
app.

Compose status
docker-compose ps
Name Command State Ports
------------------------------------------------------------------------------------------
nodeapp_mongo_container_1 docker-entrypoint.sh mongod Up 0.0.0.0:27017->27017/tcp
nodeapp_node_container_1 npm start Up 0.0.0.0:3000->3000/tcp
docker-compose down

docker-compose.yml
version: '3'
services:
node_container:
networks:
- isolated_nw
image: "oleksandrkovalov/node_example_2"
links:
- mongo_container
ports:
- "3000:3000"
mongo_container:
networks:
- isolated_nw
image: "mongo"
ports:
- "27017:27017"
networks:
isolated_nw:

docker-compose.yml
build
Configuration options that are applied at build time.
build can be specified either as a string containing a path to the build context,
or an object with the path specified under context and optionally dockerfile and
args.
build: ./dir

docker-compose.yml
build
build:
dockerfile: Dockerfile-alternate
If you specify image as well as build, then Compose names the built image with
the webapp and optional tag specified in image:
build: ./dir
image: webapp:tag

docker-compose.yml
build: CONTEXT
Either a path to a directory containing a Dockerfile, or a url to a git repository.
When the value supplied is a relative path, it is interpreted as relative to the
location of the Compose file. This directory is also the build context that is sent
to the Docker daemon.
Compose will build and tag it with a generated name, and use that image
thereafter.
build:
context: ./dir

docker-compose.yml
build: DOCKERFILE
Compose will use an alternate file to build with. A build path must also be
specified.
build:
context: .
dockerfile: Dockerfile-alternate

docker-compose.yml
build: ARGS
Add build arguments, which are environment variables accessible only during
the build process.
First, specify the arguments in your Dockerfile:
ARG buildno
ARG password
RUN echo "Build number: $buildno"
RUN script-requiring-password.sh "$password"

docker-compose.yml
build: ARGS
Then specify the arguments under the build key. You can pass either a mapping
or a list:
build:
context: .
args:
- buildno=1
- password=secret

docker-compose.yml
build: command
Override the default command.
command: bundle exec thin -p 3000
The command can also be a list, in a manner similar to dockerfile:
command: [bundle, exec, thin, -p, 3000]

Disconnecting containers
You can disconnect a container from a network at any time using the docker
network disconnect command.
Disconnect container1 from the isolated_nw network, then inspect container1
and the isolated_nw network.
docker network disconnect isolated_nw container1

Remove a network
When all the containers in a network are stopped or disconnected, you can
remove a network. If a network has connected endpoints, an error occurs.
docker network rm isolated_nw
docker network ls

Docker Swarm
Docker Swarm is the Docker-native solution for deploying a cluster of Docker
hosts. You can use it to quickly deploy a cluster of Docker hosts running either
on your local machine or on supported cloud platforms.

How Swarm nodes works
Docker Engine 1.12 introduces swarm
mode that enables you to create a
cluster of one or more Docker Engines
called a swarm. A swarm consists of
one or more nodes: physical or virtual
machines running Docker Engine 1.12
or later in swarm mode.
There are two types of nodes:
managers and workers.

How services work
To deploy an application image when
Docker Engine is in swarm mode, you
create a service. Frequently a service will
be the image for a microservice within the
context of some larger application.
Examples of services might include an
HTTP server, a database, or any other type
of executable program that you wish to
run in a distributed environment.

Create a swarm
docker swarm init
docker info
......
Swarm: active
NodeID: dxn1zf6l61qsb1josjja83ngz
Is Manager: true
Managers: 1
Nodes: 1
......

Inspect nodes
docker node ls
ID HOSTNAME STATUS AVAILABILITY MANAGER STATUS
phfku7dign7xvzppcb0i9fzqj * moby Ready Active Leader

Add nodes to the swarm
docker swarm join-token -q manager
docker swarm join
--token SWMTKN-1-49nj1cmql0jkz5s954yi3oex3nedyz0fb0xx14ie39trti4wxv-8vxv8rssmk743ojnwacrr2e7c
192.168.99.100:2377

Deploy a service to the swarm
docker service create --name helloworld --replicas 3 -p 80:80 --network isolated_nw tutum/hello-world
docker service create --name bash --network isolated_nw ubuntu
docker service ls
h3uvf93xt72b bash replicated 1/1 ubuntu:latest
tee36wrfs1z8 helloworld replicated 3/3 tutum/hello-world:latest
docker exec -it 133e43b35f30 bash
apt-get update
apt-get install curl
curl http://helloworld

Inspect a service on the swarm
docker service ls
docker service inspect --pretty tee36wrfs1z8
docker service ps tee36wrfs1z8

Scale the service in the swarm
docker service scale <SERVICE-ID>=<NUMBER-OF-TASKS>
docker service scale tee36wrfs1z8=4
tee36wrfs1z8rh63c7lkxrfzw scaled to 4

Docker-compose.yml
features for swarm
deploy
version: '3'
services:
redis:
image: redis:alpine
deploy:
replicas: 6
update_config:
parallelism: 2
delay: 10s
restart_policy:
condition: on-failure

Docker-compose.yml
features for swarm: UPDATE_CONFIG
Configures how the service should be updated. Useful for configuring rolling
updates.
parallelism: The number of containers to update at a time.
delay: The time to wait between updating a group of containers.
failure_action: What to do if an update fails. One of continue or pause (default:
pause).
monitor: Duration after each task update to monitor for failure
(ns|us|ms|s|m|h) (default 0s).

Docker-compose.yml
features for swarm: UPDATE_CONFIG
version: '3'
services:
vote:
image: dockersamples/examplevotingapp_vote:before
depends_on:
- redis
deploy:
replicas: 2
update_config:
parallelism: 2
delay: 10s

Docker-compose.yml
features for swarm: RESOURCES
Configures resource constraints.
version: '3'
services:
redis:
image: redis:alpine
deploy:
resources:
limits:
cpus: '0.001'
memory: 50M
reservations:
cpus: '0.0001'
memory: 20M

Docker-compose.yml
features for swarm: RESTART_POLICY
Configures if and how to restart containers when they exit. Replaces restart.
condition: One of none, on-failure or any (default: any).
delay: How long to wait between restart attempts, specified as a duration
(default: 0).
max_attempts: How many times to attempt to restart a container before
giving up (default: never give up).
window: How long to wait before deciding if a restart has succeeded, specified
as a duration (default: decide immediately).

Docker-compose.yml
features for swarm: RESTART_POLICY
version: "3"
services:
redis:
image: redis:alpine
deploy:
restart_policy:
condition: on-failure
delay: 5s
max_attempts: 3
window: 120s

Academy PRO: Docker. Lecture 3

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Academy PRO: Docker. Lecture 3 (20)

More from Binary Studio (20)

Recently uploaded (20)

Academy PRO: Docker. Lecture 3