Cómo usar un Dockerfile para crear una imagen de Docker

Un Dockerfile es un archivo de texto con instrucciones que se utilizan para automatizar la instalación y configuración de una imagen de Docker. Los archivos Docker facilitan la implementación de varios contenedores Docker sin tener que mantener la misma imagen en varias máquinas virtuales. Las instrucciones se ejecutan en el orden en que aparecen en el Dockerfile, lo que hace que su uso y actualización sean claros e intuitivos. Este artículo cubre los conceptos básicos, con un ejemplo, de cómo funciona un Dockerfile.

Antes de comenzar

Familiarícese con nuestra guía de introducción, cree y actualice un Linode e instale Docker. Alternativamente, puede implementar rápidamente un Linode actualizado y habilitado para Docker con la aplicación Docker Marketplace.
Asegúrese de que su Linode esté seguro siguiendo nuestra guía sobre Configuración y protección de una instancia informática.
Esta guía asume que se siente cómodo con el uso de la interfaz de línea de comandos (CLI) de Docker. Para obtener más información sobre la CLI de Docker, consulte su documentación.

¿Cómo funciona un Dockerfile?

Un Dockerfile es un script que lleva a cabo diferentes comandos y acciones para crear una imagen de Docker, que luego se puede usar para implementar un contenedor de Docker. Los comandos y la información dentro de Dockerfile se pueden configurar para usar versiones de software y dependencias específicas para implementaciones estables. También puede usar un registro de Docker para almacenar y acceder a sus imágenes de Docker públicas (o privadas).

Una vez que se escribe un Dockerfile, puede usar docker build Comando para generar una imagen de Docker basada en las instrucciones de Dockerfile. Luego, puede implementar un contenedor basado en la imagen con comandos como docker run o docker create .

Aquí hay instrucciones comunes que puede usar en sus Dockerfiles para crear imágenes:

Definiciones básicas

DESDE :define la imagen base, como ubuntu o debian , utilizado para iniciar el proceso de compilación. Requerido para cada Dockerfile.
MANTENEDOR :define el nombre completo y la dirección de correo electrónico del creador de la imagen.

Variables

ENV :establece variables de entorno que persisten cuando se implementa el contenedor.
ARG :establezca una variable de tiempo de compilación aceptable. Se puede utilizar como alternativa a ENV para crear una variable que no persista cuando el contenedor se implementa desde la imagen.

Ejecución de comandos

CORRE :ejecuta comandos, como comandos de instalación de paquetes, en una nueva capa de imagen.
CMD :ejecute un comando específico dentro del contenedor que se implementa con la imagen, o establezca parámetros predeterminados para un ENTRYPOINT instrucción. Solo se usa uno por Dockerfile.
PUNTO DE ENTRADA :establezca una aplicación predeterminada que se utilizará cada vez que se implemente un contenedor con la imagen. Solo se usa uno por Dockerfile.
USUARIO :Configure el UID (el nombre de usuario) para ejecutar comandos en el contenedor.
DIR.TRABAJO :Establece la ruta del contenedor donde se ejecutan los siguientes comandos de Dockerfile.

Nota RUN , CMD y ENTRYPOINT cada uno se puede ejecutar en shell form, que toma argumentos normales, o exec formulario, que toma los argumentos como una matriz JSON. Porque ejecutivo form no invoca un shell de comandos, generalmente se prefiere y se utiliza en esta guía.

Administración de datos

AÑADIR :copie archivos de una fuente al sistema de archivos de la imagen en el destino establecido con tarball automático y manejo remoto de URL.
COPIAR :Similar a ADD pero sin tarball automático y manejo remoto de URL.
VOLUMEN :habilite el acceso desde un punto de montaje especificado en el contenedor a un directorio en la máquina host.

Redes

EXPONER :exponga un puerto específico para permitir la creación de redes entre el contenedor y el mundo exterior.

A continuación, crearemos un Dockerfile de ejemplo que utiliza algunos de estos comandos.

Creando un Dockerfile

Para crear el Dockerfile:

