Cómo instalar y configurar Laravel con Docker Compose en Ubuntu 22.04

Introducción

Para contenerizar una aplicación se refiere al proceso de adaptar una aplicación y sus componentes para poder ejecutarla en entornos ligeros conocidos como contenedores. Dichos entornos son aislados y desechables, y se pueden aprovechar para desarrollar, probar e implementar aplicaciones en producción.

En esta guía, usaremos Docker Compose para contener una aplicación de Laravel para el desarrollo. Cuando haya terminado, tendrá una aplicación Laravel de demostración ejecutándose en tres contenedores de servicios separados:

• Una app servicio que ejecuta PHP7.4-FPM;
• A db servicio que ejecuta MySQL 5.7;
• Un nginx servicio que utiliza la app servicio para analizar el código PHP antes de entregar la aplicación Laravel al usuario final.

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

Requisitos

• Acceso a una máquina local Ubuntu 22.04 o servidor de desarrollo como usuario no root con privilegios sudo. Si está utilizando un servidor remoto, es recomendable tener instalado un firewall activo. Para configurarlos, consulte nuestra Guía de configuración inicial del servidor para Ubuntu 22.04.
• Docker instalado en su servidor, siguiendo los pasos 1 y 2 de Cómo instalar y usar Docker en Ubuntu 22.04.
• Docker Compose instalado en su servidor, siguiendo el paso 1 de Cómo instalar y usar Docker Compose en Ubuntu 22.04.

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

Para comenzar, buscaremos la aplicación de demostración Laravel de su repositorio de Github. Estamos interesados ​​en el tutorial-01 branch, que contiene la aplicación básica de Laravel que hemos creado en la primera guía de esta serie.

Para obtener el código de la aplicación compatible con este tutorial, descargue la versión tutorial-1.0.1 a su directorio de inicio con:

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

Necesitaremos el unzip Comando para descomprimir el código de la aplicación. En caso de que no haya instalado este paquete antes, hágalo ahora con:

sudo apt update
sudo apt install unzip

Ahora, 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

Navega a travellist-demo directorio:

cd travellist-demo

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

Paso 2:configurar el .env de la aplicación Archivo

Los archivos de configuración de Laravel se encuentran en un directorio llamado config , dentro del directorio raíz de la aplicación. Además, un .env El archivo se usa para configurar la 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 revisión.

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

Los valores contenidos en .env tendrá prioridad sobre los valores establecidos en los archivos de configuración normales ubicados en config directorio. Cada instalación en un entorno nuevo requiere un archivo de entorno personalizado para definir elementos como la configuración de conexión de la base de datos, las opciones de depuración, la URL de la aplicación, entre otros elementos que pueden variar según el entorno en el que se esté ejecutando la aplicación.

Ahora crearemos un nuevo .env para personalizar las opciones de configuración para el entorno de desarrollo que estamos configurando. Laravel viene con un ejemplo .env archivo que podemos copiar para crear el nuestro:

cp .env.example .env

Abre este archivo usando nano o el editor de texto de su elección:

nano .env

El .env actual archivo de la travellist La aplicación de demostración contiene configuraciones para usar una base de datos MySQL local, con 127.0.0.1 como host de la base de datos. Necesitamos actualizar el DB_HOST variable para que apunte al servicio de base de datos que crearemos en nuestro entorno Docker. En esta guía, llamaremos a nuestro servicio de base de datos db . Continúe y reemplace el valor de la lista de DB_HOST con 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éntase libre de cambiar también el nombre de la base de datos, el nombre de usuario y la contraseña, si lo desea. Estas variables se aprovecharán en un paso posterior donde configuraremos docker-compose.yml archivo para configurar nuestros servicios.

Guarde el archivo cuando haya terminado de editar. Si usaste nano , puedes hacerlo presionando Ctrl+x , luego Y y Enter para confirmar.

Paso 3:configurar el Dockerfile de la aplicación

