Horizontal scaling for multiple applications with Nginx Ingress metrics - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

A implantação de várias instâncias aumenta a estabilidade da aplicação, mas pode resultar em recursos ociosos e custos mais altos para o cluster. O dimensionamento manual exige muito trabalho e frequentemente apresenta atrasos. Utilize as métricas de um Nginx Ingress para orientar o Horizontal Pod Autoscaler (HPA), que ajusta dinamicamente o número de réplicas de pods conforme a carga de trabalho. Essa abordagem garante estabilidade e respostas rápidas à aplicação, além de otimizar o uso de recursos e reduzir custos. Este tópico descreve como usar métricas de tráfego do Nginx Ingress para dimensionar automaticamente múltiplas aplicações.

Um Ingress encaminha requisições externas para um Service dentro do cluster, e o Service então roteia essas requisições para um pod. Em ambientes de produção, configure o dimensionamento automático com base no volume de requisições. O Nginx Ingress Controller expõe esse volume por meio da métrica nginx_ingress_controller_requests, utilizável como fonte de métrica para o HPA. Nos clusters ACK, o Nginx Ingress Controller é uma versão aprimorada da edição da comunidade e oferece uma experiência de usuário mais simplificada.

Pré-requisitos

Antes de configurar o dimensionamento automático das aplicações com base no tráfego do Nginx Ingress, configure o componente ack-alibaba-cloud-metrics-adapter para expor as métricas do Alibaba Cloud Prometheus ao HPA.

O componente de monitoramento Alibaba Cloud Prometheus deve estar implantado. Para mais informações, consulte Usar o Alibaba Cloud Prometheus para monitoramento.
O componente ack-alibaba-cloud-metrics-adapter deve estar implantado e seu campo prometheus.url configurado.
Como configurar prometheus.url
1. Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
2. Na página Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Applications > Helm.
3. Localize o ack-alibaba-cloud-metrics-adapter e clique em Update na coluna Actions.
4. No painel Update Release, defina o campo alibabaCloudMetricsAdapter.prometheus.url com a URL de requisição de dados do Prometheus obtida anteriormente. Em seguida, clique em OK.
  
  Para mais informações, consulte Como obter a URL de requisição de dados do Prometheus .
  
  Para uma descrição detalhada do arquivo de configuração, consulte Detalhes do arquivo de configuração do componente ack-alibaba-cloud-metrics-adapter .
A ferramenta de teste de estresse Apache Benchmark deve estar instalada.
Comandos de exemplo
- macOS: Use o Homebrew para instalar a ferramenta.
  brew install httpd
- Windows: Acesse o Apache Lounge para baixar a versão do Apache para Windows. Depois, no Prompt de Comando, use o comando cd para navegar até o diretório bin da pasta extraída e execute ab.exe para iniciar o programa.
- Ubuntu ou Debian:
  sudo apt update sudo apt install apache2-utils
- CentOS 8 ou RHEL:
  sudo yum install httpd-tools
Após concluir a instalação, execute ab -V para verificar se ela foi bem-sucedida.

Neste tutorial, você criará dois Deployments e seus respectivos Services. Em seguida, configurará um Ingress com diferentes caminhos de acesso para rotear o tráfego externo. Por fim, definirá um HPA para as aplicações com base na métrica nginx_ingress_controller_requests e utilizará o campo selector.matchLabels.service do HPA para filtrar a métrica. Isso permite que os pods sejam dimensionados automaticamente conforme o tráfego.

Etapa 1: Criar aplicações e services

Utilize os manifestos YAML abaixo para criar os Deployments das aplicações e seus respectivos Services.

Crie um arquivo chamado nginx1.yaml e copie o seguinte conteúdo para ele.

