Corso docker

Contents
1. Virtual machine vs Containers.................................................................................................................................1
2. Componenti della virtualizzazione di docker:..........................................................................................................2
3. Componenti docker:................................................................................................................................................4
4. Popular use cases per docker (devops)...................................................................................................................4
5. 8 use cases tipici per docker....................................................................................................................................4
6. docker on windows.................................................................................................................................................5
7. docker su linux/macchina ec2 amazon e test dei componenti installati.................................................................7
8. docker su aws cloud................................................................................................................................................8
9. Persistenza dati.....................................................................................................................................................10
10. Network.............................................................................................................................................................10
11. Network control plane.......................................................................................................................................12
12. Sintassi del dockerfile........................................................................................................................................12
1. Tags dockerfile......................................................................................................................................................13
2. Costruzione di una immagine................................................................................................................................14
3. Pushing docker image to docker hub:...................................................................................................................15

1. Virtual machine vs Containers

Resourses are shared among various containers, in virtual machine they are allocated to a vm until ended.

Vm are fully isolated, containers are isolated at process level

Benefits of docker: portability (between different cloud types and o.s.), shares os, it’s useful in devops structure

2. Componenti della virtualizzazione di docker:

Come funziona docker: effettuiamo la build dell’immagine che ci serve, la carichiamo su un docker hub per
condividerla con chi vogliamo (push), successivamente

usando il “run” creiamo i container: dal nostro client partirà comando (run) verso il demone che scaricherà (pull) una
immagine dal registry, la repository, e costruirà (build) l’immagine che desideriamo.

Features di docker:
 3. Componenti docker:

Image: contiene tutte le dipendenze necessarie per far girare una applicazione

Container: la rappresentazione runtime dell’immagine

Client: che accede al container

Host: dove il motore docker o la docker machine è installata

Registry: repository centralizzata dove sono conservate le immagini

Machine: aiuta ad installare docker sui virtual hosts e offre le capability per gestire l’host usando i comandi docker

In poche parole abbiamo un demone che girerà su una macchina oppure che è considerato come un host locale su
cui puoi creare più container e immagini

Le immagini possono essere memorizzate su un docker hub repository da cui possono essere distribuite. Abbiamo
due tipi di repos: pubbliche, accessibili da vari utenti, private che possono essere accessibili solo dall’utente corrente.

Le repos contengono le immagini.

4. Popular use cases per docker (devops)

Lan Cache: usiamo docker per gestire la lan cache

Iot: possiamo usare docker per implementare le iot che producono molti dati che dobbiamo processare usando
microservizi

Federal governament applications: è stato adottato da diverse agenzie governative per risparmiare sui costi

Bioinformatica: esistono repos specializzate per tools e sw bioinformatici

5. 8 use cases tipici per docker

- gestione della configurazione semplificata,non devi avere a che fare con questioni legate a o.s. quindi meno
lavoro da fare
- code pipeline management: possiamo versionare le immagini (multiple image capability)
- app isolation: possiamo isolare le app rispetto alle piattaforme
- debugging: è semplificato in quanto possiamo mettere in piedi un enviroment per le simulazioni, grazie ad
un ventaglio di tools
- multi tenancy: docker fornisce supporto ad applicazioni multi tenancy (multi istanza, ciascuna istanza ad uso
esclusivo di una client-organization)
 - developer productivity, lo sviluppatore può testare i codice e simulare l’esecuzione come se fosse in un
ambiente di produzione
- server consolidation: utile per misurare le varie metriche necessarie per la manutenzione a lungo periodo

Il ruolo di docker in devOps:

- portabilità deployment applicazioni (processo automatizzato)

- supporto alle build automatiche grazie alle api offerte da docker: può essere automatizzato tutto tramite
scripts
- built-in version tracking: docker ha di suo il tracciamento delle versioni
- registry for sharing images: repository per condividere le immagini
- rich tools of docker api: permettono una gestione avanzata
- consistency among different enviroments
- enabled efficiency resource utilization

