0Pricing
Docker & DevOps Fundamentals · Aula

Pods: as menores unidades

Aprenda sobre os pods, os blocos fundamentais do Kubernetes, e como defini-los e gerenciá-los.

Pods: as menores unidades é uma aula grátis de Docker & DevOps Fundamentals no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Docker & DevOps Fundamentals, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Docker & DevOps Fundamentals inclui 4 aulas no total.

O que é um Pod do Kubernetes?

No Kubernetes, a menor e mais fundamental unidade que você pode implantar é um Pod. Pense em um Pod como uma única “casa” que contém um ou mais contêineres.

Os Pods são uma abstração sobre os contêineres. Eles representam um processo em execução no seu cluster e encapsulam contêineres de aplicações, recursos de armazenamento, um IP de rede exclusivo e opções que determinam como os contêineres devem ser executados.

Pods: as menores unidades — ilustração 1

Pod versus contêiner: a diferença

Talvez você esteja se perguntando: “Por que preciso de um Pod se já tenho contêineres?”. Esta é a principal diferença:

  • Um Contêiner (como um contêiner Docker) é um pacote que contém uma aplicação e suas dependências.
  • Um Pod é a abstração do Kubernetes que envolve um ou mais contêineres, fornecendo a eles recursos compartilhados e uma única identidade de rede.

Enquanto o contêiner é o executável propriamente dito, o Pod é a forma como o Kubernetes gerencia e orquestra esses executáveis.

Por que usar Pods?

Os Pods oferecem vários benefícios essenciais:

  • Namespace de rede compartilhado: Todos os contêineres dentro de um Pod compartilham o mesmo endereço IP e as mesmas portas de rede. Eles podem se comunicar usando localhost.
  • Armazenamento compartilhado: Os Pods podem compartilhar volumes de armazenamento, permitindo que os contêineres dentro do mesmo Pod acessem dados comuns.
  • Colocalização e coagendamento: É possível garantir que contêineres que precisam trabalhar em conjunto (por exemplo, uma aplicação e um agente de registro) sejam executados no mesmo nó e sempre agendados juntos.

Anatomia de uma definição de Pod

Os Pods são definidos usando arquivos de configuração YAML. Veja os principais componentes que você encontrará:

  • apiVersion: especifica a versão da API do Kubernetes (por exemplo, v1).
  • kind: o tipo de objeto do Kubernetes, que é Pod.
  • metadata: informações como o name e os labels do Pod.
  • spec: o estado desejado para o Pod, incluindo os containers a serem executados, os volumes e outras configurações.

Definindo um Pod de um único contêiner

A maioria dos Pods contém um único contêiner. Isso é comum em aplicações simples. Veja uma definição YAML básica de um Pod que executa um servidor web Nginx:

apiVersion: v1
kind: Pod
metadata:
  name: my-nginx-pod
  labels:
    app: webserver
spec:
  containers:
  - name: nginx-container
    image: nginx:latest
    ports:
    - containerPort: 80

Implantando seu primeiro Pod

Para criar um Pod a partir de um arquivo YAML, você usa o comando kubectl apply. Isso instrui o Kubernetes a criar ou atualizar recursos com base na sua definição.

Suponha que você tenha salvado a definição anterior do Pod Nginx como nginx-pod.yaml. Você faria a implantação desta forma:

  • kubectl apply -f nginx-pod.yaml

Em seguida, o Kubernetes agendará esse Pod para execução em um dos nós de trabalho.

Inspecionando Pods: obter e descrever

Depois da implantação, você provavelmente vai querer verificar o status dos seus Pods. Estes são dois comandos essenciais do kubectl:

  • kubectl get pods: lista todos os Pods no namespace atual, mostrando o nome, o status e o nó de cada um.
  • kubectl describe pod <pod-name>: fornece informações detalhadas sobre um Pod específico, incluindo eventos, status do contêiner e recursos atribuídos.

Esses comandos são essenciais para o monitoramento e a solução de problemas.

Pods com vários contêineres: sidecars

Embora os Pods com um único contêiner sejam comuns, alguns cenários se beneficiam de Pods com vários contêineres. Um exemplo clássico é o padrão sidecar.

Um contêiner sidecar é executado junto ao contêiner principal da sua aplicação no mesmo Pod, realizando tarefas auxiliares como:

  • Agentes de registro e monitoramento
  • Sincronização de dados
  • Proxy do tráfego de rede

Eles compartilham a rede e o armazenamento do Pod, o que torna a comunicação eficiente.

Exemplo: Pod com vários contêineres

Veja um exemplo de Pod com vários contêineres. Ele contém um servidor web Nginx e um contêiner sidecar busybox que grava registros em um volume compartilhado.

apiVersion: v1
kind: Pod
metadata:
  name: multi-container-pod
spec:
  volumes:
  - name: shared-log-volume
    emptyDir: {}
  containers:
  - name: web-server
    image: nginx:latest
    ports:
    - containerPort: 80
    volumeMounts:
    - name: shared-log-volume
      mountPath: /var/log/nginx
  - name: log-writer
    image: busybox:latest
    command: ["/bin/sh", "-c", "while true; do echo 'Hello from sidecar!' >> /var/log/app.log; sleep 5; done"]
    volumeMounts:
    - name: shared-log-volume
      mountPath: /var/log/app

Teste seus conhecimentos sobre Pods

Qual das afirmações a seguir sobre os Pods do Kubernetes é TRUE?

Recapitulação: Pods, a unidade central

Você acabou de aprender sobre os Pods do Kubernetes, os blocos de construção fundamentais das suas aplicações em um cluster.

  • Os Pods encapsulam um ou mais contêineres, fornecendo recursos compartilhados a eles.
  • Eles oferecem rede e armazenamento compartilhados e garantem a colocalização de contêineres relacionados.
  • Você define os Pods usando YAML e os implanta com kubectl apply.
  • kubectl get pods e kubectl describe pod ajudam a monitorá-los.

Em seguida, vamos explorar mais comandos do kubectl para interagir com seu cluster!

Perguntas Frequentes

A aula “Pods: as menores unidades” é grátis?

Sim — o texto completo de “Pods: as menores unidades” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Docker & DevOps Fundamentals, atualize para CoddyKit PRO. O curso de Docker & DevOps Fundamentals inclui 4 aulas no total.

O que vou aprender em “Pods: as menores unidades”?

Aprenda sobre os pods, os blocos fundamentais do Kubernetes, e como defini-los e gerenciá-los. Você pratica Docker & DevOps Fundamentals com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Docker & DevOps Fundamentals?

Nenhuma experiência prévia é necessária. Docker & DevOps Fundamentals no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Pods: as menores unidades”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Docker & DevOps Fundamentals?

Sim. Cada aula de Docker & DevOps Fundamentals inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Arquitetura do Kubernetes
  2. Pods: as menores unidades
  3. Fundamentos dos comandos kubectl
  4. Namespaces e rótulos para organização
← Voltar para Docker & DevOps Fundamentals