3.9 Utilizzo di Docker

Docker è una piattaforma open source provvista di una documentazione esauriente da leggere con attenzione.

3.9.1 Perché Docker?

Docker è una piattaforma basata su container che consente di sviluppare, distribuire ed eseguire applicazioni all'interno di un container. L'applicazione e tutte le dipendenze che richiede, ad esempio file binari, librerie e informazioni di configurazione, risiedono all'interno del container. È possibile distribuire più container, che vengono tutti eseguiti in Docker e nel sistema operativo.

Utilizzando Docker è possibile ridimensionare le applicazioni in verticale, vale a dire che in un server possono esistere più istanze del server di sessione e che ognuna di essere fornirà esattamente le stesse prestazioni di quando è stata creata e testata.

3.9.2 Quali sono i vantaggi?

L'utilizzo dei container offre diversi vantaggi:

  • Prestazioni

    Le macchine virtuali rappresentano un'alternativa ai container tuttavia, a differenza di esse, i container non includono un sistema operativo. Questo significa che i container sono più veloci da creare e avviare e hanno un footprint molto inferiore.

  • Flessibilità

    Poiché i container sono più portabili e forniscono prestazioni superiori, è possibile sfruttare procedure di sviluppo più flessibili e reattive.

  • Isolamento

    I container di Docker sono indipendenti l'uno dall'altro. Questo aspetto è importante perché un container di Docker che include un'applicazione, comprese le necessarie versioni di eventuale software di supporto, non interferisce con un altro container della stessa applicazione che richiede l'uso di software di supporto differente. È possibile avere la totale certezza che in ogni fase di sviluppo e distribuzione l'immagine creata sarà in grado di fornire esattamente le prestazioni previste.

  • Scalabilità

    Creare nuovi container è un'operazione rapida e semplice. Nella documentazione di Docker sono disponibili informazioni su come gestire più container.

3.9.3 Terminologia

Esistono termini di base con cui è necessario avere familiarità quando si utilizza Docker. Per ulteriori informazioni, vedere il sito della documentazione di Docker.

  • Container
  • Un'istanza runtime di un'immagine. Un container è in genere completamente isolato dall'ambiente host ed è grado di accedere alle porte e i file dell'host solo se è stato configurato per eseguire questa operazione. Per eseguire un'immagine in un container viene utilizzato il comando Run di Docker.
  • Hub di Docker
  • Una risorsa per la comunità basata sul cloud per l'utilizzo di Docker. L'hub di Docker viene generalmente utilizzato per l'hosting delle immagini, ma può essere utilizzato anche per l'autenticazione dell'utente e l'automatizzazione delle operazioni di creazione delle immagini. Qualsiasi utente può pubblicare le immagini nell'hub di Docker.
  • Docker Compose
  • Compose è uno strumento che utilizza file YAML per configurare i servizi dell'applicazione e quindi per definire ed eseguire applicazioni Docker con più container. Per ulteriori informazioni, visitare la pagina della documentazione di Docker Compose.
  • Dockerfile
  • Un documento di testo che contiene i comandi necessari per creare un'immagine Docker. È possibile specificare comandi complessi (ad esempio un'immagine esistente da utilizzare come base) o semplici (come la copia dei file da una directory a un'altra). Per creare un'immagine da un Dockerfile, è necessario utilizzare il comando Build di Docker.
  • Immagine
  • Un pacchetto eseguibile autonomo che viene eseguito in un container. Un'immagine Docker è un file binario che include tutto il necessario per eseguire un singolo container di Docker, inclusi i relativi metadati. È possibile creare immagini personali, mediante un Dockerfile, oppure utilizzare le immagini generate da altri utenti che sono state rese disponibili in un registro (ad esempio l'hub di Docker). Per creare un'immagine da un Dockerfile, è necessario utilizzare il comando Build di Docker. Per eseguire un'immagine in un container, è necessario utilizzare il comando Run di Docker.

3.9.4 Introduzione a Docker e a Host Access for the Cloud

