StatefulSet

Nesta página, descrevemos objetos StatefulSet do Kubernetes e o uso deles no Google Kubernetes Engine.

O que é um StatefulSet?

StatefulSets representam um conjunto de [pods] com identidades únicas e permanentes e nomes do host estáveis que o GKE mantém, independentemente do local em que estão programados. As informações de estado e outros dados resilientes de qualquer pod de 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 denominado web tem pods denominados web-0, web-1 e web-2. Quando a especificação do pod web é alterada, os respectivos pods são interrompidos normalmente e recriados de forma ordenada. Neste exemplo, web-2 é terminado primeiro, depois web-1 e assim por diante. Como alternativa, especifique o campo podManagementPolicy: Parallel para ter um lançamento StatefulSet ou encerrar todos os pods em paralelo, em vez de esperar que eles fiquem em execução e prontos ou sejam encerrados antes do início ou 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

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

Como criar StatefulSets

Crie um StatefulSet usando kubectl apply.

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: gcr.io/google_containers/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

Veja o que ocorre 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 encaminha 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 respectivos pods são marcados como app: nginx.
  • A especificação do pod (template: spec) indica que os pods do 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 da web aberta pelo serviço.
  • template: spec: volumeMounts especifica um mountPath, 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:

  • Marque cada pod como app: nginx.
  • Em cada pod, execute um contêiner denominado 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. Você também pode 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 Platform.

Para decidir como gerenciar 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 pods automaticamente 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.

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine