Docker: l’or­che­stra­zio­ne di app multi-con­te­ni­to­re con Swarm e Compose

Con una piat­ta­for­ma di con­te­ni­to­ri Docker potete ripartire nel network ap­pli­ca­zio­ni sotto forma di task in modo veloce, semplice e con notevole risparmio di risorse. Tutto quello di cui avete bisogno è il cluster manager Swarm, che dalla versione di Docker 1.12.0 è parte nativa di Docker Engine come “Swarm-mode” e con­se­guen­te­men­te il software centrale della piat­ta­for­ma di con­te­ni­to­ri.

Docker Swarm vi permette di scalare le ap­pli­ca­zio­ni in con­te­ni­to­ri, ese­guen­do­le in un numero qualsiasi di istanze su qualsiasi numero di nodi del vostro network. Se al contrario volete eseguire un’ap­pli­ca­zio­ne multi-con­te­ni­to­re in un cluster (ope­ra­zio­ne chiamata “stack” in Docker), potete ricorrere a Compose, un tool di Docker. Vi spie­ghia­mo ora i concetti basilari dell’or­che­stra­zio­ne Docker con Swarm e Compose mo­stran­do­vi con­cre­ta­men­te le im­ple­men­ta­zio­ni sulla base di esempi di codice.

Swarm, nato dagli stessi svi­lup­pa­to­ri di Docker, raggruppa un qualsiasi numero di host docker in un unico cluster, per­met­ten­do la gestione cen­tra­liz­za­ta dei cluster e l’or­che­stra­zio­ne dei con­te­ni­to­ri. Fino alla versione di Docker 1.11, Swarm doveva essere im­ple­men­ta­to come tool separato, mentre le versioni più recenti della piat­ta­for­ma di con­te­ni­to­ri sup­por­ta­no uno swarm mode nativo: così qualunque utente di Docker può usufruire del cluster manager in­stal­lan­do Docker Engine.

Docker Swarm si basa su un’ar­chi­tet­tu­ra master-slave. Ogni cluster di Docker (lo sciame) consta di almeno un nodo manager e di una quantità a piacere di nodi la­vo­ra­to­ri (worker). Mentre lo swarm manager è re­spon­sa­bi­le per l’am­mi­ni­stra­zio­ne del cluster e la de­le­ga­zio­ne di compiti, gli swarm worker prendono in carico l’ese­cu­zio­ne di unità la­vo­ra­ti­ve (“tasks”). Inoltre le ap­pli­ca­zio­ni del con­te­ni­to­re vengono suddivise come co­sid­det­ti servizi (“services”) in un numero qualunque di account Docker.

Nella ter­mi­no­lo­gia di Docker il concetto di “servizio” indica una struttura astratta mediante la quale potete definire compiti che devono essere eseguiti nel cluster. Ogni servizio consta di un set di task singoli, che vengono elaborati ciascuno nel proprio con­te­ni­to­re su uno dei nodi del cluster. Quando create un servizio de­ter­mi­na­te su quale immagine di con­te­ni­to­re si basa e quindi quali comandi verranno eseguiti nel con­te­ni­to­re, dato che i comandi vengono eseguiti in base all’immagine. Docker Swarm supporta due modalità nelle quali sono definiti i servizi Swarm: servizi replicati e globali.

• Servizi replicati: un servizio replicato è un task che viene eseguito in un numero di repliche definite dall’utente. Ogni replicato è un’istanza del con­te­ni­to­re di Docker definito nel servizio. I servizi replicati vengono scalati man mano che gli utenti creano più repliche. Un server web come NGINX si può ad esempio impostare a una sola riga di comando a 2, 4 o 100 istanze a seconda delle esigenze.

• Servizi globali: eseguendo un servizio in modalità globale, ogni nodo di­spo­ni­bi­le nel cluster inizia un task per il relativo servizio. Se ag­giun­ge­te un nuovo nodo al cluster, lo swarm manager gli assegna im­me­dia­ta­men­te un’attività del service globale. I service globali si prestano ad esempio ad ap­pli­ca­zio­ni di mo­ni­to­rag­gio o programmi antivirus.

Un campo centrale di ap­pli­ca­zio­ne di Docker Swarm è la ri­par­ti­zio­ne del carico. Nella modalità swarm, Docker dispone di funzioni integrate di load balancing: se per esempio eseguite un server web NGINX con 4 istanze, Docker di­stri­bui­sce in modo in­tel­li­gen­te le richieste in arrivo alle istanze dei server di­spo­ni­bi­li.

Docker Compose vi permette di definire ap­pli­ca­zio­ni multi-con­te­ni­to­re – le co­sid­det­te “stacks” o pile – e volendo di eseguirle su un unico nodo Docker o nel cluster; inoltre il tool fornisce righe di comando con le quali potete gestire l’intero ciclo vitale delle vostre ap­pli­ca­zio­ni.

