Implantar um app usando o Autopilot do GKE e o Spanner

Neste tutorial, descrevemos como implantar um aplicativo da Web conteinerizado em um cluster do Autopilot do Google Kubernetes Engine (GKE) e usar um banco de dados do Google Spanner no back-end para armazenar dados. O aplicativo de amostra gerencia uma tabela de jogadores. Você pode adicionar e excluir jogadores por meio da interface gráfica do usuário (GUI, na sigla em inglês).

O Spanner é um serviço de banco de dados relacional totalmente gerenciado, escalonável horizontalmente e distribuído globalmente que fornece transações ACID e semântica SQL sem comprometer o desempenho e a alta disponibilidade.

Antes de ler esta página, você precisa ter familiaridade com o Kubernetes.

Por que o GKE e o Spanner

Como desenvolvedor, talvez você não queira gastar tempo identificando a quantidade de recursos de armazenamento e computação que seu aplicativo precisa, nem prevendo o consumo de RAM e CPU durante períodos de demanda instável ou se preocupando com falhas no aplicativo no pico de carga.

Ao usar o Autopilot do GKE como um serviço do Kubernetes totalmente gerenciado e o Spanner como um serviço de banco de dados totalmente gerenciado, é possível desenvolver e implantar apps mais rapidamente em uma infraestrutura estável que simplifica a configuração e o gerenciamento de recursos. O Autopilot do GKE processa a configuração e o escalonamento da infraestrutura para hospedar seu aplicativo adicionando nós ao cluster ou os removendo dele, com base nos requisitos do ambiente de execução. Da mesma forma, o Spanner pode ser escalonado dinamicamente com a intervenção manual mínima, à medida que os requisitos de armazenamento ou computação mudam.

Por exemplo, imagine que você esteja lançando um novo grande sucesso, um jogo que deverá ser viral e, portanto, vai atrair um tráfego intenso da Web durante a semana de lançamento. O Spanner pode ajudar você a atender essa capacidade de processamento de pico, permitindo que você aumente, diminua ou realoque recursos de computação instantaneamente, enquanto mantém a máxima disponibilidade de aplicativos com o Autopilot do GKE.

Configurar o Spanner

Para configurar o Spanner, é necessário criar uma instância e um banco de dados do Spanner.

Criar uma instância do Spanner

Uma instância do Spanner é uma alocação de recursos usados pelos bancos de dados do Spanner criados nessa instância.

Crie uma instância do Spanner chamada hello-instance com uma configuração regional e calcule a capacidade de 100 unidades de processamento.

gcloud spanner instances create hello-instance \
    --config=regional-COMPUTE_REGION \
    --description="Spanner sample instance" \
    --processing-units=100

Substitua COMPUTE_REGION por us-west1 para fins deste tutorial.

Criar um banco de dados do Spanner

Um banco de dados do Spanner inclui tabelas, visualizações e índices. Um banco de dados herda propriedades da instância pai, como a configuração (regional ou multirregional), a capacidade de computação e armazenamento disponíveis.

Crie um banco de dados do Spanner chamado hello-database com uma tabela chamada Players, usando o dialeto GoogleSQL. Execute a consulta a seguir no Cloud Shell:

gcloud spanner databases create hello-database \
    --instance=hello-instance \
    --database-dialect=GOOGLE_STANDARD_SQL \
    --ddl="CREATE TABLE Players (
        PlayerUuid STRING(36) NOT NULL,
        FirstName STRING(1024),
        LastName STRING(1024),
        BirthDate DATE) PRIMARY KEY(PlayerUuid)"

Criar um cluster do Autopilot do GKE

Depois de configurar o Cloud Spanner, crie um cluster do Autopilot e use a federação de identidade da carga de trabalho do GKE para acessar seu banco de dados de maneira segura e gerenciável.

Crie um cluster do Autopilot chamado hello-cluster: Os clusters do Autopilot têm a federação de identidade da carga de trabalho do GKE ativada por padrão.

gcloud container clusters create-auto CLUSTER_NAME \
  --location=CONTROL_PLANE_LOCATION

Substitua:

  • CLUSTER_NAME: hello-cluster
  • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controle do cluster. Para este tutorial, use a mesma região, us-west1, em que você criou a instância do Spanner. Recomendamos que você crie a instância do Spanner e o cluster do Autopilot do GKE na mesma região, para reduzir a latência.

