Cómo instalar Laravel con Docker en Ubuntu 22.04

Laravel es un framework PHP gratuito y de código abierto que proporciona un conjunto de herramientas y recursos para crear aplicaciones PHP modernas. Con una amplia variedad de paquetes y extensiones compatibles, Laravel se ha hecho popular, y muchos desarrolladores lo han adoptado como su framework de elección. Laravel proporciona potentes herramientas de bases de datos, incluido un ORM (Object Relational Mapper) llamado Eloquent y mecanismos integrados para crear migraciones de bases de datos. Incluye una herramienta de línea de comandos, Artisan, con la que los desarrolladores pueden arrancar nuevos modelos, controladores y otros componentes de la aplicación, lo que acelera el desarrollo general de la aplicación.

Contenedorizar 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 su desarrollo.

Crearemos tres contenedores Docker para nuestra aplicación Laravel.

• Un servicio app ejecutando PHP 8.2-FPM
• Un servicio db que ejecuta MySQL 8.0
• Un servicio nginx que utiliza el servicio app para 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 con Ubuntu 22.04.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio completo (FQDN) que apunte a tu servidor. Para nuestro propósito, utilizaremos example.com como nombre de dominio.
• Asegúrate de que todo está actualizado.

  $ sudo apt update
  

• Instala los paquetes de utilidades básicas. Es posible que algunos de ellos ya estén 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 Cortafuegos

El primer paso es configurar el cortafuegos. Ubuntu viene con ufw (Uncomplicated Firewall) por defecto.

Comprueba si el cortafuegos se está ejecutando.

$ sudo ufw status

Deberías obtener la siguiente salida.

Status: inactive

Permite el puerto SSH para que el cortafuegos no rompa la conexión actual al activarlo.

$ sudo ufw allow OpenSSH

Permite también los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Habilita el cortafuegos

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Comprueba de nuevo el estado del cortafuegos.

$ sudo ufw status

Deberías ver un resultado similar.

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)

Paso 2 – Instalar SSL

Antes de continuar, vamos a crear un certificado SSL para nuestro dominio. Lo crearemos fuera de Docker, ya que es fácil de mantener. Más tarde sincronizaremos los certificados con el contenedor, que se renovará y refrescará regularmente.

Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Ubuntu u obtener la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.

Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd está actualizada. Asegúrate de que tu versión de Snapd está actualizada.

$ sudo snap install core
$ sudo snap refresh core

Instala Certbot.

$ sudo snap install --classic certbot

Utiliza el siguiente comando para asegurarte de que se ejecuta el comando Certbot creando un enlace simbólico al directorio /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Ejecuta 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 de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Realiza una ejecución en seco del proceso para comprobar si la renovación SSL funciona correctamente.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.

Después de configurar Docker e instalar Laravel, habrá que modificar el proceso de renovación. Lo veremos en una sección posterior.

Paso 3 – Instalar Docker y Docker Compose

Ubuntu 22.04 incluye una versión antigua de Docker. Para instalar la última versión, primero, importa la clave GPG de Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

Crea 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

Actualiza la lista de repositorios del sistema.

$ sudo apt update

Instala la última versión de Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Comprueba que se está ejecutando.

$ 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

Por defecto, Docker requiere privilegios de root. Si quieres evitar utilizar sudo cada vez que ejecutes el comando docker, añade tu nombre de usuario al grupo docker.

$ sudo usermod -aG docker $(whoami)

Tendrás que salir del servidor y volver a entrar como el mismo usuario para activar este cambio o utilizar el siguiente comando.

$ su - ${USER}

Confirma que tu usuario se ha añadido al grupo Docker.

$ groups
navjot wheel docker

Paso 4 – Descargar Laravel e instalar las dependencias

El primer paso es descargar la última versión de Laravel e instalar las dependencias, incluyendo Composer, el gestor de paquetes PHP.

Crea el directorio de la aplicación Laravel.

$ mkdir ~/laravel

Cambia al directorio.

$ cd ~/laravel

Clona la última versión de Laravel en el directorio. No olvides el . al final del comando, que significa que Git clonará los archivos en el directorio actual.

$ git clone https://github.com/laravel/laravel.git .

Utiliza la imagen Compose de Docker para montar los directorios que necesites para tu 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 se monta en tu directorio actual antes de ser eliminado. Copia el contenido de tu directorio Laravel al contenedor y se asegura de que la carpeta vendor que Composer crea dentro del contenedor se copia de nuevo en el directorio actual.

Establece los permisos en el directorio Laravel para que sea propiedad del usuario actualmente conectado.

$ sudo chown -R $USER:$USER ~/laravel

Paso 5 – Crear el archivo Docker Compose

Crea y abre el archivo Docker compose para editarlo.

$ nano docker-compose.yml

Pega en él el siguiente código. Aquí definimos tres servicios: app, webserver, y db. Sustituye MYSQL_ROOT_PASSWORD en el servicio db por una contraseña segura de tu 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

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Veamos los servicios en detalle.

