a. Visão geral

O que é um orquestrador?

Um orquestrador é um sistema que automatiza o deploy, o gerenciamento, a escalabilidade e a operação de aplicações em containers. Os containers empacotam uma aplicação com suas dependências, tornando-a portável entre ambientes. Os orquestradores cuidam de tarefas críticas como:

• Escalonamento (scheduling): posicionar os containers nos servidores adequados.
• Escalabilidade: adicionar ou remover containers de acordo com a demanda.
• Rede: gerenciar a comunicação entre containers.
• Autorrecuperação (self-healing): reiniciar containers que falharam ou redistribuir workloads.
• Descoberta de serviços (service discovery): permitir que os containers encontrem uns aos outros e se comuniquem.

Ao abstrair as complexidades da infraestrutura, os orquestradores garantem que as aplicações rodem de forma confiável e eficiente, especialmente em sistemas distribuídos de grande escala. Eles são essenciais para empresas que gerenciam centenas ou milhares de containers em vários hosts, dando suporte ao desenvolvimento cloud-native e às arquiteturas de microsserviços Container Orchestration - Red Hat.

Orquestradores como Kubernetes, Docker Swarm e Apache Mesos oferecem essas capacidades, cada um com recursos e complexidades próprios. O Kubernetes é o orquestrador mais adotado, conhecido por seu ecossistema robusto e pelo apoio da comunidade.

Diferença entre Docker Compose e Kubernetes

Docker Compose e Kubernetes (K8s) gerenciam aplicações em containers, mas atendem a propósitos diferentes, com escopos, complexidades e casos de uso distintos:

Docker Compose

• Propósito: projetado para ambientes de um único host, ideal para desenvolvimento, testes ou produção de pequena escala.
• Configuração: usa um arquivo YAML para definir aplicações com vários containers, especificando serviços, redes e volumes.
• Recursos: simplifica a rede entre containers e o gerenciamento de dependências em uma única máquina. Suporta políticas básicas de reinício, mas não tem recursos avançados como auto-scaling ou gerenciamento de cluster.
• Facilidade de uso: simples de configurar, com curva de aprendizado menor, o que o torna acessível para desenvolvedores.
• Caso de uso: melhor para desenvolvimento local (por exemplo, rodar uma aplicação web com um banco de dados) ou configurações de produção simples, em que a escalabilidade não é prioridade.

Kubernetes

• Propósito: construído para orquestrar containers em um cluster de vários nós, adequado a sistemas distribuídos de nível de produção.
• Configuração: usa arquivos YAML/JSON declarativos para definir o estado desejado, com controladores garantindo que o sistema corresponda à configuração.
• Recursos: oferece auto-scaling, balanceamento de carga, rolling updates, autorrecuperação, descoberta de serviços e orquestração de armazenamento.
• Complexidade: mais complexo, exigindo conhecimento de conceitos como pods, services e deployments.
• Caso de uso: ideal para aplicações cloud-native que precisam de alta disponibilidade, escalabilidade e resiliência em vários servidores.

Principais diferenças

Ferramentas como o Kompose podem ajudar a migrar arquivos do Docker Compose para o Kubernetes, facilitando a transição de aplicações em crescimento Docker Compose vs Kubernetes - Spacelift.

Alternativas ao Kubernetes

O Kubernetes é a principal plataforma de orquestração de containers, mas sua complexidade e sua demanda por recursos podem não se adequar a todos os cenários. Existem alternativas para diferentes ambientes — on-premise, nuvem e local — que oferecem soluções mais simples, específicas de um provedor de nuvem ou mais leves. A tabela abaixo resume alternativas populares, com exemplos:

Observações sobre as alternativas

• Nomad e Docker Swarm priorizam a simplicidade, sendo adequados para equipes com recursos limitados ou workloads mais simples Kubernetes Alternatives - Wiz.
• OpenShift amplia o Kubernetes com recursos corporativos, mas aumenta a complexidade; é mais indicado para organizações que precisam de ferramentas robustas.
• Opções cloud-native como Amazon ECS, Google Cloud Run e AWS Fargate reduzem o esforço de gerenciamento, mas prendem os usuários a provedores de nuvem específicos, limitando a portabilidade.
• Ferramentas locais como Minikube e Docker Compose não são próprias para produção, mas se destacam em ambientes de desenvolvimento e aprendizado.
• Serviços gerenciados de Kubernetes (GKE, EKS) simplificam a operação do Kubernetes, mas ainda exigem conhecimento de Kubernetes, o que os torna menos uma alternativa de fato para quem quer evitar a complexidade do K8s.

A escolha da ferramenta certa depende de fatores como a escala do workload, a experiência da equipe, as restrições de infraestrutura e a necessidade de portabilidade entre nuvens. Para projetos pequenos, Docker Compose ou Nomad podem bastar, enquanto sistemas distribuídos grandes costumam se beneficiar do Kubernetes ou de soluções cloud-native como o ECS.

Kubernetes

O Kubernetes é uma plataforma open source de orquestração de containers que automatiza o deploy, a escalabilidade e o gerenciamento de aplicações em containers. Ele oferece um framework robusto para executar sistemas distribuídos de forma resiliente, permitindo gerenciar clusters de hosts que executam containers Linux. Um cluster é um conjunto de máquinas (físicas ou virtuais) que executam o Kubernetes e podem ser gerenciadas como uma única entidade. Para gerenciar esses clusters, o Kubernetes usa um conjunto de APIs e um control plane que controla o estado do cluster.

