Kubernetes: ClusterIP, NodePort ou Ingress? Quando usar cada um

O Kubernetes oferece suporte a várias maneiras de obter tráfego externo em seu cluster. ClusterIPs, NodePorts e Ingresses são três recursos amplamente usados que têm uma função no roteamento de tráfego. Cada um permite que você exponha serviços com um conjunto exclusivo de recursos e compensações.

O básico

As cargas de trabalho do Kubernetes não são visíveis na rede por padrão. Você disponibiliza contêineres para o mundo externo criando um serviço. Os recursos de serviço roteiam o tráfego para os contêineres dentro dos pods.

Um serviço é um mecanismo abstrato para expor pods em uma rede. Cada serviço recebe um tipo — ClusterIP, NodePort ou LoadBalancer. Eles definem como o tráfego externo chega ao serviço.

ClusterIP

ClusterIP é o serviço Kubernetes padrão. Seu serviço será exposto em um ClusterIP, a menos que você defina outro tipo manualmente.

Um ClusterIP fornece conectividade de rede dentro do seu cluster. Normalmente não pode ser acessado de fora. Você usa esses serviços para rede interna entre suas cargas de trabalho.

apiVersion: v1
kind: Service
spec:
  selector:
    app: my-app
  type: ClusterIP
  ports:
    - name: http
      port: 80
      targetPort: 80
      protocol: TCP

Este manifesto de exemplo define um serviço ClusterIP. O tráfego para a porta 80 no ClusterIP será encaminhado para a porta 80 em seus pods (targetPort). Pods com o campo de metadados app: my-app serão adicionados ao serviço.

Você pode ver o endereço IP atribuído executando kubectl get services. Outras cargas de trabalho em seu cluster podem usar esse endereço IP para interagir com seu serviço.

Você pode definir manualmente um ClusterIP para um endereço IP específico usando o campo spec.clusterIp:

spec:
  type: ClusterIP
  clusterIp: 123.123.123.123

O valor clusterIp deve ser um endereço IP válido dentro do intervalo configurado para seu cluster. Isso é definido pela configuração service-cluster-ip-range no servidor API do Kubernetes.

NodePort

Um NodePort expõe publicamente um serviço em um número de porta fixo. Ele permite que você acesse o serviço de fora do seu cluster. Você precisará usar o endereço IP do cluster e o número NodePort, por exemplo 123.123.123.123:30000.

A criação de um NodePort abrirá essa porta em todos os nós do cluster. O Kubernetes encaminhará automaticamente o tráfego da porta para o serviço ao qual está vinculado.

Aqui está um exemplo de manifesto do serviço NodePort:

apiVersion: v1
kind: Service
spec:
  selector:
    app: my-app
  type: NodePort
  ports:
    - name: http
      port: 80
      targetPort: 80
      protocol: TCP

As definições de NodePort têm as mesmas propriedades obrigatórias que os serviços ClusterIP. A única diferença é a mudança para type: NodePort. O campo targetPort ainda é obrigatório, pois os NodePorts são suportados por um serviço ClusterIP.

A aplicação do manifesto acima atribuirá ao seu NodePort um número de porta aleatório do intervalo disponível para o Kubernetes. Geralmente, o padrão é as portas 30000-32767. Você pode especificar manualmente uma porta definindo o campo ports.nodePort:

spec:
  ports:
    - name: http
      port: 80
      targetPort: 80
      nodePort: 32000
      protocol: TCP

Isso roteará o tráfego na porta 32000 para a porta 80 em seus pods.

Os NodePorts geralmente não são ideais para serviços públicos. Eles usam portas não padrão, que são inadequadas para a maioria do tráfego HTTP. Você pode usar um NodePort para configurar rapidamente um serviço para uso de desenvolvimento ou para expor um serviço TCP ou UDP em sua própria porta. Ao servir um ambiente de produção para os usuários, convém usar uma alternativa.

Entrada

