Aprendizaje Docker, Parte 3: Archivos Dockerfile

En la traducción de la tercera parte de la serie Docker, seguiremos inspirándonos en pasteles, a saber, bagels. Nuestro tema principal hoy será trabajar con Dockerfiles. Analizaremos las instrucciones que se utilizan en estos archivos.

→ Parte 1: lo básico
→ Parte 2: términos y conceptos
→ Parte 3: archivos Dockerfile
→ Parte 4: reducir el tamaño de las imágenes y acelerar su ensamblaje
→ Parte 5: equipos
→ Parte 6: trabajar con datos


Bagels son instrucciones en un Dockerfile.

Imágenes de Docker


Recuerde que un contenedor Docker es una imagen Docker que cobra vida. Este es un sistema operativo autónomo en el que solo hay el código de aplicación y el más necesario.

Las imágenes de Docker son el resultado del proceso de compilación, y los contenedores de Docker están ejecutando imágenes. En el corazón de Docker están los Dockerfiles. Archivos como este le dicen a Docker cómo ensamblar las imágenes a partir de las cuales se crean los contenedores.

Cada imagen de Docker tiene un archivo llamado Dockerfile. Su nombre está escrito de esa manera, sin extensión. Cuando ejecuta el docker build para crear una nueva imagen, se supone que el Dockerfile está en el directorio de trabajo actual. Si este archivo se encuentra en otro lugar, su ubicación se puede especificar utilizando el indicador -f .

Los contenedores, como descubrimos en el primer material de esta serie, consisten en capas. Cada capa, excepto la última, ubicada encima de todas las demás, es de solo lectura. Dockerfile le dice al sistema Docker qué capas y en qué orden agregar a la imagen.

Cada capa, de hecho, es solo un archivo que describe el cambio en el estado de la imagen en comparación con el estado en el que estaba después de agregar la capa anterior. En Unix, por cierto, casi cualquier cosa es un archivo .

Una imagen básica es cuál es la capa (o capas) de origen de la imagen que se está creando. La imagen base también se llama imagen principal.


La imagen básica es donde comienza la imagen de Docker.

Cuando una imagen se descarga desde un repositorio remoto a una computadora local, solo las capas que no están disponibles en esta computadora se descargan físicamente. Docker tiene como objetivo ahorrar espacio y tiempo reutilizando las capas existentes.

Archivos Dockerfile


Los archivos Docker contienen instrucciones para crear una imagen. En mayúsculas, comienzan las líneas de este archivo. Siguiendo las instrucciones están sus argumentos. Las instrucciones, al construir la imagen, se procesan de arriba a abajo. Así es como se ve:

 FROM ubuntu:18.04 COPY . /app 

Las capas de la imagen final se crean solo mediante las instrucciones FROM , RUN , COPY y ADD . Otras instrucciones configuran algo, describen metadatos o le dicen a Docker que necesita hacer algo durante la ejecución del contenedor, por ejemplo, abrir algún puerto o ejecutar algún comando.

Aquí procedemos de la suposición de que se utiliza una imagen de Docker basada en un sistema operativo tipo Unix. Por supuesto, aquí también puede usar una imagen basada en Windows, pero usar Windows es una práctica menos común, trabajar con esas imágenes es más difícil. Como resultado, si tiene la oportunidad, use Unix.

Para comenzar, aquí hay una lista de instrucciones de Dockerfile con breves comentarios.

Docena de instrucciones Dockerfile


  1. FROM : establece la imagen base (principal).
  2. LABEL : describe los metadatos. Por ejemplo, información sobre quién creó y mantiene la imagen.
  3. ENV : establece variables de entorno persistentes.
  4. RUN : ejecuta un comando y crea una capa de imagen. Se utiliza para instalar paquetes en un contenedor.
  5. COPY : copia archivos y carpetas en el contenedor.
  6. ADD : copia archivos y carpetas en un contenedor, puede descomprimir archivos locales .tar.
  7. CMD : describe un comando con argumentos que debe ejecutarse cuando se inicia el contenedor. Los argumentos pueden anularse cuando se inicia el contenedor. Un archivo puede contener solo una instrucción CMD .
  8. WORKDIR : establece el directorio de trabajo para la siguiente instrucción.
  9. ARG : establece variables para pasar Docker durante la creación de la imagen.
  10. ENTRYPOINT : proporciona un comando con argumentos para invocar durante la ejecución del contenedor. Los argumentos no se anulan.
  11. EXPOSE : indica la necesidad de abrir el puerto.
  12. VOLUME : crea un punto de montaje para trabajar con almacenamiento persistente.

