Como implantar um aplicativo com estado

Nesta página, explicamos como implantar um aplicativo com estado usando o Google Kubernetes Engine (GKE).

Visão geral

Os aplicativos com estado salvam dados no armazenamento em disco permanente para uso do servidor, de clientes e de outros aplicativos. Um exemplo de aplicativo com estado é um banco de dados ou armazenamento de chave-valor em que os dados são salvos e recuperados por outros aplicativos.

O armazenamento permanente pode ser provisionado de forma dinâmica, de modo que os volumes subjacentes sejam criados sob demanda. No Kubernetes, você configura o provisionamento dinâmico criando um StorageClass. No GKE, um StorageClass padrão permite provisionar de forma dinâmica os discos permanentes do Compute Engine.

O Kubernetes usa o controlador StatefulSet para implantar aplicativos com estado como objetos StatefulSet. Os pods no StatefulSets não podem ser trocados. Cada pod tem um identificador exclusivo que é mantido, independentemente de onde está programado.

Os aplicativos com estado são diferentes dos aplicativos sem estado, em que os dados do cliente não são salvos no servidor entre as sessões.

Saiba mais sobre armazenamento permanente em clusters regionais e de várias zonas.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

Defina as configurações padrão da gcloud usando um dos métodos a seguir:

  • Use gcloud init se quiser orientações para definir os padrões.
  • Use gcloud config para definir individualmente a região, a zona e o ID do projeto.

Como usar o gcloud init

Se você receber o erro One of [--zone, --region] must be supplied: Please specify location, conclua esta seção.

  1. Execute gcloud init e siga as instruções:

    gcloud init

    Se você estiver usando SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:

    gcloud init --console-only
  2. Siga as instruções para autorizar a gcloud a usar sua conta do Google Cloud.
  3. Crie uma nova configuração ou selecione uma atual.
  4. Escolha um projeto do Google Cloud.
  5. Escolha uma zona padrão do Compute Engine.

Como usar o gcloud config

  • Defina o ID do projeto padrão:
    gcloud config set project project-id
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone compute-zone
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region compute-region
  • Atualize gcloud para a versão mais recente:
    gcloud components update
  • Verifique se o aplicativo em contêiner está armazenado em um registro de imagens, como o Container Registry.

É possível seguir as instruções do início rápido para ativar a API do GKE, criar um cluster e saber mais sobre o GKE.

Como solicitar armazenamento permanente em um StatefulSet

Os aplicativos podem solicitar armazenamento permanente com um PersistentVolumeClaim.

Normalmente, os objetos PersistentVolumeClaim precisam ser criados pelo usuário além do pod. No entanto, StatefulSets incluem uma matriz volumeClaimTemplates, que gera automaticamente os objetos PersistentVolumeClaim. Cada réplica de StatefulSet recebe o próprio objeto PersistentVolumeClaim.

Também é possível usar um disco preexistente em um StatefulSet.

Como criar um StatefulSet

Para criar um StatefulSet, use o comando kubectl apply.

O comando kubectl apply usa arquivos de manifesto para criar, atualizar e excluir recursos do cluster. Esse é um método declarativo de configuração de objetos. Esse método retém gravações feitas em objetos ativos sem mesclar as alterações nos arquivos de configuração do objeto.

Linux

O seguinte arquivo de manifesto é um exemplo simples de um StatefulSet controlado por um serviço criado separadamente:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-name
spec:
  selector:
    matchLabels:
      app: app-name
  serviceName: "service-name"
  replicas: 3
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: app-name
    spec:
      containers:
      - name: container-name
        image: ...
        ports:
        - containerPort: 80
          name: port-name
        volumeMounts:
        - name: pvc-name
          mountPath: ...
  volumeClaimTemplates:
  - metadata:
      name: pvc-name
      annotations:
        ...
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Em que:

  • statefulset-name é o nome do StatefulSet.
  • service-name é o nome do serviço.
  • app-name é o nome do aplicativo executado nos pods.
  • container-name é o nome dos contêineres nos pods.
  • port-name é o nome da porta aberta pelo StatefulSet.
  • pvc-name é o nome do PersistentVolumeClaim.