Exemplo de YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-app
  namespace: default
  labels:
    app: test-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: test-app
  template:
    metadata:
      labels:
        app: test-app
    spec:
      containers:
      - image: registry-cn-hangzhou.ack.aliyuncs.com/acs/sample-app:v1-b070784-aliyun
        name: metrics-provider
        ports:
        - name: http
          containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: test-app
  namespace: default
  labels:
    app: test-app
spec:
  ports:
    - port: 8080
      name: http
      protocol: TCP
      targetPort: 8080
  selector:
    app: test-app
  type: ClusterIP

Execute o comando a seguir para criar a aplicação test-app e seu respectivo Service.

kubectl apply -f nginx1.yaml

Crie um arquivo chamado nginx2.yaml e copie o seguinte conteúdo para ele.

Exemplo de YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
  namespace: default
  labels:
    app: sample-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sample-app
  template:
    metadata:
      labels:
        app: sample-app
    spec:
      containers:
      - image: registry-cn-hangzhou.ack.aliyuncs.com/acs/sample-app:v1-b070784-aliyun
        name: metrics-provider
        ports:
        - name: http
          containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: sample-app
  namespace: default
  labels:
    app: sample-app
spec:
  ports:
    - port: 80
      name: http
      protocol: TCP
      targetPort: 8080
  selector:
    app: sample-app
  type: ClusterIP

Execute o comando a seguir para criar a aplicação sample-app e seu respectivo Service.

kubectl apply -f nginx2.yaml

Etapa 2: Criar um Ingress

Crie um arquivo chamado ingress.yaml e copie o seguinte conteúdo para ele.

Exemplo de YAML

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  namespace: default
spec:
  ingressClassName: nginx
  rules:
    - host: test.example.com
      http:
        paths:
          - backend:
              service:
                name: sample-app
                port:
                  number: 80
            path: /
            pathType: ImplementationSpecific
          - backend:
              service:
                name: test-app
                port:
                  number: 8080
            path: /home
            pathType: ImplementationSpecific

host: Nome de domínio usado para acessar o Service. Este exemplo utiliza test.example.com.
path: Caminho da URL de acesso. Quando uma requisição chega, ela é associada ao Service correspondente com base na regra de roteamento e enviada ao pod apropriado através desse Service.
backend: Especifica o Service para o qual o path atual encaminha as requisições. É composto pelo nome e pela porta do Service.

Execute o comando a seguir para implantar o recurso de Ingress.

kubectl apply -f ingress.yaml

Execute o comando a seguir para obter o recurso de Ingress.
```
kubectl get ingress -o wide
```
Saída esperada:
```
NAME           CLASS   HOSTS              ADDRESS       PORTS   AGE                                                  
test-ingress   nginx   test.example.com   10.XX.XX.10   80      55s
```
Após uma implantação bem-sucedida, acesse o endereço do Host usando os caminhos / e /home. Com base na configuração anterior, o Nginx Ingress Controller roteia o tráfego para sample-app e test-app, respectivamente. Consulte a métrica nginx_ingress_controller_requests no Alibaba Cloud Prometheus para obter informações sobre as requisições de cada aplicação.

Etapa 3: Converter métricas do Prometheus para o HPA

Configurar o adaptador de métricas

Faça login no ACK console. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Applications > Helm.
Na página Helm, clique em ack-alibaba-cloud-metrics-adapter. Na seção Resource, clique em adapter-config e, em seguida, clique em Edit YAML no canto superior direito da página.

Substitua as regras existentes na configuração pelo conteúdo a seguir. Depois, clique em OK na parte inferior da página.

Para mais informações, consulte Dimensionamento automático horizontal de pods com base em métricas do Alibaba Cloud Prometheus .

rules:
- metricsQuery: sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m]))
  name:
    as: ${1}_per_second
    matches: ^(.*)_requests
  resources:
    namespaced: false  
  seriesQuery: nginx_ingress_controller_requests

apiVersion: v1
data:
  config.yaml: >
    rules:
    - metricsQuery: sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m]))
      name:
        as: ${1}_per_second
        matches: ^(.*)_requests
      resources:
        namespaced: false
      seriesQuery: nginx_ingress_controller_requests

