Tutorial

Cómo disponer en contenedores una aplicación de Laravel para el desarrollo con Docker Compose en Ubuntu 18.04

PHPDockerPHP FrameworksLaravel

Introducción

Cuando se habla de disponer en contenedores una aplicación, se hace referencia al proceso de adaptación de una aplicación y sus componentes para poder ejecutarla en entornos ligeros conocidos como contenedores. Estos entornos están aislados, son desechables y se pueden utilizar para desarrollar, probar e implementar aplicaciones en la producción.

En esta guía, usaremos Docker Compose con el propósito de disponer en contenedores una aplicación de Laravel para el desarrollo. Al finalizar, dispondrá de una aplicación Laravel de demostración funcional en tres contenedores de servicios separados:

  • un servicio app con PHP7.4-FPM;
  • un servicio db con MySQL 5.7;
  • un servicio nginx en el que se utilice el servicio app para analizar el código PHP antes de proporcionar la aplicación Laravel al usuario final.

Para permitir un proceso de desarrollo simplificado y facilitar la depuración de aplicaciones, mantendremos sincronizados los archivos de la aplicación usando volúmenes compartidos. También veremos cómo usar comandos docker-compose exec para la ejecución de Composer y Artisan en el contenedor app.

Requisitos previos

Paso 1: Obtener la aplicación de demostración

Para comenzar, obtendremos la aplicación Laravel de demostración de su repositorio de Github. Nos interesa la ramificación tutorial-01, que contiene la aplicación básica de Laravel que creamos en la primera guía de esta serie.

Para obtener el código de la aplicación que es compatible con este tutorial, descargue la versión tutorial-1.0.1 en su directorio de inicio con lo siguiente:

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

Necesitaremos el comando unzip para desempaquetar el código de la aplicación. En caso de que no haya instalado el paquete antes, hágalo ahora con lo siguiente:

  • sudo apt update
  • sudo apt install unzip

Luego, descomprima el contenido de la aplicación y cambie el nombre del directorio desempaquetado para facilitar el acceso:

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

Diríjase al directorio travellist-demo:

  • cd travellist-demo

En el siguiente paso, crearemos un archivo de configuración .env para configurar la aplicación.

Paso 2: Configurar el archivo .env de la aplicación

Los archivos de configuración de Laravel se encuentran en un directorio llamado config, dentro del directorio root de la aplicación. Además, un archivo .env se utiliza para establecer una configuración dependiente del entorno, como las credenciales y cualquier información que pueda variar entre las implementaciones. Este archivo no está incluido en el control de revisiones.

Advertencia: En el archivo de configuración del entorno se encuentra información confidencial sobre su servidor, incluidas las credenciales de bases de datos y las claves de seguridad. Por ese motivo, nunca debe compartir públicamente este archivo.

Los valores incluidos en el archivo .env tendrán prioridad sobre los valores establecidos en los archivos de configuración normales que se encuentran en el directorio config. Para cada instalación en un nuevo entorno se requiere un archivo de entorno personalizado a fin de definir elementos como las configuraciones de conexión de bases de datos, las opciones de depuración y las URL de aplicación, entre otros elementos que pueden variar dependiendo del entorno en el que se ejecute la aplicación.

Ahora, crearemos un nuevo archivo .env para personalizar las opciones de configuración para el entorno de desarrollo que configuraremos. En Laravel se incluye un archivo .env de ejemplo que podemos copiar para crear el nuestro:

  • cp .env.example .env

Abra este archivo utilzando nano o el editor de texto que prefiera:

  • nano .env

En el archivo .env actual de la aplicación de demostración travellist se incluyen las configuraciones para usar una base de datos local de MySQL, con 127.0.0.1 como host de base de datos. Necesitamos actualizar la variable DB_HOST para que esta apunte al servicio de base de datos que crearemos en nuestro entorno de Docker. En esta guía, usaremos el nombre db para el servicio de nuestra base de datos. Sustituya el valor de la lista de DB_HOST por el nombre del servicio de la base de datos:

.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
...

Si lo desea, puede cambiar también el nombre, el nombre de usuario y la contraseña de la base de datos. Estas variables aprovecharán en un paso posterior en el que prepararemos el archivo docker-compose.yml para configurar nuestros servicios.

Guarde el archivo cuando finalice la edición. Si utiliza nano, puede hacerlo presionando Ctrl+x, luego Y y Enter para confirmar.

