Conectando Pods com Services Kubernetes - Guia Prático

Introdução

No Kubernetes, os Pods são efêmeros e podem ser terminados e recriados a qualquer momento. Isso apresenta um desafio quando se trata de rede, pois é difícil conectar-se a um Pod diretamente. Para resolver esse problema, o Kubernetes fornece uma abstração de nível superior chamada Service (Serviço). Um Service fornece um endereço IP estável e um nome DNS para um conjunto de Pods, permitindo que outros componentes se conectem a eles facilmente. Neste laboratório, você aprenderá como fazer a rede de Pods com Services no Kubernetes.

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.
Verificar 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.

Criar um Pod

O primeiro passo é criar um Pod simples. Crie um arquivo chamado /home/labex/project/myapp-pod.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod-1
  labels:
    app: nginx
spec:
  containers:
    - name: my-container
      image: nginx

Salve o arquivo e crie o Pod executando o seguinte comando:

kubectl apply -f /home/labex/project/myapp-pod.yaml

Isso criará um Pod chamado my-pod-1 com um único container executando a imagem Nginx.

Criar um Service

O segundo passo é criar um Service que direciona para o Pod que você criou no passo anterior. Crie um arquivo chamado /home/labex/project/service.yaml com o seguinte conteúdo:

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

Salve o arquivo e crie o Service executando o seguinte comando:

kubectl apply -f /home/labex/project/service.yaml

Isso criará um Service chamado my-service que direciona para Pods com o rótulo app=nginx e expõe a porta 80.

Testar o Service

O terceiro passo é testar o Service acessando-o de outro Pod. Crie um arquivo chamado /home/labex/project/test-pod-1.yaml com o seguinte conteúdo:

apiVersion: v1
kind: Pod
metadata:
  name: test-pod-1
spec:
  containers:
    - name: my-container
      image: nginx
      command:
        - sleep
        - "3600"

Salve o arquivo e crie o Pod de teste executando o seguinte comando:

kubectl apply -f /home/labex/project/test-pod-1.yaml

Isso criará um Pod chamado test-pod-1 com um único container executando a imagem Busybox.

Em seguida, você fará o exec no container e usará curl para acessar o Service. Execute o seguinte comando para fazer o exec no container:

kubectl exec -it test-pod-1 -- sh

Isso abrirá um shell dentro do container. Do shell, execute o seguinte comando para acessar o Service:

curl http://my-service

Isso retornará a página padrão do Nginx, indicando que o Service está funcionando corretamente.

Atualizar o Service

O quarto passo é atualizar o Service para direcionar para um conjunto diferente de Pods. Atualize o campo selector no arquivo /home/labex/project/service.yaml para o seguinte:

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: busybox
  ports:
    - name: http
      port: 80
      targetPort: 8

Salve o arquivo e atualize o Service executando o seguinte comando:

kubectl apply -f service.yaml

Isso atualizará o Service para direcionar para Pods com o rótulo app=busybox.

Testar o Service Atualizado

O quinto passo é testar o Serviço atualizado, acessando-o de outro Pod. Crie um novo Pod de teste com o seguinte comando:

kubectl run my-pod-2 --image=busybox --restart=Never -- sleep 3600

Isso criará um novo Pod chamado my-pod-2 com um único container executando a imagem Busybox.

Faça o exec no container e use curl para acessar o Serviço, como você fez no Passo 3. Execute o seguinte comando para fazer o exec no container:

kubectl exec -it my-pod-2 -- sh

Desta vez, você deverá obter um erro indicando que a conexão foi recusada.

Isso ocorre porque o Serviço agora está direcionando um conjunto diferente de Pods daqueles em que o Pod de teste está sendo executado. Para corrigir isso, você pode atualizar o rótulo do Pod para corresponder ao novo seletor no Serviço.

Execute o seguinte comando para atualizar o rótulo do Pod de teste:

kubectl label pod my-pod-2 app=busybox

Isso adicionará o rótulo app=busybox ao Pod de teste.

Agora, se você executar o comando curl novamente, deverá obter a página Nginx padrão, indicando que o Serviço está funcionando corretamente.

Resumo

Neste laboratório, você aprendeu como conectar Pods com Services no Kubernetes. Você criou um Pod simples executando a imagem Nginx, criou um Service para direcionar o Pod e testou o Service acessando-o de outro Pod. Você também aprendeu como atualizar o Service para direcionar um conjunto diferente de Pods e como atualizar o rótulo de um Pod para corresponder ao novo seletor no Service. Services são um componente essencial de rede no Kubernetes e permitem que você se conecte aos Pods de maneira confiável e escalável.