Come installare e configurare Laravel con Docker Compose su Ubuntu 22.04

Introduzione

Per contenire un'applicazione si riferisce al processo di adattamento di un'applicazione e dei suoi componenti per poterla eseguire in ambienti leggeri noti come contenitori. Tali ambienti sono isolati e usa e getta e possono essere sfruttati per lo sviluppo, il test e la distribuzione di applicazioni in produzione.

In questa guida utilizzeremo Docker Compose per containerizzare un'applicazione Laravel per lo sviluppo. Al termine, avrai un'applicazione Laravel demo in esecuzione su tre contenitori di servizi separati:

• Un app servizio che esegue PHP7.4-FPM;
• Un db servizio che esegue MySQL 5.7;
• Un nginx servizio che utilizza l'app servizio per analizzare il codice PHP prima di servire l'applicazione Laravel all'utente finale.

Per consentire un processo di sviluppo semplificato e facilitare il debug delle applicazioni, manterremo sincronizzati i file delle applicazioni utilizzando i volumi condivisi. Vedremo anche come usare docker-compose exec comandi per eseguire Composer e Artisan sull'app contenitore.

Prerequisiti

• Accesso a una macchina locale Ubuntu 22.04 o a un server di sviluppo come utente non root con privilegi sudo. Se stai utilizzando un server remoto, è consigliabile avere un firewall attivo installato. Per configurarli, fare riferimento alla nostra Guida all'installazione iniziale del server per Ubuntu 22.04.
• Docker installato sul tuo server, seguendo i passaggi 1 e 2 di Come installare e utilizzare Docker su Ubuntu 22.04.
• Docker Compose installato sul tuo server, seguendo il passaggio 1 di Come installare e utilizzare Docker Compose su Ubuntu 22.04.

Fase 1:ottenere l'applicazione demo

Per iniziare, recupereremo l'applicazione demo Laravel dal suo repository Github. Siamo interessati al tutorial-01 branch, che contiene l'applicazione di base Laravel che abbiamo creato nella prima guida di questa serie.

Per ottenere il codice dell'applicazione compatibile con questo tutorial, scarica la release tutorial-1.0.1 nella tua home directory con:

cd ~
curl -L https://github.com/do-community/travellist-laravel-demo/archive/tutorial-1.0.1.zip -o travellist.zip

Avremo bisogno del unzip comando per decomprimere il codice dell'applicazione. Se non hai installato questo pacchetto prima, fallo ora con:

sudo apt update
sudo apt install unzip

Ora, decomprimi il contenuto dell'applicazione e rinomina la directory decompressa per un accesso più semplice:

unzip travellist.zip
mv travellist-laravel-demo-tutorial-1.0.1 travellist-demo

Vai alla travellist-demo directory:

cd travellist-demo

Nel passaggio successivo creeremo un .env file di configurazione per configurare l'applicazione.

Passaggio 2:configurazione del .env dell'applicazione File

I file di configurazione di Laravel si trovano in una directory chiamata config , all'interno della directory principale dell'applicazione. Inoltre, un .env viene utilizzato per configurare la configurazione dipendente dall'ambiente, ad esempio le credenziali e qualsiasi informazione che potrebbe variare tra le distribuzioni. Questo file non è incluso nel controllo di revisione.

Avviso :il file di configurazione dell'ambiente contiene informazioni riservate sul server, comprese le credenziali del database e le chiavi di sicurezza. Per questo motivo, non dovresti mai condividere questo file pubblicamente.

I valori contenuti in .env file avrà la precedenza sui valori impostati nei normali file di configurazione che si trovano in config directory. Ogni installazione in un nuovo ambiente richiede un file di ambiente personalizzato per definire cose come le impostazioni di connessione al database, le opzioni di debug, l'URL dell'applicazione e altri elementi che possono variare a seconda dell'ambiente in cui è in esecuzione l'applicazione.

Ora creeremo un nuovo .env per personalizzare le opzioni di configurazione per l'ambiente di sviluppo che stiamo configurando. Laravel viene fornito con un esempio.env file che possiamo copiare per creare il nostro:

cp .env.example .env

Apri questo file usando nano o il tuo editor di testo preferito:

nano .env

L'attuale .env file dalla travellist l'applicazione demo contiene le impostazioni per utilizzare un database MySQL locale, con 127.0.0.1 come host di database. Dobbiamo aggiornare il DB_HOST variabile in modo che punti al servizio di database che creeremo nel nostro ambiente Docker. In questa guida chiameremo il nostro servizio di database db . Vai avanti e sostituisci il valore elencato di DB_HOST con il nome del servizio database:

