Cómo usar el comando docker compose alpha scale para escalar servicios

Introducción

En este laboratorio, aprenderás a utilizar el comando docker compose alpha scale para escalar servicios definidos en un proyecto de Docker Compose. Comenzaremos preparando un proyecto simple de Docker Compose, que incluye la instalación de Docker Compose, la creación de una aplicación web básica y la definición de su Dockerfile y dependencias.

Después de configurar el proyecto, explorarás cómo escalar un único servicio utilizando docker compose alpha scale, escalar múltiples servicios simultáneamente y escalar un servicio sin iniciar sus dependencias. Esta experiencia práctica demostrará la flexibilidad y potencia del comando scale para gestionar el número de instancias en ejecución de tus servicios.

Skills Graph

Preparar un proyecto simple de Docker Compose

En este paso, prepararemos un proyecto simple de Docker Compose. Como Docker Compose no viene preinstalado en el entorno de LabEx, primero lo instalaremos. Luego, crearemos una aplicación web sencilla y un archivo de Docker Compose para definirla y ejecutarla.

Primero, instalemos Docker Compose. Descargaremos el binario de Docker Compose y lo haremos ejecutable.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Ahora, verifiquemos la instalación comprobando la versión de Docker Compose.

docker-compose --version

Deberías ver la versión instalada de Docker Compose en la salida.

A continuación, crearemos una aplicación web simple. Usaremos una aplicación básica de Python Flask. Crea un directorio para nuestro proyecto y accede a él.

mkdir my-web-app
cd my-web-app

Dentro del directorio my-web-app, crea un archivo llamado app.py con el siguiente contenido:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Docker Compose!'

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0')

Esta es una aplicación simple de Flask que devuelve "Hello, Docker Compose!" cuando se accede a ella.

Ahora, necesitamos un Dockerfile para construir una imagen Docker para nuestra aplicación Flask. Crea un archivo llamado Dockerfile en el directorio my-web-app con el siguiente contenido:

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["python", "app.py"]

Este Dockerfile utiliza una imagen ligera de Python 3.9, establece el directorio de trabajo, copia e instala las dependencias de requirements.txt, copia el código de la aplicación, expone el puerto 5000 y especifica el comando para ejecutar la aplicación.

También necesitamos un archivo requirements.txt para la dependencia de Flask. Crea un archivo llamado requirements.txt en el directorio my-web-app con el siguiente contenido:

Flask==2.2.2

Finalmente, crearemos un archivo docker-compose.yml para definir nuestro servicio. Crea un archivo llamado docker-compose.yml en el directorio my-web-app con el siguiente contenido:

version: "3.8"

services:
  web:
    build: .
    ports:
      - "5000:5000"

Este archivo docker-compose.yml define un servicio llamado web. Indica a Docker Compose que construya la imagen usando el Dockerfile en el directorio actual (.) y mapee el puerto 5000 del host al puerto 5000 del contenedor.

Ahora, construyamos y ejecutemos el servicio usando Docker Compose. Asegúrate de estar en el directorio ~/project/my-web-app.

docker-compose up -d

Este comando construye la imagen (si no está ya construida), crea un contenedor para el servicio web y lo inicia en modo desatendido (-d).

Puedes comprobar si el contenedor está en ejecución usando el comando docker ps.

docker ps

Deberías ver un contenedor para el servicio my-web-app-web-1 en ejecución.

Para verificar que la aplicación funciona, puedes acceder a ella usando curl.

curl http://localhost:5000

Deberías ver la salida "Hello, Docker Compose!".

Escalar un servicio usando docker compose alpha scale

En este paso, aprenderemos cómo escalar un servicio usando el comando docker compose alpha scale. Escalar un servicio significa aumentar o disminuir el número de instancias en ejecución (contenedores) para ese servicio. Esto es útil para manejar mayor carga o para alta disponibilidad.

El comando docker compose alpha scale te permite establecer el número deseado de réplicas para un servicio específico. El subcomando alpha indica que esta es una característica más reciente en Docker Compose.

Asegúrate de estar en el directorio ~/project/my-web-app donde se encuentra tu archivo docker-compose.yml.