Il pacchetto di installazione contiene un Dockerfile iniziale e il file jar dell'applicazione correlata, che consentono di iniziare a utilizzare il server di sessione nei container.

Alcuni esempi sono disponibili nella cartella docker/samples. Per istruzioni, vedere gli esempi su Docker Compose.

La creazione di un'immagine di base richiede il completamento di quattro passaggi:

  1. Installare Docker. Seguire le istruzioni disponibili sul sito Web.

  2. Estrarre il file del pacchetto di download e individuare Dockerfile,entrypoint.sh e sessionserver.jar nella cartella Docker.

  3. Creazione dell'immagine Docker

  4. Esecuzione dell'immagine Docker

Creazione dell'immagine Docker del server di sessione

Supponendo di aver seguito il primo e il secondo passaggio; installato Docker ed estratto e localizzato Dockerfile e sessionserver.jar, il passaggio successivo è quello di creare l'immagine Docker di base del server di sessione.

  1. Eseguire questo comando dalla cartella contenente il Dockerfile:

    docker build -t hacloud/sessionserver:<versione> .

    Sostituire <versione> con la versione del server di sessione. Se una versione non è disponibile, il tag predefinito (-t) è latest.

  2. Verificare che l'immagine sia stata creata correttamente. Eseguire:

    docker images

    L'output deve contenere le informazioni sull'immagine appena generata.

Esecuzione dell'immagine

Prima di poter eseguire l'immagine del server di sessione in un container di Docker, è necessario completare i seguenti passaggi:

Specificare l''indirizzo del server MSS

Per specificare l'ubicazione del server MSS, passare in una variabile di ambiente al server di sessione mediante il Docker. Ad esempio, --env MSS_SERVER=mss.server.com

Specificare la password di registro dei servizi

Per specificare la password di registro dei servizi, passare in una variabile di ambiente al server di sessione mediante il Docker. Ad esempio, --env SERVICE_REGISTRY_PASSWORD=<immettere password>.

È possibile recuperare la password dalla proprietà service.registry.password situata in ./mss/server/config/container.properties sul server MSS.

Indicare a MSS l'attendibilità del certificato di identità del server di sessione

È possibile completare questo passaggio utilizzando Administrative Console. Per aggiungere un certificato del server all'archivio attendibilità MSS, vedere la documentazione relativa ad Administrative Console di MSS.

Specificare l'archivio chiavi contenente il certificato di identità del server di sessione

Il server di sessione si identifica utilizzando un certificato. Il certificato dovrebbe essere presente nell'archivio chiavi Java /opt/sessionserver/etc/keystore.bcfks situato nel container.

Fornire l'archivio attendibilità contenente il certificato MSS

Quando il server di sessione effettua le connessioni TLS in uscita, verifica l'attendibilità dei server remoti, ad esempio MSS, mediante certificati nell'archivio attendibilità. I certificati presenti nell'archivio chiavi Java /opt/sessionserver/etc/trustcerts.bcfks situato nel container saranno considerati attendibili.

Mappare l'archivio chiavi e archivio attendibilità a quelli del container

Sono disponibili due opzioni che consentono di fornire tali archivi chiavi nel container:

Utilizzare un montaggio di volume

Un montaggio di volume consente di inserire un file o una directory presente nel computer host in un container. Al file o alla directory verrà fatto riferimento mediante il relativo percorso completo o relativo presente nel computer host.

Questo volume inserisce i file dell'archivio chiavi e dell'archivio attendibilità presenti sull'host nel container di Docker.

docker run --env MSS_SERVER=localhost \
--env SERVICE_REGISTRY_PASSWORD=<immettere password qui> \
--volume ~/demo_keystore.bcfks:/opt/sessionserver/etc/keystore.bcfks \
--volume ~/demo_truststore.bcfks:/opt/sessionserver/etc/trustcerts.bcfks \
--publish 7443:7443 \
sessionserver

