Curso práctico de Docker y Microservicios (apto para todos)

Veamos cuál es la diferencia entre Contenedores e Imágenes. Así mismo qué es un Dockerfile, un Registry, y Docker Hub.

Contenedores Linux funcionan sobre Linux. ¿Pero qué hacemos si usamos Windows o Mac? Veamos una primera alternativa de solución.

Si tu máquina virtual no se expande a pantalla completa, lo puedes solucionar usando "Guest Additions".

Veamos cómo instalar Docker en Linux. Específicamente en Ubuntu. Y verifiquemos finalmente la instalación ejecutando nuestro primer contenedor.

En esta lección vemos qué alternativas tenemos para trabajar con Docker en Windows. Así mismo, vemos qué son los Windows Containers y cómo operan, a diferencia de los Linux Containers. Finalmente, revisamos las diferencias entre VirtualBox y Hyper-V.

En esta lección vemos qué alternativas tenemos para trabajar con Docker en Mac.

En esta lección vemos un resumen de los comandos básicos principales. Los mismos que estaremos usando en este módulo.

Veamos de forma práctica cómo crear, listar y eliminar contenedores; y así mismo cómo listar y eliminar imágenes.

En esta lección continuamos revisando los comandos básicos que listamos al inicio de este módulo. Vemos cómo descargar una imagen, cómo detener un contenedor, y cómo ejecutar un comando sobre un contenedor activo.

Esta lección no está relacionada directamente al uso de Docker. Sin embargo, es importante para tener una mejor idea de cómo surgen los scripts que vamos a usar en la construcción de imágenes posteriormente. Aquí creamos un primer script Bash que actúa como un contador hasta el infinito.

Ya que estamos con Bash, aprovechamos para crear un segundo script, que pregunta al usuario por datos, captura los valores de entrada, y los muestra. Este script genera un mensaje de saludo simple con el nombre del usuario.

Veamos por qué es conveniente y útil construir imágenes. Y cómo es el proceso en términos generales, haciendo uso de un Dockerfile.

Veamos cómo construir nuestra primera imagen usando el comando "docker build". Partimos de una imagen base, copiamos nuestro script y por último definimos un comando por defecto con el cuál se iniciarán nuestros contenedores.

En esta lección cometemos un error en nuestro Dockerfile pero volvemos a construir la imagen con el mismo tag para solucionarlo. Con esto, tenemos ya 2 imágenes construidas, una por cada script Bash que definimos en lecciones previas.

Veamos cómo podemos subir nuestras imágenes a Docker Hub, haciendo uso del comando "docker push".

Veamos cómo podemos iniciar un contenedor en Detached mode, cuál es la diferencia entre foreground y background, cómo detener un contenedor inmediatamente, y cómo hacer uso del comando docker attach.

Veamos cómo conectar la terminal de nuestro host con la de nuestro contenedor, y así mismo cómo iniciar un contenedor en modo interactivo, a fin de enlazar los valores de entrada (STDIN).

En esta lección vemos cómo publicar los puertos de un contenedor, al asociarlos con puertos de nuestro host. A modo de práctica iniciamos contenedores de servidores web, tales como Apache y Nginx.

Antes creamos 2 contenedores, correspondientes a Nginx y Apache. En esta lección vemos cómo conectarnos a tales contenedores que ya están en ejecución, a fin de modificar archivos ubicados al interior de ellos.

Cuando hacemos pruebas, podemos iniciar muchos contenedores, y es muy probable que queramos eliminarlos al final. Veamos cómo iniciar un contenedor de modo que se elimine automáticamente al detenerse.

Veamos cuál es la diferencia entre docker attach y docker exec, y por qué usamos uno en vez del otro para conectarnos por consola a nuestro contenedor de Nginx.

En esta lección vemos cómo podemos montar un volumen, es decir, compartir una carpeta de nuestro host con un contenedor. También vemos cómo podemos usar docker inspect sobre los contenedores para ver información detallada sobre ellos.

En esta lección vemos cómo eliminar de forma práctica todos los contenedores. También vemos cómo podemos usar los resultados de un comando como parte de otro.

En esta lección vemos cómo iniciar contenedores, declarando variables de entorno sobre los mismos, a fin de personalizar sus características.

En esta lección revisamos algunas ideas sobre cómo organizarnos a fin de escribir un Dockerfile, y así crear nuestras propias imágenes, correspondientes a cualquier proyecto que nos interese compartir.

