Solução de problemas de conexão para pods ou serviços em um cluster do AKS (tráfego interno)

Artigo
10/15/2024

Este artigo discute como solucionar problemas de conexão com pods ou serviços como tráfego interno de dentro do mesmo cluster do AKS (Serviços de Kubernetes do Microsoft Azure).

Pré-requisitos

A ferramenta kubectl do Kubernetes ou uma ferramenta semelhante para se conectar ao cluster. Para instalar o kubectl usando a CLI do Azure, execute o comando az aks install-cli .
A ferramenta de linha de comando apt-get para lidar com pacotes.
A ferramenta URL do cliente (cURL) ou uma ferramenta de linha de comando semelhante.
A ferramenta de linha de comando Netcat (nc) para conexões TCP.

Lista de verificação de solução de problemas

Etapa 1: Configurar o pod de teste e a porta do servidor remoto

Configure o pod de teste e certifique-se de que a porta necessária esteja aberta no servidor remoto. No pod de origem (ou em um pod de teste que esteja no mesmo namespace que o pod de origem), siga estas etapas:

Inicie um pod de teste no cluster executando o comando kubectl run :

kubectl run -it --rm aks-ssh --namespace <namespace> --image=debian:stable

Depois de obter acesso ao pod, execute os seguintes apt-get comandos para instalar os pacotes DNS Utils, cURL e Netcat:
```
apt-get update -y
apt-get install dnsutils -y
apt-get install curl -y
apt-get install netcat-openbsd -y
```
Depois que os pacotes forem instalados, execute o seguinte comando cURL para testar a conectividade com o endereço IP do pod:
```
curl -Iv http://<pod-ip-address>:<port>
```
Execute o comando Netcat para verificar se o servidor remoto abriu a porta necessária:
```
nc -z -v <endpoint> <port>
```

Etapa 2: Visualizar informações operacionais sobre pods, contêineres, serviços do Kubernetes e endpoints

Usando kubectl e cURL na linha de comando, siga estas etapas para verificar se tudo funciona conforme o esperado:

Verifique se o pod de destino está ativo e em execução:
```
kubectl get pods -n <namespace-name>
```
Se o pod de destino estiver funcionando corretamente, o status do pod será mostrado como Running, e o pod será mostrado como READY.
```
NAME           READY   STATUS    RESTARTS   AGE
my-other-pod   1/1     Running   0          44m
my-pod         1/1     Running   0          44m
```
Pesquise os logs do pod em busca de erros de acesso:
```
kubectl logs <pod-name> -n <namespace-name>
```
Pesquise os logs do pod para um contêiner individual em um pod de vários contêineres:
```
kubectl logs <pod-name> -n <namespace-name> -c <container-name>
```
Se o aplicativo que está dentro do pod for reiniciado repetidamente, exiba os logs do pod de uma instância de contêiner anterior para obter as mensagens de saída:
```
kubectl logs <pod-name> --previous                      
```
Para o caso de vários contêineres, use o seguinte comando:
```
kubectl logs <pod-name> -c <container-name> --previous  
```
Verifique se há alguma política de rede que possa bloquear o tráfego:
```
kubectl get networkpolicies -A
```
Você deverá ver uma saída semelhante à tabela a seguir.
```
NAMESPACE     NAME                 POD-SELECTOR             AGE
kube-system   konnectivity-agent   app=konnectivity-agent   4d1h
```
Se você vir qualquer outra política de rede criada de forma personalizada, verifique se ela está bloqueando o acesso de ou para os pods.
Verifique se você pode acessar o aplicativo a partir do endereço IP do serviço. Primeiro, mostre detalhes sobre o recurso de serviço, como o endereço IP externo e a porta, executando o kubectl get services comando:
```
kubectl get services -n <namespace-name>
```
```
NAME         TYPE           CLUSTER-IP   EXTERNAL-IP      PORT(S)        AGE
my-service   LoadBalancer   10.0.21.43   20.119.121.232   80:31773/TCP   28s
```
Em seguida, execute o cURL usando o endereço IP e a porta do serviço para verificar se você pode acessar o aplicativo:
```
curl -Iv http://20.119.121.232:80
.
.
.
< HTTP/1.1 200 OK
HTTP/1.1 200 OK
```

Obtenha informações mais detalhadas sobre o serviço:

kubectl describe services <service-name> -n <namespace-name>

Verifique o endereço IP do pod:

kubectl get pods -o wide

NAME            READY   STATUS        RESTARTS   AGE   IP            NODE                                
my-pod          1/1     Running       0          12m   10.244.0.15   aks-agentpool-000000-vmss000000

Verifique se o endereço IP do pod existe como um endpoint no serviço:

kubectl describe services my-cluster-ip-service

Name:              my-cluster-ip-service
Namespace:         default
Selector:          app=my-pod
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.0.174.133
IPs:               10.0.174.133
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.0.15:80     # <--- Here

Verifique os pontos de extremidade diretamente:

kubectl get endpoints

NAME                      ENDPOINTS           AGE
my-cluster-ip-service     10.244.0.15:80      14m

Se a conexão com um serviço não funcionar, reinicie os kube-proxy pods e CoreDNS:

kubectl delete pods -n kube-system -l component=kube-proxy
kubectl delete pods -n kube-system -l k8s-app=kube-dns

Verifique se o nó não está sendo usado em excesso:
```
kubectl top nodes
```
Observação

Você também pode usar o Azure Monitor para obter os dados de uso do cluster.

Entre em contato conosco para obter ajuda

Se você tiver dúvidas ou precisar de ajuda, crie uma solicitação de suporte ou peça ajuda à comunidade de suporte do Azure. Você também pode enviar comentários sobre o produto para a comunidade de comentários do Azure.

Partilhar via