A criação do cluster pode levar de 8 a 10 minutos.

O resultado será assim:

NAME: hello-cluster
LOCATION: us-west1
MASTER_VERSION: 1.26.5-gke.1200
MASTER_IP: 192.0.2.1
MACHINE_TYPE: e2-medium
NODE_VERSION: 1.26.5-gke.1200
NUM_NODES: 3
STATUS: RUNNING

Configurar o cluster para usar a federação de identidade da carga de trabalho para o GKE

Configure o cluster para se autenticar no Google Cloud usando a federação de identidade da carga de trabalho do GKE antes de implantar o app.

  1. Obtenha credenciais para acessar seu cluster:

    gcloud container clusters get-credentials CLUSTER_NAME \
  --location=CONTROL_PLANE_LOCATION

    Substitua:

    • CLUSTER_NAME: hello-cluster
    • CONTROL_PLANE_LOCATION: us-west1

    Isso vai atualizar um arquivo kubeconfig com as credenciais e informações de endpoint apropriadas para apontar kubectl no cluster.

  2. Crie o namespace que será usado para a conta de serviço do Kubernetes. Também é possível utilizar o namespace padrão ou qualquer namespace existente.

    kubectl create namespace NAMESPACE

    Substitua NAMESPACE por hello-namespace, o nome do novo namespace que você está criando.

  3. Crie uma conta de serviço do Kubernetes para o aplicativo usar:

    kubectl create serviceaccount KSA_NAME \
  --namespace NAMESPACE

    Substitua:

    • KSA_NAME: ksa-helloapp, o nome da nova conta de serviço do Kubernetes que você está criando.
    • NAMESPACE: hello-namespace

  4. Crie uma conta de serviço do IAM para seu aplicativo:

    gcloud iam service-accounts create GSA_NAME \
  --project=GSA_PROJECT

    Substitua:

    • GSA_NAME: gsa-helloapp, o nome da nova conta de serviço do IAM que você está criando.
    • GSA_PROJECT: o ID do projeto Google Cloud. Neste tutorial, você vai criar a conta de serviço do IAM no mesmo projeto Google Cloud em que está implantando o app de amostra. Portanto, o GSA_PROJECT e oGoogle Cloud PROJECT_ID são iguais.

  5. Adicione uma vinculação de política do IAM à conta de serviço do IAM para leitura e gravação no Spanner:

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

    Substitua:

    • PROJECT_ID: o ID do projeto Google Cloud
    • GSA_NAME: gsa-helloapp

    Exemplo:

    gcloud projects add-iam-policy-binding my-gcp-project \
  --member "serviceAccount:gsa-helloapp@my-gcp-project.iam.gserviceaccount.com" \
  --role "roles/spanner.admin"

  6. Permita a conta de serviço do Kubernetes atuar como a conta de serviço do IAM. Para isso, adicione uma vinculação de política do IAM entre as duas contas de serviço. Essa vinculação permite à conta de serviço do Kubernetes atue como a conta de serviço do IAM, para que a conta de serviço do Kubernetes possa ser lida e gravada no Spanner.

    gcloud iam service-accounts add-iam-policy-binding GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"

    Substitua:

    • GSA_NAME: gsa-helloapp
    • GSA_PROJECT: o ID do projeto Google Cloud
    • PROJECT_ID: o ID do projeto Google Cloud
    • NAMESPACE: hello-namespace
    • KSA_NAME: ksa-helloapp

    Exemplo:

    gcloud iam service-accounts add-iam-policy-binding gsa-helloapp@my-gcp-project.iam.gserviceaccount.com \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:my-gcp-project.svc.id.goog[hello-namespace/ksa-helloapp]"

  7. Anote a conta de serviço do Kubernetes com o endereço de e-mail da conta de serviço do IAM. Isso permite que seu app de amostra identifique qual conta de serviço usar para acessar os serviços do Google Cloud . Portanto, quando o app usa qualquer biblioteca de cliente padrão da API do Google para acessar os serviços do Google Cloud , ele usa essa conta de serviço do IAM.

    kubectl annotate serviceaccount KSA_NAME \
  --namespace NAMESPACE \
  iam.gke.io/gcp-service-account=GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com

    Substitua:

    • KSA_NAME: ksa-helloapp
    • NAMESPACE: hello-namespace
    • GSA_NAME: gsa-helloapp
    • GSA_PROJECT: o ID do projeto Google Cloud

    Exemplo:

    kubectl annotate serviceaccount ksa-helloapp \
  --namespace hello-namespace \
  iam.gke.io/gcp-service-account=gsa-helloapp@my-gcp-project.iam.gserviceaccount.com

