Aula 4: Implantação em cluster

• Gerenciando software com Deployments
• O que são ReplicaSets
• O que são Replicas
• Template Deployment
• Organizando recursos dentro de um cluster (Namespaces)

Gerenciando software com Deployments

Um Deployment no Kubernetes é uma abstração que representa o conjunto de configurações para implantar e gerenciar aplicações em clusters. Ele permite a criação, atualização ou eliminação de aplicativos com precisão controlada, sem interrupções desnecessárias.

Usos típicos de Deployments:

• Implantações contínuas: Garantir que uma determinada quantidade de réplicas (pods) esteja sempre em execução.
• Declaração do novo estado dos Pods atualizando o PodTemplateSpec da aplicação de rollout: O novo ReplicaSet é criado e a aplicação de rollout gerencia mover os pods do anterior ReplicaSet para o novo, num ritmo controlado. Cada novo ReplicaSet atualiza a revisão da aplicação de rollout.
• Reverter à uma revisão anterior se o estado atual não for estável: A cada rollback, a revisão da aplicação de rollout é atualizada.
• Escalar a aplicação para facilitar carregas maiores.
• Pausar o roll-out de uma aplicação para aplicar múltiplas correções no PodTemplateSpec e em seguida retomá-lo para iniciar um novo roll-out
• Usar o status da aplicação como indicador de que o roll-out ficou preso.
• Limpar os ReplicaSets mais antigos que você não precisa mais

Características principais:

• Control sobre replicação: Define quão muitas instâncias da aplicação devem estar rodando em todo momento.
• Atualizações controladas: Permite realizar atualizações de aplicações com precisão controlada, minimizando interrupções.
• Recuperação automática: No caso de falhas ou outros problemas, o Deployment pode ser configurado para reconstruir a aplicação automaticamente.

Criando Deployments:

1. Crie um arquivo YAML que define o Deployment desejado.
2. Utilize kubectl apply para criar o Deployment.
3. Quando precisar atualizar o Deployment, faça alterações no arquivo YAML e aplique-as novamente com kubectl apply.
4. O Kubernetes gerenciará a atualização da aplicação.

Exemplo básico:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: meu-aplicativo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: meu-aplicativo
  template:
    metadata:
      labels:
        app: meu-aplicativo
    spec:
      containers:
      - name: meu-container
        image: exemplo/imagem-do-meuprojeto:latest

Essa configuração define um Deployment chamado meu-aplicativo com três réplicas, usando a imagem exemplo/imagem-do-meuprojeto:latest.

O que são ReplicaSets

Um ReplicaSet (RS) é um objeto Kubernetes responsável por garantir que um número específico de réplicas de contêiner esteja sempre rodando. Ele é usado para replicar aplicativos em clusters Kubernetes, garantindo que haja sempre uma quantidade desejada de instâncias executáveis da aplicação.

O que são Réplicas Em um contexto Kubernetes, uma réplica (ou pod replica) é uma instância isolada e executável do seu contêiner. Em outras palavras, uma réplica é uma cópia de sua aplicação em execução dentro de um contêiner.

Características principais:

• Isolado: Cada réplica tem seu próprio namespace, IP e portas.
• Executável: A réplica representa uma instância executável da sua aplicação.
• Cópias idênticas: Todas as réplicas de um deployment são cópias idênticas da aplicação original.

Propósitos principais:

1. Tolerância a Falhas: Quando uma réplica falha, o Kubernetes pode criar outra réplica para substituí-la.
2. Balanceamento de Carga: O número de réplicas pode ser aumentado ou diminuído para controlar a carga na aplicação.

Exemplo:

Suponha que você esteja executando uma aplicação em seu cluster Kubernetes com um deployment configurado para 3 réplicas. Isso significa que o Kubernetes criará 3 cópias idênticas da sua aplicação, cada uma executando em seu próprio contêiner e com suas próprias informações de rede.

• Réplica 1: A primeira réplica terá seu próprio namespace (ns1), IP (192.168.0.1) e portas (80).
• Réplica 2: A segunda réplica terá seu próprio namespace (ns2), IP (192.168.0.2) e portas (80).
• Réplica 3: A terceira réplica terá seu próprio namespace (ns3), IP (192.168.0.3) e portas (80).

