Como usar o comando docker compose alpha scale para escalar serviços

DockerBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como usar o comando docker compose alpha scale para escalar serviços definidos em um projeto Docker Compose. Começaremos preparando um projeto Docker Compose simples, que inclui a instalação do Docker Compose, a criação de uma aplicação web básica e a definição de seu Dockerfile e dependências.

Após a configuração do projeto, você explorará como escalar um único serviço usando docker compose alpha scale, escalar múltiplos serviços simultaneamente e escalar um serviço sem iniciar suas dependências. Esta experiência prática demonstrará a flexibilidade e o poder do comando scale para gerenciar o número de instâncias em execução de seus serviços.

Prepare um projeto Docker Compose simples

Nesta etapa, prepararemos um projeto Docker Compose simples. Como o Docker Compose não está pré-instalado no ambiente LabEx, primeiro o instalaremos. Em seguida, criaremos uma aplicação web simples e um arquivo Docker Compose para defini-la e executá-la.

Primeiro, vamos instalar o Docker Compose. Faremos o download do binário do Docker Compose e o tornaremos executável.

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

Agora, vamos verificar a instalação verificando a versão do Docker Compose.

docker-compose --version

Você deve ver a versão instalada do Docker Compose na saída.

Em seguida, criaremos uma aplicação web simples. Usaremos uma aplicação Flask Python básica. Crie um diretório para nosso projeto e navegue até ele.

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

Dentro do diretório my-web-app, crie um arquivo chamado app.py com o seguinte conteúdo:

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 é uma aplicação Flask simples que retorna "Hello, Docker Compose!" quando acessada.

Agora, precisamos de um Dockerfile para construir uma imagem Docker para nossa aplicação Flask. Crie um arquivo chamado Dockerfile no diretório my-web-app com o seguinte conteúdo:

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 usa uma imagem Python 3.9 slim, define o diretório de trabalho, copia e instala dependências de requirements.txt, copia o código da aplicação, expõe a porta 5000 e especifica o comando para executar a aplicação.

Também precisamos de um arquivo requirements.txt para a dependência Flask. Crie um arquivo chamado requirements.txt no diretório my-web-app com o seguinte conteúdo:

Flask==2.2.2

Finalmente, criaremos um arquivo docker-compose.yml para definir nosso serviço. Crie um arquivo chamado docker-compose.yml no diretório my-web-app com o seguinte conteúdo:

version: "3.8"

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

Este arquivo docker-compose.yml define um serviço chamado web. Ele diz ao Docker Compose para construir a imagem usando o Dockerfile no diretório atual (.) e mapear a porta 5000 no host para a porta 5000 no container.

Agora, vamos construir e executar o serviço usando o Docker Compose. Certifique-se de estar no diretório ~/project/my-web-app.

docker-compose up -d

Este comando constrói a imagem (se ainda não foi construída), cria um container para o serviço web e o inicia em modo detached (-d).

Você pode verificar se o container está em execução usando o comando docker ps.

docker ps

Você deve ver um container para o serviço my-web-app-web-1 em execução.

Para verificar se a aplicação está funcionando, você pode acessá-la usando curl.

curl http://localhost:5000

Você deve ver a saída "Hello, Docker Compose!".

Escalar um serviço usando docker compose alpha scale

Nesta etapa, aprenderemos como escalar um serviço usando o comando docker compose alpha scale. Escalar um serviço significa aumentar ou diminuir o número de instâncias em execução (containers) para aquele serviço. Isso é útil para lidar com o aumento da carga ou para alta disponibilidade.

O comando docker compose alpha scale permite que você defina o número desejado de réplicas para um serviço específico. O subcomando alpha indica que esta é uma funcionalidade mais recente no Docker Compose.

Certifique-se de estar no diretório ~/project/my-web-app onde seu arquivo docker-compose.yml está localizado.

Atualmente, temos uma instância do serviço web em execução. Podemos verificar isso listando os containers em execução e filtrando pelo nome do serviço.

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

Você deve ver apenas um container listado.

Agora, vamos escalar o serviço web para 3 instâncias. Usaremos o comando docker compose alpha scale seguido pelo nome do serviço e o número desejado de réplicas.

docker compose alpha scale web=3

Este comando iniciará dois novos containers para o serviço web, elevando o número total de instâncias para 3.

Após executar o comando, você pode verificar novamente os containers em execução para ver as instâncias escaladas.

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

Você deve agora ver três containers listados, cada um com um ID e nome de container diferentes (por exemplo, my-web-app-web-1, my-web-app-web-2, my-web-app-web-3).

O comando docker compose alpha scale é uma maneira conveniente de ajustar dinamicamente o número de réplicas de serviço sem modificar o arquivo docker-compose.yml e executar docker compose up novamente.

Para reduzir a escala do serviço, você pode usar o mesmo comando com um número menor. Por exemplo, para reduzir a escala para 1 instância:

docker compose alpha scale web=1

Isso irá parar e remover os containers extras, deixando apenas uma instância em execução.

Vamos escalá-lo de volta para 3 instâncias para a próxima etapa.

docker compose alpha scale web=3

Escalar múltiplos serviços simultaneamente

Nesta etapa, aprenderemos como escalar múltiplos serviços simultaneamente usando o comando docker compose alpha scale. Isso é útil quando você tem múltiplos serviços em sua aplicação que precisam ser escalados juntos para lidar com o aumento da carga ou manter uma arquitetura balanceada.

Para demonstrar isso, vamos adicionar outro serviço simples ao nosso arquivo docker-compose.yml. Criaremos um serviço Nginx simples que serve conteúdo estático.