Ahora hablemos de estas instrucciones.

Instrucciones y ejemplos de su uso.


▍Simple Dockerfile


Dockerfile puede ser extremadamente simple y corto. Por ejemplo, así:

 FROM ubuntu:18.04 

▍De la instrucción


El Dockerfile debe comenzar con una declaración FROM , o con una declaración ARG seguida de una declaración FROM .

La palabra clave FROM le dice a Docker que use una imagen base que coincida con el nombre y la etiqueta proporcionados al crear la imagen. La imagen básica, además, también se llama imagen principal .

En este ejemplo, la imagen base se almacena en el repositorio de ubuntu . Ubuntu es el nombre del repositorio oficial de Docker, que proporciona la versión base de la popular familia de sistemas operativos Linux llamada Ubuntu.

Tenga en cuenta que el Dockerfile en cuestión incluye una etiqueta 18.04 que especifica qué imagen base necesitamos. Es esta imagen la que se cargará al construir nuestra imagen. Si la etiqueta no está incluida en las instrucciones, Docker parte de la suposición de que se requiere la última imagen del repositorio. Para expresar más claramente sus intenciones, se recomienda que el autor de Dockerfile indique qué imagen necesita.

Cuando el Dockerfile anterior se usa en la máquina local para construir la imagen por primera vez, Docker cargará las capas definidas por la imagen de ubuntu . Se pueden imaginar superpuestos entre sí. Cada capa siguiente es un archivo que describe las diferencias de la imagen en comparación con el estado en que se encontraba después de agregarle la capa anterior.

Cuando crea un contenedor, se agrega una capa en la que puede realizar cambios sobre todas las demás capas. Los datos en las capas restantes solo se pueden leer.


Estructura del contenedor (tomada de la documentación )

Docker, en aras de la eficiencia, utiliza una estrategia de copia en escritura. Si la capa en la imagen existe en el nivel anterior y alguna capa necesita leer datos de ella, Docker usa el archivo existente. No necesitas descargar nada.

Cuando se ejecuta la imagen, si la capa necesita ser modificada por medio del contenedor, entonces el archivo correspondiente se copia en la capa superior mutable. Para obtener más información sobre la estrategia de copiar y escribir, eche un vistazo a este material de la documentación de Docker.

Continuamos la discusión de las instrucciones utilizadas en el Dockerfile, dando un ejemplo de dicho archivo con una estructura más compleja.

▍Dockerfile más sofisticado


Aunque el Dockerfile que acabamos de revisar resultó ser ordenado y comprensible, es demasiado simple, solo utiliza una instrucción. Además, no hay instrucciones invocadas durante la ejecución del contenedor. Eche un vistazo a otro archivo que recopila una imagen pequeña. Tiene mecanismos que determinan los comandos que se invocan durante la ejecución del contenedor.

 FROM python:3.7.2-alpine3.8 LABEL maintainer="jeffmshale@gmail.com" ENV ADMIN="jeff" RUN apk update && apk upgrade && apk add bash COPY . ./app ADD https://raw.githubusercontent.com/discdiver/pachy-vid/master/sample_vids/vid1.mp4 \ /my_app_directory RUN ["mkdir", "/a_directory"] CMD ["python", "./my_script.py"] 

Quizás a primera vista este archivo puede parecer bastante complicado. Por lo tanto, tratemos con él.

