One place for hosting & domains

      Compose

      Cómo configurar Laravel, Nginx y MySQL con Docker Compose


      El autor seleccionó a The FreeBSD Foundation para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Durante los últimos años, Docker se ha convertido en una solución de uso frecuente para implementar aplicaciones gracias a la forma en que simplifican el funcionamiento y la implementación de aplicaciones en contenedores efímeros. Cuando se usa una pila de aplicación LEMP, por ejemplo, con PHP, Nginx, MySQL y el framework de Laravel, Docker puede simplificar considerablemente el proceso de configuración.

      Docker Compose ha simplificado aún más el proceso de desarrollo al permitir que los desarrolladores definan su infraestructura, incluidos los servicios de aplicación, las redes y los volúmenes, en un único archivo. Docker Compose ofrece una alternativa eficaz para ejecutar varios comandos docker container create y docker container run.

      A través de este tutorial, creará una aplicación web utilizando el marco Laravel con Nginx como servidor web y MySQL como base de datos; todo ello dentro de contenedores de Docker. Definirá toda la configuración de pila en un archivo docker-compose, junto con los archivos de configuración para PHP, MySQL y Nginx.

      Requisitos previos

      Antes de comenzar, necesitará lo siguiente:

      Paso 1: Descargar Laravel e instalar dependencias

      Como primer paso, obtendremos la versión más reciente de Laravel e instalaremos las dependencias del proyecto. Incluiremos Composer, el administrador de paquetes de nivel de aplicación para PHP. Instalaremos estas dependencias con Docker para evitar la instalación de Composer a nivel global.

      Primero, compruebe que se encuentre en su directorio de inicio, clone la última versión de Laravel y dispóngala en un directorio llamado laravel-app:

      • cd ~
      • git clone https://github.com/laravel/laravel.git laravel-app

      Posiciónese en el directorio laravel-app:“

      A continuación, utilice la imagen de composer de Docker a fin de montar los directorios que necesitará para su proyecto de Laravel y evitar la sobrecarga que implica instalar Composer a nivel global:

      • docker run --rm -v $(pwd):/app composer install

      Mediante los indicadores -v y --rm con docker run se crea un contenedor efímero para el cual se aplica un montaje “bind” a la lista de comandos actual antes de su eliminación. Con esto, se copiará el contenido de su directorio ~/laravel-app al contenedor y también se garantizará que la carpeta vendor creada por Composer dentro del contenedor se copie a su directorio actual.

      Como paso final, establezca permisos en el directorio del proyecto para que sea propiedad de su usuario no root:

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

      Esto será importante al escribir el Dockerfile para la imagen de su aplicación en el paso 4, ya que le permitirá trabajar con el código de la aplicación y ejecutar procesos en su contenedor como usuario no root.

      Una vez establecido el código de su aplicación, puede proceder a definir sus servicios con Docker Compose.

      Paso 2: Crear el archivo de Docker Compose

      Desarrollar sus aplicaciones con Docker Compose simplifica el proceso de configuración y control de versiones de su infraestructura. Para configurar nuestra aplicación de Laravel, escribiremos un archivo docker-compose que defina nuestro servidor web, nuestra base de datos y nuestros servicios de aplicación.

      Abra el archivo:

      • nano ~/laravel-app/docker-compose.yml

      En el archivo docker-compose, definirá tres servicios: app, webserver y db. Agregue el siguiente código al archivo, asegúrese de sustituir la contraseña root de MySQL_ROOT_PASSWORD, definida como una variable de entorno bajo el servicio db, por una contraseña segura de su elección:

      ~/laravel-app/docker-compose.yml

      version: '3'
      services:
      
        #PHP Service
        app:
          build:
            context: .
            dockerfile: Dockerfile
          image: digitalocean.com/php
          container_name: app
          restart: unless-stopped
          tty: true
          environment:
            SERVICE_NAME: app
            SERVICE_TAGS: dev
          working_dir: /var/www
          networks:
            - app-network
      
        #Nginx Service
        webserver:
          image: nginx:alpine
          container_name: webserver
          restart: unless-stopped
          tty: true
          ports:
            - "80:80"
            - "443:443"
          networks:
            - app-network
      
        #MySQL Service
        db:
          image: mysql:5.7.22
          container_name: db
          restart: unless-stopped
          tty: true
          ports:
            - "3306:3306"
          environment:
            MYSQL_DATABASE: laravel
            MYSQL_ROOT_PASSWORD: your_mysql_root_password
            SERVICE_TAGS: dev
            SERVICE_NAME: mysql
          networks:
            - app-network
      
      #Docker Networks
      networks:
        app-network:
          driver: bridge
      

      Los servicios definidos aquí incluyen lo siguiente:

      • app: esta definición de servicio contiene la aplicación de Laravel y ejecuta una imagen personalizada de Docker, digitalocean.com/php, que usted definirá en el paso 4. También fija /var/www para working_dir en el contenedor.
      • webserver: esta definición de servicio obtiene la imagen nginx:alpine de Docker y expone los puertos 80 y 443.
      • db: esta definición de servicio obtiene la imagen mysql:5.7.22 de Docker y define algunas variables de entorno, incluida una base de datos llamada laravel para su aplicación y la contraseña root para la base de datos. Puede nombrar la base de datos como lo desee y debe sustituir your_mysql_root_password por su propia contraseña segura. Esta definición de servicio también asigna el puerto 3306 en el host al puerto 3306 en el contenedor.

      Cada propiedad container_name define un nombre para el contenedor, que corresponde al nombre del servicio. Si no define esta propiedad, Docker asignará un nombre a cada contenedor combinando el nombre de una persona históricamente famosa y una palabra al azar separada por un guión bajo.

      Para facilitar la comunicación entre contenedores, los servicios se conectan a una red de puente llamada app-network. Una red de puente utiliza un puente de software que permite que los contenedores conectados a la misma red de puente se comuniquen entre sí. El controlador de puente instala de forma automática reglas en la máquina host para que los contenedores de diferentes redes de puente no puedan comunicarse directamente entre sí. Esto crea un mayor nivel de seguridad para las aplicaciones y garantiza que solo los servicios relacionados puedan comunicarse entre sí. También implica que usted puede definir diferentes redes y servicios que se conectan a funciones relacionadas: los servicios de aplicaciones clientes pueden utilizar una red frontend, por ejemplo, y los servicios de servidor pueden usar una red backend.

      Veamos la forma de agregar volúmenes y montajes “bind” a sus definiciones de servicio para persistir los datos de su aplicación.

      Paso 3: Persistir datos

      Docker tiene características potentes y convenientes para la persistencia de datos. En nuestra aplicación, usaremos volúmenes y montajes bind para persistir la base de datos y los archivos de aplicación y configuración. Los volúmenes ofrecen flexibilidad para los respaldos y la persistencia más allá del ciclo de vida de un contenedor, mientras que los montajes “bind” facilitan los cambios de código durante el desarrollo y realizan cambios en los archivos host o directorios disponibles de inmediato en sus contenedores. En nuestra configuración usaremos ambas opciones.

      Advertencia: Al usar de montajes “bind”, permite cambiar el sistema de archivos host a través de procesos que se ejecutan en un contenedor. Se incluye la creación, modificación o eliminación de archivos o directorios importantes del sistema. Esta es una poderosa capacidad que tiene consecuencias para la seguridad y podría afectar a los procesos no Docker del sistema host. Use los montajes “bind” con cuidado.

      En el archivo docker-compose, defina un volumen llamado dbdata bajo la definición de servicio db para persistir la base de datos de MySQL:

      ~/laravel-app/docker-compose.yml

      ...
      #MySQL Service
      db:
        ...
          volumes:
            - dbdata:/var/lib/mysql
          networks:
            - app-network
        ...
      

      El volumen llamado dbdata persiste el contenido de la carpeta /var/lib/mysql situada dentro del contenedor. Esto le permite detener y reiniciar el servicio db sin perder datos.

      En la parte inferior del archivo, agregue la definición para el volumen dbdata:

      ~/laravel-app/docker-compose.yml

      ...
      #Volumes
      volumes:
        dbdata:
          driver: local
      

      Una vez implementada esta definición, podrá utilizar este volumen en todos los servicios.

      A continuación, agregue un montaje “bind” al servicio db para los archivos de configuración de MySQL que creará en el paso 7:

      ~/laravel-app/docker-compose.yml

      ...
      #MySQL Service
      db:
        ...
          volumes:
            - dbdata:/var/lib/mysql
            - ./mysql/my.cnf:/etc/mysql/my.cnf
        ...
      

      Este montaje “bind” vincula ~/laravel-app/mysql/my.cnf a /etc/mysql/my.cnf en el contenedor.

      A continuación, agregue montajes “bind” al servicio webserver. Habrá dos: uno para el código de su aplicación y otro para la definición de configuración de Nginx que creará en el paso 6:

      ~/laravel-app/docker-compose.yml

      #Nginx Service
      webserver:
        ...
        volumes:
            - ./:/var/www
            - ./nginx/conf.d/:/etc/nginx/conf.d/
        networks:
            - app-network
      

      El primer montaje “bind” vincula el código de la aplicación situado en el directorio ~/laravel-app al directorio /var/www dentro del contenedor. El archivo de configuración que agregará a ~/laravel-app/nginx/conf.d/ también se montará a /etc/nginx/conf.d/ en el contenedor, lo que le permitirá agregar o modificar el contenido del directorio de configuración cuando sea necesario.

      Por último, agregue los siguientes montajes “bind” al servicio app para el código de la aplicación y los archivos de configuración:

      ~/laravel-app/docker-compose.yml

      #PHP Service
      app:
        ...
        volumes:
             - ./:/var/www
             - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
        networks:
            - app-network
      

      El servicio app vincula mediante montaje “bind” la carpeta ~/laravel-app, que contiene el código de la aplicación, a la carpeta /var/www en el contenedor. Esto acelerará el proceso de desarrollo, ya que los cambios realizados en el directorio de su aplicación local se reflejarán de inmediato dentro del contenedor. También vinculará su archivo de configuración PHP, ~/laravel-app/php/local.ini, a /usr/local/etc/php/conf.d/local.ini, dentro del contenedor. Creará el archivo de configuración de PHP local en el paso 5.

      Ahora, su archivo docker-compose tendrá el siguiente aspecto:

      ~/laravel-app/docker-compose.yml

      version: '3'
      services:
      
        #PHP Service
        app:
          build:
            context: .
            dockerfile: Dockerfile
          image: digitalocean.com/php
          container_name: app
          restart: unless-stopped
          tty: true
          environment:
            SERVICE_NAME: app
            SERVICE_TAGS: dev
          working_dir: /var/www
          volumes:
            - ./:/var/www
            - ./php/local.ini:/usr/local/etc/php/conf.d/local.ini
          networks:
            - app-network
      
        #Nginx Service
        webserver:
          image: nginx:alpine
          container_name: webserver
          restart: unless-stopped
          tty: true
          ports:
            - "80:80"
            - "443:443"
          volumes:
            - ./:/var/www
            - ./nginx/conf.d/:/etc/nginx/conf.d/
          networks:
            - app-network
      
        #MySQL Service
        db:
          image: mysql:5.7.22
          container_name: db
          restart: unless-stopped
          tty: true
          ports:
            - "3306:3306"
          environment:
            MYSQL_DATABASE: laravel
            MYSQL_ROOT_PASSWORD: your_mysql_root_password
            SERVICE_TAGS: dev
            SERVICE_NAME: mysql
          volumes:
            - dbdata:/var/lib/mysql/
            - ./mysql/my.cnf:/etc/mysql/my.cnf
          networks:
            - app-network
      
      #Docker Networks
      networks:
        app-network:
          driver: bridge
      #Volumes
      volumes:
        dbdata:
          driver: local
      

      Guarde el archivo y cierre su editor cuando termine de realizar cambios.

      Ahora que su archivo docker-compose está escrito, podrá crear la imagen personalizada para su aplicación.

      Paso 4: Crear el Dockerfile

      Docker le permite especificar el entorno dentro de contenedores individuales con un Dockerfile. Un Dockerfile le permite crear imágenes personalizadas que puede emplear para instalar el software requerido por su aplicación y configurar los ajustes según sus requisitos. Puede introducir en Docker Hub o en cualquier registro privado las imágenes personalizadas que cree.

      Nuestro Dockerfile se ubicará en nuestro directorio ~/laravel-app. Cree el archivo:

      • nano ~/laravel-app/Dockerfile

      Este Dockerfile establecerá la imagen de base y especificará los comandos y las instrucciones que se necesitan para crear la imagen de aplicación de Laravel. Agregue el siguiente código al archivo:

      ~/laravel-app/php/Dockerfile

      FROM php:7.2-fpm
      
      # Copy composer.lock and composer.json
      COPY composer.lock composer.json /var/www/
      
      # Set working directory
      WORKDIR /var/www
      
      # Install dependencies
      RUN apt-get update && apt-get install -y 
          build-essential 
          mysql-client 
          libpng-dev 
          libjpeg62-turbo-dev 
          libfreetype6-dev 
          locales 
          zip 
          jpegoptim optipng pngquant gifsicle 
          vim 
          unzip 
          git 
          curl
      
      # Clear cache
      RUN apt-get clean && rm -rf /var/lib/apt/lists/*
      
      # Install extensions
      RUN docker-php-ext-install pdo_mysql mbstring zip exif pcntl
      RUN docker-php-ext-configure gd --with-gd --with-freetype-dir=/usr/include/ --with-jpeg-dir=/usr/include/ --with-png-dir=/usr/include/
      RUN docker-php-ext-install gd
      
      # Install composer
      RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
      
      # Add user for laravel application
      RUN groupadd -g 1000 www
      RUN useradd -u 1000 -ms /bin/bash -g www www
      
      # Copy existing application directory contents
      COPY . /var/www
      
      # Copy existing application directory permissions
      COPY --chown=www:www . /var/www
      
      # Change current user to www
      USER www
      
      # Expose port 9000 and start php-fpm server
      EXPOSE 9000
      CMD ["php-fpm"]
      

      Primero, el Dockerfile crea una imagen en la parte superior de la imagen de php:7.2-fpm Docker. Esta es una imagen basada en Debian que tiene instalada la implementación PHP-FPM de PHP FastCGI. El archivo también instala con composer los paquetes previos para Laravel: mcrypt, pdo_mysql, mbstring e imagick.

      La directiva RUN especifica los comandos para actualizar, instalar y configurar los ajustes dentro del contenedor. Esto incluye la creación de un usuario dedicado y un grupo llamado www. La instrucción WORKDIR especifica el directorio /var/www como directorio de trabajo para la aplicación.

      Crear un usuario dedicado y un grupo con permisos restringidos mitiga la vulnerabilidad inherente al ejecutar contenedores de Docker, que se funcionan por defecto como root. En lugar de ejecutar este contenedor como root, creamos el usuario** www**, que tiene acceso de lectura y escritura a la carpeta /var/www gracias a la instrucción COPY que usaremos con el indicador --chown para copiar los permisos de la carpeta de la aplicación.

      Por último, el comando EXPOSE expone un puerto del contenedor, el 9000, para el servidor php-fpm. CMD especifica el comando que debe ejecutarse una vez que se cree el contenedor. Aquí, el CMD especifica “php-fpm”, que iniciará el servidor.

      Guarde el archivo y cierre su editor cuando termine de realizar cambios.

      Ahora podrá definir su configuración de PHP.

      Paso 5: Configurar PHP

      Ahora que definió su infraestructura en el archivo docker-compose, puede configurar el servicio PHP para que funciones como procesador PHP para solicitudes entrantes de Nginx.

      Para configurar PHP, creará el archivo local.ini dentro de la carpeta php. Este es el archivo que vinculó mediante montaje “bind” a /usr/local/etc/php/conf.d/local.ini dentro del contenedor en el paso 2. Crear este archivo le permitirá anular el archivo php.ini predeterminado que PHP lee al iniciarse.

      Cree el directorio php:

      A continuación, abra el archivo local.ini:

      • nano ~/laravel-app/php/local.ini

      Con el propósito de demostrar cómo configurar PHP, agregaremos el siguiente código para establecer limitaciones de tamaño para archivos cargados:

      ~/laravel-app/php/local.ini

      upload_max_filesize=40M
      post_max_size=40M
      

      Las directivas upload_max_filesize y post_max_size establecen el tamaño máximo permitido para los archivos cargados y demuestran la forma en que puede configurar parámetros php.ini desde su archivo local.ini. Puede disponer cualquier configuración específica de PHP que desee anular en el archivo local.ini.

      Guarde el archivo y cierre el editor.

      Una vez preparado su archivo PHP local.ini, podrá configurar Nginx.

      Paso 6: Configurar Nginx

      Una vez configurado el servicio PHP, podrá modificar el servicio Nginx para usar PHP-FPM como servidor de FastCGI para proporcionar contenido dinámico. El servidor FastCGI se basa en un protocolo binario para interconectar programas interactivos con un servidor web. Para obtener más información, consulte este artículo sobre Comprensión e implementación de proxy de FastCGI en Nginx.

      Para configurar Nginx, creará un archivo app.conf con la configuración del servicio en la carpeta ~/laravel-app/nginx/conf.d/.

      Primero, cree el directorio nginx/conf.d/:

      • mkdir -p ~/laravel-app/nginx/conf.d

      Luego, cree el archivo de configuración app.conf:

      • nano ~/laravel-app/nginx/conf.d/app.conf

      Agregue el siguiente código al archivo para especificar su configuración de Nginx:

      ~/laravel-app/nginx/conf.d/app.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;
          }
      }
      

      El bloque de servidor define la configuración para el servidor web de Nginx con las siguientes directivas:

      • listen: esta directiva define el puerto en el cual el servidor escuchará las solicitudes entrantes.
      • error_log y access_log: estas directivas definen los archivos para escribir registros.
      • root: esta directiva establece la ruta de la carpeta root y forma la ruta para cualquier archivo solicitado en el sistema de archivos local.

      En el bloque de ubicación php, la directiva fastcgi_pass especifica que el servicio de app escuchando en un socket TCP del puerto 9000. Esto hace que el servidor PHP-FPM escuche a través de la red en lugar de hacerlo en un socket de Unix. Aunque un socket de Unix tiene una ligera ventaja de velocidad con respecto a un socket de TCP, no cuenta con un protocolo de red y, por lo tanto, omite la pila de red. Para los casos en los cuales los hosts están ubicados en una máquina, puede tener sentido la presencia de un socket de Unix. Sin embargo, en los casos en los que tenga servicios ejecutándose en diferentes hosts, un socket de TCP le ofrece la ventaja de permitirle conectarse a servicios distribuidos. Debido a que nuestro contenedor app se ejecuta en un host diferente del de nuestro contenedor webserver, un socket de TCP es la opción que más sentido tiene para nuestro tipo de configuración.

      Guarde el archivo y cierre su editor cuando termine de realizar cambios.

      Gracias al montaje “bind” mount que creó en el paso 2, cualquier cambio que realice dentro de la carpeta nginx/conf.d/ se reflejará directamente dentro del contenedor webserver.

      A continuación, observaremos nuestras configuraciones de MySQL.

      Paso 7: Configurar MySQL

      Una vez configurados PHP y Nginx, podrá habilitar MySQL para que actúe como base de datos para su aplicación.

      Para configurar MySQL, creará el archivo my.cnf en la carpeta mysql. Este es el archivo que vinculó mediante montaje “bind” a /etc/mysql/my.cnf dentro del contenedor en el paso 2. Este montaje “bind” le permite anular los ajustes de my.cnf según sea necesario.

      Para demostrar cómo funciona esto, agregaremos al archivo my.cnf ajustes que habiliten el registro general de consulta y especifiquen el archivo de registro.

      Primero, cree el directorio mysql:

      • mkdir ~/laravel-app/mysql

      A continuación, cree el archivo my.cnf:

      • nano ~/laravel-app/mysql/my.cnf

      En el archivo, agregue el siguiente código para habilitar el registro de consulta y establecer la ubicación del archivo de registro:

      ~/laravel-app/mysql/my.cnf

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

      Este archivo my.cnf habilita los registros y define la configuración de general_log con el valor 1 para permitir registros generales. La configuración general_log_file especifica dónde se almacenarán los registros.

      Guarde el archivo y cierre el editor.

      Nuestro siguiente paso será iniciar los contenedores.

      Paso 8: Ejecutar los contenedores y modificar las preferencias de entorno

      Ahora que definió todos sus servicios en su archivo docker-compose y creó los archivos de configuración para estos servicios, puede iniciar los contenedores. Sin embargo, como paso final, crearemos una copia del archivo .env.example que Laravel incluye por defecto y daremos a la copia el nombre .env, que corresponde al archivo que Laravel prevé que definirá su entorno:

      Configuraremos los detalles específicos de nuestros ajustes en este archivo una vez que iniciemos los contenedores.

      Una vez definidos todos sus servicios en su archivo docker-compose, solo deberá emitir un comando para iniciar todos los contenedores, crear los volúmenes y configurar y conectar las redes:

      Cuando ejecute docker-compose por primera vez, descargará todas las imágenes de Docker necesarias, lo cual podría tardar un tiempo. Una vez que las imágenes se descarguen y se almacenen en su máquina local, Compose creará sus contenedores. El indicador -d agrega un demonio al proceso y ejecuta sus contenedores en segundo plano.

      Una vez que el proceso esté completo, use el siguiente comando para enumerar todos los contenedores en ejecución:

      Verá el siguiente resultado con detalles sobre sus contenedores app, webserver y db:

      Output

      CONTAINER ID NAMES IMAGE STATUS PORTS c31b7b3251e0 db mysql:5.7.22 Up 2 seconds 0.0.0.0:3306->3306/tcp ed5a69704580 app digitalocean.com/php Up 2 seconds 9000/tcp 5ce4ee31d7c0 webserver nginx:alpine Up 2 seconds 0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp

      CONTAINER ID en este resultado es un identificador único para cada contenedor, mientras que NAMES enumera el nombre de servicio asociado con cada una. Puede usar ambos identificadores para acceder a los contenedores. IMAGE define el nombre de imagen para cada contenedor, mientras que STATUS proporciona información sobre el su estado: en ejecución, en proceso de reinicio o detenido.

      Ahora puede modificar el archivo .env en el contenedor app para incluir detalles específicos sobre su configuración.

      Abra el archivo usando docker-compose exec, que permite ejecutar comandos específicos en contenedores. En este caso, abrirá el archivo para editar lo siguiente:

      • docker-compose exec app nano .env

      Busque el bloque que especifica DB_CONNECTION y actualícelo para reflejar los detalles de su configuración. Cambiará los siguientes campos:

      • DB_HOST será su contenedor de base de datos db.
      • `DB_DATABASE será la base de datos laravel.
      • `DB_USERNAME será el nombre de usuario que usará para su base de datos. En este caso, usaremos laraveluser.
      • DB_PASSWORD será la contraseña segura que desee utilizar para esta cuenta de usuario.

      /var/www/.env

      DB_CONNECTION=mysql
      DB_HOST=db
      DB_PORT=3306
      DB_DATABASE=laravel
      DB_USERNAME=laraveluser
      DB_PASSWORD=your_laravel_db_password
      

      Guarde sus cambios y cierre el editor.

      A continuación, establezca la clave de aplicación para la aplicación de Laravel con el comando php artisan key:generate. Este comando generará una clave, dispondrá una copia de esta en su archivo .env y se asegurará de que las sesiones y los datos cifrados de sus usuarios permanezcan seguros:

      • docker-compose exec app php artisan key:generate

      Con esto, dispondrá de los ajustes de entorno necesarios para ejecutar su aplicación. Para almacenar en caché estos ajustes en un archivo, lo cual aumentará la velocidad de carga de su aplicación, ejecute lo siguiente:

      • docker-compose exec app php artisan config:cache

      Sus ajustes de configuración se cargarán en /var/www/bootstrap/cache/config.php en el contenedor.

      Como paso final, visite http://your_server_ip en el navegador. Verá la siguiente página de inicio para su aplicación Laravel:

      Página de inicio de Laravel

      Con sus contenedores en ejecución y la información de su configuración lista, podrá configurar la información de usuario para la base de datos laravel en el contenedor db.

      Paso 9: Crear un usuario para MySQL

      La instalación predeterminada de MySQL solo crea la cuenta administrativa root, que tiene privilegios ilimitados en el servidor de base de datos. Por lo general, es mejor evitar el uso de la cuenta administrativa root al interactuar con la base de datos. En su lugar, crearemos un usuario de base de datos dedicado para la base de datos de nuestra aplicación de Laravel.

      Para crear un nuevo usuario, ejecute un shell bash interactivo en el contenedor db con docker-compose exec:

      • docker-compose exec db bash

      Dentro del contenedor, inicie sesión en la cuenta administrativa root de MySQL:

      Se le solicitará la contraseña que estableció para la cuenta root de MySQL durante la instalación en su archivo docker-compose.

      Comience revisando la base de datos llamada laravel, que definió en su archivo docker-compose. Ejecute el comando show databases para verificar las bases de datos existentes:”“”

      Verá la base de datos laravel en el resultado:“

      Output

      +--------------------+ | Database | +--------------------+ | information_schema | | laravel | | mysql | | performance_schema | | sys | +--------------------+ 5 rows in set (0.00 sec)

      A continuación, cree la cuenta de usuario que tendrá permisos de acceso a esta base de datos. Nuestro nombre de usuario será laraveluser, aunque puede cambiarlo por otro que prefiera. Asegúrese de que su nombre de usuario y contraseña aquí coincidan con la información que estableció en su archivo .env en el paso anterior:”“

      • GRANT ALL ON laravel.* TO 'laraveluser'@'%' IDENTIFIED BY 'your_laravel_db_password';

      Elimine los privilegios para notificar los cambios al servidor MySQL:

      Cierre MySQL:

      Por último, cierre el contenedor:

      Con esto, habrá configurado la cuenta de usuario para la base de datos de su aplicación de Laravel y estará listo para migrar sus datos y trabajar con la consola Tinker.

      Paso 10: Migrar datos y trabajar con la consola Tinker

      Con su aplicación en ejecución, podrá migrar sus datos y experimentar con el comando tinker, que iniciará una consola PsySH con Laravel precargada. PsySH es una consola para desarrolladores de tiempo de ejecución y un depurador interactivo para PHP, y Tinker es un REPL específico para Laravel. Usar el comando tinker le permitirá interactuar con su aplicación de Laravel desde la línea de comandos en un shell interactivo.

      Primero, pruebe la conexión con MySQL ejecutando el comando Laravel artisan migrate, que crea una tabla migrations en la base de datos dentro del contenedor:

      • docker-compose exec app php artisan migrate

      Con este comando se migrarán las tablas predeterminadas de Laravel. El resultado que confirme la migración tendrá este aspecto:

      Output

      Migration table created successfully. Migrating: 2014_10_12_000000_create_users_table Migrated: 2014_10_12_000000_create_users_table Migrating: 2014_10_12_100000_create_password_resets_table Migrated: 2014_10_12_100000_create_password_resets_table

      Una vez que la migración esté completa, podrá ejecutar una consulta para verificar si su conexión a la base de datos es correcta usando el comando tinker:

      • docker-compose exec app php artisan tinker

      Pruebe la conexión de MySQL obteniendo los datos que acaba de migrar:

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

      Verá un resultado similar a este:

      Output

      => IlluminateSupportCollection {#2856 all: [ {#2862 +"id": 1, +"migration": "2014_10_12_000000_create_users_table", +"batch": 1, }, {#2865 +"id": 2, +"migration": "2014_10_12_100000_create_password_resets_table", +"batch": 1, }, ], }

      Puede usar tinker para interactuar con sus bases de datos y experimentar con servicios y modelos.

      Una vez implementada su aplicación de Laravel, estará listo para seguir adelante con el desarrollo y la experimentación.

      Conclusión

      Con esto, dispondrá de una aplicación de pila LEMP en ejecución en su servidor, que probó accediendo a la página de bienvenida de Laravel y creando migraciones de base de datos de MySQL.

      La clave de la simplicidad en esta instalación es Docker Compose, que le permite crear un grupo de contenedores de Docker definidos en un solo archivo mediante un comando. Si desea obtener más información sobre cómo realizar una integración continua con Docker Compose, consulte Cómo configurar un entorno de prueba de integración continua con Docker y Docker Compose en Ubuntu 16.04. Si desea simplificar su proceso de implementación de la aplicación de Laravel, resultará pertinente el recurso Cómo implementar de forma automática aplicaciones de Laravel con Deployer en Ubuntu 16.04.



      Source link

      Cómo instalar Docker Compose en Ubuntu 18.04


      Introducción

      Docker es una excelente herramienta para automatizar la implementación de aplicaciones de Linux dentro de contenedores de software, pero para aprovechar plenamente su potencial cada componente de una aplicación debería ejecutarse en su propio contenedor individual. En el caso de aplicaciones complejas con muchos componentes, la estrategia de organizar todos los contenedores para que se inicien, se comuniquen y se desconecten juntos puede volverse poco productiva en poco tiempo.

      La comunidad de Docker propuso una solución popular llamada Fig, que permitió el uso de un archivo YAML único para organizar la totalidad de sus contenedores y configuraciones de Docker. La popularidad de esto fue tal que el equipo de Docker decidió crear Docker Compose en base a la fuente de Fig, que ahora es obsoleta. Docker Compose permite que los usuarios organicen de forma más sencilla los procesos de los contenedores de Docker, incluidos los de inicio, cierre y configuración de enlaces y volúmenes dentro de los contenedores.

      En este tutorial, le mostraremos la forma de instalar la versión más reciente de Docker Compose para ayudarlo a administrar aplicaciones en varios contenedores.

      Requisitos previos

      Para seguir los pasos de este artículo, necesitará un servidor Ubuntu 18.04. con lo siguiente:

      Una vez implementado esto, estará listo para seguir adelante.

      Nota: Aunque en los requisitos previos se brindan instrucciones para instalar Docker en Ubuntu 18.04, los comandos de Dockerde este artículo deben funcionar en otros sistemas operativos mientras Docker esté instalado.

      Paso 1: Instalar Docker Compose

      Si bien se puede instalar Docker Compose desde los repositorios oficiales de Ubuntu, la versión está considerablemente atrasada respecto de la más reciente. Por lo tanto, instalaremos Docker Compose desde el repositorio de GitHub. El comando que se muestra a continuación difiere ligeramente respecto del que encontrará en la página Versiones. Al usar el indicador -o para especificar primero el archivo de salida en lugar de redirigirla, esta sintaxis evita que se produzca un error de denegación de permiso al usar sudo.

      Revisaremos la versión actual y, si es necesario, la actualizaremos en el comando que se muestra a continuación:

      • sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

      Luego, configuraremos los permisos:

      • sudo chmod +x /usr/local/bin/docker-compose

      A continuación, comprobaremos que la instalación se haya realizado de forma correcta revisando la versión:

      Con esto se imprimirá la versión que instalamos:

      Output

      docker-compose version 1.21.2, build a133471

      Ahora que instalamos Docker Compose, estamos listos para ejecutar un ejemplo “Hello World”.

      Paso 2: Ejecución de un contenedor con Docker Compose

      En Docker Hub, el registro público de Docker, se incluye una imagen de Hello World para demostración y pruebas. En ella se muestra la configuración mínima requerida para ejecutar un contenedor usando Docker Compose; un archivo YAML que llama a una única imagen:

      Primero, crearemos un directorio para el archivo YAML y nos ubicaremos en él:

      • mkdir hello-world
      • cd hello-world

      Luego, crearemos el archivo YAML:

      Introduzca el siguiente contenido en el archivo, guárdelo y cierre el editor de texto:

      docker-compose.yml

      my-test:
       image: hello-world
      

      La primera línea del archivo YAML se utiliza como parte del nombre del contenedor. En la segunda línea se especifica la imagen que se debe usar para crear el contenedor. Cuando ejecutamos el comando docker-compose se buscará una imagen local con el nombre que precisamos: hello-world. Una vez implementado esto, guardaremos el archivo y lo cerraremos.

      Podemos ver de forma manual imágenes de nuestro sistema con el comando docker images:

      Cuando no hay imágenes locales, solo se muestran los encabezados de columnas:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE

      Ahora, aunque aún nos encontremos en el directorio ~/hello-world, ejecutaremos el siguiente comando:

      La primera vez que ejecutemos el comando, si no aparece una imagen local con el nombre hello-world Docker Compose la extraerá del repositorio público de Docker Hub:

      Output

      Pulling my-test (hello-world:latest)... latest: Pulling from library/hello-world c04b14da8d14: Downloading [==================================================>]c04b14da8d14: Extracting [==================================================>]c04b14da8d14: Extracting [==================================================>]c04b14da8d14: Pull complete Digest: sha256:0256e8a36e2070f7bf2d0b0763dbabdd67798512411de4cdcf9431a1feb60fd9 Status: Downloaded newer image for hello-world:latest . . .

      Tras extraer la imagen, docker-compose crea un contenedor, adjunta y ejecuta el programa hello, lo que a su vez confirma que la instalación parece funcionar:

      Output

      . . . Creating helloworld_my-test_1... Attaching to helloworld_my-test_1 my-test_1 | my-test_1 | Hello from Docker. my-test_1 | This message shows that your installation appears to be working correctly. my-test_1 | . . .

      Luego imprime una explicación de lo que hizo:

      Output of docker-compose up

      1. The Docker client contacted the Docker daemon. 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. 3. The Docker daemon created a new container from that image which runs the executable that produces the output you are currently reading. 4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.

      Los contenedores de Docker solo se ejecutan mientras el comando está activo, de modo que cuando hello termina de ejecutarse, el contenedor se detiene. Por consiguiente, cuando examinamos procesos activos los encabezados de columna aparecerán, pero el contenedor de hello-world no figurará por no estar en ejecución.

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

      Podemos ver la información del contenedor, la cual necesitaremos en el siguiente paso, usando el indicador -a que muestra todos los contenedores, no solo los activos:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 06069fd5ca23 hello-world "/hello" 35 minutes ago Exited (0) 35 minutes ago drunk_payne

      Esto muestra la información que deberemos eliminar del contenedor cuando terminemos con él.

      Paso 3: Eliminación de la imagen (opcional)

      Para evitar ocupar espacio innecesario en el disco, eliminaremos la imagen local. Para hacerlo, tendremos que eliminar todos los contenedores que hagan referencia a la imagen usando el comandodocker rm, seguido del ID DEL CONTENEDOR o del NOMBRE. A continuación, usaremos el ID del CONTENEDOR del comando docker ps -a que acabamos de ejecutar. Asegúrese de sustituir el ID de su contenedor:

      Una vez eliminados todos los contenedores que hagan referencia a la imagen, podemos eliminar la imagen:

      Conclusión

      De esta manera, instalamos Docker Compose, probamos nuestra instalación ejecutando un ejemplo de Hello World y eliminamos la imagen de prueba y el contenedor.

      Aunque el ejemplo de Hello World confirmó nuestra instalación, la configuración sencilla no muestra uno de los principales beneficios de Docker Compose: crear y eliminar un grupo de contenedores de Docker al mismo tiempo. Para ver el poder de Docker Compose en acción, tal vez desee revisar el ejemplo práctico Cómo configurar un entorno de integración continua de prueba con Docker y Docker Compose en Ubuntu 16.04 (nota: este artículo es para Ubuntu 16.04 y no responde a la versión 18.04).



      Source link

      Como Instalar e Usar o Docker Compose no CentOS 7


      Introdução

      O Docker é uma ótima ferramenta para automatizar o deployment de aplicações Linux dentro de containers de software, mas para aproveitar realmente ao máximo seu potencial, é melhor se cada componente de sua aplicação for executado em seu próprio container. Para aplicações complexas com muitos componentes, orquestrar todos os containers para iniciar e encerrar juntos (para não mencionar ter que falar uns com os outros) pode rapidamente tornar-se problemático.

      A comunidade Docker apareceu com uma solução popular chamada Fig, que permitia usar um único arquivo YAML para orquestrar todos os containers e configurações do Docker. Isso se tornou tão popular que a equipe do Docker decidiu fazer o Docker Compose com base nos fontes do Fig, que agora está obsoleto. O Docker Compose torna mais fácil para os usuários orquestrarem os processos de containers do Docker, incluindo inicialização, encerramento e configuração de links e volumes dentro de containers.

      Neste tutorial, você instalará a versão mais recente do Docker Compose para ajudá-lo a gerenciar aplicações de vários containers e explorará os comandos básicos do software.

      Conceitos de Docker e Docker Compose

      A utilização do Docker Compose requer uma combinação de vários conceitos diferentes do Docker em um, portanto, antes de começarmos, vamos analisar alguns dos vários conceitos envolvidos. Se você já estiver familiarizado com os conceitos do Docker, como volumes, links e port forwarding, você pode querer ir em frente e pular para a próxima seção.

      Imagens Docker

      Cada container Docker é uma instância local de uma imagem Docker. Você pode pensar em uma imagem Docker como uma instalação completa do Linux. Geralmente, uma instalação mínima contém apenas o mínimo de pacotes necessários para executar a imagem. Essas imagens usam o kernel do sistema host, mas como elas estão rodando dentro de um container Docker e só veem seu próprio sistema de arquivos, é perfeitamente possível executar uma distribuição como o CentOS em um host Ubuntu (ou vice-versa).

      A maioria das imagens Docker é distribuída através do Docker Hub, que é mantido pela equipe do Docker. Os projetos open source mais populares têm uma imagem correspondente carregada no Registro Docker, que você pode usar para fazer o deploy do software. Quando possível, é melhor pegar imagens “oficiais”, pois elas são garantidas pela equipe do Docker e seguem as práticas recomendadas do Docker.

      Comunicação Entre Imagens Docker

      Os containers Docker são isolados da máquina host, o que significa que, por padrão, a máquina host não tem acesso ao sistema de arquivos dentro do container, nem a qualquer meio de comunicação com ele por meio da rede. Isso pode dificultar a configuração e o trabalho com a imagem em execução em um container Docker.

      O Docker tem três maneiras principais de contornar isso. O primeiro e mais comum é fazer com que o Docker especifique variáveis de ambiente que serão definidas dentro do container. O código em execução no container Docker verificará os valores dessas variáveis de ambiente na inicialização e os utilizará para se configurar adequadamente.

      Outro método comumente usado é um Docker data volume. Os volumes Docker vêm em dois tipos – internos e compartilhados.

      Especificar um volume interno significa apenas que, para uma pasta que você especificar para um determinado container Docker, os dados persistirão quando o container for removido. Por exemplo, se você quisesse ter certeza de que seus arquivos de log persistam, você poderia especificar um volume /var/log interno.

      Um volume compartilhado mapeia uma pasta dentro de um container Docker para uma pasta na máquina host. Isso permite que você compartilhe arquivos facilmente entre o container Docker e a máquina host.

      A terceira maneira de se comunicar com um container Docker é pela rede. O Docker permite a comunicação entre diferentes containers por meio de links, bem como o port forwarding ou encaminhamento de portas, permitindo que você encaminhe portas de dentro do container Docker para portas no servidor host. Por exemplo, você pode criar um link para permitir que os containers do WordPress e do MariaDB se comuniquem entre si e usem o encaminhamento de porta para expor o WordPress ao mundo externo, para que os usuários possam se conectar a ele.

      Pré-requisitos

      Para seguir este artigo, você precisará do seguinte:

      Uma vez que estes requisitos estejam atentidos, você estará pronto para seguir adiante.

      Passo 1 — Instalando o Docker Compose

      Para obter a versão mais recente, tome conhecimento dos docs do Docker e instale o Docker Compose a partir do binário no repositório GitHub do Docker.

      Verifique a release atual e se necessário, atualize-a no comando abaixo:

      • sudo curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

      Em seguida, defina as permissões para tornar o binário executável:

      • sudo chmod +x /usr/local/bin/docker-compose

      Logo após, verifique se a instalação foi bem-sucedida, checando a versão

      Isso imprimirá a versão que você instalou:

      Output

      docker-compose version 1.23.2, build 1110ad01

      Agora que você tem o Docker Compose instalado, você está pronto para executar um exemplo de “Hello World”.

      O registro público do Docker, o Docker Hub, inclui uma imagem simples “Hello World” para demonstração e teste. Ela ilustra a configuração mínima necessária para executar um container usando o Docker Compose: um arquivo YAML que chama uma única imagem.

      Primeiro, crie um diretório para o nosso arquivo YAML:

      Em seguida, mude para o diretório:

      Agora crie o arquivo YAML usando seu editor de texto favorito. Este tutorial usará o vi:

      Entre no modo de inserção, pressionando i, depois coloque o seguinte conteúdo no arquivo:

      docker-compose.yml

      my-test:
        image: hello-world
      

      A primeira linha fará parte do nome do container. A segunda linha especifica qual imagem usar para criar o container. Quando você executar o comando docker-compose up, ele procurará uma imagem local com o nome especificado, hello-world.

      Com isso pronto, pressione ESC para sair do modo de inserção. Digite :x e depois ENTER para salvar e sair do arquivo.

      Para procurar manualmente as imagens no seu sistema, use o comando docker images:

      Quando não há imagens locais, apenas os cabeçalhos das colunas são exibidos:

      Output

      REPOSITORY TAG IMAGE ID CREATED SIZE

      Agora, ainda no diretório ~/hello-world, execute o seguinte comando para criar o container:

      Na primeira vez que executarmos o comando, se não houver uma imagem local chamada hello-world, o Docker Compose vai baixá-la do repositório público do Docker Hub:

      Output

      Pulling my-test (hello-world:)… latest: Pulling from library/hello-world 1b930d010525: Pull complete . . .

      Depois de baixar a imagem, o docker-compose cria um container, anexa e executa o programa hello, que por sua vez confirma que a instalação parece estar funcionando:

      Output

      . . . Creating helloworld_my-test_1… Attaching to helloworld_my-test_1 my-test_1 | my-test_1 | Hello from Docker. my-test_1 | This message shows that your installation appears to be working correctly. my-test_1 | . . .

      Em seguida, imprimirá uma explicação do que ele fez:

      Output

      . . . my-test_1 | To generate this message, Docker took the following steps: my-test_1 | 1. The Docker client contacted the Docker daemon. my-test_1 | 2. The Docker daemon pulled the "hello-world" image from the Docker Hub. my-test_1 | (amd64) my-test_1 | 3. The Docker daemon created a new container from that image which runs the my-test_1 | executable that produces the output you are currently reading. my-test_1 | 4. The Docker daemon streamed that output to the Docker client, which sent it my-test_1 | to your terminal. . . .

      Os containers Docker só são executados enquanto o comando estiver ativo, portanto, assim que o hello terminar a execução, o container finaliza. Conseqüentemente, quando você olha para os processos ativos, os cabeçalhos de coluna aparecerão, mas o container hello-world não será listado porque não está em execução:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

      Use a flag -a para mostrar todos os containers, não apenas os ativos:

      Output

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 50a99a0beebd hello-world "/hello" 3 minutes ago Exited (0) 3 minutes ago hello-world_my-test_1

      Agora que você testou a execução de um container, é possível explorar alguns dos comandos básicos do Docker Compose.

      Passo 3 — Aprendendo os Comandos do Docker Compose

      Para começar com o Docker Compose, esta seção irá examinar os comandos gerais que a ferramenta docker-compose suporta.

      O comando docker-compose funciona em uma base por diretório. Você pode ter vários grupos de containers do Docker em execução em uma máquina — basta criar um diretório para cada container e um arquivo docker-compose.yml para cada diretório.

      Até agora você tem executado o docker-compose up por conta própria, a partir do qual você pode usar o CTRL-C para fechar o container. Isso permite que as mensagens de debug sejam exibidas na janela do terminal. Isso não é o ideal; quando rodando em produção, é mais robusto ter o docker-compose agindo mais como um serviço. Uma maneira simples de fazer isso é adicionar a opção -d quando você fizer um up em sua sessão:

      O docker-compose agora será executado em segundo plano ou background.

      Para mostrar seu grupo de containers Docker (estejam interrompidos ou em execução no momento), use o seguinte comando:

      Se um container for interrompido, o State será listado como Exited, conforme mostrado no exemplo a seguir:

      Output

      Name Command State Ports ------------------------------------------------ hello-world_my-test_1 /hello Exit 0

      Um container em execução mostrará Up:

      Output

      Name Command State Ports --------------------------------------------------------------- nginx_nginx_1 nginx -g daemon off; Up 443/tcp, 80/tcp

      Para parar todos os containers Docker em execução para um grupo de aplicações, digite o seguinte comando no mesmo diretório que o arquivo docker-compose.yml que você usou para iniciar o grupo Docker:

      Nota: docker-compose kill também está disponível se você precisar fechar as coisas de maneira forçada.

      Em alguns casos, os containers Docker armazenarão suas informações antigas em um volume interno. Se você quiser começar do zero, você pode usar o comando rm para excluir totalmente todos os containers que compõem o seu grupo de containers:

      Se você tentar qualquer um desses comandos a partir de um diretório diferente do diretório que contém um container Docker e um arquivo .yml, ele retornará um erro:

      Output

      ERROR: Can't find a suitable configuration file in this directory or any parent. Are you in the right directory? Supported filenames: docker-compose.yml, docker-compose.yaml

      Esta seção abordou o básico sobre como manipular containers com o Docker Compose. Se você precisasse obter maior controle sobre seus containers, você poderia acessar o sistema de arquivos do container e trabalhar a partir de um prompt de comando dentro de seu container, um processo descrito na próxima seção.

      Passo 4 — Acessando o Sistema de Arquivos do Container Docker

      Para trabalhar no prompt de comando dentro de um container e acessar seu sistema de arquivos, você pode usar o comando docker exec.

      O exemplo “Hello World” sai depois de ser executado, portanto, para testar o docker exec, inicie um container que continuará em execução. Para os fins deste tutorial, use a imagem Nginx do Docker Hub.

      Crie um novo diretório chamado nginx e vá até ele:

      Em seguida, crie um arquivo docker-compose.yml em seu novo diretório e abra-o em um editor de texto:

      Em seguida, adicione as seguintes linhas ao arquivo:

      ~/nginx/docker-compose.yml

      nginx:
        image: nginx
      

      Salve o arquivo e saia. Inicie o container Nginx como um processo em background com o seguinte comando:

      O Docker Compose fará o download da imagem Nginx e o container será iniciado em background.

      Agora você precisará do CONTAINER ID para o container. Liste todos os containers que estão em execução com o seguinte comando:

      Você verá algo semelhante ao seguinte:

      Output of `docker ps`

      CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES b86b6699714c nginx "nginx -g 'daemon of…" 20 seconds ago Up 19 seconds 80/tcp nginx_nginx_1

      Se você quisesse fazer uma alteração no sistema de arquivos dentro deste container, você pegaria seu ID (neste exemplo b86b6699714c) e usaria docker exec para iniciar um shell dentro do container:

      • docker exec -it b86b6699714c /bin/bash

      A opção -t abre um terminal, e a opção -i o torna interativo. /bin/bash abre um shell bash para o container em execução.

      Você verá um prompt bash para o container semelhante a:

      root@b86b6699714c:/#
      

      A partir daqui, você pode trabalhar no prompt de comando dentro do seu container. No entanto, lembre-se de que, a menos que você esteja em um diretório salvo como parte de um volume de dados, suas alterações desaparecerão assim que o container for reiniciado. Além disso, lembre-se de que a maioria das imagens Docker é criada com instalações mínimas do Linux, portanto, alguns dos utilitários e ferramentas de linha de comando aos quais você está acostumado podem não estar presentes.

      Conclusão

      Agora você instalou o Docker Compose, testou sua instalação executando um exemplo “Hello World” e explorou alguns comandos básicos.

      Embora o exemplo “Hello World” tenha confirmado sua instalação, a configuração simples não mostra um dos principais benefícios do Docker Compose — a capacidade de ligar e desligar um grupo de containers Docker ao mesmo tempo. Para ver o poder do Docker Compose em ação, confira How To Secure a Containerized Node.js Application with Nginx, Let’s Encrypt, and Docker Compose e How To Configure a Continuous Integration Testing Environment with Docker and Docker Compose on Ubuntu 16.04. Embora estes tutoriais sejam voltados para o Ubuntu 16.04 e 18.04, os passos podem ser adaptados para o CentOS 7.



      Source link