PiumaLab

Idee, esperimenti, tentativi e molto altro

presentazione docker


Slide di introduzione su docker. Scritte in markdown per reveraljs. Argomenti trattati: Introduzione, cosa è, caratteristiche, pregi, confronto con le macchine virtuali, container, immagini, esempi con Dockerfile e docker-compose.

Slide in Markdown

Di seguito il file .md della presentazione.

# docker
###An uncompleted introduction to docker
![text](md/image/homepage-docker-logo.png)
####piuma@piumalab.org
---
## What is?
Docker is a platform for developers and sysadmins to develop,
 ship, and run applications.
---
## Why it was born?

To resolve a necessity

Mobility workload in cloud systems!
---
### Cargo transport pre-1960
![text](md/image/cargo-transport-pre-1960.png)
---
### Solution: Intermodal Shipping Container
![text](md/image/standard_container.jpg)
---
### Docker is a Container System for Code
![text](md/image/container.png)

Docker leverages LXC (Linux Containers), which encompasses Linux
features like cgroups and namespaces for strong process isolation and
resource control.

They are lightweight and consume less resources than a virtual machine.
---
## Benefits for developers
 - portability, build once... run anywhere
 - no worries about missing dependencies, packages and other pain
 points during subsequent deployments
 - tracking changes
 - run each app in its own isolated container, so you can run various
 versions of libraries and other dependencies for each app without
 worrying
 - reduce/eliminate concerns about compatibility on different
 platforms, either your own or your customers
---
## Benefits for sysadmins
 - portability, configure once... run anywhere
 - tracking changes
 - simple to understand what application do
 - simplify to upgrade application processes. Significantly improves
 the speed and reliability of continuous deployment and continuous
 integration systems
 - eliminate inconsistencies between different enviroments (develop, testing, production)
 - re-use other people images
 - do you not need an hypervisor. Because the containers are so
 lightweight, address significant performance, costs, deployment, and
 portability issues normally associated with VMs
---
## Docker Concepts and Interactions
 - **Host**, the machine that is running the containers.
 - **Image**, a hierarchy of files, with meta-data for how to run a container.
 - **Container**, a contained running process, started from an image.
 - **Registry**, a repository of images.
 - **Volume**, storage outside the container.
 - **Dockerfile**, a script for creating images.
-
![text](md/image/docker-interactions.png)
---
## Separation of concerns
 - inside the container:
   * libreries
   * package manager
   * application
   * data
   * code
 - outside the container:
   * logging
   * remote access
   * network configuration
   * monitoring
---
## Difference between docker and virtual machine
![text](md/image/VM-Diagram.png)
---
## Dockerizing Applications
```
$ docker run busybox /bin/echo 'Hello world'
```
```
$ docker run -t -i ubuntu:14.04 bash
```
---
## Containers
```
$ docker create  # creates a container but does not start it.
$ docker run     # creates and starts a container.
$ docker stop    # stops it.
$ docker start   # will start it again.
$ docker restart # restarts a container.
$ docker rm      # deletes a container.
$ docker kill    # sends a SIGKILL to a container.
$ docker attach  # will connect to a running container.
$ docker wait    # blocks until container stops.
$ docker exec    # executes a command in a running container.
```
inspecting containers
```
$ docker ps      # shows running containers.
$ docker inspect # information on a container (incl. IP address).
$ docker logs    # gets logs from container.
$ docker events  # gets events from container.
$ docker port    # shows public facing port of container.
$ docker top     # shows running processes in container.
$ docker diff    # shows changed files in container's FS.
$ docker stats   # shows metrics, memory, cpu, filsystem
```
---
## Images
### like template for VMs
Docker leverages a copy-on-write fs. This allows Docker to instantiate
containers very quickly. Docker use to layering one container on top
of another. For example, you might create a container that is based on
a base Debian image, and then in turn create another container that is
based on the first container.
-
## Images
![text](md/image/docker-filesystems-debian.png)
-
## Images
![text](md/image/docker-filesystems-debianrw.png)
-
## Images
![text](md/image/docker-filesystems-multilayer.png)
-
## Commands for interacting with images
```
$ docker images  # shows all images.
$ docker import  # creates an image from a tarball.
$ docker build   # creates image from Dockerfile.
$ docker commit  # creates image from a container.
$ docker rmi     # removes an image.
$ docker history # list changes of an image.
```
---
## Dockerfile
```
FROM debian:7.8
MAINTAINER Piuma "piuma@piumalab.org"
RUN apt-get update && apt-get -y install apache2
EXPOSE 80
CMD ["/usr/sbin/apache2ctl", "-D", "FOREGROUND"]
```
```
$ docker build -t apache-example .
```
---
## docker-compose
Compose is a tool for defining and running complex applications with
Docker.

With Compose, you define a multi-container application in a
single file, then spin your application up in a single command which
does everything that needs to be done to get it running.
-
## docker-compose
###Using Compose is basically a three-step process:

 - **First**, you define your app's environment with a Dockerfile
 - **Next**, you 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.
-
## docker-compose
docker-compose.yml
```
web:
  build: .
  command: python app.py
  ports:
   - "5000:5000"
  volumes:
   - .:/code
  links:
   - redis
redis:
  image: redis
```
```
$ docker-compose up -d
```
---
## docker-compose example
```
web1:
  image: piuma/phpsysinfo
  ports:
   - "80:80"
```
-
## docker-compose example
```
web1:
  image: piuma/phpsysinfo
web2:
  image: piuma/phpsysinfo
proxy:
  image: tutum/haproxy
  links:
   - web1
   - web2
  ports:
   - "80:80"
```
-
## docker-compose example
```
web1:
  image: piuma/phpsysinfo
web2:
  image: piuma/phpsysinfo
web3:
  image: piuma/phpsysinfo
proxy:
  image: tutum/haproxy
  links:
   - web1
   - web2
   - web3
  ports:
   - "80:80"
```
-
## docker-compose example
```
phpmyadmin:
  image: nazarpc/phpmyadmin
  links:
   - mysql
  ports:
   - "8080:80"
mysql:
  image: mysql
  environment:
   - MYSQL_ROOT_PASSWORD=secret
```
---
## What next?
From here, the logical step would be to scale our architecture by
creating a **Docker Swarm** cluster.
![text](md/image/SWARM.png)
---
## Even this presentation runs in a docker container
```
docker run -d -p 8000:8000 \
           -v ~/documents/docker:/revealjs/md amouat/revealjs
```
-
```bash
docker run --rm mribeiro/cowsay "Any questions?"
 ________________
< Any questions? >
 ----------------
        \  ^___^
         \ (ooo)\_______
           (___)\       )\/\
                ||----w |
                ||     ||
```
---
## Exercises
 1. Building images with *Dockerfiles* 

 1. Using *Supervisor* with Docker

*Supervisor* is a ``process management tool`` to manage multiple processes in our container

 1. Automated Builds on Docker Hub

Automatically create images from a GitHub or Bitbucket repository containing a Dockerfile.

 1. Use *docker-compose* to benchmark a web server with ab

 1. Set up docker *Swarm nodes*

Docker Swarm is native clustering for Docker.

 1. Setup Docker Registry 2.0

Docker Registry stores and distributes images centrally.

Leave a Reply

Your email address will not be published. Required fields are marked *