Todos os produtos
Search
Central de documentação

Container Service for Kubernetes:Criar e usar um NGINX Ingress

Última atualização: Oct 10, 2026

O NGINX Ingress Controller atua como o gateway de entrada do Alibaba Cloud Container Service for Kubernetes (ACK) managed clusters, roteando o tráfego externo para serviços internos com regras de roteamento flexíveis. Com suporte a recursos como criptografia HTTPS, canary releases e configurações personalizadas por meio de anotações, ele oferece acesso de rede de camada 7 (L7) seguro, altamente disponível e escalável.

Importante

Notas de uso

  • Não exclua o serviço padrão usado pelo NGINX Ingress Controller. Após a instalação do add-on, um serviço padrão chamado nginx-ingress-lb é criado no namespace kube-system . A exclusão desse serviço torna o add-on instável e pode causar falhas.

  • Use Add-ons or OpenAPI para configurar parâmetros personalizados do add-on. A modificação da configuração por outros métodos pode fazer o add-on funcionar incorretamente e interferir em futuras atualizações.

  • Use the NGINX Ingress ConfigMap para configurações personalizadas. O suporte técnico não cobre problemas causados por configurações adicionais, como snippets ou código Lua.

  • Upgrade the NGINX Ingress Controller add-on para evitar interrupções nos negócios causadas por bugs ou vulnerabilidades de segurança na versão da comunidade upstream.

Instalar o add-on NGINX Ingress Controller

Durante a criação do cluster

1. Selecionar o add-on

  1. Faça login no ACK console e clique em Create Kubernetes Cluster.

  2. In the Component Configurations etapa, na seção Ingress e selecione NGINX Ingress.

2. Selecionar a origem do Server Load Balancer (SLB)

  • New: Cria automaticamente uma instância de CLB pública ou privada multizona na VPC do cluster. A instância usa o método de cobrança pay-by-specification e possui uma specified instance type.

  • Use Existing: Selecione uma instância de CLB pública existente na mesma região do cluster ou uma instância de CLB privada na mesma VPC. Certifique-se de que a instância de CLB não esteja associada a outro cluster.

Instalar pela página de Add-ons

A instalação do add-on pela página de Add-ons cria automaticamente uma instância de CLB pública que usa o método de cobrança pay-by-specification e possui o tipo de instância Small I (slb.s1.small) . Essa instância serve como o ponto de entrada de tráfego para o NGINX Ingress.

  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 Components and Add-ons .

  3. Encontre o add-on NGINX Ingress Controller na guia Network ou use a barra de pesquisa. No canto inferior direito do cartão do add-on, clique em Install.

  4. In the Install Comment NGINX Ingress Controller dialog box, configure the parameters e clique em OK.

Criar um aplicativo de exemplo

O aplicativo de exemplo implanta dois workloads sem estado (Deployments) chamados coffee and tea, e seus Services correspondentes chamados coffee-svc and tea-svc.

Console

1. Criar recursos

  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 Workloads > Deployments.

  3. Clique em Create from YAML. Select Custom na lista suspensa Sample Template drop-down list. Copy the following content into the template editor e clique em Create.

    YAML do aplicativo de exemplo

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: coffee
      namespace: default
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: coffee
      template:
        metadata:
          labels:
            app: coffee
        spec:
          containers:
          - name: coffee
            image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
            ports:
            - containerPort: 80
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: coffee-svc
      namespace: default
    spec:
      ports:
      - port: 80
        targetPort: 80
        protocol: TCP
      selector:
        app: coffee
      type: ClusterIP
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: tea
      namespace: default
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: tea
      template:
        metadata:
          labels:
            app: tea
        spec:
          containers:
          - name: tea
            image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
            ports:
            - containerPort: 80
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: tea-svc
      namespace: default
    spec:
      ports:
      - port: 80
        targetPort: 80
        protocol: TCP
      selector:
        app: tea
      type: ClusterIP

2. Verificar o resultado

In the YAML Resource Creation Result , clique em View na coluna Actions de um recurso para confirmar que ele foi criado. 