flowchart TD
    Deployment:::orange -->|define| ReplicaSet
    ReplicaSet -->|gerencia| pod((Pod))
    pod:::red -->|executa| Container
    Deployment -->|escala| pod
    Deployment -->|atualiza| pod

    Service:::orange -->|expõe| pod

    subgraph  
        ConfigMap:::orange
        Secret:::orange
    end

    ConfigMap --> Deployment
    Secret --> Deployment
    classDef red fill:#f55
    classDef orange fill:#ffa500

• Deployment: funciona como o gerente da sua aplicação, decidindo quantas cópias (réplicas) devem rodar e atualizando-as quando necessário.

• ReplicaSet: garante que o número certo de Pods (os containers efetivamente em execução) esteja sempre disponível, criando-os ou removendo-os conforme necessário.

• Pod: a menor unidade, onde a sua aplicação de fato roda, geralmente contendo um ou mais containers.

• Container: a aplicação propriamente dita, rodando dentro do Pod, isolada das demais.

• Service: funciona como um balanceador de carga, direcionando o tráfego para os Pods certos com base nas regras que você define. Um Service permite expor sua aplicação ao mundo externo ou a outras aplicações dentro do cluster. O serviço exposto pode ser de diferentes tipos:

  Tipos de Service	Descrição
  ClusterIP	O tipo padrão, que expõe o serviço em um IP interno do cluster. Isso significa que o serviço só pode ser acessado de dentro do cluster.
  NodePort	Expõe o serviço no IP de cada nó, em uma porta fixa. Isso permite acessar o serviço de fora do cluster usando <NodeIP>:<NodePort>.
  LoadBalancer	Cria um balanceador de carga externo nos provedores de nuvem compatíveis, roteando o tráfego para o seu serviço.

• ConfigMap: uma forma de passar dados de configuração para a sua aplicação sem deixá-los fixos dentro do container.

• Secret: semelhante ao ConfigMap, mas usado para informações sensíveis, como senhas ou chaves de API, garantindo que sejam armazenadas com segurança.

📁 postgres-service
└── 📁 k8s
    ├──  secrets.yaml
    ├──  configmap.yaml
    ├──  deployment.yaml
    └──  service.yaml

1
2
3
4
5
6
7

apiVersion: v1
kind: Secret
metadata:
    name: postgres-secrets
data:
    POSTGRES_USER: c3RvcmU=
    POSTGRES_PASSWORD: c3RvcmU=

kubectl apply -f ./k8s/secrets.yaml
kubectl get secrets

1
2
3
4
5
6
7
8
9

apiVersion: v1
kind: ConfigMap
metadata:
    name: postgres-configmap
    labels:
        app: postgres
data:
    POSTGRES_HOST: postgres
    POSTGRES_DB: store

kubectl apply -f ./k8s/configmap.yaml
kubectl get configmap

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
          - name: postgres
            image: postgres:latest
            imagePullPolicy: Always
            ports:
              - containerPort: 5432
            resources:
              requests:
                memory: "256Mi"
                cpu: "250m"
              limits:
                memory: "512Mi"
                cpu: "500m"
            env:
              - name: POSTGRES_DB
                valueFrom:
                  configMapKeyRef:
                    name: postgres-configmap
                    key: POSTGRES_DB

              - name: POSTGRES_USER
                valueFrom:
                  secretKeyRef:
                    name: postgres-secrets
                    key: POSTGRES_USER

              - name: POSTGRES_PASSWORD
                valueFrom:
                  secretKeyRef:
                    name: postgres-secrets
                    key: POSTGRES_PASSWORD

kubectl apply -f ./k8s/deployment.yaml
kubectl get deployments
kubectl get pods

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

apiVersion: v1
kind: Service
metadata:
    name: postgres
    labels:
        app: postgres
spec:
    type: ClusterIP
    ports:
        - port: 5432
    selector:
        app: postgres

kubectl apply -f ./k8s/service.yaml
kubectl get services

📁 gateway-service
└── 📁 k8s
    └──  k8s.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gateway
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gateway
  template:
    metadata:
      labels:
        app: gateway
    spec:
      containers:
          - name: gateway
            image: humbertosandmann/gateway:latest
            imagePullPolicy: Always
            ports:
              - containerPort: 8080

---

apiVersion: v1
kind: Service
metadata:
  name: gateway
spec:
  selector:
    app: gateway
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 8080
  type: LoadBalancer

kubectl apply -f ./k8s/k8s.yaml
kubectl get deployments
kubectl get pods
kubectl get services

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP                                                              PORT(S)        AGE
gateway      LoadBalancer   10.100.59.61   aac9dbab7421e4ec0a1b19472728b793-834724138.us-east-2.elb.amazonaws.com   80:31973/TCP   34m
kubernetes   ClusterIP      10.100.0.1     <none>                                                                   443/TCP        5d5h

http://aac9dbab7421e4ec0a1b19472728b793-834724138.us-east-2.elb.amazonaws.com/info # (1)!

Kubectl

O Kubernetes é uma poderosa plataforma de orquestração de containers, e o kubectl é a sua ferramenta de linha de comando para gerenciar clusters Kubernetes. Abaixo estão alguns comandos comuns e suas descrições para ajudar você a começar com o kubectl.

Para instalar o kubectl, siga as instruções da documentação do Kubernetes. Para verificar se o kubectl está instalado corretamente, execute:

kubectl version --client

Guia rápido do kubectl

Minikube

O Minikube é uma ferramenta que facilita executar o Kubernetes localmente. Ele cria um cluster Kubernetes de um único nó na sua máquina, permitindo testar e desenvolver aplicações em um ambiente Kubernetes sem precisar de uma configuração completa na nuvem.

Para instalar o Minikube, siga as instruções da documentação do Minikube.

Guia rápido do Minikube