En el símbolo del sistema (ya sea a través de SSH o Lish en Linode Manager), cree y cambie a un nuevo directorio:
```
mkdir ~/mydockerbuild && cd ~/mydockerbuild
```
Nota Esto coloca el directorio de compilación de Docker en su directorio de inicio. Como buena práctica, no almacene el Dockerfile en su propio directorio de inicio o en el directorio raíz del servidor. En su lugar, cree un directorio separado y coloque todos los archivos necesarios dentro de él (junto con el Dockerfile) como se muestra en esta guía.
Cree un Dockerfile de ejemplo:
```
touch example_dockerfile
```
Abra el Dockerfile usando el editor de texto de su elección (para este ejemplo, usamos nano):
```
nano example_dockerfile
```

Copie el siguiente ejemplo en su Dockerfile. Esto crea un Dockerfile que genera una imagen de Debian, establece la información del mantenedor y simplemente devuelve "¡Hola, Sunshine!" cuando se ejecuta:

Archivo:ejemplo_dockerfile

Guarde el Dockerfile.

Ingrese cat example_dockerfile y asegúrese de que el texto de arriba esté incluido.

Crear una imagen de Docker desde un archivo de Docker

Cree la imagen desde Dockerfile usando docker build comando:

docker build ~/mydockerbuild -f example_dockerfile -t example_image

Etiquetando tu imagen con example_image facilita la implementación de un contenedor en el siguiente paso.

La salida debería verse así:

Sending build context to Docker daemon  4.096kB
Step 1/3 : FROM debian
 ---> 4a7a1f401734
Step 2/3 : MAINTAINER Jane Doe [email protected]
 ---> Running in fdd81bd8b5c6
Removing intermediate container fdd81bd8b5c6
 ---> 1253842068a3
Step 3/3 : CMD ["echo", "Hello, Sunshine!"]
 ---> Running in d33e1bacf1af
Removing intermediate container d33e1bacf1af
 ---> a5d95e138b97
Successfully built a5d95e138b97
Successfully tagged example_image:latest

Como puede ver, las instrucciones de example_dockerfile se ejecutan en orden. La imagen etiquetada como example_image ahora está listo para ejecutarse para implementar un contenedor.

Ejecutando su imagen de Docker para implementar un contenedor

Ejecutar la imagen que acaba de crear para implementar un contenedor Docker ahora es tan fácil como ingresar lo siguiente:

docker run example_image

Un nuevo contenedor basado en example_image se implementa y el comando especificado en el CMD Luego, la instrucción se ejecuta desde el contenedor con el siguiente resultado:

Hello, Sunshine!

Nota Si docker run se ejecuta el comando y la imagen de Docker no está disponible en su directorio de trabajo actual; en su lugar, se extrae del registro de Docker.

Lecturas adicionales

¡Felicidades! Ha creado su primer Dockerfile y ha ejecutado su primera imagen de Docker.

Para obtener más ejemplos e información sobre el uso de Dockerfiles con imágenes y contenedores de Docker, consulte:

nuestra guía sobre cómo usar imágenes Docker, contenedores y archivos Docker en profundidad;
Mejores prácticas de Dockerfile de Docker.

Más información

Es posible que desee consultar los siguientes recursos para obtener información adicional sobre este tema. Si bien estos se proporcionan con la esperanza de que sean útiles, tenga en cuenta que no podemos garantizar la precisión o la puntualidad de los materiales alojados externamente.

Prácticas recomendadas para escribir Dockerfiles
Imágenes oficiales de Docker en Docker Hub
Documentos de Docker

Cree, etiquete y cargue su propia imagen de Docker

Cómo implementar un contenedor nginx con Docker en Linode

Docker

Cómo crear imágenes de Docker en una canalización de GitLab CI

Cómo crear una imagen de ventana de Docker con la etiqueta de compilación de Docker

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

Cómo usar Docker Commit para cambiar imágenes de contenedores

Cómo crear una imagen Docker personalizada con Dockerfile

Cómo compilar y enviar una imagen de Docker al repositorio de Docker Hub

1
2
3

FROM debian
MAINTAINER Jane Doe [email protected]
CMD ["echo", "Hello, Sunshine!"]