kubectl

  1. Obtana coluna KubeConfig for your cluster e use kubectl para conectar-se ao cluster.

  2. Crie um arquivo chamado test-deployment-service.yaml com o seguinte conteúdo.

    Arquivo YAML de exemplo

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: coffee
      namespace: default
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: coffee
      template:
        metadata:
          labels:
            app: coffee
        spec:
          containers:
          - name: coffee
            image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
            ports:
            - containerPort: 80
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: coffee-svc
      namespace: default
    spec:
      ports:
      - port: 80
        targetPort: 80
        protocol: TCP
      selector:
        app: coffee
      type: ClusterIP
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: tea
      namespace: default
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: tea
      template:
        metadata:
          labels:
            app: tea
        spec:
          containers:
          - name: tea
            image: registry.cn-hangzhou.aliyuncs.com/acs-sample/nginxdemos:latest
            ports:
            - containerPort: 80
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: tea-svc
      namespace: default
    spec:
      ports:
      - port: 80
        targetPort: 80
        protocol: TCP
      selector:
        app: tea
      type: ClusterIP
  3. Aplique a configuração para criar o Deployment e o Service.

    kubectl apply -f test-deployment-service.yaml
  4. Verifique o status dos coffee and tea Deployments.

    kubectl get deployment coffee tea

    Saída esperada:

    NAME     READY   UP-TO-DATE   AVAILABLE   AGE
    coffee   2/2     2            2           14m
    tea      2/2     2            2           14m
  5. Verifique o status dos coffee-svc and tea-svc Services.

    kubectl get service coffee-svc tea-svc

    Saída esperada:

    NAME         TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)   AGE
    coffee-svc   ClusterIP   192.168.xxx.xxx   <none>        80/TCP    15m
    tea-svc      ClusterIP   192.168.xxx.xxx   <none>        80/TCP    15m

Criar NGINX Ingress

Este exemplo usa test-nginx-ingress.com as the domain name (host). Replace this with your own registered domain name. The path mapping (paths) is taken na lista suspensa Criar um aplicativo de exemplo . Modifique esses caminhos para corresponder à configuração do seu aplicativo.

Console

1. Criar um Ingress

  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 cluster de destino. No painel de navegação à esquerda, escolha Network > Ingresses. Selecione o namespace default , clique em Create Ingress e configure o Ingress conforme a seguir.

    • Gateway Type: Nginx Ingress

    • Name: test-nginx-ingress

    • Domain Name: test-nginx-ingress.com (Substitua pelo seu nome de domínio registrado)

    • Mappings:

      • Path: /coffee

      • Rule: Default (ImplementationSpecific)

      • Service: coffee-svc

      • Port: 80

  3. Clique em +Add para configurar um caminho para o serviço tea-svc service.

    • Mappings:

      • Path: /tea

      • Rule: Default (ImplementationSpecific)

      • Service: tea-svc

      • Port: 80

  4. Clique em +Add Rule para adicionar o nome de domínio www.test-nginx-ingress.com (substitua pelo seu nome de domínio registrado) e configurar seus mapeamentos de caminho. Ao concluir, clique em OK.

2. Obtana coluna endpoint

Após aproximadamente um minuto, atualize a página. The Nginx Ingress is successfully created when an Elastic IP (EIP) appears na coluna Endpoint . Esse EIP é o endereço de serviço público da instância do Cloud Load Balancer (CLB) associada.

Se as informações do endpoint não aparecerem após alguns minutos, clique no nome do Ingress e verifique a guia Events para solucionar o problema.