Primeiro, crie um diretório para o conteúdo estático do Nginx.

mkdir static

Dentro do diretório static, crie um arquivo HTML simples chamado index.html com o seguinte conteúdo:

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

Agora, vamos atualizar o arquivo docker-compose.yml no diretório ~/project/my-web-app para incluir o serviço Nginx. Abra o arquivo docker-compose.yml usando nano.

nano docker-compose.yml

Adicione a seguinte definição de serviço abaixo do serviço web:

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

O arquivo docker-compose.yml atualizado deve ser semelhante a este:

version: "3.8"

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

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

Isso adiciona um serviço nginx que usa a imagem nginx:latest, mapeia a porta 80 no host para a porta 80 no container e monta o diretório ./static para a raiz web padrão do Nginx (/usr/share/nginx/html).

Salve o arquivo docker-compose.yml e saia do nano (Ctrl+X, Y, Enter).

Agora, vamos levantar o novo serviço. Como modificamos o arquivo docker-compose.yml, precisamos executar docker compose up novamente. A flag -d executa os containers em modo detached.

docker compose up -d

Docker Compose criará e iniciará o serviço nginx. O serviço web já deve estar em execução da etapa anterior.

Você pode verificar se ambos os serviços estão em execução usando docker ps.

docker ps

Você deve ver containers para my-web-app-web-1, my-web-app-web-2, my-web-app-web-3 e my-web-app-nginx-1.

Agora, vamos escalar o serviço web para 5 instâncias e o serviço nginx para 2 instâncias simultaneamente. Podemos fazer isso listando os serviços e suas contagens de réplicas desejadas no comando docker compose alpha scale.

docker compose alpha scale web=5 nginx=2

Este comando irá escalar o serviço web para 5 instâncias e o serviço nginx para 2 instâncias.

Após executar o comando, verifique os containers em execução novamente.

docker ps

Você deve agora ver 5 containers para o serviço web e 2 containers para o serviço nginx.

Isso demonstra como você pode escalar múltiplos serviços com um único comando docker compose alpha scale, tornando-o eficiente para gerenciar o dimensionamento dos componentes de sua aplicação.

Escalar um serviço sem iniciar dependências

Nesta etapa, exploraremos como escalar um serviço específico usando docker compose alpha scale sem iniciar suas dependências. Por padrão, quando você escala um serviço, o Docker Compose também pode iniciar ou garantir que suas dependências estejam em execução. No entanto, existem cenários em que você pode querer escalar apenas um único serviço sem afetar outros.

Para ilustrar isso, vamos adicionar uma dependência ao nosso serviço web. Adicionaremos um serviço de banco de dados simples, embora não implementemos nenhuma lógica de banco de dados em nossa aplicação web para este exemplo. Isso é apenas para demonstrar o conceito de dependência.

Abra o arquivo docker-compose.yml no diretório ~/project/my-web-app usando nano.

nano docker-compose.yml

Adicione uma nova definição de serviço para um banco de dados (por exemplo, uma imagem postgres simples) e adicione uma seção depends_on ao serviço 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

O arquivo docker-compose.yml atualizado agora inclui um serviço db usando a imagem postgres:latest e o serviço web tem uma linha depends_on: - db, indicando que o serviço web depende do serviço db.

Salve o arquivo docker-compose.yml e saia do nano (Ctrl+X, Y, Enter).

Agora, vamos levantar os serviços com a configuração atualizada.

docker compose up -d

Docker Compose agora também criará e iniciará o serviço db porque o serviço web depende dele.

Você pode verificar se todos os serviços estão em execução usando docker ps.

docker ps

Você deve ver containers para web, nginx e db.

Agora, digamos que queremos escalar apenas o serviço web para 4 instâncias sem iniciar ou afetar o serviço db (se ele já não estivesse em execução). O comando docker compose alpha scale, por padrão, respeita as dependências. No entanto, para este cenário específico em que queremos escalar apenas o serviço especificado, o comando docker compose alpha scale padrão é suficiente, pois ele se concentra principalmente no serviço de destino. A relação depends_on afeta principalmente a ordem de inicialização ao usar docker compose up. Ao usar docker compose alpha scale, ele se concentra em ajustar o número de instâncias para o serviço especificado.

Vamos escalar o serviço web para 4 instâncias.

docker compose alpha scale web=4

Este comando irá escalar o serviço web para 4 instâncias. Ele não iniciará explicitamente o serviço db se ele não estiver em execução, mas como ele foi iniciado pelo docker compose up anterior, ele permanecerá em execução. A principal conclusão aqui é que docker compose alpha scale foi projetado para escalar o serviço especificado sem necessariamente acionar a inicialização de suas dependências, caso elas ainda não estejam em execução.

Verifique o número de containers do serviço web em execução.

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

Você deve ver 4 containers para o serviço web. O container do serviço db também ainda deve estar em execução.

Isso demonstra que docker compose alpha scale se concentra no serviço de destino para dimensionamento.

Finalmente, vamos derrubar todos os serviços.

docker compose down

Este comando irá parar e remover todos os containers, redes e volumes criados pelo Docker Compose para este projeto.

Resumo

Neste laboratório, aprendemos como preparar um projeto Docker Compose simples. Isso envolveu a instalação do Docker Compose no ambiente LabEx, a verificação da instalação e, em seguida, a criação de uma aplicação web Python Flask básica. Também criamos um Dockerfile para construir uma imagem Docker para a aplicação e um arquivo requirements.txt para listar as dependências da aplicação. Essa configuração inicial fornece a base para explorar as funcionalidades do Docker Compose, com foco específico no dimensionamento de serviços nas etapas subsequentes.