Kubernetes Port Forward: Guia Completo

Introdução

Neste laboratório, você aprenderá como usar o comando port-forward do Kubernetes para encaminhar uma porta local para uma porta em um pod. O encaminhamento de porta (port forwarding) é uma ferramenta crucial de depuração que permite acessar com segurança aplicativos em execução no seu cluster sem expô-los à internet. Você começará com exemplos simples e progredirá gradualmente para cenários mais complexos, incluindo o trabalho com múltiplas portas, múltiplos contêineres e serviços.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 97%. Recebeu uma taxa de avaliações positivas de 94% dos estudantes.

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 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 (Em execução).
- 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.

Explorar o Comando kubectl port-forward

O comando kubectl port-forward permite encaminhar uma ou mais portas locais para um pod, deployment ou serviço em seu cluster Kubernetes. Ele é comumente usado para testar e depurar serviços sem expô-los externamente.

Execute o seguinte comando para visualizar as opções disponíveis para kubectl port-forward:

kubectl port-forward -h

Você verá a seguinte saída:

Forward one or more local ports to a pod.

Use resource type/name such as deployment/mydeployment to select a pod. Resource type defaults to 'pod' if omitted.

If there are multiple pods matching the criteria, a pod will be selected automatically. The forwarding session ends
when the selected pod terminates, and a rerun of the command is needed to resume forwarding.

Examples:
  ## Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in the pod
  kubectl port-forward pod/mypod 5000 6000

  ## Listen on ports 5000 and 6000 locally, forwarding data to/from ports 5000 and 6000 in a pod selected by the deployment
  kubectl port-forward deployment/mydeployment 5000 6000

  ## Listen on port 8443 locally, forwarding to the targetPort of the service's port named "https" in a pod selected by the service
  kubectl port-forward service/myservice 8443:https

  ## Listen on port 8888 locally, forwarding to 5000 in the pod
  kubectl port-forward pod/mypod 8888:5000

  ## Listen on port 8888 on all addresses, forwarding to 5000 in the pod
  kubectl port-forward --address 0.0.0.0 pod/mypod 8888:5000

  ## Listen on port 8888 on localhost and selected IP, forwarding to 5000 in the pod
  kubectl port-forward --address localhost,10.19.21.23 pod/mypod 8888:5000

  ## Listen on a random port locally, forwarding to 5000 in the pod
  kubectl port-forward pod/mypod :5000

Encaminhamento de Porta Local para um Pod

Nesta etapa, você aprenderá como encaminhar uma porta local para uma porta em um pod. Isso é útil para depurar aplicativos ou acessar serviços que não são expostos fora do cluster.

Observação sobre o gerenciamento do terminal:

O comando kubectl port-forward continuará em execução no seu terminal e o bloqueará para outros usos
Você precisará abrir uma nova janela do terminal para executar comandos adicionais enquanto o encaminhamento de porta estiver ativo
Para parar o encaminhamento de porta a qualquer momento, você pode pressionar Ctrl+C no terminal onde ele está sendo executado

Comece criando um deployment com uma réplica e um contêiner Nginx:
```
kubectl create deployment nginx --image=nginx --replicas=1
```
Este comando cria um deployment executando a imagem oficial do contêiner Nginx.

Aguarde o pod ficar pronto:

kubectl wait --for=condition=Ready pod -l app=nginx

Obtenha o nome do pod que usaremos para o encaminhamento de porta:

kubectl get pod -l app=nginx

Você deve ver uma saída semelhante a:

NAME                     READY   STATUS    RESTARTS   AGE
nginx-66b6c48dd5-abcd1   1/1     Running   0          30s

Use o comando kubectl port-forward para encaminhar uma porta local para o pod:

Primeiro, obtenha o nome do seu pod:
```
export POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')
echo $POD_NAME
```
Você deve ver uma saída como:
```
nginx-748c667d99-pdhzs
```
Agora use o nome do pod para configurar o encaminhamento de porta:
```
kubectl port-forward $POD_NAME 19000:80
```
Você deve ver uma saída como:
```
Forwarding from 127.0.0.1:19000 -> 80
Forwarding from [::1]:19000 -> 80
```
Abra uma nova janela do terminal (já que o port-forward continua em execução no terminal atual) e verifique o encaminhamento de porta:
```
curl http://localhost:19000
```
Você deve ver o conteúdo HTML da página de boas-vindas do Nginx.

Você também pode abrir um navegador da web e visitar http://localhost:19000 para ver a página renderizada.

Encaminhamento de Múltiplas Portas Locais para um Pod

Antes de iniciar esta etapa, você precisa:

Parar o encaminhamento de porta da Etapa 1, voltar para aquele terminal e pressionar Ctrl+C

Nesta etapa, você aprenderá como encaminhar várias portas locais para um pod. Vamos encaminhar duas portas locais diferentes para a mesma porta do contêiner, o que é útil quando você deseja fornecer diferentes pontos de acesso ao mesmo serviço.

Use os seguintes comandos para configurar o encaminhamento de porta:

Primeiro, obtenha o nome do seu pod, se você ainda não o fez:
```
export POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')
echo $POD_NAME
```
Você deve ver uma saída como:
```
nginx-748c667d99-pdhzs
```
Agora configure o encaminhamento de porta para mapear duas portas locais (19080 e 19081) para a porta 80 do contêiner:
```
## The correct format is: kubectl port-forward POD_NAME LOCAL_PORT:CONTAINER_PORT [LOCAL_PORT:CONTAINER_PORT ...]
kubectl port-forward pod/$POD_NAME 19080:80 19081:80
```
Você deve ver uma saída como:
```
Forwarding from 127.0.0.1:19080 -> 80
Forwarding from [::1]:19080 -> 80
Forwarding from 127.0.0.1:19081 -> 80
Forwarding from [::1]:19081 -> 80
```
Este comando encaminha:
- Porta local 19080 para a porta 80 do contêiner
- Porta local 19081 para a porta 80 do contêiner
Ambas as portas locais são mapeadas para a mesma porta 80 do contêiner Nginx, permitindo que você acesse o mesmo servidor web por meio de diferentes portas locais.