Docker definisce gli stack come gruppi di servizi collegati che con­di­vi­do­no di­pen­den­ze software e che sono or­che­stra­ti e scalati. Uno stack di Docker vi permette di definire diverse fun­zio­na­li­tà di un’ap­pli­ca­zio­ne in un file centrale (il docker-compose.yml) e di iniziare da qui ad eseguirle insieme in un runtime en­vi­ron­ment isolato am­mi­ni­stran­do­le in modo cen­tra­liz­za­to.

Con alcuni sistemi operativi Compose va in­stal­la­to se­pa­ra­ta­men­te: se uti­liz­za­te la piat­ta­for­ma di con­te­ni­to­ri Docker nell’ambito delle in­stal­la­zio­ni desktop Docker per il Mac o Docker per Windows, Docker Compose è già contenuto nelle funzioni e lo stesso vale per Docker Toolbox, che è di­spo­ni­bi­le per i vecchi sistemi Mac o Windows; se invece uti­liz­za­te Docker con Linux o con Windows Server 2016, è ne­ces­sa­ria un’in­stal­la­zio­ne manuale del tool.

Per scaricare i file binari di Compose dal re­po­si­to­ry di GitHub, aprite il terminale ed eseguite il seguente comando:

Date a tutti gli utenti il permesso di eseguire i file binari:

Con il comando seguente potete con­trol­la­re se il tool è stato in­stal­la­to cor­ret­ta­men­te:

Se l’in­stal­la­zio­ne è stata ef­fet­tua­ta con successo, avrete come output del terminale il numero di versione del tool.

Avviate il Po­wer­Shell come am­mi­ni­stra­to­re e date il seguente comando per avviare il download dei file binari di Compose dal re­po­si­to­ry di GitHub:

Avviate i file ese­gui­bi­li per in­stal­la­re Docker Compose.

Per poter gestire app multi-con­te­ni­to­re con Docker nel cluster, avete bisogno di uno sciame (swarm), cioè di un cluster di Docker Engine in modalità swarm, nonché di Compose, tool di Docker.

Nella prima parte del nostro tutorial potete vedere come giungere in pochi passi al vostro sciame con Docker. La pro­du­zio­ne di app multi-con­te­ni­to­re con Docker Compose e il de­ploy­ment nel cluster saranno invece tema della seconda parte.

Per “sciame” si intende un numero a piacere di Docker Engine in modalità swarm. Ogni Docker Engine funziona su un nodo separato e lo lega nel cluster.

La pro­du­zio­ne di cluster Docker richiede tre passaggi:

1. Preparare gli host Docker
2. Ini­zia­liz­za­re swarm
3. Collegare gli host Docker nello sciame

Per la pre­pa­ra­zio­ne di nodi Docker si consiglia di ricorrere al tool di pro­vi­sio­ning Docker Machine, che facilita l’im­ple­men­ta­zio­ne degli host Docker (chiamati anche “doc­ke­ri­zed hosts”, host virtuali inclusivi di Docker Engine). Con Docker Machine si possono di­stri­bui­re gli account per il vostro sciame su qualsiasi in­fra­strut­tu­ra e gestirli da remoto. I plug-in del driver Docker Machine sono forniti da diverse piat­ta­for­me cloud. Ciò riduce lo sforzo di pro­vi­sio­ning di host Docker a fornitori come Amazon Web Services (AWS) o Digital Ocean a un’unica riga di codice. Per creare un host Docker (qui: docker-sandbox) nell’in­fra­strut­tu­ra di Digital Ocean, uti­liz­za­te il seguente codice:

Per AWS potete creare un host Docker (qui: aws-sandbox) con il seguente comando:

Dopo aver preparato il numero de­si­de­ra­to di host virtuali per il vostro sciame, potete am­mi­ni­strar­li at­tra­ver­so Docker Machine e rag­grup­par­li in un cluster con Docker Swarm. In­nan­zi­tut­to accedete al nodo che volete uti­liz­za­re come “swarm manager”. Docker Machine offre il seguente comando per costruire una con­nes­sio­ne criptata SSH all’host Docker:

Una volta ef­fet­tua­ta la con­nes­sio­ne al nodo de­si­de­ra­to, uti­liz­za­te il seguente comando per ini­zia­liz­za­re uno sciame:

A seconda dell’opzione scelta (vedi do­cu­men­ta­zio­ne), il comando docker swarm init definisce il nodo at­tual­men­te scelto come swarm manager e genera due token casuali: un token manager e un token worker.

