Hablando libremente, Docker se está convirtiendo cada vez más en un administrador de paquetes universal que funciona en todas las plataformas Linux posibles. Toma contenedores y los usa para resolver un problema completamente diferente al que se 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 venga empaquetada como una imagen de Docker. El trabajo de Docker es tomar esta imagen y ejecutarla como una aplicación en 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 del portátil del desarrollador e incluso del servidor de producción. Siempre que ambos sean compatibles con Docker, ambos pueden ejecutar la misma aplicación exactamente de la misma manera.
Anatomía de una imagen de Docker
Como se mencionó anteriormente, una aplicación de 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 se crean a partir de capas de software. Una imagen de contenedor de wordpress se crea utilizando una imagen de contenedor httpd que, a su vez, se construye sobre una imagen de Ubuntu. La imagen sobre la que se construye una imagen más nueva se conoce como IMAGEN PADRE en la terminología de Docker. En Dockerfile (llegaremos a lo que significa un Dockerfile, un poco más adelante), esta imagen principal se menciona en la parte superior del archivo como se muestra a continuación:
DESDE 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 enviar 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 ejecutarán como si fuera un sistema Ubuntu en el que se estén ejecutando.
Es posible que haya notado esto al intentar extraer una nueva imagen de la ventana acoplable.
Esto muestra cuántas capas se extraen antes de que se ingrese la aplicación real (que puede tener solo unos pocos megabytes de tamaño).
Por este motivo, nos gustaría crear lo que se conoce como imagen base. Que no se construye encima de nada más. La palabra clave scratch se usa para indicar que esta capa no se construye encima de ninguna otra cosa. Al igual que:
Desde cero## Resto del Dcokerfile
Primero crearemos una aplicación simple de hola-mundo y luego averiguaremos cuál será el resto del Dockerfile. El sistema host es Ubuntu: 18.04 LTS y estamos usando la versión 17.12.1-ce de Docker 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. Con lo único que está en contacto ese proceso es con el Kernel. Kernel es responsable de programar estos procesos en la CPU, realizar la gestión de la memoria y algunas otras tareas básicas de mantenimiento de reservas.
Pero la mayoría de las aplicaciones de alto nivel dependen de muchas bibliotecas del sistema (como glibc, musl, klibc, etc. ) y muchas dependencias de tiempo de ejecución como Python o Node.js o Java Runtime. El binario de la aplicación no tiene todas las bibliotecas disponibles en su interior, pero cuando comienza la ejecución, llama a esas bibliotecas desde el sistema operativo host.
Debido a que estamos tratando de crear una imagen desde cero, no obtendríamos estas sutilezas. Entonces, nuestra aplicación debe ser un archivo estático o un ejecutable independiente.
Comencemos creando una carpeta llamada MyDockerImage y creando un archivo hello.cc dentro de ella.
$mkdirMyDockerImage$cdMyDockerImage
$tocarhello.cc
Abra hello.cc con su editor de texto favorito y agregue las siguientes líneas en su interior.
#incluirusando el espacio de nombres std;
En tprincipal(){
costo<< '¡Hola! Este mensaje proviene de un contenedor orte';
regreso 0;
}
Este es un programa simple de C ++ que imprime ¡Hola! Este mensaje …
Por las razones discutidas anteriormente, compilaremos esto usando la bandera estática. El compilador que se utiliza es g ++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.
Para compilar el programa, en el mismo directorio ejecute el siguiente comando:
$ g++ -o hola-estáticoHola.ccEsto crea un archivo ejecutable binario hola en el mismo directorio. Ese es nuestro archivo estático. Pruebe si se está ejecutando según lo previsto mencionando el nombre del archivo en la terminal.
$ ./Hola 
Ahora estamos listos para contener este sencillo programa.
Dockerfile
El Dockerfile consiste en un conjunto de reglas que toma los archivos de su aplicación (como binarios, archivos fuente, 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 cualquier persona que desee ejecutar esa aplicación.
No profundizaremos en todas las opciones disponibles para Dockerfile, sino que escribiremos un Dockerfile muy minimalista. En el mismo directorio, donde reside su ejecutable hello, cree un archivo vacío llamado Dockerfile.
$tocarDockerfileÁbrelo con tu editor de texto favorito y escríbele las siguientes líneas:
DESDE ceroAÑADIR hola/
CMD['/Hola']
rasguño no es una imagen de los padres. Más bien, indica a Docker que la imagen no está construida sobre ninguna otra imagen. Está construido desde cero. El comando ADD tomaría el binario estático llamado hello del directorio actual y lo agregaría al directorio raíz del archivo de imagen. Cuando finalmente ejecutemos un contenedor basado en esta imagen, el ejecutable hello se verá dentro del directorio raíz en /hello.
Por último, la línea CMD tiene una cadena /Hola esta cadena se ejecutará como un comando de 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 imprimirá el mensaje que escribimos en nuestra aplicación.
Construyamos la imagen invocando el compilación de docker 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.
$compilación de docker--etiquetaHola .los –Tag hola bandera establece el nombre de la imagen en Hola y el punto . ) al final dice compilación de docker para buscar en el directorio actual Dockerfile y contenidos relacionados.
Ejecutando el contenedor de Docker
Para comprobar si la imagen que acabamos de crear aparece en la lista de imágenes, ejecute:
$imágenes de docker 
Observe lo pequeña que es la imagen de saludo en comparación con otras imágenes. En cualquier caso, está listo para ser ejecutado como contenedor,
$Docker ejecutar hola 
¡Eso es todo! Creaste tu primer contenedor minimalista desde cero.
Otras opciones
Si bien la creación de imágenes desde cero siempre es una opción, las personas a menudo tienden a crear imágenes a partir de otras distribuciones ligeras de Linux. Por ejemplo, imágenes como alpine y busybox son entornos realmente ligeros con bibliotecas más pequeñas como musl en lugar de glibc.
Usándolos como su imagen principal usando DESDE alpine: último también daría como resultado imágenes más pequeñas. Dado que las imágenes base tienen un tamaño de solo 2-5 MB. Háganos saber si hay algún tema relacionado con Docker que desee que cubramos a continuación. Puede comunicarse con nosotros en Gorjeo , Facebook o suscríbete a nosotros por correo electrónico.