kubectl

  1. Crie um arquivo chamado test-ingress.yaml com o seguinte conteúdo.

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
      name: test-nginx-ingress
      namespace: default
    spec:
      ingressClassName: nginx
      rules:
      - host: test-nginx-ingress.com # Replace with your registered domain name
        http:
          paths:
          - path: /coffee
            backend:
              service: 
                name: coffee-svc
                port:
                  number: 80
            pathType: ImplementationSpecific
          - path: /tea
            backend:
              service: 
                name: tea-svc
                port:
                  number: 80
            pathType: ImplementationSpecific
      - host: www.test-nginx-ingress.com # Replace with your registered domain name
        http:
          paths:
          - path: /coffee
            backend:
              service: 
                name: coffee-svc
                port:
                  number: 80
            pathType: ImplementationSpecific
          - path: /tea
            backend:
              service: 
                name: tea-svc
                port:
                  number: 80
            pathType: ImplementationSpecific

    Parâmetro descriptions:

    • name: O nome do Ingress. Neste exemplo, o nome é test-nginx-ingress.

    • host: O nome de domínio usado para acessar o serviço. Neste exemplo, o nome de domínio é test-nginx-ingress.com. Substitua pelo seu nome de domínio registrado.

    • path: O caminho da URL para a regra. Para que uma requisição seja roteada para o backend, ela deve corresponder ao host and path. Neste exemplo, os caminhos são /coffee and /tea.

    • backend: Consiste em um nome de serviço e uma porta de serviço.

      • Nome do serviço: O nome do serviço de backend para o qual o Ingress encaminha o tráfego. Por exemplo, coffee-svc and tea-svc.

      • Porta do serviço: A porta de destino no Service de backend. Neste exemplo, a porta é 80.

  2. Crie o Ingress.

    kubectl apply -f test-ingress.yaml
  3. Visualize o Ingress e obtenha seu Elastic IP (EIP), como 8.xxx.xxx.117.

    kubectl get ingress

    Saída esperada:

    NAME                 CLASS   HOSTS                                               ADDRESS         PORTS   AGE
    test-nginx-ingress   nginx   test-nginx-ingress.com,www.test-nginx-ingress.com   8.xxx.xxx.117   80      2m39s
  4. Use o EIP para verificar se o Nginx Ingress está funcionando corretamente.

    curl http://8.xxx.xxx.117/coffee -H "Host: test-nginx-ingress.com"

    Saída esperada:

    ...
    <title>Hello World</title>
    ...
    <p><span>Server&nbsp;address:</span> <span>10.xxx.xxx.19:80</span></p>
    <p><span>Server&nbsp;name:</span> <span>coffee-96d4bc87-l29dh</span></p>
    <p class="smaller"><span>Date:</span> <span>08/Aug/2025:02:21:02 +0000</span></p>
    <p class="smaller"><span>URI:</span> <span>/coffee</span></p>
    ...
        <div id="footer">
            <div id="center" align="center">
                Request ID: 42e2d73c85b16b55b6ab52deb7d995d4<br/>
                &copy; NGINX, Inc. 2018
            </div>
        </div>
    ...

Configurar resolução de DNS

Registre um nome de domínio. Você só precisa adicionar um nome de domínio se ele estiver registrado em um provedor terceirizado. A Alibaba Cloud adiciona automaticamente os nomes de domínio adquiridos por meio de sua plataforma às zonas autoritativas públicas no Alibaba Cloud DNS, para que você possa adicionar registros DNS diretamente.

1. Adicionar um nome de domínio

  1. Go to Alibaba Cloud DNS - Public Zone.

    Na página Public Zone tab, click Add Zone.

  2. Insira o nome de domínio que deseja adicionar e selecione a instância de Public Zone criada. Para mais informações sobre os parâmetros, consulte Adquira umnd bind a domain name.

2. Adicionar um registro DNS

  1. Encontre o add-on target domain name e clique em Settings na coluna Actions coluna. Em seguida, clique em Add Record. Adicione um registro DNS com o tipo de registro A e o registro de host @. The Record Value is the endereço de acesso do NGINX Ingress.

  2. Siga os mesmos passos para adicionar outro registro DNS com o registro de host definido como www.

  3. Clique em Probing ao lado do novo registro DNS para verificar seu status de resolução.

Para mais informações, consulte Add a website resolution record.

3. Verificar o nome de domínio e o caminho

