Come installare e configurare MySQL in Docker

Per quanto riguarda l'uso di MySQL all'interno di container Docker, beh, è un connubio fatto tra le nuvole. Se hai già lavorato con Docker, tutti i suoi vantaggi valgono anche per i container MySQL:

• Isolamento e coerenza: l'istanza MySQL sarà isolata da altro software e dipendenze, prevenendo potenziali conflitti
• Controllo delle versioni: Docker ti consente di versionare l'intero stack software insieme a MySQL. Questo significa poter riprodurre l'ambiente in qualsiasi momento, facilitando sviluppo e test.
• Scalabilità e gestione delle risorse: con Docker puoi scalare la tua applicazione MySQL assegnando facilmente più risorse come memoria o CPU.
• Gestione delle dipendenze: Docker incapsula la tua istanza MySQL, permettendoti di gestirne versioni diverse senza toccare nulla sulla tua macchina locale.

Soprattutto, la tua applicazione MySQL funzionerà ovunque, non solo sul tuo computer.

Se vuoi confrontare MySQL con il suo secondo concorrente più popolare, dai un'occhiata al nostro confronto approfondito PostgreSQL vs. MySQL.

Oggi imparerai le basi per eseguire MySQL assieme a Docker. Iniziamo!

Prerequisiti

Poiché questo articolo si concentra sui container Docker di MySQL, ci sono alcuni prerequisiti per seguirlo al meglio:

• Accesso alla riga di comando/terminale: ti serve un ambiente locale con accesso al terminale. Se sei in un ambiente Jupyter come Colab, passa ora a un terminale.
• Un'istanza Docker in esecuzione: dovresti avere già installato Docker Desktop (istruzioni nel nostro tutorial Docker per la Data Science). Quando è completamente operativo, in basso a sinistra dell'interfaccia vedrai una balenottera verde:

e il comando docker --help funziona senza errori nel terminale.

• Familiarità di base con Docker: anche se spiegherò tutti i comandi usati nell'articolo, una comprensione di base di Docker aumenterà notevolmente i benefici che potrai trarre da questa lettura.
• SQL: lo stesso vale per SQL — non spiegherò i comandi SQL usati qui, perché ci allontanerebbe dall'argomento principale. Se le tue competenze SQL sono un po' arrugginite, puoi ripassare gli argomenti più importanti in questo corso SQL.

Download dell'immagine Docker ufficiale di MySQL

Inizieremo scaricando l'immagine Docker ufficiale di MySQL con il seguente comando:

$ docker pull mysql:latestOfferto da

docker pull richiede il nome e la versione dell'immagine con la sintassi image:version. Usando la parola chiave latest scarichi l'ultima release stabile.

Se visiti la pagina dell'immagine ufficiale di MySQL su Docker Hub, puoi vedere molte altre versioni per scopi diversi.

Ecco come scaricare, per esempio, la v8.2:

$ docker pull mysql:8.2Offerto da

Una volta scaricata l'immagine, dovrebbe comparire tra le immagini Docker esistenti:

Elencare le immagini Docker è possibile anche dal terminale:

$ docker imagesOfferto da

Ricorda: le immagini Docker sono blueprint per costruire container. Proprio come un progetto consente di costruire una casa, un'immagine Docker contiene tutte le istruzioni e i componenti necessari per creare un'istanza in esecuzione di un'applicazione o servizio.

Se vieni da un background OOP, pensa alle immagini Docker come a classi. Così come da una singola classe puoi creare più oggetti, dalle immagini Docker puoi creare più container.

Esecuzione e gestione di un container server MySQL

Ora creiamo il nostro primo container dall'immagine mysql. Ecco il comando che useremo:

$ docker run --name test-mysql -e MYSQL_ROOT_PASSWORD=strong_password -d mysql
Offerto da

• run: crea un nuovo container o ne avvia uno esistente
• --name CONTAINER_NAME: assegna un nome al container. Il nome dovrebbe essere leggibile e breve. Nel nostro caso, il nome è test-mysql.
• -e ENV_VARIABLE=value: il flag -e crea una variabile d'ambiente accessibile all'interno del container. È fondamentale impostare MYSQL_ROOT_PASSWORD così da poter eseguire comandi SQL dal container. Assicurati di conservare la tua password robusta in un posto sicuro (non nel cervello).
• -d: abbreviazione di detached, il flag -d fa girare il container in background. Se lo rimuovi, il comando continuerà a stampare log finché il container non si ferma.
• image_name: l'argomento finale è il nome dell'immagine da cui verrà costruito il container. In questo caso, la nostra immagine è mysql.