Actualmente, tenemos una instancia del servicio web en ejecución. Podemos verificarlo listando los contenedores en ejecución y filtrando por el nombre del servicio.

docker ps --filter "name=my-web-app-web"

Deberías ver solo un contenedor listado.

Ahora, escalemos el servicio web a 3 instancias. Usaremos el comando docker compose alpha scale seguido del nombre del servicio y el número deseado de réplicas.

docker compose alpha scale web=3

Este comando iniciará dos nuevos contenedores para el servicio web, llevando el número total de instancias a 3.

Después de ejecutar el comando, puedes verificar nuevamente los contenedores en ejecución para ver las instancias escaladas.

docker ps --filter "name=my-web-app-web"

Ahora deberías ver tres contenedores listados, cada uno con un ID y nombre diferente (ej. my-web-app-web-1, my-web-app-web-2, my-web-app-web-3).

El comando docker compose alpha scale es una forma conveniente de ajustar dinámicamente el número de réplicas del servicio sin modificar el archivo docker-compose.yml y volver a ejecutar docker compose up.

Para reducir el escalado del servicio, puedes usar el mismo comando con un número menor. Por ejemplo, para volver a 1 instancia:

docker compose alpha scale web=1

Esto detendrá y eliminará los contenedores adicionales, dejando solo una instancia en ejecución.

Escalemos nuevamente a 3 instancias para el siguiente paso.

docker compose alpha scale web=3

Escalar múltiples servicios simultáneamente

En este paso, aprenderemos cómo escalar múltiples servicios al mismo tiempo usando el comando docker compose alpha scale. Esto es útil cuando tienes varios servicios en tu aplicación que necesitan escalarse juntos para manejar mayor carga o mantener una arquitectura balanceada.

Para demostrarlo, agreguemos otro servicio simple a nuestro archivo docker-compose.yml. Crearemos un servicio Nginx básico que sirva contenido estático.

Primero, crea un directorio para el contenido estático de Nginx.

mkdir static

Dentro del directorio static, crea un archivo HTML simple llamado index.html con el siguiente contenido:

<!doctype html>
<html>
  <head>
    <title>Static Content</title>
  </head>
  <body>
    <h1>Hello from Nginx!</h1>
  </body>
</html>

Ahora, actualicemos el archivo docker-compose.yml en el directorio ~/project/my-web-app para incluir el servicio Nginx. Abre el archivo docker-compose.yml usando nano.

nano docker-compose.yml

Agrega la siguiente definición de servicio debajo del servicio web:

nginx:
  image: nginx:latest
  ports:
    - "80:80"
  volumes:
    - ./static:/usr/share/nginx/html

El archivo docker-compose.yml actualizado debería verse así:

version: "3.8"

services:
  web:
    build: .
    ports:
      - "5000:5000"

  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./static:/usr/share/nginx/html

Esto agrega un servicio nginx que usa la imagen nginx:latest, mapea el puerto 80 del host al puerto 80 del contenedor, y monta el directorio ./static en la raíz web predeterminada de Nginx (/usr/share/nginx/html).

Guarda el archivo docker-compose.yml y sal de nano (Ctrl+X, Y, Enter).

Ahora, iniciemos el nuevo servicio. Como modificamos el archivo docker-compose.yml, necesitamos ejecutar docker compose up nuevamente. El flag -d ejecuta los contenedores en modo desatendido.

docker compose up -d

Docker Compose creará e iniciará el servicio nginx. El servicio web ya debería estar en ejecución del paso anterior.

Puedes verificar que ambos servicios estén ejecutándose usando docker ps.

docker ps

Deberías ver contenedores para my-web-app-web-1, my-web-app-web-2, my-web-app-web-3 y my-web-app-nginx-1.

Ahora, escalemos el servicio web a 5 instancias y el servicio nginx a 2 instancias simultáneamente. Podemos hacer esto listando los servicios y sus conteos de réplicas deseados en el comando docker compose alpha scale.

docker compose alpha scale web=5 nginx=2

Este comando escalará el servicio web a 5 instancias y el servicio nginx a 2 instancias.