Nesse arquivo, o campo kind especifica que um objeto StatefulSet precisa ser criado com as especificações definidas no arquivo. Nesse exemplo, o StatefulSet produz três Pods replicados e abre a porta 80 para expor o StatefulSet na Internet.

Windows

Ao usar clusters com pools de nós do Windows Server, você precisa criar um StorageClass, porque o StorageClass padrão usa ext4 como o tipo de sistema de arquivos que só funciona para contêineres do Linux. Se estiver usando um disco permanente do Compute Engine, você precisará usar o NTFS como o tipo de armazenamento de arquivo conforme mostrado no seguinte exemplo:

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: storageclass-name
parameters:
  type: pd-standard
  fstype: NTFS
provisioner: kubernetes.io/gce-pd
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer

O manifesto StatefulSet a seguir usa o StorageClass definido acima. Ele cria quatro pares de PersistentVolume e PersistentVolumeClaim para representar quatro discos permanentes do Compute Engine. Cada pod no StatefulSet consome um disco permanente.

Para garantir que seus pods sejam programados corretamente em nós do Windows Server, você precisa adicionar um seletor de nós à especificação do Pod:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: statefulset-name
spec:
  replicas: 4
  selector:
    matchLabels:
      app: app-name
  template:
    metadata:
      labels:
        app: app-name
      name: container-name
    spec:
      nodeSelector:
        kubernetes.io/os: windows
      containers:
      - name: container-name
        image: ...
        ports:
        - containerPort: 80
          name: port-name
        volumeMounts:
        - name: pvc-name
          mountPath: C:\mnt\state
  volumeClaimTemplates:
  - metadata:
      name: pvc-name
    spec:
      storageClassName: storageclass-name
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 1Gi

Em que:

  • app-name é o nome do aplicativo executado nos pods.
  • statefulset-name é o nome do StatefulSet.
  • container-name é o nome dos contêineres nos pods.
  • port-name é o nome da porta aberta pelo StatefulSet.
  • pvc-name é o nome do PersistentVolumeClaim.
  • storageclass-name é o nome do StorageClass.

Para criar um StatefulSet, execute o comando a seguir:

kubectl apply -f statefulset-file

em que statefulset-file é o arquivo de manifesto.

Também é possível usar kubectl apply -f directory/ para criar todos os objetos (exceto os atuais) definidos em arquivos de configuração armazenados em um diretório.

Como inspecionar um StatefulSet

kubectl

Para inspecionar o StatefulSet, execute o seguinte comando:

kubectl get statefulset statefulset-name -o yaml

Esse comando exibe a configuração ativa do StatefulSet no formato YAML.

Para listar os pods criados pelo StatefulSet, execute o comando a seguir:

kubectl get pods -l app=app-name

Neste comando, a sinalização -l instrui kubectl a receber todos os pods rotulados para o app-name.

A saída será assim:

NAME                                READY     STATUS    RESTARTS   AGE
pod-name                            1/1       Running   0          1m
pod-name                            1/1       Running   0          1m

Para informações detalhadas sobre o StatefulSet, execute o seguinte comando:

kubectl describe statefulset statefulset-name

em que statefulset-name é o nome do StatefulSet.

Para informações sobre um pod específico:

kubectl describe pod pod-name

Para listar os PersistentVolumeClaims que foram criados:

kubectl get pvc

A saída será assim:

NAME                            STATUS    VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
statefulset-name-pvc-name-0     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800002   1G         RWO            standard        9s
statefulset-name-pvc-name-1     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800003   1G         RWO            standard        9s
statefulset-name-pvc-name-2     Bound     pvc-bdff4e1e-183e-11e8-bf6d-42010a800004   1G         RWO            standard        9s

Para obter informações sobre um PersistentVolumeClaim específico:

kubectl describe pvc statefulset-name-pvc-name-0

Para obter informações sobre um PersistentVolume específico:

kubectl describe pv pv-name

Console

Para inspecionar um StatefulSet, siga as etapas a seguir:

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. Selecione a carga de trabalho desejada no menu.

Em "Cargas de trabalho", é possível encontrar outros menus:

  • Para ver a configuração ativa do StatefulSet, clique em YAML.
  • Para ver todos os eventos relacionados ao StatefulSet, clique em Eventos.
  • Para ver o histórico de revisões do StatefulSet, clique em Histórico de revisão.

Como atualizar um StatefulSet

Há várias maneiras de atualizar StatefulSets. O método declarativo comum é kubectl apply. Para atualizar o StatefulSet diretamente do shell ou em um editor preferencial, use kubectl edit. Também é possível usar o editor YAML no menu Cargas de trabalho do GKE no Console do Cloud.

É possível distribuir atualizações para a especificação de pods dos StatefulSet, como imagem, uso/solicitações de recursos ou configuração.

kubectl apply

Para atualizar o StatefulSet, você pode aplicar um arquivo de manifesto novo ou atualizado. Isso é útil para fazer várias alterações no StatefulSet. Por exemplo, ao dimensionar ou especificar uma nova versão do aplicativo.

Para atualizar um StatefulSet, execute o comando a seguir:

kubectl apply -f statefulset-file

em que statefulset-file é o arquivo de manifesto atualizado.

O comando kubectl apply aplica um arquivo de manifesto a um recurso. Se o recurso especificado não existir, ele será criado pelo comando.

Para mais informações sobre kubectl apply, consulte a documentação de referência dekubectl.

Console

Para editar a configuração ativa de um StatefulSet, siga as etapas a seguir:

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. Selecione a carga de trabalho desejada.

  3. Clique em Editar.

  4. Use o editor para fazer as alterações pretendidas no objeto.

  5. Clique em Salvar.

Como inspecionar o lançamento de atualizações

kubectl

Para inspecionar a implantação do StatefulSet, execute o seguinte comando:

kubectl rollout status statefulset statefulset-name

Para ver o histórico de lançamento do StatefulSet:

kubectl rollout history statefulset statefulset-name

Para desfazer um lançamento:

kubectl rollout undo statefulset statefulset-name

Console

Para ver o histórico de revisões de um StatefulSet, siga as etapas a seguir:

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. Selecione a carga de trabalho desejada no menu.

  3. Clique em Histórico de revisões.

  4. Selecione a revisão desejada.

Atualizar estratégias

O campo updateStrategy de StatefulSet permite configurar e desativar atualizações graduais e automáticas para contêineres, marcadores, limites e solicitações de recursos e anotações para os pods em um StatefulSet.

Saiba mais sobre como Atualizar estratégias para StatefulSets na documentação do Kubernetes.

Como escalonar um StatefulSet

kubectl

kubectl scale pode ser usado a qualquer momento para escalonar seu StatefulSet.

Para escalonar manualmente um StatefulSet, execute o comando a seguir:

kubectl scale statefulset statefulset-name --replicas number-of-replicas

em que number-of-replicas é o número desejado de pods replicados.

Console

Para escalonar um StatefulSet, siga as etapas a seguir:

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. Selecione a carga de trabalho desejada no menu.

  3. Clique em Ações e depois em Escalonar.

  4. No campo Réplicas, insira o número desejado de réplicas.

  5. Clique em Escalonar.

Como excluir um StatefulSet

kubectl

Para excluir um StatefulSet, execute o seguinte comando:

kubectl delete statefulset statefulset-name

Console

Para excluir um StatefulSet, siga as etapas a seguir:

  1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

    Acessar o menu “Cargas de trabalho”

  2. No menu, selecione a carga de trabalho pretendida.

  3. Clique em Excluir.

  4. No menu da caixa de diálogo de confirmação, clique em Excluir.

A seguir