Aula 5 : Escalando aplicações​

• Expondo aplicações como serviço (Service)
• Configurando dpeloyments com ConfigMap
• Persistindo dados com Volumes

Expondo aplicações via Service

Um recurso Service em Kubernetes permite expor uma aplicação para o mundo externo, fornecendo uma porta de entrada única para que os clientes possam acessar a aplicação.

Caso de uso para Service

• Acesso a aplicações em um cluster: Quando você tem vários Pods rodando sua aplicação, o Service fornece uma maneira consistente de acessar todos eles.
• Balanceamento de carga: O Service pode ser configurado para distribuir o tráfego entre vários Pods, proporcionando alta disponibilidade e escalabilidade.
• Rede interna: O Service também facilita a comunicação entre os Pods dentro do cluster.

Para testes locais com Kind, use service tipo NodePort.

Tipos de Services:

1. ClusterIP: Fornece acesso apenas dentro do cluster.
2. NodePort: Expõe a aplicação em um porto no nó do cluster (geralmente na faixa de 30000-32767).
3. LoadBalancer: Utiliza um balanceador de carga externo (como o AWS ELB, Google Cloud Load Balancer) para distribuir o tráfego.

Listando Services de um Namespace

Para listar todos os Services em um namespace específico, você pode usar o comando kubectl get services --namespace <nome-do-namespace>.

Deletando um Service

Para deletar um Service, você pode usar o comando kubectl delete service <nome-do-service> --namespace <nome-do-namespace>.

Conhecendo o kubectl expose

O comando kubectl expose expõe um recurso como um serviço do Kubernetes. Podem ser Deployment, Pod, ReplicaSet e usa um seletor para aquele recurso em uma determinada porta IPv4.

É importante que o cluster Kind tenha sido criado com a configuração de mapeamento da porta que deseja utilizar.

• Exponha o Pod ou deployment

kubectl expose po nginx --name=nginx-service --port=80

• Edite o service para informar a porta desejada:

kubectl edit svc nginx
# Edite o trecho do yaml com o valor da porta:
ports:
  - nodePort: 30800
    port: 80
    protocol: TCP
    targetPort: 80
# Salve o arquivo

• Verifique que o service está utilizando a porta definida, 30800:

k get svc
NAME         TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1     <none>        443/TCP        5m39s
nginx        NodePort    10.96.176.2   <none>        80:30800/TCP   19s

Acessando um service pelo DNS do Kubernetes

Quando você cria um Service do tipo ClusterIP, ele automaticamente cria um DNS para esse serviço dentro do cluster. Você pode acessar o serviço pelo nome do serviço no formato <nome-do-servico>.<namespace>.svc.cluster.local.

curl meu-pod.default.svc.cluster.local:5000/api/people

Descrevendo um serviço

Para descrever um serviço chamado app-svc usando kubectl, execute:

kubectl describe svc app-svc

Criando um Service via template

Vamos criar um Service para o nosso Deployment de Nginx. Primeiro, certifique-se que você tem um Deployment configurado:

kubectl create deploy nginx --image=nginx:latest --replicas=1

• Crie o arquivo service.yaml com o seguinte conteudo:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
  - name: http
    port: 80
    nodePort: 30800

• Aplique o recurso utilizando kubectl:

kubectl apply -f service.yaml
kubectl get service

Redirecionamento de portas

O comando kubectl port-forward permite usar o nome do recurso, como o nome do pod, deployment ou service, para encaminhar a porta para acesso local (do host para o cluster).

Para redirecionar o service Postgres, execute:

$ kubectl port-forward service/postgres :5432
Forwarding from 127.0.0.1:54424 -> 5432
Forwarding from [::1]:54424 -> 5432

Neste exemplo:

• service/postgresql: É o nome do serviço. Pode ser obtido via kubectl
• 5432: É a porta que o service expõe no cluster.
• 127.0.0.1:54424: É a porta alocada no Host, no caso, sua máquina local.

Nota: O kubectl port-forward não retorna. Ele alocal o terminal atual. Para continuar com os exercícios, você precisará abrir outro terminal.

Exercicios

• Crie um namespace dev e outro prod

kubectl create ns dev
kubectl create ns prod

• Listar namespaces

kubectl get namespace

• Alterar para um namespace

kubectl config set-context --current --namespace=prod

• Listar recursos de um namespace especifico

kubectl get all --namespace dev

• Crie o arquivo postgres-deploy.yaml com o conteudo:

  apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-claim
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 5Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgresql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgresql
  template:
    metadata:
      labels:
        app: postgresql
    spec:
      containers:
      - name: postgresql-container
        image: postgres:latest
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: postgresql-pv
          mountPath: /var/lib/postgresql/data
        env:
        - name: POSTGRES_USER
          value: "myuser"
        - name: POSTGRES_PASSWORD
          value: "mypassword"
        - name: POSTGRES_DB
          value: "mydb"
      volumes:
      - name: postgresql-pv
        persistentVolumeClaim:
          claimName: postgres-claim

• Crie o deployment no namespace prod:

kubectl apply -f postgres-deploy.yaml -n prod

• Verificar que o Deployment foi criado e o Pod está Running:

kubectl get deploy
kubectl get pod

• Exponha o Deployment do Postgres como serviço:

kubectl expose deploy postgresql --port=5432

• Crie um Pod com ubuntu para testar a conexão ao banco de dados:

kubectl run ubuntu-pod --image=ubuntu --command -- /bin/bash -c "while true; do sleep 3000; done;"

• Obtenha o IP do Service do Postgres:

$ kubectl get svc
NAME                    TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
postgresql              ClusterIP   10.96.183.144   <none>        5432/TCP   2s

• Acesse o ubuntu-pod e atualize e instale os pacotes necessarios para acessar o banco:

kubectl exec -it ubuntu-pod -- /bin/bash
apt update && apt install -y postgresql-client curl
exit

• Acesse o serviço do Postgres com as informações do Deployment:

kubectl exec -it ubuntu-pod -- /bin/bash
psql -U myuser -h 10.96.183.144 -d mydb

• Crie uma tabela usuários:

CREATE TABLE usuarios (
  id SERIAL PRIMARY KEY,
  nome VARCHAR(255) NOT NULL
);

• Verifique as informações da tabela criada:

\d usuarios;

• Crie dois registros para teste:

INSERT INTO usuarios (nome) VALUES ('João');
INSERT INTO usuarios (nome) VALUES ('Maria');

\d usuario;

SELECT * FROM usuarios;

Neste momento, o Pod ubuntu-pod conseguiu acessar o Serviço do Postgres implantado no cluster.

---