C'è un lato negativo nell'utilizzare un montaggio di volume. Dal momento che gli archivi chiavi devono essere ubicati su ciascun host di Docker in cui è in esecuzione un container, il container di Docker non sarà molto portatile.

Estensione di un'immagine Docker esistente

Con questo metodo viene creato un nuovo Dockerfile per copiare i file necessari nell'immagine Docker. In questo modo è più portatile l'immagine di Docker.

Per prima cosa, è necessario creare un Dockerfile che venga esteso dall'immagine Docker hacloud/sessionserver.

FROM hacloud/sessionserver:<ad esempio hacloud/sessionserver:latest o hacloud/sessionserver:version>

COPY <il-proprio-percorso>/keystore.bcfks
/opt/sessionserver/etc/keystore.bcfks COPY <il-proprio-percorso>/truststore.bcfks /opt/sessionserver/etc/trustcerts.bcfks

A questo punto, creare il Dockerfile esteso, denominandolo demo.

docker build -t demo .

Infine, eseguire l'immagine demo.

docker run --env MSS_SERVER=localhost \
--env SERVICE_REGISTRY_PASSWORD=<immettere la password qui> \
--publish 7443:7443 \
demo

Specificare il nome e la porta dell'host di Docker

Il server di sessione deve trasmettere il nome host di MSS per trovarlo. Dato che Docker genera un nome univoco casuale che non è raggiungibile all'esterno del container, è necessario specificare il nome dell'host di Docker per MSS. È inoltre necessario indicare al server di sessione la porta che si sta pubblicando sull'host di Docker. I client che accedono al server di sessione finiscono per colpire <nome_host_docker>:<porta_pubblicata_docker>.

--env HOST_NAME=docker_host_name
--env SERVER_PORT=docker_published_port

3.9.5 Esempi

Gli esempi, disponibili nella cartella docker/samples, illustrano quattro scenari in cui è utilizzato Docker Compose. Compose è uno strumento che utilizza un file YAML per configurare ed eseguire le applicazioni con un singolo comando.

Prerequisiti

Per eseguire gli esempi, è necessario disporre di:

Gli esempi includono:

  • Esempio di base - Un esempio di base che fornisce file dimostrativi dell'archivio chiavi e dell'archivio attendibilità in cui è possibile importare un certificato del server MSS.

  • Esempio ibrido - Un esempio ibrido che presuppone l'esistenza di un'installazione Host Access for the Cloud locale e monta file dell'archivio chiavi e dell'archivio attendibilità esistenti su disco nel container di Docker.

  • Esempio di estensione - Un esempio di estensione che illustra come eseguire l'aggiornamento, la modifica e la personalizzazione del client Web.

  • Esempio su un sistema di bilanciamento del carico - Un esempio con un sistema di bilanciamento del carico che illustra come bilanciare il carico tra container collegati.

Esempio di base

In questo esempio di base viene illustrato come eseguire l'immagine di Docker del server di sessione di Docker Compose. Per questo esempio è necessario importare il certificato del server MSS nell'esempio fornito./certs/demo_truststore.bcfks utilizzando un elemento come KeyStore Explorer. Il certificato MSS, per default, si trova in /mss/server/etc/<nome-computer>.cer. Vedere Protezione delle connessioni.

Prima di eseguire l'esempio, aggiornare i valori MSS_SERVER, HOST_NAME e SERVICE_REGISTRY_PASSWORD in docker-compose.yml.

  • Per avviare il servizio del server di sessione, utilizzare il comando:

    docker-compose up

  • Per eseguire il servizio in un daemon, utilizzare il comando:

    docker-compose up -d

  • Per esaminare i container in esecuzione, utilizzare il comando:

    docker ps

Esempio ibrido

In questo esempio è presente un'installazione locale di Host Access for the Cloud, con file dell'archivio chiavi e dell'archivio attendibilità su disco. Questi file verranno montati, ossia copiati, nel container di Docker.

Prima di eseguire l'esempio, aggiornare i valori MSS_SERVER, HOST_NAME, SERVER_PORT e SERVICE_REGISTRY_PASSWORD nel file .env.

