Gestire i contenitori Linux con Docker su Ubuntu

Versione: 1.0
Autori: Srijan Kishore
Ultima modifica: 02 /Lug/2014

Questa guida spiega come installare Docker e gestire le macchine virtuali in modo efficace. Docker è una piattaforma di virtualizzazione Linux open source per sviluppatori e amministratori di sistema per costruire, distribuire ed eseguire applicazioni distribuite facilmente. Docker è composto dal Docker Engine, un runtime leggero e un livello di virtualizzazione, strumenti per impacchettare e versionare macchine virtuali simili a un repository di codice sorgente e Docker Hub, un servizio nel cloud per condividere applicazioni e automatizzare il flusso di lavoro. Docker consente di assemblare rapidamente le applicazioni da componenti e elimina l’attrito tra ambienti di sviluppo, controllo qualità e produzione.

1 Nota preliminare

Nel mio caso ho Ubuntu 14.04 su cui installerò Docker. Nel mercato del software di virtualizzazione abbiamo diverse tecnologie di virtualizzazione hardware complete disponibili come KVM, Xen o Hyper-V. Ma le virtualizzazioni complete sono troppo pesanti per virtualizzare singole applicazioni su Linux. Possiamo superare questa situazione utilizzando i contenitori Linux, che sono una buona alternativa per la virtualizzazione a livello di sistema operativo. I contenitori Linux sono molto utili per avere un ambiente di sviluppo/test in un insieme sicuro di contenitori. Docker fornisce un ambiente di contenitori Linux per questo scopo.

2 Installazione

Come ho detto sopra, ho Ubuntu su cui installerò Docker. In questo capitolo ti mostrerò 2 opzioni per installare Docker, in 2a utilizzo la versione di Docker dal repository di Ubuntu, questa versione è mantenuta da Ubuntu per i 5 anni di supporto LTS, ma non è l’ultima versione. In 2b utilizzerò l’ultima versione dal repository PPA di Ubuntu. Poiché Docker è in fase di sviluppo attivo, l’ultima versione di Docker da 2b) si adatterà molto probabilmente alla maggior parte degli utenti. Si prega di utilizzare il metodo 2a o 2b ma non entrambi contemporaneamente!

2a Installazione dal repository ufficiale di Ubuntu

Per installare usa:

sudo apt-get update  
sudo apt-get install docker.io

e crea un symlink per rendere più facile l’uso nella shell.

sudo ln -sf /usr/bin/docker.io /usr/local/bin/docker  
sudo sed -i '$acomplete -F _docker docker' /etc/bash_completion.d/docker.io

2b Installa l’ultima versione di Docker

Per installare l’ultima versione di Docker dal repository docker.io, esegui questo comando

curl -s https://get.docker.io/ubuntu/ | sudo sh

3 Preparare l’ambiente della shell

Ora aggiungerò il mio utente=srijan al gruppo docker

sudo usermod -a -G docker srijan

Oppure usa:

sudo usermod -a -G docker $USER

Qui uscirò dalla mia sessione attuale e rientrerò di nuovo. Ora aggiungerò il file di configurazione di Docker per far sapere al sistema la sua posizione.

sudo vi /etc/default/docker.io

| DOCKER="/usr/bin/docker.io" |

Ora riavvia il servizio come segue:

sudo service docker.io restart

4 Gestione dei contenitori

Sto per avviare un contenitore con il sistema operativo Ubuntu. Scaricherò l’immagine Docker come segue:

docker pull ubuntu

Nota: pull viene utilizzato per scaricare un'immagine o un repository dal registro

Ora accederò alla shell bash del contenitore ubuntu utilizzando:

docker run -i -t ubuntu /bin/bash

Solo per conferma controllerò il mio IP del contenitore come segue:

root@fd98ee950252:/# ifconfig 
eth0      Link encap:Ethernet  HWaddr 5a:a6:c6:88:f2:48  
          inet addr:172.17.0.3  Bcast:0.0.0.0  Mask:255.255.0.0
          inet6 addr: fe80::58a6:c6ff:fe88:f248/64 Scope:Link
          UP BROADCAST RUNNING  MTU:1500  Metric:1
          RX packets:7 errors:0 dropped:2 overruns:0 frame:0
          TX packets:8 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000 
          RX bytes:558 (558.0 B)  TX bytes:648 (648.0 B)

lo        Link encap:Local Loopback  
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0 
          RX bytes:0 (0.0 B)  TX bytes:0 (0.0 B)

root@fd98ee950252:/#

Ho un IP di 172.17.0.3 nel mio contenitore. Allo stesso modo posso utilizzare anche altri contenitori. Per uscire dal contenitore basta digitare:

exit

Allo stesso modo puoi avere altri contenitori OS, ad esempio.

Voglio usare un contenitore Debian utilizzerò il codice:

docker run -i -t debian /bin/bash

Se vuoi avere una distribuzione particolare allora usa:

docker run -i -t ubuntu:12.04 /bin/bash

Creerà il contenitore ubuntu12.04. Lo controllerò come segue:

root@44b56100fd1f:/# cat /etc/lsb-release 
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=12.04
DISTRIB_CODENAME=precise
DISTRIB_DESCRIPTION="Ubuntu 12.04.4 LTS"
root@44b56100fd1f:/#

