getting-started/index.es.md at 2fd5b07926cbbdd1b7ed79c68e41c0867222181b

Publio Estupiñán 2fd5b07926 Multi language support (Spanish)

mkdocs-i18n implemented for new languages
Spanish translation

2021-05-30 21:38:41 -05:00

13 KiB

Raw Blame History

Docker Compose es una herramienta que se desarrolló para ayudar a definir y compartir aplicaciones de varios contenedores. Con Compose, podemos crear un archivo YAML para definir los servicios y con un solo comando, podemos hacer girar todo o destruirlo todo.

La gran ventaja de usar Compose es que puede definir su pila de aplicaciones en un archivo, mantenerlo en la raíz del repositorio de su proyecto (ahora está controlado por la versión) y permitir fácilmente que otra persona contribuya a su proyecto. Alguien solo necesitaría clonar su repositorio e iniciar la aplicación de redacción. De hecho, es posible que veas bastantes proyectos en GitHubGitLab haciendo exactamente esto ahora.

Entonces, ¿cómo empezamos?

Instalación de Docker Compose

Si instaló Docker DesktopToolbox para Windows o Mac, ¡ya tiene Docker Compose! Las instancias de Play-with-Docker también tienen Docker Compose instalado. Si está en una máquina Linux, deberá instalar Docker Compose usando las instrucciones aquí.

Después de la instalación, debería poder ejecutar lo siguiente y ver la información de la versión.

docker-compose version

Creando nuestro Compose File

En la raíz del proyecto de la aplicación, cree un archivo llamado docker-compose.yml.
En el archivo de redacción, comenzaremos definiendo la versión del esquema. En la mayoría de los casos, es mejor utilizar la última versión compatible. Puede consultar la Referencia a Compose file para ver las versiones actuales del esquema y la matriz de compatibilidad.
```
version: "3.7"
```
A continuación, definiremos la lista de servicios (o contenedores) que queremos ejecutar como parte de nuestra aplicación.
```
version: "3.7"

services:
```

Y ahora, comenzaremos a migrar un servicio a la vez en el compose file.

Definición de la App Service

Para recordar, este era el comando que estábamos usando para definir nuestro contenedor de aplicaciones.

docker run -dp 3000:3000 \
  -w /app -v "$(pwd):/app" \
  --network todo-app \
  -e MYSQL_HOST=mysql \
  -e MYSQL_USER=root \
  -e MYSQL_PASSWORD=secret \
  -e MYSQL_DB=todos \
  node:12-alpine \
  sh -c "yarn install && yarn run dev"

Si está utilizando PowerShell, utilice este comando.

docker run -dp 3000:3000 `
  -w /app -v "$(pwd):/app" `
  --network todo-app `
  -e MYSQL_HOST=mysql `
  -e MYSQL_USER=root `
  -e MYSQL_PASSWORD=secret `
  -e MYSQL_DB=todos `
  node:12-alpine `
  sh -c "yarn install && yarn run dev"

Primero, definamos la entrada de servicio y la imagen del contenedor. Podemos elegir cualquier nombre para el servicio. El nombre se convertirá automáticamente en un alias de red, que será útil a la hora de definir nuestro servicio MySQL.
```
version: "3.7"

services:
  app:
    image: node:12-alpine
```
Normalmente, verá el comando cerca de la definición de la image, aunque no hay ningún requisito para realizar el pedido. Entonces, sigamos adelante y traslademos eso a nuestro archivo.
```
version: "3.7"

services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
```
Migremos la parte -p 3000: 3000 del comando definiendo los ports para el servicio. Usaremos la sintaxis corta aquí, pero también hay una sintaxis larga más detallada disponible también.
```
version: "3.7"

services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
```
A continuación, migraremos tanto el directorio de trabajo (-w app) como el mapeo de volumen (-v "$(pwd):/app") usando las definiciones working_dir y volumes. Los volúmenes también tienen una sintaxis corta y larga.

Una ventaja de las definiciones de volumen de Docker Compose es que podemos usar rutas relativas del directorio actual.
```
version: "3.7"

services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
```

Finalmente, necesitamos migrar las definiciones de variables de entorno usando la clave environment.

version: "3.7"

services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

Definición del servicio MySQL

Ahora es el momento de definir el servicio MySQL. El comando que usamos para ese contenedor fue el siguiente:

docker run -d \
  --network todo-app --network-alias mysql \
  -v todo-mysql-data:/var/lib/mysql \
  -e MYSQL_ROOT_PASSWORD=secret \
  -e MYSQL_DATABASE=todos \
  mysql:5.7

Si está utilizando PowerShell, utilice este comando.

docker run -d `
  --network todo-app --network-alias mysql `
  -v todo-mysql-data:/var/lib/mysql `
  -e MYSQL_ROOT_PASSWORD=secret `
  -e MYSQL_DATABASE=todos `
  mysql:5.7

Primero definiremos el nuevo servicio y lo llamaremos mysql para que automáticamente obtenga el alias de la red. Continuaremos y especificaremos la imagen a usar también.
```
version: "3.7"

