Escalabilidade de serviços

8.1 Comando docker compose scale

Escalabilidade de serviços — é o processo de aumentar ou diminuir a quantidade de instâncias de containers que executam o mesmo serviço, para gerenciar a carga e garantir a tolerância a falhas do aplicativo. No Docker Compose, o comando docker compose scale (nas versões antigas) ou o parâmetro --scale nas versões mais recentes são usados para escalar serviços.

Conceitos principais de escalabilidade:

1. Escalabilidade: A habilidade de aumentar ou diminuir facilmente a quantidade de instâncias de um serviço dependendo da carga atual.
2. Tolerância a falhas: Rodar várias instâncias de um serviço permite garantir a tolerância a falhas, já que a falha de uma instância não levará à interrupção de todo o serviço.
3. Balanceamento de carga: Distribuir a carga entre várias instâncias de um serviço para otimizar o desempenho.

Como usar o comando docker compose scale

Sintaxe do comando:

docker compose scale SERVICE=NUM

Onde:

• SERVICE: o nome do serviço que precisa ser escalado.
• NUM: a quantidade de instâncias que deve ser iniciada.

Exemplo de uso:

Suponha que você tenha um arquivo compose.yaml com a definição do serviço web.

version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Para iniciar 3 instâncias do serviço web, use o comando:

docker compose scale web=3

Nota: Antes de executar o comando docker compose scale, certifique-se de que os serviços foram iniciados com o comando docker compose up.

Usando o parâmetro --scale nas versões mais recentes

Nas versões mais recentes do Docker Compose, o comando docker compose scale foi substituído pelo parâmetro --scale, que é usado junto com o comando up.

docker compose up --scale web=3

Este método é preferível, pois permite iniciar e escalar serviços ao mesmo tempo.

8.2 Exemplos práticos

Exemplo 1: Escalabilidade de um servidor web

Crie o arquivo compose.yaml:

version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80-90:80"

Inicie e escale o serviço para 3 réplicas:

docker compose up --scale web=3

Agora você terá 3 réplicas do servidor web Nginx rodando nas portas do intervalo 80-90.

Importante! Se o serviço precisa ser escalado para várias réplicas, é necessário especificar um intervalo de portas, por exemplo: "80-90:80". Isso vai "reservar" no host um intervalo de 10 portas. Quando uma réplica for adicionada, uma porta do intervalo será atribuída a ela. Se isso não for feito, as portas serão escolhidas aleatoriamente, e as réplicas ficarão inacessíveis.

Exemplo 2: Escalabilidade com banco de dados

Crie o arquivo compose.yaml:

version: '3.8'

services:
  web:
    image: nginx:latest
    ports:
      - "80-90:80"
    depends_on:
      - db

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

Inicie e escale o serviço web para 4 réplicas:

docker compose up --scale web=4

Agora você terá 4 réplicas do servidor web Nginx trabalhando com um banco de dados PostgreSQL.

8.3 Gerenciamento de serviços escaláveis

Depois de escalar os serviços, você pode usar comandos do Docker Compose para gerenciar as instâncias.

Visualizar os containers em execução

Use o comando docker compose ps para ver todos os containers que estão rodando:

docker compose ps

Parar e remover serviços escaláveis

Para parar e remover todas as instâncias de um serviço, use o comando docker compose down:

docker compose down

Dicas e recomendações:

1. Balanceamento de carga: use balanceadores de carga para distribuir o tráfego entre várias instâncias de um serviço. Por exemplo, você pode usar Nginx ou HAProxy para essa finalidade.
2. Persistência de dados: certifique-se que os dados gerados pelos serviços escaláveis sejam salvos em volumes ou armazenamentos externos para evitar perda de dados ao parar ou remover containers.
3. Monitoramento: use ferramentas de monitoramento como Prometheus ou Grafana para acompanhar o desempenho e o estado dos serviços escaláveis.
4. Escalabilidade automática: considere a possibilidade de escalar os serviços automaticamente, dependendo da carga, utilizando orquestradores como Kubernetes ou Docker Swarm.