Esta es solo una demostración simple para obtener una comprensión básica de cómo funciona Docker mientras se trabaja paso a paso. Aprendí Docker de esta manera e hice este repositorio para resolver algunos problemas que enfrenté durante mi experiencia de aprendizaje para que pudiera ayudar a otros principiantes. Espero que disfrutes aprendiendo. Si te gusta, dale un GitHub y apoya mi trabajo.
Importante: - Al ver el tamaño del archivo Léame, es posible que lo pienses mejor pero, para ser honesto, si trabajas desde el principio no experimentarás ningún problema y aprenderás a lo largo del camino.
Wikipedia define Docker como
es un conjunto de productos de plataforma como servicio (PaaS) que utilizan virtualización a nivel de sistema operativo para entregar software en paquetes llamados contenedores. Los contenedores están aislados unos de otros y agrupan su software, bibliotecas y archivos de configuración; pueden comunicarse entre sí a través de canales bien definidos. Todos los contenedores se ejecutan mediante un único kernel de sistema operativo y, por lo tanto, utilizan menos recursos que las máquinas virtuales.
Docker le ayuda a implementar sus aplicaciones de manera más eficiente en un espacio aislado (llamado contenedores) para ejecutarlas en el sistema operativo host, es decir, Mac. La principal ventaja de Docker es que le permite empaquetar software con todas sus dependencias en una única unidad estandarizada.
El contenedor es una solución sobre cómo hacer que el software se ejecute sin problemas cuando se mueve de un entorno informático a otro. Esto podría ser desde un entorno de prueba a producción o tal vez desde una computadora portátil a otra computadora portátil diferente con otro sistema operativo.
Los contenedores proporcionan un mecanismo de empaquetado lógico en el que sus aplicaciones pueden abstraerse del entorno en el que se ejecutan. La principal diferencia es que cada contenedor no requiere su sistema operativo completo. Todos los contenedores en un único host comparten un único sistema operativo. Esto ayuda a liberar grandes cantidades de recursos del sistema, como CPU y RAM.
Una vez que haya terminado de instalar Docker, pruebe su instalación de Docker ejecutando lo siguiente:
docker run hello-world
Hello from Docker.
This message shows that your installation appears to be working correctly.
...Dockerfile es un documento de texto que contiene todos los comandos que puede llamar en la línea de comando para crear una imagen. Cree un archivo hello.js y copie este código en él. Aquí escribimos un código JS simple para mostrar Hello World en localhost:8888 . var http = require( " http " ) ;
http.createServer(function (request, response) {
response.writeHead(200, { ' Content-Type ' : ' text/plain ' }) ;
response.end( ' Hello Worldn ' ) ;
}).listen(8888) ;
// Console will print the message
console.log( ' Server running at http://127.0.0.1:8888/ ' ) ;Dockerfile y copie este código en él. FROM node:8
LABEL maintainer= " [email protected] "
RUN npm install
ADD hello.js /hello.js
EXPOSE 8888
ENTRYPOINT [ " node " , " hello.js " ]Incluso si este es el primer Dockerfile que ve, diría que puede adivinar lo que está sucediendo aquí. Las instrucciones de Dockerfile son FROM, ENV, LABEL, RUN, ADD, EXPOSE y ENTRYPOINT; están en mayúsculas, pero eso es una convención, no un requisito.
En un nivel alto, este Dockerfile brinda instrucciones como comenzar con la imagen del nodo, agregar “[email protected]” como mantenedor, ejecutar npm install para instalar dependencias, copiar el archivo en el código de la aplicación, documentar el puerto de red de la aplicación, y configure hello.js como la aplicación predeterminada para ejecutar.
Ahora crearemos una imagen de Docker en nuestra máquina local. Abra su terminal en la carpeta del proyecto actual y ejecute
docker build -t helloworld . Aquí le estás indicando a Docker que cree una imagen llamada helloworld basada en el contenido del directorio actual (nota el punto (.) al final del comando de compilación). Docker buscará el Dockerfile en el directorio y creará la imagen según las instrucciones del archivo.
Después de crear la imagen de la ventana acoplable, el siguiente paso sería ejecutar la imagen y ver si funciona:
docker run -p 8888:8888 helloworldEl comando que acabamos de ejecutar utilizó el puerto 8888 para el servidor dentro del contenedor y lo expuso externamente en el puerto 8888. Dirígete a la URL con el puerto 8888:
¡Felicitaciones! Ha creado con éxito su primera imagen acoplable.
Las imágenes de Docker son como plantillas de máquinas virtuales y se utilizan para iniciar contenedores. Debajo del capó, se componen de una o más capas de solo lectura que, cuando se apilan, forman la imagen general. Docker se encarga de apilar estas capas y representarlas como un único objeto unificado. Nota: Las imágenes de Docker son inmutables, lo que significa que las imágenes de Docker nunca pueden cambiar. Una vez que haya creado uno, puede eliminarlo, pero no modificarlo.
La imagen de Docker contiene todos los archivos que empaquetó, que se convierten en el sistema de archivos del contenedor, y también contiene muchos metadatos sobre la imagen misma. Eso incluye una breve historia de cómo se construyó la imagen. Puede usarlo para ver cada capa de la imagen y el comando que creó la capa. Puede consultar el historial de la imagen helloworld utilizando:
docker image history helloworld
IMAGE CREATED CREATED BY COMMENT
cb84eb33ca20 58 seconds ago /bin/sh -c # (nop) ENTRYPOINT ["node" "hello…
7d652a817a9f 58 seconds ago /bin/sh -c # (nop) EXPOSE 8888
334575e947c9 59 seconds ago /bin/sh -c # (nop) ADD file:b9606ef53b832e66e… Los comandos CREATED BY son las instrucciones de Dockerfile; existe una relación uno a uno, por lo que cada línea en Dockerfile crea una capa de imagen.
Primero, debe iniciar sesión con su cuenta de Dockerhub mediante
docker login --username $dockerIdAhora que ha iniciado sesión, puede enviar imágenes a su cuenta o a cualquier organización a la que tenga acceso. Si no es miembro de ninguna organización, solo puede enviar imágenes a los repositorios de su cuenta.
Creamos una imagen de Docker llamada helloworld . Esa referencia de imagen no tiene un nombre de cuenta, por lo que no podemos enviarla a ningún registro. No necesitamos reconstruir la imagen para darle una nueva referencia, las imágenes pueden tener varias referencias. Etiqueta tu imagen así:
docker image tag helloworld $dockerId /helloworld:v1Ahora tenemos una referencia de imagen con nuestra ID de Docker en el nombre de la cuenta e iniciamos sesión en Docker Hub para estar listos para compartir nuestra imagen. El comando docker image push es la contraparte del comando pull, carga nuestras capas de imágenes locales en el registro:
docker image push championshuttler/helloworld:v1
The push refers to a repository [docker.io/championshuttler/helloworld]
9519a21ac374: PushedPodemos poner cualquier cadena en una etiqueta de imagen de Docker y, como ya hemos visto, puedes tener varias etiquetas para la misma imagen. Lo usaremos para versionar el software en nuestras imágenes y permitir que los usuarios tomen decisiones informadas sobre lo que no usarán, y para tomar nuestras propias decisiones informadas cuando usemos imágenes de otras personas.
Muchos proyectos de software utilizan un esquema de control de versiones numérico con puntos decimales para indicar qué tan grande es el cambio entre versiones, y puedes seguirlo con tus etiquetas de imagen. La idea básica es algo así como [mayor].[menor].[parche], que tiene algunas garantías implícitas. Una versión que sólo incrementa el número de parche puede tener correcciones de errores, pero debería tener las mismas características que la última versión; una versión que incrementa la versión secundaria puede agregar funciones pero no debería eliminar ninguna; una versión importante podría tener características completamente diferentes.
La mayoría de las aplicaciones no se ejecutan en un solo componente. Incluso las aplicaciones antiguas de gran tamaño suelen crearse como componentes de front-end y back-end, que son capas lógicas separadas que se ejecutan en componentes distribuidos físicamente. Docker es ideal para ejecutar aplicaciones distribuidas, desde monolitos de n niveles hasta microservicios modernos. Cada componente se ejecuta en su contenedor liviano y Docker los conecta utilizando protocolos de red estándar. Usted define y administra aplicaciones de múltiples contenedores como esta usando Docker Compose. Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker de múltiples contenedores. Con Compose, utiliza un archivo YAML para configurar los servicios de su aplicación. Luego, con un solo comando, creamos e iniciamos todos los servicios desde su configuración.
El archivo Docker Compose describe el estado deseado de su aplicación: cómo debería verse cuando todo se esté ejecutando. Es un formato de archivo simple en el que captura todas las opciones que colocaría en su contenedor acoplable y ejecuta comandos en el archivo Compose. Luego usa la herramienta Docker Compose para ejecutar la aplicación. Determina qué recursos de Docker necesita (que podrían ser contenedores, redes o volúmenes) y envía solicitudes a la API de Docker para crearlos. El nombre predeterminado para el archivo Compose YAML es docker-compose.yml . Sin embargo, podemos usar el indicador -f para especificar nombres de archivos personalizados.
Empecemos.
Debajo del código se muestra un archivo Docker Compose muy simple que define una pequeña aplicación Flask con dos servicios (web-frontend y redis). La aplicación es un servidor web simple que cuenta el número de visitas y almacena el valor en Redis.
version: " 3.5 "
services:
web-frontend:
build: .
command: python app.py
ports:
- target: 8888
published: 8888
networks:
- counter-net
volumes:
- type: volume
source: counter-vol
target: /code
redis:
image: " redis:alpine "
networks:
counter-net:
networks:
counter-net:
volumes:
counter-vol: La clave version es necesaria y siempre debe estar en la primera línea del archivo. Esto explica la versión del formato Compose file (básicamente la API).
La clave services de nivel superior es donde definimos los diferentes servicios de la aplicación. El ejemplo que estamos usando define dos servicios; una interfaz web llamada web-frontend y una base de datos en memoria llamada Redis. Compose implementará cada uno de estos servicios como su contenedor.
La clave networks de nivel superior le indica a Docker que cree nuevas redes. De forma predeterminada, Compose creará redes puente. Estas son redes de un solo host que solo pueden conectar contenedores en el mismo host.
Dentro de la definición del servicio web-frontend, le damos a Docker las siguientes instrucciones:
Implementaremos la aplicación definida en el archivo Redactar de la sección anterior. Para hacer esto, necesitará los siguientes 4 archivos de https://github.com/championshuttler/counter-app:
Clona el repositorio de Git localmente.
git clone https://github.com/championshuttler/counter-app.gitDescribamos rápidamente cada archivo:
app.py es el código de la aplicación (una aplicación Python Flask).docker-compose.yml es el archivo Docker Compose que describe cómo Docker debe implementar la aplicación.Dockerfile describe cómo crear la imagen para el servicio de interfaz web.requirements.txt enumera los paquetes de Python necesarios para la aplicación. Usemos Compose para abrir la aplicación. Debe ejecutar todos estos comandos siguientes desde el directorio de counter-app :
docker-compose up &La aplicación tardará unos segundos en aparecer y el resultado puede ser bastante detallado.
Con la aplicación implementada correctamente, puede apuntar un navegador web a su host Docker en port 5000 y ver la aplicación en todo su esplendor.
¿El tutorial te pareció un completo desastre o te divertiste y aprendiste algo? Envíame tus pensamientos directamente o simplemente crea un problema. Encuéntrame también en Twitter, no dudes en preguntar si tienes alguna duda.
Me encantaría conocer tu experiencia con este tutorial. Espero que hayas disfrutado aprendiendo. Si te gusta, dale un comentario en GitHub y apoya mi trabajo.