No seu navegador, acesse http://test-nginx-ingress.com/coffee, substituindo test-nginx-ingress.com pelo seu nome de domínio real, para verificar se o caminho do serviço está acessível.

If the request succeeds, the page returns information na lista suspensa NGINX backend pod, including the server address, server name, Date, and URI .

Para confirmar o resultado, você também pode consultar Methods for testing DNS resolution. Se um registro DNS não entrar em vigor, consulte Quickly troubleshoot DNS resolution failures.

Configurar segurança HTTPS

Adquira um certificado comercial, and solicite o certificado. Ensure the certificate is na coluna Issued . Em seguida, siga estas etapas para baixar o certificado e adicionar uma configuração TLS. Isso permite o acesso HTTPS criptografado ao seu domínio.

Console

1. Baixar o certificado

  1. Faça login no Certificate Management Service console. No painel de navegação à esquerda, escolha Certificate Management > SSL Certificate Management.

  2. Na página Commercial Certificates tab, select the certificate you want to download, e clique em Download na coluna bottom-left corner of the certificate list.

  3. Na caixa de diálogo exibida, selecione Nginx como tipo de servidor, baixe o pacote do certificado e descompacte-o.

Para mais detalhes, consulte Download an SSL certificate.

2. Criar um Secret

  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 Configurations > Secrets.

  3. Na página Secrets , selecione o namespace default , clique em Create na coluna upper-left corner, configure a new Secret na coluna panel that appears e clique em OK.

    • Name: nginx-ingress-tls

    • Type: Ingress TLS Certificate

    • Certificates: O conteúdo completo do arquivo de certificado baixado e descompactado (.pem).

    • Key: O conteúdo completo do arquivo de chave privada baixado e descompactado (.key).

3. Adicionar uma configuração TLS

  1. No painel de navegação à esquerda, escolha Network > Ingresses. In the Actions do Ingress de destino, clique em Update.

  2. Na página Modify Ingress , adicione a seguinte configuração TLS e clique em OK.

    • TLS Settings: Enabled

    • Domain Name: test-nginx-ingress.com (Substitua pelo seu nome de domínio registrado real.)

    • Secrets: nginx-ingress-tls

4. Verificar acesso HTTPS

No seu navegador, acesse https://test-nginx-ingress.com/coffee (substitua pelo seu nome de domínio registrado real) para verificar o acesso HTTPS criptografado ao caminho do serviço.

Kubectl

  1. Faça login no Certificate Management Service console. No painel de navegação à esquerda, escolha Certificate Management > SSL Certificate Management.

  2. Na página Commercial Certificates tab, select the certificate you want to download, e clique em Download na coluna bottom-left corner of the certificate list.

  3. Na caixa de diálogo exibida, selecione Nginx como tipo de servidor, baixe o pacote do certificado e descompacte-o.

  4. Use o arquivo de certificado baixado (.pem) e o arquivo de chave privada (.key) para criar um Secret.

    kubectl create secret tls nginx-ingress-tls --cert test-nginx-ingress.com.pem --key test-nginx-ingress.com.key -n default
  5. Adicione uma configuração TLS ao Ingress test-nginx-ingress . Substitua test-nginx-ingress.com na coluna command with your actual registered domain name.

    kubectl patch ingress test-nginx-ingress -p '{"spec":{"tls":[{"hosts":["test-nginx-ingress.com"],"secretName":"nginx-ingress-tls"}]}}'
  6. Verifique o acesso HTTPS criptografado ao caminho do serviço executando o seguinte comando com seu Elastic IP Address real.

    curl -v -k https://8.xxx.xxx.117/coffee -H "Host: test-nginx-ingress.com"
    • Parâmetros:

      • -v: Exibe saída detalhada, incluindo o handshake TLS.

      • -k (ou --insecure): Ignora a verificação do certificado. Use esta opção se estiver usando um certificado autoassinado.

    • Saída esperada:

      ...
      *   Trying 8.xxx.xxx.117:443...
      * Connected to 8.xxx.xxx.117 (8.xxx.xxx.117) port 443
      * ALPN: curl offers h2,http/1.1
      * (304) (OUT), TLS handshake, Client hello (1):
      * (304) (IN), TLS handshake, Server hello (2):
      * (304) (IN), TLS handshake, Unknown (8):
      * (304) (IN), TLS handshake, Certificate (11):
      * (304) (IN), TLS handshake, CERT verify (15):
      * (304) (IN), TLS handshake, Finished (20):
      * (304) (OUT), TLS handshake, Finished (20):
      ...
      <title>Hello World</title>
      ...
      <p><span>Server&nbsp;address:</span> <span>10.xxx.xxx.159:80</span></p>
      <p><span>Server&nbsp;name:</span> <span>coffee-96d4bc87-6cstv</span></p>
      <p class="smaller"><span>Date:</span> <span>14/Aug/2025:09:27:42 +0000</span></p>
      <p class="smaller"><span>URI:</span> <span>/coffee</span></p>
      ...
          <div id="footer">
              <div id="center" align="center">
                  Request ID: fee5fe107106748a35d99a2dbbbc6652<br/>
                  &copy; NGINX, Inc. 2018
              </div>
          </div>
      ...

