Administracion del sistema

Cómo construir una imagen de Docker usando un Dockerfile

Cómo construir una imagen de Docker usando un Dockerfile

Las habilidades de Docker tienen una alta demanda principalmente porque, gracias a la Estibador Podemos automatizar la implementación de aplicaciones dentro de las llamadas contenedores, Creación de entornos personalizados que se pueden replicar fácilmente en cualquier lugar del Estibador La tecnología es compatible. En este tutorial veremos cómo crear un Imagen de Docker desde cero, usando un Dockfile. Aprenderemos las instrucciones más importantes que podemos usar para personalizar nuestra imagen, cómo construir la imagen y cómo ejecutar contenedores en función de ella.

En este tutorial aprenderás:

  • Cómo crear una imagen Docker usando un DockerFile
  • Algunas de las instrucciones de Dockerfile más utilizadas
  • Cómo lograr la persistencia de datos en contenedores


Requisitos y convenciones de software utilizados

Requisitos de software y convenciones de línea de comandos de Linux
Categoría Requisitos, convenciones o versión de software utilizada
Sistema INDEPENDO DEL OS
Software Estibador
Otro
  • Un Docker Daemon en ejecución
  • La utilidad de la línea de comandos de Docker
  • Familiaridad con la interfaz de línea de comandos de Linux
Convenciones # - requiere que los comandos de Linux dados se ejecuten con privilegios raíz directamente como un usuario raíz o mediante el uso de sudo dominio
ps - Requiere que los comandos de Linux dados se ejecuten como un usuario regular no privilegiado

Imágenes y contenedores

Antes de comenzar, puede ser útil definir claramente lo que queremos decir cuando hablamos de imágenes y contenedores en el contexto de Estibador. Las imágenes pueden considerarse como bloques de construcción del mundo de Docker. Representan los "planos" utilizados para crear contenedores. De hecho, cuando se crea un contenedor, representa una instancia concreta de las imágenes en las que se basa.

Se pueden crear muchos contenedores a partir de la misma imagen. En el resto de este artículo, aprenderemos cómo proporcionar las instrucciones necesarias para crear una imagen adaptada a nuestras necesidades dentro de un Dockfile, Cómo construir realmente la imagen y cómo ejecutar un contenedor basado en ella.

Construya nuestra propia imagen usando un Dockerfile

Para construir nuestra propia imagen usaremos un Dockfile. Un Dockerfile contiene todas las instrucciones necesarias para crear y configurar una imagen. Una vez que nuestro Dockerfile esté listo, usaremos el Docker Build comandar realmente construir la imagen.

Lo primero que debemos hacer es crear un nuevo directorio para alojar nuestro proyecto. Por el bien de este tutorial, construiremos una imagen que contenga el apache servidor web, por lo que nombraremos el directorio raíz del proyecto "Dockerized-apache":

$ mkdir dockerized-apache

Este directorio es lo que llamamos el Contexto de construcción. Durante el proceso de compilación, todos los archivos y directorios contenidos en él, incluido el Dockfile Crearemos, se enviaremos al Docker Daemon para que puedan acceder fácilmente, a menos que se enumeren en el .dockerignore archivo.

Creemos nuestro Dockfile. Se debe llamar al archivo Dockfile y contendrá, como dijimos anteriormente, todas las instrucciones necesarias para crear una imagen con las características deseadas. Encontramos nuestro editor de texto favorito y comenzamos escribiendo las siguientes instrucciones:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "
Copiar

La primera instrucción que debemos proporcionar es DE: Con él podemos especificar una imagen existente que utilizaremos como base (esto se llama imagen base), para crear el nuestro. En este caso, nuestra imagen base será ubuntu. Además del nombre de la imagen, también usamos una etiqueta, para especificar la versión de la imagen que queremos usar, en este caso 18.10. Si no se especifica ninguna etiqueta, el último La etiqueta se usa de forma predeterminada: esto causará la última versión disponible de la imagen base. Si la imagen aún no está presente en nuestro sistema, se descargará desde Dockerhub.

Después de la DE instrucción, usamos ETIQUETA. Esta instrucción es opcional, se puede repetir varias veces y se usa para agregar metadatos a nuestra imagen. En este caso lo usamos para especificar el mantenedor de imágenes.

La instrucción de ejecución

