Como implantar um aplicativo sem estado

Nesta página, você vê como implantar um aplicativo sem estado usando o Google Kubernetes Engine.

Visão geral

Os aplicativos sem estado são aqueles que não armazenam dados ou o estado do aplicativo no cluster ou no armazenamento permanente. Na verdade, os dados e o estado do aplicativo permanecem no cliente, o que torna os aplicativos sem estado mais escalonáveis. Por exemplo, um aplicativo de front-end é sem estado: você implanta várias réplicas para aumentar a disponibilidade dele e diminui quando a demanda é baixa, e as réplicas não precisam de identidades exclusivas.

O Kubernetes usa o Deployment para implantar aplicativos sem estado como pods uniformes e não exclusivos. Os objetos Deployment gerenciam o estado pretendido do aplicativo: quantos pods executarão seu aplicativo, qual versão da imagem do container será executada, como os pods serão rotulados e assim por diante. É possível alterar o estado pretendido dinamicamente por meio de atualizações na especificação do pod do Deployment.

Os aplicativos sem estado são diferentes dos com estado, que usam armazenamento permanente (em inglês) para salvar dados e StatefulSets para implantar pods com identidades exclusivas.

Antes de começar

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

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

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

Como usar o gcloud init

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

    gcloud init

    Se você usa o 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.

  • Se você é iniciante no GKE, é necessário concluir o guia de início rápido. Lá, você ativará a API do GKE e saberá como o produto funciona.

Anatomia do Deployment

Veja a seguir um exemplo de arquivo de manifesto de um objeto Deployment simples. Esse Deployment cria três pods replicados rotulados como app=my-app, que executam a imagem hello-app armazenada no Container Registry:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-app
    spec:
      replicas: 3
      selector:
        matchLabels:
          run: my-app
      template:
        metadata:
          labels:
            run: my-app
        spec:
          containers:
          - name: hello-app
            image: gcr.io/google-samples/hello-app:1.0
    

em que:

  • spec: replicas: é o número de pods replicados que o Deployment gerencia;
  • spec: template: metadata: labels: é o rótulo dado a cada pod que o Deployment usa para gerenciá-los;
  • spec: template: spec: é a especificação do pod, que define como cada pod será executado. spec: containers inclui o nome do contêiner a ser executado em cada pod e a imagem do contêiner que será executada.

Para mais informações sobre a especificação do Deployment, consulte a referência da API Deployment (em inglês).

Como criar um Deployment

Você cria uma implantação usando um dos seguintes métodos:

kubectl apply

Use kubectl apply para criar e atualizar declarativamente (em inglês) o Deployment a partir de arquivos de manifesto. Esse método também mantém atualizações feitas em recursos ativos sem mesclar as alterações novamente nos arquivos de manifesto.

Para criar um Deployment a partir do seu arquivo de manifesto, execute o comando a seguir:

kubectl apply -f [DEPLOYMENT_FILE]

em que [DEPLOYMENT_FILE] é o arquivo de manifesto, como config.yaml.

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

Console

Para criar um Deployment, execute 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. Clique em Implantar.

  3. Em Editar contêiner, selecione:

    • Imagem de contêiner atual para escolher uma imagem do Docker disponível no Container Registry. Preencha Imagem de contêiner com a imagem que você quer usar e a versão dela.

    • Nova imagem de contêiner para usar uma imagem criada com o Cloud Source Repositories e o Cloud Build.

  4. Se quiser, configure a implantação com:

    • as variáveis de ambiente a serem transmitidas para o contêiner;
    • os comandos iniciais para personalizar o entrypoint do contêiner no ambiente de execução.
  5. Clique em Continuar. A tela Configuração será exibida.

  6. Dê um Nome de aplicativo à implantação e especifique o Namespace do Kubernetes para implantá-lo.

  7. Se quiser aplicar rótulos do Kubernetes (em inglês) à implantação, acesse Rótulos e adicione Chaves e Valores.

  8. Se quiser salvar o YAML que cria essa implantação para atualizá-lo depois, clique em Ver YAML. Copie e cole o YAML em um arquivo e salve-o.

  9. No menu suspenso Cluster, escolha o cluster que quiser.

  10. Clique em Implantar.

Como inspecionar o Deployment

Depois de criar um Deployment, é possível usar um dos métodos a seguir para inspecioná-la:

kubectl

Para ver informações detalhadas sobre a implantação, execute o seguinte comando:

kubectl describe deployment [DEPLOYMENT_NAME]

em que [DEPLOYMENT_NAME] é o nome da implantação.

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

kubectl get pods -l [KEY]=[VALUE]

Neste comando, a sinalização -l instrui kubectl a conseguir todos os pods com um rótulo de chave-valor. Por exemplo, se você identificou o Deployment app: my-app, execute kubectl get pods -l app=my-app para ver os pods com esse rótulo.

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