Si bien nuestros servicios MySQL y Nginx se basarán en imágenes predeterminadas obtenidas de Docker Hub, todavía necesitamos crear una imagen personalizada para el contenedor de la aplicación. Crearemos un nuevo Dockerfile para eso.

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

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

Crea un nuevo Dockerfile con:

nano Dockerfile

Copie los siguientes contenidos a 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 olvides guardar el archivo cuando hayas terminado.

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

Después de instalar los paquetes del sistema y las extensiones de PHP, instalamos Composer copiando el composer ejecutable desde su última imagen oficial hasta nuestra propia imagen de aplicación.

Luego se crea y configura un nuevo usuario del sistema usando el user y uid argumentos que se declararon al principio del Dockerfile. Docker Compose inyectará estos valores en el momento de la compilación.

Finalmente, configuramos el directorio de trabajo predeterminado como /var/www y cambie al usuario recién creado. Esto asegurará que se esté conectando como un usuario normal y que esté en el directorio correcto cuando ejecute composer y artisan comandos en el contenedor de la aplicación.

Paso 4:Configuración de archivos de volcado de base de datos y configuración de Nginx

Al crear entornos de desarrollo con Docker Compose, a menudo es necesario compartir archivos de configuración o inicialización con contenedores de servicios para configurar o arrancar esos servicios. Esta práctica facilita la realización de cambios en los archivos de configuración para ajustar su entorno mientras desarrolla la aplicación.

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

Para configurar Nginx, compartiremos un travellist.conf archivo que configurará cómo se sirve la aplicación. Crea el docker-compose/nginx carpeta con:

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

Este archivo configurará Nginx para escuchar en el puerto 80 y usa index.php como página de índice predeterminada. Establecerá la raíz del documento en /var/www/public y luego configure Nginx para usar la app servicio en el puerto 9000 para procesar *.php archivos.

Guarde y cierre el archivo cuando termine de editarlo.

Para configurar la base de datos MySQL, compartiremos un volcado de base de datos que se importará cuando se inicialice el contenedor. Esta es una función proporcionada por la imagen de MySQL 5.7 que usaremos en ese contenedor.

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

mkdir docker-compose/mysql

Abra un nuevo .sql archivo:

nano docker-compose/mysql/init_db.sql

El siguiente volcado de MySQL se basa en la base de datos que configuramos en nuestra guía Laravel en LEMP. Creará una nueva tabla llamada places . Luego, llenará la tabla con un conjunto de lugares de muestra.

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

Los places la tabla contiene tres campos:id , name y visited . El visited El campo es una bandera que se utiliza para identificar los lugares a los que todavía ir . Siéntase libre de cambiar los lugares de muestra o incluir otros nuevos. Guarde y cierre el archivo cuando haya terminado.

Hemos terminado de configurar el Dockerfile de la aplicación y los archivos de configuración del servicio. A continuación, configuraremos Docker Compose para usar estos archivos al crear nuestros servicios.

Paso 5:Creación de un entorno de varios contenedores con Docker Compose

Docker Compose le permite crear entornos de varios contenedores para aplicaciones que se ejecutan en Docker. Utiliza definiciones de servicio para construir entornos totalmente personalizables con múltiples contenedores que pueden compartir redes y volúmenes de datos. Esto permite una integración perfecta entre los componentes de la aplicación.

Para configurar nuestras definiciones de servicio, crearemos un nuevo archivo llamado docker-compose.yml . Por lo general, este archivo se encuentra en la raíz de la carpeta de la aplicación y define su entorno en contenedores, incluidas las imágenes base que usará para crear sus contenedores y cómo interactuarán sus servicios.

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

La app El servicio creará una imagen llamada travellist , basado en el Dockerfile que hemos creado previamente. El contenedor definido por este servicio ejecutará un php-fpm servidor para analizar el código PHP y enviar los resultados a nginx servicio, que se ejecutará en un contenedor separado. El mysql service define un contenedor que ejecuta un servidor MySQL 5.7. Nuestros servicios compartirán una red puente llamada travellist .

