Laravel Docker · 17 min read · Sep 23, 2025
Come installare Laravel con Docker su Ubuntu 22.04
Laravel è un framework PHP gratuito e open-source che fornisce un insieme di strumenti e risorse per costruire applicazioni PHP moderne. Con una vasta gamma di pacchetti e estensioni compatibili, Laravel è diventato popolare, con molti sviluppatori che lo adottano come il loro framework di scelta. Laravel fornisce potenti strumenti per database, inclusi un ORM (Object Relational Mapper) chiamato Eloquent e meccanismi integrati per la creazione di migrazioni di database. Viene fornito con uno strumento da riga di comando Artisan, con il quale gli sviluppatori possono avviare nuovi modelli, controller e altri componenti dell’applicazione, accelerando lo sviluppo complessivo dell’applicazione.
Containerizzare un’applicazione si riferisce al processo di adattamento di un’applicazione e dei suoi componenti per poterla eseguire in ambienti leggeri noti come contenitori. Questa guida utilizzerà Docker Compose per containerizzare un’applicazione Laravel per lo sviluppo.
Creeremo tre contenitori Docker per la nostra applicazione Laravel.
- Un servizio
appche esegue PHP 8.2-FPM - Un servizio
dbche esegue MySQL 8.0 - Un servizio
nginxche utilizza il servizioappper analizzare il codice PHP prima di servire l’applicazione Laravel all’utente
Creeremo anche un certificato SSL per il nostro sito web Laravel utilizzando Let’s Encrypt.
Prerequisiti
- Un server che esegue Ubuntu 22.04.
- Un utente non root con privilegi sudo.
- Un nome di dominio completamente qualificato (FQDN) che punta al tuo server. Per i nostri scopi, utilizzeremo
example.comcome nome di dominio. - Assicurati che tutto sia aggiornato.
$ sudo apt update - Installa pacchetti di utilità di base. Alcuni di essi potrebbero già essere installati.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Passo 1 - Configurare il Firewall
Il primo passo è configurare il firewall. Ubuntu viene fornito con ufw (Uncomplicated Firewall) per impostazione predefinita.
Controlla se il firewall è attivo.
$ sudo ufw status
Dovresti ottenere il seguente output.
Status: inactive
Consenti la porta SSH affinché il firewall non interrompa la connessione attuale quando viene abilitato.
$ sudo ufw allow OpenSSH
Consenti anche le porte HTTP e HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Abilita il Firewall
$ sudo ufw enable
Il comando potrebbe interrompere le connessioni ssh esistenti. Procedere con l'operazione (y|n)? y
Il firewall è attivo e abilitato all'avvio del sistema
Controlla di nuovo lo stato del firewall.
$ sudo ufw status
Dovresti vedere un output simile.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443 ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443 (v6) ALLOW Anywhere (v6)
Passo 2 - Installare SSL
Prima di procedere, creiamo prima un certificato SSL per il nostro dominio. Creeremo questo al di fuori di Docker poiché è facile da mantenere. Sincronizzeremo in seguito i certificati nel contenitore che verranno rinnovati e aggiornati regolarmente.
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata. Assicurati che la tua versione di Snapd sia aggiornata.
$ sudo snap install core
$ sudo snap refresh core
Installa Certbot.
$ sudo snap install --classic certbot
Usa il seguente comando per assicurarti che il comando Certbot venga eseguito creando un collegamento simbolico alla directory /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Esegui il seguente comando per generare un certificato SSL.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.
Genera un certificato Diffie-Hellman group.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Fai una prova del processo per controllare se il rinnovo SSL funziona correttamente.
$ sudo certbot renew --dry-run
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Dopo aver impostato Docker e installato Laravel, il processo di rinnovo dovrà essere modificato. Lo tratteremo in una sezione successiva.
Passo 3 - Installare Docker e Docker Compose
Ubuntu 22.04 viene fornito con una versione più vecchia di Docker. Per installare l’ultima versione, prima importa la chiave GPG di Docker.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Crea un file di repository Docker.
$ echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aggiorna l’elenco dei repository di sistema.
$ sudo apt update
Installa l’ultima versione di Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Verifica che sia in esecuzione.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Sat 2023-01-14 10:41:35 UTC; 2min 1s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 2054 (dockerd)
Tasks: 52
Memory: 22.5M
CPU: 248ms
CGroup: /system.slice/docker.service
?? 2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Per impostazione predefinita, Docker richiede privilegi di root. Se desideri evitare di utilizzare sudo ogni volta che esegui il comando docker, aggiungi il tuo nome utente al gruppo docker.
$ sudo usermod -aG docker $(whoami)
Dovrai disconnetterti dal server e riconnetterti come lo stesso utente per abilitare questa modifica o utilizzare il seguente comando.
$ su - ${USER}
Conferma che il tuo utente sia stato aggiunto al gruppo Docker.
$ groups
navjot wheel docker
Passo 4 - Scaricare Laravel e Installare le Dipendenze
Il primo passo è scaricare l’ultima versione di Laravel e installare le dipendenze, incluso Composer, il gestore di pacchetti PHP.
Crea la directory dell’applicazione Laravel.
$ mkdir ~/laravel
Passa alla directory.
$ cd ~/laravel
Clona l’ultima versione di Laravel nella directory. Non dimenticare il . alla fine del comando che significa che Git clonerà i file nella directory corrente.
$ git clone https://github.com/laravel/laravel.git .
Usa l’immagine Compose di Docker per montare le directory di cui hai bisogno per il tuo progetto Laravel. Questo evita la necessità di installare Composer globalmente.
$ docker run --rm -v $(pwd):/app composer install
Il comando sopra crea un contenitore effimero che è montato in modo bind nella tua directory corrente prima di essere rimosso. Copia il contenuto della tua directory Laravel nel contenitore e assicura che la cartella vendor che Composer crea all’interno del contenitore venga copiata di nuovo nella directory corrente.
Imposta i permessi sulla directory Laravel in modo che sia di proprietà dell’utente attualmente connesso.
$ sudo chown -R $USER:$USER ~/laravel
Passo 5 - Creare il File Docker Compose
Crea e apri il file Docker compose per la modifica.
$ nano docker-compose.yml
Incolla il seguente codice in esso. Qui definiamo tre servizi: app, webserver e db. Sostituisci MYSQL_ROOT_PASSWORD sotto il servizio db con una password forte a tua scelta.
services:
app:
build:
context: .
dockerfile: Dockerfile
image: howtoforge/app
container_name: app
restart: unless-stopped
tty: true
environment:
SERVICE_NAME: app
SERVICE_TAGS: dev
working_dir: /var/www
volumes:
- ./:/var/www
- ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
networks:
- app-network
webserver:
container_name: webserver
image: nginx:alpine
restart: unless-stopped
tty: true
ports:
- 80:80
- 443:443
volumes:
- ./:/var/www
- ./nginx/conf.d:/etc/nginx/conf.d
- ./nginx/logs:/var/log/nginx
- /etc/ssl/certs/dhparam.pem:/etc/ssl/certs/dhparam.pem
- /etc/letsencrypt:/etc/letsencrypt
logging:
options:
max-size: "10m"
max-file: "3"
networks:
- app-network
db:
image: mysql:latest
container_name: db
restart: unless-stopped
tty: true
ports:
- "3306:3306"
environment:
MYSQL_DATABASE: laravel
MYSQL_ROOT_PASSWORD: MYSQL_ROOT_PASSWORD
MYSQL_USER: laraveluser
MYSQL_PASSWORD: password
SERVICE_TAGS: dev
SERVICE_NAME: mysql
volumes:
- dbdata:/var/lib/mysql
- ./mysql/my.cnf:/etc/mysql/my.cnf
networks:
- app-network
volumes:
dbdata:
driver: local
networks:
app-network:
driver: bridge
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Esaminiamo i servizi in dettaglio.
app- Questo servizio definisce l’applicazione Laravel e esegue un’immagine Docker personalizzata intitolatahowtoforge/app. Creeremo questa immagine nel passo successivo. La directory di lavoro per Laravel all’interno del contenitore è impostata su/var/www, che è mappata alla directory corrente sull’host. Montiamo anche un file di configurazione PHP che viene copiato nel contenitore PHP. Configureremo questo in un passo successivo.webserver- Questo servizio crea un contenitore utilizzando l’immagine Docker Nginx ed espone le porte 80 e 443 all’host. Montiamo anche volumi per i log di Nginx, la configurazione personalizzata, la directory dell’applicazione Laravel e i certificati SSL.db- Questo servizio crea un contenitore utilizzando l’immagine Docker MySQL e definisce variabili ambientali per impostare il nome del database e la password di root di MySQL. Puoi nominare il database come vuoi e sostituireMYSQL_ROOT_PASSWORDcon una password forte a tua scelta. Imposta anche il nome utente di MySQL (MYSQL_USER_NAME) e la password (MYSQL_USER_PASSWORD) che avranno accesso al database scelto. Questo servizio mappa anche la porta 3306 dal contenitore alla porta 3306 sull’host. Montiamo anche un volume per la configurazione personalizzata di MySQL e un volume locale per i dati di MySQL. Questo ti consente di riavviare il serviziodbsenza perdere i dati.
Per far comunicare i servizi tra loro, abbiamo creato una rete Docker chiamata app-network. È impostata come rete bridge. Consente ai contenitori connessi di comunicare tra loro. Il driver di rete bridge installa regole nella macchina host in modo che i contenitori su reti bridge diverse non possano comunicare direttamente tra loro.
Passo 6 - Creare il Dockerfile
Un Dockerfile viene utilizzato per creare immagini personalizzate. Non esiste un’immagine standard per Laravel, motivo per cui dobbiamo definire un Dockerfile per creare un’immagine personalizzata per Laravel. Contiene comandi per installare pacchetti e configurare l’ambiente Linux a seconda delle esigenze della tua applicazione. Puoi anche pubblicare la tua immagine personalizzata su Docker Hub o su qualsiasi registro Docker privato. Puoi saperne di più nel nostro tutorial sul Dockerfile.
Crea e apri il Dockerfile per la modifica.
$ nano Dockerfile
Incolla il seguente codice in esso.
FROM php:8.2-fpm
# Copia composer.lock e composer.json
COPY composer.lock composer.json /var/www/
# Imposta la directory di lavoro
WORKDIR /var/www
# Installa le dipendenze
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 \
curl \
libonig-dev
# Pulisci la cache
RUN apt-get clean && rm -rf /var/lib/apt/lists/*
# Installa le estensioni
RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
RUN docker-php-ext-configure gd --enable-gd --with-freetype --with-jpeg
RUN docker-php-ext-install gd
# Installa composer
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
# Assegna i permessi della directory di lavoro all'utente www-data
RUN chown -R www-data:www-data \
/var/www/storage \
/var/www/bootstrap/cache
# Assegna permessi di scrittura alle directory di log e framework
RUN chmod 775 storage/logs \
/var/www/storage/framework/sessions \
/var/www/storage/framework/views
# Espone la porta 9000 e avvia il server php-fpm
EXPOSE 9000
CMD ["php-fpm"]
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Vediamo cosa sta succedendo qui. Prima di tutto, creiamo la nostra immagine personalizzata sopra l’immagine docker:php:8.2-fpm. Questa è un’immagine basata su Debian che ha PHP 8.2-FPM installato. Il Dockerfile utilizza varie direttive per eseguire operazioni, la direttiva RUN specifica i comandi per aggiornare, installare e configurare le impostazioni all’interno del contenitore, la direttiva COPY per copiare file nel contenitore, la direttiva EXPOSE per esporre una porta nel contenitore e la direttiva CMD per eseguire un comando.
Prima copiamo i file di Composer dalla directory Laravel sull’host all’interno del contenitore nella directory /var/www. Impostiamo anche la directory di lavoro per il contenitore su /var/www. Poi installiamo vari prerequisiti e pacchetti richiesti per il funzionamento di Laravel, inclusi le estensioni PHP come mbstring, gd, exif, zip, pdo_mysql e pcntl. Infine, installiamo il gestore di pacchetti Composer.
Successivamente, copiamo tutti i file dalla directory Laravel nel contenitore e impostiamo i permessi sulla directory di lavoro per l’utente www-data. Questo è l’utente che PHP utilizza per impostazione predefinita sulla piattaforma Debian. Infine, esponiamo la porta 9000 per il servizio PHP-FPM che sarà utilizzata dal server Nginx e avviamo il comando PHP per avviare il contenitore.
Passo 7 - Configurare PHP
Crea la directory PHP.
$ mkdir ~/laravel/php
Crea e apri il file local.ini per la modifica.
$ nano local.ini
Incolla il seguente codice in esso.
upload_max_filesize=40M
post_max_size=40M
Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Queste direttive impostano la dimensione massima caricata per i file caricati. Cambia il valore in base alle tue esigenze. Puoi inserire qualsiasi configurazione specifica di PHP per sovrascrivere le direttive predefinite.
Passo 8 - Configurare Nginx
Crea la directory Nginx per la configurazione del sito.
$ mkdir ~/laravel/nginx/conf.d -p
Dobbiamo creare un file di configurazione Nginx per utilizzare PHP-FPM come server FastCGI per servire Laravel.
Crea e apri il file app.conf per la modifica.
$ nano ~/laravel/nginx/conf.d/app.conf
Incolla il seguente codice in esso.
server {
# Reindirizza tutte le richieste http a https
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
index index.php index.html;
error_log /var/log/nginx/error.log;
access_log /var/log/nginx/access.log;
root /var/www/public;
client_max_body_size 40m;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
ssl_ecdh_curve secp384r1;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# OCSP stapling
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8 8.8.4.4 valid=300s;
resolver_timeout 5s;
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;
}
}
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Il file sopra configura Nginx per servire sia le versioni HTTP che HTTPS del sito Laravel e reindirizza automaticamente qualsiasi richiesta HTTP a HTTPS. Assicurati che il valore della variabile client_max_body_size corrisponda alla dimensione di upload impostata nel passo precedente.
Nel blocco di posizione PHP, la direttiva fastcgi_pass specifica che il servizio app sta ascoltando su un socket TCP sulla porta 9000. Il server PHP-FPM può anche ascoltare su un socket Unix, che ha un vantaggio rispetto a un socket TCP. Ma non funziona se i servizi sono in esecuzione su host diversi, come nel caso in cui il contenitore app sta girando su un host diverso dal tuo contenitore webserver.
Passo 9 - Configurare MySQL
Configureremo MySQL per abilitare il log delle query generali e specificare il file di log corrispondente.
Crea la directory MySQL.
$ mkdir ~/laravel/mysql
Crea e apri il file my.cnf per la modifica.
$ nano ~/laravel/my.cnf
Incolla il seguente codice in esso.
[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passo 10 - Configurare il File di Ambiente
Ora che abbiamo creato e configurato tutti i servizi, è tempo di avviare i contenitori. Ma prima di farlo, dobbiamo configurare le variabili ambientali per Laravel. Laravel viene fornito con un file di ambiente predefinito, .env.example.
Crea una copia del file di ambiente di esempio.
$ cp .env.example .env
Apri il file .env per la modifica.
$ nano .env
Trova il blocco che inizia con DB_CONNECTION e aggiorna i valori delle variabili in base alle tue esigenze.
DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password
Il valore di DB_HOST sarà il servizio db. I valori di DB_NAME, DB_USERNAME e DB_PASSWORD saranno il nome del database, il nome utente e la password che hai scelto nel passo 4 nel file Docker compose.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passo 11 - Avviare i Contenitori e completare l’installazione di Laravel
È finalmente tempo di avviare i contenitori.
$ docker compose up -d
Questo comando, quando eseguito per la prima volta, scaricherà le immagini Nginx, MySQL e creerà l’immagine app utilizzando il Dockerfile che abbiamo creato. Una volta completato il processo, puoi controllare lo stato dei tuoi contenitori utilizzando il seguente comando.
$ docker ps
Vedrai un output simile.
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a57be976c0fa mysql:latest "docker-entrypoint.s…" 6 hours ago Up 6 hours 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp db
85e515c4a404 howtoforge/app "docker-php-entrypoi…" 6 hours ago Up 6 hours 9000/tcp app
8418bbc83bd3 nginx:alpine "/docker-entrypoint.…" 6 hours ago Up 6 hours 0.0.0.0:80->80/tcp, :::80->80/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp webserver
Una volta che i contenitori sono in esecuzione, è tempo di completare l’installazione di Laravel utilizzando il comando docker compose exec per eseguire comandi all’interno del contenitore.
Genera una chiave per l’applicazione e copiala nel tuo file .env per proteggere le sessioni utente e crittografare i dati degli utenti.
$ docker compose exec app php artisan key:generate
Crea la cache dell’applicazione Laravel.
$ docker compose exec app php artisan config:cache
Questo comando caricherà le impostazioni di configurazione nel file /var/www/bootstrap/cache/config.php.
Visita https://example.com nel tuo browser e vedrai la seguente pagina che implica l’installazione riuscita di Laravel.
Passo 12 - Configurare il Rinnovo SSL
Ora che il sito Laravel è attivo, è tempo di rivedere le impostazioni SSL per configurare il rinnovo. Per questo, dovremo creare script per fermare il servizio webserver prima di avviare il rinnovo e riavviare il servizio una volta rinnovato il certificato. Certbot fornisce due hook, pre_hook e post_hook per questo scopo.
Crea la directory SSL per memorizzare gli script.
$ mkdir ~/laravel/ssl
Crea lo script server-stop.sh.
$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'
Crea lo script server-start.sh.
$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'
Rendi gli script eseguibili.
$ chmod +x ~/laravel/ssl/server-*.sh
Ora dobbiamo dire a Certbot di utilizzare questi script. Apri il file /etc/letsencrypt/renewal/example.com.conf per la modifica.
$ sudo nano /etc/letsencrypt/renewal/example.com.conf
Incolla le seguenti righe alla fine del file.
pre_hook = /home//laravel/ssl/server-stop.sh
post_hook = /home//laravel/ssl/server-start.sh
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Testa il processo di rinnovo del certificato facendo una prova.
$ sudo certbot renew --dry-run
Riceverai un output simile che conferma il successo.
Saving debug log to /var/log/letsencrypt/letsencrypt.log
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/example.com.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Account registered.
Hook 'pre-hook' ran with output:
webserver
Simulating renewal of an existing certificate for example.com
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Congratulations, all simulated renewals succeeded:
/etc/letsencrypt/live/example.com/fullchain.pem (success)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Hook 'post-hook' ran with output:
webserver
I tuoi certificati SSL verranno ora rinnovati automaticamente e utilizzati dal contenitore Docker per servire la tua applicazione Laravel.
Passo 13 - Migrazione dei Dati e Console Tinker
Ora che l’applicazione è in esecuzione, puoi migrare i tuoi dati e sperimentare con il comando tinker. Tinker è un REPL (Read-Eval-Print Loop) per Laravel. Il comando tinker avvia una console PsySH con Laravel precaricato. PsySH è una console per sviluppatori runtime e un debugger interattivo per PHP. Il comando tinker ti consente di interagire con l’applicazione Laravel dalla riga di comando in una shell interattiva.
Testa la connessione MySQL utilizzando il comando artisan migrate sul contenitore. Creerà una tabella migrations nel database.
$ docker compose exec app php artisan migrate
Riceverai il seguente output.
INFO Preparing database.
Creating migration table .............................................................................................. 32ms DONE
INFO Running migrations.
2014_10_12_000000_create_users_table .................................................................................. 184ms DONE
2014_10_12_100000_create_password_resets_table ......................................................................... 259ms DONE
2019_08_19_000000_create_failed_jobs_table ............................................................................ 102ms DONE
2019_12_14_000001_create_personal_access_tokens_table .................................................................. 46ms DONE
Successivamente, avvia la console PsySH utilizzando il comando tinker.
$ docker compose exec app php artisan tinker
Riceverai il seguente prompt.
Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>
Testa la connessione MySQL ottenendo i dati che hai appena migrato eseguendo il seguente comando al prompt della console.
> \DB::table('migrations')->get();
Riceverai il seguente output.
= Illuminate\Support\Collection {#3670
all: [
{#3679
+"id": 1,
+"migration": "2014_10_12_000000_create_users_table",
+"batch": 1,
},
{#3681
+"id": 2,
+"migration": "2014_10_12_100000_create_password_resets_table",
+"batch": 1,
},
{#3682
+"id": 3,
+"migration": "2019_08_19_000000_create_failed_jobs_table",
+"batch": 1,
},
{#3683
+"id": 4,
+"migration": "2019_12_14_000001_create_personal_access_tokens_table",
+"batch": 1,
},
],
}
Digita exit per uscire dalla console.
> exit
INFO Goodbye.
Puoi usare tinker per interagire con i tuoi database e per sperimentare con servizi e modelli. Ora puoi iniziare a utilizzare Laravel per ulteriori sviluppi.
Conclusione
Questo conclude il nostro tutorial, dove hai containerizzato e installato l’applicazione Laravel utilizzando Docker, MySQL e PHP. Hai anche servito l’applicazione su un nome di dominio sicuro. Se hai domande, pubblicale nei commenti qui sotto.
Ricevi i nuovi post nella tua casella di posta.
Nessuno spam. Disiscriviti in qualsiasi momento.