Conectando Pods com Kubernetes Services

Introdução

No Kubernetes, os Pods são efêmeros e podem ser encerrados e recriados a qualquer momento. Isso apresenta um desafio em relação à rede, pois é difícil conectar-se diretamente a um Pod. Para resolver esse problema, o Kubernetes oferece uma abstração de nível superior chamada Service. 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 conectar Pods via rede usando Services no Kubernetes.

Iniciar o Cluster Minikube

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

Navegue até o seu diretório de trabalho:

Abra o terminal e navegue até a pasta padrão do projeto:
```
cd /home/labex/project
```
Inicie 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 minikube start novamente.

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:

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

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

Criar um Service

O segundo passo é criar um Service que direcione o tráfego 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:

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

Isso criará um Service chamado my-service que aponta 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 a partir 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: busybox
      command:
        - sleep
        - "3600"

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

minikube 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, acesse o Service a partir do Pod Busybox com wget:

minikube kubectl -- exec test-pod-1 -- wget -qO- http://my-service

Este comando retorna a página padrão do Nginx, indicando que o Service está funcionando corretamente.

Atualizar o Service

O quarto passo é atualizar o Service para apontar 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: 80

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

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

Isso atualizará o Service para apontar para Pods com o rótulo app=busybox. Neste ponto, o Service não possui endpoints, pois nenhum dos Pods existentes usa esse rótulo ainda.

Testar o Service Atualizado

O quinto passo é testar o Service atualizado acessando-o a partir de outro Pod. Crie um novo Pod de teste com o seguinte comando:

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

Antes de alterar quaisquer rótulos, confirme que o Service não possui endpoints correspondentes:

minikube kubectl -- get endpoints my-service

A saída deve mostrar <none> porque nenhum Pod atualmente possui o rótulo app=busybox.

Isso acontece porque o seletor do Service agora procura por app=busybox, mas seu Pod de servidor Nginx ainda está rotulado como app=nginx. Para corrigir isso, altere o rótulo do Pod de servidor original para que o Service aponte para o container Nginx novamente.

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

minikube kubectl -- label pod my-pod-1 app=busybox --overwrite

Isso atualiza o rótulo em my-pod-1 para que ele corresponda ao seletor do Service.

Agora teste o Service novamente a partir do my-pod-2:

minikube kubectl -- exec my-pod-2 -- wget -qO- http://my-service

Este comando deve retornar a página padrão do Nginx, indicando que o Service está funcionando corretamente novamente.

Resumo

Neste laboratório, você aprendeu como conectar Pods via rede usando Services no Kubernetes. Você criou um Pod Nginx, expôs o mesmo com um Service e testou esse Service a partir de Pods clientes Busybox. Você também atualizou o seletor do Service e alterou o rótulo do Pod Nginx original para que o Service voltasse a apontar para um servidor web funcional. Os Services são um componente essencial da rede no Kubernetes e permitem que você se conecte aos Pods de forma confiável e escalável.