Mais configurações

Canary release

Para atualizar serviços, você pode usar várias estratégias de implantação, como rolling updates, phased releases, blue-green deployments e canary releases. Para instruções detalhadas, consulte Implement phased releases and blue-green deployments using NGINX Ingress.

Protocolo do serviço de backend

Para especificar o protocolo de um serviço de backend, adicione a anotação nginx.ingress.kubernetes.io/backend-protocol . Os protocolos suportados são HTTP, HTTPS, gRPC e gRPCS. Para um exemplo de configuração, consulte Configure a gRPC service for NGINX Ingress.

Reescrita de URL

Ao usar o NGINX Ingress controller, ele encaminha requisições com base no caminho completo. Por exemplo, uma requisição para /service1/api é encaminhada para o caminho /service1/api do pod de backend. Se o caminho do seu serviço de backend for /api, ocorre uma incompatibilidade de caminho, resultando em um erro 404. Para resolver esse problema, você pode adicionar a anotação nginx.ingress.kubernetes.io/rewrite-target para reescrever o caminho da requisição para o diretório correto.

Para instruções detalhadas, consulte Configure URL redirection.

Anotações

NGINX Ingress supports an extensive range of features that you can enable with annotations. Para mais informações, consulte NGINX Ingress configuration dictionary and Advanced NGINX Ingress configurations.

Observabilidade

Ative o Simple Log Service (SLS) durante a criação do cluster para acessar relatórios abrangentes de análise de logs de acesso do NGINX Ingress e painéis de monitoramento em tempo real. Para detalhes, consulte Analyze and monitor NGINX Ingress access logs.

Cenários de alta carga

Para melhorar o desempenho e a estabilidade do NGINX Ingress Controller em cenários de alta carga, consulte Configure an NGINX Ingress Controller for high-payload scenarios and Suggestions for using an NGINX Ingress Controller.

FAQ

IP externo inacessível de dentro do cluster

Sintoma

Some Pods na coluna cluster cannot access backend Pods using the external address of the NGINX Ingress Controller (the IP address of the load balancer instance), while others can.

Causa

Esse problema é causado pela configuração externalTrafficPolicy do Service do controller, que determina como o tráfego externo é tratado. Quando definido como local, apenas os Pods de backend no mesmo nó do Pod do controller podem receber requisições. Quando definido como Cluster, access works as expected. When a resource withna coluna cluster accesses the Service using the external IP address of the load balancer, the request is also treated as external traffic.