En este punto, si corremos Docker Build, Simplemente produciremos una imagen idéntica a la base, excepto los metadatos que agregamos. Esto no sería útil para nosotros. Dijimos que queremos "dockerizar" el apache servidor web, así que lo siguiente que debe hacer en nuestro Dockfile, es proporcionar una instrucción para instalar el servidor web como parte de la imagen. La instrucción que nos permite lograr esta tarea es CORRER:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2
Copiar

El CORRER La instrucción se utiliza para ejecutar comandos en la parte superior de la imagen. Una cosa muy importante para recordar es que para cada CORRER instrucción que utilizamos, un nueva capa se crea y se agrega a la pila. A este respecto, Docker es muy inteligente: las capas ya construidas serán "almacenadas en caché": esto significa que si construimos una imagen basada en nuestra Dockfile, y luego decidimos, por ejemplo, agregar otro CORRER Instrucción (y, por lo tanto, una nueva capa) al final, la compilación no comenzará desde cero, pero solo ejecutará las nuevas instrucciones.

Para que esto suceda, por supuesto, las instrucciones ya se construyeron en el Dockfile no debe ser modificado. Incluso es posible evitar este comportamiento por completo al construir una imagen, solo usando el --no cache opción del Docker Build dominio.

En nuestro caso usamos el CORRER instrucción para ejecutar el Apt-Get Update && apt-get -y install apache2 comandos. Observe cómo pasamos el -Y opción para el instalación de apt-get Comando: Esta opción hace para que una respuesta afirmativa se proporcione automáticamente a todas las confirmaciones requeridas por el comando. Esto es necesario porque estamos instalando el paquete de manera no interactiva.

Exposición del puerto 80

Como sabemos, el servidor web de Apache escucha Puerto 80 Para conexiones estándar. Debemos instruir a Docker que haga que ese puerto sea accesible en el contenedor. Para lograr la tarea usamos el EXPONER función y proporcionar el número de puerto. Por razones de seguridad, el puerto especificado se abre solo cuando se inicia el contenedor. Agreguemos esta instrucción a nuestro Dockfile:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2 expose 80
Copiar

Construyendo la imagen

En este punto ya podemos intentar construir nuestra imagen. Desde el interior del directorio raíz de nuestro proyecto, "Dockerized-Apache", ejecutamos el siguiente comando:

$ sudo Docker Build -T linuxconfig/dockerized -apache .

Examinemos el comando. En primer lugar, prefijamos el comando con sudo para ejecutarlo con privilegios administrativos. Es posible evitar esto, agregando un usuario al estibador grupo, pero esto representa un riesgo de seguridad. El -T Opción que proporcionamos, abreviatura de --etiqueta, Aplicemos un nombre de repositorio y opcionalmente una etiqueta a nuestra imagen si la compilación tiene éxito.

Finalmente, el . le indica a Docker que busque el Dockfile En el directorio actual. Tan pronto como iniciamos el comando, el proceso de compilación comenzará. Los mensajes de progreso y compilación se mostrarán en la pantalla:

Enviar contexto de compilación a Docker Daemon 2.048 KB Paso 1/4: de Ubuntu: 18.10 tratando de tirar del repositorio Docker.io/biblioteca/ubuntu .. . [… .]
Copiar

En pocos minutos nuestra imagen debe crearse con éxito. Para verificarlo, podemos ejecutar el Imágenes de Docker Comando, que devuelve una lista de todas las imágenes existentes en nuestro repositorio local de Docker:

$ sudo Docker Images Repositorio ID de imagen ID de imagen creada LinuxConfig/Dockerized-Apache Último 7AB7B6873614 2 minutos hace 191 MB
Copiar

Como se esperaba, la imagen aparece en la lista. Como podemos notar, ya que no proporcionamos una etiqueta (solo un nombre de repositorio, linuxconfig/dockerized-apache) el el último La etiqueta se ha aplicado automáticamente a nuestra imagen. Un IDENTIFICACIÓN también ha sido asignado a la TI, 7AB7B6873614: Podemos usarla para hacer referencia a la imagen en futuros comandos.

Lanzamiento de un contenedor basado en la imagen

Ahora que nuestra imagen está lista, podemos crear y iniciar un envase Basado en eso. Para lograr la tarea usamos el Docker Run dominio:

$ sudo Docker Run - -Name = LinuxConfig -Apache -D -P 8080: 80 LinuxConfig/Dockerized -Apache Apachectl -D Pravundat

Examinemos el comando anterior. La primera opción que proporcionamos fue --nombre: Con eso, especificamos un nombre para el contenedor, en este caso "LinuxConfig-Apache". Si omitimos esta opción, un nombre generado aleatorio se habría asignado a nuestro contenedor.