Docker continuous integration:

- push commit (configurazioni etc)

- code repository (storage contenente le configurazioni)
- build/test (dopo la pull è possibile procedere alla build e al test)
o possiamo definire dei multi-stage docker files per avere pipelines di continuous integration più
complesse
- docker registry (push dopo lo step di build / test)

Codice -> push in bitbucket -> trigger build -> source checkout commit per la build di una immagine docker -> docker
run and sanity testing (identificazione di test fails etc) -> push docker image to docker registry (se test ok)

dopo la push è possibile effettuare la pull nell’enviroment desiderato (EC2/K8s cluster oppure developer
workstation)

6. docker on windows
download e install docker-toolbox

dopo l’installazione lanciamo kitematic e dopo esserci loggati su docker otteniamo un elenco di immagini
preconfezionate da cui partire
nella barra di stato avremo l’apposita icona che ci permetterà di accedere ad un menù

andiamo su settings
da notare che il demone è esposto su una determinata porta su localhost e permette agli sviluppatori di collegarsi a
docker per svolgere i propri task

nella sezione network possiamo configurare la rete locale docker, nella sezione shared drivers possiamo decidere se
condividere o meno i dischi locali

se apriamo un command e digitiamo docker info otteniamo i dettagli della configurazione di docker.

7. docker su linux/macchina ec2 amazon e test dei componenti installati

dopo la login “sudo yum update –y” per essere sicuri che il sistema della ec2 sia aggiornato

per installare docker “sudo amazon-linux-extras install docker”

chiederà di installare i files di installazione, daremo conferma

dopo l’installazione il ns obiettivo è quello di aggiungere l’utente al gruppo docker

“sudo usermod –a –G <nome gruppo docker> <utente che vogliamo aggiungere>” (es ec2-user)

infine

“docker info” ci dirà che non c’è alcun servizio docker attivo (verifica prima del seguente comando)
“sudo service docker start” per far partire il servizio (docker.service usando systemctl)

“docker info” adesso ci dirà permission denied per collegarsi al demone docker, se precediamo il tutto da sudo
otterremo le informazioni sul servizio e sui componenti

se facciamo logout e proviamo a connetterci con putty all’istanza docker usando le chiavi docker per la connessione
sicura (staranno in una cartella windows in locale) e le credenziali precedentemente usate (ec2-user) questa volta
digitando docker info non avremo bisogno di usare sudo perchè in precedenza abbiamo aggiunto l’utente al gruppo
docker

8. docker su aws cloud

i servizi che useremo di aws:

- ecs: le macchine per la computazione containerizzate

- aws fargate: la tecnologia che ci aiuta a far girare docker container sulle ecs senza dover fare il deploy o
gestire l’infrastruttura
- eks: che ci offre il supporto a kubernates senza bisogno di installare o operare sui componenti kubernates
- ecr: repository ad alta affidabilità dove memorizzeremo le immagini docker

Docker e l’architettura ecs:

abbiamo un application load balancer su cui girano 2 servizi distinti su porta 70 e 90, questi servizi sono mappati sui
servizi amazon (ecs) che si occupano di orchestrare le richieste in modo da ospitare i nostri “target groups”
Parliamo adesso di uno scenario su aws: consideriamo jenkins come tool di build in modo da configurare aws e
docker scegliendo il plugin corretto.

1. il programmatore scrive il codice e lo committa nella repository

2. in jenkis configuriamo il poll trigger per gestire l’evento di commit
3. jenkins si occuperà di fare la push degli artifacts con le varie dipendenze nella repository
4. facciamo partire la build dell’immagine usando l’approccio del docker file
5. infine facciamo la push dell’image nella docker registry
6. successivamente facciamo fare la pull dell’image dal docker registry
7. infine gli faremo fare la submit del template al servizio cloud formation che si occuperà di mettere in piedi lo
stack di servizi (es. route 53, amazon ecs, amazon ec2, ...) e risorse che che servono