Per avviare il servizio di server di sessione, copiare.env e docker-compose.yml in sessionserver/microservices/sessionserver/, e da questa directory, eseguire: docker-compose up -d.

Esempio di estensione

Utilizzando le estensioni e il proprio codice HTML, CSS o JavaScript, è possibile aggiornare, modificare e personalizzare l'aspetto del client Web all'interno del browser. Per ulteriori informazioni, vedere Estensione del client Web.

In questo esempio SPRING_PROFILES_ACTIVE viene impostato su extensions-enabled e l'ubicazione delle estensioni viene mappata in docker-compose.yml.

Prima di eseguire l'esempio, aggiornare i valori MSS_SERVER, HOST_NAME e SERVICE_REGISTRY_PASSWORD nel file.env.

Per avviare il servizio del server di sessione, utilizzare il comando: 

docker-compose up -d

È anche possibile scegliere di estendere l'immagine di base di Docker hacloud/sessionserver e copiare i file di estensione nel container Docker:

  1. Creare il Dockerfile che si estende dall'immagine di Docker hacloud/sessionserver.

    FROM hacloud/sessionserver

COPY ./certs/keystore.bcfks /opt/sessionserver/etc/keystore.bcfks
COPY ./certs/trustcerts.bcfks /opt/sessionserver/etc/trustcerts.bcfks
COPY ./extensions /opt/sessionserver/extensions/

  2. Creare il Dockerfile esteso e denominarlo extensions.

    docker build -t extensions

  3. Aggiornare docker compose.yml affinché utilizzi la nuova immagine extensions 

    
version: '3'
services:
	sessionserver:
		image: extensions
		environment:
			- LOGGING_FILE=./logs/sessionserver.log
			- LOGGING_FILE_MAXSIZE=10MB
			- LOGGING_FILE_MAXHISTORY=10
			- MSS_SERVER=${MSS_SERVER}
			- SERVICE_REGISTRY_PASSWORD=${SERVICE_REGISTRY_PASSWORD}
			- SPRING_PROFILES_ACTIVE=extensions-enabled
		ports:
			- ${SERVER_PORT}:7443

Esempio su un sistema di bilanciamento del carico

HAProxy è un sistema di bilanciamento del carico. Ulteriori informazioni su HAProxy sono disponibili sul relativo sito Web.

In questo esempio il file docker compose.yml include un servizio haproxy. L'esempio utilizza un'immagine HAProxy per bilanciare il carico tra container collegati. In questo esempio, per collegare i container, viene utilizzato il bridging SSL

Per garantire una comunicazione sicura tra il client e il sistema di bilanciamento del carico, è necessario aggiornare la proprietà LOAD_BALANCER_CERT nel file .env con l'ubicazione del certificato del sistema di bilanciamento del carico.

Per fare una prova, è possibile generare un certificato firmato da se stessi:

  1. Generare una chiave privata univoca (KEY):

    sudo openssl genrsa -out mydomain.key 2048

  2. Generare una richiesta di firma del certificato (CRS).

    sudo openssl req -new -key mydomain.key -out mydomain.csr

  3. Creare un certificato firmato da se stessi (CRT):

    openssl x509 -req -days 365 -in mydomain.csr -signkey mydomain.key -out mydomain.crt

  4. Aggiungere KEY e CERT a loadbalancer.pem:

    sudo cat mydomain.key mydomain.crt > ./certs/loadbalancer.pem

Per avviare il server di sessione e i servizi haproxy, utilizzare il comando: 

docker-compose up -d

-oppure-

docker-compose up --scale sessionserver=n -d

In cui n è il numero delle istanze del server di sessione.

È possibile modificare il numero di istanze del server di sessione dopo l'avvio dei servizi:

docker-compose scale sessionserver=n

Per accedere alla pagina delle statistiche del server di sessione e HAProxy:

  • https://server:7443

  • http://server:1936/haproxy?stats

Utilizzo:

  • utente: amministratore

  • password: password