Il comando docker swarm init genera inoltre un output di terminale che comprende tutte le in­for­ma­zio­ni di cui avete bisogno per ag­giun­ge­re altri account al vostro sciame.

Dopo che avete ini­zia­liz­za­to il vostro sciame con il nodo scelto come swarm manager, potete ag­giun­ge­re una quantità di nodi manager o worker a piacere, uti­liz­zan­do il comando docker swarm join in com­bi­na­zio­ne con il token cor­ri­spon­den­te.

3.1 Come ag­giun­ge­re un nodo worker: se volete ag­giun­ge­re al vostro sciame un nodo worker, accedete at­tra­ver­so docker-machine al nodo cor­ri­spon­den­te ed eseguite il seguente comando:

Parte ob­bli­ga­to­ria del comando docker swarm join è il flag --token, che contiene il token per l’accesso al cluster.

Nell’esempio citato il comando contiene il token worker generato pre­ce­den­te­men­te nonché l’indirizzo IP presso il quale è di­spo­ni­bi­le lo swarm manager.

Se non avete sottomano il token cor­ri­spon­den­te, lo potete in­di­vi­dua­re at­tra­ver­so docker swarm join-token worker.

3.2 Come ag­giun­ge­re un nodo master: se de­si­de­ra­te ag­giun­ge­re al vostro sciame un ulteriore nodo manager, ac­cer­ta­te­vi in­nan­zi­tut­to del token manager. Eseguite inoltre il comando docker swarm join-token manager sull’account manager dove avete ini­zia­liz­za­to lo sciame e seguite le in­di­ca­zio­ni sul terminale.

Docker genera un token manager che può essere eseguito in com­bi­na­zio­ne con il comando docker swarm join e con l’indirizzo IP da voi definito su un host Docker a scelta, in modo da unirlo allo sciame in qualità di manager.

3.3 Pa­no­ra­mi­ca di tutti i nodi nello sciame: potete ottenere una pa­no­ra­mi­ca su tutti i nodi collegati al vostro sciame eseguendo il comando di ma­na­ge­ment docker node ls su uno dei vostri nodi manager.

I nodi manager sono indicati nella pa­no­ra­mi­ca come Leader.

Nella prima parte del nostro tutorial avete imparato come preparare gli host Docker con Docker Machine e come riunirli in modalità swarm sotto forma di cluster. Ora vi mo­stre­re­mo come uti­liz­za­re Docker Compose per definire i diversi servizi come app multi-con­te­ni­to­re compatte ed eseguirle nel cluster.

La pre­pa­ra­zio­ne di app multi-con­te­ni­to­re nel cluster consta di cinque passi:

1. Creare un Docker Registry locale.
2. Definire l’app multi-con­te­ni­to­re come stack.
3. Testare l’app multi-con­te­ni­to­re con Compose.
4. Caricare l’immagine nel Registry.
5. Eseguire lo stack nel cluster.

Poiché uno sciame Docker consiste di un numero a piacere di Docker Engines, le ap­pli­ca­zio­ni si possono gestire nel cluster soltanto se tutti i Docker Engines che par­te­ci­pa­no hanno accesso all’immagine dell’ap­pli­ca­zio­ne. Per questo serve un Registry, ovvero un servizio centrale che vi permetta di am­mi­ni­stra­re le images e di metterle a di­spo­si­zio­ne nel cluster.

1.1   Avviare Registry come service nel cluster: Per avviare un Registry Server locale come servizio nel cluster, uti­liz­za­te il comando docker service create:

1.2 Ve­ri­fi­ca­re lo status del Registry Service: Per esaminare lo status del Registry Service appena avviato, uti­liz­za­te il comando docker service ls

1.3 Ve­ri­fi­ca­re la con­nes­sio­ne al Registry con cURL: As­si­cu­ra­te­vi di poter accedere al vostro Registry via cURL. Per farlo, eseguite il seguente comando:

Se il vostro Registry funziona come previsto, il cURL dovrebbe fornire il seguente output:

Nel passo suc­ces­si­vo create tutti i file che sono necessari per il de­ploy­ment di uno stack nel cluster di Docker e po­si­zio­na­te­li in una directory di progetto comune.

2.1 Creare una cartella di progetto: Create una directory di progetto con un nome qualunque, come ad esempio stackdemo.

La vostra directory di progetto funge da cartella di raccolta per tutti i file necessari per eseguire la vostra app multi-con­te­ni­to­re; questi includono un file con il codice sorgente del­l'ap­pli­ca­zio­ne, ossia un file di testo in cui si definisce il software ne­ces­sa­rio per il fun­zio­na­men­to del­l'ap­pli­ca­zio­ne, così come un file Docker e un file Compose.

2.2 Creare la app: Create un’ap­pli­ca­zio­ne Python con il seguente contenuto e po­si­zio­na­te­la sotto il nome app.py nella directory di progetto.