El -d opción (abreviatura de --despegar) hace que el contenedor se ejecute en segundo plano.

El -pag Opción, abreviatura de --publicar, se necesita para publicar un puerto de contenedor (o una gama de puertos) al sistema de host. La sintaxis de la opción es la siguiente:

-P localhost_port: contenedor_port

En este caso publicamos el Puerto 80 Anteriormente expusimos en el contenedor, al anfitrión puerto 8080. En aras de la integridad, debemos decir que también es posible usar el -PAG opción (abreviatura de --publicar) en su lugar, causando que todos los puertos expuestos en el contenedor se asignen aleatorio puertos en el host.

Las dos últimas cosas que especificamos en el comando anterior son: el imagen el contenedor debe estar basado en y el dominio para ejecutar cuando se inicia el contenedor, que es opcional. La imagen es por supuesto linuxconfig/dockerized-apache, el que construimos antes.

El comando que especificamos es apachectl -d en primer plano. Con este comando el apache El servidor web se inicia en primer plano Modo: Esto es obligatorio para que funcione en el contenedor. El Docker Run El comando ejecuta el comando especificado en un nuevo envase:

$ sudo Docker Run - -Name = LinuxConfig -Apache -D -P 8080: 80 LinuxConfig/Dockerized -Apache Apachectl -D Premio A51FC9A6DD66B02117F00235A341003A9BF0FFDD53F90A040BC1122CBBC4534233
Copiar

¿Cuál es el número impreso en la pantalla?? Es el IDENTIFICACIÓN del contenedor! Una vez que tengamos el contenedor en funcionamiento, deberíamos poder acceder a la página servida por el valor predeterminado apache Virtualhost en el Localhost: 8080 dirección (puerto 8080 en el host se asigna en el puerto 80 en el contenedor):



Índice de apache predeterminado.página HTML

Nuestra configuración funciona correctamente. Si corremos el Docker PS Comando, que enumera todos los contenedores activos en el sistema, podemos recuperar información sobre nuestro contenedor: ID (versión corta, más fácil de hacer referencia a la línea de comando para un humano), la imagen de la que se ejecutó, el comando utilizado, su creación tiempo y estado actual, mapeo y nombre de puertos.

$ sudo Docker PS PS Comando de imagen de ID de contenedor creado Puertos de estado Nombres A51FC9A6DD66 LinuxConfig/Dockerized -Apache "Apachectl -d Fore ..." hace 28 segundos hasta 28 segundos 0.0.0.0: 8080-> 80/TCP Linuxconfig-apache
Copiar

Para detenerlo, el contenedor, todo lo que necesitamos hacer es hacer referencia por su identificación o nombre, y ejecutar el Docker Stop dominio. Por ejemplo:

$ sudo docker stop linuxconfig-apache

Para comenzar de nuevo:

$ sudo Docker Start Linuxconfig-apache

Ejecutar el comando directamente a través de DockerFile

Dado que aquí construimos una imagen básica y en tiempo de ejecución, usando el Docker Run comando, especificamos el comando que se iniciará cuando se inicia el contenedor. A veces queremos especificar este último directamente dentro del Dockerfile. Podemos hacerlo de dos maneras: usar CMD o PUNTO DE ENTRADA.

Ambas instrucciones se pueden usar para el mismo propósito, pero se comportan de manera diferente cuando también se especifica un comando desde la línea de comando. Veamos como.

La instrucción CMD

El CMD La instrucción se puede utilizar básicamente en dos formas. El primero es el ejecución forma:

Cmd ["/usr/sbin/apachectl", "-d", "primer plano"]

El otro es el caparazón forma:

CMD/USR/SBIN/APACHECTL -D PARAJE

El ejecución de la vez es preferido. Vale la pena notar que al usar el formulario ejecutivo, no se invoca un shell, por lo tanto, no se producirán expansiones variables. Si se necesita expansión variable, podemos usar el caparazón formar o podemos invocar un caparazón directamente en el ejecución modo, como:

Cmd ["sh", "-c", "echo", "$ home"]

El CMD La instrucción se puede especificar solo una vez en el Dockfile. Si múltiple CMD Se proporcionan opciones, solo la última entrará en vigencia. El propósito de la instrucción es proporcionar un por defecto comando que se lanzará cuando comience el contenedor:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2 exponer 80 cmd ["/usr/sbin/apachectl "," -d "," primer plano "]
Copiar