Se uma das réplicas falhar ou precisar ser atualizada, o Kubernetes pode criar outra réplica para substituí-la ou executar a atualização sem interrupções.

O template de um Deployment é um objeto Kubernetes que define a configuração dos pods que serão criados pelo Deployment. Ele especifica os detalhes necessários para criar e gerenciar os pods.

Estrutura do Template:

• apiVersion: A versão da API do Kubernetes utilizada.
• kind: Indicando que é um template de Deployment.
• metadata:
• name: O nome único do Deployment.
• labels: Dicionário de etiquetas para identificar o Deployment.
• spec:
• selector: A seleção dos pods existentes a serem atualizados ou excluídos pelo Deployment.
• template:
  • metadata:
    • name: O nome do template do pod (geralmente igual ao nome do Deployment).
    • labels: Dicionário de etiquetas para identificar o template do pod.
  • spec:
    • containers:
      • name: O nome da imagem Docker a ser utilizada no container.
      • image: A imagem Docker exata que será utilizada (por exemplo, /:).
      • ports e env podem ser adicionados conforme necessário.

Exemplo de Template:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: meuprojeto
spec:
  replicas: 3
  selector:
    matchLabels:
      app: meuprojeto
  template:
    metadata:
      labels:
        app: meuprojeto
    spec:
      containers:
      - name: meucontainer
        image: meu-repositorio/meu-projeto:v1
        ports:
          - containerPort: 8080

Características principais:

• Nível de Replicação: O campo replicas define quantos pods devem ser criados e manter-se no estado ativo.
• Seleção dos Pods: O campo selector permite identificar quais pods existentes devem ser atualizados ou excluídos pelo Deployment.

Escalando aplicações com Kubectl

O comando kubectl scale é utilizado para escalar um recurso do Kubernetes, como um deployment ou um replicaset. Isso permite aumentar ou diminuir o número de replicas de um recurso sem precisar criar uma nova configuração.

Caso de uso:

Um caso de uso comum para escalabilidade é quando a demanda por uma aplicação aumenta durante um período específico, como uma promoção online. Nesse cenário, você pode usar o kubectl scale para aumentar o número de replicas do deployment da aplicação e atender à demanda.

Revertendo implantações com kubectl

O comando kubectl rollout é utilizado para gerenciar a reversão de implantações em um recurso do Kubernetes, como um deployment ou um replicaset.

Caso de uso:

Um caso de uso comum para reversão é quando uma atualização de um deployment causa problemas e você precisa revertê-la para uma versão anterior.

Exercicios

New-Alias -Name k -Value kubectl

0. Acessando kubectl direto do cluster

docker exec -it kind-control-plane /bin/bash
kubectl cluster-info

1. Listando deployments existentes

kubectl get deployments

2. Criando um Deployment via kubectl

kubectl create deployment nginx --image=nginx:latest --replicas=3
$ kubectl get deployments -o wide
NAME    READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES         SELECTOR
nginx   3/3     3            3           35s   nginx        nginx:latest   app=nginx

3. Criando um Deployment com YAML via kubectl

kubectl create deployment nginx --image=nginx:latest --dry-run=client -o yaml > nginx-deployment.yaml
$ cat nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: nginx
  name: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:latest
        name: nginx
        resources: {}
status: {}

4. Descrevendo um Deployment com kubectl

kubectl describe deployment/nginx

5. Atualizando o Deployment para 2 replicas via kubectl

kubectl scale deployment nginx --replicas=2

6. Acessando um Deployment de outro Pod

• List os Pods do deployment nginx
• A partir do ubuntu-pod, execute curl

kubectl get po -o wide
NAME                     READY   STATUS    RESTARTS   AGE   IP           NODE                 NOMINATED NODE   READINESS GATES
app                      1/1     Running   0          46m   10.244.0.5   kind-control-plane   <none>           <none>
nginx-7bf8c77b5b-cnxz5   1/1     Running   0          12m   10.244.0.9   kind-control-plane   <none>           <none>
nginx-7bf8c77b5b-d2xkf   1/1     Running   0          12m   10.244.0.7   kind-control-plane   <none>           <none>
nginx-7bf8c77b5b-mlph7   1/1     Running   0          12m   10.244.0.8   kind-control-plane   <none>           <none>
ubuntu-pod               1/1     Running   0          45m   10.244.0.6   kind-control-plane   <none>           <none>