Después de ejecutar el comando, verifica nuevamente los contenedores en ejecución.

docker ps

Ahora deberías ver 5 contenedores para el servicio web y 2 contenedores para el servicio nginx.

Esto demuestra cómo puedes escalar múltiples servicios con un solo comando docker compose alpha scale, haciéndolo eficiente para gestionar el escalado de los componentes de tu aplicación.

Escalar un servicio sin iniciar sus dependencias

En este paso, exploraremos cómo escalar un servicio específico usando docker compose alpha scale sin iniciar sus dependencias. Por defecto, cuando escalas un servicio, Docker Compose podría también iniciar o asegurar que sus dependencias estén en ejecución. Sin embargo, existen escenarios donde podrías querer escalar solo un servicio sin afectar a los demás.

Para ilustrar esto, agreguemos una dependencia a nuestro servicio web. Añadiremos un servicio de base de datos simple, aunque no implementaremos lógica de base de datos en nuestra aplicación web para este ejemplo. Esto es solo para demostrar el concepto de dependencia.

Abre el archivo docker-compose.yml en el directorio ~/project/my-web-app usando nano.

nano docker-compose.yml

Agrega una nueva definición de servicio para una base de datos (ej. una imagen simple de postgres) y añade una sección depends_on al servicio web.

version: "3.8"

services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db

  nginx:
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./static:/usr/share/nginx/html

  db:
    image: postgres:latest
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydatabase

El archivo docker-compose.yml actualizado ahora incluye un servicio db usando la imagen postgres:latest y el servicio web tiene una línea depends_on: - db, indicando que el servicio web depende del servicio db.

Guarda el archivo docker-compose.yml y sal de nano (Ctrl+X, Y, Enter).

Ahora, iniciemos los servicios con la configuración actualizada.

docker compose up -d

Docker Compose ahora también creará e iniciará el servicio db porque el servicio web depende de él.

Puedes verificar que todos los servicios estén ejecutándose usando docker ps.

docker ps

Deberías ver contenedores para web, nginx y db.

Ahora, digamos que queremos escalar solo el servicio web a 4 instancias sin iniciar o afectar el servicio db (si no estaba ya en ejecución). El comando docker compose alpha scale, por defecto, respeta las dependencias. Sin embargo, para este escenario específico donde queremos escalar solo el servicio especificado, el comando estándar docker compose alpha scale es suficiente ya que se enfoca principalmente en el servicio objetivo. La relación depends_on afecta principalmente el orden de inicio cuando se usa docker compose up. Al usar docker compose alpha scale, se enfoca en ajustar el número de instancias para el servicio especificado.

Escalemos el servicio web a 4 instancias.

docker compose alpha scale web=4

Este comando escalará el servicio web a 4 instancias. No iniciará explícitamente el servicio db si no estaba en ejecución, pero como fue iniciado por el anterior docker compose up, permanecerá en ejecución. El punto clave aquí es que docker compose alpha scale está diseñado para escalar el servicio especificado sin necesariamente activar el inicio de sus dependencias si no están ya en ejecución.

Verifica el número de contenedores del servicio web en ejecución.

docker ps --filter "name=my-web-app-web"

Deberías ver 4 contenedores para el servicio web. El contenedor del servicio db también debería seguir en ejecución.

Esto demuestra que docker compose alpha scale se enfoca en el servicio objetivo para el escalado.

Finalmente, detengamos todos los servicios.

docker compose down

Este comando detendrá y eliminará todos los contenedores, redes y volúmenes creados por Docker Compose para este proyecto.

Resumen

En este laboratorio, aprendimos cómo preparar un proyecto simple con Docker Compose. Esto incluyó la instalación de Docker Compose en el entorno de LabEx, verificar la instalación y luego crear una aplicación web básica con Python Flask. También creamos un Dockerfile para construir una imagen Docker de la aplicación y un archivo requirements.txt para listar las dependencias de la aplicación. Esta configuración inicial sienta las bases para explorar las funcionalidades de Docker Compose, enfocándonos específicamente en el escalado de servicios en los pasos siguientes.