Solução

  • (Recommended) From withna coluna Kubernetes cluster, access NGINX Ingress using its ClusterIP or service name. The service name of NGINX Ingress is nginx-ingress-lb.kube-system.

  • Run kubectl edit svc nginx-ingress-lb -n kube-system para modificar o Service do NGINX Ingress. Altere o externalTrafficPolicy do Service LoadBalancer para Cluster. Se o plugin de rede de containers do cluster for Flannel, as requisições perdem o IP de origem do cliente. Se você usar o Terway, o IP de origem do cliente será preservado.

    Exemplo:

    apiVersion: v1
    kind: Service
    metadata:
      annotations:
        service.beta.kubernetes.io/backend-type: eni   # Passes traffic directly to the Elastic Network Interface (ENI).
      labels:
        app: nginx-ingress-lb
      name: nginx-ingress-lb
      namespace: kube-system
    spec:
      externalTrafficPolicy: Cluster

Para mais informações sobre anotações de Service, consulte Configure Classic Load Balancer (CLB) using annotations.

Headers ou cookies grandes

Se uma requisição de cliente contiver headers de requisição ou cookies grandes, o NGINX Ingress pode retornar um erro como "400 Request Header Or Cookie Too Large /Bad request". Para resolver isso, aumente os tamanhos de buffer modificando as seguintes configurações:

  • client-header-buffer-size: O tamanho do buffer para headers de requisição do cliente. O valor padrão é 1k.

  • large-client-header-buffers: O número máximo e o tamanho dos buffers usados para ler headers de requisição grandes do cliente. O valor padrão é 4 8k.

Run kubectl edit cm -n kube-system nginx-configuration to edit the ConfigMap and modify these settings. Exemplo:

client-header-buffer-size: "16k"
large-client-header-buffers: "4 32k" 

Após atualizar as configurações, verifique se o plano de dados do NGINX reflete as alterações. Execute kubectl exec <nginx-ingress-pod> -n kube-system -- cat /etc/nginx/nginx.conf | vim - para visualizar o arquivo nginx.conf e confirmar que as alterações do ConfigMap foram sincronizadas.

Configuração CORS

Ative o Cross-Origin Resource Sharing (CORS) adicionando anotações específicas à seção metadata.annotations section of your Ingress resource. Para mais informações, consulte Configure CORS for NGINX Ingress.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/enable-cors: "true"     # Enables CORS.
    nginx.ingress.kubernetes.io/cors-allow-origin: "*"  # Allows access from all domains.
    nginx.ingress.kubernetes.io/cors-allow-methods: "GET, PUT, POST, DELETE, PATCH, OPTIONS"  # Allowed HTTP methods.
    nginx.ingress.kubernetes.io/cors-allow-headers: "DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range" # Allowed custom request headers.
    nginx.ingress.kubernetes.io/cors-expose-headers: "Content-Length,Content-Range"  # Exposed response headers.
    nginx.ingress.kubernetes.io/cors-max-age: "86400"  # Preflight request cache duration.
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: example-service
            port:
              number: 80

Repasse do IP do cliente

Por padrão, o NGINX Ingress usa os headers X-Forwarded-For and X-Real-IP headers to pass through the client IP address. However, if a client explicitly sets these headers na coluna request, the backend server may be unable to obtana coluna real client IP address.

Para ativar o repasse de IP do cliente na camada 7 para o Ingress, execute o comando kubectl edit cm -n kube-system nginx-configuration e adicione as seguintes configurações ao ConfigMap.

compute-full-forwarded-for: "true"
forwarded-for-header: "X-Forwarded-For"
use-forwarded-headers: "true"

Se o NGINX Ingress estiver atrás de várias camadas de proxy, ajuste a configuração com base no parâmetro proxy-real-ip-cidr . Adicione os endereços IP dos proxies upstream ao proxy-real-ip-cidr in CIDR format, separating multiple CIDR blocks with commas. Para mais informações, consulte Use a WAF.

proxy-real-ip-cidr:  "0.0.0.0/0,::/0"  

Em um cenário IPv6 com um Classic Load Balancer (CLB) upstream, se o header X-Forwarded-For header received by NGINX Ingress is empty, enable Proxy Protocol on the CLB to obtana coluna client IP address. For more information about Proxy Protocol, see Obtain real client IP addresses through a Layer 4 listener of a CLB instance.

Referências