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 servicioapp
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
- Acceso a un equipo local o servidor de desarrollo de Ubuntu 20.04 como usuario non root con privilegios sudo. Si utiliza un servidor remoto, se recomienda tener instalado un firewall activo. Para configurarlos, consulte nuestra Guía de configuración inicial para servidores de Ubuntu 20.04.
- Docker instalado en su servidor conforme a los pasos 1 y 2 de Cómo instalar y usar Docker en Ubuntu 20.04
- Docker Compose instalado en su servidor conforme el paso 1 de Cómo instalar Docker Compose en Ubuntu 20.04
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 servicioapp
, y usa la ruta especificada (context) y Dockerfile para las instrucciones. Los argumentosuser
yuid
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 contenedornginx
.networks
: configura este servicio para que se utilice una red llamadatravellist
.
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 serviciotravellist-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 llamadatravellist
.
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 puerto8000
al servidor web que se ejecuta en el puerto80
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 endocker-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 llamadatravellist
.
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:
OutputBuilding 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
OutputCreating 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 /docker-entrypoint.sh ngin ... 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
Outputtotal 260 -rw-rw-r-- 1 sammy sammy 737 Jun 9 11:19 Dockerfile -rw-rw-r-- 1 sammy sammy 101 Jan 7 08:05 README.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 app -rwxr-xr-x 1 sammy sammy 1686 Jan 7 08:05 artisan drwxrwxr-x 3 sammy sammy 4096 Jan 7 08:05 bootstrap -rw-rw-r-- 1 sammy sammy 1501 Jan 7 08:05 composer.json -rw-rw-r-- 1 sammy sammy 179071 Jan 7 08:05 composer.lock drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 config drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 database drwxrwxr-x 4 sammy sammy 4096 Jun 9 11:19 docker-compose -rw-rw-r-- 1 sammy sammy 965 Jun 9 11:27 docker-compose.yml -rw-rw-r-- 1 sammy sammy 1013 Jan 7 08:05 package.json -rw-rw-r-- 1 sammy sammy 1405 Jan 7 08:05 phpunit.xml drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 public -rw-rw-r-- 1 sammy sammy 273 Jan 7 08:05 readme.md drwxrwxr-x 6 sammy sammy 4096 Jan 7 08:05 resources drwxrwxr-x 2 sammy sammy 4096 Jan 7 08:05 routes -rw-rw-r-- 1 sammy sammy 563 Jan 7 08:05 server.php drwxrwxr-x 5 sammy sammy 4096 Jan 7 08:05 storage drwxrwxr-x 4 sammy sammy 4096 Jan 7 08:05 tests drwxrwxr-x 41 sammy sammy 4096 Jun 9 11:32 vendor -rw-rw-r-- 1 sammy sammy 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:
OutputLoading 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 > IlluminateFoundationComposerScripts::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
OutputApplication 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
Nota: En el caso de que esté ejecutando esta demo en su equipo local, utilice https://localhost:8000
para acceder a la aplicación desde su navegador.
Verá una página como la siguiente:
Puede usar el comando logs
para verificar los registros generados por sus servicios:
- docker-compose logs nginx
Attaching to travellist-nginx … travellist-nginx | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh travellist-nginx | /docker-entrypoint.sh: Configuration complete; ready for start up travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:34 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" travellist-nginx | 192.168.0.1 - - [09/Jun/2020:11:46:35 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 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
OutputPausing travellist-db ... done Pausing travellist-nginx ... done Pausing travellist-app ... done
Luego podrá reanudar sus servicios con lo siguiente:
- docker-compose unpause
OutputUnpausing 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
OutputStopping travellist-nginx ... done Stopping travellist-db ... done Stopping travellist-app ... done Removing travellist-nginx ... done Removing travellist-db ... done Removing travellist-app ... done Removing network travellist-laravel-demo_travellist
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.