Paso 3: Configurar el Dockerfile de la aplicación

Aunque ambos servicios de MySQL y Nginx se basarán en imágenes predeterminadas obtenidas de Docker Hub, debemos de todas formas crear una imagen personalizada para el contenedor de la aplicación. Crearemos un nuevo Dockerfile para ello.

Nuestra imagen de travellist se basará en la imagen oficial de PHP php:7.4-fpm de Docker Hub. Además de ese entorno básico de PHP-FPM, instalaremos algunos módulos de PHP adicionales y la herramienta de administración de dependencias Composer.

También crearemos un nuevo usuario de sistema; esto es necesario para ejecutar los comandos artisan y composer mientras se desarrolla la aplicación. En la configuración uid se garantiza que el usuario dentro del contenedor tenga el mismo uid que el usuario de su sistema en su equipo host, donde Docker está en ejecución. De esta manera, todos los archivos creados por estos comandos se replican en el host con los permisos correctos. Esto también significa que podrá usar su editor de código preferido en la máquina host para desarrollar la aplicación que está en ejecución dentro de los contenedores.

Cree un nuevo Dockerfile con lo siguiente:

  • nano Dockerfile

Copie el siguiente contenido en su 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

No olvide guardar el archivo cuando termine.

Nuestro Dockerfile comienza definiendo la imagen base que usaremos: php:7.4-fpm.

Después de instalar los paquetes del sistema y las extensiones de PHP, instalamos Composer copiando el ejecutable composer de su imagen oficial más reciente en la propia imagen de nuestra aplicación.

A continuación, se crea un nuevo usuario de sistema y se configura usando los argumentos user y uid que se declararon al inicio del Dockerfile. Docker Compose insertará estos valores en el tiempo de compilación.

Por último, fijaremos el directorio de trabajo predeterminado como /var/www y cambiaremos al usuario recién creado. Esto garantizará que se conecte como un usuario normal y que se encuentre en el directorio correcto, al ejecutar comandos de composer y artisan en el contenedor de la aplicación.

Paso 4: Preparar archivos de configuración de Nginx y de volcado de bases de datos

Cuando se crean entornos de desarrollo con Docker Compose, a menudo es necesario compartir archivos de configuración o de inicialización con contenedores de servicios para que se puedan configurar o aplicar estos servicios. Esta práctica facilita la aplicación de cambios en los archivos de configuración para ajustar el entorno mientras desarrolla la aplicación.

Ahora crearemos una carpeta con archivos que se utilizarán para configurar e inicializar nuestros contenedores de servicios.

Para configurar Nginx, compartiremos un archivo travellist.conf en el que se configurará la forma en que se proporciona la aplicación. Cree la carpeta docker-compose/nginx con lo siguiente:

  • mkdir -p docker-compose/nginx

Abra un nuevo archivo llamado travellist.conf dentro de ese directorio:

  • nano docker-compose/nginx/travellist.conf

Copie la siguiente configuración de Nginx en ese archivo:

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

En este archivo se configurará Nginx para que escuche en el puerto 80 y utilice index.php como la página de índice predeterminada. Establecerá el documento root en /var/www/public y luego configurará Nginx para que en este se utilice el servicio app en el puerto 9000 a fin de procesar archivos *.php.

Guarde y cierre el archivo cuando finalice la edición.

Para configurar la base de datos de MySQL, compartiremos un volcado de base de datos que se importará cuando se inicialice el contenedor. Esta es una característica que se proporciona a través de la imagen de MySQL 5.7 y que usaremos en ese contenedor.

Cree una nueva carpeta para sus archivos de inicialización de MySQL dentro de la carpeta docker-compose:

  • mkdir docker-compose/mysql

Abra un nuevo archivo .sql:

  • nano docker-compose/mysql/init_db.sql

El siguiente volcado de MySQL deriva de la base de datos que configuramos en nuestra guía sobre Laravel en LEMP. Se creará una nueva tabla llamada places. Luego, se completará la tabla con un conjunto de lugares de ejemplo.

Añada el siguiente código al archivo:

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);

En la tabla places se incluyen tres campos: id, name y visited. El campo visited es un indicador utilizado para identificar los lugares que aún quedan por recorrer. Puede cambiar los lugares de ejemplo o incluir casos nuevos si lo desea. Guarde y cierre el archivo cuando termine.

