Cómo reducir el tamaño de la imagen de Docker en los contenedores de Docker

¿Tu imagen de Docker está tardando demasiado en construirse e implementarse? ¿Toma horas exportar? Deje de perder tiempo y acelere estos procesos desarrollando una imagen más pequeña. En este tutorial, aprenderá tres trucos para reducir el tamaño de su imagen de Docker.

¡Empecemos!

Requisitos

Este tutorial será una demostración práctica. Si desea seguirnos, asegúrese de tener lo siguiente:

• Docker Desktop o Engine. Hay versiones de Docker disponibles para Linux, Windows y macOS. Este tutorial utiliza Docker versión 20.10.8 compilación 3967b7d en una computadora con Ubuntu 18.04 LTS.

• Node.js. Este tutorial usa la versión 10.10.0 de Node.js, pero también debería funcionar con versiones más nuevas.

• Necesitará un editor de código como Visual Studio Code, vim y nano . Este tutorial utiliza nano.

Crear una imagen acoplable

Probablemente ya tenga una imagen de Docker por ahí que quiera reducir. No. En este tutorial, comenzará de nuevo creando una imagen de Docker para su prueba.

Comenzará creando un contenedor para una aplicación Node.js. La aplicación Node.js que usará es el ejemplo Hello World Express.js que muestra el texto “¡Hola mundo!” en su navegador.

1. Primero, abra una sesión de terminal y cree un directorio donde creará su imagen de Docker y los archivos asociados. Para este ejemplo, el directorio de trabajo será ~/docker_demo .

# Create the project directory
mdkir ~/docker_demo
# Change the current directory to your working directory
cd ~/docker_demo

A continuación, cree tres archivos en su directorio de trabajo. Estos archivos son:

• index.js:el punto de partida para su aplicación de muestra.
• paquete.json – contiene los metadatos de su aplicación.
• Dockerfile – contiene las instrucciones para construir su imagen Docker. Ejecute el siguiente comando en la terminal para crear todos estos archivos a la vez.

touch index.js package.json Dockerfile

3. Abra index.js en su editor de código, complételo con el siguiente código y guárdelo.

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

app.get('/', (req, res) => res.send('Hello World!'))

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

4. A continuación, abra el package.json archivo para editarlo, copie y pegue el código a continuación y guárdelo.

{
  "name": "hello-world",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "express": "^4.16.2"
  },
  "scripts": {
    "start": "node index.js"
  }
}

5. De la misma manera, edite el Dockerfile para completar el código a continuación y guardar el archivo.

# use the Node.js parent image 
FROM node:8 

# set a directory for the app
WORKDIR /app
# copy all the files to the container
COPY . .
# install dependencies
RUN npm install
# define the port number the container should expose
EXPOSE 3000

# run the application
CMD ["npm", "start"]

6. Ejecute el siguiente docker build Comando para construir su imagen de Docker. El -t opcional flag etiqueta su imagen con un nombre para que sea identificable. Este ejemplo usa el nombre ‘my_app.’

docker build -t my_app .

7. Cuando Docker completó la creación de la imagen, ejecute el siguiente comando para ver su imagen etiquetada con ‘my_app.’

El grep El comando solo está disponible en Linux, pero para ver su imagen en otros sistemas operativos, ejecute el comando docker images y busca la imagen con la etiqueta 'mi_aplicación'.

docker images | grep my_app

Como se muestra en la siguiente imagen, el tamaño de la imagen de Docker es de 904 MB.

8. Ahora verifique que su imagen funcione correctamente. Ejecute el siguiente comando de ejecución de la ventana acoplable. Este comando usará su imagen de Docker para crear un contenedor donde se ejecutará su aplicación.

docker run -p 3000:3000 -ti --rm --init my_app

Si la aplicación se inicia correctamente, aparecerá el mensaje ‘¡Aplicación de ejemplo escuchando en el puerto 3000!’ se imprimirá en su terminal.

9. Para verificar que su aplicación funcione, abra su navegador y vaya a http://localhost:3000/. El texto ‘¡Hola mundo!’ debe mostrarse como se muestra en la siguiente imagen.

10. Para finalizar la aplicación y volver al indicador del terminal, presione CTRL+C .

Reducir el tamaño de una imagen de Docker

Ahora que tiene una imagen de Docker, ¡es hora de aprender a reducir el tamaño de su imagen! Las siguientes secciones cubren tres métodos para reducir el tamaño de la imagen de Docker.

Método 1:aplicar compilaciones de varias etapas

Tener archivos Dockerfile separados para desarrollo y producción era una práctica común.

El Dockerfile de desarrollo contenía todo lo necesario para construir la aplicación, mientras que el de producción incluía lo que la aplicación necesitaba para ejecutarse. Este método produce la imagen de producción final con el tamaño óptimo. Pero administrar dos Dockerfiles es innecesariamente complicado.

Desde la introducción de compilaciones de varias etapas en la versión 17.05, los desarrolladores ahora solo necesitan un Dockerfile que contiene múltiples FROM instrucciones para separar las etapas de construcción de desarrollo y producción. Por lo tanto, copiando selectivamente artefactos de una etapa de construcción a otra.

¡Ahora es el momento de usar compilaciones de varias etapas en su imagen!

1. Abra su Dockerfile en el editor de código y reemplace su contenido con el siguiente código. Este nuevo código de Dockerfile tiene dos etapas de compilación como lo indican los dos FROM líneas.

De forma predeterminada, las etapas de compilación no tienen nombres y su código solo puede hacer referencia a ellas como el número entero en el orden en que aparecen (comenzando en cero) en el Dockerfile. Puede agregar el as <name> al FROM línea para asignar un nombre a la etapa de construcción para una mejor identificación .

