0Pricing
Kubernetes Basics · Aula

StatefulSets para aplicações com estado

Implante e gerencie aplicações com estado, como bancos de dados, usando StatefulSets e garantindo identificadores de rede estáveis e armazenamento persistente.

StatefulSets para aplicações com estado é uma aula grátis de Kubernetes Basics no CoddyKit. Esta é a aula 1 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 Kubernetes Basics, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kubernetes Basics inclui 4 aulas no total.

StatefulSets para aplicações com estado

Boas-vindas! Nesta lição, você vai conhecer em detalhes os StatefulSets, um objeto do Kubernetes criado para gerenciar aplicações com estado.

Ao contrário das aplicações sem estado (que podem ser facilmente dimensionadas e substituídas), as aplicações com estado precisam de identidades exclusivas e armazenamento persistente para cada instância. Pense em bancos de dados, filas de mensagens ou aplicações personalizadas que armazenam dados localmente.

Por que usar StatefulSets? O desafio

As implantações tradicionais são excelentes para aplicações sem estado. Se um Pod parar de funcionar, outro o substitui, e não importa qual deles atende à solicitação.

Porém, nas aplicações com estado, cada réplica geralmente precisa de uma identidade estável e exclusiva, além de seu próprio armazenamento dedicado. Se um Pod de banco de dados for reiniciado, ele precisará se reconectar ao seu volume de dados específico.

Identidade estável da rede e do Pod

Uma característica essencial dos StatefulSets é fornecer identificadores de rede estáveis e exclusivos para cada Pod.

  • Os Pods recebem nomes de maneira previsível e ordenada (por exemplo, web-0, web-1).
  • Eles mantêm seus nomes de host durante os reinícios.
  • Isso permite que outros serviços se conectem de forma confiável a uma réplica específica.

Armazenamento estável e persistente

Os StatefulSets garantem que cada Pod receba seu próprio armazenamento estável e persistente. Isso é gerenciado por meio de reivindicações de volume persistente (PVCs).

Quando um Pod de um StatefulSet é criado, um PVC é provisionado automaticamente com base em uma definição de volumeClaimTemplates. Se o Pod parar de funcionar e for recriado, ele será reconectado ao mesmo PVC e, portanto, aos seus dados originais.

Anatomia de um YAML de StatefulSet

Uma definição YAML de StatefulSet é semelhante à de uma implantação, mas inclui alguns acréscimos essenciais. Ela contém:

  • apiVersion, kind, metadata
  • spec.replicas, spec.selector, spec.template (como nas implantações)
  • spec.serviceName: estabelece o vínculo com um serviço sem cabeça.
  • spec.volumeClaimTemplates: define como os PVCs serão criados para cada Pod.

Serviço sem cabeça para IDs estáveis

Para que os StatefulSets forneçam identidades de rede estáveis, eles precisam de um serviço sem cabeça. Um serviço sem cabeça não tem um IP de cluster. Em vez disso, ele retorna diretamente os endereços IP dos Pods que seleciona.

O StatefulSet usa esse serviço para registrar entradas DNS para cada um de seus Pods (por exemplo, pod-0.my-service.my-namespace.svc.cluster.local).

apiVersion: v1
kind: Service
metadata:
  name: my-app-headless
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None # This makes it a headless service
  selector:
    app: my-app

VolumeClaimTemplates

A seção volumeClaimTemplates é exclusiva dos StatefulSets. Ela é um modelo para as reivindicações de volume persistente (PVCs) que serão criadas para cada réplica.

Cada Pod do StatefulSet (por exemplo, my-app-0, my-app-1) receberá seu próprio PVC (por exemplo, data-my-app-0, data-my-app-1) com base nesse modelo, garantindo armazenamento dedicado.

volumeClaimTemplates:
- metadata:
    name: data # This name is used in Pod's volumeMounts
  spec:
    accessModes: [ "ReadWriteOnce" ]
    storageClassName: standard
    resources:
      requests:
        storage: 1Gi

Exemplo completo de StatefulSet

Veja um exemplo completo de um StatefulSet simples do Nginx. Observe o serviceName, que estabelece o vínculo com o serviço sem cabeça, e o volumeClaimTemplates.

Para implantá-lo, salve-o como nginx-statefulset.yaml e execute kubectl apply -f nginx-statefulset.yaml.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  serviceName: "nginx-headless" # Must match headless service name
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: k8s.gcr.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www # Mounts the volume from the PVC
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www # This name links to volumeMounts.name
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: standard
      resources:
        requests:
          storage: 1Gi
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-headless
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx

Nomenclatura e ordenação dos Pods

Depois da implantação, você verá Pods com nomes como web-0, web-1. Esses índices são estáveis e exclusivos.

Os StatefulSets impõem uma ordenação rigorosa às operações de dimensionamento. Os Pods são criados em ordem (0, 1, 2...) e encerrados na ordem inversa (..., 2, 1, 0).

Essa abordagem ordenada é essencial para que muitos sistemas distribuídos com estado mantenham a consistência.

Dimensionamento e atualizações graduais

Você pode dimensionar um StatefulSet assim como uma implantação, usando kubectl scale statefulset web --replicas=3.

As atualizações graduais também funcionam, mas mantêm as mesmas garantias de ordenação: os Pods são atualizados um por vez, na ordem ordinal inversa, garantindo que o próximo Pod não seja atualizado antes que o anterior esteja pronto.

Essa orquestração cuidadosa minimiza as interrupções em aplicações com estado.

Verifique sua compreensão

Quais das opções a seguir são características ou requisitos essenciais dos StatefulSets do Kubernetes?

Recapitulação: StatefulSets em ação

Excelente trabalho! Nesta lição, você explorou os StatefulSets, um objeto poderoso do Kubernetes para gerenciar aplicações com estado.

  • Eles fornecem identidades de rede estáveis e operações ordenadas.
  • Eles usam volumeClaimTemplates para oferecer armazenamento dedicado e persistente a cada réplica.
  • Um serviço sem cabeça é essencial para seus IDs de rede estáveis.

Os StatefulSets são fundamentais para executar bancos de dados e outras cargas de trabalho críticas com estado de maneira confiável no Kubernetes.

Perguntas Frequentes

A aula “StatefulSets para aplicações com estado” é grátis?

Sim — o texto completo de “StatefulSets para aplicações com estado” é 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 Kubernetes Basics, atualize para CoddyKit PRO. O curso de Kubernetes Basics inclui 4 aulas no total.

O que vou aprender em “StatefulSets para aplicações com estado”?

Implante e gerencie aplicações com estado, como bancos de dados, usando StatefulSets e garantindo identificadores de rede estáveis e armazenamento persistente. Você pratica Kubernetes Basics 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 Kubernetes Basics?

Nenhuma experiência prévia é necessária. Kubernetes Basics 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 1 de 4.

Quanto tempo leva a aula “StatefulSets para aplicações com estado”?

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 Kubernetes Basics?

Sim. Cada aula de Kubernetes Basics 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. StatefulSets para aplicações com estado
  2. DaemonSets para tarefas específicas de nós
  3. Entendendo os Operators do Kubernetes
  4. Definições de Recursos Personalizados (CRDs)
← Voltar para Kubernetes Basics