Como implantar um aplicativo com estado

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

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 dinamicamente sob demanda, para que os volumes subjacentes não precisem ser criados manualmente de antemão. No Kubernetes, o provisionamento dinâmico é configurado por meio da criação de um StorageClass. No GKE, um StorageClass padrão é instalado para que você possa provisionar dinamicamente os discos permanentes do Google Compute Engine.

O Kubernetes usa o controlador StatefulSet para implantar aplicativos com estado como objetos StatefulSet. Os pods nos StatefulSets não podem ser trocados. Cada pod tem um identificador exclusivo que é mantido, seja qual for o local em que está programado.

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

Observação: se você estiver trabalhando com clusters multizonais ou regionais, consulte Armazenamento permanente em clusters multizonais ou regionais.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

• Verifique se você ativou a API Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Verifique se o SDK do Cloud está instalado.
• Defina o ID do projeto padrão:

  gcloud config set project [PROJECT_ID]

• Se você estiver trabalhando com clusters zonais, defina a zona de computação padrão:

  gcloud config set compute/zone [COMPUTE_ZONE]

• Se você estiver trabalhando com clusters regionais, defina a região de computação padrão:

  gcloud config set compute/region [COMPUTE_REGION]

• Atualize a gcloud para a versão mais recente:

  gcloud components update

Observação: é possível substituir essas configurações padrão nos comandos gcloud usando as sinalizações operacionais --project, --zone e --region.

• Verifique se o aplicativo em contêiner está armazenado em um registro de imagens, como o Container Registry.

Se você for iniciante no GKE, precisará concluir o início rápido. Lá, você ativará a API GKE e saberá como o produto funciona.

Como solicitar armazenamento permanente em um StatefulSet

Aplicativos podem solicitar armazenamento permanente com um objeto 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.

Como criar um StatefulSet

Use kubectl apply para criar um StatefulSet.

O kubectl apply usa arquivos de manifesto para criar, atualizar e excluir recursos no 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.

Veja a seguir um exemplo simples de StatefulSet regido por um serviço criado separadamente:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: [STATEFULSET_NAME]
spec:
  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 escolhido para o StatefulSet;
• [SERVICE_NAME] é o nome escolhido para o serviço;
• [APP_NAME] é o nome escolhido para o aplicativo executado nos pods;
• [CONTAINER_NAME] é o nome escolhido para os contêineres nos pods;
• [PORT_NAME] é o nome escolhido para a porta aberta pelo StatefulSet;
• [PVC_NAME] é o nome escolhido para o PersistentVolumeClaim.

Nesse arquivo, o campo kind especifica que um objeto StatefulSet 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 à Internet.

Para criar um StatefulSet, execute o comando a seguir:

kubectl apply -f [STATEFULSET_FILE]

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

Observação: kubectl apply falhará se você não tiver um cluster ativo.

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

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]

Nesse comando, a sinalização -l instrui a kubectl para receber todos os pods rotulados do aplicativo [APP_NAME].

A resposta será semelhante a:

NAME                                READY     STATUS    RESTARTS   AGE
[POD_NAME]                                      1/1       Running   0          1m
[POD_NAME]                                      1/1       Running   0          1m

Para obter informações detalhadas sobre o StatefulSet, execute o comando a seguir:

kubectl describe statefulset [STATEFULSET_NAME]

em que [STATEFULSET_NAME] é o nome do StatefulSet.

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

kubectl describe pod [POD_NAME]

Para listar os PersistentVolumeClaims que foram criados:

kubectl get pvc

A resposta será semelhante a:

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. Visite o menu Cargas de trabalho do Google Kubernetes Engine no Console do GCP.

   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 comum e declarativo é kubectl apply. Para atualizar o StatefulSet diretamente a partir do shell ou do seu editor preferido, use kubectl edit. Você também pode usar o editor de YAML no menu Cargas de trabalho do GKE no Console do GCP.

Você pode fazer o lançamento de atualizações da especificação de pods dos StatefulSets, 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.

Observação: para atualizar um recurso com kubectl apply, é preciso que ele tenha sido criado com kubectl apply ou kubectl create --save-config.

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 da kubectl.

Console

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

1. Visite o menu Cargas de trabalho do Google Kubernetes Engine no Console do GCP.

   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.

Observação: é possível especificar um PersistentVolume diferente, mas não atualizar os atuais.

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. Visite o menu Cargas de trabalho do Google Kubernetes Engine no Console do GCP.

   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

Com o campo updateStrategy do StatefulSet, você configura e desativa as atualizações automáticas de contêineres, marcadores, solicitações/limites de recursos e anotações dos pods em um StatefulSet.

Para saber mais sobre as estratégias de atualização do StatefulSet, consulte a seção correspondente na documentação do Kubernetes.

Como escalonar um StatefulSet

kubectl

kubectl scale pode ser usado a qualquer momento para escalonar o 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. Visite o menu Cargas de trabalho do Google Kubernetes Engine no Console do GCP.

   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. Visite o menu Cargas de trabalho do Google Kubernetes Engine no Console do GCP.

   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

• Saiba como implantar aplicativos sem estado.