Ingress Kubernetes: Configuração e Gerenciamento de Acesso Externo

Introdução

Neste laboratório, você aprenderá como usar o Ingress para rotear tráfego externo para serviços em execução em um cluster Kubernetes.

O Kubernetes Ingress é uma ferramenta poderosa para gerenciar o acesso externo a serviços em um cluster Kubernetes. O Ingress atua como um balanceador de carga de camada 7, permitindo que você roteie o tráfego para diferentes serviços com base no caminho URL de entrada ou no nome do host.

Neste laboratório, criaremos uma aplicação de exemplo e a exporemos ao mundo exterior usando o Ingress. Usaremos o nginx-ingress como o controlador Ingress, que é uma solução popular e amplamente utilizada para o Kubernetes Ingress.

Iniciar o Cluster Minikube

Antes de criar recursos, você precisa de um cluster Kubernetes em execução. Minikube é um ambiente Kubernetes leve que roda em sua máquina local.

Navegue para o seu diretório de trabalho:

Abra o terminal e navegue até a pasta do projeto padrão:
```
cd /home/labex/project
```
Iniciar o Minikube:

Inicie o Minikube para inicializar um cluster Kubernetes:
```
minikube start
```
- Este comando configura um cluster Kubernetes de nó único em sua máquina local.
- O Minikube pode levar alguns minutos para iniciar, dependendo do desempenho do seu sistema.
Verifique se o Minikube está em execução:

Verifique o status do cluster Minikube:
```
minikube status
```
- Procure por componentes como kubelet e apiserver listados como Running.
- Se o cluster não estiver em execução, execute novamente minikube start.

Se você encontrar problemas ao iniciar o Minikube. Use minikube delete para redefinir o ambiente, se necessário.

Instalar o Controlador Nginx Ingress

Primeiro, precisamos instalar o controlador nginx-ingress em nosso cluster. Podemos fazer isso criando um Deployment e um Service que serão responsáveis por executar o controlador Ingress.

Crie um namespace para o controlador Ingress:

kubectl create namespace ingress-nginx

Instale o chart ingress-nginx usando kubectl:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.7.0/deploy/static/provider/cloud/deploy.yaml

Verifique se os pods do controlador ingress-nginx estão em execução:

kubectl get pods -n ingress-nginx

NAME                                        READY   STATUS              RESTARTS   AGE
ingress-nginx-admission-create-zjfqx        0/1     ContainerCreating   0          2s
ingress-nginx-admission-patch-8rvzw         0/1     ContainerCreating   0          2s
ingress-nginx-controller-6bdb654777-qz8fb   0/1     ContainerCreating   0          2s

Criar uma Aplicação de Exemplo

Em seguida, criaremos uma aplicação de exemplo que exporemos usando o Ingress.

Crie um Deployment para uma aplicação de exemplo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: sample-app
  template:
    metadata:
      labels:
        app: sample-app
    spec:
      containers:
      - name: sample-app
        image: nginx
        ports:
        - containerPort: 80

O arquivo YAML chamado sample-app.yaml. Aplique o deployment ao seu cluster com o seguinte comando:

kubectl apply -f sample-app.yaml

Crie um Service para a aplicação de exemplo:

apiVersion: v1
kind: Service
metadata:
  name: sample-app
spec:
  selector:
    app: sample-app
  ports:
  - name: http
    port: 80
    targetPort: 80

O arquivo YAML chamado service-sample-app.yaml. Aplique o deployment ao seu cluster com o seguinte comando:

kubectl apply -f service-sample-app.yaml

Criar um Recurso Ingress

Agora que temos o controlador Ingress configurado e um serviço de backend em execução, podemos criar as regras para o recurso Ingress.

Neste exemplo, criaremos uma regra simples para rotear o tráfego para o domínio test.local para o nosso serviço de backend:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: test.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: sample-app
            port:
              name: http

O arquivo YAML chamado ingress.yaml. Aplique o recurso Ingress ao cluster:

kubectl apply -f ingress.yaml

Testar o Recurso Ingress

Finalmente, podemos testar o recurso Ingress para garantir que tudo está funcionando corretamente.

Primeiro, determine o endereço IP do nó:

kubectl get node -o wide

NAME       STATUS   ROLES           AGE   VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION      CONTAINER-RUNTIME
minikube   Ready    control-plane   93s   v1.26.1   192.168.49.2   <none>        Ubuntu 20.04.5 LTS   5.15.0-56-generic   docker://20.10.23

Este comando obterá o endereço do nó Kubernetes. O endereço IP rotulado como INTERNAL-IP.

Em seguida, adicione uma entrada ao seu arquivo /etc/hosts para mapear o domínio test.local para o endereço IP do nó:

echo "<IP_ADDRESS> test.local" | sudo tee -a /etc/hosts

Substitua <IP_ADDRESS> pelo endereço IP interno do nó. Por exemplo:

echo "192.168.49.2 test.local" | sudo tee -a /etc/hosts

Em seguida, obtenha o NodePort do serviço para ingress-nginx.

kubectl get services -n ingress-nginx

Este comando exibirá uma lista de serviços no namespace ingress-nginx. Procure o serviço nginx-ingress-controller e anote seu NodePort.

NAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.104.99.158   <pending>     80:32518/TCP,443:31620/TCP   2m45s
ingress-nginx-controller-admission   ClusterIP      10.100.46.109   <none>        443/TCP                      2m45s

Finalmente, use curl para fazer uma requisição HTTP para o endpoint Ingress:

curl test.local:NodePort

Por exemplo:

curl test.local:32518

Substitua <NodePort> pelo NodePort do serviço nginx-ingress-controller.

Se tudo estiver configurado corretamente, você deverá ver a página de boas-vindas do Nginx.

Você também pode testar o Ingress usando um navegador web para visitar test.local:<NodePort>/nginx.

Parabéns, você configurou com sucesso um recurso Ingress no Kubernetes e o testou para garantir que está funcionando corretamente.

Resumo

Neste laboratório, percorremos o processo de configuração e ajuste de um controlador Ingress Nginx no Kubernetes. Também criamos uma aplicação de exemplo e usamos o Ingress para rotear o tráfego externo para o nosso serviço Nginx. Este é apenas o começo do que você pode fazer com a rede Kubernetes, e nós o encorajamos a explorar mais.

Rede com Ingress no Kubernetes