La base de esta imagen es la imagen oficial de Python con la etiqueta 3.7.2-alpine3.8. Después de analizar este código, puede ver que esta imagen básica incluye Linux, Python y, en general, se limita a su composición. Las imágenes de Alpine OS son muy populares en el mundo Docker. El hecho de que son de tamaño pequeño, alta velocidad y seguridad. Sin embargo, las imágenes Alpine no difieren en las amplias capacidades típicas de los sistemas operativos convencionales. Por lo tanto, para recopilar algo útil sobre la base de dicha imagen, el creador de la imagen necesita instalar los paquetes que necesita.

▍ ETIQUETA de instrucciones



Etiquetas

La declaración LABEL (etiqueta) le permite agregar metadatos a la imagen. En el caso del archivo bajo consideración ahora, incluye la información de contacto del creador de la imagen. La declaración de etiquetas no ralentiza el proceso de ensamblaje de la imagen ni aumenta su tamaño. Solo contienen información útil sobre la imagen de Docker, por lo que se recomienda que se incluyan en el archivo. Los detalles sobre cómo trabajar con metadatos en el Dockerfile se pueden encontrar aquí .

▍Inv instrucciones



Medio ambiente

La instrucción ENV le permite establecer variables de entorno constantes que estarán disponibles en el contenedor durante su ejecución. En el ejemplo anterior, después de crear el contenedor, puede usar la variable ADMIN .

La instrucción ENV es adecuada para establecer constantes. Si usa un cierto valor en el Dockerfile varias veces, por ejemplo, cuando describe los comandos que se ejecutan en el contenedor, y sospecha que algún día tendrá que cambiarlo a otro, tiene sentido escribirlo en una constante similar.

Cabe señalar que en los archivos Dockerfile a menudo hay diferentes formas de resolver los mismos problemas. Lo que se debe utilizar exactamente es una pregunta, cuya decisión se ve afectada por el deseo de cumplir con los métodos de trabajo adoptados en el entorno de Docker, para garantizar la transparencia de la solución y su alto rendimiento. Por ejemplo, las ENTRYPOINT RUN , CMD y ENTRYPOINT sirven para diferentes propósitos, pero todas se usan para ejecutar comandos.

▍ instrucción de EJECUTAR



Instrucción RUN

La instrucción EJECUTAR le permite crear una capa durante la creación de la imagen. Después de su ejecución, se agrega una nueva capa a la imagen, su estado es fijo. La instrucción RUN se usa a menudo para instalar paquetes adicionales en imágenes. En el ejemplo anterior, la declaración RUN apk update && apk upgrade le dice a Docker que el sistema necesita actualizar los paquetes desde la imagen base. Después de estos dos comandos está el comando && apk add bash , que indica que bash debe instalarse en la imagen.

Lo que parece apk en equipos es una abreviatura de Alpine Linux package manager . Si está usando la imagen base de algún otro sistema operativo de la familia Linux, entonces, por ejemplo, cuando usa Ubuntu, es posible que necesite un comando del formulario RUN apt-get para instalar paquetes. Más adelante hablaremos sobre otras formas de instalar paquetes.

La instrucción RUN y otras instrucciones similares, como CMD y ENTRYPOINT , se pueden usar en forma ejecutiva o en forma de shell. El formulario exec utiliza una sintaxis que se parece a la descripción de una matriz JSON. Por ejemplo, podría verse así: RUN ["my_executable", "my_first_param1", "my_second_param2"] .

En el ejemplo anterior, utilizamos la forma de shell de la instrucción RUN de la siguiente manera: RUN apk update && apk upgrade && apk add bash .

Más adelante en nuestro Dockerfile, usamos la forma ejecutiva de la instrucción RUN , en forma de RUN ["mkdir", "/a_directory"] para crear un directorio. Al mismo tiempo, siguiendo las instrucciones de este formulario, debe recordar la necesidad de formatear cadenas con comillas dobles, como es habitual en el formato JSON.

▍Instrucción COPIA



Instrucción COPIA

La instrucción COPY se presenta en nuestro archivo así: COPY . ./app COPY . ./app . Ella le dice a Docker que necesita tomar archivos y carpetas del contexto local del ensamblaje y agregarlos al directorio de trabajo actual de la imagen. Si el directorio de destino no existe, esta instrucción lo creará.