kubectl describe pod [POD_NAME]

Para ver o manifesto de uma implantação, execute o seguinte comando:

kubectl get deployments [DEPLOYMENT_NAME] -o yaml

Esse comando exibe a configuração ativa da implantação no formato YAML.

Console

Para inspecionar uma implantação, siga as etapas a seguir:

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

    Acesse o menu "Cargas de trabalho"

  2. Para ver mais informações sobre uma carga de trabalho, selecione-a no menu.

O menu "Cargas de trabalho" oferece vários menus:

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

Como atualizar a implantação

É possível lançar atualizações na especificação de pod do Deployment, como imagem, uso/solicitação de recursos ou configuração.

É possível atualizar um objeto Deployment usando os métodos a seguir:

  • Use o menu Atualização gradual e o editor de YAML no menu Cargas de trabalho no Console do Cloud.
  • Faça alterações em um arquivo de manifesto e os aplique com o kubectl apply (em inglês).
  • Atualize os campos image, resources ou selector da especificação do pod usando o kubectl set.
  • Atualize um Deployment diretamente do shell ou em um editor de preferência usando o kubectl edit (em inglês).

kubectl apply

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

Para atualizar um Deployment, execute o comando a seguir:

kubectl apply -f [DEPLOYMENT_FILE]

em que [DEPLOYMENT_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.

kubectl set

Use kubectl set para modificar a imagem, recursos (solicitações ou limites) ou campos de seleção de um Deployment.

Para alterar a imagem de um Deployment, execute o comando a seguir:

kubectl set image deployment [DEPLOYMENT_NAME] [IMAGE] [IMAGE]:[TAG]

Por exemplo, para atualizar um Deployment do nginx versão 1.7.9 para 1.9.1, execute este comando:

kubectl set image deployment nginx nginx=nginx:1.9.1

Console

O menu Atualização contínua, disponível no menu "Cargas de trabalho",

Para acessar o menu Atualização gradual do Deployment, siga estas etapas:

  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, em seguida, em Atualização contínua.

É possível fazer as alterações a seguir na estratégia de atualização do Deployment:

  • Mínimo de segundos para estar pronto: especifica o número mínimo de segundos em que os pods recém-criados precisam estar prontos para que sejam considerados disponíveis.
  • Máximo de sobretensão: campo opcional que especifica o número máximo de pods que podem ser criados além do número pretendido. O valor pode ser um número absoluto ou uma porcentagem.
  • Máximo indisponível: campo opcional que especifica o número máximo de pods que podem estar indisponíveis durante o processo de atualização. O valor pode ser um número absoluto ou uma porcentagem.

    Para editar um contêiner atual:

    1. No menu Atualização gradual, selecione o contêiner para expandir o menu correspondente.
    2. Para alterar o nome do contêiner, edite o campo Nome do contêiner.
    3. Para alterar a imagem ou a versão do contêiner, edite o campo Nome da imagem.
    4. Clique em Concluído para salvar as alterações.
    5. Para excluir o contêiner, clique no ícone de Lixeira.

    Para adicionar um novo contêiner:

    1. No menu Atualização gradual, clique em Adicionar contêiner.
    2. Preencha o campo Nome da imagem com a imagem e a versão usando este formato: [IMAGE_NAME]:[IMAGE_VERSION]. Por exemplo, nginx:1.7.9.
    3. Opcionalmente, preencha o campo Nome do contêiner com um nome para o contêiner.
    4. Clique em Concluído.
  • Clique em Atualizar.

Para editar a configuração ativa de uma implantação, siga as etapas a seguir:

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

    Acesse 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 reverter uma atualização

Use kubectl rollout undo (em inglês) para reverter uma atualização.

É possível reverter uma atualização em andamento ou concluída para a revisão anterior:

kubectl rollout undo deployment my-deployment

Você também pode reverter para uma revisão específica:

kubectl rollout undo deployment my-deployment --to-revision=3

Como escalonar uma implantação

Use o Console do Cloud ou o kubectl scale (em inglês) para escalonar manualmente um objeto Deployment.

Saiba mais sobre o escalonamento automático do Deployment.

kubectl

kubectl scale pode ser usado a qualquer momento para escalonar sua implantação.

Para escalonar uma implantação manualmente, execute o comando a seguir:

kubectl scale deployment [DEPLOYMENT_NAME] --replicas [NUMBER_OF_REPLICAS]

em que [NUMBER_OF_REPLICAS] é o número desejado de pods replicados.

Console

Para escalonar uma implantação, 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 uma implantação

Use o Console do Cloud ou o kubectl delete (em inglês) para excluir um Deployment.

kubectl

Para excluir uma implantação, execute o comando a seguir:

kubectl delete deployment [DEPLOYMENT_NAME]

Console

Para excluir uma implantação, 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