Developer Advocate
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:
app
con PHP7.4-FPM;db
con MySQL 5.7;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
.
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.
.env
de la aplicaciónLos 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:
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.
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:
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.
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:
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:
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.
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
:
version: "3.7"
services:
networks:
travellist:
driver: bridge
Ahora, editaremos el nodo services
para incluir los servicios app
, db
y nginx
.
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
:
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
.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
:
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
.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
:
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
.docker-compose.yml
terminadoEste es el aspecto de nuestro archivo docker-compose.yml
terminado:
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.
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 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
Outputtotal 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:
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
> 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
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
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 | 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
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.
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.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!
Tuve un pequeño problema con “composer install”, pero se resuelve con “composer update”. Gracias. :)