Los archivos de la aplicación se sincronizarán tanto en la app y el nginx servicios a través de montajes de enlace . Los montajes de enlace son útiles en entornos de desarrollo porque permiten una sincronización bidireccional eficaz entre la máquina host y los contenedores.

Crea un nuevo docker-compose.yml archivo en la raíz de la carpeta de la aplicación:

nano docker-compose.yml

Un típico docker-compose.yml El archivo comienza con una definición de versión, seguida de services nodo, bajo el cual se definen todos los servicios. Las redes compartidas generalmente se definen en la parte inferior de ese archivo.

Para comenzar, copie este código repetitivo en su docker-compose.yml archivo:

docker-compose.yml

version: "3.7"
services:


networks:
  travellist:
    driver: bridge

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

La app Servicio

La app El servicio configurará un contenedor llamado travellist-app . Crea una nueva imagen de Docker basada en un Dockerfile ubicado en la misma ruta que docker-compose.yml expediente. La nueva imagen se guardará localmente con el nombre travellist .

Aunque la raíz del documento que se sirve como aplicación se encuentra en nginx contenedor, necesitamos los archivos de la aplicación en algún lugar dentro de la app contenedor también, por lo que podemos ejecutar tareas de línea de comandos con la herramienta Laravel Artisan.

Copie la siguiente definición de servicio en sus services nodo, dentro de docker-compose.yml 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

Esta configuración hace lo siguiente:

• build :esta configuración le dice a Docker Compose que cree una imagen local para la app servicio, utilizando la ruta especificada (contexto) y Dockerfile para obtener instrucciones. Los argumentos user y uid se inyectan en Dockerfile para personalizar los comandos de creación de usuarios en el momento de la compilación.
• image :El nombre que se usará para la imagen que se está construyendo.
• container_name :configura el nombre del contenedor para este servicio.
• restart :Reinicie siempre, a menos que se detenga el servicio.
• working_dir :establece el directorio predeterminado para este servicio como /var/www .
• volumes :crea un volumen compartido que sincronizará los contenidos del directorio actual con /var/www dentro del contenedor. Tenga en cuenta que esta no es la raíz de su documento, ya que vivirá en nginx contenedor.
• networks :Configura este servicio para usar una red llamada travellist .

El db Servicio

El db El servicio utiliza una imagen MySQL 8.0 preconstruida de Docker Hub. Porque Docker Compose carga automáticamente .env archivos de variables ubicados en el mismo directorio que docker-compose.yml archivo, podemos obtener la configuración de nuestra base de datos de Laravel .env archivo que creamos en un paso anterior.

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

docker-compose.yml

  db:
    image: mysql:8.0
    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

Esta configuración hace lo siguiente:

• image :define la imagen de Docker que debe usarse para este contenedor. En este caso, usamos una imagen MySQL 5.7 de Docker Hub.
• container_name :configura el nombre del contenedor para este servicio:travellist-db .
• restart :reinicie siempre este servicio, a menos que se detenga explícitamente.
• environment :Define las variables de entorno en el nuevo contenedor. Estamos usando valores obtenidos de Laravel .env para configurar nuestro servicio MySQL, que creará automáticamente una nueva base de datos y un nuevo usuario en función de las variables de entorno proporcionadas.
• volumes :Crea un volumen para compartir un .sql volcado de base de datos que se utilizará para inicializar la base de datos de la aplicación. La imagen de MySQL importará automáticamente .sql archivos colocados en /docker-entrypoint-initdb.d directorio dentro del contenedor.
• networks :Configura este servicio para usar una red llamada travellist .

El nginx Servicio