services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
```
A continuación, definiremos el mapeo de volumen. Cuando ejecutamos el contenedor con docker run, el named volume se creó automáticamente. Sin embargo, eso no sucede cuando se ejecuta con Compose. Necesitamos definir el volumen en la sección volúmenes: de nivel superior y luego especificar el punto de montaje en la configuración del servicio. Simplemente proporcionando solo el nombre del volumen, se utilizan las opciones predeterminadas. Sin embargo, hay muchas más opciones disponibles.
```
version: "3.7"

services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql

volumes:
  todo-mysql-data:
```

Finalmente, solo necesitamos especificar las variables de entorno.

version: "3.7"

services:
  app:
    # The app service definition
  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

En este punto, nuestro docker-compose.yml completo debería verse así:

version: "3.7"

services:
  app:
    image: node:12-alpine
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

  mysql:
    image: mysql:5.7
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment: 
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

Ejecutando nuestra pila de aplicaciones

Ahora que tenemos nuestro archivo docker-compose.yml, ¡podemos iniciarlo!

Asegúrese de que no se estén ejecutando primero otras copias de la appdb (docker ps y docker rm -f <ids>).
Inicie la pila de aplicaciones usando el comando docker-compose up. Agregaremos la bandera -d para ejecutar todo en segundo plano.
```
docker-compose up -d
```
Cuando ejecutamos esto, deberíamos ver un resultado como este:
```
Creating network "app_default" with the default driver
Creating volume "app_todo-mysql-data" with default driver
Creating app_app_1   ... done
Creating app_mysql_1 ... done
```
¡Notará que el volumen fue creado además de una red! De forma predeterminada, Docker Compose crea automáticamente una red específicamente para el stack de aplicaciones (razón por la cual no definimos una en el archivo de composición).
Veamos los logs usando el comando docker-compose logs -f. Verá los logs de cada uno de los servicios intercalados en un solo flujo. Esto es increíblemente útil cuando desea estar atento a problemas relacionados con el tiempo. La bandera -f "sigue" el log, por lo que le dará una salida en vivo a medida que se genere.

Si aún no lo ha hecho, verá un resultado que se ve así ...
```
mysql_1  | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections.
mysql_1  | Version: '5.7.27'  socket: '/var/run/mysqld/mysqld.sock'  port: 3306  MySQL Community Server (GPL)
app_1    | Connected to mysql db at host mysql
app_1    | Listening on port 3000
```
El nombre del servicio se muestra al principio de la línea (a menudo de color) para ayudar a distinguir los mensajes. Si desea ver los registros de un servicio específico, puede agregar el nombre del servicio al final del comando de logs (por ejemplo, docker-compose logs -f app).

!!! info "Consejo profesional: esperar la base de datos antes de iniciar la aplicación" Cuando la aplicación se inicia, en realidad se sienta y espera a que MySQL esté listo y listo antes de intentar conectarse. Docker no tiene ningún soporte integrado para esperar a que otro contenedor esté completamente en funcionamiento, en ejecución y listo antes de iniciar otro contenedor. Para proyectos Node-based, puede usar la dependencia wait-port. Existen proyectos similares para marcos de otros lenguajes.
En este punto, debería poder abrir su aplicación y verla en ejecución. ¡Y oye! ¡Estamos en un solo comando!

Ver nuestro stack de aplicaciones en el Dashboard Docker

Si miramos el panel de Docker, veremos que hay un grupo llamado app. Este es el "nombre del proyecto" de Docker Compose y se utiliza para agrupar los contenedores. Por defecto, el nombre del proyecto es simplemente el nombre del directorio en el que se encontraba el docker-compose.yml.

Si gira la aplicación, verá los dos contenedores que definimos en el compose file. Los nombres también son un poco más descriptivos., ya que siguen el patrón de <project-name>_<service-name>_<replica-number>. Por lo tanto, es muy fácil ver rápidamente qué contenedor es nuestra aplicación y qué contenedor es la base de datos mysql.

Derribarlo todo

Cuando esté listo para derribarlo todo, simplemente ejecute docker-compose down o presione la papelera en el Docker Dashboard para toda la aplicación. Los contenedores se detendrán y la red se eliminará.

!!! warning "Removing Volumes" De forma predeterminada, los named volumes en su compose file NO se eliminan cuando se ejecuta docker-compose down. Si desea eliminar los volúmenes, deberá agregar la marca --volumes.

El panel de Docker _no_ elimina volúmenes cuando elimina el stack de aplicaciones.

Una vez derribado, puede cambiar a otro proyecto, ejecutar docker-compose up y estar listo para contribuir a ese proyecto. ¡Realmente no hay nada más simple que eso!

Resumen

En esta sección, aprendimos sobre Docker Compose y cómo nos ayuda a simplificar drásticamente la definición y el uso compartido de aplicaciones multiservicio. Creamos un archivo de redacción traduciendo los comandos que estábamos usando al formato de redacción apropiado.

En este punto, comenzamos a concluir el tutorial. Sin embargo, existen algunas mejores prácticas sobre la creación de imágenes que queremos cubrir, ya que hay un gran problema con el Dockerfile que hemos estado usando. Entonces, ¡echemos un vistazo!

13 KiB Raw Blame History