4 Creazione delle nostre immagini

Ci sono due modi per creare un’immagine Docker:

Tramite il comando docker commit
Tramite il comando docker build con un Dockerfile

Il metodo docker commit non è attualmente raccomandato, poiché costruire con un Dockerfile è molto più flessibile e potente, ma lo dimostreremo per completezza. Dopo di che, mi concentrerò sul metodo raccomandato per costruire immagini Docker: scrivere un Dockerfile e utilizzare il comando docker build.

4.1 Utilizzo di Docker commit per creare immagini

Creerò un contenitore, apporterò modifiche a quel contenitore come faresti con il codice, e poi commetterò quelle modifiche a una nuova immagine.

Iniziamo creando un contenitore dall’immagine ubuntu che abbiamo usato in passato.

docker run -i -t ubuntu /bin/bash  
root@73527b8b4261:/#

Nota: Si prega di notare che sopra root mostra il nome host 73527b8b4261, è il nome del contenitore creato e differirà nel tuo caso.

In seguito installerò apache in esso:

apt-get install apache2

Ho avviato il contenitore e poi installato Apache al suo interno. Ora sto per utilizzare questo contenitore come server web, quindi lo salverò nel suo stato attuale.
Questo ci eviterà di doverlo ricostruire con Apache ogni volta che creo un nuovo contenitore. Per fare ciò uscirò dal contenitore, utilizzando il comando exit,
e utilizzerò il comando docker commit.

exit

docker commit 73527b8b4261 srijan/apache2 8ce0ea7a1528

Nota: qui 73527b8b4261 è il nome del mio contenitore e sto usando 8ce0ea7a1528 come Tag per il contenitore, puoi dare qualsiasi nome di tag o usare lo stesso.

Supponiamo che tu abbia dimenticato l’id dell’ultimo contenitore creato puoi usare:

docker ps -l -q

Restituirà 73527b8b4261

Nota: 73527b8b4261 è il nome del tuo ultimo contenitore creato, differirà nel tuo caso.*

Diamo un’occhiata alla nostra nuova immagine. Può essere ottenuta come segue:

docker images srijan/apache2

srijan@vboxtest:~$ docker images srijan/apache2
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
srijan/apache2      8ce0ea7a1528        741155868ac8        6 minutes ago       207.2 MB
srijan@vboxtest:~$

Nota: Qui 8ce0ea7a1528 era il nome del tag che ho usato al momento del salvataggio del contenitore,   
Nota: 741155868ac8 è l'IMAGE ID di quel contenitore  
Nota: Tutti questi valori differiranno nel tuo caso poiché al momento del salvataggio del contenitore Docker genera nomi casuali per essi

Ora salverò l’immagine personalizzata come segue:

docker commit -m="Una nuova immagine personalizzata" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver

Restituirà il risultato come:

srijan@vboxtest:~$ docker commit -m="Una nuova immagine personalizzata" --author="Srijan Kishore" 73527b8b4261 srijan/apache2:webserver
f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec

Per eseguire un contenitore dalla nostra nuova immagine, possiamo farlo utilizzando il comando docker run.

docker run -t -i srijan/apache2:webserver /bin/bash

Possiamo controllare la nostra immagine committata come segue:

docker inspect srijan/apache2:webserver

srijan@vboxtest:~$ docker inspect srijan/apache2:webserver
[{
    "Architecture": "amd64",
    "Author": "Srijan Kishore",
    "Comment": "Una nuova immagine personalizzata",
    "Config": {
        "AttachStderr": false,
        "AttachStdin": false,
        "AttachStdout": false,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "",
        "Image": "",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": false,
        "PortSpecs": null,
        "StdinOnce": false,
        "Tty": false,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Container": "73527b8b42614f6ecd83fb5f9822d6086988d3b68fd5e32b4afbc7cd415402fd",
    "ContainerConfig": {
        "AttachStderr": true,
        "AttachStdin": true,
        "AttachStdout": true,
        "Cmd": [
            "/bin/bash"
        ],
        "CpuShares": 0,
        "Cpuset": "",
        "Domainname": "",
        "Entrypoint": null,
        "Env": [
            "HOME=/",
            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
        ],
        "ExposedPorts": null,
        "Hostname": "73527b8b4261",
        "Image": "ubuntu",
        "Memory": 0,
        "MemorySwap": 0,
        "NetworkDisabled": false,
        "OnBuild": null,
        "OpenStdin": true,
        "PortSpecs": null,
        "StdinOnce": true,
        "Tty": true,
        "User": "",
        "Volumes": null,
        "WorkingDir": ""
    },
    "Created": "2014-06-30T12:58:04.973349049Z",
    "DockerVersion": "1.0.1",
    "Id": "f0367362eb405c513ac002b5cf172a2c0bc6c8212eab91c613f9ee611cf92fec",
    "Os": "linux",
    "Parent": "ef83896b7fb99b00b9e0e6ac943826386e7edcef11a3a2f58b42011ab4a4e683",
    "Size": 14463026
}
]srijan@vboxtest:~$

Per eseguire un contenitore dalla nostra nuova immagine, possiamo farlo utilizzando il comando docker run.

docker run -t -i srijan/apache2:webserver /bin/bash