Cloud Server
Como configurar autoscaling em Cloud Server
Aprenda a configurar autoscaling em Cloud Server com métricas, health checks, balanceador, templates, testes de carga e limites seguros para produção real.
Resposta direta
Para configurar autoscaling em Cloud Server, crie um template reproduzível da aplicação, coloque as instâncias atrás de um balanceador de carga e defina políticas que aumentem ou reduzam a capacidade conforme métricas mensuráveis. Uma configuração inicial pode manter no mínimo 2 instâncias e no máximo 8, adicionando uma unidade quando a CPU superar 65% por 5 minutos ou quando houver mais de 100 requisições por segundo por instância. Cada servidor novo precisa passar por um health check antes de receber tráfego. Na redução, o balanceador deve drenar conexões e permitir que tarefas em andamento terminem. O fluxo também exige métricas centralizadas, logs, testes de carga e proteção contra oscilações rápidas. Autoscaling não corrige consultas lentas, banco saturado ou aplicação com estado salvo localmente.
Resumo rápido
- Use pelo menos 2 instâncias em produção para evitar que uma única falha interrompa o serviço.
- Mantenha a aplicação sem estado local e armazene sessões, arquivos e filas em serviços compartilhados.
- Crie as máquinas a partir de uma imagem validada ou de um script cloud-init idempotente.
- Combine CPU com latência, volume de requisições ou tamanho da fila para tomar decisões melhores.
- Configure cooldown de 300 a 600 segundos para impedir ciclos repetidos de criação e remoção.
- Só envie tráfego a uma instância depois que o endpoint de prontidão retornar sucesso.
- Teste tanto o crescimento quanto a redução do grupo antes de considerar o ambiente pronto.
O autoscaling horizontal distribui a carga entre várias instâncias semelhantes. Ele é diferente de aumentar CPU e RAM de uma única máquina, processo conhecido como escala vertical. Se essa decisão ainda não estiver clara, o artigo sobre escalabilidade vertical ou horizontal em Cloud Server explica os limites de cada abordagem. Na prática, escalar horizontalmente ajuda quando uma aplicação pode ser replicada e quando o gargalo está na camada computacional, não em um banco de dados central ou serviço externo.
Uma política saudável começa com limites conservadores. Um grupo com mínimo de 2, capacidade desejada de 2 e máximo de 6 instâncias é mais previsível que um conjunto capaz de saltar imediatamente de 1 para 20 servidores. Primeiro meça quanto uma instância suporta. Se uma API processa 80 requisições por segundo mantendo p95 abaixo de 250 ms, duas instâncias oferecem capacidade teórica de 160 requisições por segundo, antes de descontar margem para falhas e picos. Trabalhar com 25% a 40% de folga reduz o risco de escalar tarde demais.
O processo completo tem quatro partes conectadas: provisionamento, decisão, distribuição e remoção. O provedor cria a instância, a política decide quando agir, o balanceador encaminha tráfego e o mecanismo de encerramento retira a máquina sem derrubar conexões. Se uma dessas partes estiver mal configurada, adicionar servidores pode aumentar erros em vez de ampliar capacidade.
Como funciona uma arquitetura com autoscaling
Uma arquitetura comum possui um grupo de instâncias, um balanceador de carga, um serviço de métricas e um controlador de autoscaling. O grupo declara quantas máquinas devem existir. O controlador consulta as métricas em intervalos regulares, compara os valores com uma política e solicita a criação ou remoção de instâncias. O balanceador mantém apenas servidores considerados prontos em seu conjunto de destinos.
O primeiro requisito técnico é retirar o estado da máquina. Sessões de usuários podem ficar em Redis ou em um banco compartilhado. Uploads devem seguir para armazenamento de objetos, não para /var/www/uploads em um disco local. Filas precisam usar um broker acessível por todos os workers. Sem essa separação, um usuário autenticado na instância A pode perder a sessão quando a requisição seguinte chegar à instância B.
Escalabilidade horizontal e estado da aplicação
Considere uma API Node.js executada em máquinas com 2 vCPUs e 4 GB de RAM. Cada instância atende cerca de 60 requisições por segundo dentro da meta de latência. O grupo começa com 2 unidades, sobe até 8 e utiliza um banco PostgreSQL gerenciado. Outro exemplo é um conjunto de workers: cada servidor processa 20 jobs simultâneos, enquanto a política observa o número de mensagens pendentes. Uma fila com 1.000 itens pode justificar cinco workers adicionais, mas apenas se o banco e as APIs externas suportarem esse paralelismo.
Uma terceira situação é uma loja virtual que recebe picos durante campanhas. Nesse caso, escalar somente pela CPU pode ser insuficiente, pois requisições bloqueadas esperando banco ou gateway de pagamento nem sempre consomem muito processador. Latência p95, requisições por segundo e conexões ativas descrevem melhor a pressão. Para entender a camada de distribuição, consulte o conteúdo sobre Cloud Server com HAProxy e balanceamento de carga.
Perfis iniciais de capacidade
| Perfil | Instância de referência | Mínimo e máximo | Métrica principal | Janela inicial | Uso típico |
|---|---|---|---|---|---|
| API pequena | 2 vCPUs, 4 GB RAM | 2 a 4 | CPU acima de 65% | 5 minutos | API REST com tráfego previsível |
| Aplicação web | 4 vCPUs, 8 GB RAM | 2 a 8 | Requisições e latência p95 | 3 a 5 minutos | SaaS, e-commerce e portais |
| Workers assíncronos | 2 vCPUs, 4 GB RAM | 1 a 12 | Jobs pendentes por worker | 2 minutos | E-mails, vídeos e integrações |
| Serviço crítico | 4 vCPUs, 8 GB RAM | 3 a 15 | CPU, erros e latência | 2 a 5 minutos | Operação com alta disponibilidade |
Esses números são pontos de partida, não garantias de desempenho. O limite real depende do código, do banco, da rede e da virtualização oferecida pelo provedor. Um teste controlado deve determinar a capacidade segura de cada tipo de instância.
Prepare o template e o provisionamento das instâncias
Autoscaling depende de servidores intercambiáveis. Se uma máquina nova exigir comandos manuais, arquivos copiados por SSH ou alterações feitas fora do controle de versão, o grupo ficará inconsistente. O template precisa definir sistema operacional, pacotes, aplicação, agente de métricas, regras de firewall e processo de inicialização. Existem duas abordagens comuns: gerar uma imagem pronta em um pipeline ou instalar os componentes durante o boot com cloud-init.
Uma imagem pronta reduz o tempo de entrada em serviço. Se a instalação completa demora 9 minutos, mas uma imagem pré-configurada inicia em 90 segundos, a política reage melhor a picos rápidos. O custo é operacional: cada versão precisa gerar uma nova imagem, passar por testes e receber identificação clara, como api-2026-10-30-7f31c2. Cloud-init oferece mais flexibilidade, porém depende de repositórios, DNS e serviços externos no momento da inicialização.
Imagem pronta ou inicialização com cloud-init
Um cloud-init simples pode instalar o runtime, criar um serviço e iniciar a aplicação. O exemplo usa valores não sensíveis e pressupõe que credenciais serão obtidas de um gerenciador de segredos ou de uma identidade vinculada à instância:
#cloud-config
package_update: true
packages:
- nginx
- curl
write_files:
- path: /etc/systemd/system/app.service
permissions: '0644'
content: |
[Unit]
After=network-online.target
[Service]
ExecStart=/opt/app/bin/server
Restart=always
RestartSec=5
[Install]
WantedBy=multi-user.target
runcmd:
- systemctl daemon-reload
- systemctl enable --now app
- systemctl enable --now nginx
O script deve ser idempotente. Executá-lo duas vezes não pode duplicar usuários, corromper configurações ou reinserir dados. Também é prudente fixar versões. Instalar sempre o pacote mais recente pode produzir duas instâncias diferentes dentro do mesmo grupo após uma atualização do repositório.
Inicialização segura e repetível
Separe o processo em três estados. No boot, a instância ainda não recebe tráfego. Depois, um endpoint como /ready confirma que a aplicação carregou configurações, abriu o pool de conexões e alcança dependências essenciais. Por fim, o servidor é registrado no balanceador. Uma API pode levar 40 segundos para iniciar, enquanto uma aplicação Java com migrações e cache aquecido pode precisar de 2 a 4 minutos. O período de tolerância do health check deve refletir esse comportamento.
Não coloque chaves de API, senhas ou certificados privados no template. Use identidade da instância, cofre de segredos ou variáveis entregues pelo plano de controle. A regra de firewall deve permitir a porta da aplicação somente a partir do balanceador. SSH, quando necessário, deve ficar limitado a uma VPN ou bastion host. Antes de ativar a escala automática, crie três instâncias consecutivas com o mesmo template e confirme versão, logs, consumo de memória, health check e conectividade.
Escolha métricas e políticas de escalabilidade
A métrica de autoscaling precisa acompanhar a demanda que realmente pressiona a aplicação. CPU é um começo prático para serviços computacionais, como conversão de imagens ou geração de relatórios. Para APIs que esperam banco, rede ou serviços externos, a CPU pode permanecer em 35% mesmo quando a latência ultrapassa 2 segundos. Nesses casos, requisições por instância, conexões simultâneas, latência p95 e tamanho da fila produzem decisões mais úteis.
Uma política inicial para uma API pode adicionar uma instância quando a média de CPU do grupo ficar acima de 65% por 5 minutos. Uma segunda condição pode escalar quando cada servidor receber mais de 70 requisições por segundo durante 3 minutos. A redução ocorre apenas quando a CPU fica abaixo de 35% e o tráfego abaixo de 35 requisições por segundo durante 15 minutos. A janela maior para remover capacidade evita desligar servidores entre dois picos próximos.
Métricas que representam demanda real
Para workers, uma fórmula baseada em fila é mais direta. Se cada instância processa 600 jobs em 5 minutos e existem 2.400 jobs pendentes, quatro instâncias seriam necessárias para limpar a fila nessa janela. O controlador pode calcular ceil(jobs_pendentes / 600), respeitando mínimo e máximo. Se uma API externa aceita somente 100 chamadas por segundo, o grupo também precisa de rate limiting. Criar vinte workers não aumenta a capacidade do terceiro e pode provocar bloqueios.
Uma política conceitual pode ser representada assim:
capacity:
min: 2
desired: 2
max: 8
scale_out:
metric: requests_per_instance
threshold: 70
evaluation_periods: 3
add: 1
scale_in:
metric: requests_per_instance
threshold: 35
evaluation_periods: 5
remove: 1
cooldown_seconds: 300
O nome dos campos muda entre AWS Auto Scaling Groups, Google Cloud Managed Instance Groups, Azure Virtual Machine Scale Sets e serviços equivalentes. A lógica permanece semelhante: capacidade mínima, desejada e máxima, métrica, limite, janela e ação.
Limites, cooldown e proteção contra oscilações
Cooldown é o intervalo em que a política espera o efeito da ação anterior. Se uma instância leva 3 minutos para ficar pronta, avaliar a cada 30 segundos pode solicitar seis máquinas antes que a primeira aceite tráfego. Comece com 300 segundos e ajuste usando o tempo real de boot. Para picos muito rápidos, mantenha capacidade ociosa ou use escala agendada antes de eventos conhecidos.
Defina ainda um limite financeiro e operacional. Um máximo de 8 instâncias de 4 vCPUs significa até 32 vCPUs nessa camada. Monitore também banco, cache, conexões e cotas da conta. Se o PostgreSQL aceita 200 conexões, oito servidores com pool de 40 conexões tentariam abrir 320. Reduzir o pool para 20 ou usar um proxy de conexões impede que o autoscaling transfira o gargalo para o banco.
Configure balanceamento, health checks e remoção segura
O balanceador é responsável por encaminhar requisições apenas a instâncias utilizáveis. Um teste TCP confirma que uma porta está aberta, mas não prova que a aplicação consegue consultar o banco ou carregar a configuração. Para serviços HTTP, prefira endpoints separados para vida e prontidão. /live indica que o processo não travou. /ready confirma que o servidor pode receber tráfego naquele momento.
Uma configuração razoável consulta /ready a cada 10 segundos, usa timeout de 3 segundos e exige três sucessos consecutivos para registrar uma máquina. Para retirar uma instância com falha, dois ou três erros consecutivos costumam evitar reações a uma perda isolada de pacote. O endpoint deve ser rápido, normalmente abaixo de 100 ms, e não pode executar consultas pesadas. Uma verificação que faz cinco queries a cada 10 segundos cria carga artificial no banco quando existem dezenas de instâncias.
Health checks de vida e prontidão
A resposta de prontidão pode verificar se o processo terminou o boot, se o pool de conexões foi criado e se a aplicação não está em modo de encerramento. Evite tornar o serviço indisponível por causa de uma dependência opcional. Se o sistema de e-mail cair, uma loja ainda pode aceitar pedidos e enfileirar notificações. Já a ausência do banco principal provavelmente deve retirar a instância do balanceador.
Um exemplo de resposta enxuta seria:
{
"status": "ready",
"version": "7f31c2",
"checks": {
"database": "ok",
"cache": "ok"
}
}
O código HTTP deve ser 200 quando a máquina está pronta e 503 durante inicialização ou encerramento. Não inclua credenciais, endereços internos ou detalhes de exceções. Logs internos podem guardar o motivo completo da falha.
Drenagem de conexões e encerramento
Na redução de capacidade, marque a instância como não pronta, remova-a da rotação e aguarde a drenagem. Para APIs comuns, 30 a 60 segundos podem bastar. Uploads grandes, WebSockets e processamento síncrono exigem uma janela maior. Depois, envie SIGTERM ao processo e permita que ele finalize requisições. SIGKILL deve aparecer apenas após o timeout final.
Workers precisam parar de buscar novos jobs antes de encerrar. Uma tarefa já reservada deve terminar ou retornar à fila de maneira segura. Idempotência também ajuda: se o mesmo job for executado novamente, não pode cobrar o cliente duas vezes. Esse cuidado aproxima autoscaling de uma estratégia mais ampla de alta disponibilidade e failover em VPS, embora uma VPS isolada e um grupo gerenciado tenham modelos operacionais diferentes.
Também teste a falha do próprio balanceador. Um HAProxy instalado em uma única máquina apenas desloca o ponto único de falha. Use um balanceador gerenciado ou duas instâncias com mecanismo de failover, além de monitoramento externo. TLS, limites de conexão e timeouts devem ser revisados conforme o número máximo de backends.
Teste o autoscaling e investigue falhas
Uma política não está pronta apenas porque o painel mostra regras ativas. O teste precisa provar que a capacidade cresce, recebe tráfego, reduz erros e volta ao nível normal sem encerrar requisições. Registre antes do teste a capacidade por instância, o tempo de boot, a latência p95, a taxa de erros e o limite do banco. Sem uma linha de base, fica difícil saber se a nova máquina resolveu o gargalo.
Comece com 2 instâncias e gere carga crescente por 20 minutos. Um roteiro simples pode subir de 20 para 160 requisições por segundo em quatro etapas. A expectativa pode ser: primeira escala aos 5 minutos, nova instância pronta até o minuto 8 e latência p95 mantida abaixo de 300 ms. Ferramentas como k6, JMeter ou Locust executam esse cenário, mas a massa de dados e os endpoints devem representar o uso real.
export const options = {
stages: [
{ duration: '5m', target: 40 },
{ duration: '5m', target: 80 },
{ duration: '5m', target: 160 },
{ duration: '5m', target: 20 }
]
};
Um segundo teste deve desligar uma instância manualmente enquanto há tráfego. Confirme que o health check a remove, que o balanceador redistribui conexões e que o grupo cria uma substituta. No terceiro cenário, simule lentidão do banco. Se novas máquinas elevarem o número de conexões e piorarem a latência, a política precisa considerar saturação da dependência, não apenas CPU.
Observabilidade e troubleshooting
O painel operacional deve exibir quantidade desejada, instâncias prontas, instâncias em inicialização, CPU, memória, requisições por segundo, latência p50 e p95, erros 5xx e duração do provisionamento. Para workers, acrescente profundidade e idade da fila. Um alerta útil detecta quando a capacidade desejada aumenta, mas o número de instâncias saudáveis não acompanha em 10 minutos.
Se servidores novos falham no health check, consulte cloud-init, systemd, firewall, DNS e acesso ao gerenciador de segredos. Se o grupo oscila entre três e quatro máquinas, aumente a diferença entre os limites de entrada e saída, alongue a janela de redução ou amplie o cooldown. Se a escala ocorre tarde, reduza a janela de crescimento, use uma métrica antecipada, como tamanho da fila, ou mantenha uma unidade adicional ociosa.
Faça ainda um teste de redução. Observe se conexões são drenadas, se jobs retornam à fila e se os logs chegam ao sistema central antes do desligamento. Uma instância descartável não deve ser a única cópia de logs, arquivos ou dados necessários para auditoria.
Recomendações por perfil
A melhor configuração depende do impacto de indisponibilidade, da variação de tráfego e da maturidade operacional. Autoscaling adiciona componentes e pode ser desnecessário para uma aplicação pequena com carga estável. Em outros casos, manter capacidade fixa para o pico inteiro desperdiça recursos. Os perfis abaixo ajudam a escolher um ponto inicial, mas os limites precisam ser confirmados por testes na aplicação real.
Dev solo e projeto pequeno
Comece com 2 instâncias de 2 vCPUs e 4 GB de RAM, mínimo 2 e máximo 3 ou 4. Use CPU acima de 70% por 5 minutos como primeira métrica, combinada com requisições por instância se o balanceador disponibilizar esse dado. Configure cooldown de 600 segundos e redução após 20 minutos de baixa utilização. Uma imagem simples ou cloud-init versionado é suficiente. Mantenha banco, sessões e uploads fora das máquinas. Para reduzir complexidade, prefira o balanceador e o grupo de instâncias nativos do provedor em vez de construir um controlador próprio. Teste uma criação e uma remoção a cada nova versão da aplicação.
Time de produto em crescimento
Use no mínimo 2 ou 3 instâncias de 4 vCPUs e 8 GB de RAM, com máximo inicial entre 8 e 12. Combine CPU, latência p95 e requisições por servidor. Separe a política dos workers da política da API, pois cada camada responde a sinais diferentes. Gere imagens no pipeline, identifique-as pelo commit e faça implantação gradual. Um cooldown de 300 segundos costuma ser um ponto inicial razoável quando o boot leva menos de 2 minutos. Monitore pool de conexões, cache e cotas do provedor. Também defina alertas para falha de provisionamento e capacidade máxima atingida, situações em que o grupo deixa de absorver crescimento.
Produção crítica e tráfego variável
Mantenha pelo menos 3 instâncias distribuídas entre domínios de falha quando o provedor oferecer esse recurso. Dimensione o mínimo para sobreviver à perda de uma unidade sem ultrapassar 70% da capacidade restante. Use métricas compostas, escala agendada para eventos conhecidos e limites entre 10 e 30 instâncias somente após validar banco, cache, rede e orçamento. O processo de remoção deve incluir drenagem de 60 a 300 segundos, encerramento gracioso e proteção temporária para instâncias que executam tarefas longas. Faça testes de falha trimestrais, acompanhe tempo de recuperação e mantenha uma estratégia para indisponibilidade do plano de controle. Recursos, localidades e nomes dos serviços variam entre provedores e devem ser confirmados na documentação oficial antes da implementação.
Em qualquer perfil, não trate autoscaling como substituto de otimização. Uma consulta que demora 4 segundos continuará cara em dez servidores. Primeiro elimine gargalos evidentes, estabeleça uma capacidade mensurável por instância e só então automatize a expansão. Essa ordem produz políticas mais estáveis, custos previsíveis e diagnósticos muito mais simples.
Continue lendo
Perguntas frequentes
Qual é a configuração mínima para começar com autoscaling?
Para uma aplicação web pequena em produção, um ponto inicial razoável é usar duas instâncias com 2 vCPUs e 4 GB de RAM, mantendo mínimo de 2, desejado de 2 e máximo de 4 servidores. A escala pode ocorrer quando a CPU superar 65% a 70% por cinco minutos. Essa configuração não garante capacidade específica, pois o resultado depende do código, banco e tipo de virtualização. Execute um teste de carga para descobrir quantas requisições cada instância suporta dentro da meta de latência e reserve pelo menos 25% de folga.
CPU é suficiente para decidir quando criar novas instâncias?
CPU funciona bem para tarefas intensivas em processamento, mas pode representar mal APIs que esperam banco de dados, armazenamento ou serviços externos. Uma aplicação pode apresentar latência elevada com CPU abaixo de 40%. Combine CPU com requisições por instância, latência p95, conexões ativas ou tamanho da fila. Workers assíncronos normalmente escalam melhor pelo número e pela idade dos jobs pendentes. A política deve refletir a causa do congestionamento. Também monitore dependências, pois adicionar servidores quando o banco está saturado pode aumentar conexões e piorar a indisponibilidade.
Quanto tempo de cooldown devo configurar?
O cooldown precisa ser maior que o tempo necessário para uma instância iniciar, passar pelo health check e começar a produzir efeito nas métricas. Se o boot completo leva dois minutos, comece com 300 segundos. Ambientes que instalam muitos pacotes durante a inicialização podem precisar de 600 segundos. Use uma janela menor para aumentar capacidade e uma janela maior para reduzir. Por exemplo, escale após cinco minutos de carga alta, mas remova uma máquina somente depois de quinze minutos de baixa utilização. Isso evita oscilações e encerramentos entre picos próximos.
Como evitar perda de sessões e arquivos durante a escala?
A aplicação deve manter o estado fora das instâncias descartáveis. Armazene sessões em Redis, banco compartilhado ou outro serviço acessível por todo o grupo. Envie uploads para armazenamento de objetos e mantenha logs em uma plataforma centralizada. Arquivos gravados apenas no disco local desaparecem quando a máquina é removida e não ficam disponíveis nas demais réplicas. Também evite depender de afinidade de sessão como solução permanente. Sticky sessions podem reduzir sintomas, mas dificultam distribuição de carga e não protegem o usuário quando a instância original falha ou é encerrada.
Como o autoscaling deve tratar requisições e jobs em andamento?
Antes de encerrar uma instância, o controlador deve removê-la do balanceador e aguardar a drenagem das conexões. A aplicação recebe um sinal de término, deixa de aceitar novas requisições e conclui o trabalho atual dentro de um prazo definido. Para APIs, uma janela de 30 a 60 segundos pode bastar. Uploads, WebSockets e tarefas longas exigem mais tempo. Workers devem parar de buscar novos jobs e finalizar ou devolver à fila o item reservado. Operações idempotentes reduzem o risco de cobranças, notificações ou gravações duplicadas após uma repetição.
Autoscaling substitui alta disponibilidade e failover?
Não. Autoscaling ajusta a quantidade de instâncias conforme demanda ou métricas, enquanto alta disponibilidade trata falhas de componentes e continuidade do serviço. Um grupo pode escalar corretamente e continuar vulnerável se usar um único balanceador, banco sem redundância ou armazenamento local. Para combinar as duas estratégias, mantenha várias instâncias, distribua-as entre domínios de falha quando possível, use um balanceador redundante e teste a substituição automática de máquinas. Banco, cache, DNS e observabilidade também precisam de planos de recuperação. A escala automática é apenas uma camada da arquitetura resiliente.
Fontes consultadas
- AWS Documentation, Amazon EC2 Auto Scaling · coletado em 30/10/2026
- Google Cloud Documentation, Autoscaling groups of instances · coletado em 30/10/2026
- Microsoft Learn, Azure Virtual Machine Scale Sets overview · coletado em 30/10/2026
- HAProxy Documentation, Health checks · coletado em 30/10/2026
- cloud-init Documentation · coletado em 30/10/2026