Terminamos de preparar el Dockerfile de la aplicación y los archivos de configuración del servicio. A continuación, configuraremos Docker Compose para que se utilicen estos archivos al crear nuestros servicios.

Paso 5: Crear un entorno en varios contenedores con Docker Compose

Docker Compose le permite crear entornos en varios contenedores para aplicaciones que se ejecuten en Docker. Se utilizan definiciones de servicio para crear entornos totalmente personalizables con varios contenedores que pueden compartir redes y volúmenes de datos. Esto permite una integración sin problemas entre los componentes de la aplicación.

Para establecer nuestras definiciones de servicios, crearemos un nuevo archivo llamado docker-compose.yml. Normalmente, este archivo se encuentra en la carpeta root de la aplicación y define su entorno en contenedor, incluidas las imágenes de base que usará para crear sus contenedores y la forma en que interactuarán sus servicios.

Definiremos tres servicios diferentes en nuestro archivo docker-compose.yml: app, db y nginx.

En el servicio app se creará una imagen llamada travellist, basada en el Dockerfile que creamos previamente. En el contenedor definido por este servicio se ejecutará un servidor php-fpm para analizar el código PHP y enviar los resultados de vuelta al servicio nginx, que estará en ejecución en un contenedor separado. A través del servicio mysql, se define un contenedor en un servidor MySQL 5.7. En nuestros servicios se compartirá una red de puente llamada travellist.

Los archivos de la aplicación se sincronizarán en los servicios app y nginx mediante montajes “bind”. Los montajes “bind” son útiles en los entornos de desarrollo porque en estos se permite una sincronización bidireccional estable entre el equipo host y los contenedores.

Cree un nuevo archivo docker-compose.yml en la carpeta root de la aplicación:

  • nano docker-compose.yml

Un archivo típico de docker-compose.yml comienza con una definición de versión, a la que le sigue un nodo services, donde se definen todos los servicios. Las redes compartidas suelen definirse al final de ese archivo.

Para comenzar, copie el siguiente código estándar a su archivo docker-compose.yml:

docker-compose.yml
version: "3.7"
services:


networks:
  travellist:
    driver: bridge

Ahora, editaremos el nodo services para incluir los servicios app, db y nginx.

El servicio app

A través del servicio app se configurará un contenedor llamado travellist-app. Crea una nueva imagen de Docker basada en un Dockerfile ubicado en la misma ruta que el archivo docker-compose.yml. La nueva imagen se guardará a nivel local con el nombre travellist.

Aunque el root de documentos que se proporciona como la aplicación se encuentra en el contenedor nginx, también necesitamos los archivos de la aplicación en algún lugar dentro del contenedor app para poder ejecutar tareas de línea de comandos con la herramienta Laravel Artisan.

Copie la siguiente definición de servicio en su nodo services, dentro del archivo docker-compose.yml:

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

Estas configuraciones tienen los siguientes atributos:

  • build: en esta configuración indica a Docker Compose que cree una imagen local para el servicio app, y usa la ruta especificada (context) y Dockerfile para las instrucciones. Los argumentos user y uid se insertan en Dockerfile para personalizar los comandos de creación del usuario en el tiempo de compilación.
  • image: nombre que se usará para la imagen que se creará.
  • container_name: configura el nombre del contenedor para este servicio.
  • restart: siempre ejecuta un reinicio, a menos que se detenga el servicio.
  • working_dir: establece el directorio predeterminado para este servicio como /var/www.
  • volumes: crea un volumen compartido en el que se sincronizarán los contenidos del directorio actual con /var/www dentro del contenedor. Tenga en cuenta que esto no es su root de documentos, ya que este residirá en el contenedor nginx.
  • networks: configura este servicio para que se utilice una red llamada travellist.

El servicio db

En el servicio db se utiliza una imagen previamente creada de MySQL 5.7 de Docker Hub. Debido a que en Docker Compose se cargan automáticamente los archivos de variable .env ubicados en el mismo directorio que el archivo docker-compose.yml, podemos obtener la configuración de nuestra base de datos del archivo Laravel .env que creamos en un paso anterior.

Incluya la siguiente definición de servicio en el nodo services, justo después del servicio app:

docker-compose.yml
  db:
    image: mysql:5.7
    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