▍Instrucción ADD


La instrucción ADD le permite resolver los mismos problemas que COPY , pero hay otros dos COPY uso asociados. Entonces, usando esta instrucción, puede agregar archivos descargados de fuentes remotas al contenedor, así como descomprimir archivos .tar locales.

En este ejemplo, la instrucción ADD se usó para copiar un archivo accesible por URL en el my_app_directory contenedor my_app_directory . Sin embargo, debe tenerse en cuenta que la documentación de Docker no recomienda el uso de dichos archivos obtenidos por URL, ya que no pueden eliminarse y aumentan el tamaño de la imagen.

Además, la documentación sugiere, siempre que sea posible, que utilice la instrucción COPY lugar de la instrucción ADD para que Dockerfile sea más fácil de entender. Creo que el equipo de desarrollo de Docker debe combinar ADD y COPY en una sola instrucción para que quienes crean las imágenes no tengan que recordar demasiadas instrucciones.

Tenga en cuenta que la instrucción ADD contiene el carácter de salto de línea - \ . Dichos caracteres se utilizan para mejorar la legibilidad de los comandos largos al dividirlos en varias líneas.

▍ instrucción CMD



Instrucción CMD

La instrucción CMD proporciona a Docker un comando para ejecutar cuando se inicia el contenedor. Los resultados de este comando no se agregan a la imagen durante su ensamblaje. En nuestro ejemplo, este comando inicia el script my_script.py en tiempo de ejecución.

Aquí hay algo más que necesita saber sobre la instrucción CMD :

  • Solo una instrucción CMD puede estar presente en un Dockerfile. Si hay varias instrucciones de este tipo en el archivo, el sistema ignorará todo excepto el último.
  • Una instrucción CMD puede tener una forma ejecutiva. Si la instrucción no incluye la referencia al archivo ejecutable, entonces la instrucción ENTRYPOINT debe estar presente en el archivo. En este caso, ambas instrucciones deben estar en JSON .
  • Los argumentos de la línea de comandos pasados ​​a docker run anulan los argumentos proporcionados por la instrucción CMD en el Dockerfile.

▍Un Dockerfile aún más complejo


Considere otro Dockerfile, en el que se usarán algunos comandos nuevos.

 FROM python:3.7.2-alpine3.8 LABEL maintainer="jeffmshale@gmail.com" #   RUN apk add --update git #     WORKDIR /usr/src/my_app_directory #          COPY . . #       ARG my_var=my_default_value #  ,           ENTRYPOINT ["python", "./app/my_script.py", "my_var"] #   EXPOSE 8000 #      VOLUME /my_volume 

En este ejemplo, entre otras cosas, puede ver comentarios que comienzan con el carácter # .
Una de las cosas principales que hace Dockerfile es instalar paquetes. Como ya se mencionó, hay varias formas de instalar paquetes utilizando la instrucción RUN .

Los paquetes en la imagen Alpine Docker se pueden instalar usando apk . Para esto, como ya dijimos, RUN apk update && apk upgrade && apk add bash un comando del formulario RUN apk update && apk upgrade && apk add bash .

Además, los paquetes de Python en la imagen se pueden instalar usando pip , wheel y conda . Si no estamos hablando de Python, sino de otros lenguajes de programación, se pueden usar otros administradores de paquetes para preparar las imágenes correspondientes.

Al mismo tiempo, para que la instalación sea posible, la capa subyacente debe proporcionar al administrador de paquetes un administrador de paquetes adecuado. Por lo tanto, si tiene problemas para instalar paquetes, asegúrese de que el administrador de paquetes esté instalado antes de intentar usarlo.

Por ejemplo, puede usar la instrucción RUN en un Dockerfile para instalar una lista de paquetes usando pip . Si hace esto, combine todos los comandos en una sola instrucción y sepárelos con caracteres de salto de línea usando el carácter \ . Gracias a este enfoque, los archivos se verán limpios y esto llevará a agregar menos capas a la imagen de las que se agregarían usando varias instrucciones de RUN .