El comando especificado con CMD dentro de Dockfile, funciona como un valor predeterminado, y se anulará si se especifica otro comando desde la línea de comando al ejecutar Docker Run.

La instrucción de EntryPoint

El PUNTO DE ENTRADA La instrucción también se puede utilizar para configurar un comando que se utilizará cuando se inicia el contenedor, y como CMD, ambos ejecución y caparazón la forma se puede usar con él. La gran diferencia entre los dos es que un comando pasado de la línea de comando no anulará el especificado con PUNTO DE ENTRADA: en su lugar será adjunto lo.

Al usar esta instrucción, podemos especificar un comando básico y modificarlo con las opciones que proporcionamos al ejecutar el corredor de acopolador comando, haciendo que nuestro contenedor se comporte como un ejecutable. Veamos un ejemplo con nuestro Dockfile:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2 expose 80 entrypoint ["/usr/sbin/apachectl "]
Copiar

En este caso sustituimos el CMD instrucciones con PUNTO DE ENTRADA y también eliminó el -D primer plano Opción desde el formato EXEC. Supongamos que ahora reconstruimos la imagen y recreamos el contenedor usando el siguiente comando:

$ sudo Docker Run - -Name = LinuxConfig -Apache -d -P 8080: 80 LinuxConfig/Dockerized -Apache -d Peartrow

Cuando comienza el contenedor, el -D primer plano Los argumentos se adjuntan al comando proporcionado en el Dockfile con el PUNTO DE ENTRADA instrucción, pero solo si usa el ejecución forma. Esto se puede verificar ejecutando el Docker PS Comando (aquí agregamos algunas opciones al comando, para mostrar y formatear mejor su salida, seleccionando solo la información que necesitamos):

$ sudo docker ps--no-trunc-format ".Nombres \ t .Comando "linuxconfig -apache"/usr/sbin/apachectl -d en primer plano "
Copiar

Al igual que CMD, el PUNTO DE ENTRADA La instrucción se puede proporcionar solo una vez. Si aparece múltiples tiempo en el DockerFile, solo se considerará el último ocurrencia. Es posible anular el valor predeterminado PUNTO DE ENTRADA de la imagen desde la línea de comando, utilizando el --punto de entrada opción del Docker Run dominio.

Combinando CMD y EntryPoint

Ahora que conocemos la peculiaridad del CMD y PUNTO DE ENTRADA Instrucciones también podemos combinarlas. ¿Qué podemos obtener al hacerlo?? Nosotros podemos usar PUNTO DE ENTRADA para especificar un comando base válido y el CMD instrucción para especificar los parámetros predeterminados para ello.

El comando se ejecutará con esos parámetros predeterminados de forma predeterminada, a menos que los anulemos desde la línea de comando al ejecutar Docker Run. Pegado a nuestro Dockfile, Podríamos escribir:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2 expose 80 entrypoint ["/usr/sbin/apachectl "] cmd [" -d "," primer plano "]
Copiar

Si reconstruimos la imagen de esto Dockfile, Elimine el contenedor anterior que creamos y vuelva a lanzar el Docker Run comandar sin especificar ningún argumento adicional, el /usr/bin/apachectl -d primer plano el comando se ejecutará. Si en su lugar proporcionamos algunos argumentos, anularán los especificados en el Dockfile con el CMD instrucción. Por ejemplo, si ejecutamos:

$ sudo Docker Run - -Name = LinuxConfig -Aapache -D -P 8080: 80 LinuxConfig/Dockerized -Apache -x

El comando que se ejecutará al iniciar el contenedor será /usr/bin/apachectl -x. Verifiquemos:

$ sudo docker ps--no-trunc-format ".Nombres \ t .Comando "linuxconfig -apache"/usr/sbin/apachectl -x "
Copiar

El comando lanzado fue como se esperaba: el -X La opción, por cierto, hace para que el demonio httpd se inicie en modo de depuración.

Copiar archivos en el contenedor

Nuestro servidor Apache "dockerizado" funciona. Como vimos, si navegamos a Localhost: 8080, Visualizamos la página de bienvenida de Apache predeterminada. Ahora, digamos que tenemos un sitio web listo para ser enviado con el contenedor, ¿cómo podemos "cargarlo" para que Apache lo sirva en su lugar??

Bueno, en aras de este tutorial solo reemplazaremos el índice predeterminado.archivo html. Para lograr la tarea podemos usar el COPIAR instrucción. Supongamos que tenemos un índice alternativo.archivo html dentro de la raíz de nuestro proyecto (nuestro contexto de compilación) con este contenido:

  
Hola!
 
