Deploy multiple NGINX Ingress controllers in Alibaba Cloud ACK for traffic isolation - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Como funciona

Cada controlador possui um nome IngressClass exclusivo. Defina o campo spec.ingressClassName em um Ingress para direcioná-lo a um controlador específico. Apenas o controlador correspondente aplica as regras, o que garante o isolamento do tráfego.

Exemplo: isolamento de tráfego voltado para a Internet e tráfego interno.

Pré-requisitos

O cluster deve executar a versão 1,22 ou posterior.

As versões de componentes para clusters na versão 1,20 ou anterior atingiram o fim da vida útil ([[Product Announcement] End of Maintenance for NGINX Ingress controller v1.2 and Earlier](t2767923.xdita#)). Se necessário, atualize manualmente um cluster ACK.

Implante um novo controlador de Ingress usando o Helm

Na página ACK Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Applications > Helm.

Clique em Deploy para instalar o ack-ingress-nginx-v1.

Configure os seguintes parâmetros principais:

Parâmetro	Descrição
Application name	O nome deve ser exclusivo dentro do cluster. Importante Este nome serve como prefixo para o Service: `<Application Name>-ack-ingress-nginx-v1-controller` (voltado para a Internet) ou `<Application Name>-ack-ingress-nginx-v1-controller-internal` (interno). A criação falhará se o nome total exceder 63 caracteres.
Chart	Pesquise e selecione ack-ingress-nginx-v1. O chart ack-ingress-nginx não recebe mais manutenção.
Chart Version	Para clusters versão 1.24 ou posterior: 4.0.22 ou superior. Para clusters versão 1.22: versões de 4.0.16 (inclusivo) até 4.0.22 (exclusivo).
Parameters	Padrão: implanta como um Deployment com 2 réplicas, criando um Service LoadBalancer voltado para a Internet vinculado a uma instância CLB. Ajuste os padrões em parâmetros do ack-ingress-nginx-v1. Este exemplo implanta um controlador interno. Defina `controller.service.external.enabled` como `false` e `controller.service.internal.enabled` como `true`. Importante Garanta que controller.ingressClassResource.name e controller.ingressClassResource.controllerValue sejam exclusivos dentro do cluster.

Na página Helm, anote o Namespace (em Basic Information), bem como o nome da IngressClass e do Service (em Resource) para uso posterior.

Verifique o isolamento de tráfego

Este cenário utiliza controladores separados (voltados para a Internet e internos) para validar o isolamento:

Controlador padrão: implantado via Add-ons, vinculado a uma instância SLB voltada para a Internet.

Caso não esteja configurado, consulte Create and use an NGINX Ingress to expose a service .
Novo controlador: vinculado a uma instância SLB interna, acessível apenas dentro da VPC.

Implante uma aplicação de exemplo e crie uma regra de Ingress direcionada apenas ao novo controlador.

Etapa 1: Implante uma aplicação de teste

Crie um arquivo nginx.yaml.

Exemplo: Deployment e Service NGINX.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
        imagePullPolicy: Always
        name: nginx
        ports:
        - containerPort: 80
          protocol: TCP
      restartPolicy: Always
---
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: nginx
  sessionAffinity: None
  type: NodePort

Implante a aplicação de exemplo.
```
kubectl apply -f nginx.yaml
```

Etapa 2: Crie e vincule uma regra de Ingress

Crie um arquivo ingress.yaml.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx
spec:
  # Change the value to the IngressClass name you configured earlier (controller.ingressClassResource.name).
  ingressClassName: "<YOUR_INGRESS_CLASS>"
  rules:
  # The following domain name is for testing purposes. Replace it with your actual domain name in a production environment.
  - host: foo.bar.com
    http:
      paths:
      - path: /
        backend:
          service: 
            name: nginx
            port:
              number: 80
        pathType: ImplementationSpecific

Crie a regra de Ingress.
```
kubectl apply -f ingress.yaml
```

Etapa 3: Teste o acesso

Obtenha os endereços IP do SLB de cada controlador.

Endereço IP do SLB do controlador padrão voltado para a Internet:

PUBLIC_IP=$(kubectl get svc -n kube-system nginx-ingress-lb -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "Public Ingress IP: $PUBLIC_IP"

Endereço IP do SLB do novo controlador interno:

# Replace <YourNamespace> with the namespace of the new controller (for example, default).
# Replace <YourChartName> with the application name (release name) of the new controller.
INTERNAL_IP=$(kubectl get svc -n <YourNamespace> <YourChartName>-ack-ingress-nginx-v1-controller-internal -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "Internal Ingress IP: $INTERNAL_IP"

Acesse a aplicação pelo controlador interno (espera-se sucesso).

Envie uma solicitação de um terminal dentro da VPC. Um código de status 200 confirma que o controlador interno roteia o tráfego corretamente.
```
# Replace with the actual internal IP address.
curl -o /dev/null -s -w "%{http_code}\n" -H "Host: foo.bar.com" http://$INTERNAL_IP
```
Tente acessar a aplicação pelo controlador voltado para a Internet (espera-se falha).

Envie uma solicitação curl. Uma resposta 404 Not Found confirma que o controlador externo ignorou a regra de Ingress, validando o isolamento de tráfego.
```
# Replace with the actual Internet-facing IP address.
curl -H "Host: foo.bar.com" http://$PUBLIC_IP
```

Implantação em produção

Planejamento de recursos: Configure estes parâmetros para garantir alta disponibilidade:
- Múltiplas réplicas: controller.replicaCount
- Solicitações e limites de recursos adequados: controller.resources.requests e controller.resources.limits
- Anti-afinidade de Pods: Adicione uma regra podAntiAffinity em controller.affinity para agendar Pods em nós diferentes.
Monitoramento: Defina controller.metrics.enabled: true e controller.metrics.serviceMonitor.enabled: true. Integre com o Prometheus para monitorar métricas como latência de requisição, taxas de erro (4xx/5xx) e configure alert rules.
Desempenho: Para cenários de baixa latência, utilize uma instância NLB na configuração do Service:
- Service interno: controller.service.internal.loadBalancerClass: "alibabacloud.com/nlb"
- Service voltado para a Internet: controller.service.loadBalancerClass: "alibabacloud.com/nlb"
Manutenção de versão:
- Aplique correções de segurança conforme as NGINX Ingress controller component release notes.
- Para um isolamento mais robusto, restrinja o acesso ao backend por controlador usando uma Network Policy.

Apêndice: Parâmetros principais dos componentes

Parâmetro	Descrição
`controller.image.repository`	Repositório de imagens do controlador NGINX Ingress.
`controller.image.tag`	Versão da imagem do controlador NGINX Ingress.
`controller.ingressClassResource.name`	Nome IngressClass exclusivo dentro do cluster. Não pode ser `nginx` (reservado para o controlador padrão).
`controller.ingressClassResource.controllerValue`	Valor de classe do controlador exclusivo. Não pode ser `k8s.io/ingress-nginx` (reservado para o controlador padrão).
`controller.replicaCount`	Número de réplicas de Pods do controlador. Defina como 2 ou mais para alta disponibilidade.
`controller.service.enabled`	Define se deve ser criado um Service LoadBalancer (voltado para a Internet ou interno) para expor o controlador.
`controller.service.external.enabled`	Se `true`, cria um Service SLB voltado para a Internet.
`controller.service.internal.enabled`	Se `true`, cria um Service SLB interno (apenas VPC).
`controller.kind`	Modo de implantação do controlador de Ingress: `Deployment` ou `DaemonSet`.
`controller.electionID`	Identificador de eleição de líder entre as réplicas do controlador. Apenas o Líder pode atualizar o status do recurso Ingress. Deve ser exclusivo ao implantar múltiplos controladores no mesmo namespace.
`controller.metrics.enabled`	Se `true`, habilita um endpoint de métricas do Prometheus.
`controller.metrics.serviceMonitor.enabled`	Se `true`, cria um ServiceMonitor para descoberta automática pelo Prometheus. Recomendado quando `controller.metrics.enabled` for `true`.
`controller.service.loadBalancerClass`	Tipo de SLB para Services voltados para a Internet. `"alibabacloud.com/clb"` (Padrão): Usa uma instância CLB. `"alibabacloud.com/nlb"`: Usa uma instância NLB.
`controller.service.internal.loadBalancerClass`	Tipo de SLB para Services internos. `"alibabacloud.com/clb"` (Padrão): Usa uma instância CLB. `"alibabacloud.com/nlb"`: Usa uma instância NLB.

Documentação relacionada

O controlador de Add-ons também pode lidar com tráfego voltado para a Internet e interno (Configure the network type of an NGINX Ingress controller), mas compartilha Pods e configurações do controlador, sem isolamento de falhas.
Consulte Deploy a high-availability NGINX Ingress controller para configuração de alta disponibilidade.
Configure the network type of an NGINX Ingress controller para ajustar a configuração do controlador padrão.