Estas configuraciones hacen lo siguiente:

  • image: define la imagen de Docker que debe utilizarse para este contenedor. En este caso, usamos una imagen MySQL 5.7 de Docker Hub.
  • container_name: establece el nombre del contenedor para el servicio travellist-db.
  • restart: reinicie siempre este servicio, a menos que se detenga de forma explicita.
  • environment: define las variables de entorno en el nuevo contenedor. Usaremos valores obtenidos del archivo Laravel .env para establecer nuestro servicio de MySQL, que creará automáticamente una nueva base de datos y usuario basadas en las variables de entorno proporcionadas.
  • volumes: crea un volumen para compartir un volcado de base de datos .sql que se usará para inicializar la base de datos de la aplicación. En la imagen de MySQL se importarán automáticamente archivos .sql ubicados en el directorio /docker-entrypoint-initdb.d dentro del contenedor.
  • networks: configura este servicio para que se utilice una red llamada travellist.

El servicio nginx

En el servicio nginx se utiliza una imagen previamente creada de Nginx en la parte superior de Alpine, una distribución ligera de Linux. Se crea un contenedor llamado travellist-nginx y se utiliza la definición ports para crear un redireccionamiento del puerto 8000 en el sistema host al puerto 80 dentro del contenedor.

Incluya la siguiente definición de servicio en su nodo services, justo después del servicio db:

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

Esta configuración hace lo siguiente:

  • image: define la imagen de Docker que debe utilizarse para este contenedor. En este caso, usaremos la imagen Alpine Nginx 1.17.
  • container_name: establece el nombre del contenedor para el servicio travellist-nginx.
  • restart: reinicie siempre este servicio, a menos que se detenga de forma explicita.
  • ports: establece un redireccionamiento de puerto que permitirá el acceso externo a través del puerto 8000 al servidor web que se ejecuta en el puerto 80 dentro del contenedor.
  • volumes: crea dos volúmenes compartidos. El primero sincronizará los contenidos del directorio actual con /var/www dentro del contenedor. De esta manera, cuando realice cambios locales en los archivos de la aplicación, se reflejarán rápidamente en la aplicación proporcionada por Nginx dentro del contenedor. En el segundo volumen, se asegurará que nuestro archivo de configuración de Nginx, ubicado en docker-compose/nginx/travellist.conf, se copie a la carpeta de configuración de Nginx del contenedor.
  • networks: configura este servicio para que se utilice una red llamada travellist.

Archivo docker-compose.yml terminado

Este es el aspecto de nuestro archivo docker-compose.yml terminado:

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:5.7
    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

Asegúrese de guardar el archivo cuando termine.

Paso 6: Ejecutar la aplicación con Docker Compose

Ahora, usaremos comandos docker-compose para crear la imagen de la aplicación y ejecutar los servicios que especificamos en nuestra configuración.

Cree la imagen app con el siguiente comando:

  • docker-compose build app

La aplicación de este comando puede tardar unos minutos en completarse. Verá un resultado similar a este:

Output
Building app Step 1/11 : FROM php:7.4-fpm ---> fa37bd6db22a Step 2/11 : ARG user ---> Running in f71eb33b7459 Removing intermediate container f71eb33b7459 ---> 533c30216f34 Step 3/11 : ARG uid ---> Running in 60d2d2a84cda Removing intermediate container 60d2d2a84cda ---> 497fbf904605 Step 4/11 : RUN apt-get update && apt-get install -y git curl libpng-dev libonig-dev ... Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer ---> e499f74896e3 Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user ---> Running in 232ef9c7dbd1 Removing intermediate container 232ef9c7dbd1 ---> 870fa3220ffa Step 9/11 : RUN mkdir -p /home/$user/.composer && chown -R $user:$user /home/$user ---> Running in 7ca8c0cb7f09 Removing intermediate container 7ca8c0cb7f09 ---> 3d2ef9519a8e Step 10/11 : WORKDIR /var/www ---> Running in 4a964f91edfa Removing intermediate container 4a964f91edfa ---> 00ada639da21 Step 11/11 : USER $user ---> Running in 9f8e874fede9 Removing intermediate container 9f8e874fede9 ---> fe176ff4702b Successfully built fe176ff4702b Successfully tagged travellist:latest

Cuando se complete la compilación, podrá ejecutar el entorno en el modo de segundo plano con lo siguiente:

  • docker-compose up -d
Output
Creating travellist-db ... done Creating travellist-app ... done Creating travellist-nginx ... done

Con esto, se ejecutarán sus contenedores en segundo plano. Para mostrar información sobre el estado de sus servicios activos, ejecute lo siguiente:

  • docker-compose ps