.env

APP_NAME=Travellist
APP_ENV=dev
APP_KEY=
APP_DEBUG=true
APP_URL=http://localhost:8000

LOG_CHANNEL=stack

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=travellist
DB_USERNAME=travellist_user
DB_PASSWORD=password
...

Sentiti libero di cambiare anche il nome del database, il nome utente e la password, se lo desideri. Queste variabili verranno sfruttate in un passaggio successivo in cui imposteremo docker-compose.yml file per configurare i nostri servizi.

Salva il file quando hai finito di modificare. Se hai usato nano , puoi farlo premendo Ctrl+x , quindi Y e Enter per confermare.

Passaggio 3:configurazione del Dockerfile dell'applicazione

Sebbene entrambi i nostri servizi MySQL e Nginx saranno basati su immagini predefinite ottenute da Docker Hub, dobbiamo comunque creare un'immagine personalizzata per il contenitore dell'applicazione. Creeremo un nuovo Dockerfile per questo.

La nostra lista di viaggio l'immagine sarà basata su php:7.4-fpm immagine PHP ufficiale da Docker Hub. Oltre all'ambiente PHP-FPM di base, installeremo alcuni moduli PHP aggiuntivi e lo strumento di gestione delle dipendenze Composer.

Creeremo anche un nuovo utente di sistema; questo è necessario per eseguire artisan e composer comandi durante lo sviluppo dell'applicazione. Il uid l'impostazione garantisce che l'utente all'interno del contenitore abbia lo stesso uid dell'utente di sistema sul computer host, su cui stai eseguendo Docker. In questo modo, tutti i file creati da questi comandi vengono replicati nell'host con le autorizzazioni corrette. Ciò significa anche che potrai utilizzare il tuo editor di codice preferito nella macchina host per sviluppare l'applicazione in esecuzione all'interno dei container.

Crea un nuovo Dockerfile con:

nano Dockerfile

Copia i seguenti contenuti nel tuo Dockerfile:

Dockerfile

FROM php:7.4-fpm

# Arguments defined in docker-compose.yml
ARG user
ARG uid

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    zip \
    unzip

# Clear cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*

# Install PHP extensions
RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd

# Get latest Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer

# Create system user to run Composer and Artisan Commands
RUN useradd -G www-data,root -u $uid -d /home/$user $user
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user

# Set working directory
WORKDIR /var/www

USER $user

Non dimenticare di salvare il file quando hai finito.

Il nostro Dockerfile inizia definendo l'immagine di base che stiamo usando:php:7.4-fpm .

Dopo aver installato i pacchetti di sistema e le estensioni PHP, installiamo Composer copiando il composer eseguibile dalla sua ultima immagine ufficiale alla nostra immagine dell'applicazione.

Un nuovo utente di sistema viene quindi creato e configurato utilizzando il user e uid argomenti dichiarati all'inizio del Dockerfile. Questi valori verranno inseriti da Docker Compose in fase di compilazione.

Infine, impostiamo la directory di lavoro predefinita come /var/www e passare all'utente appena creato. Questo ti assicurerà di connetterti come un utente normale e di trovarti nella directory giusta quando esegui composer e artisan comandi sul contenitore dell'applicazione.

Passaggio 4:configurazione di Nginx e file di dump del database

Quando si creano ambienti di sviluppo con Docker Compose, è spesso necessario condividere i file di configurazione o di inizializzazione con i contenitori di servizi, al fine di configurare o avviare tali servizi. Questa pratica consente di apportare modifiche ai file di configurazione per ottimizzare l'ambiente durante lo sviluppo dell'applicazione.

Ora imposteremo una cartella con i file che verranno utilizzati per configurare e inizializzare i nostri contenitori di servizi.

Per configurare Nginx, condivideremo un travellist.conf file che configurerà il modo in cui viene servita l'applicazione. Crea il docker-compose/nginx cartella con:

mkdir -p docker-compose/nginx

Apri un nuovo file chiamato travellist.conf all'interno di quella directory:

nano docker-compose/nginx/travellist.conf

Copia la seguente configurazione di Nginx in quel file:

docker-compose/nginx/travellist.conf

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/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;
    }
}