Visualizar a saída da métrica

Execute o comando a seguir para visualizar a saída da métrica.

kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1/namespaces/*/nginx_ingress_controller_per_second" | jq .

O resultado da consulta é o seguinte:

{
  "kind": "ExternalMetricValueList",
  "apiVersion": "external.metrics.k8s.io/v1beta1",
  "metadata": {},
  "items": [
    {
      "metricName": "nginx_ingress_controller_per_second",
      "metricLabels": {},
      "timestamp": "2025-07-25T07:56:04Z",
      "value": "0"
    }
  ]
}

Etapa 4: Criar HPAs

Crie um arquivo chamado hpa.yaml e copie o seguinte conteúdo para ele.

Exemplo de YAML

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: sample-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: sample-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: External
      external:
        metric:
          name: nginx_ingress_controller_per_second
          selector:
            matchLabels:
# You can use this field to filter metrics. The labels specified here are passed to the <<.LabelMatchers>> tag in adapter.config.
              service: sample-app
# The External metric type supports only the Value and AverageValue target types.
        target:
          type: AverageValue
          averageValue: 30
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: test-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: test-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: External
      external:
        metric:
          name: nginx_ingress_controller_per_second
          selector:
            matchLabels:
# You can use this field to filter metrics. The labels specified here are passed to the <<.LabelMatchers>> tag in adapter.config.
              service: test-app
# The External metric type supports only the Value and AverageValue target types.
        target:
          type: AverageValue
          averageValue: 30

Execute o comando a seguir para implantar os HPAs para as aplicações sample-app e test-app.

kubectl apply -f hpa.yaml

Execute o comando a seguir para verificar o status da implantação do HPA.

kubectl get hpa

Saída esperada:

NAME         REFERENCE               TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
sample-hpa   Deployment/sample-app   0/30 (avg)   1         10        1          74s
test-hpa     Deployment/test-app     0/30 (avg)   1         10        1          59m

Etapa 5: Verificar os resultados

Após a implantação dos HPAs, utilize a ferramenta Apache Benchmark para executar um teste de estresse e confirmar se os pods da aplicação escalam horizontalmente à medida que o volume de requisições aumenta.

Execute o comando a seguir para realizar um teste de estresse no caminho /home do host.
```
ab -c 50 -n 5000 test.example.com/home
```

Execute o comando a seguir para verificar o status do HPA.

kubectl get hpa

Saída esperada:

NAME         REFERENCE               TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
sample-hpa   Deployment/sample-app   0/30 (avg)        1         10        1          22m
test-hpa     Deployment/test-app     22096m/30 (avg)   1         10        3          80m

Execute o comando a seguir para testar a carga no caminho raiz do host.
```
ab -c 50 -n 5000 test.example.com/
```

Execute o comando a seguir para verificar o status do HPA.

kubectl get hpa

Saída esperada:

NAME         REFERENCE               TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
sample-hpa   Deployment/sample-app   27778m/30 (avg)   1         10        2          38m
test-hpa     Deployment/test-app     0/30 (avg)        1         10        1          96m

Os resultados demonstram que as aplicações escalaram horizontalmente com sucesso quando o volume de requisições ultrapassou o limiar definido.

Documentos relacionados

O balanceamento multizona é um método comum de implantação para serviços intensivos em dados em cenários de alta disponibilidade. Quando a carga de trabalho aumenta, as aplicações que usam uma política de agendamento balanceado entre zonas devem escalar instâncias automaticamente em várias zonas para atender às demandas de agendamento do cluster. Para mais informações, consulte Implementar dimensionamento elástico rápido e simultâneo em múltiplas zonas.
É possível criar imagens personalizadas de sistema operacional para simplificar o dimensionamento elástico em cenários complexos. Para mais informações, consulte Otimização elástica com imagens personalizadas.