Se il comando restituisce una lunga stringa incomprensibile (l'ID del container), significa che il container è stato avviato. Puoi verificarne lo stato con docker ps:

Ricorda: un container Docker è un potente emulatore di sistema operativo. Oltre a eseguire MySQL, puoi svolgere qualsiasi attività che normalmente faresti con il terminale del tuo computer, dall'interno del container.

Per accedere al terminale dentro il tuo container, puoi usare il seguente comando:

$ docker exec -it container_name bashOfferto da

Questo avvierà una sessione bash.

Connessione locale al container server MySQL

Tutti i container MySQL avviano un server MySQL che include tutto il necessario per creare e gestire database usando SQL. Per connetterci al server, i container includono anche un client MySQL che ci permette di eseguire query SQL. Il client è solo un nome altisonante per il comando da terminale mysql. Usiamolo nel terminale di test-mysql:

1. Apri il terminale bash di test-mysql:

$ docker exec -it test-mysql bashOfferto da

2. Connettiti al client come utente root:

$ mysql -u root -p
Enter password: ...
mysql>
Offerto da

Stiamo usando il flag -u per specificare l'username (root) e aggiungendo il flag -p per inserire la password quando richiesto.

È possibile connettersi al server MySQL anche dall'esterno del container. Ad esempio, per connetterti dalla macchina host, puoi installare manualmente il client MySQL nel tuo sistema.

Per installare MySQL e il suo client su Windows, puoi seguire le istruzioni dalla guida ufficiale all'installazione di MySQL.

Su Mac, puoi usare Homebrew:

$ brew install mysqlOfferto da

Su Linux o WSL2 (la mia scelta), puoi usare sudo:

$ sudo apt update
$ sudo apt install mysql-client
Offerto da

Dopo l'installazione, se il container è in esecuzione, fermalo e rimuovilo:

$ docker stop test-mysql
test-mysql
$ docker rm test-mysql
Offerto da

Successivamente, riavvieremo il container mappando una porta del container a una porta sulla nostra macchina locale:

$ docker run -d --name test-mysql -e MYSQL_ROOT_PASSWORD=strong_password -p 3307:3306 mysqlOfferto da

Questo comando fa quanto segue:

• -p 3307:3306: mappa la porta 3306 del container (la porta predefinita di MySQL) alla tua porta locale 3307. Ciò significa che qualsiasi traffico inviato alla tua porta locale 3307 verrà inoltrato alla porta 3306 del container e il tuo server MySQL sarà accessibile su quella porta.
• -d: esegue nuovamente il container in modalità detached.
• --name test-mysql: riutilizza lo stesso nome di container "test-mysql".
• -e MYSQL_ROOT_PASSWORD=strong_password: imposta nuovamente la password di root per il server MySQL.
• mysql: specifica l'immagine Docker da eseguire, ovvero l'immagine ufficiale MySQL.

Dopo che il terminale restituisce un nuovo ID per il container, possiamo verificare il mapping delle porte:

$ docker port test-mysql
3306/tcp -> 0.0.0.0:3307
Offerto da

È andato a buon fine! Ora, dalla tua macchina locale, puoi connetterti al server sulla porta 3307 usando il client mysql:

$ mysql --host=127.0.0.1 --port=3307 -u root -p
Enter password:

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.2.0 MySQL Community Server - GPL

Copyright (c) 2000, 2023, Oracle and/or its affiliates…
Offerto da

Configurare il container MySQL

Puoi configurare i container MySQL per una miriade di impostazioni usando un file di configurazione. Di solito, il file viene archiviato in una delle seguenti directory del container:

• /etc/mysql/
• /etc/mysql/conf.d
• /etc/mysql/mysql.conf.d

Le directory cambiano da immagine a immagine. Ma il nome e l'estensione standard per un file di configurazione è my.cnf. Se il file non esiste in nessuna delle directory elencate sopra, significa che il container richiede un file di configurazione personalizzato. È il caso del nostro container test-mysql:

$ ls /etc/mysql/conf.d/ # Returns no outputOfferto da

In situazioni come queste, dobbiamo seguire con attenzione i passaggi seguenti:

1. Arresta e rimuovi il container:

$ docker stop test-mysql; docker rm test-mysql
Offerto da

2. Crea un file di configurazione vuoto in locale (sulla tua macchina):

$ sudo mkdir -p /etc/docker/test-mysql # Create a dir
$ sudo touch /etc/docker/test-mysql/my.cnf # Create a config file inside dir
Offerto da

3. Riavvia il container collegando i due file .cnf vuoti:

$ docker run \
   --name test-mysql \
   -v /etc/docker/test-mysql:/etc/mysql/conf.d \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -d mysql
Offerto da

Stiamo usando un nuovo flag: -v, abbreviazione di volume. Il flag può essere usato per collegare directory tra il container e la macchina locale. In gergo informatico, questo processo si chiama mount.

Quindi, nel comando sopra, stiamo montando la directory locale /etc/docker/test-mysql nella directory /etc/mysql/conf.d del container. Questo collegherà i contenuti di entrambe le directory. Qualsiasi modifica apportata in una delle due si rifletterà in entrambe.

Il mount ci consente di modificare il file my.cnf sulla nostra macchina locale per cambiare le configurazioni dei container Docker. E la parte migliore è che le configurazioni modificate persisteranno sulla nostra macchina locale anche dopo che il container è stato arrestato o rimosso. Saranno riutilizzabili.

Dunque, dopo questo passaggio, che tipo di configurazioni possiamo cambiare? La risposta dipende dal tuo caso d'uso. Le vedremo qui sotto.

Ti piacerebbe ottenere una certificazione Docker? Dai un'occhiata alla nostra guida per conseguire una certificazione Docker!

Quali opzioni dovresti configurare?

Sebbene la configurazione predefinita dei container Docker di MySQL funzioni in molti scenari comuni, dovresti modificare alcune impostazioni per ottimizzare prestazioni, sicurezza e utilizzo delle risorse. Ecco alcune delle opzioni di configurazione più spesso cambiate:

Prestazioni

• innodb_buffer_pool_size: questa impostazione determina la quantità di memoria assegnata all'InnoDB buffer pool, che mette in cache i dati usati di frequente per un recupero più rapido. Aumentare questo valore può migliorare le prestazioni per carichi di lavoro con molte letture, ma consuma più memoria.
• query_cache_size: questa impostazione controlla la dimensione della query cache, che memorizza le query eseguite in precedenza per una riesecuzione più veloce. Aumentarne il valore può migliorare le prestazioni per query ripetitive, ma consuma più memoria e potrebbe non essere efficace per query dinamiche.
• thread_pool_size: questa impostazione determina il numero massimo di connessioni concorrenti che il server può gestire. Regolarla in base al carico di traffico previsto può ottimizzare l'utilizzo delle risorse e prevenire colli di bottiglia.

Sicurezza

• bind-address: questa opzione limita il server MySQL ad ascoltare solo su specifiche interfacce di rete, limitando l'accesso da fonti non autorizzate.
• mysql_bind_host: questa impostazione consente di associare il server MySQL a indirizzi IP specifici invece di ascoltare su tutte le interfacce.
• validate_password_policy: questa opzione abilita requisiti di password più rigorosi per una sicurezza migliorata.

Utilizzo delle risorse

• max_connections: controlla il numero massimo di connessioni concorrenti consentite. Regolare questo valore può prevenire l'esaurimento delle risorse e garantire un funzionamento efficiente del server.
• innodb_file_per_table: memorizza ogni tabella InnoDB in un file separato, potenzialmente migliorando le prestazioni ma aumentando lo spazio di archiviazione richiesto.
• innodb_io_capacity: imposta gli IOPS (Input/Output Operations Per Second) stimati per il sistema di storage, consentendo al motore di ottimizzare l'uso del buffer pool e le operazioni su disco.

Altre modifiche comuni

• character_set_server: imposta il set di caratteri predefinito per il server, garantendo una codifica e una gestione coerenti dei dati.
• collation_server: determina le regole di collazione predefinite usate per l'ordinamento e il confronto dei dati testuali.
• log_bin: abilita il logging binario dell'attività del server, utile per la risoluzione dei problemi e la replica.

Per vedere l'elenco completo delle opzioni di configurazione, puoi eseguire il seguente comando:

$ docker run -it --rm mysql:tag --verbose --helpOfferto da

Puoi modificare il file .cnf con qualsiasi editor di testo. Ecco la sintassi da seguire:

[mysqld]
max_connections=200
other_params=value
...
Offerto da

Come preservare i dati archiviati nel container Docker di MySQL

Rendere persistenti i dati archiviati nei tuoi container MySQL è fondamentale per molte ragioni:

• Persistenza dei dati: quando fermi o rimuovi un container, tutti i dati vanno persi, incluso il tuo database. Disaccoppiare i dati dal container li rende sempre accessibili.
• Condivisione dei dati tra container: separare i dati dal container consente a più container di accedervi. In questo modo eviti duplicazioni e semplifichi la sincronizzazione tra progetti che usano gli stessi dati.
• Portabilità e backup: i dati persistenti possono essere facilmente sottoposti a backup e condivisi in modo indipendente, offrendo un metodo affidabile per recuperare da perdite o cancellazioni accidentali.
• Migliori prestazioni e scalabilità: archiviando i dati a cui si accede spesso su storage persistente come SSD, puoi migliorare le prestazioni della tua applicazione rispetto all'affidarti al layer scrivibile del container, in genere più lento.

Il processo è lo stesso che abbiamo già visto — creeremo un volume e lo monteremo dove sono archiviati i dati nel nostro container. Ecco i passaggi:

1. Crea un volume:

$ docker volume create test-mysql-dataOfferto da

Il comando volume create crea uno storage dedicato sul file system locale per il volume. Dopo il mount del volume, tutti i dati del container verranno collegati a esso.

2. Riavvia il container con il volume montato:

$ docker stop test-mysql; docker rm test-mysql
$ docker run \
   --name test-mysql \
   -v test-mysql-data:/var/lib/mysql \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -d mysql
Offerto da

Questa volta, la sintassi è nel formato: -v volume_name:directory_in_container. Tutti i volumi creati dovrebbero essere montati sulla directory /var/lib/mysql come specificato nella documentazione dell'immagine MySQL.

Ora, quindi, qualsiasi database o tabella creato all'interno di test-mysql persisterà in locale, anche dopo l'arresto o la rimozione del container.

Il comando finale

Nel corso dell'articolo, il nostro comando docker run si è evoluto notevolmente. Quindi, mettiamo insieme tutte le sue varianti in un unico comando finale. Dobbiamo di nuovo fermare e rimuovere il container. Rimuoveremo anche il volume per ripartire da zero:

$ docker stop test-mysql; docker rm test-mysql
$ docker volume rm test-mysql-data
Offerto da

Ecco quindi il comando master finale:

$ docker run \
   --name final-mysql \
   -e MYSQL_ROOT_PASSWORD=strong_password \
   -p 3307:3306 \
   -v /etc/docker/test-mysql:/etc/mysql/conf.d \
   -v final-mysql-data:/var/lib/mysql \
   -d mysql
Offerto da

Questo comando monta il nostro precedente file locale my.cnf nella posizione desiderata e crea anche un nuovo volume chiamato final-mysql-data montandolo.

Gestire configurazioni MySQL complesse con Docker Compose

Per configurazioni più avanzate che coinvolgono più container, ad esempio l'esecuzione di MySQL insieme ad altri servizi (ad es. server web o backend applicativi), Docker Compose semplifica il processo consentendoti di definire e gestire applicazioni multi-container con un unico file di configurazione.

Ecco un esempio di base di file docker-compose.yml per un container MySQL:

version: '3.9'
services:
  db:
    image: mysql:8.3.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: strong_password
      MYSQL_DATABASE: example_db
      MYSQL_USER: user
      MYSQL_PASSWORD: user_password
    ports:
      - "3306:3306"
    volumes:
      - db_data:/var/lib/mysql
      - ./mysql-config:/etc/mysql/conf.d
volumes:
  db_data:Offerto da

Passaggi per usare Docker Compose:

• Crea un file docker-compose.yml: salva il file di configurazione nella directory del tuo progetto.
• Avvia i servizi: esegui il seguente comando per avviare tutti i servizi definiti nel file:

docker-compose up -dOfferto da

• Arresta i servizi: spegni i servizi quando hai finito:

docker-compose down
Offerto da

Vantaggi di Docker Compose per MySQL:

• Configurazione semplificata: gestisci configurazioni, porte e volumi di MySQL in un unico file.
• Scalabilità più semplice: scala facilmente il database o integralo con altri servizi nel tuo stack applicativo.
• Dati persistenti: gestisci automaticamente i volumi per la persistenza dei dati tra i riavvii dei container.

Usare Docker Compose è particolarmente utile per gestire più ambienti (ad es. sviluppo, staging e produzione) o quando si collabora in team.

Conclusione

Questo articolo ha trattato gli aspetti essenziali dell'esecuzione e gestione di database MySQL all'interno di container Docker. Abbiamo visto come scaricare e configurare le immagini MySQL, avviare server MySQL nei container, come modificare tali container e aggiungere volumi per configurazioni personalizzate e persistenza dei dati.

Per approfondire l'argomento, ti consiglio le seguenti risorse:

• Introduzione a Docker per la data science
• Corso Introduzione a Docker
• Containerizzazione con Docker e Kubernetes per il machine learning
• Documentazione dell'immagine MySQL su Docker
• Manuale di riferimento MySQL

Grazie per la lettura!