Saltar a contenido

Ejercicios · Infra · Docker Compose y Swarm

De un servicio suelto a varios que se levantan juntos, y de una máquina a un clúster. Los apartados van en el orden de la sesión y todos se resuelven en el navegador. Las cifras y las trazas son las de la sesión: el contador que sube entre dos peticiones, la columna de puertos que distingue lo publicado de lo que solo se alcanza por dentro, lo que queda en el disco después de bajar el sistema, el reparto de tres réplicas entre tres nodos y los lotes de una actualización progresiva. Antes de ver un número hay que escoger uno, y cada respuesta equivocada dice por qué no.

Volúmenes y redes

Los dos mecanismos sobre los que se apoya todo lo demás ya tienen su ejercicio en la sesión anterior, y aquí se vuelven a usar tal cual.

Lo que sobrevive al contenedor

La capa escribible que nace y muere con el contenedor, el volumen que no, y la base de datos que amanece vacía cuando nadie montó nada.

Quién alcanza a quién

Siete ping entre tres contenedores repartidos en dos redes, con los dos modos distintos de fallar: el nombre que nadie traduce y el paquete que sale y no llega.

Fundamentos de Compose

De tres docker run a un archivo

Qué clave del compose.yml reemplaza a cada bandera de la línea de órdenes, y por qué en docker compose ps la base y la caché muestran su puerto sin ninguna dirección delante mientras el servicio web sí publica. Cierra con las dos peticiones y lo que prueba cada dato: el contador que pasa de 1 a 2, el db_ok en verdadero y la dirección que aparece en la última línea del log.

Anatomía del compose.yml

Las cuatro secciones de raíz y qué va en cada una, y el error que más se comete: confundir la lista de referencias que va dentro de un servicio con la definición que tiene que estar en la raíz. Termina contando cuántos contenedores deja un archivo de tres servicios y de dónde sale el número con que Compose los nombra.

depends_on y lo que de verdad espera

Las tres condiciones y cuándo va cada una. El centro del ejercicio es por qué depends_on a secas ordena la creación y nada más, de modo que la base arranca primero y el servicio web ya está pidiendo cuando PostgreSQL todavía no acepta conexiones. Con el healthcheck del ejemplo hay que calcular en cuánto tiempo se da por caído.

Operación con Compose

El ciclo del día a día

Las nueve órdenes que se usan todo el tiempo, clasificadas entre las que solo miran y las que crean, paran o borran. Después, lo que de verdad hay que tener claro antes de escribir down: cuántas filas quedan en la base al volver a levantar el sistema, qué se lleva down -v y por qué el contador de la caché no corre la misma suerte que la tabla.

Escalar sin balanceador

Cuántos contenedores deja --scale web=3, por qué la orden falla cuando el servicio fija un puerto del anfitrión, y el límite que importa: Compose levanta las réplicas y no reparte el tráfico entre ellas. Cierra con cuántos servicios recrea un up -d después de editar una sola parte del archivo.

Introducción a Docker Swarm

El clúster: manager y worker

Qué resuelve el clúster que Compose plano no, y el reparto de responsabilidades entre quien decide y quien ejecuta, incluidas las que son de los dos. Con la salida de docker swarm init en una sola máquina: por qué ese nodo solitario ya aparece como líder y de dónde sacó la dirección que anuncia.

Servicios distribuidos en Swarm

Tres réplicas y un solo puerto

Qué cuenta la columna 3/3 y qué se lee mientras una tarea arranca, cómo el planificador repartió las tres tareas entre los tres nodos sin que nadie se lo pidiera, y la diferencia que separa esto de --scale: el puerto es del servicio y responde en todos los nodos, no de la réplica.

La actualización, lote por lote

Con seis réplicas y dos por lote, cuántos lotes salen y cuánto suma la espera. Hay que seguir la traza momento a momento contando cuántas tareas conviven, que es lo que cambia entre arrancar la nueva antes de parar la vieja y hacerlo al revés, y decidir qué ocurre cuando el segundo lote no sirve.