Este archivo se ha copiado en el contenedor con la instrucción de copia!
Copiar

Queremos cargarlo y copiarlo al /var/www/html directorio dentro del contenedor, por lo tanto dentro de nuestro Dockfile Añademos el COPIAR instrucción:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2 expose 80 Entrypoint ["/usr/sbin/apachectl "] cmd [" -d "," primer plano "] Copiar índice.html/var/www/html/índice.html
Copiar

Reconstruimos la imagen y el contenedor. Si ahora navegue a Localhost: 8080, Veremos el nuevo mensaje:

# nuevo mensaje

El COPIAR La instrucción se puede usar para copiar ambos archivos y directorios. Cuando la ruta de destino no existe, se crea dentro del contenedor. Todos los archivos y directorios nuevos se crean con un Uid y Aturdir de 0.

Otra solución de posibilidad para copiar archivos dentro del contenedor es usar el AGREGAR instrucción, que es más poderosa que COPIAR. Con esta instrucción podemos copiar archivos, directorios pero también URLS. Además, si copiamos un local Archivo de alquitrán Con un formato comprimido reconocido, se desconocará automáticamente como directorio dentro del contenedor.

La estrategia ideal sería usar COPIAR a menos que las características adicionales proporcionadas por AGREGAR son realmente necesarios.

Creando un volumen

En el ejemplo anterior, para demostrar cómo el COPIAR La instrucción funciona, reemplazamos el índice predeterminado.archivo html del apache virtualhost predeterminado dentro del contenedor.

Si nos detenemos y iniciamos el contenedor, aún encontraremos la modificación que hicimos, pero si el contenedor se elimina por alguna razón, todos los datos contenidos en su capa de escritura se perderán con él. Cómo resolver este problema? Un enfoque es usar el VOLUMEN instrucción:

De Ubuntu: 18.10 etiqueta mantenedor = "[email protected] "Ejecutar Apt-Get Update && apt-get -y install apache2 expose 80 Entrypoint ["/usr/sbin/apachectl "] cmd [" -d "," primer plano "] Copiar índice.html/var/www/html/índice.Volumen HTML/var/www/html
Copiar

El VOLUMEN La instrucción toma uno o más directorios (en este caso /var/www/html) y hace que se usen como puntos de montaje para volúmenes externos de nombres aleatorios generados cuando se crea el contenedor.

De esta manera, los datos que ponemos en los directorios utilizados como puntos de montaje se persistirán dentro de los volúmenes montados y aún existirán incluso si el contenedor se destruye. Si un directorio establecido para usarse como punto de montaje ya contiene datos en el momento de la inicialización, esos datos se copian dentro del volumen que se monta en él.

Reconstruyamos la imagen y el contenedor. Ahora podemos verificar que el volumen se haya creado y está en uso inspeccionando el contenedor:

$ sudo Docker Inspect Linuxconfig-apache [.. .] "Mounts": [  "Type": "volume", "Name": "8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61", "Source": "/var/lib/docker/volumes/8f24f75459c24c491b2a5e53265842068d7c44bf1b0ef54f98b85ad08e673e61/_data", "Destination": "/var/ www/html "," controlador ":" local "," modo ":" "," rw ": true," propagation ":" "], [.. .]
Copiar

Como ya se dijo, el volumen sobrevivirá incluso después de que se destruya el contenedor para que nuestros datos no se pierdan.

El VOLUMEN instrucción dentro del Meta, Como podemos ver en la salida del comando Docker Inspect anterior, hace que se cree un volumen con nombre al azar. Para definir un Volumen llamado, o para montar un volumen ya existente dentro de un contenedor, debemos especificarlo en tiempo de ejecución, al ejecutar el Docker Run comando, usando el -V opción (abreviatura de --volumen). Veamos un ejemplo:

$ sudo Docker Run - -Name = LinuxConfig -Apache -D -P 8080: 80 -v MyVolume:/var/www/html linuxconfig/dockerized -apache

En el comando anterior, usamos el -V opción especificando el nombre de volumen (muy importante: observe que no es un camino, sino un nombre simple) y el punto de montaje Dentro del contenedor usando la siguiente sintaxis:

:

Cuando realizamos dicho comando, el volumen llamado "myVolume" se montará en la ruta específica dentro del contenedor (el volumen se creará si aún no existe). Como dijimos antes, si el volumen está vacío, los datos ya existentes en el punto de montaje dentro del contenedor se copiarán dentro de él. Utilizando el Docker Volumen LS Comando, podemos confirmar un volumen con el nombre que especificamos ha sido creado:

$ sudo Docker Volumen LS Nombre del volumen del controlador MyVolume local
Copiar

Para eliminar un volumen usamos el Docker Volumen RM comandar y proporcionar el nombre del volumen para eliminar. Docker, sin embargo, no nos permitirá eliminar un volumen utilizado por un contenedor activo:

$ sudo Docker Volumen RM Respuesta de error de MyVolume de Daemon: No se puede eliminar el volumen, volumen aún en uso: Eliminar myVolume: el volumen está en uso - [95381B7B6003F6165DFE2E1912D2F827F7167AC26E22CF26C1BCAB704A2D7E02]]]]]
Copiar

Otro enfoque para la persistencia de datos, especialmente útil durante el desarrollo, es montaje de ataduras un directorio de host dentro del contenedor. Este enfoque tiene la ventaja de permitirnos trabajar en nuestro código localmente con nuestras herramientas favoritas y ver el efecto de los cambios inmediatamente reflejados dentro del contenedor, pero tiene una gran desventaja: el contenedor depende de la estructura del directorio del host.

Por esta razón, dado que la portabilidad es uno de los principales objetivos de Docker, no es posible definir un montaje de ataduras dentro de un Dockerfile, pero solo en tiempo de ejecución. Para lograr esta tarea, usamos el -V opción de Docker Run comandar nuevamente, pero esta vez proporcionamos el camino de un directorio dentro del sistema de archivos host en lugar de un nombre de volumen:

$ sudo Docker Run - -Name = LinuxConfig -Aapache -D -P 8080: 80 -V/Path/ON/Host:/Var/Www/Html LinuxConfig/Dockerized -Apache

Al iniciar el comando anterior, el directorio de host/ruta/on/host se montará en/var/www/html dentro del contenedor. Si el directorio en el host no existe, se crea automáticamente. En este caso, los datos en el directorio de MountPoint dentro del contenedor (/var/www/html en nuestro ejemplo) son no copiado en el directorio host que se monta sobre él, como sucede para volúmenes.

Conclusión

En este tutorial aprendimos los conceptos básicos necesarios para crear y construir una imagen de Docker utilizando un Dockfile y cómo ejecutar un contenedor basado en él. Construimos una imagen muy simple que nos permitió ejecutar una versión "dockerized" del servidor web Apache. En el proceso, vimos cómo usar el DE instrucción, que es obligatoria especificar una imagen base para trabajar, el ETIQUETA instrucción para agregar metadatos a nuestra imagen, el EXPONER instrucción para declarar que los puertos se expusen en el contenedor. También aprendimos a mapear dicho puerto (s) de los puertos del sistema host del host.

Aprendimos a usar el
CORRER instrucción para ejecutar comandos en la imagen, y aprendimos cómo especificar un comando que se ejecutará cuando el contenedor se inicie tanto desde la línea de comandos como dentro del Dockfile. Vimos cómo lograr esto usando el CMD y PUNTO DE ENTRADA instrucciones, y cuáles son las diferencias entre los dos. Finalmente, vimos cómo COPIAR datos dentro del contenedor y cómo lograr la persistencia de datos utilizando volúmenes. En nuestros ejemplos, discutimos solo un pequeño subconjunto de las instrucciones que se pueden usar en un Dockfile.

Para una lista completa y detallada, consulte la documentación oficial de Docker. Mientras tanto, si quieres saber cómo construir un completo LÁMPARA pila usando Docker y la herramienta Docker-Compose, puede echar un vistazo a nuestro artículo sobre cómo crear una pila de lámparas basada en Docker usando Docker-Compose en Ubuntu 18.04 Bionic Beaver Linux.

Tutoriales de Linux relacionados:

  • Una introducción a la automatización, herramientas y técnicas de Linux
  • Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
  • Cosas para instalar en Ubuntu 20.04
  • Cómo montar la imagen ISO en Linux
  • Cómo crear copias de seguridad del sistema incremental con paso de tiempo en ..
  • Kubernetes vs Docker, ¿cuál es la diferencia??
  • Cómo cambiar el tamaño de una imagen de disco QCOW2 en Linux
  • Cómo crear una pila de lámparas basada en Docker usando Docker en ..
  • Mastering Bash Script Loops
  • Cosas que hacer después de instalar Ubuntu 22.04 Jellyfish de Jammy ..