7. Removendo todos os Pods de um Deployment via kubectl

kubectl scale deployment nginx --replicas=0

8. Obtem informações de status do Deployment

kubectl get deploy nginx -o jsonpath='{.status}

9. Listando logs do Deployment nginx via kubectl

kubectl logs deploy/nginx

10. Obter o histórico de atualizações de um Deployment

kubectl rollout history deployment nginx

11. Criando Deployment para a API App-Py

kubectl create deployment app-py --image=app-py:v0.1 --replicas=3

12. Excluir um Deployment

kubectl delete deployment nginx

13. Realizar Rollback de um Deployment

kubectl rollout undo deployment app-py

14. Reiniciar um Deployment

kubectl rollout restart deployment/nginx

15. Obter informações sobre imagem utilizada por um Deployment

kubectl get deploy nginx -o jsonpath='{.spec.template.spec.containers[0].image}'
nginx:latest

16. Atualizar a imagem do container no Deployment

kubectl set image deployment/nginx nginx=nginx:1.19.4

17. Adicionar variaveis de ambiente em um Deployment

• Crie o template do deployment no arquivo app-deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: app-py
  name: app-py
spec:
  replicas: 1
  selector:
    matchLabels:
      app: app-py
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: app-py
    spec:
      containers:
      - image: app-py:v0.1
        name: app-py
        env:
          - name: API_KEY
            value: "123"

• Execute o deployment informado a variavel no terminal:

MINHA_API_KEY=123
kubectl apply -f app-deploy.yaml

Organizando recursos dentro de um cluster (Namespaces)

O que são namespaces no Kubernetes?

Namespaces são um recurso do Kubernetes que permite a criação de ambientes isolados dentro do mesmo cluster. Cada namespace é uma "zona" virtual onde você pode organizar seus recursos, como Pods, Services, ConfigMaps, etc. Isso é útil para várias equipes trabalharem em projetos diferentes ou para fins de segurança e governança do cluster.

Casos de uso para Namespace

• Separação de Deployment por ambiente: Com namespace é possivel criar um deployment para a versão de desenvolvimento e outro para a versão de testes (QA).
• Separação de Deployment por projeto ou equipe: Cada equipe pode ter seu próprio namespace, evitando conflitos e permitindo que cada um gerencie seus recursos independentemente.
• Isolamento para fins de segurança: Namespace podem ser usados para isolar ambientes sensíveis ou críticos, como bancos de dados, servidores de aplicativos, etc.
• Controle de acesso granular: Com namespaces, é possível definir políticas de controle de acesso mais refinadas, permitindo que diferentes equipes tenham acesso apenas ao seu namespace.

Criando um Namespace no Kubernetes

Para criar um namespace no Kubernetes, você pode usar o comando kubectl create namespace <nome-do-namespace>. Aqui está um exemplo:

kubectl create namespace dev-namespace

Listando namespaces no cluster

Para listar todos os namespaces no cluster, você pode usar o comando kubectl get namespaces. Aqui está um exemplo:

kubectl get namespaces

Configurando um Pod em um Namespace específico

Para criar um Pod em um namespace específico, você pode usar o comando kubectl run com a opção --namespace. Aqui está um exemplo:

kubectl run nginx --image=nginx --namespace dev-namespace

Deletando Namespaces

Ao deletar um namespaces, todos os seus recursos também serão deletados. Para deletar um namespace, você pode usar o comando kubectl delete namespace <nome-do-namespace>. Aqui está um exemplo:

kubectl delete namespace dev-namespace

Desafios complementares

1. Atualize a imagem do deployment e verifique o histórico (rollout history).
2. Crie um namespace staging e implante a mesma aplicação nele.
3. Escale o deployment para 5 réplicas e observe os pods sendo criados.

---

Resumo prático

Conceito	Descrição	Comando principal
Deployment	Gerencia rollout e réplicas	kubectl create deployment
ReplicaSet	Garante número fixo de pods	kubectl get rs
Pod	Unidade executável	kubectl get pods
Namespace	Isola recursos	kubectl create namespace
Rollout	Controla atualizações e rollback	kubectl rollout

---