Implantar um controlador de entrada

Artigo
06/27/2024

Aplica-se a: AKS no Azure Stack HCI 22H2, AKS no Windows Server

Um controlador de entrada é um recurso do Kubernetes que permite acesso externo a serviços dentro do cluster do Kubernetes. A entrada permite que um operador exponha um serviço a solicitações de rede externas, geralmente HTTP ou HTTPS. Você configura o acesso criando um conjunto de regras que definem as conexões de entrada que alcançam serviços específicos.

Um controlador de entrada é um software que fornece roteamento de tráfego configurável para serviços Kubernetes. Os recursos de entrada de Kubernetes são usados para configurar as regras de entrada e as rotas para os serviços de Kubernetes individuais. Ao usar um controlador de entrada e regras de entrada, você pode usar um único endereço IP para rotear o tráfego para vários serviços em um cluster do Kubernetes.

Depois de implantar o controlador em seu ambiente, você pode criar e implantar o manifesto de entrada. Atualmente, você usa a entrada no AKS Arc usando o controlador de entrada NGINX. Para obter informações sobre como instalar, configurar e usar o controlador de entrada NGINX, consulte Instalação com manifestos.

O Ingress difere do NodePort e do LoadBalancer de uma maneira exclusiva e melhora o roteamento de tráfego para o cluster de uma maneira menos dispendiosa. A definição de serviços NodePort cria várias portas aleatórias, e a definição de serviços LoadBalancer aumenta o custo dos recursos de nuvem mais do que você deseja. Quando você define um controlador de entrada, consolida as regras de roteamento de tráfego em um único recurso executado como parte do cluster. O NodePort e o LoadBalancer permitem expor um serviço especificando esse valor no tipo do serviço, enquanto a entrada é um recurso independente para o serviço. A entrada é definida, criada e destruída separadamente do serviço.

Você pode implantar a entrada de várias maneiras, dependendo do caso de uso. Os recursos de entrada são usados para atualizar a configuração dentro do controlador de entrada para determinar como ele funciona.

Usar a entrada para expor serviços por meio de URLs acessíveis externamente

Um exemplo de uso de ingresso é mostrado no manifesto YAML a seguir. O ingress.class aparece dentro dos metadados (neste exemplo, ingress-nginx), e essa configuração permite que o controlador de entrada NGINX saiba o que precisa monitorar e atualizar:

apiVersion: networking.k8s.io/v1  
kind: Ingress  
metadata: 
      name: hello-world
      annotations:
          nginx.ingress.kubernetes.io/rewrite-target: /
        kubernetes.io/ingress.class: "nginx"
  spec:  
      rules:
       - host: test.example.com
          http:
             paths: 
             - path: /hello-world
pathType: Prefix
backend:
    service: 
         name: hello-world 
                    port:  
                     number: 8080

A spec seção fornece informações sobre o que está configurado. Neste exemplo, uma regra (ou conjunto de regras) é definida e inclui os seguintes itens:

O host ao qual as regras são aplicadas.
Se o tráfego é HTTP ou HTTPS.
O caminho monitorado.
O serviço interno e a porta para onde o tráfego é enviado.

Usar entrada para balancear a carga do tráfego

No exemplo a seguir, outro caminho é adicionado ao manifesto que permite o balanceamento de carga entre diferentes back-ends de um aplicativo. Neste exemplo, o operador pode dividir o tráfego e enviá-lo para diferentes pontos de extremidade de serviço e implantações com base no caminho descrito. Por trás de cada caminho há uma implantação e um serviço, que é útil para pontos de extremidade que recebem mais tráfego:

apiVersion: networking.k8s.io/v1  
kind: Ingress  
metadata: 
      name: hello-world-and-earth
      annotations:
          nginx.ingress.kubernetes.io/rewrite-target: /
  spec:  
      rules:
       - host: test.example.com
          http:
             paths: 
             - path: /hello-world
pathType: Prefix
backend:
    service: 
         name: hello-world 
                    port:  
                     number: 8080
               - path: /hello-earth
pathType: Prefix
backend:
    service: 
         name: hello-earth 
                    port:  
                     number: 8080

Usar a entrada para rotear o tráfego HTTP para vários nomes de host no mesmo endereço IP

Você pode usar um recurso de entrada diferente para cada host, que permite controlar o tráfego com vários nomes de host. Para usar um recurso de entrada diferente, aponte vários nomes de host para o mesmo endereço IP público usado para o serviço LoadBalancer. No arquivo de manifesto a seguir, uma versão de produção do hello-world foi adicionada. O nome prod.example.com do host é usado e o tráfego é apontado para o novo serviço hello-world-prod. O tráfego chega através do endereço IP do balanceador de carga e é roteado com base no nome do host e no caminho fornecido:

apiVersion: networking.k8s.io/v1  
kind: Ingress  
metadata: 
      name: hello-world-prod
      annotations:
          nginx.ingress.kubernetes.io/rewrite-target: /
  spec:  
      rules:
       - host: test.example.com
          http:
             paths: 
             - path: /hello-world
pathType: Prefix
backend:
    service: 
         name: hello-world-test 
                    port:  
                     number: 8080
       - host: prod.example.com
          http:
              paths:
               - path: /hello-world
pathType: Prefix
backend:
    service: 
         name: hello-world-prod 
                    port:  
                     number: 8080

Próximas etapas

Para obter mais informações, consulte os seguintes links:

Compartilhar via