Verifique o encaminhamento de porta verificando as portas de escuta:

ss -tulnp | grep 1908

Você deve ver uma saída semelhante a esta:

tcp   LISTEN  0       4096         0.0.0.0:19080     0.0.0.0:*
tcp   LISTEN  0       4096         0.0.0.0:19081     0.0.0.0:*

Agora você pode acessar a página de boas-vindas do Nginx por meio de qualquer porta:
- http://localhost:19080
- http://localhost:19081
```
curl http://localhost:19080
```
```
curl http://localhost:19081
```

Ambas as URLs mostrarão a mesma página de boas-vindas do Nginx, pois ambas são encaminhadas para a mesma porta do contêiner.

Encaminhamento de Porta Local para um Pod com Múltiplos Containers

Antes de iniciar esta etapa:

Se você tiver algum comando de encaminhamento de porta em execução das etapas anteriores, vá para esses terminais e pressione Ctrl+C para pará-los
Começaremos do zero com uma nova configuração de pod com múltiplos contêineres

Nesta etapa, você aprenderá como encaminhar uma porta local para um contêiner específico em um pod com múltiplos contêineres. Este é um cenário comum em arquiteturas de microsserviços onde sidecars são usados.

Primeiro, vamos limpar os recursos anteriores:
```
kubectl delete deployment nginx
```

Crie um pod com dois contêineres: Nginx e BusyBox:

cat << EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: nginx-busybox
  labels:
    app: nginx-multi
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80
  - name: busybox
    image: busybox
    command: ['sh', '-c', 'while true; do sleep 3600; done']
EOF

Aguarde o pod ficar pronto:

kubectl wait --for=condition=Ready pod/nginx-busybox

Verifique se ambos os contêineres estão em execução:
```
kubectl get pod nginx-busybox -o wide
```
Você deve ver 2/2 na coluna READY.
Use o comando kubectl port-forward para encaminhar uma porta local para o contêiner Nginx:
```
kubectl port-forward pod/nginx-busybox 19001:80
```
Em um novo terminal, verifique a conexão:
```
curl http://localhost:19001
```
Você deve ver o conteúdo HTML da página de boas-vindas do Nginx.

Usando Port-Forward com Kubernetes Services

Antes de iniciar esta etapa:

Se você tiver algum comando de encaminhamento de porta em execução da Etapa 3, vá para aquele terminal e pressione Ctrl+C para pará-lo
Tenha em mente que criaremos um novo deployment e service nesta etapa, mas você não precisa excluir o pod anterior, pois ele não interferirá em nossos novos recursos

Nesta etapa, você aprenderá como usar o comando kubectl port-forward com Kubernetes services. O encaminhamento de porta para um service é diferente do encaminhamento de porta para um pod porque permite que você acesse qualquer pod ao qual o service aponta.

Primeiro, crie um novo deployment com múltiplas réplicas:

kubectl create deployment nginx-service --image=nginx --replicas=3

Aguarde todos os pods ficarem prontos:

kubectl wait --for=condition=Ready pod -l app=nginx-service

Crie um service para o deployment:

kubectl expose deployment nginx-service --port=80 --type=ClusterIP --name=nginx-service

Verifique se o service foi criado:

kubectl get service nginx-service

Você deve ver uma saída como:

NAME           TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)   AGE
nginx-service  ClusterIP   10.96.123.456   <none>        80/TCP    10s

Use o comando kubectl port-forward para encaminhar uma porta local para o service:
```
kubectl port-forward service/nginx-service 20000:80
```
Em um novo terminal, teste a conexão:
```
curl http://localhost:20000
```
Você deve ver o conteúdo HTML da página de boas-vindas do Nginx. Tente executar este comando várias vezes - você pode notar respostas vindas de diferentes pods por trás do service.

Resumo

Neste laboratório, você aprendeu como usar o comando Kubernetes port-forward de forma eficaz em vários cenários. Você praticou:

Encaminhar uma única porta local para um pod
Encaminhar múltiplas portas locais para a mesma porta do contêiner
Trabalhar com pods de múltiplos contêineres e encaminhamento de porta
Encaminhamento de porta para Kubernetes services

Essas habilidades são essenciais para depurar e testar aplicações em um cluster Kubernetes. O encaminhamento de porta fornece uma maneira segura de acessar suas aplicações durante o desenvolvimento e a solução de problemas, sem expô-las à internet pública.

Alguns pontos-chave:

O encaminhamento de porta é uma conexão temporária que dura apenas enquanto o comando kubectl port-forward estiver em execução
Você pode encaminhar múltiplas portas locais para a mesma porta do contêiner
O encaminhamento de porta funciona com pods e services
Ao encaminhar a porta para um service, as requisições podem ser distribuídas entre múltiplos pods

Lembre-se de que o encaminhamento de porta é principalmente uma ferramenta de depuração e não deve ser usado para acesso de produção a aplicações. Para cenários de produção, você deve usar os tipos de Kubernetes Service adequados (LoadBalancer, NodePort) ou controladores Ingress.

Comando Kubernetes Port Forward