Laravel Docker · 18 min read · Sep 23, 2025
Cómo instalar Laravel con Docker en Ubuntu 22.04
Laravel es un marco de trabajo PHP gratuito y de código abierto que proporciona un conjunto de herramientas y recursos para construir aplicaciones PHP modernas. Con una amplia variedad de paquetes y extensiones compatibles, Laravel se ha vuelto popular, siendo adoptado por muchos desarrolladores como su marco de trabajo preferido. Laravel proporciona potentes herramientas de base de datos, incluyendo un ORM (Object Relational Mapper) llamado Eloquent y mecanismos integrados para crear migraciones de base de datos. Viene con una herramienta de línea de comandos llamada Artisan, que permite a los desarrolladores crear nuevos modelos, controladores y otros componentes de la aplicación, lo que acelera el desarrollo general de la aplicación.
Contenerizar una aplicación se refiere al proceso de adaptar una aplicación y sus componentes para poder ejecutarla en entornos ligeros conocidos como contenedores. Esta guía utilizará Docker Compose para contenerizar una aplicación Laravel para desarrollo.
Crearemos tres contenedores Docker para nuestra aplicación Laravel.
- Un servicio
appque ejecuta PHP 8.2-FPM - Un servicio
dbque ejecuta MySQL 8.0 - Un servicio
nginxque utiliza el servicioapppara analizar el código PHP antes de servir la aplicación Laravel al usuario
También crearemos un certificado SSL para nuestro sitio web Laravel utilizando Let’s Encrypt.
Requisitos previos
- Un servidor que ejecute Ubuntu 22.04.
- Un usuario no root con privilegios sudo.
- Un nombre de dominio completamente calificado (FQDN) apuntando a su servidor. Para nuestros propósitos, utilizaremos
example.comcomo el nombre de dominio. - Asegúrese de que todo esté actualizado.
$ sudo apt update - Instale paquetes de utilidad básicos. Algunos de ellos pueden estar ya instalados.
$ sudo apt install wget curl nano software-properties-common dirmngr apt-transport-https gnupg gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -y
Paso 1 - Configurar el Firewall
El primer paso es configurar el firewall. Ubuntu viene con ufw (Uncomplicated Firewall) por defecto.
Verifique si el firewall está en funcionamiento.
$ sudo ufw status
Debería obtener la siguiente salida.
Estado: inactivo
Permita el puerto SSH para que el firewall no interrumpa la conexión actual al habilitarlo.
$ sudo ufw allow OpenSSH
Permita también los puertos HTTP y HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Habilite el Firewall
$ sudo ufw enable
El comando puede interrumpir las conexiones ssh existentes. ¿Proceder con la operación (y|n)? y
El firewall está activo y habilitado al inicio del sistema
Verifique el estado del firewall nuevamente.
$ sudo ufw status
Debería ver una salida similar.
Estado: activo
Para Acción Desde
-- ------ ----
OpenSSH PERMITIR En cualquier lugar
80/tcp PERMITIR En cualquier lugar
443 PERMITIR En cualquier lugar
OpenSSH (v6) PERMITIR En cualquier lugar (v6)
80/tcp (v6) PERMITIR En cualquier lugar (v6)
443 (v6) PERMITIR En cualquier lugar (v6)
Paso 2 - Instalar SSL
Antes de continuar, primero crearemos un certificado SSL para nuestro dominio. Crearemos esto fuera de Docker ya que es fácil de mantener. Más tarde sincronizaremos los certificados con el contenedor, que serán renovados y actualizados regularmente.
Necesitamos instalar Certbot para generar el certificado SSL. Puede instalar Certbot utilizando el repositorio de Ubuntu o obtener la última versión utilizando la herramienta Snapd. Usaremos la versión de Snapd.
Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecute los siguientes comandos para asegurarse de que su versión de Snapd esté actualizada. Asegúrese de que su versión de Snapd esté actualizada.
$ sudo snap install core
$ sudo snap refresh core
Instale Certbot.
$ sudo snap install --classic certbot
Utilice el siguiente comando para asegurarse de que el comando Certbot se ejecute creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Ejecute el siguiente comando para generar un Certificado SSL.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/example.com en su servidor.
Genere un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Haga una prueba del proceso para verificar si la renovación de SSL está funcionando correctamente.
$ sudo certbot renew --dry-run
Si no ve errores, está todo listo. Su certificado se renovará automáticamente.
Después de configurar Docker e instalar Laravel, el proceso de renovación necesitará ser modificado. Lo cubriremos en una sección posterior.
Paso 3 - Instalar Docker y Docker Compose
Ubuntu 22.04 viene con una versión más antigua de Docker. Para instalar la última versión, primero importe la clave GPG de Docker.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Cree un archivo de repositorio de 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
Actualice la lista de repositorios del sistema.
$ sudo apt update
Instale la última versión de Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Verifique que esté en funcionamiento.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Cargado: cargado (/lib/systemd/system/docker.service; habilitado; preset del proveedor: habilitado)
Activo: activo (en ejecución) desde Sat 2023-01-14 10:41:35 UTC; hace 2min 1s
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 2054 (dockerd)
Tareas: 52
Memoria: 22.5M
CPU: 248ms
CGroup: /system.slice/docker.service
?? 2054 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Por defecto, Docker requiere privilegios de root. Si desea evitar usar sudo cada vez que ejecute el comando docker, agregue su nombre de usuario al grupo docker.
$ sudo usermod -aG docker $(whoami)
Necesitará cerrar sesión del servidor y volver a iniciar sesión como el mismo usuario para habilitar este cambio o usar el siguiente comando.
$ su - ${USER}
Confirme que su usuario ha sido agregado al grupo Docker.
$ groups
navjot wheel docker
Paso 4 - Descargar Laravel e instalar dependencias
El primer paso es descargar la última versión de Laravel e instalar las dependencias, incluyendo Composer, el gestor de paquetes de PHP.
Cree el directorio de la aplicación Laravel.
$ mkdir ~/laravel
Cámbiese al directorio.
$ cd ~/laravel
Clone la última versión de Laravel en el directorio. No olvide el . al final del comando, que significa que Git clonará los archivos en el directorio actual.
$ git clone https://github.com/laravel/laravel.git .
Utilice la imagen de Compose de Docker para montar los directorios que necesita para su proyecto Laravel. Esto evita la necesidad de instalar Composer globalmente.
$ docker run --rm -v $(pwd):/app composer install
El comando anterior crea un contenedor efímero que está montado en su directorio actual antes de ser eliminado. Copia el contenido de su directorio Laravel al contenedor y asegura que la carpeta vendor que Composer crea dentro del contenedor se copie de nuevo al directorio actual.
Establezca permisos en el directorio Laravel para que sea propiedad del usuario que ha iniciado sesión actualmente.
$ sudo chown -R $USER:$USER ~/laravel
Paso 5 - Crear el archivo Docker Compose
Cree y abra el archivo Docker compose para editar.
$ nano docker-compose.yml
Pegue el siguiente código en él. Aquí, definimos tres servicios: app, webserver y db. Reemplace MYSQL_ROOT_PASSWORD bajo el servicio db con una contraseña fuerte de su elección.
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
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite.
Repasemos los servicios en detalle.
app- Este servicio define la aplicación Laravel y ejecuta una imagen Docker personalizada tituladahowtoforge/app. Crearemos esta imagen en el siguiente paso. El directorio de trabajo para Laravel dentro del contenedor se establece en/var/www, que está mapeado al directorio actual en el host. También montamos un archivo de configuración de PHP que se copia al contenedor PHP. Configuraremos esto en un paso posterior.webserver- Este servicio crea un contenedor utilizando la imagen Docker de Nginx y expone los puertos 80 y 443 al host. También montamos volúmenes para los registros de Nginx, configuración personalizada, el directorio de la aplicación Laravel y certificados SSL.db- Este servicio crea un contenedor utilizando la imagen Docker de MySQL y define variables de entorno que configuran el nombre de la base de datos y la contraseña de root de MySQL. Puede nombrar la base de datos como desee y reemplazarMYSQL_ROOT_PASSWORDcon una contraseña fuerte de su elección. También establezca el nombre de usuario de MySQL (MYSQL_USER_NAME) y la contraseña (MYSQL_USER_PASSWORD) que tendrán acceso a la base de datos que eligió. Este servicio también mapea el puerto 3306 del contenedor al puerto 3306 en el host. También montamos un volumen para la configuración personalizada de MySQL y un volumen local para los datos de MySQL. Esto le permite reiniciar el serviciodbsin perder los datos.
Para hacer que los servicios se comuniquen entre sí, hemos creado una red Docker llamada app-network. Está configurada como una red de puente. Permite que los contenedores conectados a ella se comuniquen entre sí. El controlador de red de puente instala reglas en la máquina host para que los contenedores en diferentes redes de puente no puedan comunicarse directamente entre sí.
Paso 6 - Crear el Dockerfile
Un Dockerfile se utiliza para crear imágenes personalizadas. No hay una imagen estándar para Laravel, por lo que necesitamos definir un Dockerfile para crear una imagen personalizada para Laravel. Contiene comandos para instalar paquetes y configurar el entorno de Linux según las necesidades de su aplicación. También puede publicar su imagen personalizada en Docker Hub o en cualquier registro privado de Docker. Puede aprender más en nuestro tutorial de Dockerfile.
Cree y abra el Dockerfile para editar.
$ nano Dockerfile
Pegue el siguiente código en él.
FROM php:8.2-fpm
# Copiar composer.lock y composer.json
COPY composer.lock composer.json /var/www/
# Establecer el directorio de trabajo
WORKDIR /var/www
# Instalar dependencias
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
# Limpiar caché
RUN apt-get clean && rm -rf /var/lib/apt/lists/*
# Instalar extensiones
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
# Instalar composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
# Copiar el contenido del directorio de la aplicación existente al directorio de trabajo
COPY . /var/www
# Asignar permisos del directorio de trabajo al usuario www-data
RUN chown -R www-data:www-data \
/var/www/storage \
/var/www/bootstrap/cache
# Asignar permisos de escritura a los registros y directorios del framework
RUN chmod 775 storage/logs \
/var/www/storage/framework/sessions \
/var/www/storage/framework/views
# Exponer el puerto 9000 y comenzar el servidor php-fpm
EXPOSE 9000
CMD ["php-fpm"]
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite.
Veamos qué está sucediendo aquí. Primero, creamos nuestra imagen personalizada sobre la imagen php:8.2-fpm de Docker. Esta es una imagen basada en Debian que tiene PHP 8.2-FPM instalado. El Dockerfile utiliza varias directivas para realizar operaciones, la directiva RUN especifica los comandos para actualizar, instalar y configurar ajustes dentro del contenedor, la directiva COPY para copiar archivos dentro del contenedor, la directiva EXPOSE para exponer un puerto en el contenedor, y la directiva CMD para ejecutar un comando.
Primero, copiamos los archivos de Composer desde el directorio Laravel en el host dentro del contenedor al directorio /var/www. También establecemos el directorio de trabajo para el contenedor en /var/www. Luego, instalamos varios requisitos y paquetes necesarios para que Laravel funcione, incluyendo extensiones de PHP como mbstring, gd, exif, zip, pdo_mysql y pcntl. Luego, instalamos el gestor de paquetes Composer.
A continuación, copiamos todos los archivos del directorio Laravel al contenedor y establecemos permisos en el directorio de trabajo para el usuario www-data. Este es el usuario que PHP utiliza por defecto en la plataforma Debian. A continuación, establecemos los permisos de escritura correctos para los registros, sesiones y directorios de vistas de Laravel.
Y finalmente, exponemos el puerto 9000 para el servicio PHP-FPM que será utilizado por el servidor Nginx, y ejecutamos el comando PHP para iniciar el contenedor.
Paso 7 - Configurar PHP
Cree el directorio PHP.
$ mkdir ~/laravel/php
Cree y abra el archivo local.ini para editar.
$ nano local.ini
Pegue el siguiente código en él.
upload_max_filesize=40M
post_max_size=40M
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite. Estas directivas establecen el tamaño máximo de los archivos subidos. Cambie el valor según sus requisitos. Puede poner cualquier configuración específica de PHP para anular las directivas predeterminadas.
Paso 8 - Configurar Nginx
Cree el directorio Nginx para la configuración del sitio.
$ mkdir ~/laravel/nginx/conf.d -p
Necesitamos crear un archivo de configuración de Nginx para usar PHP-FPM como el servidor FastCGI para servir Laravel.
Cree y abra el archivo app.conf para editar.
$ nano ~/laravel/nginx/conf.d/app.conf
Pegue el siguiente código en él.
server {
# Redirigir cualquier solicitud 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;
}
}
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite.
El archivo anterior configura Nginx para servir tanto las versiones HTTP como HTTPS del sitio Laravel y redirigir automáticamente cualquier solicitud HTTP a HTTPS. Asegúrese de que el valor de la variable client_max_body_size coincida con el tamaño de carga establecido en el paso anterior.
En el bloque de ubicación de PHP, la directiva fastcgi_pass especifica que el servicio app está escuchando en un socket TCP en el puerto 9000. El servidor PHP-FPM también puede escuchar en un socket Unix, que tiene una ventaja sobre un socket TCP. Pero no funciona si los servicios se ejecutan en hosts diferentes, que es el caso aquí, ya que el contenedor app se está ejecutando en un host diferente al de su contenedor webserver.
Paso 9 - Configurar MySQL
Configuraremos MySQL para habilitar el registro de consultas generales y especificar el archivo de registro correspondiente.
Cree el directorio MySQL.
$ mkdir ~/laravel/mysql
Cree y abra el archivo my.cnf para editar.
$ nano ~/laravel/my.cnf
Pegue el siguiente código en él.
[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite.
Paso 10 - Configurando el archivo de entorno
Ahora que hemos creado y configurado todos los servicios, es hora de iniciar los contenedores. Pero antes de hacerlo, necesitamos configurar las variables de entorno para Laravel. Laravel viene con un archivo de entorno predeterminado, .env.example.
Cree una copia del archivo de entorno de ejemplo.
$ cp .env.example .env
Abra el archivo .env para editar.
$ nano .env
Encuentre el bloque que comienza con DB_CONNECTION y actualice los valores de las variables de acuerdo a sus requisitos.
DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=laravel
DB_USERNAME=laraveluser
DB_PASSWORD=your_laravel_db_password
El valor de DB_HOST será el servicio db. DB_NAME, DB_USERNAME y DB_PASSWORD serán el nombre de la base de datos, el nombre de usuario y la contraseña que eligió en el paso 4 en el archivo Docker compose.
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite.
Paso 11 - Iniciar los contenedores y completar la instalación de Laravel
Finalmente, es hora de iniciar los contenedores.
$ docker compose up -d
Este comando, cuando se ejecuta por primera vez, descargará las imágenes de Nginx, MySQL y creará la imagen app utilizando el Dockerfile que creamos. Una vez que el proceso esté completo, puede verificar el estado de sus contenedores utilizando el siguiente comando.
$ docker ps
Verá una salida similar.
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 vez que los contenedores estén en funcionamiento, es hora de terminar de instalar Laravel utilizando el comando docker compose exec para ejecutar comandos dentro del contenedor.
Genere una clave de aplicación y cópiela en su archivo .env para asegurar las sesiones de usuario y cifrar los datos de usuario.
$ docker compose exec app php artisan key:generate
Cree la caché de la aplicación Laravel.
$ docker compose exec app php artisan config:cache
Este comando cargará la configuración en el archivo /var/www/bootstrap/cache/config.php.
Visite https://example.com en su navegador y verá la siguiente página que implica la instalación exitosa de Laravel.
Paso 12 - Configurar la renovación de SSL
Ahora que el sitio Laravel está activo, es hora de revisar la configuración de SSL para configurar la renovación. Para esto, necesitaremos crear scripts para detener el servicio webserver antes de comenzar la renovación y reiniciar el servicio una vez que se renueve el certificado. Certbot proporciona dos hooks, pre_hook y post_hook para este propósito.
Cree el directorio SSL para almacenar los scripts.
$ mkdir ~/laravel/ssl
Cree el script server-stop.sh.
$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'
Cree el script server-start.sh.
$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'
Haga que los scripts sean ejecutables.
$ chmod +x ~/laravel/ssl/server-*.sh
Ahora necesitamos decirle a Certbot que use estos scripts. Abra el archivo /etc/letsencrypt/renewal/example.com.conf para editar.
$ sudo nano /etc/letsencrypt/renewal/example.com.conf
Pegue las siguientes líneas al final del archivo.
pre_hook = /home//laravel/ssl/server-stop.sh
post_hook = /home//laravel/ssl/server-start.sh
Guarde el archivo presionando Ctrl + X y luego Y cuando se le solicite.
Pruebe el proceso de renovación del certificado haciendo una prueba.
$ sudo certbot renew --dry-run
Obtendrá una salida similar que confirma el éxito.
Guardando el registro de depuración en /var/log/letsencrypt/letsencrypt.log
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Procesando /etc/letsencrypt/renewal/example.com.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Cuenta registrada.
El hook 'pre-hook' se ejecutó con salida:
webserver
Simulando la renovación de un certificado existente para example.com
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Felicidades, todas las renovaciones simuladas tuvieron éxito:
/etc/letsencrypt/live/example.com/fullchain.pem (éxito)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
El hook 'post-hook' se ejecutó con salida:
webserver
Sus certificados SSL ahora se renovarán automáticamente y se utilizarán por el contenedor Docker para servir su aplicación Laravel.
Paso 13 - Migración de datos y consola Tinker
Ahora que la aplicación está en funcionamiento, puede migrar sus datos y experimentar con el comando tinker. Tinker es un REPL (Read-Eval-Print Loop) para Laravel. El comando tinker inicia una consola PsySH con Laravel precargado. PsySH es una consola de desarrollador en tiempo de ejecución y un depurador interactivo para PHP. El comando tinker le permite interactuar con la aplicación Laravel desde la línea de comandos en un shell interactivo.
Pruebe la conexión MySQL utilizando el comando artisan migrate en el contenedor. Creará una tabla migrations en la base de datos.
$ docker compose exec app php artisan migrate
Obtendrá la siguiente salida.
INFO Preparando la base de datos.
Creando tabla de migración .............................................................................................. 32ms HECHO
INFO Ejecutando migraciones.
2014_10_12_000000_create_users_table .................................................................................. 184ms HECHO
2014_10_12_100000_create_password_resets_table ......................................................................... 259ms HECHO
2019_08_19_000000_create_failed_jobs_table ............................................................................ 102ms HECHO
2019_12_14_000001_create_personal_access_tokens_table .................................................................. 46ms HECHO
A continuación, inicie la consola PsySH utilizando el comando tinker.
$ docker compose exec app php artisan tinker
Obtendrá el siguiente aviso.
Psy Shell v0.11.10 (PHP 8.2.1 — cli) por Justin Hileman
>
Pruebe la conexión MySQL obteniendo los datos que acaba de migrar ejecutando el siguiente comando en el aviso de la consola.
> \DB::table('migrations')->get();
Obtendrá la siguiente salida.
= 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,
},
],
}
Escriba exit para salir de la consola.
> exit
INFO Adiós.
Puede usar tinker para interactuar con sus bases de datos y experimentar con servicios y modelos. Ahora puede comenzar a usar Laravel para un desarrollo adicional.
Conclusión
Esto concluye nuestro tutorial, donde contenedorizamos e instalamos la aplicación Laravel utilizando Docker, MySQL y PHP. También sirvió la aplicación en un nombre de dominio seguro. Si tiene alguna pregunta, publíquelas en los comentarios a continuación.
Recibe nuevas publicaciones en tu bandeja de entrada.
No spam. Cancela la suscripción en cualquier momento.