StatefulSet

Nesta página, descrevemos os objetos StatefulSet do Kubernetes e como usá-los no Google Kubernetes Engine (GKE). Você também aprende a implantar um aplicativo com estado.

Visão geral

StatefulSets representam um conjunto de pods com identidades únicas e permanentes e nomes do host estáveis que o GKE mantém, onde quer que estejam programados. As informações de estado e outros dados resilientes de qualquer pod do StatefulSet são mantidos em um armazenamento de disco permanente associado ao StatefulSet.

StatefulSets usam um índice ordinal para a identidade e a ordenação dos pods. Por padrão, os pods de StatefulSet são implantados em ordem sequencial e terminados em ordem ordinal inversa. Por exemplo, um StatefulSet chamado web tem os pods denominados web-0, web-1 e web-2. Quando a especificação do pod web é alterada, os pods são convenientemente interrompidos e recriados de forma organizada. Neste exemplo, web-2 é encerrado primeiro, depois web-1 e assim por diante. Outra opção é especificar o campo podManagementPolicy: Parallel (em inglês) para iniciar o StatefulSet ou encerrar todos os pods em paralelo, em vez de esperar que os pods estejam em execução e prontos ou sejam encerrados antes do lançamento ou do encerramento de outro pod.

StatefulSets usam um modelo de pod, que contém uma especificação para os pods. A especificação de pod determina como será cada pod: quais aplicativos são executados dentro dos contêineres, quais volumes ele ativa, os marcadores e seletores dele e muito mais.

Padrões de uso

StatefulSets são projetados para implantar aplicativos com estado e aplicativos em cluster que salvam dados em armazenamento permanente, como os discos permanentes do Compute Engine. São apropriados para implantar Kafka, MySQL, Redis, ZooKeeper e outros aplicativos que precisam de identidades únicas e permanentes além de nomes do host estáveis. Para aplicativos sem estado, use implantações.

Como criar StatefulSets

É possível criar um StatefulSet usando kubectl apply (em inglês).

Depois de criado, o StatefulSet garante que o número pretendido de pods esteja disponível e em execução sempre. O StatefulSet substitui automaticamente os pods que falham ou são expulsos dos respectivos nodes e associa automaticamente novos pods a recursos de armazenamento, solicitações e limites de recursos e outras configurações definidas na especificação de pod do StatefulSet.

Veja a seguir um exemplo de arquivo de manifesto de serviço e StatefulSet:

apiVersion: v1
kind: Service
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  ports:
  - port: 80
    name: web
  clusterIP: None
  selector:
    app: nginx
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: web
spec:
  selector:
    matchLabels:
      app: nginx # Label selector that determines which Pods belong to the StatefulSet
                 # Must match spec: template: metadata: labels
  serviceName: "nginx"
  replicas: 3
  template:
    metadata:
      labels:
        app: nginx # Pod template's label selector
    spec:
      terminationGracePeriodSeconds: 10
      containers:
      - name: nginx
        image: k8s.gcr.io/nginx-slim:0.8
        ports:
        - containerPort: 80
          name: web
        volumeMounts:
        - name: www
          mountPath: /usr/share/nginx/html
  volumeClaimTemplates:
  - metadata:
      name: www
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Neste exemplo:

Um objeto Service denominado nginx é criado, de acordo com o indicado pelo campo metadata: name. O serviço aponta um aplicativo denominado nginx, indicado por labels: app: nginx e selector: app: nginx. O serviço expõe a porta 80 e a nomeia como web. Esse serviço controla o domínio de rede e direciona o tráfego da Internet para o aplicativo em contêiner implantado pelo StatefulSet.
Um StatefulSet denominado web é criado com três pods replicados (replicas: 3).
O modelo de pod (spec: template) indica que os pods estão marcados como app: nginx.
A especificação de pod (template: spec) indica que os pods de StatefulSet executam um contêiner, nginx, que executa a imagem nginx-slim na versão 0.8. A imagem do contêiner é hospedada pelo Container Registry.
A especificação do pod usa a porta web aberta pelo serviço.
template: spec: volumeMounts especifica um mountPath, que é denominado www. O mountPath é o caminho dentro do contêiner em que um volume de armazenamento é ativado.
O StatefulSet provisiona um PersistentVolumeClaim, www, com 1 GB de armazenamento provisionado.

Em suma, a especificação do pod contém as seguintes instruções:

Rotule cada pod como app: nginx.
Em cada pod, execute um contêiner chamado nginx.
Execute a imagem nginx-slim na versão 0.8.
Faça com que os pods usem a porta 80.
Salve os dados no caminho de ativação.

Para mais informações sobre configurações de StatefulSet, consulte a referência da StatefulSet API.

Como atualizar StatefulSets

Você pode atualizar um StatefulSet fazendo alterações na respectiva especificação de pod, que inclui imagens e volumes de contêiner. Também é possível atualizar as solicitações de recurso e limites, marcadores e anotações do objeto. Para atualizar um StatefulSet, use kubectl, a API Kubernetes ou o menu Cargas de trabalho do GKE no Console do Google Cloud.

Para decidir como lidar com as atualizações, os StatefulSets usam uma estratégia de atualização definida em spec: updateStrategy. Há duas estratégias, OnDelete e RollingUpdate:

OnDelete não exclui e recria automaticamente os pods quando a configuração do objeto é alterada. Em vez disso, você precisa excluir manualmente os pods antigos para que o controlador crie pods atualizados.
RollingUpdate exclui e recria pods automaticamente quando a configuração do objeto é alterada. Novos pods precisam estar nos estados pronto e funcionando antes que os antecessores sejam excluídos. Com essa estratégia, alterar a especificação de pod aciona automaticamente uma implementação. Essa é a estratégia de atualização padrão para StatefulSets.

StatefulSets atualizam pods em ordem ordinal inversa. Você pode monitorar as implementações de atualização executando o seguinte comando:

kubectl rollout status statefulset statefulset-name

Como particionar atualizações contínuas

Você pode particionar atualizações contínuas. O particionamento é útil quando você quer organizar uma atualização, fazer uma implementação canário ou executar uma implementação gradual.

Com o particionamento de uma atualização, todos os pods com um ordinal maior ou igual ao valor da partição são atualizados quando você atualiza a especificação de pod do StatefulSet. Os pods com um ordinal menor que o valor da partição não são atualizados e, mesmo se forem excluídos, serão recriados usando a versão anterior da especificação. Se o valor da partição for maior que o número de réplicas, as atualizações não serão propagadas para os pods.