Docker Compose: semplificare il lavoro con Makefile

Ogni pochi anni, nell'industria dello sviluppo software, si verifica un cambiamento di paradigma. Un fenomeno di questo tipo è l'aumento dell'interesse per il concetto di microservizi. Sebbene i microservizi non siano una tecnologia nuovissima, la loro popolarità è letteralmente esplosa solo di recente.

I grandi servizi monolitici vengono sostituiti da microservizi autonomi e indipendenti. Un microservizio può essere considerato un'applicazione che serve a un singolo scopo molto specifico. Ad esempio, potrebbe essere un RDBMS, un'applicazione Express o un servizio Solr.

Oggi è difficile immaginare lo sviluppo di un nuovo sistema software senza l'uso di microservizi. Questa situazione ci porta all'idea della piattaforma Docker.

Docker

Piattaforma Docker, nel contesto dello sviluppo e del deployment di microservizi, è diventata praticamente uno standard industriale. Sul sito del progetto si può scoprire che Docker è l'unica piattaforma indipendente di containerizzazione che permette alle organizzazioni di creare facilmente qualsiasi applicazione e distribuirla e lanciarla in qualsiasi ambiente, dai cloud ibridi ai sistemi edge.

Docker Compose

Tecnologia Docker Compose è progettato per configurare applicazioni multi-contenitore. Un progetto Docker Compose può includere quanti più contenitori Docker desidera il creatore di quel progetto.

Lavorando con Docker Compose, per configurare i servizi dell'applicazione e organizzare la loro interazione si utilizza un file YAML. Docker Compose è, quindi, uno strumento per descrivere e avviare applicazioni Docker multi-contenitore.

Due contenitori che operano su un sistema host

GNU Make

Programma make, in sostanza, è uno strumento per automatizzare la compilazione di programmi e librerie a partire dal codice sorgente. In generale, si può affermare che make è applicabile a qualsiasi processo che comporti l'esecuzione di comandi arbitrari per trasformare materiali di partenza in una certa forma finale, verso un certo obiettivo. Nel nostro caso, i comandi docker-compose saranno trasformati in obiettivi astratti (Obiettivi fittizi).

Per comunicare al programma make cosa ci aspettiamo da esso, avremo bisogno di un file Makefile.

Nel nostro Makefile che conterrà comandi normali docker e docker-compose, progettati per risolvere molteplici compiti. In particolare, si tratta della creazione di un contenitore, del suo avvio, arresto, riavvio, dell'organizzazione dell'accesso dell'utente al contenitore, del lavoro con i log del contenitore e della risoluzione di altre attività simili.

Usi tipici di Docker Compose

Immaginiamo un'applicazione web comune, che presenta i seguenti componenti:

• Database TimescaleDB (Postgres).
• Applicazione Express.js.
• Ping (un semplice contenitore che non fa nulla di speciale).

A questa applicazione serviranno 3 contenitori Docker e un file docker-compose, contenente istruzioni su come gestire questi contenitori. Ciascuno dei contenitori avrà diversi punti di interazione. Ad esempio, con il contenitore timescale , sarà possibile interagire all'incirca come si fa con i database. In particolare, consente di eseguire le seguenti operazioni:

• Accesso alla shell di Postgres.
• Importazione ed esportazione di tabelle.
• Creazione pg_dump tabelle o database.

Contenitore dell'applicazione Express.js, expressjs, può possedere le seguenti funzionalità:

• Fornitura di dati freschi dal registro di sistema.
• Accesso alla shell per eseguire determinati comandi.

Interazione con i contenitori

Dopo aver configurato la connessione tra i contenitori utilizzando Docker Compose, è tempo di stabilire interazioni con questi contenitori. Nel sistema Docker Compose esiste un comando docker-compose, che supporta l'opzione -f, che consente di passare al sistema un file docker-compose.yml.

Utilizzando le capacità di questa opzione, è possibile limitare l'interazione con il sistema solo ai contenitori menzionati nel file docker-compose.yml.

Diamo un'occhiata a come si vedono le interazioni con i contenitori utilizzando i comandi docker-compose. Se immaginiamo di aver bisogno di accedere alla shell psql, i comandi corrispondenti potrebbero apparire così:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres

Lo stesso comando, per il quale non si utilizza docker-compose, ma docker, potrebbe apparire così:

docker exec -it edp_timescale_1 psql -Upostgres

Si noti che in tali casi è sempre preferibile usare non il comando docker, ma il comando docker-compose, poiché consente di eliminare la necessità di ricordare i nomi dei contenitori.

Entrambi i comandi sopra indicati non sono affatto complessi. Ma se avessimo utilizzato un "wrapper" sotto forma di Makefile, che ci darebbe un'interfaccia sotto forma di comandi semplici e richiamerebbe automaticamente comandi lunghi simili, si potrebbero ottenere risultati simili in questo modo:

make db-shell

È assolutamente chiaro che l'uso di Makefile semplifica notevolmente il lavoro con i container!

Esempio funzionante

Basandoci sullo schema di progetto esaminato sopra, creiamo il seguente file docker-compose.yml:

version: '3.3'
services:
    api:
        build: .
        image: mywebimage:0.0.1
        ports:
            - 8080:8080
        volumes:
            - /app/node_modules/
        depends_on:
            - timescale
        command: npm run dev
        networks:
            - webappnetwork
    timescale:
        image: timescale/timescaledb-postgis:latest-pg11
        environment:
          - POSTGRES_USER=postgres
          - POSTGRES_PASSWORD=postgres
        command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]
        volumes:
          - ./create_schema.sql:/docker-entrypoint-initdb.d/create_schema.sql
        networks:
           - webappnetwork
    ping:
       image: willfarrell/ping
       environment:
           HOSTNAME: "localhost"
           TIMEOUT: 300
networks:
   webappnetwork:
       driver: bridge

Per gestire la configurazione di Docker Compose e interagire con i container che essa descrive, creiamo il seguente file Makefile:

THIS_FILE := $(lastword $(MAKEFILE_LIST))
.PHONY: help build up start down destroy stop restart logs logs-api ps login-timescale login-api db-shell
help:
        make -pRrq -f $(THIS_FILE) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'
build:
        docker-compose -f docker-compose.yml build $(c)
up:
        docker-compose -f docker-compose.yml up -d $(c)
start:
        docker-compose -f docker-compose.yml start $(c)
down:
        docker-compose -f docker-compose.yml down $(c)
destroy:
        docker-compose -f docker-compose.yml down -v $(c)
stop:
        docker-compose -f docker-compose.yml stop $(c)
restart:
        docker-compose -f docker-compose.yml stop $(c)
        docker-compose -f docker-compose.yml up -d $(c)
logs:
        docker-compose -f docker-compose.yml logs --tail=100 -f $(c)
logs-api:
        docker-compose -f docker-compose.yml logs --tail=100 -f api
ps:
        docker-compose -f docker-compose.yml ps
login-timescale:
        docker-compose -f docker-compose.yml exec timescale /bin/bash
login-api:
        docker-compose -f docker-compose.yml exec api /bin/bash
db-shell:
        docker-compose -f docker-compose.yml exec timescale psql -Upostgres

La maggior parte dei comandi descritti qui si applica a tutti i container, ma l'uso dell'opzione c= permette di limitare l'ambito del comando a un singolo container.

Una volta che Makefile Pronto, può essere utilizzato in questo modo:

• make help — restituisce un elenco di tutti i comandi disponibili per make.

Documentazione sui comandi disponibili

• make build — costruzione dell'immagine da Dockerfile. Nel nostro esempio abbiamo utilizzato immagini esistenti timescale e ping. Ma l'immagine api che vogliamo assemblare localmente. Questo è esattamente ciò che verrà fatto dopo aver eseguito questo comando.

Assemblaggio del contenitore Docker

• make start – avvia tutti i contenitori. Per avviare solo un contenitore, è possibile utilizzare un comando del tipo make start c=timescale.

Avvio del contenitore timescale

Avvio del contenitore ping

• make login-timescale – accesso alla sessione bash del contenitore timescale.

Accesso alla bash nel contenitore timescale

• make db-shell – accesso a psql in un contenitore timescale per eseguire query SQL sul database.

Avvio di psql nel contenitore timescaledb

• make stop – arresto dei contenitori.

Arresto del contenitore timescale

• make down – arresto e rimozione dei contenitori. Per rimuovere un contenitore specifico, è possibile utilizzare questo comando specificando il contenitore desiderato. Ad esempio – make down c=timescale o make down c=api.

Arresto e rimozione di tutti i contenitori

Conclusioni

Nonostante Docker Compose ci fornisca un ampio insieme di comandi per la gestione dei contenitori, a volte questi comandi diventano lunghi e quindi difficili da ricordare.

La metodologia di utilizzo Makefile ci ha aiutato a stabilire un'interazione rapida e semplice con i contenitori del file docker-compose.yml. Precisamente, si tratta di quanto segue:

• Lo sviluppatore interagisce solo con i contenitori del progetto descritti in docker-compose.yml, il funzionamento non è disturbato da altri contenitori in esecuzione.
• Nel caso in cui un certo comando venga dimenticato, è possibile eseguire il comando make help e ottenere assistenza sui comandi disponibili.
• Non è necessario ricordare lunghi elenchi di argomenti per eseguire azioni come ottenere nuove registrazioni del log o accedere al sistema. Ad esempio, un comando del tipo docker-compose -f docker-compose.yml exec timescale psql -Upostgres si trasforma in make db-shell.
• all'interno di ogni container per impostazione predefinita apparirà così: Makefile può, con la crescita del progetto, adattarsi in modo flessibile. Ad esempio, è facile aggiungere un comando per creare un backup del database o per eseguire qualsiasi altra azione.
• Se un grande team di sviluppatori utilizza lo stesso Makefile, questo organizza il lavoro collaborativo e riduce gli errori.

P.S. Nel nostro marketplace si ha un'immagine Docker, che si installa con un clic. Puoi verificare il funzionamento dei container su VPS. A tutti i nuovi clienti vengono forniti gratuitamente 3 giorni per la sperimentazione.

Gentili lettori! Come automatizzate il lavoro con Docker Compose?

Fonte: habr.com