Docker: l’orchestrazione di app multi-contenitore con Swarm e Compose
La redazione di IONOS
Con una piattaforma di contenitori Docker potete ripartire nel network applicazioni 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 conseguentemente il software centrale della piattaforma di contenitori.
Docker Swarm vi permette di scalare le applicazioni in contenitori, eseguendole in un numero qualsiasi di istanze su qualsiasi numero di nodi del vostro network. Se al contrario volete eseguire un’applicazione multi-contenitore in un cluster (operazione chiamata “stack” in Docker), potete ricorrere a Compose, un tool di Docker. Vi spieghiamo ora i concetti basilari dell’orchestrazione Docker con Swarm e Compose mostrandovi concretamente le implementazioni sulla base di esempi di codice.
Docker Swarm
Swarm, nato dagli stessi sviluppatori di Docker, raggruppa un qualsiasi numero di host docker in un unico cluster, permettendo la gestione centralizzata dei cluster e l’orchestrazione dei contenitori. Fino alla versione di Docker 1.11, Swarm doveva essere implementato come tool separato, mentre le versioni più recenti della piattaforma di contenitori supportano uno swarm mode nativo: così qualunque utente di Docker può usufruire del cluster manager installando Docker Engine.
Docker Swarm si basa su un’architettura master-slave. Ogni cluster di Docker (lo sciame) consta di almeno un nodo manager e di una quantità a piacere di nodi lavoratori (worker). Mentre lo swarm manager è responsabile per l’amministrazione del cluster e la delegazione di compiti, gli swarm worker prendono in carico l’esecuzione di unità lavorative (“tasks”). Inoltre le applicazioni del contenitore vengono suddivise come cosiddetti servizi (“services”) in un numero qualunque di account Docker.
Nella terminologia 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 contenitore su uno dei nodi del cluster. Quando create un servizio determinate su quale immagine di contenitore si basa e quindi quali comandi verranno eseguiti nel contenitore, 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 contenitore 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 disponibile nel cluster inizia un task per il relativo servizio. Se aggiungete un nuovo nodo al cluster, lo swarm manager gli assegna immediatamente un’attività del service globale. I service globali si prestano ad esempio ad applicazioni di monitoraggio o programmi antivirus.
Un campo centrale di applicazione di Docker Swarm è la ripartizione 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 distribuisce in modo intelligente le richieste in arrivo alle istanze dei server disponibili.
Docker Compose
Docker Compose vi permette di definire applicazioni multi-contenitore – le cosiddette “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 applicazioni.
Docker definisce gli stack come gruppi di servizi collegati che condividono dipendenze software e che sono orchestrati e scalati. Uno stack di Docker vi permette di definire diverse funzionalità di un’applicazione in un file centrale (il docker-compose.yml) e di iniziare da qui ad eseguirle insieme in un runtime environment isolato amministrandole in modo centralizzato.
Con alcuni sistemi operativi Compose va installato separatamente: se utilizzate la piattaforma di contenitori Docker nell’ambito delle installazioni desktop Docker per il Mac o Docker per Windows, Docker Compose è già contenuto nelle funzioni e lo stesso vale per Docker Toolbox, che è disponibile per i vecchi sistemi Mac o Windows; se invece utilizzate Docker con Linux o con Windows Server 2016, è necessaria un’installazione manuale del tool.
Installazioni di Compose con Linux
Per scaricare i file binari di Compose dal repository di GitHub, aprite il terminale ed eseguite il seguente comando:
sudo curl -L https://github.com/docker/compose/releases/download/1.18
.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-composeDate a tutti gli utenti il permesso di eseguire i file binari:
sudo chmod +x /usr/local/bin/docker-composeCon il comando seguente potete controllare se il tool è stato installato correttamente:
docker-compose -versionSe l’installazione è stata effettuata con successo, avrete come output del terminale il numero di versione del tool.
Installazione di Compose con Windows Server 2016 (solo Docker EE per Windows)
Avviate il PowerShell come amministratore e date il seguente comando per avviare il download dei file binari di Compose dal repository di GitHub:
Invoke-WebRequest
"https://github.com/docker/compose/releases/download/1.18.0/docker-compose-
Windows-x86_64.exe" -UseBasicParsing -OutFile
$Env:ProgramFiles\docker\docker-compose.exeAvviate i file eseguibili per installare Docker Compose.
Potete trovare maggiori informazioni sui tool di Docker come Swarm e Compose nel nostro articolo sull’ecosistema Docker.
Tutorial: Docker Swarm e Compose nell’applicazione
Per poter gestire app multi-contenitore 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 produzione di app multi-contenitore con Docker Compose e il deployment nel cluster saranno invece tema della seconda parte.
Nel nostro articolo sui fondamenti della piattaforma di contenitori trovate un’introduzione a Docker e una guida passo per passo all’installazione di Docker Engine con Linux.
Parte prima: Docker in modalità swarm
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 produzione di cluster Docker richiede tre passaggi:
- Preparare gli host Docker
- Inizializzare swarm
- Collegare gli host Docker nello sciame
In alternativa si può trasporre in swarm mode (sciamare) un singolo Docker Engine in un ambiente di sviluppo locale. In questi casi si parla di un single-node swarm.
Passo 1: Preparare gli host Docker
Per la preparazione di nodi Docker si consiglia di ricorrere al tool di provisioning Docker Machine, che facilita l’implementazione degli host Docker (chiamati anche “dockerized hosts”, host virtuali inclusivi di Docker Engine). Con Docker Machine si possono distribuire gli account per il vostro sciame su qualsiasi infrastruttura e gestirli da remoto. I plug-in del driver Docker Machine sono forniti da diverse piattaforme cloud. Ciò riduce lo sforzo di provisioning 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’infrastruttura di Digital Ocean, utilizzate il seguente codice:
$ docker-machine create --driver digitalocean --digitalocean-access-token xxxxx docker-sandboxPer AWS potete creare un host Docker (qui: aws-sandbox) con il seguente comando:
$ docker-machine create --driver amazonec2 --amazonec2-access-key AKI******* --amazonec2-secret-key 8T93C******* aws-sandboxI caratteri xxxxx e ****** fungono da metacarattere per token di accesso o chiavi che potete generare attraverso il vostro account cliente presso i rispettivi fornitori.
Passo 2: inizializzare Swarm
Dopo aver preparato il numero desiderato di host virtuali per il vostro sciame, potete amministrarli attraverso Docker Machine e raggrupparli in un cluster con Docker Swarm. Innanzitutto accedete al nodo che volete utilizzare come “swarm manager”. Docker Machine offre il seguente comando per costruire una connessione criptata SSH all’host Docker:
docker-machine ssh MACHINE-NAMESostituite il metacarattere MACHINE-NAME con il nome dell’host Docker a cui volete accedere.
Una volta effettuata la connessione al nodo desiderato, utilizzate il seguente comando per inizializzare uno sciame:
docker swarm init [OPTIONS]A seconda dell’opzione scelta (vedi documentazione), il comando docker swarm init definisce il nodo attualmente scelto come swarm manager e genera due token casuali: un token manager e un token worker.
Swarm initialized: current node (1ia0jlt0ylmnfofyfj2n71w0z) is now a manager.
To add a worker to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-6cng4m8lhlrdfuq9jgzznre1p \
10.0.2.15:2377
Per aggiungere un manager a questo swarm, invece, date il comando
docker swarm join-token manager
e seguite le istruzioni.Il comando docker swarm init genera inoltre un output di terminale che comprende tutte le informazioni di cui avete bisogno per aggiungere altri account al vostro sciame.
Normalmente docker swarm init viene utilizzato con il flag --advertise-addr, che indica quale indirizzo IP debba essere utilizzato per gli accessi API e per l’overlay networking. Se l’indirizzo IP non dovesse essere indicato esplicitamente, Docker controllerà automaticamente a quale indirizzo IP è raggiungibile il sistema scelto selezionandolo direttamente. Se un nodo ha più di un indirizzo IP, occorre mettere il flag corrispondente. Salvo diversa indicazione, Docker utilizza la porta 2377.
Passo 3: collegare gli host Docker nello sciame
Dopo che avete inizializzato il vostro sciame con il nodo scelto come swarm manager, potete aggiungere una quantità di nodi manager o worker a piacere, utilizzando il comando docker swarm join in combinazione con il token corrispondente.
3.1 Come aggiungere un nodo worker: se volete aggiungere al vostro sciame un nodo worker, accedete attraverso docker-machine al nodo corrispondente ed eseguite il seguente comando:
docker swarm join [OPTIONS] HOST:PORTParte obbligatoria del comando docker swarm join è il flag --token, che contiene il token per l’accesso al cluster.
docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-6cng4m8lhlrdfuq9jgzznre1p \
10.0.2.15:2377Nell’esempio citato il comando contiene il token worker generato precedentemente nonché l’indirizzo IP presso il quale è disponibile lo swarm manager.
Se non avete sottomano il token corrispondente, lo potete individuare attraverso docker swarm join-token worker.
3.2 Come aggiungere un nodo master: se desiderate aggiungere al vostro sciame un ulteriore nodo manager, accertatevi innanzitutto del token manager. Eseguite inoltre il comando docker swarm join-token manager sull’account manager dove avete inizializzato lo sciame e seguite le indicazioni sul terminale.
Docker genera un token manager che può essere eseguito in combinazione 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.
$ sudo docker swarm join-token manager
To add a manager to this swarm, run the following command:
docker swarm join \
--token SWMTKN-1-511cy9taxx5w47n80vopivx6ii6cjpi71vfncqhcfcawxfcb14-ed2ct6pg5rc6vp8bj46t08d0i \
10.0.2.15:2377
3.3 Panoramica di tutti i nodi nello sciame: potete ottenere una panoramica su tutti i nodi collegati al vostro sciame eseguendo il comando di management docker node ls su uno dei vostri nodi manager.
ID HOSTNAME STATUS AVAILABILITY MANAGER
jhy7ur9hvzvwd4o1pl8veqms3 worker2 Ready Active
jukrzzii3azdnub9jia04onc5 worker1 Ready Active
1ia0jlt0ylmnfofyfj2n71w0z * osboxes Ready Active LeaderI nodi manager sono indicati nella panoramica come Leader.
Se volete eliminare un nodo dal vostro sciame, potete loggarvi nell’host corrispondente ed eseguire il comando docker swarm leave. Se il nodo è uno swarm manager, dovete forzare l’attuazione del comando con il flag --force.
Parte seconda: eseguire app multi-contenitore nel cluster
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 mostreremo come utilizzare Docker Compose per definire i diversi servizi come app multi-contenitore compatte ed eseguirle nel cluster.
La preparazione di app multi-contenitore nel cluster consta di cinque passi:
- Creare un Docker Registry locale.
- Definire l’app multi-contenitore come stack.
- Testare l’app multi-contenitore con Compose.
- Caricare l’immagine nel Registry.
- Eseguire lo stack nel cluster.
Passo 1: avviare un Docker Registry locale come servizio
Poiché uno sciame Docker consiste di un numero a piacere di Docker Engines, le applicazioni si possono gestire nel cluster soltanto se tutti i Docker Engines che partecipano hanno accesso all’immagine dell’applicazione. Per questo serve un Registry, ovvero un servizio centrale che vi permetta di amministrare le images e di metterle a disposizione nel cluster.
Una “image” è un’immagine compatta ed eseguibile di un’applicazione e contiene, oltre al codice di applicazione, tutte le dipendenze (ambiente runtime, librerie, variabili di ambiente e file di configurazione) di cui Docker necessita per eseguire le rispettive applicazioni come contenitore. In questo modo ogni contenitore è un’istanza di runtime di un’immagine.
1.1 Avviare Registry come service nel cluster: Per avviare un Registry Server locale come servizio nel cluster, utilizzate il comando docker service create:
docker service create --name registry --publish 5000:5000 registry:2Il comando assegna a Docker il compito di avviare un servizio con il nome registry che ascolta alla porta 5000. Il primo valore dopo il flag --publish indica la porta host, il secondo la porta del contenitore. Il servizio è basato sull’image registry:2, che contiene un’implementazione del Docker Registry http API V2 e può essere ottenuto liberamente tramite il Docker Hub.
1.2 Verificare lo status del Registry Service: Per esaminare lo status del Registry Service appena avviato, utilizzate il comando docker service ls
$ sudo docker service ls
ID NAME MODE REPLICAS IMAGE PORTS
K2hq2ivnwuq4 registry replicated 1/1 registry:2 *:5000->5000/tcpIl comando docker service ls vi fornisce una lista di tutti i servizi in corso nel vostro cluster Docker.
1.3 Verificare la connessione al Registry con cURL: Assicuratevi di poter accedere al vostro Registry via cURL. Per farlo, eseguite il seguente comando:
$ curl http://localhost:5000/v2/Se il vostro Registry funziona come previsto, il cURL dovrebbe fornire il seguente output:
{}Il cURL è un’interfaccia a riga di comando con la quale si possono richiamare indirizzi web e caricare o scaricare file. Sul sito del software open source potete trovare maggiori informazioni sul cURL: curl.haxx.se
Passo 2: creare app multi-contenitore e definirle come stack
Nel passo successivo create tutti i file che sono necessari per il deployment di uno stack nel cluster di Docker e posizionateli 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.
$ mkdir stackdemoNavigate nella directory del vostro progetto.
$ cd stackdemoLa vostra directory di progetto funge da cartella di raccolta per tutti i file necessari per eseguire la vostra app multi-contenitore; questi includono un file con il codice sorgente dell'applicazione, ossia un file di testo in cui si definisce il software necessario per il funzionamento dell'applicazione, così come un file Docker e un file Compose.
2.2 Creare la app: Create un’applicazione Python con il seguente contenuto e posizionatela sotto il nome app.py nella directory di progetto.
from flask import Flask
from redis import Redis
app = Flask(__name__)
redis = Redis(host='redis', port=6379)
@app.route('/')
def hello():
count = redis.incr('hits')
return 'Hello World! I have been seen {} times.\n'.format(count)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000, debug=True)L’applicazione di esempio app.py è una semplice applicazione web con una pagina iniziale che dice “Hello World!” e include un’indicazione su quante volte l’app è stata richiamata. 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 requirements.txt con il contenuto seguente e collocatelo nella directory del progetto.
flask
redisIn requirements.txt definite su quale software si basa la vostra applicazione.
2.4 Creare un file Docker: Create un altro file di testo con il nome Dockerfile, inserite il seguente contenuto e collocate anche questo file nella cartella di progetto.
FROM python:3.4-alpine
ADD . /code
WORKDIR /code
RUN pip install -r requirements.txt
CMD ["python", "app.py"]Il Dockerfile contiene tutte le istruzioni necessarie per creare un’immagine di applicazione. Per esempio il Dockerfile fa riferimento a requirements.txt, stabilendo in questo modo quale software installare per la gestione dell’applicazione.
Il Dockerfile dell’esempio permette di creare un’immagine dell’applicazione web app.py includendo tutti i requisiti (Flask e Redis).
2.5 Creare un file Compose: create un file di configurazione con il seguente contenuto e salvatelo come docker-compose.yml.
version: '3'
services:
web:
image: 127.0.0.1:5000/stackdemo
build: .
ports:
- "8000:8000"
redis:
image: redis:alpineIl docker-compose.yml permette di collegare tra di loro diversi servizi e di eseguirli insieme come unità, amministrandoli in modo centrale.
Il file Compose è scritto in YAML, un linguaggio di markup semplificato utilizzato per rappresentare i dati strutturati e utilizzato principalmente nei file di configurazione. Docker utilizza docker-compose.yml per configurare centralmente i servizi di un’applicazione multi-contenitore.
Nell’esempio preso in considerazione definiamo due servizi: un servizio web e uno Redis.
- Servizio web: Il fondamento del “web service” è un’immagine che viene prodotta sulla base del Dockerfile che avete creato nella directory stackdemo.
- Servizio Redis: Per i servizi Redis non utilizziamo immagini proprie: attingiamo invece ad una Redis Image disponibile pubblicamente (redis:alpine) e reperibile attraverso il Docker Hub.
Passo 3: testare l’app multi-contenitore con Compose
Per prima cosa testate localmente l’app multi-contenitore eseguendola sul vostro nodo manager.
3.1 Avviare la app: Per avviare il vostro stack utilizzate il comando docker-compose up in combinazione con il flag -d. Il flag attiva il “detached mode”, attraverso il quale tutti i contenitori vengono eseguiti in background. In questo modo il vostro terminale è pronto a ricevere altri comandi.
$ sudo docker-compose up -d
WARNING: The Docker Engine you're using is running in swarm mode.
Compose does not use swarm mode to deploy services to multiple nodes in a swarm. All containers will be scheduled on the current node.
To deploy your application across the swarm, use the bundle feature of the Docker experimental build.
More info:
https://docs.docker.com/compose/bundles
Creating network "stackdemo_default" with the default driver
Creating stackdemo_web_1
Creating stackdemo_redis_1
3.2 Controllare lo stato dello stack: Per verificare lo status del vostro stack eseguite il comando docker-compose ps. Visualizzerete un output di terminale simile al seguente esempio:
$ sudo docker-compose ps
Name Command State Ports
-------------------------------------------------------------------------
stackdemo_redis_ docker- Up 6379/tcp
1 entrypoint.sh
redis ...
stackdemo_web_1 python app.py Up 0.0.0.0:8000->80
00/tcpIl comando docker-compose ps vi fornisce una panoramica di tutti i contenitori che sono stati avviati nel contesto della vostra applicazione multi-contenitore: nell’esempio riportato la lista comprende due contenitori (uno per i servizi Redis e uno per quelli web).
3.3 Testare lo stack con cURL: Testate il vostro stack eseguendo l’interfaccia a riga di comando cURL con l’indirizzo host locale (localhost o 127.0.0.1).
$ curl http://localhost:8000
Hello World! I have been seen 1 times.
$ curl http://localhost:8000
Hello World! I have been seen 2 times.
$ curl http://localhost:8000
Hello World! I have been seen 3 times.
Alternativamente si può richiamare l’applicazione web nel browser.
3.4 Disattivare un’app: Se desiderate disattivare lo stack, eseguite il comando docker-compose down con il flag --volumes.
$ sudo docker-compose down --volumes
Stopping stackdemo_redis_1 ... done
Stopping stackdemo_web_1 ... done
Removing stackdemo_redis_1 ... done
Removing stackdemo_web_1 ... done
Removing network stackdemo_default
Passo 4: caricare un’immagine nel Registry
Prima di poter eseguire la vostra app multi-contenitore come applicazione ripartita nel cluster, dovete preparare tutte le immagini necessarie attraverso il Registry Service. Nell’esempio illustrato si tratta solamente delle immagini create autonomamente del web service (l’immagine Redis è a disposizione grazie a un Registry pubblico nel Docker Hub).
In Docker l’upload di immagini create localmente in un Registry centrale è chiamato “push”. A tal fine Docker Compose mette a disposizione il comando docker-compose push: eseguitelo nella vostra directory di progetto.
Tutte le immagini elencate all’interno di docker-compose.yml che sono state create localmente vengono caricate sul Registry.
$ sudo docker-compose push
Pushing web (127.0.0.1:5000/stackdemo:latest)...
The push refers to a repository [127.0.0.1:5000/stackdemo]
5b5a49501a76: Pushed
be44185ce609: Pushed
bd7330a79bcf: Pushed
c9fc143a069a: Pushed
011b303988d2: Pushed
latest: digest: sha256:a81840ebf5ac24b42c1c676cbda3b2cb144580ee347c07e1bc80e35e5ca76507 size: 1372Nell’esempio in considerazione docker-compose push carica l’immagine dello stack stackdemo con il tag latest nel Registry locale sotto 127.0.0.1:5000.
Passo 5: eseguire uno stack nel cluster.
Se l’immagine del vostro stack è a disposizione attraverso il Registry Service locale, l’applicazione 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 piattaforma di contenitore predispone il seguente comando:
docker stack deploy [OPTIONS] STACKAl posto del metacarattere STACK mettete il nome dell’immagine stack che volete eseguire.
Eseguite il comando docker stack deploy su uno dei nodi manager del vostro sciame:
$ sudo docker stack deploy --compose-file docker-compose.yml stackdemo
Ignoring unsupported options: build
Creating network stackdemo_default
Creating service stackdemo_web
Creating service stackdemo_redisIl flag --compose-file indica il percorso del file Compose.
5.2 Richiamare lo status dello stack: Per richiamare lo status del vostro stack, utilizzate il seguente comando:
docker stack services [OPTIONS] STACKDocker 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.
$ sudo docker stack services stackdemo
ID NAME MODE REPLICAS IMAGE PORTS
cxyp7srukffy stackdemo_web replicated 1/1 127.0.0.1:5000/stackdemo:latest *:8000->8000/tcp
z0i2rtjbrj9s stackdemo_redis replicated 1/1 redis:alpine
5.3 Testare l’app con cURL: Per testare un’app multi-contenitore, richiamatela attraverso l’indirizzo host locale alla porta 8000.
$ curl http://localhost:8000
Hello World! I have been seen 1 times.
$ curl http://localhost:8000
Hello World! I have been seen 2 times.
$ curl http://localhost:8000
Hello World! I have been seen 3 times.
In alternativa al cURL si può richiamare l’app attraverso il browser. Per farlo, utilizzate un indirizzo host locale o l’indirizzo di un nodo a piacere. Grazie alla rete interna di routing potete accedere a ogni nodo del vostro sciame alla porta 8000 per poi essere ricondotti alla vostra app.
5.4 Disattivare uno stack: Se volete disattivare il vostro stack, utilizzate il comando docker stack rm in combinazione con il nome dello stack.
$ docker stack rm stackdemo
Removing service stackdemo_web
Removing service stackdemo_redis
Removing network stackdemo_default
5.5 Disattivare il Registry-Service: Se desiderate disattivare il Registry Service, utilizzate il comando docker service rm con il nome del servizio (qui: registry).
$ docker service rm registry
Docker Swarm e Compose estendono le funzionalità principali della piattaforma di contenitori con dei tool che vi permettono di gestire con il minimo sforzo applicazioni complesse in sistemi distribuiti. Il leader di mercato nella virtualizzazione di contenitori offre agli utenti una soluzione completa per l’orchestrazione dei contenitori da un’unica fonte. Entrambi i tool sono dotati di una buona documentazione e aggiornati regolarmente. Swarm e Compose si attestano come un’alternativa valida a strumenti consolidati di terze parti come Kubernetes o Paramax.
