Como podemos aceder ao contêiner Kubernetes onde a aplicação está a correr a partir da rede externa?

Existem várias formas principais de aceder a um contêiner Kubernetes a partir de uma rede externa:

1. Serviço do tipo LoadBalancer:

   • Os provedores de nuvem (AWS, GCP, Azure) criam um balanceador de carga externo que direciona o tráfego para os pods da sua aplicação.
   • É atribuída uma endereço IP externo.
   • A forma mais simples em ambiente de nuvem.

2. Serviço do tipo NodePort:

   • Abre uma porta em cada nó do cluster.
   • Essa porta encaminha o tráfego para o serviço da sua aplicação.
   • O acesso é feito através do IP de qualquer nó e do número de NodePort.
   • Menos escalável e seguro do que LoadBalancer.

3. Serviço do tipo ClusterIP juntamente com Ingress:

   • ClusterIP - serviço acessível apenas dentro do cluster.
   • Ingress - objeto API que gere o acesso externo aos serviços no cluster.
   • O controlador de Ingress (por exemplo, Nginx Ingress Controller, Traefik) escuta o tráfego externo e o encaminha para o serviço ClusterIP adequado.
   • Permite gerir de forma centralizada o roteamento, a terminação SSL, o balanceamento de carga.
   • Abordagem flexível e escalável.

4. Serviço do tipo ExternalName:

   • Cria um alias para um domínio externo. Não fornece acesso direto ao contêiner através deste serviço, mas permite usar um nome DNS dentro do cluster para aceder a um recurso externo. Não é adequado para acesso direto ao contêiner de fora.

5. Acesso direto ao NodePort/HostPort num Pod:

   • Pode especificar hostPort na especificação do pod para abrir uma porta no nó onde o pod está a ser executado. Altamente desaconselhado para ambientes de produção devido à baixa gestão e potenciais conflitos de portas.
   • De forma semelhante, nodePort pode ser especificado num Serviço do tipo NodePort.

Exemplos de configurações:

• Serviço LoadBalancer:

  // service.yaml
  apiVersion: v1
  kind: Service
  metadata:
    name: my-app-service
  spec:
    selector:
      app: my-app
    ports:
      - protocol: TCP
        port: 80
        targetPort: 8080
    type: LoadBalancer
  

• Serviço NodePort:

  // service-nodeport.yaml
  apiVersion: v1
  kind: Service
  metadata:
    name: my-app-service-np
  spec:
    selector:
      app: my-app
    ports:
      - protocol: TCP
        port: 80
        targetPort: 8080
        nodePort: 30000 # opcional, o Kubernetes irá atribuir se não for especificado
    type: NodePort
  

• Ingress (para serviço ClusterIP):

  // service-clusterip.yaml (assume-se que já existe)
  apiVersion: v1
  kind: Service
  metadata:
    name: my-app-service-ci
  spec:
    selector:
      app: my-app
    ports:
      - protocol: TCP
        port: 80
        targetPort: 8080
    type: ClusterIP
  

  // ingress.yaml
  apiVersion: networking.k8s.io/v1
  kind: Ingress
  metadata:
    name: my-app-ingress
  spec:
    rules:
      - host: myapp.example.com
        http:
          paths:
            - path: /
              pathType: Prefix
              backend:
                service:
                  name: my-app-service-ci
                  port:
                    number: 80
  

A escolha do método depende dos requisitos de escalabilidade, segurança, ambiente de implantação (nuvem ou on-premise) e necessidade de gestão centralizada do acesso. O Ingress é a solução preferencial para sistemas de produção.