Además, puede hacer diferentes cosas para instalar varios paquetes. Puede enumerarlos en un archivo y transferir este archivo al administrador de paquetes usando RUN . Por lo general, estos archivos se denominan requirements.txt .

▍ Instrucción WORKDIR



Directorios de trabajo

La instrucción WORKDIR le permite cambiar el directorio de trabajo del contenedor. Las ENTRYPOINT COPY , ADD , RUN , CMD y ENTRYPOINT que siguen a WORKDIR funcionan con este directorio. Estas son algunas características relacionadas con esta instrucción:

  • Es mejor establecer rutas absolutas a las carpetas con WORKDIR lugar de navegar por el sistema de archivos utilizando los comandos de cd en el Dockerfile.
  • La instrucción WORKDIR crea automáticamente un directorio si no existe.
  • Puede usar varias instrucciones de WORKDIR . Si se proporcionan instrucciones relativas a dichas instrucciones, cada una de ellas cambia el directorio de trabajo actual.

▍Guide ARG


La instrucción ARG le permite establecer una variable cuyo valor se puede pasar de la línea de comando a la imagen durante su ensamblaje. El valor de la variable predeterminada se puede representar en el Dockerfile. Por ejemplo: ARG my_var=my_default_value .

A diferencia de las variables ENV , las variables ARG no están disponibles en tiempo de ejecución. Sin embargo, las variables ARG se pueden usar para establecer valores predeterminados para las variables ENV desde la línea de comandos durante la creación de imágenes. Y las variables ENV ya estarán disponibles en el contenedor durante su ejecución. Los detalles sobre esta técnica de trabajar con variables se pueden encontrar aquí .

▍PUNTO DE ENTRADA DE INSTRUCCIÓN



Punto de transición a algún lugar.

La instrucción ENTRYPOINT le permite especificar un comando con argumentos que deben ejecutarse cuando se inicia el contenedor. Es similar al comando CMD , pero los parámetros especificados en ENTRYPOINT no se sobrescriben si el contenedor se inicia con parámetros de línea de comando.

En cambio, los argumentos de línea de comando pasados ​​en las construcciones de la docker run my_image_name formulario docker run my_image_name se agregan a los argumentos especificados por la ENTRYPOINT . Por ejemplo, después de ejecutar un comando del formulario docker run my_image bash argumento docker run my_image bash se agregará al final de la lista de argumentos especificada por ENTRYPOINT . Cuando prepare su Dockerfile, no olvide las ENTRYPOINT CMD o ENTRYPOINT .

Hay varias recomendaciones en la documentación para Docker con respecto a qué instrucción, CMD o ENTRYPOINT , se debe elegir como herramienta para ejecutar comandos cuando se inicia el contenedor:

  • Si necesita ejecutar el mismo comando cada vez que inicia el contenedor, use ENTRYPOINT .
  • Si el contenedor se usará como una aplicación, use ENTRYPOINT .
  • Si sabe que cuando inicia el contenedor, debe pasarle argumentos que puedan sobrescribir los argumentos especificados en el Dockerfile, use CMD .

En nuestro ejemplo, el uso de la instrucción ENTRYPOINT ["python", "my_script.py", "my_var"] hace que el contenedor, cuando se inicia, ejecute el script Python my_script.py con el argumento my_var . El valor representado por my_var se puede usar en el script usando argparse . , Dockerfile my_var , , ARG . , , .

Docker exec- ENTRYPOINT : ENTRYPOINT ["executable", "param1", "param2"] .

▍ EXPOSE



EXPOSE

EXPOSE , , . . , , , , , , .

( ) , docker run -p . -P ( P ), , EXPOSE .

▍ VOLUME



VOLUME

VOLUME , . .

Resumen


, Dockerfile. . , , USER , ONBUILD , STOPSIGNAL , SHELL HEALTHCHECK . Dockerfile.

, Dockerfile — Docker, , . , .

Estimados lectores! Docker , , Docker-.

Source: https://habr.com/ru/post/439980/


All Articles