Creando una imagen Docker desde cero
Hablando libremente, Docker se está volviendo cada vez más como un administrador de paquetes universal que funciona en todas las plataformas de Linux posibles. Se necesitan contenedores y los usa para resolver un problema completamente diferente al que enfrentan los desarrolladores. El problema es que los desarrolladores usan su sistema operativo de escritorio (como Windows, MacOS o Linux con una tonelada de paquetes relacionados con el escritorio) para escribir aplicaciones. La aplicación que escriben a menudo se ejecuta en un sistema operativo completamente diferente en un servidor en algún lugar con alguna distribución de Linux completamente diferente a la de la computadora portátil del desarrollador.
Con Docker, la idea es que su aplicación viene empaquetada como una imagen de Docker. Es el trabajo de Docker tomar esta imagen y ejecutarla como una aplicación contenedor para usted. Estar en contenedores significa que la aplicación y sus dependencias se ejecutarán en un entorno aislado que puede diferir completamente de la computadora portátil del desarrollador e incluso del servidor de producción. Mientras ambos admitan Docker, ambos pueden ejecutar la misma aplicación de la misma manera.
Anatomía de una imagen de Docker
Como se mencionó anteriormente, una aplicación Docker se ejecutará en un entorno acordado. Ahora la pregunta es cómo creamos ese entorno? La mayoría de las imágenes de aplicaciones importarían una imagen base de Docker y construirían su aplicación sobre ella.
Las aplicaciones están hechas de capas de software. Se crea una imagen de contenedor de WordPress utilizando una imagen de contenedor HTTPD que, a su vez, está construida sobre una imagen de Ubuntu. La imagen sobre la cual se construye una imagen más nueva se conoce como la imagen principal en Docker Terminology. En DockerFile (llegaremos a lo que significa un DockerFile, un poco más tarde), esta imagen principal se menciona en la parte superior del archivo como se muestra a continuación:
De Ubuntu: 18.04## resto del Dockerfile
Este dockerfile cuando se ejecuta convierte su aplicación en una imagen de Docker (una especie de binario) que luego puede llevar a un registro desde donde se puede extraer para crear nuevos contenedores en otro lugar. Sin embargo, todos tendrán Ubuntu: 18.04 como su imagen base, y se ejecuta como si fuera un sistema Ubuntu en el que se están ejecutando.
Es posible que hayas notado esto cuando intentes extraer una nueva imagen de Docker.
Esto muestra cuántas capas se extraen antes de que la aplicación real (que podría tener solo unas pocas megabytes).
Por esta razón, nos gustaría crear lo que se conoce como imagen base. Que no se construye sobre nada más. La palabra clave "scratch" se usa para indicar que esta capa no está construida sobre cualquier otra cosa. Al igual que:
Desde cero## RESTO DEL DOCKERFILE
Primero crearemos una aplicación simple de Hello-World y luego descubriremos cuál será el resto del Dockerfile. El sistema host es Ubuntu: 18.04 LTS y estamos usando Docker versión 17.12.1-CE para el experimento.
Creando un binario estático
Los contenedores Docker son una colección de procesos que se ejecutan aislados del resto del sistema operativo. Lo único que el proceso está en contacto es el núcleo. Kernel es responsable de programar estos procesos en la CPU, hacer la gestión de la memoria y algunas otras reservas básicas para mantener las tareas.
Pero la mayoría de las aplicaciones de alto nivel dependen de muchas bibliotecas de sistemas (como GLIBC, MUSL, KLIBC, etc) y muchas dependencias de tiempo de ejecución como Python o Node.tiempo de ejecución js o java. El binario de la aplicación no tiene todas las bibliotecas disponibles dentro de ella, pero cuando comienza a ejecución, llama a esas bibliotecas desde el sistema operativo del host.
Porque estamos tratando de crear una imagen desde cero, no recibiríamos estas sutilezas. Por lo tanto, nuestra aplicación debe ser un archivo estático o un ejecutable independiente.
Comencemos creando una carpeta llamada mydockerimage y creando un archivo hola.cc dentro de él.
$ mkdir mydockerimage
$ CD mydockerimage
$ touch hola.CC
Open Hola.CC usando su editor de texto favorito y agregue las siguientes líneas dentro de él.
#incluirusando el espacio de nombres STD;
int main ()
cout << "Hello! This message is coming from a container \n ";
regresar 0;
Este es un programa simple C ++ que imprime "Hola! Este mensaje… "
Por razones discutidas anteriormente, lo compilaremos utilizando la bandera estática. El compilador que se está utilizando es G ++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.
Para compilar el programa, en el mismo directorio ejecuta el siguiente comando:
$ G ++ -O Hello -Shatic Hello.CCEsto crea un archivo ejecutable binario "hola" en el mismo directorio. Ese es nuestro archivo estático. Prueba si se ejecuta según lo previsto mencionando el nombre de archivo en el terminal.
ps ./HolaAhora estamos listos para contenedores este programa simple.
Dockfile
DockerFile consta de un conjunto de reglas que toma sus archivos de aplicación (como binarios, archivos de origen, etc.) junto con varios parámetros de configuración como diseño del sistema de archivos, puertos expuestos, etc. y los convierte en un archivo de imagen Docker. Luego puede compartir el archivo de imagen con cualquiera que quiera ejecutar esa aplicación.
No estaremos cavando en todas las opciones disponibles para DockerFile, en su lugar escribiremos un Dockerfile muy minimalista. En el mismo directorio, donde reside su ejecutable de hola, cree un archivo vacío nombrado Dockfile.
$ touch dockerfile
Ábralo con tu editor de texto favorito y escriba las siguientes líneas:
Desde ceroAgregar hola /
CMD ["/Hello"]
rascar no es una imagen de los padres. Más bien indica Docker que la imagen no está construida sobre ninguna otra imagen. Está construido desde cero. Agregar comando tomaría el binario estático nombrado HolaDesde el directorio actual y agréguelo al directorio raíz del archivo de imagen. Cuando finalmente ejecutaríamos un contenedor basado en esta imagen, el ejecutable Hello se verá dentro del directorio raíz en sí mismo en /Hola.
Por último, la línea CMD tiene una cadena "/Hola" Esta cadena se ejecutará como un comando shell cada vez que se cree un contenedor a partir de esta imagen, por lo tanto, el archivo binario que agregamos a nuestro contenedor e imprime el mensaje que escribimos en nuestra aplicación.
Construyamos la imagen invocando el Docker Build comando que pasaría por el contenido del Dockerfile y generaría la imagen. Ejecute el siguiente comando en el mismo directorio que DockerFile y el binario ejecutable.
$ Docker Build -Tag Hello .
El -Etiqueta hola la bandera establece el nombre de la imagen en Hola y el punto ( ".") al final dice Docker Build buscar el directorio actual de DockerFile y contenido relacionado.
Ejecutando el contenedor Docker
Para verificar si la imagen que acabamos de crear aparece en la lista de imágenes, ejecute:
$ Docker Imágenes
Observe qué tan pequeña es la imagen de hola en comparación con otras imágenes. En cualquier caso, está listo para ejecutarse como contenedor,
$ Docker Run Hello
Eso es todo! Creaste tu primer contenedor minimalista desde cero.
Otras opciones
Si bien crear imágenes desde cero es siempre una opción, las personas a menudo tienden a crear imágenes de otras distribuciones livianas de Linux. Por ejemplo, las imágenes como Alpine y Busybox son entornos realmente livianos con bibliotecas más pequeñas como Musl en lugar de GLIBC.
Usarlos como su imagen principal usando "De Alpine: Último" resultaría en imágenes más pequeñas también. Dado que las imágenes base tienen solo 2-5 MB de tamaño. Háganos saber si hay algún tema relacionado con Docker que quiera que cubramos a continuación. Puede comunicarse con nosotros en Twitter, Facebook o suscribirse a nosotros por correo electrónico.