Questo file configurerà Nginx per l'ascolto sulla porta 80 e usa index.php come pagina indice predefinita. Imposterà la radice del documento su /var/www/public , quindi configura Nginx per utilizzare l'app servizio sulla porta 9000 per elaborare *.php file.

Salva e chiudi il file quando hai finito di modificare.

Per configurare il database MySQL, condivideremo un dump del database che verrà importato quando il contenitore verrà inizializzato. Questa è una funzionalità fornita dall'immagine MySQL 5.7 che useremo su quel container.

Crea una nuova cartella per i tuoi file di inizializzazione MySQL all'interno di docker-compose cartella:

mkdir docker-compose/mysql

Apri un nuovo .sql file:

nano docker-compose/mysql/init_db.sql

Il seguente dump di MySQL si basa sul database che abbiamo impostato nella nostra guida Laravel su LEMP. Creerà una nuova tabella denominata places . Quindi, popolerà la tabella con una serie di posizioni campione.

Aggiungi il seguente codice al file:

docker-compose/mysql/db_init.sql

DROP TABLE IF EXISTS `places`;

CREATE TABLE `places` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) COLLATE utf8mb4_unicode_ci NOT NULL,
  `visited` tinyint(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

INSERT INTO `places` (name, visited) VALUES ('Berlin',0),('Budapest',0),('Cincinnati',1),('Denver',0),('Helsinki',0),('Lisbon',0),('Moscow',1),('Nairobi',0),('Oslo',1),('Rio',0),('Tokyo',0);

I places la tabella contiene tre campi:id , name e visited . Il visited field è un flag utilizzato per identificare i luoghi che devono ancora andare . Sentiti libero di cambiare i luoghi del campione o includerne di nuovi. Salva e chiudi il file quando hai finito.

Abbiamo finito di configurare il Dockerfile dell'applicazione e i file di configurazione del servizio. Successivamente, imposteremo Docker Compose per utilizzare questi file durante la creazione dei nostri servizi.

Passaggio 5:creazione di un ambiente multi-container con Docker Compose

Docker Compose consente di creare ambienti multi-container per le applicazioni in esecuzione su Docker. Utilizza definizioni di servizio per creare ambienti completamente personalizzabili con più contenitori in grado di condividere reti e volumi di dati. Ciò consente una perfetta integrazione tra i componenti dell'applicazione.

Per impostare le definizioni dei nostri servizi, creeremo un nuovo file chiamato docker-compose.yml . In genere, questo file si trova nella radice della cartella dell'applicazione e definisce il tuo ambiente containerizzato, comprese le immagini di base che utilizzerai per creare i tuoi container e come interagiranno i tuoi servizi.

Definiremo tre diversi servizi nel nostro docker-compose.yml file:app , db e nginx .

L'app il servizio creerà un'immagine chiamata travellist , in base al Dockerfile che abbiamo creato in precedenza. Il contenitore definito da questo servizio eseguirà un php-fpm server per analizzare il codice PHP e inviare i risultati a nginx servizio, che verrà eseguito su un contenitore separato. Il mysql service definisce un contenitore che esegue un server MySQL 5.7. I nostri servizi condivideranno una rete bridge denominata travellist .

I file dell'applicazione verranno sincronizzati su entrambe le app e nginx servizi tramite bind mount . I montaggi di binding sono utili negli ambienti di sviluppo perché consentono una sincronizzazione bidirezionale efficiente tra la macchina host e i container.

Crea un nuovo docker-compose.yml file nella radice della cartella dell'applicazione:

nano docker-compose.yml

Un tipico docker-compose.yml il file inizia con una definizione di versione, seguita da un services nodo, in base al quale sono definiti tutti i servizi. Le reti condivise sono generalmente definite in fondo a quel file.

Per iniziare, copia questo codice standard nel tuo docker-compose.yml file:

docker-compose.yml

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Ora modificheremo i services nodo per includere l'app , db e nginx servizi.

L'app Servizio

L'app il servizio imposterà un contenitore denominato travellist-app . Crea una nuova immagine Docker basata su un Dockerfile situato nello stesso percorso di docker-compose.yml file. La nuova immagine verrà salvata localmente con il nome travellist .

Anche se la radice del documento utilizzata come applicazione si trova in nginx container, abbiamo bisogno dei file dell'applicazione da qualche parte all'interno dell'app container, quindi siamo in grado di eseguire attività da riga di comando con lo strumento Laravel Artisan.

Copia la seguente definizione di servizio sotto i tuoi services nodo, all'interno di docker-compose.yml file:

docker-compose.yml

  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

Queste impostazioni effettuano le seguenti operazioni:

• build :questa configurazione indica a Docker Compose di creare un'immagine locale per l'app servizio, utilizzando il percorso specificato (contesto) e Dockerfile per le istruzioni. Gli argomenti user e uid vengono inseriti nel Dockerfile per personalizzare i comandi di creazione dell'utente in fase di compilazione.
• image :il nome che verrà utilizzato per la creazione dell'immagine.
• container_name :imposta il nome del contenitore per questo servizio.
• restart :riavvia sempre, a meno che il servizio non venga interrotto.
• working_dir :imposta la directory predefinita per questo servizio come /var/www .
• volumes :crea un volume condiviso che sincronizzerà i contenuti dalla directory corrente a /var/www all'interno del contenitore. Nota che questa non è la tua radice del documento, poiché vivrà nel nginx contenitore.
• networks :imposta questo servizio per utilizzare una rete denominata travellist .

Il db Servizio

Il db il servizio utilizza un'immagine MySQL 8.0 predefinita da Docker Hub. Perché Docker Compose carica automaticamente .env file variabili che si trovano nella stessa directory di docker-compose.yml file, possiamo ottenere le impostazioni del nostro database da Laravel .env file che abbiamo creato in un passaggio precedente.

Includi la seguente definizione di servizio nei tuoi services nodo, subito dopo l'app servizio:

docker-compose.yml

  db:
    image: mysql:8.0
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

Queste impostazioni effettuano le seguenti operazioni:

• image :definisce l'immagine Docker da utilizzare per questo contenitore. In questo caso, stiamo usando un'immagine MySQL 5.7 da Docker Hub.
• container_name :imposta il nome del contenitore per questo servizio:travellist-db .
• restart :riavvia sempre questo servizio, a meno che non venga interrotto in modo esplicito.
• environment :definisce le variabili di ambiente nel nuovo contenitore. Stiamo usando valori ottenuti da Laravel .env per configurare il nostro servizio MySQL, che creerà automaticamente un nuovo database e un nuovo utente in base alle variabili di ambiente fornite.
• volumes :crea un volume per condividere un .sql dump del database che verrà utilizzato per inizializzare il database dell'applicazione. L'immagine MySQL importerà automaticamente .sql file inseriti nel /docker-entrypoint-initdb.d directory all'interno del contenitore.
• networks :imposta questo servizio per utilizzare una rete denominata travellist .

Il nginx Servizio

Il nginx il servizio utilizza un'immagine Nginx pre-costruita su Alpine, una distribuzione Linux leggera. Crea un contenitore chiamato travellist-nginx e utilizza le ports definizione per creare un reindirizzamento dalla porta 8000 sul sistema host per portare 80 all'interno del contenitore.

Includi la seguente definizione di servizio nei tuoi services nodo, subito dopo il db servizio:

docker-compose.yml

  nginx:
    image: nginx:1.17-alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d
    networks:
      - travellist

Queste impostazioni effettuano le seguenti operazioni:

• image :definisce l'immagine Docker da utilizzare per questo contenitore. In questo caso, stiamo usando l'immagine Alpine Nginx 1.17.
• container_name :imposta il nome del contenitore per questo servizio:travellist-nginx .
• restart :riavvia sempre questo servizio, a meno che non venga interrotto in modo esplicito.
• ports :imposta un reindirizzamento della porta che consentirà l'accesso esterno tramite la porta 8000 al server web in esecuzione sulla porta 80 all'interno del contenitore.
• volumes :Crea due volumi condivisi. Il primo sincronizzerà i contenuti dalla directory corrente a /var/www all'interno del contenitore. In questo modo, quando apporti modifiche locali ai file dell'applicazione, queste si rifletteranno rapidamente nell'applicazione servita da Nginx all'interno del contenitore. Il secondo volume assicurerà il nostro file di configurazione Nginx, che si trova in docker-compose/nginx/travellist.conf , viene copiato nella cartella di configurazione Nginx del contenitore.
• networks :imposta questo servizio per utilizzare una rete denominata travellist .

Fine docker-compose.yml File

Ecco come è finito il nostro docker-compose.yml il file è simile a:

docker-compose.yml

version: "3.7"
services:
  app:
    build:
      args:
        user: sammy
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: travellist
    container_name: travellist-app
    restart: unless-stopped
    working_dir: /var/www/
    volumes:
      - ./:/var/www
    networks:
      - travellist

  db:
    image: mysql:8.0
    container_name: travellist-db
    restart: unless-stopped
    environment:
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_USER: ${DB_USERNAME}
      SERVICE_TAGS: dev
      SERVICE_NAME: mysql
    volumes:
      - ./docker-compose/mysql:/docker-entrypoint-initdb.d
    networks:
      - travellist

  nginx:
    image: nginx:alpine
    container_name: travellist-nginx
    restart: unless-stopped
    ports:
      - 8000:80
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d/
    networks:
      - travellist

networks:
  travellist:
    driver: bridge

Assicurati di salvare il file quando hai finito.

Passaggio 6:esecuzione dell'applicazione con Docker Compose

Ora useremo docker-compose comandi per creare l'immagine dell'applicazione ed eseguire i servizi che abbiamo specificato nella nostra configurazione.

Crea l'app immagine con il seguente comando:

docker-compose build app

Il completamento di questo comando potrebbe richiedere alcuni minuti. Vedrai un output simile a questo:

OutputBuilding app
Sending build context to Docker daemon  377.3kB
Step 1/11 : FROM php:7.4-fpm
 ---> 8c08d993542f
Step 2/11 : ARG user
 ---> e3ce3af04d87
Step 3/11 : ARG uid
 ---> 30cb921ef7df
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     libxml2-dev     zip     unzip
. . .
 ---> b6dbc7a02e95
Step 5/11 : RUN apt-get clean && rm -rf /var/lib/apt/lists/*
 ---> 10ef9dde45ad
. . .
Step 6/11 : RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
. . .
 ---> 920e4f09ec75
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> dbbcd44e44af
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> db98e899a69a
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> 5119e26ebfea
Step 10/11 : WORKDIR /var/www
 ---> 699c491611c0
Step 11/11 : USER $user
 ---> cf250fe8f1af
Successfully built cf250fe8f1af
Successfully tagged travellist:latest

Al termine della compilazione, puoi eseguire l'ambiente in modalità background con:

docker-compose up -d

OutputCreating travellist-db    ... done
Creating travellist-app   ... done
Creating travellist-nginx ... done

Questo eseguirà i tuoi contenitori in background. Per mostrare informazioni sullo stato dei tuoi servizi attivi, esegui:

docker-compose ps

Vedrai un output come questo:

Output      Name                    Command              State                  Ports                
-----------------------------------------------------------------------------------------------
travellist-app     docker-php-entrypoint php-fpm   Up      9000/tcp                            
travellist-db      docker-entrypoint.sh mysqld     Up      3306/tcp, 33060/tcp                 
travellist-nginx   nginx -g daemon off;            Up      0.0.0.0:8000->80/tcp,:::8000->80/tcp

Il tuo ambiente è ora attivo e funzionante, ma dobbiamo ancora eseguire un paio di comandi per completare la configurazione dell'applicazione. Puoi usare docker-compose exec comando per eseguire comandi nei contenitori del servizio, come un ls -l per mostrare informazioni dettagliate sui file nella directory dell'applicazione:

docker-compose exec app ls -l

Outputtotal 256
-rw-r--r-- 1 sammy sammy    737 Apr 18 14:21 Dockerfile
-rw-r--r-- 1 sammy sammy    101 Jan  7  2020 README.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 app
-rwxr-xr-x 1 sammy sammy   1686 Jan  7  2020 artisan
drwxr-xr-x 3 sammy sammy   4096 Jan  7  2020 bootstrap
-rw-r--r-- 1 sammy sammy   1501 Jan  7  2020 composer.json
-rw-r--r-- 1 sammy sammy 179071 Jan  7  2020 composer.lock
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 config
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 database
drwxr-xr-x 4 sammy sammy   4096 Apr 18 14:22 docker-compose
-rw-r--r-- 1 sammy sammy   1017 Apr 18 14:29 docker-compose.yml
-rw-r--r-- 1 sammy sammy   1013 Jan  7  2020 package.json
-rw-r--r-- 1 sammy sammy   1405 Jan  7  2020 phpunit.xml
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 public
-rw-r--r-- 1 sammy sammy    273 Jan  7  2020 readme.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 resources
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 routes
-rw-r--r-- 1 sammy sammy    563 Jan  7  2020 server.php
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 storage
drwxr-xr-x 4 sammy sammy   4096 Jan  7  2020 tests
-rw-r--r-- 1 sammy sammy    538 Jan  7  2020 webpack.mix.js

Ora eseguiremo composer install per installare le dipendenze dell'applicazione:

docker-compose exec app rm -rf vendor composer.lock
docker-compose exec app composer install

Vedrai un output come questo:

OutputNo composer.lock file present. Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.
. . .
Lock file operations: 89 installs, 0 updates, 0 removals
  - Locking doctrine/inflector (2.0.4)
  - Locking doctrine/instantiator (1.4.1)
  - Locking doctrine/lexer (1.2.3)
  - Locking dragonmantank/cron-expression (v2.3.1)
  - Locking egulias/email-validator (2.1.25)
  - Locking facade/flare-client-php (1.9.1)
  - Locking facade/ignition (1.18.1)
  - Locking facade/ignition-contracts (1.0.2)
  - Locking fideloper/proxy (4.4.1)
  - Locking filp/whoops (2.14.5)
. . .
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 89 installs, 0 updates, 0 removals
  - Downloading doctrine/inflector (2.0.4)
  - Downloading doctrine/lexer (1.2.3)
  - Downloading dragonmantank/cron-expression (v2.3.1)
  - Downloading symfony/polyfill-php80 (v1.25.0)
  - Downloading symfony/polyfill-php72 (v1.25.0)
  - Downloading symfony/polyfill-mbstring (v1.25.0)
  - Downloading symfony/var-dumper (v4.4.39)
  - Downloading symfony/deprecation-contracts (v2.5.1)
. . .
Generating optimized autoload files
> Illuminate\Foundation\ComposerScripts::postAutoloadDump
> @php artisan package:discover --ansi
Discovered Package: facade/ignition
Discovered Package: fideloper/proxy
Discovered Package: laravel/tinker
Discovered Package: nesbot/carbon
Discovered Package: nunomaduro/collision
Package manifest generated successfully.

L'ultima cosa che dobbiamo fare prima di testare l'applicazione è generare una chiave univoca dell'applicazione con l'artisan Strumento da riga di comando di Laravel. Questa chiave viene utilizzata per crittografare le sessioni utente e altri dati sensibili:

docker-compose exec app php artisan key:generate

OutputApplication key set successfully.

Ora vai al tuo browser e accedi al nome di dominio o all'indirizzo IP del tuo server sulla porta 8000:

http://server_domain_or_IP:8000

Nota :Se stai eseguendo questa demo sul tuo computer locale, usa http://localhost:8000 per accedere all'applicazione dal tuo browser.

Vedrai una pagina come questa:

Puoi usare i logs comando per controllare i log generati dai tuoi servizi:

docker-compose logs nginx

Attaching to travellist-nginx
. . .
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:49:16 +0000] "GET / HTTP/1.1" 200 627 "-" "curl/7.82.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"

Se desideri mettere in pausa il tuo ambiente Docker Compose mantenendo lo stato di tutti i suoi servizi, esegui:

docker-compose pause

OutputPausing travellist-db    ... done
Pausing travellist-nginx ... done
Pausing travellist-app   ... done

Potrai quindi riprendere i tuoi servizi con:

docker-compose unpause

OutputUnpausing travellist-app   ... done
Unpausing travellist-nginx ... done
Unpausing travellist-db    ... done

Per chiudere l'ambiente Docker Compose e rimuovere tutti i suoi contenitori, reti e volumi, esegui:

docker-compose down

OutputStopping travellist-nginx ... done
Stopping travellist-db    ... done
Stopping travellist-app   ... done
Removing travellist-nginx ... done
Removing travellist-db    ... done
Removing travellist-app   ... done
Removing network travellist-laravel-demo_travellist

Per una panoramica di tutti i comandi Docker Compose, controlla il riferimento della riga di comando Docker Compose.

Conclusione

In questa guida, abbiamo configurato un ambiente Docker con tre contenitori utilizzando Docker Compose per definire la nostra infrastruttura in un file YAML.

Da questo momento in poi, puoi lavorare sulla tua applicazione Laravel senza dover installare e configurare un server web locale per lo sviluppo e il test. Inoltre, lavorerai con un ambiente usa e getta che può essere facilmente replicato e distribuito, il che può essere utile durante lo sviluppo della tua applicazione e anche quando ti muovi verso un ambiente di produzione.