L’ap­pli­ca­zio­ne di esempio app.py è una semplice ap­pli­ca­zio­ne web con una pagina iniziale che dice “Hello World!” e include un’in­di­ca­zio­ne su quante volte l’app è stata ri­chia­ma­ta. La base è il framework web open source Flask e il database open source in-memory Redis. 2.3 Definire i requisiti: Create un file di testo re­qui­re­men­ts.txt con il contenuto seguente e col­lo­ca­te­lo nella directory del progetto.

In re­qui­re­men­ts.txt definite su quale software si basa la vostra ap­pli­ca­zio­ne.

2.4 Creare un file Docker: Create un altro file di testo con il nome Doc­ker­fi­le, inserite il seguente contenuto e collocate anche questo file nella cartella di progetto.

Il docker-compose.yml permette di collegare tra di loro diversi servizi e di eseguirli insieme come unità, am­mi­ni­stran­do­li in modo centrale.

Nell’esempio preso in con­si­de­ra­zio­ne definiamo due servizi: un servizio web e uno Redis.

• Servizio web: Il fon­da­men­to del “web service” è un’immagine che viene prodotta sulla base del Doc­ker­fi­le che avete creato nella directory stackdemo.

• Servizio Redis: Per i servizi Redis non uti­liz­zia­mo immagini proprie: at­tin­gia­mo invece ad una Redis Image di­spo­ni­bi­le pub­bli­ca­men­te (redis:alpine) e re­pe­ri­bi­le at­tra­ver­so il Docker Hub.

Per prima cosa testate lo­cal­men­te l’app multi-con­te­ni­to­re ese­guen­do­la sul vostro nodo manager.

3.1 Avviare la app: Per avviare il vostro stack uti­liz­za­te il comando docker-compose up in com­bi­na­zio­ne con il flag -d. Il flag attiva il “detached mode”, at­tra­ver­so il quale tutti i con­te­ni­to­ri vengono eseguiti in back­ground. In questo modo il vostro terminale è pronto a ricevere altri comandi.

3.3 Testare lo stack con cURL: Testate il vostro stack eseguendo l’in­ter­fac­cia a riga di comando cURL con l’indirizzo host locale (localhost o 127.0.0.1).

3.4 Di­sat­ti­va­re un’app: Se de­si­de­ra­te di­sat­ti­va­re lo stack, eseguite il comando docker-compose down con il flag --volumes.

Prima di poter eseguire la vostra app multi-con­te­ni­to­re come ap­pli­ca­zio­ne ripartita nel cluster, dovete preparare tutte le immagini ne­ces­sa­rie at­tra­ver­so il Registry Service. Nell’esempio il­lu­stra­to si tratta solamente delle immagini create au­to­no­ma­men­te del web service (l’immagine Redis è a di­spo­si­zio­ne grazie a un Registry pubblico nel Docker Hub).

In Docker l’upload di immagini create lo­cal­men­te in un Registry centrale è chiamato “push”. A tal fine Docker Compose mette a di­spo­si­zio­ne il comando docker-compose push: ese­gui­te­lo nella vostra directory di progetto.

Tutte le immagini elencate all’interno di docker-compose.yml che sono state create lo­cal­men­te vengono caricate sul Registry.

Se l’immagine del vostro stack è a di­spo­si­zio­ne at­tra­ver­so il Registry Service locale, l’ap­pli­ca­zio­ne multipla può essere eseguita nel cluster.

5.1 Eseguire stack nel cluster: anche nel cluster potete eseguire degli stack con una semplice riga di comando. A questo scopo la piat­ta­for­ma di con­te­ni­to­re pre­di­spo­ne il seguente comando:

Eseguite il comando docker stack deploy su uno dei nodi manager del vostro sciame:

5.2 Ri­chia­ma­re lo status dello stack: Per ri­chia­ma­re lo status del vostro stack, uti­liz­za­te il seguente comando:

Docker vi fornisce gli ID, i nomi, le modalità, le repliche, le immagini e le porte di tutti i servizi eseguiti all’interno del vostro stack.

5.3 Testare l’app con cURL: Per testare un’app multi-con­te­ni­to­re, ri­chia­ma­te­la at­tra­ver­so l’indirizzo host locale alla porta 8000.

5.4 Di­sat­ti­va­re uno stack: Se volete di­sat­ti­va­re il vostro stack, uti­liz­za­te il comando docker stack rm in com­bi­na­zio­ne con il nome dello stack.

5.5 Di­sat­ti­va­re il Registry-Service: Se de­si­de­ra­te di­sat­ti­va­re il Registry Service, uti­liz­za­te il comando docker service rm con il nome del servizio (qui: registry).