Verá resultados como este:

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

Su entorno ahora estárá configurado y en funcionamiento, pero aún debemos ejecutar algunos comandos para finalizar la configuración de la aplicación. Puede usar el comando docker-compose exec para ejecutar comandos en los contenedores de servicios, como ls -l. Este muestra información detallada sobre los archivos en el directorio de la aplicación:

  • docker-compose exec app ls -l
Output
total 256 -rw-rw-r-- 1 sammy 1001 738 Jan 15 16:46 Dockerfile -rw-rw-r-- 1 sammy 1001 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy 1001 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy 1001 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy 1001 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy 1001 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy 1001 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy 1001 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy 1001 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy 1001 4096 Jan 15 16:46 docker-compose -rw-rw-r-- 1 sammy 1001 1015 Jan 15 16:45 docker-compose.yml -rw-rw-r-- 1 sammy 1001 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy 1001 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy 1001 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy 1001 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy 1001 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy 1001 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy 1001 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy 1001 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy 1001 4096 Jan 7 08:05 tests -rw-rw-r-- 1 sammy 1001 538 Jan 7 08:05 webpack.mix.js

Ahora, ejecutaremos composer install para instalar las dependencias de la aplicación:

  • docker-compose exec app composer install

Verá resultados como este:

Output
Loading composer repositories with package information Installing dependencies (including require-dev) from lock file Package operations: 85 installs, 0 updates, 0 removals - Installing doctrine/inflector (1.3.1): Downloading (100%) - Installing doctrine/lexer (1.2.0): Downloading (100%) - Installing dragonmantank/cron-expression (v2.3.0): Downloading (100%) - Installing erusev/parsedown (1.7.4): Downloading (100%) - Installing symfony/polyfill-ctype (v1.13.1): Downloading (100%) - Installing phpoption/phpoption (1.7.2): Downloading (100%) - Installing vlucas/phpdotenv (v3.6.0): Downloading (100%) - Installing symfony/css-selector (v5.0.2): Downloading (100%) … 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.

Lo último que debemos hacer antes de probar la aplicación es generar una clave de aplicación única con la herramienta de línea de comandos de Laravel artisan. Esta clave se utiliza para cifrar las sesiones de los usuarios y otros datos confidenciales:

  • docker-compose exec app php artisan key:generate
Output
Application key set successfully.

Ahora diríjase a su navegador y acceda al nombre de dominio o dirección IP de su servidor en el puerto 8000:

http://server_domain_or_IP:8000

Verá una página como la siguiente:

Aplicación de demostración de Laravel

Puede usar el comando logs para verificar los registros generados por sus servicios:

  • docker-compose logs nginx
Attaching to travellist-nginx
travellist-nginx | 192.168.160.1 - - [23/Jan/2020:13:57:25 +0000] "GET / HTTP/1.1" 200 626 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36"
travellist-nginx | 192.168.160.1 - - [23/Jan/2020:13:57:26 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36"
travellist-nginx | 192.168.160.1 - - [23/Jan/2020:13:57:42 +0000] "GET / HTTP/1.1" 200 626 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.88 Safari/537.36"
…

Si desea pausar su entorno de Docker Compose mientras mantiene el estado de todos sus servicios, ejecute lo siguiente:

  • docker-compose pause
Output
Pausing travellist-db ... done Pausing travellist-nginx ... done Pausing travellist-app ... done

Luego podrá reanudar sus servicios con lo siguiente:

  • docker-compose unpause
Output
Unpausing travellist-app ... done Unpausing travellist-nginx ... done Unpausing travellist-db ... done

Para cerrar su entorno de Docker Compose y eliminar por completo sus contenedores, redes y volúmenes, ejecute lo siguiente:

  • docker-compose down
Output
Stopping 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

Para acceder a una visión general de todos los comandos de Docker Compose, consulte la referencia de línea de comandos de Docker Compose.

Conclusión

A lo largo de esta guía, configuramos un entorno de Docker con tres contenedores usando Docker Compose para definir nuestra infraestructura en un archivo YAML.

A partir de este punto, puede trabajar en su aplicación de Laravel sin necesidad de instalar y configurar un servidor web local para el desarrollo y las pruebas. Además, trabajará con un entorno disponible que se puede replicar y distribuir de forma sencilla, lo cual puede resultarle útil al desarrollar su aplicación y realizar la transición a un entorno de producción.

Creative Commons License