Reconstruir un contenedor en un archivo Docker-Compose

1. Crear un nuevo proyecto
2. Crear un Dockerfile para la imagen
3. Crear un archivo de redacción para los contenedores
4. Ejecutar contenedores usando compose
5. Reconstruir un solo contenedor usando compose
6. Conclusión

Antes de implementar nuestra aplicación, debemos comprender la diferencia entre un archivo Dockerfile y un archivo compose.yaml.

Cuando creamos imágenes personalizadas para nuestras aplicaciones, generalmente usamos un archivo llamado Dockerfile y ejecutamos contenedores desde él en la línea de comando usando el comando docker run. Si queremos crear varias imágenes, este comando se vuelve demasiado tedioso y difícil de administrar los contenedores, por lo que aquí es donde entra el archivo compose.yaml.

El archivo compose.yaml crea las imágenes, ejecuta los contenedores, crea una red para estos contenedores y los agrega a la red. Entonces podemos acceder a las aplicaciones de red usando el nombre del servicio.

Estos dos comandos deben existir en la aplicación para que el comando docker compose up pueda crear y ejecutar las imágenes.

Si se realizaron cambios en la imagen, este comando obtiene los cambios, detiene los contenedores y vuelve a crear las imágenes. En este tutorial, veremos cómo reconstruir un solo contenedor docker a partir de varios contenedores definidos en un archivo Docker.

Crear un nuevo proyecto

Abra IntelliJ IDEA y seleccione Archivo > Nuevo > Proyecto. En la ventana abierta, seleccione Node.js y cambie el nombre del proyecto de “sin título” a docker-rebuild-container o use el nombre que prefiera.

Asegúrese de que el entorno de tiempo de ejecución de Node esté instalado para que las secciones del intérprete de Node y del administrador de paquetes se agreguen automáticamente desde la computadora. Por último, haga clic en el botón Crear para generar el proyecto.

Cree un archivo llamado index.js en la carpeta docker-rebuild-container y copie y pegue el siguiente código en el archivo.

const express = require('express')
const app = express()
const port = 3000

app.get('/', (req, res) => {
    res.json(
        [

            {
                name: "Java in action",
                author: "chad darby",
                price: 345
            },
            {
                name: 'React cookbook',
                author: "mary public",
                price: 600
            },
        ])
})

app.listen(port, () => {
    console.log(`Example app listening on port ${port}`)
})

En este archivo, hemos creado una aplicación Node.js de muestra para crear una imagen y ejecutar contenedores a partir de ella. Esta aplicación expone una API a la que se puede acceder emitiendo una solicitud de obtención a / en el navegador.

Crear un Dockerfile para la imagen

Cree un archivo llamado Dockerfile y copie y pegue las siguientes instrucciones en el archivo.

FROM node:16.17.0-alpine
WORKDIR /com/app
ADD package*.json ./
RUN npm install
ADD . .
CMD node index.js

Este archivo define las instrucciones para crear una imagen y ejecutar un contenedor a partir de ella. La documentación de la ventana acoplable proporciona una explicación detallada de cómo funcionan estas instrucciones.

Crear un archivo de redacción para los contenedores

Cree un archivo compose.yaml en la carpeta docker-rebuild-container y copie y pegue las siguientes instrucciones en el archivo.

services:
  service-one:
    restart: on-failure
    build: .
    hostname: service-one
    ports:
      - '3000:3000'
  service-two:
    restart: on-failure
    build: .
    hostname: service-two
    ports:
      - '5000:3000'

Este archivo define dos servicios llamados servicio-uno y servicio-dos con los servicios escuchando el puerto 3000 en el contenedor desde el puerto 3000 y 5000 en el host, respectivamente.

1. servicios: define los componentes informáticos de una aplicación.
2. reiniciar: define la acción a realizar cuando se termina un contenedor.
3. construir: esto define la fuente del Dockerfile que contiene la configuración para construir una imagen.
4. hostname: establece un nombre personalizado que utilizará el servicio.
5. puertos: esto expone los puertos en la máquina host para servir la aplicación.

La documentación de Docker proporciona una referencia de archivo de composición de docker que explica estas instrucciones en detalle.

Ejecutar contenedores usando compose

En este ejemplo, veremos cómo compilar y ejecutar todos los contenedores definidos a la vez. Para ejecutar nuestro archivo docker compose.yaml, abra una nueva ventana de terminal en su entorno de desarrollo usando el atajo de teclado ALT + F12 y el siguiente comando para compilar y ejecutar el contenedores

~/WebstormProjects/docker-rebuild-container$ docker compose up --build --force-recreate --no-deps -d

Con este comando, se vuelve muy fácil ejecutar y administrar contenedores. Antes de usar este comando, ejecutamos docker compose up -d para asegurarnos de que estamos reconstruyendo la imagen y recreando los contenedores con este comando.

 => CACHED [docker-rebuild-container_service-two 2/5] WORKDIR /com/app                                                          0.0s
 => CACHED [docker-rebuild-container_service-two 3/5] ADD package*.json ./                                                      0.0s
 => CACHED [docker-rebuild-container_service-two 4/5] RUN npm install                                                           0.0s
 => [docker-rebuild-container_service-two 5/5] ADD . .                                                                          1.2s
 => [docker-rebuild-container_service-one] exporting to image

1. --build: esto garantiza que las imágenes se construyan antes de ejecutar los contenedores.
2. --force-recreate: recrea los contenedores sin tener en cuenta el estado de sus configuraciones e imágenes.
3. --no-deps: esto garantiza que los servicios vinculados no se inicien.

Reconstruir un solo contenedor usando compose

Para reconstruir un solo contenedor a partir de múltiples contenedores definidos en el archivo compose.yaml, use el comando usado en el ejemplo anterior y agregue el nombre del servicio que se va a reconstruir, como se muestra a continuación.

~/WebstormProjects/docker-rebuild-container$ docker compose up --build --force-recreate --no-deps -d service-one

Este comando reconstruye la imagen y recrea el contenedor llamado service-one ya que solo queremos recrear un solo contenedor. Podemos verificar a partir de la salida de este comando que solo se recrea un contenedor, como se muestra a continuación.

[+] Running 1/1
 ⠿ Container docker-rebuild-container-service-one-1  Started

Para verificar si los contenedores funcionan como se espera, emita dos solicitudes en el navegador, una en localhost:3000 (http://localhost:3000/) y otra en localhost:5000 (http://localhost:5000 /), y tenga en cuenta que podemos acceder a la misma aplicación desde los dos contenedores. La siguiente es la respuesta JSON devuelta por los contenedores.

[
    {
    "name": "Java in action",
    "author": "chad darby",
    "price": 345
    },
    {
    "name": "React cookbook",
    "author": "mary public",
    "price": 600
    }
]

Conclusión

En este tutorial, aprendimos a definir una imagen usando un Dockerfile, definir contenedores usando el archivo compose.yaml, ejecutar contenedores en un archivo de composición y recrear un solo contenedor en un archivo de composición.

Tenga en cuenta que la sintaxis para ejecutar contenedores desde un archivo de composición es docker compose up [OPCIONES] [SERVICIO...], y el parámetro opcional SERVICIO nos permite especificar uno o más servicios que queremos reconstruir sus imágenes o recrear sus contenedores.