• app – Este servicio define la aplicación Laravel y ejecuta una imagen Docker del cliente titulada howtoforge/app. Crearemos esta imagen en el siguiente paso. El directorio de trabajo para Laravel dentro del contenedor se establece en /var/www que se mapea al directorio actual en el host. También montamos un archivo de configuración PHP que se copia en el contenedor PHP. Lo configuraremos 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 bind-mount volúmenes para los logs de Nginx, la configuración personalizada, el directorio de la aplicación Laravel y los certificados SSL.
• db – Este servicio crea un contenedor utilizando la imagen Docker de MySQL y define variables de entorno configurando el nombre de la base de datos y la contraseña raíz de MySQL. Puedes dar a la base de datos el nombre que quieras y sustituir MYSQL_ROOT_PASSWORD por una contraseña fuerte de tu elección. Establece también 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 hayas elegido. Este servicio también mapea el puerto 3306 del contenedor al puerto 3306 en el host. También bind-mount el volumen para la configuración personalizada de MySQL y un volumen local para los datos de MySQL. Esto te permite reiniciar el servicio db sin perder los datos.

Para que los servicios se comuniquen entre sí, hemos creado una red Docker llamada app-network. Está configurada como red puente. Permite que los contenedores conectados a ella se comuniquen entre sí. El controlador de la red puente instala reglas en la máquina anfitriona para que los contenedores de diferentes redes puente no puedan comunicarse directamente entre sí.

Paso 6 – Crear el Dockerfile

Un Dockerfile se utiliza para crear imágenes personalizadas. No existe 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 Linux en función de las necesidades de tu aplicación. También puedes publicar tu imagen personalizada en Docker Hub o en cualquier registro privado de Docker. Puedes obtener más información en nuestro tutorial Dockerfile.

Crea y abre el Dockerfile para editarlo.

$ nano Dockerfile

Pega en él el siguiente código.

FROM php:8.2-fpm

# Copy composer.lock and composer.json
COPY composer.lock composer.json /var/www/

# Set working directory
WORKDIR /var/www

# Install dependencies
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

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

# Install extensions
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

# Install composer
RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

# Copy existing application directory contents to the working directory
COPY . /var/www

# Assign permissions of the working directory to the www-data user
RUN chown -R www-data:www-data \
        /var/www/storage \
        /var/www/bootstrap/cache

# Assign writing permissions to logs and framework directories
RUN chmod 775 storage/logs \
        /var/www/storage/framework/sessions \
        /var/www/storage/framework/views

# Expose port 9000 and start php-fpm server
EXPOSE 9000
CMD ["php-fpm"]

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Veamos qué ocurre aquí. En primer lugar, creamos nuestra imagen personalizada sobre la imagen Docker php:8.2-fpm. Se trata de una imagen basada en Debian que tiene instalado PHP 8.2-FPM. 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 en el contenedor, la directiva EXPOSE para exponer un puerto en el contenedor y la directiva CMD para ejecutar un comando.

En primer lugar, copiamos los archivos de Composer del directorio Laravel en el host dentro del contenedor al directorio /var/www. También establecemos el directorio de trabajo del contenedor en /var/www. A continuación, instalamos varios requisitos previos y paquetes necesarios para que Laravel funcione, incluidas las extensiones de PHP mbstring, gd, exif, zip, pdo_mysql y pcntl. A continuación, 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 permisos de escritura correctos en los directorios Laravel logs, sessions y views.

Y por último, exponemos el puerto 9000 para el servicio PHP-FPM que utilizará el servidor Nginx, y ejecutamos el comando PHP para iniciar el contenedor.

Paso 7 – Configurar PHP

Crea el directorio PHP.

$ mkdir ~/laravel/php

Crea y abre el archivo local.ini para editarlo.

$ nano local.ini

Pega en él el siguiente código.

upload_max_filesize=40M
post_max_size=40M

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Estas directivas establecen el tamaño máximo de carga para los archivos subidos. Cambia el valor según tus necesidades. Puedes poner cualquier configuración específica de PHP para anular las directivas por defecto.

Paso 8 – Configurar Nginx

Crea 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 utilizar PHP-FPM como servidor FastCGI para servir a Laravel.

Crea y abre el archivo app.conf para editarlo.

$ nano ~/laravel/nginx/conf.d/app.conf

Pega en él el siguiente código.

server {
    # Redirect any http requests to 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;
    }
}

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

El archivo anterior configura Nginx para que sirva las versiones HTTP y HTTPS del sitio Laravel y redirija cualquier petición HTTP a HTTPS automáticamente. Asegúrate de que el valor de la variable client_max_body_size coincide con el tamaño de carga establecido en el paso anterior.

En el bloque de ubicación PHP, la directiva fastcgi_pass especifica que el servicio app está a la escucha en un socket TCP en el puerto 9000. El servidor PHP-FPM también puede escuchar en un socket Unix, lo que tiene una ventaja sobre un socket TCP. Pero no funciona si los servicios se ejecutan en hosts diferentes, como ocurre en este caso, ya que el contenedor app se ejecuta en un host diferente al de tu contenedor webserver.

Paso 9 – Configurar MySQL

Configuraremos MySQL para habilitar el registro general de consultas y especificar el archivo de registro correspondiente.