Per deployare docker community edition su aws andiamo su hub.docker.com, ci logghiamo con l’account docker che
abbiamo creato, andiamo in /edition/community/docker-ce-aws che ci visualizza la pagina che ci permetterà
l’installazione su aws: un one-click template che permette il deploy di docker su una ec2

abbiano 2 opzioni: stable channel o edge channel, il primo è testato e perfettamente funzionante, il secondo invece
ha delle features sperimentali non testate completamente

se eravamo già loggati su aws verremo direzionati alla pagina per costruire lo stack cloudformation:
allo step successivo amazon chiederà i dettagli dello stack, come ad esempio nome stack, numero di swarm
managers per gestire lo stack (1) numero di swarm nodes (1), il tipo di istanza ec2 (t2.large), il size del volume dove
memorizzare i dati, il type di volume

nello step successivo possiamo specificare i tags e i iam roles o iam names

infine pagina di riepilogo e possiamo creare lo stack

aspettiamo che venga tirato su lo stack

componenti docker per gestire le applicazioni, i dati e la rete

prendiamo in considerazione il workflow di sviluppo:

- sviluppatore scrive codice

- poi scrive un docker file, responsabile della costruzione dell’enviroment
- infine creiamo l’immagine
- usando il compose application facciamo il setup dei servizi che serviranno (rif. docker-compose.yml)
- facciamo girare il container e la app composer
- testiamo la app e/o i microservizi
- facciamo la push su una repo
- a questo punto possiamo continuare a sviluppare seguendo la metodologia devops (nel frattempo parte il
giro di deploy)

9. Persistenza dati
approccio del volume: è la cartella sull’host che può essere usata da uno o più containers (dati condivisi da più
containers), possiamo fare operazioni di scrittura che non impatteranno sul data mirroring. il data volume esisterà
per default anche se i container vengono eliminati, non è legato ad un singolo container

approccio del bind-mounts: viene montato su ogni container attivo

approccio tmpfs: che si occuperà della gestione dei files temporanei, è come il precedente ma i files vengono salvati
su memoria volatile piuttosto che su un device di storage persistente

approccio named pipes: per costruire comunicazioni tra l’host e il docker container; tipicamente

Questi diversi tipi di gestione della persistenza collaborano in modo da implementare la persistenza dei dati nelle nei
container di Docker

10. Network
CNM, container networking model: l’architettura docker è basata su un set di interfaces chiamate così
quando la rete è configurata i container avranno una nw endpoint che verrà gestita dal motore docker usando i
driver di rete o i driver ipam che comunicheranno con l’infrastruttura di rete nativa

CNM driver interface: cnm sta per container network model e mette a disposizione 2 pluggable e open interfaces che
possono essere usate da utenti, community e vendor per implementare funzionalità addizionali, visibility o i controlli
di rete necessari

ci sono differenti servizi che vengono implementati:

i cnm si interfacciano a loro volta con 4 categorie di driver

- native, provided da docker

- native ipam
- remote nw drivers : implementati da external vendors
- remote ipam nw drivers: implementati da external vendors

native:

host driver: tramite questo un container userà lo stack di rete dell’host, nessun namespace separation e
tutte le interfacce dell’host possono essere usate dai container

bridge: viene creato un bridge linux sull’host, gestito da docker, i container possono comunicare tra loro, ed
è usato per far comunicare i container tra loro
 overlay: usa la combinazione di bridge e vxlan per implementare la comunicazione container to container
utilizzando però l’infrastruttura fisica

macvlan: usa il macvlan bridge mode per instaurare una connessione tra l’interfaccia del container e il parent
host interface, viene usato per dare un indirizzo ip al container utilizzabile sulla rete fisica, nel caso in cui
vogliamo che il container sia accessibile dall’esterno

none: dà al container le proprie capacità dello stack di rete (?)

