Recrear contenedores a partir de nuevas imágenes mediante Docker-Compose

David Mbochi Njonge 20 junio 2023

Docker Docker Compose

Crear un nuevo proyecto
Reconstruir una imagen con caché
Reconstruir una imagen sin caché
Conclusión

Recrear contenedores a partir de nuevas imágenes mediante Docker-Compose

Cuando desarrollamos aplicaciones, generalmente hacemos cambios o agregamos más funciones para que la aplicación sea más efectiva para los diferentes usuarios que interactúan con las aplicaciones.

Al trabajar con Docker, debemos asegurarnos de que los cambios o funciones realizados se actualicen en la aplicación principal mediante la reconstrucción de la imagen y la ejecución de un nuevo contenedor a partir de esta imagen. Este tutorial nos enseñará cómo recrear contenedores a partir de nuevas imágenes usando Docker Compose.

Crear un nuevo proyecto

En WebStorm IDEA, seleccione Archivo > Nuevo > Proyecto para crear un nuevo proyecto. A continuación, seleccione Proyecto vacío y cambie el nombre del proyecto de sin título a docker-compose-no-cache o utilice el nombre que prefiera.

Presione el botón etiquetado como Crear para generar el proyecto. Cree un archivo llamado index.html en la carpeta actual y copie y pegue el siguiente código.

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Bootstrap demo</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/css/bootstrap.min.css"
          rel="stylesheet"
          integrity="sha384-Zenh87qX5JnK2Jl0vWa8Ck2rdkQ2Bzep5IDxbcnCeuOxjzrPF/et3URy9Bv1WTRi"
          crossorigin="anonymous">
</head>
<body>
<div class="card">
    <div class="card-header">
        Featured
    </div>
    <div class="card-body">
        <h5 class="card-title">Special title treatment</h5>
        <p class="card-text">With supporting text below as a natural lead-in to additional content.</p>
        <a href="#" class="btn btn-primary">Go somewhere</a>
    </div>
</div>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.2.2/dist/js/bootstrap.bundle.min.js"
        integrity="sha384-OERcA2EqjJCMA+/3y+gxIOqMEjwtxJY7qPCqsdltbNJuaOe923+mo//f6V8Qbsw3"
        crossorigin="anonymous"></script>
</body>
</html>

Este archivo usa Bootstrap para crear una página web que muestra una tarjeta cuando ejecutamos un contenedor desde la imagen de la aplicación. Usaremos esta página para verificar si nuestro contenedor se está ejecutando.

Definir una imagen

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

FROM nginx:1.22.0-alpine
COPY . /usr/share/nginx/html

FROM - Establece la imagen base sobre la cual crear nuestra imagen personalizada usando las instrucciones subsiguientes. En este caso, establecimos nuestra imagen base como Nginx y usamos alpine para extraer una versión ligera de Nginx.
COPY - Copia los archivos y carpetas en el directorio actual a una ubicación del sistema de archivos en nuestra imagen. En este caso, hemos copiado todos los archivos del directorio actual en /src/share/nginx/html.

Definir un contenedor usando Componer archivo

Cree un archivo llamado compose.yaml en la carpeta actual y copie y pegue las siguientes instrucciones en el archivo.

services:
  web-app:
    restart: on-failure
    build: ./
    hostname: web-app-service
    ports:
      - '80:80'

Este archivo define un servicio llamado aplicación web que expone el puerto 80 en el host para escuchar en el puerto 80 en el contenedor. Este archivo proporciona una forma más fácil de administrar contenedores que los contenedores en la terminal.

Cree una imagen y ejecute un contenedor

Dado que esta es la primera vez que creamos una imagen, nuestra imagen base se extraerá y usará para crear nuestra imagen personalizada utilizando las instrucciones definidas en el Dockerfile. El contenedor definido en el archivo compose.yaml también se creará y agregará a una red.

Abra una nueva ventana de terminal usando el método abreviado de teclado ALT+F12 en su computadora y ejecute el siguiente comando para crear una imagen y ejecutar un contenedor desde ella.

~/WebstormProjects/docker-compose-no-cache$ docker compose up -d