Crea el directorio MySQL.

$ mkdir ~/laravel/mysql

Crea y abre el archivo my.cnf para editarlo.

$ nano ~/laravel/my.cnf

Pega en él el siguiente código.

[mysqld]
general_log = 1
general_log_file = /var/lib/mysql/general.log

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Paso 10 – Configurar el archivo de entorno

Ahora que hemos creado y configurado todos los servicios, es el momento de iniciar los contenedores. Pero antes de hacerlo, necesitamos configurar las variables de entorno para Laravel. Laravel viene con un archivo de entorno por defecto, .env.example.

Crea una copia del archivo de entorno de ejemplo.

$ cp .env.example .env

Abre el archivo .env para editarlo.

$ nano .env

Busca el bloque que empieza por DB_CONNECTION y actualiza los valores de las variables según tus necesidades.

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. Los valores 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 elegiste en el paso 4 del archivo Docker compose.

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Paso 11 – Iniciar los Contenedores y completar la instalación de Laravel

Por fin ha llegado el momento de iniciar los contenedores.

$ docker compose up -d

Este comando, cuando se ejecute por primera vez, extraerá las imágenes Nginx, MySQL y creará la imagen app utilizando el Dockerfile que hemos creado. Una vez completado el proceso, puedes comprobar el estado de tus contenedores utilizando el siguiente comando.

$ docker ps

Verás 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 se estén ejecutando, es hora de terminar de instalar Laravel utilizando el comando docker compose exec para ejecutar comandos dentro del contenedor.

Genera una clave de aplicación y cópiala en tu archivo .env para asegurar las sesiones de usuario y cifrar los datos de usuario.

$ docker compose exec app php artisan key:generate

Crea la caché de la aplicación Laravel.

$ docker compose exec app php artisan config:cache

Este comando cargará los ajustes de configuración en el archivo /var/www/bootstrap/cache/config.php.

Visita https://example.com en tu navegador y verás la siguiente página que implica la correcta instalación de Laravel.

Paso 12 – Configurar la renovación SSL

Ahora que el sitio Laravel está activo, es el momento de volver a visitar la configuración SSL para configurar la renovación. Para ello, necesitaremos crear scripts para detener el servicio webserver antes de iniciar la renovación y volver a iniciarlo una vez renovado el certificado. Certbot proporciona dos hooks, pre_hook y post_hook para este fin.

Crea el directorio SSL para almacenar los scripts.

$ mkdir ~/laravel/ssl

Crea el script server-stop.sh.

$ sh -c 'printf "#!/bin/sh\ndocker stop webserver\n" > ~/laravel/ssl/server-stop.sh'

Crea el script server-start.sh.

$ sh -c 'printf "#!/bin/sh\ndocker start webserver\n" > ~/laravel/ssl/server-start.sh'

Haz que los scripts sean ejecutables.

$ chmod +x ~/laravel/ssl/server-*.sh

Ahora tenemos que decirle a Certbot que utilice estos scripts. Abre el archivo /etc/letsencrypt/renewal/example.com.conf para editarlo.

$ sudo nano /etc/letsencrypt/renewal/example.com.conf

Pega las siguientes líneas al final del archivo.

pre_hook = /home/<username>/laravel/ssl/server-stop.sh
post_hook = /home/<username>/laravel/ssl/server-start.sh

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Prueba el proceso de renovación del Certificado haciendo un simulacro.

$ sudo certbot renew --dry-run

Obtendrás una salida similar confirmando el éxito.

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

Tus certificados SSL se renovarán automáticamente y serán utilizados por el contenedor Docker para servir tu aplicación Laravel.

Paso 13 – Migración de Datos y Consola Tinker

Ahora que la aplicación se está ejecutando, puedes migrar tus 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 desarrollo en tiempo de ejecución y un depurador interactivo para PHP. El comando tinker te permite interactuar con la aplicación Laravel desde la línea de comandos en una shell interactiva.

Prueba la conexión MySQL utilizando el comando artisan migrate en el contenedor. Se creará una tabla migrations en la base de datos.

$ docker compose exec app php artisan migrate

Obtendrás la siguiente salida.

 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

A continuación, inicia la consola PsySH utilizando el comando tinker.

$ docker compose exec app php artisan tinker

Aparecerá el siguiente mensaje.

Psy Shell v0.11.10 (PHP 8.2.1 — cli) by Justin Hileman
>

Prueba la conexión MySQL obteniendo los datos que acabas de migrar ejecutando el siguiente comando en el indicador de la consola.

> \DB::table('migrations')->get();

Obtendrás 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,
      },
    ],
  }

Escribe exit para salir de la consola.

> exit
   INFO  Goodbye.

Puedes utilizar tinker para interactuar con tus bases de datos y experimentar con servicios y modelos. Ahora puedes empezar a utilizar Laravel para seguir desarrollando.

Conclusión

Con esto concluye nuestro tutorial, en el que has containerizado e instalado la aplicación Laravel utilizando Docker, MySQL y PHP. También has servido la aplicación en un nombre de dominio seguro. Si tienes alguna pregunta, publícala en los comentarios a continuación.