Continuando con nuestro ejemplo, ahora seleccionamos la imagen base que usaremos. A modo de repaso usamos docker run con algunos flags, y docker exec.

¿Cómo podemos asociar puertos de un contenedor con nuestro host si el contenedor ya está ejecutándose? ¿Cómo podemos salvar cambios realizados sobre un contenedor que está en ejecución? ¿Es posible crear imágenes sin un Dockerfile?

Recordemos siempre usar versiones específicas: para nuestra imagen base, para el software y paquetes que instalamos, además de las dependencias específicas de nuestro proyecto a nivel de aplicación.

En esta lección definimos una vista (template), y pasamos una primera variable desde backend, definida en nuestro código Python. Luego haremos lo mismo leyendo los valores desde variables de entorno.

En esta lección leemos 2 variables de entorno en nuestro código Python, y usamos tales valores para cambiar el comportamiento de nuestra aplicación web.

Si bien ambos permiten construir imágenes, ¿cuál es recomendable?

¿Es posible copiar archivos y/o carpetas de un contenedor al host y/o viceversa sin usar volúmenes? Sí, y en esta lección vemos cómo hacer ello.

En esta lección definimos nuestro Dockerfile, usando las instrucciones FROM, RUN, COPY, WORKDIR y CMD.

Veamos cómo consultar los mensajes de log generados por un contenedor.

Con nuestra imagen lista, creamos N contenedores, todos personalizados de manera distinta gracias a las variables de entorno que soporta. También hacemos algunas conclusiones de forma general, según lo visto en este módulo.

Veamos cómo renombrar una imagen usando "docker tag", y cómo compartir una imagen construida.

En esta lección subimos a un repositorio remoto los ejemplos que llevamos desarrollando en el curso, para que estén al alcance de todos.

Compartir imágenes está bien. ¿Pero qué hacen los contenedores que se inician a partir de ellas?

Docker consta de 3 componentes principales, veamos cuáles son. Así mismo, veamos cómo funcionan los contenedores gracias a namespaces, control groups y union file systems.

En esta lección vemos cómo Docker gestiona las capas de imágenes y contenedores, usando una estrategia llamada CoW. Y así mismo, los tipos de volúmenes que podemos montar para persistir los cambios realizados en nuestros contenedores.

Veamos qué tipos de networks usa Docker y en qué se diferencian. Además de cómo podemos definir nuestras propias networks y asociar contenedores a ellas.

En esta lección vemos qué son y cómo funcionan los registros de imágenes. Y así mismo que Docker Hub no es el único Docker Registry que existe.

En esta lección hacemos un repaso general de los conceptos que hemos visto hasta ahora, y luego proponemos un ejercicio que involucra interacción entre contenedores de distintas imágenes.

Veamos cómo hacer uso de un Dockerfile para construir una imagen basada en Node y que contenga nuestra aplicación web.

Veamos cómo ejecutar un contenedor a partir de la imagen que hemos creado, y qué opciones podemos usar junto al comando docker run.

En esta lección vemos cómo crear una Network, y cómo iniciar un contenedor de Mongo DB, de tal manera que luego podamos conectarnos desde nuestra app Node y desde Mongo Express.

En esta lección iniciamos un contenedor de Mongo Express, sobre la Network que creamos anteriormente, y exponemos un puerto, para conectarnos a la UI desde nuestro navegador, y crear una primera base de datos y colección en Mongo DB.

En esta lección terminamos de levantar todos nuestros contenedores y vemos nuestra aplicación Node funcionando correctamente en nuestro navegador. Sin embargo, surge la interrogante de cómo automatizar todos los pasos que hemos seguido.

En esta lección vemos qué es YAML y cómo es el formato para un archivo de docker compose. Los comandos que escribimos anteriormente son resumidos en un único archivo a fin de luego iniciar todo con un solo comando.

Ahora vemos cómo hacer uso del comando docker-compose up para construir nuestra imagen e iniciar todos nuestros contenedores con las opciones indicadas.

Veamos qué es Container Orchestration, y por qué es importante hacer uso de herramientas como Docker Swarm y Kubernetes (que permiten orquestar contenedores y hosts).

Introducción general de qué es y cómo se usa Docker Swarm.

Introducción general de qué es y cómo se usa Kubernetes.