Introduzione
L'Integrazione Continua (CI) e la Distribuzione Continua (CD) sono tra gli argomenti più di tendenza nello sviluppo software attuale. Per ottenere l'aspetto CI/CD dell'architettura software, gli sviluppatori fanno uso dei container. I container sono ambienti leggeri, virtualizzati, portatili e definiti dal software. Nei container, il software può essere eseguito in isolamento rispetto ad altri software in esecuzione sulla macchina host fisica. Il focus di questo tutorial è sull'uso della piattaforma di container Docker per distribuire ed eseguire applicazioni web. Docker aiuta a snellire il processo di configurazione di uno stack di server web. In questo tutorial, useremo lo stack LEMP per servire un'applicazione Laravel.
Lo stack LEMP combina Linux come sistema operativo, Nginx come webserver, MySQL come database, e il linguaggio PHP per lo scripting e l'elaborazione dinamica. Puoi seguire il nostro tutorial su come installare e configurare uno stack LEMP su Ubuntu. Laravel è uno dei principali framework PHP per lo sviluppo di applicazioni web.
Docker fornisce uno strumento chiamato Docker Compose per definire il processo di configurazione di un container Docker. Docker Compose consente agli sviluppatori di definire l'infrastruttura della propria applicazione, servizi, volumi, reti e qualsiasi dipendenza in un unico file chiamato file docker-compose. Può gestire più container Docker attraverso i suoi comandi come docker container create, docker container run, ecc.
In questo tutorial imparerai come distribuire un'applicazione web Laravel con Nginx e MySQL all'interno di un container Docker. Le configurazioni per l'intero stack saranno definite all'interno di un file docker-compose, così come altri file di configurazione per PHP, MySQL e Nginx. Cominciamo!
Le prime cose importanti
- Trattandosi di un tutorial pratico, dovresti avere un'installazione di Ubuntu 20.04 come ambiente operativo iniziale. Dovresti anche avere un utente non-root con privilegi sudo. Ecco un tutorial passo-passo per aiutarti a configurare il tuo server Ubuntu.
- Devi installare Docker. Abbiamo un tutorial su come installare e utilizzare Docker su Ubuntu 18.04.
- Devi installare Docker Compose seguendo il tutorial della documentazione ufficiale di Docker.
Passo 1: Scaricare Laravel e installare le dipendenze
Il primo passo consiste nell'ottenere il codice Laravel da un repository. Negli scenari reali potresti avere il tuo codice Laravel in un repository da qualche parte, ad esempio su GitHub, Bitbucket, Gitlab, ecc. Tuttavia, ai fini di questo tutorial, cloneremo l'ultima versione dal repository ufficiale di Laravel su GitHub. Il repository include un file composer, un gestore delle dipendenze a livello di applicazione per PHP. Poiché vogliamo che tutto venga eseguito all'interno del container Docker, installeremo le dipendenze utilizzando l'immagine Docker di composer. Questo ci aiuterà anche a evitare di dover installare composer a livello globale sulla macchina host effettiva. Successivamente, avvia il terminale.
Spostati nella tua directory home:
|
1 |
cd ~ |
Inserisci il seguente comando per clonare il repository in una directory chiamata laravel-web. Sei libero di nominarla come preferisci. Al momento della scrittura di questo repository, quando eseguiamo questo comando, viene scaricata la versione 8 di Laravel. Quando eseguirai il comando, probabilmente troverai una nuova versione:
|
1 |
git clone https://github.com/laravel/laravel.git laravel-web |
Quindi, spostati nella directory in cui hai appena clonato il repository:
|
1 |
cd ~/laravel-web |
Inserisci il seguente comando per montare le directory necessarie alla tua app Laravel utilizzando l'immagine composer di Docker:
|
1 |
docker run --rm -v $(pwd):/app composer install |
I flag -v e –rm nel comando docker run creano un container effimero che verrà montato tramite bind alla directory corrente prima di essere rimosso. Il comando copia il contenuto di ~/laravel-web nel container e assicura che la cartella vendor creata da composer venga ricopiata nella directory corrente.
Ora, è necessario modificare la proprietà della directory laravel-web per l'utente non root. Questo consentirà di lavorare con il codice dell'applicazione come utente non root e di eseguire i processi all'interno del container nei passaggi successivi. Inserisci il seguente comando per modificare la proprietà:
|
1 |
sudo chown -R $USER:$USER ~/laravel-web |
Il codice dell'applicazione è ora al suo posto. La directory è di proprietà di un utente non root, quindi puoi procedere con la definizione dei servizi dell'applicazione nel file docker-compose.
Passo 2: Creare il file Docker Compose
Docker Compose semplifica il processo di compilazione e distribuzione di un'applicazione. Una volta definite le configurazioni e i servizi, puoi distribuire facilmente la tua applicazione in qualsiasi macchina host in cui siano installati Docker e Docker Compose senza preoccuparti delle dipendenze dell'applicazione. Soprattutto, puoi farlo con un solo comando Docker Compose, come vedremo nel Passo 9.
In questo passo, definirai un file Docker Compose con le configurazioni per il webserver, il database e i servizi dell'applicazione necessari per distribuire un'app Laravel.
I file Docker Compose sono YAML file salvati con l'estensione .yml. Si prega di notare che una corretta indentazione è necessaria per un file Docker Compose valido. Inserisci il seguente comando per creare e aprire il file con nano per la modifica:
|
1 |
nano ~/laravel-web/docker-compose.yml |
Successivamente, definirai tre servizi in questo file: app, webserver e db. La sezione db definisce le credenziali del database per la tua applicazione, quindi assicurati di scegliere una mysql_root_password complessa e di sostituirla in quella sezione. Copia e incolla il seguente codice:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 |
version: '2.0' services: #Servizio PHP app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ networks: - app-network #Servizio Nginx webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" networks: - app-network #Servizio MySQL db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql networks: - app-network #Reti Docker networks: app-network: driver: bridge |
Di seguito, seguono le spiegazioni delle definizioni dei servizi dal codice sopra riportato:
- app: definisce l'applicazione Laravel ed esegue un'immagine Docker personalizzata, cloudsigma.com/php, che definiremo nel Passo 4. Imposta anche la working_dir nel container su /var/www/html.
- webserver: scarica l'immagine nginx:alpine da Docker ed espone le porte 80 e 443.
- db: scarica l'immagine mysql:5.7.32 da Docker e definisce alcune variabili d'ambiente. Queste includono un database chiamato laravel_web per l'applicazione e la password di root per il database. Puoi rinominare il database con un nome a tua scelta. Ricorda di sostituire la proprietà MYSQL_ROOT_PASSWORD con una password complessa. Questo servizio mappa anche la porta 3306 sull'host alla porta 3306 sul container.
La proprietà container_name in ciascun servizio definisce un nome per il container corrispondente al servizio. Se non si definisce la proprietà, Docker sceglie un nome casuale per ciascun container.
La proprietà networks definisce una rete bridge chiamata app-network che facilita la comunicazione tra i container. Una rete bridge è controllata da un bridge software che consente la comunicazione solo tra container sullo stesso bridge di rete. Il controller software del bridge installa driver che impediscono ai container su reti bridge diverse di comunicare direttamente tra loro. Ciò garantisce un elevato livello di sicurezza poiché solo i servizi correlati possono comunicare direttamente. È possibile scegliere di definire più servizi e reti che si collegano a funzioni correlate.
Passo 3: Come rendere persistenti i dati
La tua applicazione web gestirà e fornirà dati ai tuoi utenti. In questo passaggio, ti guideremo nella definizione di volumi e bind mount per le definizioni dei tuoi servizi al fine di rendere persistenti i dati dell'applicazione. Docker offre funzionalità incredibili come bind mount e volumi per rendere persistenti i dati e salvare i file di configurazione dell'applicazione. Li useremo per configurare la nostra app Laravel con Docker.
I volumi sono preferiti per vari motivi, tra cui l'offerta di backup e la persistenza dei dati oltre il ciclo di vita di un container. I bind mount di solito fanno riferimento a una directory reale sulla macchina host. Quando si crea un volume, viene creata una nuova directory all'interno della directory di archiviazione di Docker, che è gestita da Docker. Quando si crea un bind mount, un file o una directory all'interno della macchina host viene montato in un container (indicato dal suo percorso assoluto). Questo è fondamentale per la nostra applicazione web perché quando si apportano modifiche al codice sulla macchina host, queste saranno immediatamente disponibili per il container.
Presta attenzione quando usi i bind mount. I processi in esecuzione all'interno del container Docker possono apportare modifiche al file system dell'host e influenzare i processi non Docker in esecuzione sul sistema host. Sebbene i mount di Docker siano una funzionalità potente, tieni presenti queste implicazioni di sicurezza.
Detto questo, vediamo come possiamo utilizzare queste due funzionalità nella nostra configurazione. Per prima cosa, definiremo un volume per rendere persistente il database MySQL. Nel file Docker Compose che abbiamo creato, sotto il servizio db, aggiungi una proprietà volumes come evidenziato di seguito:
|
1 2 3 4 5 6 7 8 |
#Servizio MySQL db: ... volumes: - dbdata:/var/lib/mysql/ networks: - app-network ... |
Come definito, il volume dbdata renderà persistente il contenuto di /var/lib/mysql. Facilita i backup e consente il riavvio dei servizi senza perdere i dati. Successivamente, dovresti aggiungere la definizione dei volumi alla fine del file Docker Compose per renderla disponibile tra i servizi. Inserisci il seguente frammento di codice in fondo al file:
|
1 2 3 4 |
#Volumi volumes: dbdata: driver: local |
Per connettersi a un database MySQL, è necessario fornire le credenziali. Per farlo, definisci un bind mount aggiungendo il seguente frammento di codice evidenziato al servizio db sotto la proprietà volumes:
|
1 2 3 4 5 6 7 |
#Servizio MySQL db: ... volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf ... |
Il codice associa ~/laravel-web/mysql/my.cnf a /etc/mysql/my.cnf nel container. Il file associato è il file di configurazione di MySQL che creeremo nel Passo 7.
Il container deve utilizzare il server Nginx per servire il codice della tua applicazione. Pertanto, definiremo due bind mount (uno per il file di configurazione di Nginx e uno per il codice dell'applicazione) sotto il servizio webserver a questo scopo. Aggiungi il seguente frammento di codice per la definizione dei volumi sotto il servizio webserver:
|
1 2 3 4 5 6 7 8 |
#Servizio Nginx webserver: ... volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network |
Questa riga – ./:/var/www/html collega il codice dell'applicazione nella directory ~/laravel-web alla directory /var/www/html all'interno del container. Per il secondo bind mount, verrà creato un file di configurazione per Nginx in ~/laravel-web/nginx/conf.d/. Verrà montato in /etc/nginx/conf.d/ all'interno del container. Pertanto, è possibile aggiornare il file di configurazione sulla macchina host secondo necessità. Creeremo il file conf di Nginx nel Passo 6.
Affinché le modifiche al codice si riflettano automaticamente nel container, colleghiamo tramite bind mount il codice dell'applicazione al container. Questo velocizza il processo di distribuzione. Pertanto, aggiungi il seguente frammento di codice evidenziato al servizio app:
|
1 2 3 4 5 6 7 8 |
#Servizio PHP app: ... volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network |
La seconda riga collega un file di configurazione php, che creeremo nel Passo 5 all'interno del file ~/laravel-web/php/laravel.ini a /usr/local/etc/php/conf.d/laravel.ini all'interno del container.
Il tuo file Docker Compose completo dovrebbe ora apparire così:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
version: '2.0' services: #Servizio PHP app: build: context: . dockerfile: Dockerfile image: cloudsigma.com/php container_name: app restart: unless-stopped tty: true environment: SERVICE_NAME: app SERVICE_TAGS: dev working_dir: /var/www/html/ volumes: - ./:/var/www/html/ - ./php/laravel.ini:/usr/local/etc/php/conf.d/laravel.ini networks: - app-network #Servizio Nginx webserver: image: nginx:alpine container_name: webserver restart: unless-stopped tty: true ports: - "80:80" - "443:443" volumes: - ./:/var/www/html/ - ./nginx/conf.d/:/etc/nginx/conf.d/ networks: - app-network #Servizio MySQL db: image: mysql:5.7.32 container_name: db restart: unless-stopped tty: true ports: - "3306:3306" environment: MYSQL_DATABASE: laravel_web MYSQL_ROOT_PASSWORD: replace_mysql_root_password SERVICE_TAGS: dev SERVICE_NAME: mysql volumes: - dbdata:/var/lib/mysql/ - ./mysql/my.cnf:/etc/mysql/my.cnf networks: - app-network #Reti Docker networks: app-network: driver: bridge #Volumi volumes: dbdata: driver: local |
Se tutto sembra a posto, premi Ctrl + O per salvare il file. Quindi, premi Ctrl + X per uscire dall'editor. A questo punto, dovresti essere in grado di compilare un'immagine Docker personalizzata per la tua applicazione con il file Docker Compose.
Passo 4: Creare il Dockerfile
Il Dockerfile include istruzioni che Docker può utilizzare per compilare immagini Docker personalizzate. Può anche installare il software richiesto e configurare le impostazioni necessarie per la tua applicazione. Specificano l'ambiente all'interno di un container che ospiterà il codice della tua applicazione. Puoi inviare le immagini che crei a docker hub per la condivisione o posizionarle su altri registri privati.
Creeremo un Dockerfile che specificherà le istruzioni per compilare l'immagine dell'applicazione Laravel. Usa nano per creare il Dockerfile nella directory ~/laravel-web:
|
1 |
nano ~/laravel-web/Dockerfile |
Nell'editor aperto, aggiungi il seguente codice:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 |
FROM php:7.4-fpm # Copia composer.lock e composer.json nella directory di lavoro COPY composer.lock composer.json /var/www/html/ # Imposta la directory di lavoro WORKDIR /var/www/html/ # Installa le dipendenze per il software del sistema operativo RUN apt-get update && apt-get install -y \ build-essential \ libpng-dev \ libjpeg62-turbo-dev \ libfreetype6-dev \ locales \ zip \ jpegoptim optipng pngquant gifsicle \ vim \ libzip-dev \ unzip \ git \ libonig-dev \ curl # Svuota la cache RUN apt-get clean && rm -rf /var/lib/apt/lists/* # Installa le estensioni per php RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl RUN docker-php-ext-configure gd --with-freetype --with-jpeg RUN docker-php-ext-install gd # Installa composer (gestore di pacchetti php) RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer # Copia i contenuti della directory dell'applicazione esistente nella directory di lavoro COPY . /var/www/html # Assegna i permessi della directory di lavoro all'utente www-data RUN chown -R www-data:www-data \ /var/www/html/storage \ /var/www/html/bootstrap/cache # Esponi la porta 9000 e avvia il server php-fpm (per FastCGI Process Manager) EXPOSE 9000 CMD ["php-fpm"] |
Il Dockerfile crea innanzitutto un'immagine basata sull'immagine Docker php:7.4-fpm. Si tratta di un'immagine basata su Debian con l'implementazione PHP FastCGI (PHP-FPM installata. Affinché Laravel funzioni correttamente, richiede la disponibilità di altre estensioni php come mcrypt, pdo_mysql, mbstring e imagick, che lo script installa. Successivamente installa il gestore di pacchetti php composer. Il container lo utilizzerà per installare le dipendenze php di Laravel.
Puoi utilizzare la direttiva RUN per definire comandi come installazione, aggiornamento e configurazione delle impostazioni all'interno del container. Assegna anche i permessi utente. La direttiva WORKDIR specifica la directory di lavoro, in questo caso /var/www/html. Lo script esegue il comando CHOWN per assegnare i permessi della directory /var/www/html all'utente www-data.
Prima di compilare definitivamente l'immagine, è necessario esporre una porta per consentire l'accesso all'applicazione in esecuzione all'interno del container. Il comando EXPOSE espone una porta, la 9000, per il server php-fpm. L'ultimo comando da eseguire è la direttiva CMD, che esegue php-fpm per avviare il server.
Ora puoi premere Ctrl + O per salvare il file. Quindi, premi Ctrl + X per uscire dall'editor.
Passo 5: Configurare PHP
In questo passaggio, configureremo il servizio php per elaborare le richieste in arrivo da Nginx. Creerai un file laravel.ini all'interno della directory php. Questo file conterrà le configurazioni PHP. Questo è il file che hai montato tramite bind su /usr/local/etc/php/conf.d/laravel.ini nel container nel Passaggio 3. Le configurazioni in questo file sostituiscono il file php.ini predefinito solitamente letto da PHP all'avvio. Inserisci il seguente comando per creare la directory php:
|
1 |
mkdir ~/laravel-web/php |
Crea e apri il file laravel.ini all'interno della directory php inserendo il seguente comando:
|
1 |
nano ~/laravel-web/php/laravel.ini |
Il file php.ini predefinito ha un limite di caricamento impostato su 2M. Come esempio, ti mostreremo come regolare e impostare le configurazioni php modificando il valore del limite di caricamento consentito, nel caso in cui desideri caricare file più grandi. Inserisci le seguenti righe di codice all'interno del file:
|
1 2 |
upload_max_filesize=80M post_max_size=80M |
Questo imposta il limite di caricamento e potrai caricare file con una dimensione totale non superiore a 80MB. Puoi aggiungere altre configurazioni php all'interno del file laravel.ini per sovrascrivere le configurazioni php predefinite. Ora, salva e chiudi il file.
Passaggio 6: Configurare Nginx
In questo passaggio, configureremo Nginx per utilizzare il servizio php definito in precedenza. Utilizzerà PHP-FPM come server FastCGI per servire contenuti dinamici. Il server FastCGI è un software che consente ai programmi interattivi di interfacciarsi con un server web.
Come avevamo definito nel file docker-compose nel Passaggio 3, creeremo il file di configurazione di Nginx app.conf all'interno della directory ~/laravel-web/nginx/conf.d/. Per prima cosa, inserisci il seguente comando per creare la directory:
|
1 |
mkdir -p ~/laravel-web/nginx/conf.d |
Successivamente, crea e apri il file app.conf usando nano inserendo il seguente comando:
|
1 |
nano ~/laravel-web/nginx/conf.d/app.conf |
Aggiungi il seguente codice di configurazione di Nginx al file:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
server { listen 80; index index.php index.html; error_log /var/log/nginx/error.log; access_log /var/log/nginx/access.log; root /var/www/html/public; location ~ \.php$ { try_files $uri =404; fastcgi_split_path_info ^(.+\.php)(/.+)$; fastcgi_pass app:9000; fastcgi_index index.php; include fastcgi_params; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param PATH_INFO $fastcgi_path_info; } location / { try_files $uri $uri/ /index.php?$query_string; gzip_static on; } } |
Nginx legge i file di configurazione chiamati server block per sapere quale directory deve essere servita a un visitatore del sito web in base all'URL. Per saperne di più, leggi come configurare i server block nel nostro tutorial su installazione di Nginx su Ubuntu 18.04. Le direttive definite servono ai seguenti scopi:
- listen – Definisce la porta su cui il server rimarrà in ascolto per le richieste in arrivo, che di solito è la porta 80.
- error_log & access_log – Definisce i file per la scrittura dei log dell'applicazione.
- root – Definisce il percorso della webroot, la directory che servirà qualsiasi richiesta effettuata al server da Internet.
Nel blocco location per php, la direttiva fastcgi_pass specifica che il servizio app è in ascolto su un socket TCP sulla porta 9000 (che è stata definita nel Dockerfile). Questo indica al server PHP-FPM di ascoltare sulla rete e non su un socket Unix. Sebbene un socket Unix possa avere un leggero vantaggio in termini di velocità rispetto a un socket TCP, è privo di un protocollo di rete, saltando quindi lo stack di rete.
Un socket Unix sarebbe più appropriato per scenari in cui gli host si trovano su una sola macchina. Tuttavia, se si hanno servizi in esecuzione su host diversi, un socket TCP ha il vantaggio di connettere servizi distribuiti. Nel nostro caso, il container dell'app è in esecuzione su un host diverso rispetto al container del nostro server web. Pertanto, un socket TCP è il più appropriato per la nostra configurazione.
Ora puoi premere Ctrl + O per salvare il file, quindi premere Ctrl + X per uscire dall'editor. Le modifiche apportate nella directory nginx/conf.d/ si rifletteranno automaticamente nel container del server web grazie al bind mount aggiunto nel file Docker Compose nel Passo 3.
Passo 7: Configurare MySQL
Dopo aver configurato Nginx per funzionare con PHP, possiamo ora configurare MySQL per memorizzare e servire dati dinamici a PHP. Avevamo già impostato il file Docker Compose per installare le estensioni necessarie per la comunicazione tra PHP e MySQL. Creeremo il file di configurazione di MySQL my.cnf all'interno della cartella mysql, che sarà montato tramite bind mount su /etc/mysql/my.cnf come avevamo definito nella sezione del servizio db di Docker Compose nel Passo 3.
Le impostazioni di configurazione e le modifiche di MySQL possono essere apportate al file my.cnf in qualsiasi momento. Dovrebbero riflettersi immediatamente all'interno del container. Innanzitutto, crea la directory inserendo il seguente comando:
|
1 |
mkdir ~/laravel-web/mysql |
Successivamente, crea e apri nano inserendo il seguente comando:
|
1 |
nano ~/laravel-web/mysql/my.cnf |
Inserisci il seguente frammento di codice per abilitare il log delle query e specificare la posizione del file di log delle query:
|
1 2 3 |
[mysqld] general_log = 1 general_log_file = /var/lib/mysql/general.log |
Definendo la proprietà general_log come 1, consenti i log generali. La proprietà general_log_file specifica la posizione del file dei log. Premi Ctrl + O per salvare il file, quindi premi Ctrl + X per uscire dall'editor.
Passo 8: Impostare le variabili d'ambiente di Laravel
Fino a questo punto, tutti i servizi e le impostazioni di configurazione sono completi. Pertanto, potremmo essere in grado di distribuire i nostri container. Tuttavia, c'è un passo importante da compiere prima che la nostra applicazione web sia effettivamente utilizzabile: le variabili d'ambiente. Il framework Laravel si aspetta un file chiamato .env che utilizza per definire il suo ambiente. Per impostazione predefinita, Laravel viene fornito con il file .env.example che puoi copiare in .env, quindi modificare le variabili con i tuoi dettagli effettivi. Inserisci il seguente comando per copiare il file:
|
1 |
cp .env.example .env |
Una volta copiato, apri il file usando nano per modificarlo:
|
1 |
nano .env |
Ecco uno screenshot di come potrebbe apparire il file:

Nel file, il passo successivo consiste nel modificare le variabili sotto il blocco DB_CONNECTION come avevi impostato nelle configurazioni precedenti fatte finora. Aggiorna come segue:
- DB_HOST è il db container del database.
- DB_DATABASE è il laravel_web.
- DB_USERNAME è il nome utente per il database. Scegli un nome a tua scelta, ma ai fini di questo tutorial, useremo laraveldocker.
- DB_PASSWORD è una password complessa che il tuo utente sopra utilizzerà per accedere al database, quindi scegli una password sicura. Nel Passo 10, creeremo questo utente con la password che hai scelto qui.
Con i valori aggiornati, il tuo DB_CONNECTION dovrebbe ora apparire così:

Salva e chiudi il file.
Passo 9: Eseguire i container Docker
In questa fase, tutti i tuoi servizi e configurazioni sono definiti nel file Docker Compose. È richiesto un solo comando per avviare tutti i container, creare i volumi, connettere le reti, e configurare e compilare la tua applicazione. Inserisci il seguente comando nel tuo terminale:
|
1 |
docker-compose up -d |
Quando esegui il comando docker-compose up per la prima volta, questo scarica tutte le immagini Docker necessarie. Se stai configurando l'infrastruttura sul tuo computer locale, potrebbe essere necessario del tempo per completare l'operazione. Una volta scaricate le immagini, Compose crea i container. Il flag -d indica a Docker di eseguire i container in background. Se il processo si completa correttamente, dovresti vedere qualcosa di simile nel tuo terminale:

Inserisci il seguente comando nel tuo terminale per elencare tutti i container in esecuzione:
|
1 |
docker ps |
Dovrebbe mostrare qualcosa di simile allo screenshot qui sotto, con i dettagli sui container app, webserver e db:

- CONTAINER ID – Un identificatore univoco per ciascun container.
- NAMES – Il nome del servizio associato a ciascun container, come definito nel file Docker Compose. (Puoi utilizzare l'id o il nome del container per accedervi).
- IMAGE – Il nome dell'immagine per ciascun container.
- STATUS – Mostra informazioni sullo stato del container (potrebbe essere arrestato, in esecuzione o in riavvio).
- PORTS – Mostra le porte esposte da un container.
Docker Compose fornisce un comando chiamato exec che puoi utilizzare per eseguire comandi da terminale o accedere alla riga di comando all'interno di un container. Per prima cosa vogliamo eseguire alcuni comandi all'interno del container app, che è il container che esegue l'app Laravel.
Docker fornisce un comando per accedere alla riga di comando di un container. La sua sintassi è la seguente: docker-compose exec container_name bash. To access the command line of the app container, enter the following command:
|
1 |
docker-compose exec app bash |
Una volta nella riga di comando del container, puoi eseguire alcuni comandi di configurazione Laravel Artisan. Inserisci il seguente comando per generare la chiave laravel e salvarla nel file .env:
|
1 |
php artisan key:generate |
Con la chiave d'ambiente impostata, puoi eseguire il seguente comando per memorizzare nella cache le impostazioni di configurazione:
|
1 |
php artisan config:cache |
Le configurazioni sono memorizzate nel file /var/www/html/bootstrap/cache/config.php all'interno del container. Puoi premere Ctrl + D per uscire dal terminale del container.
Per confermare che l’app Laravel sia stata distribuita e sia in esecuzione, visita l’IP pubblico del tuo server nel browser (http://your_server_public_ip). Dovresti vedere la pagina di benvenuto per una nuova installazione di Laravel:

Passo 10: Configura un utente MySQL
In questo passo, creeremo un utente di database per il database MySQL laravel_web che abbiamo specificato nel file docker-compose. Quando hai eseguito il comando di compilazione del container nel Step 9, MySQL è stato installato, ma ha creato solo un account amministrativo root predefinito, che ha privilegi illimitati sul database. Per evitare di utilizzare l'utente root, creeremo un utente dedicato, laraveldocker, da utilizzare per l'applicazione. Questo è l'utente che hai specificato nelle variabili d'ambiente nel Step 8. Accedi alla riga di comando all'interno del terminale inserendo il seguente comando:
|
1 |
docker-compose exec db bash |
Una volta all'interno del container, accedi a MySQL inserendo il seguente comando:
|
1 |
mysql -u root -p |
Nella richiesta della password, inserisci la password che hai impostato nel servizio db nel file docker-compose nel Step 2.
Una volta effettuato l’accesso al prompt di MySQL, verifica se riesci a vedere il database specificato nel file docker-compose inserendo il seguente comando SQL:
|
1 |
show databases; |
Dovresti vedere il database laravel_web, o qualsiasi nome tu abbia specificato per la tua configurazione:

Successivamente, creiamo un utente e una password per il database laravel_web. Questi devono essere gli stessi dettagli specificati nel file .env nel Step 8. Inserisci il seguente comando per creare l'utente e la password, e concedere tutti i privilegi a questo utente:
|
1 |
GRANT ALL ON laravel_web.* TO 'laraveldocker'@'%' IDENTIFIED BY 'your_strong_laravel_docker_password'; |
Affinché le modifiche abbiano effetto immediato, inserisci il seguente comando per svuotare i privilegi:
|
1 |
FLUSH PRIVILEGES; |
Questo completa la configurazione dell'utente MySQL. Esci dal prompt di MySQL digitando exit e premendo invio. Infine, esci dal container db premendo Ctrl + D.
Passo 11: Testare la comunicazione tra il codice dell'applicazione Laravel e il database MySQL
Fino a questo passaggio, tutto ha funzionato bene. Tuttavia, vogliamo confermare che il codice Laravel nel container app possa comunicare con il database MySQL nel container db. Innanzitutto, accedi al terminale del container app inserendo il seguente comando:
|
1 |
docker-compose exec app bash |
Il passo successivo consiste nell'eseguire il comando di migrazione di Laravel che crea le tabelle:
|
1 |
php artisan migrate |
Dovresti vedere il processo di migrazione nel tuo terminale mentre Laravel crea le tabelle predefinite:

Successivamente, verificheremo se possiamo accedere al database da Laravel. Laravel include Tinker per impostazione predefinita, che consente di interagire con l'intera applicazione dalla riga di comando, incluso l'accesso al database, l'esecuzione di job, eloquent ORM, e altro ancora. Possiamo usare Tinker per visualizzare i dati nella tabella delle migrazioni. Inserisci il seguente comando per accedere a Tinker:
|
1 |
php artisan tinker |
Una volta nel prompt di Tinker, puoi elencare le tabelle create dal comando migrate inserendo quanto segue:
|
1 |
\DB::select('show tables'); |
La schermata seguente mostra l'output, ovvero le tabelle attualmente presenti nel database laravel_web:

Puoi recuperare i dati in una tabella specificando il nome della tabella. Ad esempio, puoi recuperare i dati nella tabella delle migrazioni inserendo il seguente comando:
|
1 |
\DB::table('migrations')->get(); |
Il comando restituisce il seguente output:

Dall'output sopra, la tua applicazione Laravel è configurata correttamente e può comunicare con il database. Puoi sperimentare con altri comandi come la creazione di modelli, l'esecuzione di job e altro ancora. Puoi uscire dal prompt di Tinker premendo Ctrl + D.
Conclusione
In questo tutorial, hai distribuito un'applicazione Laravel con stack LEMP all'interno di un container Docker. Hai testato l'applicazione accedendo all'interfaccia web e connettendoti al database tramite Laravel Tinker. Hai potuto sperimentare la potenza di Docker Compose. Ti consente di creare un gruppo di container Docker definiti in un unico file, che può quindi essere eseguito con un solo comando.
Se desideri familiarizzare ulteriormente con i container, dai un'occhiata al nostro tutorial che mostra come ripulire le risorse Docker – immagini, container e volumi e alla nostra panoramica dettagliata dello strumento Kubernetes.
Puoi inoltre visitare il nostro blog per saperne di più su Docker e Continuous Integration e Continuous Deployment.
Buona programmazione!
Commenti
Ancora nessun commento. Scrivi il primo.