El nginx El servicio utiliza una imagen Nginx prediseñada sobre Alpine, una distribución ligera de Linux. Crea un contenedor llamado travellist-nginx , y usa los ports definición para crear una redirección desde el puerto 8000 en el sistema host al puerto 80 dentro del contenedor.

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

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 usarse para este contenedor. En este caso, estamos usando la imagen de Alpine Nginx 1.17.
• container_name :configura el nombre del contenedor para este servicio:travellist-nginx .
• restart :reinicie siempre este servicio, a menos que se detenga explícitamente.
• ports :configura una redirección 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 a /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 que Nginx sirve dentro del contenedor. El segundo volumen se asegurará de que nuestro archivo de configuración de Nginx, ubicado en docker-compose/nginx/travellist.conf , se copia en la carpeta de configuración de Nginx del contenedor.
• networks :Configura este servicio para usar una red llamada travellist .

Terminado docker-compose.yml Archivo

Así es como nuestro docker-compose.yml terminado el archivo se parece a:

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:8.0
    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úrate de guardar el archivo cuando hayas terminado.

Paso 6:ejecutar la aplicación con Docker Compose

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

Crea la app imagen con el siguiente comando:

docker-compose build app

Este comando puede tardar unos minutos en completarse. Verá un resultado similar a este:

OutputBuilding app
Sending build context to Docker daemon  377.3kB
Step 1/11 : FROM php:7.4-fpm
 ---> 8c08d993542f
Step 2/11 : ARG user
 ---> e3ce3af04d87
Step 3/11 : ARG uid
 ---> 30cb921ef7df
Step 4/11 : RUN apt-get update && apt-get install -y     git     curl     libpng-dev     libonig-dev     libxml2-dev     zip     unzip
. . .
 ---> b6dbc7a02e95