Um Ingress é, na verdade, um recurso completamente diferente de um Serviço. Você normalmente usa Ingresses na frente de seus serviços para fornecer configuração de roteamento HTTP. Eles permitem que você configure URLs externos, hosts virtuais baseados em domínio, SSL e balanceamento de carga.

A configuração do Ingresses requer que um Ingress Controller exista em seu cluster. Há uma ampla seleção de controladores disponíveis. A maioria dos principais provedores de nuvem tem seu próprio Ingress Controller que se integra à sua infraestrutura de balanceamento de carga. nginx-ingress é uma opção autônoma popular que usa o servidor web NGINX como um proxy reverso para obter tráfego para seus serviços.

Você cria Ingresses usando o tipo de recurso Ingress. A anotação kubernetes.io/ingress.class permite indicar qual tipo de Ingress você está criando. Isso é útil se você estiver executando vários controladores de cluster.

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
    - host: example.com
      http:
        paths:
          - path: /
            backend:
              serviceName: my-service
              servicePort: 80
    - host: another-example.com
      http:
        paths:
          - path: /
            backend:
              serviceName: second-service
              servicePort: 80

Este manifesto define dois endpoints do Ingress. A primeira regra host roteia o tráfego example.com para a porta 80 no serviço my-service. A segunda regra configura another-example.com para mapear para pods que fazem parte de second-service.

Você pode configurar o SSL definindo o campo tls em sua especificação do Ingress:

spec:
  tls:
    - hosts:
      - example.com
      - another-example.com

Você precisará de um emissor como Cert Manager em seu cluster para que isso funcione. O Emissor adquirirá certificados SSL para seus domínios quando seu Ingress for criado.

As entradas devem ser usadas quando você deseja lidar com o tráfego de vários domínios e caminhos de URL. Você configura seus terminais usando instruções declarativas. O controlador do Ingress provisionará suas rotas e as mapeará para os serviços.

Balanceadores de carga

Um tipo de serviço final é LoadBalancer. Esses serviços se integram automaticamente aos balanceadores de carga fornecidos por ambientes de nuvem pública. Você precisará configurar seu próprio balanceador de carga se estiver auto-hospedando seu cluster.

Os balanceadores de carga são usados para mapear endereços IP externos para serviços em seu cluster. Ao contrário do Ingresses, não há filtragem ou roteamento automático. O tráfego para o IP externo e porta será enviado diretamente para o seu serviço. Isso significa que eles são adequados para todos os tipos de tráfego.

A implementação de cada balanceador de carga depende do provedor. Algumas plataformas de nuvem oferecem mais recursos do que outras. Esteja ciente de que a criação de um balanceador de carga geralmente aplicará cobranças adicionais à sua fatura.

apiVersion: v1
kind: Service
spec:
  selector:
    app: my-app
  type: LoadBalancer
  loadBalancerIP: 123.123.123.123
  ports:
    - name: http
      port: 80
      targetPort: 80
      protocol: TCP

Os manifestos do balanceador de carga são semelhantes aos outros tipos de serviço. O tráfego para a porta do balanceador de carga que você definir será recebido pelo targetPort em seus pods.

Seu ambiente de nuvem criará um novo balanceador de carga para lidar com seu tráfego. Alguns provedores permitem que você solicite um endereço IP externo específico usando o campo spec.loadBalancerIP. Você receberá um IP aleatório quando isso não for suportado.

Conclusão

ClusterIPs, NodePorts, Ingresses e Load Balancers roteiam o tráfego externo para os serviços em seu cluster. Cada um é projetado para um caso de uso diferente. Alguns de seus serviços farão mais sentido com um NodePort, enquanto outros precisarão de um Ingress, geralmente quando você deseja fornecer uma URL.

Todas as quatro opções funcionam em conjunto com o conceito mais amplo de “serviço”. Eles são os porteiros que permitem o acesso à rede aos seus serviços. Esses serviços lidam com o último salto em seus pods. As duas camadas de abstração mantêm o roteamento totalmente desacoplado de suas cargas de trabalho: seus pods simplesmente expõem as portas, que os serviços tornam acessíveis publicamente.