print ('Name: ', Juan['name'])
print ('Email: ', Juan['email'])
print ('Work: ', Juan['work'])
Slides: https://comnets.bitbucket.io/wcnc-tutorial/hands-on/
Press esc for a menu of the slides
Slides inspired and adapted from:
Docker by Example, by:
Ganesh & Hari {ganesh|hari}(at)codeops.tech
Docker version¶
%%bash
docker -v
Docker info¶
%%bash
docker info
%%bash
docker run docker/whalesay cowsay Hello World
%%bash
docker run hello-world
Getting help¶
%%bash
docker -h
What images do you have?¶
%%bash
docker images
How to search for an image?¶
%%bash
docker search ubuntu
Let us get a new image - Ubuntu¶
%%bash
docker pull ubuntu
Let us get a new image - Alpine¶
%%bash
docker pull alpine
Where are these images located?¶
from IPython.core.display import HTML
HTML('<a href="https://hub.docker.com/">Docker Hub</a>')
Prefer Smaller Images¶
Alpine linux might be enough compared to Ubuntu image
%%bash
docker images
Getting details of an image¶
%%bash
docker inspect alpine
Inspect the "inside" of an image¶
%%bash
docker history ubuntu
Deleting an image¶
docker rmi <image-tag>
Docker containers¶
We create a container using docker run
specifically:
docker run OPTIONS <<image-tag>> CMD ARGS
Let us ping a server¶
docker run alpine ping "8.8.8.8"
How do we run a container interactively?¶
docker run -t -i ubuntu /bin/bash
-t Attach a pseudo-tty console
-i Stands for Interactive
Running a container in the background¶
docker run -d ubuntu /bin/sh -c "while true; do $(echo date); sleep 2 ; done"-d stands for detach
How do we see the logs of a container?¶
docker logs <Container-Tag>
We can do it with one command, without pre-installs
from IPython.display import IFrame
IFrame('https://en.wikipedia.org/wiki/Comparison_of_web_server_software#Overview', width=700, height=350)
Is it in docker hub?¶
%%bash
docker search nginx
Of course it is!¶
Let us run it!¶
docker run -d -p 80:80 nginx
-d stands for detach
-p stands for port. We basically say: "Redirect every incomming TCP packet at port 80 of the host, to the port 80 of the container"
from IPython.display import IFrame
IFrame('http://localhost:80', width=700, height=350)
How do we forward the traffic from the host to the container?¶
When we use the flag -p we "publish a port, or range of ports to the host".
Format: hostPort:containerPort
For UDP ports: hostPort:containerPort/udp
Let us map a different port in the host¶
Let us stop the server¶
First we need to find the container
docker ps
Then, we stop it
docker stop CONTAINER_ID
Let us also delete it
docker rm CONTAINER_ID
Check that the container is not there anymore. Go to localhost:80 in your browser. You should see an error
Note: Use incognito mode. Otherwise, the browser will display the cached site.
Let us make the new server¶
docker run -d -p 45700:80 nginx
Now, if go in your browser to localhost:4570
Docker Container State Transition¶
Editing Nginx¶
index.html¶
Lets crreate the html file that we will serve from our containerized http server
index.html
=================================
<h1> Welcome to PBL </h1>
<h2> Have Fun! </h2>
Editing Nginx¶
Dockerfile¶
Dockerfiles are like a recipe. It is a set of instructions used to create a custom image
Dockerfile
=================================
# Base image
FROM nginx:latest
# The maintainer
MAINTAINER Juan
# The actual recipe
# ADD Will add the created file in the step above
ADD ./index.html /usr/share/nginx/html/index.html
EXPOSE 80
docker build -t my_server .
docker run -p 80:80 -d my_server
Docker Volumes¶
They can be used to make data persistent
# Make a folder to store the data
mkdir ~/testing_data
# Run a container
docker run -v ~/testing_data:/container_volumes ubuntu /bin/sh -c "echo peristent data > /container_volumes/data.txt"
# Check that your data is there
cat ~/testing_data/data.txt
Make an image to compile and run our C code with a specific gcc version¶
Dockerfile
=======================
FROM gcc:4.9
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
RUN gcc -o myapp main.c
CMD ["./myapp"]main.c
=======================
#include <stdio.h>
main()
{
printf("Hello container world\n");
}
Running the image¶
# Build the image
docker build . -t my-gcc-app
# Run a container
docker run -rm my-gcc-app
Monitoring your containers¶
First, Lets build a benchmarking image¶
Let us use sysbench
The cpu is one of the most simple benchmarks in SysBench. In this mode each request consists in calculation of prime numbers up to a value specified by the −−cpu−max−primes option. All calculations are performed using 64−bit integers.
Each thread executes the requests concurrently until either the total number of requests or the total execution time exceed the limits specified with the common command line options.
Monitoring your containers¶
First, Lets build a benchmarking image¶
Dockerfile
=======================
FROM ubuntu:latest
MAINTAINER Juan
RUN apt-get update \
&& apt-get install -y sysbench
CMD sysbench --test=cpu --cpu-max-prime=35000 --num-threads=4 runbuild it and run it to test it
Monitoring your containers¶
Let us run the monitoring tool¶
There are several options out there.
Let us use Google's cAdvisor https://github.com/google/cadvisor
docker run \
--volume=/:/rootfs:ro \
--volume=/var/run:/var/run:rw \
--volume=/sys:/sys:ro \
--volume=/var/lib/docker/:/var/lib/docker:ro \
--publish=8080:8080 \
--detach=true \
--name=cadvisor \
google/cadvisor:latest
Run the benchmarking container, and check the browser¶
Monitoring your containers¶
Limit the number of cores¶
docker run --cpuset-cpus="0,1" my-benchmarkMaking changes to an image¶
Go to https://hub.docker.com/ and create an account
Run the image you want to modify¶
The ubuntu image does not have the "ping" functionality installed. Lets add it.
docker run -it ubuntu- Make the modifications
apt update apt install inetutils-ping exit - Take notes of the container ID
docker commit -a '[COMMIT AUTHOR]' -m 'ping function' [CONTAINER ID] [USERNAME]/ubu_lecture:ping
Lets push the image¶
- Log in. You need sudo for this.
sudo docker login - Push the image (use sudo docker push (USERNAME)/(NAME:[TAG])
sudo docker push juancabre/ubu_lecture:ping - Go to https://hub.docker.com/ and see your new image there
Repeat all the steps with a new function and a new tag¶
I will do it for vim
Lets pull the images¶
- First lets remove the images
sudo rmi juancabre/ubu_lecture:ping - And now we pull it
docker pull juancabre/ubu_lecture:ping
Lets use :ping as a base image to create a new image with both functionalities¶
- Run your image (juancabre/ubu_lecture:ping)
- Install the new functionalities
- Exit
- Commit the changes WITHOUT A TAG
docker commit -a 'Juan' -m 'ping function' a122a23fd3bb juancabre/ubu_lecture - Push the changes WITHOUT A TAG
sudo docker push juancabre/ubu_lecture - What does this do? The default tag is called :latest
Now I have 3 images with the same base image¶
- ubu_lecture:ping (it can ping)
- ubu_lecture:vim (it can edit text)
- ubu_lecture:latest (it can ping and edit text)
Doing the same with a Dockerfile¶
Dockerfile
=============================================
# Base image
FROM ubuntu
# The maintainer
MAINTAINER Juan Cabrera
# The actual recipee
RUN apt update;\
apt install -y vim
# Adding files
ADD https://gist.githubusercontent.com/anonymous/c966c0757f62b451bffa/raw/a15e10aa38d146bf50ee6c9d7fd851ce5bb91aee/gistfile1.txt /root/.vimrc
# The default command to run
CMD /bin/bash
Build it¶
docker build -t juancabre/dockerfile:vim_config .
Run it¶
docker run -it juancabre/dockerfile:vim_config
Managing Multiple Containers and Containers Dependencies¶
Install docker compose¶
Setting Up a Wordpress¶
To set a word press, we need a data base and a wordpress server
We can use docker compose to have one file to rule them all
yml
version: '2'
services:
db:
image: mysql:5.7
volumes:
- ./db_volume:/var/lib/mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: wordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress
wordpress:
depends_on:
- db
image: wordpress:latest
ports:
- "8000:80"
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_PASSWORD: wordpressSetting Up a Wordpress¶
What do we have in that file?¶
- Services:
- db: Database
- Volumes
- restart policy
- environment variables
- wordpress
- Dependencies
- ports
- db: Database
- Volumes
Let us run it!
docker-compose up -d
Try it in your browser
Docker Compose: A Load Balancer¶
Excercise inspired from: http://blog.hypriot.com/
Lets create a webserver that performs a "computationally intensive" task
Let us create a Hello-World Node.js web application based on Express.js
Make two new folders: load-balancing/ and load-balancing/src/
We need 2 files inside load-balancing/src/. Namely index.js and package.json
load-balancing/src/index.js
var express = require('express');
var os = require("os");
var app = express();
var hostname = os.hostname();
app.get('/', function (req, res) {
// A CPU Intensive task:
for (var i = 0; i < 1000000 ; i++) {
Math.pow(i,i);
}
// Respond the request:
res.send('<html><body>Hello from Node.js container '
+ hostname + '</body></html>');
});
app.listen(80);
console.log('Running on http://localhost');
Docker Compose: A Load Balancer¶
load-balancing/src/package.json
{
"name": "node-hello-world",
"private": true,
"version": "0.0.1",
"description": "Node.js Hello world app on docker",
"author": "hypriot.com",
"dependencies": {
"express": "4.12.0"
}
}
Docker Compose: A Load Balancer¶
Now let us make the Dockerfile of our application
load-balancing/Dockerfile
FROM node
ADD src/ /src
WORKDIR /src
RUN npm install
EXPOSE 80
CMD ["node", "index.js"]
Build and run a container
docker build . -t node-hello
docker run -p 45700:80 --name web -d node-hello
Docker Compose: A Load Balancer¶
Try it in your browser
Lets benchmark it:
- See the CPU utilization with
htop - Install apache2-utils (in your pc or in an Ubuntu container)
- run:
ab -n 10000 -c 100 http://localhost:45700/ - How many requests-per-second can you support?
Docker Compose: A Load Balancer¶
load-balancing/docker-compose.yml
yml
weba:
build: .
expose:
- 80
webb:
build: .
expose:
- 80
webc:
build: .
expose:
- 80
haproxy:
image: haproxy
volumes:
- ./haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
links:
- weba
- webb
- webc
ports:
- "80:80"
- "70:70"
expose:
- "80"
- "70"Docker Compose: A Load Balancer¶
Haproxy config file
load-balancing/haproxy/haproxy.cfg
global
log 127.0.0.1 local0
log 127.0.0.1 local1 notice
defaults
log global
mode http
option httplog
option dontlognull
timeout connect 5000
timeout client 10000
timeout server 10000
listen stats
bind :70
stats enable
stats uri /
frontend balancer
bind 0.0.0.0:80
mode http
default_backend aj_backends
backend aj_backends
mode http
option forwardfor
# http-request set-header X-Forwarded-Port %[dst_port]
balance roundrobin
server weba weba:80 check
server webb webb:80 check
server webc webc:80 check
# option httpchk OPTIONS * HTTP/1.1\r\nHost:\ localhost
option httpchk GET /
http-check expect status 200Docker Compose: A Load Balancer¶
Let us run it!
docker-compose up -d
Try it in your browser!
Let us benchmark this one! :D