Step 5/11 : RUN apt-get clean && rm -rf /var/lib/apt/lists/*
 ---> 10ef9dde45ad
. . .
Step 6/11 : RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd
. . .
 ---> 920e4f09ec75
Step 7/11 : COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 ---> dbbcd44e44af
Step 8/11 : RUN useradd -G www-data,root -u $uid -d /home/$user $user
 ---> db98e899a69a
Step 9/11 : RUN mkdir -p /home/$user/.composer &&     chown -R $user:$user /home/$user
 ---> 5119e26ebfea
Step 10/11 : WORKDIR /var/www
 ---> 699c491611c0
Step 11/11 : USER $user
 ---> cf250fe8f1af
Successfully built cf250fe8f1af
Successfully tagged travellist:latest

Cuando finaliza la compilación, puede ejecutar el entorno en segundo plano con:

docker-compose up -d

OutputCreating travellist-db    ... done
Creating travellist-app   ... done
Creating travellist-nginx ... done

Esto ejecutará sus contenedores en segundo plano. Para mostrar información sobre el estado de sus servicios activos, ejecute:

docker-compose ps

Verá un resultado 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,:::8000->80/tcp

Su entorno ahora está en funcionamiento, pero aún necesitamos ejecutar un par de comandos para terminar de configurar la aplicación. Puede usar el docker-compose exec comando para ejecutar comandos en los contenedores de servicios, como ls -l para mostrar información detallada sobre los archivos en el directorio de la aplicación:

docker-compose exec app ls -l

Outputtotal 256
-rw-r--r-- 1 sammy sammy    737 Apr 18 14:21 Dockerfile
-rw-r--r-- 1 sammy sammy    101 Jan  7  2020 README.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 app
-rwxr-xr-x 1 sammy sammy   1686 Jan  7  2020 artisan
drwxr-xr-x 3 sammy sammy   4096 Jan  7  2020 bootstrap
-rw-r--r-- 1 sammy sammy   1501 Jan  7  2020 composer.json
-rw-r--r-- 1 sammy sammy 179071 Jan  7  2020 composer.lock
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 config
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 database
drwxr-xr-x 4 sammy sammy   4096 Apr 18 14:22 docker-compose
-rw-r--r-- 1 sammy sammy   1017 Apr 18 14:29 docker-compose.yml
-rw-r--r-- 1 sammy sammy   1013 Jan  7  2020 package.json
-rw-r--r-- 1 sammy sammy   1405 Jan  7  2020 phpunit.xml
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 public
-rw-r--r-- 1 sammy sammy    273 Jan  7  2020 readme.md
drwxr-xr-x 6 sammy sammy   4096 Jan  7  2020 resources
drwxr-xr-x 2 sammy sammy   4096 Jan  7  2020 routes
-rw-r--r-- 1 sammy sammy    563 Jan  7  2020 server.php
drwxr-xr-x 5 sammy sammy   4096 Jan  7  2020 storage
drwxr-xr-x 4 sammy sammy   4096 Jan  7  2020 tests
-rw-r--r-- 1 sammy sammy    538 Jan  7  2020 webpack.mix.js

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

docker-compose exec app rm -rf vendor composer.lock
docker-compose exec app composer install

Verá un resultado como este:

OutputNo composer.lock file present. Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.
. . .
Lock file operations: 89 installs, 0 updates, 0 removals
  - Locking doctrine/inflector (2.0.4)
  - Locking doctrine/instantiator (1.4.1)
  - Locking doctrine/lexer (1.2.3)
  - Locking dragonmantank/cron-expression (v2.3.1)
  - Locking egulias/email-validator (2.1.25)
  - Locking facade/flare-client-php (1.9.1)
  - Locking facade/ignition (1.18.1)
  - Locking facade/ignition-contracts (1.0.2)
  - Locking fideloper/proxy (4.4.1)
  - Locking filp/whoops (2.14.5)
. . .
Writing lock file
Installing dependencies from lock file (including require-dev)
Package operations: 89 installs, 0 updates, 0 removals
  - Downloading doctrine/inflector (2.0.4)
  - Downloading doctrine/lexer (1.2.3)
  - Downloading dragonmantank/cron-expression (v2.3.1)
  - Downloading symfony/polyfill-php80 (v1.25.0)
  - Downloading symfony/polyfill-php72 (v1.25.0)
  - Downloading symfony/polyfill-mbstring (v1.25.0)
  - Downloading symfony/var-dumper (v4.4.39)
  - Downloading symfony/deprecation-contracts (v2.5.1)
. . .
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 el artisan Herramienta de línea de comandos de Laravel. Esta clave se utiliza para cifrar sesiones de usuario y otros datos confidenciales:

docker-compose exec app php artisan key:generate

OutputApplication key set successfully.

Ahora vaya 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 caso de que esté ejecutando esta demostración en su máquina local, use http://localhost:8000 para acceder a la aplicación desde su navegador.

Verás una página como esta:

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

docker-compose logs nginx

Attaching to travellist-nginx
. . .
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:49:16 +0000] "GET / HTTP/1.1" 200 627 "-" "curl/7.82.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET / HTTP/1.1" 200 627 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"
travellist-nginx | 172.24.9.1 - - [18/Apr/2022:14:51:27 +0000] "GET /favicon.ico HTTP/1.1" 200 0 "http://localhost:8000/" "Mozilla/5.0 (X11; Linux x86_64; rv:89.0) Gecko/20100101 Firefox/89.0"

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

docker-compose pause

OutputPausing travellist-db    ... done
Pausing travellist-nginx ... done
Pausing travellist-app   ... done

Luego puede reanudar sus servicios con:

docker-compose unpause

OutputUnpausing travellist-app   ... done
Unpausing travellist-nginx ... done
Unpausing travellist-db    ... done

Para cerrar su entorno de Docker Compose y eliminar todos sus contenedores, redes y volúmenes, ejecute:

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 obtener una descripción general de todos los comandos de Docker Compose, consulte la referencia de la línea de comandos de Docker Compose.

Conclusión

En esta guía, configuramos un entorno Docker con tres contenedores utilizando Docker Compose para definir nuestra infraestructura en un archivo YAML.

A partir de este momento, puede trabajar en su aplicación Laravel sin necesidad de instalar y configurar un servidor web local para el desarrollo y las pruebas. Además, trabajará con un entorno desechable que se puede replicar y distribuir fácilmente, lo que puede ser útil mientras desarrolla su aplicación y también cuando avanza hacia un entorno de producción.