Este comando ejecuta el archivo compose.yaml para crear una imagen llamada docker-compose-no-cache_web-app y también ejecuta un contenedor con el nombre docker-compose-no-cache-web-app-1. Como se muestra abajo.

 => CACHED [1/2] FROM docker.io/library/nginx:1.22.0-alpine@sha256:addd3bf05ec3c69ef3e8f0021ce1ca98e0eb21117b97ab8b64127e  0.0s
 => [2/2] COPY . /usr/share/nginx/html                                                                                     0.6s
 => exporting to image                                                                                                     0.8s
 => => exporting layers                                                                                                    0.6s
 => => writing image sha256:d72675b7a3e3a52dd27fe46f298dc30757382d837a5fbf36d8e36d646b5902d6                               0.1s
 => => naming to docker.io/library/docker-compose-no-cache_web-app                                                         0.1s

Use 'docker scan' to run Snyk tests against images to find vulnerabilities and learn how to fix them
[+] Running 2/2
 ⠿ Network docker-compose-no-cache_default      Created                                                                    0.3s
 ⠿ Container docker-compose-no-cache-web-app-1  Started

Para verificar si nuestro contenedor se está ejecutando, abra el navegador y envíe una solicitud a localhost:80 (http://localhost/#). La tarjeta que definimos en la página index.html se mostrará en el navegador.

Usando la misma ventana de terminal, ejecute el siguiente comando para verificar que se creó nuestra imagen personalizada.

~/WebstormProjects/docker-compose-no-cache$ docker image ls

Producción :

REPOSITORY                        TAG       IMAGE ID       CREATED         SIZE
docker-compose-no-cache_web-app   latest    d72675b7a3e3   8 minutes ago   23.5MB

Reconstruir una imagen con caché

Para reconstruir la imagen existente con caché y ejecutar contenedores, primero debemos detener y eliminar los contenedores existentes usando el comando docker compose down.

La reconstrucción de una imagen acoplable con la memoria caché significa que el contenedor actual se reutilizará para crear un nuevo contenedor. Usando la misma ventana de terminal, ejecute el siguiente comando para reconstruir la imagen existente con el caché.

~/WebstormProjects/docker-compose-no-cache$ docker compose build

Este comando reconstruye una nueva imagen usando la imagen existente, y podemos usar el docker compose up -d para ejecutar un contenedor desde allí.

Para verificar que la imagen existente se reutilice para crear un nuevo contenedor, ejecute el siguiente comando y observe que no hay ninguna imagen aparte de la imagen creada en la sección anterior.

~/WebstormProjects/docker-compose-no-cache$ docker image ls

Producción :

REPOSITORY                        TAG       IMAGE ID       CREATED         SIZE
docker-compose-no-cache_web-app   latest    d72675b7a3e3   8 minutes ago   23.5MB

Reconstruir una imagen sin caché

Reconstruir una imagen sin caché significa crear una nueva imagen sin reutilizar la imagen anterior. Podemos lograr esto agregando el comando --no-cache al construir una imagen usando el comando docker build.

Usando la misma ventana de terminal, ejecute el siguiente comando para reconstruir una imagen sin caché. Asegúrese de que los contenedores en ejecución se eliminen con el comando docker compose down.

~/WebstormProjects/docker-compose-no-cache$ docker compose build --no-cache

Este comando reconstruye una nueva imagen sin caché, lo que significa que la imagen anterior no se reutiliza. Para verificar que la imagen anterior no se reutilizó para crear la imagen actual, ejecute el siguiente comando y observe que la imagen anterior no tiene nombre como lo indica <ninguno>.

La nueva imagen utiliza el nombre de la imagen anterior.

~/WebstormProjects/docker-compose-no-cache$ docker image ls

Producción :

docker-compose-no-cache_web-app   latest    f111dde0e704   3 seconds ago    23.5MB
<none>                            <none>    1c05a46fe049   13 minutes ago   23.5MB

Dado que la imagen anterior y la imagen nueva no pueden tener los mismos nombres, la imagen actual usa el nombre de la imagen anterior, y la imagen anterior obtiene ninguno para mostrar que no tiene nombre.

Conclusión

Hemos aprendido a recrear contenedores a partir de nuevas imágenes usando Docker Compose. Para implementar esto, hemos aprendido cómo reconstruir una imagen con el caché y cómo reconstruir una imagen sin caché.

Autor: David Mbochi Njonge

David is a back end developer with a major in computer science. He loves to solve problems using technology, learning new things, and making new friends. David is currently a technical writer who enjoys making hard concepts easier for other developers to understand and his work has been published on multiple sites.

LinkedIn GitHub

Crear un nuevo proyecto

Definir una imagen

Definir un contenedor usando Componer archivo

Cree una imagen y ejecute un contenedor

Reconstruir una imagen con caché

Reconstruir una imagen sin caché

Conclusión

Artículo relacionado - Docker Compose