Implantar o app de amostra no cluster

Agora que você configurou o GKE e o Spanner com os serviços e a autenticação necessários, tudo está pronto para implantar o aplicativo de amostra hello-app-cloud-spanner.

  1. Clone o aplicativo de amostra do repositório do GitHub para o Cloud Shell:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

  2. Inicie o editor do Cloud Shell clicando em Botão "Editor de código" Abrir editor na barra de ferramentas da janela do terminal.

    Para mais informações, consulte a Visão geral da interface do editor do Cloud Shell.

  3. Abra o painel Explorer do editor do Cloud Shell e procure o diretório kubernetes-engine-samples/databases/hello-app-cloud-spanner/k8s.

  4. Abra o arquivo deployment.yaml e atualize o campo serviceAccountName substituindo <KSA_NAME> por ksa-helloapp, o nome da sua conta de serviço do Kubernetes.

    Edite yaml para atualizar KSA_NAME.
    Figura 1. Atualize o nome da conta de serviço do Kubernetes no arquivo de implantação.

  5. Feche o editor do Cloud Shell e volte ao terminal do Cloud Shell.

  6. No terminal do Cloud Shell, procure o diretório hello-app-cloud-spanner:

    cd kubernetes-engine-samples/databases/hello-app-cloud-spanner

  7. Implante o aplicativo:

    kubectl apply -f k8s/deployment.yaml -n=NAMESPACE

    Substitua NAMESPACE por hello-namespace.

  8. Aguarde até que o aplicativo seja implantado com STATUS como Running:

    kubectl get pods -n=NAMESPACE --watch

    Substitua NAMESPACE por hello-namespace.

    O resultado será assim:

    NAME                                       READY   STATUS              RESTARTS   AGE
hello-app-cloud-spanner-765c9b8779-lfcrc   0/1     ContainerCreating   0          87s
hello-app-cloud-spanner-765c9b8779-lfcrc   1/1     Running             0          3m15s

  9. Pressione Ctrl+C no teclado para retornar ao prompt de comando e executar mais comandos.

Publicar o app de amostra na Internet

Para publicar um serviço do Kubernetes fora do cluster, crie um Serviço do tipo LoadBalancer. Esse tipo de serviço gera um endereço IP do balanceador de carga externo para os pods, que pode ser acessado pela Internet.

  1. Implante o balanceador de carga:

    kubectl apply -f k8s/service.yaml -n=NAMESPACE

    Substitua NAMESPACE por hello-namespace.

  2. Preste atenção ao endereço IP externo que será atribuído:

    kubectl get service -n=NAMESPACE --watch

    Substitua NAMESPACE por hello-namespace.

  3. Depois de atribuído, copie o EXTERNAL-IP (por exemplo, 203.0.113.0) e abra-o em um navegador. É aberta uma interface da Web que exibe e gerencia o banco de dados dos jogadores.

  4. É possível usar a GUI do app para criar ou excluir registros de um jogador. Eles ficam salvos no banco de dados do Spanner.

    Adicionar ou excluir jogadores.
    Figura 2. Criar ou excluir jogadores no registro.

    Execute a consulta a seguir para verificar se o banco de dados do Spanner foi atualizado com as entradas:

    gcloud spanner databases execute-sql hello-database \
  --instance=hello-instance \
  --sql="SELECT * FROM Players LIMIT 10"

    O resultado será assim:

    PlayerUuid: a1f34bbf-929c-498d-8b16-39bbb29d70e3
FirstName: John
LastName: Smith
BirthDate: 1997-07-12

PlayerUuid: d634e157-96ea-45f2-be3f-fb907ced188e
FirstName: Jane
LastName: Doe
BirthDate: 2013-07-12