11. Network control plane

ecco il lavoro che fa questo oggetto:

12. Sintassi del dockerfile

come si usa il file docker nell’ambito del setup di un container docker

vediamo la struttura dell’immagine

Abbiamo un indice con l’elenco dei manifesti, per ciascuno una configurazione di layer....

1. Tags dockerfile
ADD: copia nuovi file, cartelle, o una url remota sul file system dell’immagine specificata come destinazione

ENTRYPOINT: ci permette di configurare un container che girerà come eseguibile

COPY: per copiare nuovi file o cartelle dal sorgente aggiungendoli al file system ad un path ben specifico

ENV: per definire varibili di enviroment

EXPOSE: per permettere di ascoltare un container su una porta di rete specifica quando è in esecuzione specificando
anche se tcp o udp

FROM: viene usato per indicare che l’immagine corrente sarà basata su una immagine di base ben specifica

LABEL: aggiunge metadati ad una immagine (key value pair)

STOPSIGNAL: che istruisce il container su quando uscire

USER: imposta lo user name e opzionalmente la user group quando si esegue una immagine

VOLUME: per gestire i dati

WORKDIR: imposta la cartella di lavoro per l’esecuzione di qualsiasi comando o comando “entrypoint”, supporta
anche le istruzione copy e add

esempio di dockerfile:

FROM ubuntu latest -> immagine base

MANTAINER .... -> chi manutiene l’immagine corrente (nome, email...)

RUN apt-get update.... -> comando per eseguire l’update e/o installare software

RUN git clone.... -> comando per clonare una repo git

RUN systemctl start ngix -> comando per far partire un server ngix
 2. Costruzione di una immagine
Docker version a riga di comando per conoscere la versione docker

apprendiamo che la versione del motore docker 10.03.1 e il fatto che supporta sistemi linux/amd64

prendiamo un normale notepad e scriviamo un file chiamato “dockerfile”:

FROM ubuntu:16.04

RUN apt-get update

...altri comandi per configurare la rete, crare volumi, data directories e altro

per fare la build della immagine digitiamo a riga di comando

docker build –t <nome immagine, es bizubuntu2> .

il punto indica di cercare il dockerfile nella directory corrente

l’id dopo la parola built va usato come tag quando si fa la push nella repository, ignoriamo i messaggi di warning
perchè stiamo costruendo una immagine ubuntu sotto windows

poniamo che vogliamo taggare l’immagine con un tag personale, per fare questo scriviamo

docker tag b637..... alchemybiz/bizubuntu2:ver1.0

docker image

l’output sarà:

con docker image ls vedremo l’elenco delle immagini disponibili

3. Pushing docker image to docker hub:

per poter creare una repos dobbiamo loggarci su dockerhub

dopo la login otterremo l’elenco delle repos nostre, con apposito bottone creiamo una nuova

ci verrà chiesto se la repo deve essere pubblica o privata, il nome della repo, la descrizione, opzionalmente i build
settings
cliccando su create parte la creazione

usando il comando docker push possiamo fare la push sulla repos appena creata tramite il prompt dei comandi

riprendiamo la lista delle immagini che abbiamo in locale

facciamo la login su docker

dopo aver ottenuto il messaggio “login succeded” possiamo pushare la immagine specificando anche il nome del tag:

docker push alchemybiz/bizubintu2:ver1.0

al termine dell’operazione ci verrà comunicato il digest sha il nome del tag etc

Se entriamo nella nostra repos da web ci accorgeremo della presenza della nostra immagine

Riepilogo:

creiamo una repo su web, poi proviamo a fare la push di una image
docker push <username>/<nome immagine>

causerà errore perchè l’immagine non ha un tag

a questo punto diamo un tag all’immagine con

docker tag <id immagine> <username>/<nome repos locale>

a questo punto abbiamo aggiunto l’immagine in una repo locale, possiamo pusharla su docker:

docker push alchemybiz/newimage