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.
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/projectIniciar 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
kubeleteapiserverlistados comoRunning(Em execução). - Se o cluster não estiver em execução, execute novamente
minikube start.
- Procure por componentes como
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-forwardcontinuará 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+Cno 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=1Este 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=nginxObtenha o nome do pod que usaremos para o encaminhamento de porta:
kubectl get pod -l app=nginxVocê deve ver uma saída semelhante a:
NAME READY STATUS RESTARTS AGE nginx-66b6c48dd5-abcd1 1/1 Running 0 30sUse o comando
kubectl port-forwardpara 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_NAMEVocê deve ver uma saída como:
nginx-748c667d99-pdhzsAgora use o nome do pod para configurar o encaminhamento de porta:
kubectl port-forward $POD_NAME 19000:80Você deve ver uma saída como:
Forwarding from 127.0.0.1:19000 -> 80 Forwarding from [::1]:19000 -> 80Abra 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:19000Você 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:19000para 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_NAMEVocê deve ver uma saída como:
nginx-748c667d99-pdhzsAgora 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:80Você 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 -> 80Este 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 1908Você 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:
curl http://localhost:19080curl 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+Cpara 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 nginxCrie 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'] EOFAguarde o pod ficar pronto:
kubectl wait --for=condition=Ready pod/nginx-busyboxVerifique se ambos os contêineres estão em execução:
kubectl get pod nginx-busybox -o wideVocê deve ver
2/2na colunaREADY.Use o comando
kubectl port-forwardpara encaminhar uma porta local para o contêiner Nginx:kubectl port-forward pod/nginx-busybox 19001:80Em um novo terminal, verifique a conexão:
curl http://localhost:19001Você 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+Cpara 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=3Aguarde todos os pods ficarem prontos:
kubectl wait --for=condition=Ready pod -l app=nginx-serviceCrie um service para o deployment:
kubectl expose deployment nginx-service --port=80 --type=ClusterIP --name=nginx-serviceVerifique se o service foi criado:
kubectl get service nginx-serviceVocê 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 10sUse o comando
kubectl port-forwardpara encaminhar uma porta local para o service:kubectl port-forward service/nginx-service 20000:80Em um novo terminal, teste a conexão:
curl http://localhost:20000Você 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-forwardestiver 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.