# the develop build stage using the node parent image
FROM node:8 as develop

# set a directory for the app
WORKDIR /app
# copy all the files to the container
COPY . .
# install dependencies
RUN npm install

# the production build stage using the node parent image
FROM node:8

# Copy only the build artifact from the first (develop) build stage
# Any intermediate artifacts used to build your application are not included in the final image.
COPY --from=develop /app /

# define the port number the container should expose
EXPOSE 3000

# run the application
CMD ["npm", "start"]

2. Cree su nueva imagen con el nombre my_app_multi_stage_builds ejecutando el siguiente comando.

docker build -t my_app_multi_stage_builds .

3. Después de la compilación, vea el tamaño de imagen actualizado ejecutando el siguiente comando.

docker images | grep my_app_multi_stage_builds

La aplicación de muestra es pequeña y solo tiene algunos artefactos intermedios. Pero todavía hay una reducción de 1 MB en comparación con la compilación anterior de imágenes de Docker.

Método 2:uso de una imagen principal ligera

A menos que construya una imagen de Docker desde cero (usando el FROM scratch directiva), cada imagen de Docker tiene una imagen principal. El Dockerfile los archivos de las secciones anteriores usan node:8 como imagen principal durante la compilación.

Si su aplicación no requiere una versión específica del sistema operativo para ejecutarse, considere cambiar su imagen principal por una más liviana. Si usa Linux, la imagen más liviana en Docker Hub es Alpine.

¡Ahora es el momento de aprender a reemplazar la imagen principal con Alpine!

1. Edite su Dockerfile y reemplace el segundo FROM node:8 línea con FROM node:8-alpine . Este nuevo FROM instrucción, Docker, utilizará node-8-alpine como imagen principal. Ahora su imagen final se ejecutará en Alpine en lugar de Node.

# the first build stage using the node parent image
FROM node:8 as build

# set a directory for the app
WORKDIR /app
# copy all the files to the container
COPY . .
# install dependencies
RUN npm install

# the second build stage using the node-8-alpine parent image
FROM node:8-alpine

# copy the required artifacts to from the first build stage
COPY --from=build /app /
# define the port number the container should expose
EXPOSE 3000

# run the application
CMD ["npm", "start"]

2. Ejecute el siguiente comando para crear la imagen de Docker con el nombre my_app_alpine.

docker build -t my_app_alpine .

3. Finalmente, vea el tamaño de imagen actualizado ejecutando el siguiente comando.

docker images | grep my_app_alpine

El tamaño final de la imagen de Docker ahora es de solo 75,2 MB. ¡Una reducción significativa de 827.8 MB!

Método 3:crear un archivo .dockerignore

Docker es una aplicación cliente-servidor que consiste en el cliente Docker o CLI y el demonio Docker, que administra imágenes Docker (y contenedores, redes y volúmenes).

La CLI compila un construir contexto que consta de los archivos a incluir en la imagen a construir. La CLI también busca un archivo .dockerignore que enumera los archivos que se deben ignorar antes de enviar el contexto de compilación al demonio Docker. Como resultado, copiar menos archivos reduce el tamaño de la imagen de Docker.

¡Ahora es el momento de aplicar un archivo .dockerignore en su compilación!

1. Primero, cree un nuevo archivo vacío llamado .dockerignore .

touch .dockerignore

2. A continuación, cree un archivo ficticio que hará que Docker ignore durante las compilaciones. En este ejemplo, cree un archivo ficticio README.md de 2 MB de tamaño.

Si está en una computadora con Linux, ejecute el siguiente comando fallacate para crear el archivo.

fallocate -l 2MB README.md

Si está en una computadora con Windows, ejecute el comando fsutil en su lugar.

fsutil file createnew README.md 2000000

3. A continuación, cree su nueva imagen de Docker ejecutando el siguiente comando. Dado que el archivo README.md está en el mismo directorio, espere que este archivo ficticio sea parte de la imagen de Docker resultante.

docker build -t my_app_readme .

4. Vea el tamaño de imagen actualizado ejecutando el siguiente comando.

docker images | grep my_app_readme

Como era de esperar, con la inclusión del archivo README.md, el tamaño final de la imagen de Docker aumentó en 2 MB.

5. Ahora, excluya todos los archivos con .md extensión de la construcción de la imagen. Para hacerlo, edite .dockerignore archivo y rellénelo con el siguiente código.

# ignore markdown files
.md

Los archivos Markdown (.md) normalmente no afectan la funcionalidad de una aplicación y, por lo general, es seguro excluirlos de las compilaciones. Otros archivos que puede excluir son los registros de compilación, los scripts de prueba, la carpeta .git de su repositorio y cualquier archivo que incluya información confidencial (como contraseñas).

6. Ahora que ha actualizado el archivo de ignorar, vuelva a ejecutar el comando de creación de imágenes de Docker como se muestra a continuación.

docker build -t my_app_dockerignore .

7. Por último, ejecute el siguiente comando para ver el nuevo tamaño de imagen de Docker, incluido el archivo README.md.

docker images | grep my_app_dockerignore

Ahora que el archivo README.md está fuera de la nueva compilación, ¡el tamaño de la imagen de Docker se ha reducido a 75,2 MB!

Conclusión

En este tutorial, aprendió los diferentes métodos para reducir el tamaño de su imagen de Docker. Aprendió a usar compilaciones de varias etapas, compilar a partir de una imagen principal más pequeña y excluir archivos no esenciales.

La próxima vez que Docker tarde demasiado en construirse e implementarse, no se detenga y aplique sus conocimientos para optimizar el tamaño de la imagen de Docker. ¿Qué método crees que usarás más?