Conectar-se do Google Kubernetes Engine (GKE) ao AlloyDB para PostgreSQL

Para conectar com segurança um aplicativo conteinerizado em um cluster do Autopilot do Google Kubernetes Engine a uma instância do AlloyDB para PostgreSQL, implante o proxy de autenticação do AlloyDB como um contêiner secundário em uma conexão de rede de IP particular.

O AlloyDB é um serviço de banco de dados totalmente gerenciado e compatível com o PostgreSQL no Google Cloud, e o Google Kubernetes Engine ajuda a implantar, escalonar e gerenciar automaticamente as cargas de trabalho do Kubernetes.

Objetivos

  • Crie uma imagem Docker para o AlloyDB.
  • Executar um aplicativo no Google Kubernetes Engine.
  • Conectar-se a uma instância do AlloyDB usando o proxy de autenticação do AlloyDB e um IP interno.

Custos

Neste tutorial, usamos componentes faturáveis do Google Cloud, incluindo:

  • AlloyDB
  • Google Kubernetes Engine
  • Artifact Registry

Use a calculadora de preços para gerar uma estimativa de custos baseada na projeção de uso.

Antes de começar

Console

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

  3. Verifique se você tem as permissões necessárias para concluir este tutorial.

  4. Ative as APIs do Cloud necessárias para criar e se conectar ao AlloyDB.

    Ativar as APIs

    1. Na etapa Confirmar projeto, clique em Avançar para confirmar o nome do projeto em que você vai fazer alterações.

    2. Na etapa Ativar APIs, clique em Ativar para ativar o seguinte:

      • API AlloyDB
      • API Artifact Registry
      • API Compute Engine
      • API Cloud Resource Manager
      • API Cloud Build
      • API Kubernetes Engine
      • API Service Networking

gcloud

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  2. Verify that billing is enabled for your Google Cloud project.

  3. Verifique se você tem as permissões necessárias para concluir este tutorial.

Para este tutorial, use o aplicativo da Web de amostra para coleta de votos chamado gke-alloydb-app.

Funções exigidas

Para receber as permissões necessárias para executar as tarefas neste tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Iniciar o Cloud Shell

O Cloud Shell é um ambiente shell para gerenciar recursos hospedados no Google Cloud.

O Cloud Shell vem pré-instalado com as ferramentas de linha de comando Google Cloud CLI e kubectl. A CLI gcloud fornece a principal interface de linha de comando para o Google Cloud. A kubectl fornece a principal interface de linha de comando para executar comandos em clusters do Kubernetes.

Console

Para iniciar o Cloud Shell, siga estas etapas.

  1. Acesse o console do Google Cloud .

    Console doGoogle Cloud

  2. Clique em Botão "Ativar o Cloud Shell" Ativar o Cloud Shell na parte de cima do console do Google Cloud .

  3. Na caixa de diálogo Autorizar o Cloud Shell, clique em Autorizar.

    Uma sessão do Cloud Shell é aberta dentro de um quadro inferior no console. Use este shell para executar os comandos gcloud e kubectl.

    1. Antes de executar comandos, defina o projeto padrão na Google Cloud CLI usando o seguinte comando:

      gcloud config set project PROJECT_ID

      Substitua PROJECT_ID pelo ID do projeto.

gcloud

  1. Para iniciar o Cloud Shell, siga estas etapas.

  2. No console do Google Cloud , ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do console do Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

  3. Para inicializar o ambiente, defina o projeto padrão na Google Cloud CLI usando o seguinte comando:

    gcloud config set project PROJECT_ID

    Substitua PROJECT_ID pelo ID do projeto.

  4. Ative as APIs do Cloud necessárias para criar e se conectar ao AlloyDB para PostgreSQL.

    gcloud services enable alloydb.googleapis.com \
    compute.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudbuild.googleapis.com \
    servicenetworking.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com

Criar um cluster do AlloyDB e a instância principal dele

Seu cluster do AlloyDB é composto por vários nós em uma nuvem privada virtual (VPC) do Google. Ao criar um cluster, você também configura o acesso a serviços particulares entre uma das suas redes VPC e a rede VPC gerenciada pelo Google que contém o novo cluster. Use o acesso por IP interno para evitar a exposição do banco de dados à Internet pública.

Para se conectar a um cluster do AlloyDB para PostgreSQL de fora da rede VPC configurada, configure o acesso a serviços particulares na VPC para o AlloyDB e use a rede VPC padrão para executar consultas de um aplicativo implantado em um cluster do GKE.

Console

  1. Acesse a página Clusters.

    Acessar Clusters

  2. Na seção Configurar cluster, no campo ID do cluster, insira um ID para o cluster. Ele precisa começar com uma letra minúscula e pode conter letras minúsculas, números e hifens, como alloydb-cluster.

  3. No campo Senha, insira a CLUSTER_PASSWORD que será usada para o usuário padrão do banco de dados postgres ao criar o cluster.

  4. No campo Versão do banco de dados, selecione a versão principal do POSTGRES_VERSION para o novo cluster do AlloyDB.

  5. Selecione uma REGION para o cluster, como us-central1.

  6. Na seção Configurar a instância primária, faça o seguinte:

    1. No campo ID da instância, insira o INSTANCE_ID da instância principal, como alloydb-primary.

    2. Selecione uma série de máquinas, por exemplo, N2.

    3. Selecione um tipo de máquina e especifique o número de unidades de processamento virtual NUM_CPU, como 2.

    4. Para atribuir um intervalo de IP ao peering de serviço, configure a conexão de acesso a serviços particulares:

      1. Na lista Rede, selecione default.

      2. Se um intervalo de IP como default-ip-range já estiver reservado, selecione-o na lista Intervalo de IP alocado.

      3. Se nenhum intervalo de IP estiver atribuído, clique em Alocar intervalo de IP personalizado para alocar um novo IP_RANGE_NAME interno e configurar a conexão.

  7. Clique em Criar cluster.

Aguarde a criação da instância do AlloyDB. Isso pode levar alguns minutos.

gcloud

  1. No Cloud Shell, verifique se o intervalo de endereços IP (IPv4) não utilizados já está atribuído ao peering de serviço:

    gcloud services vpc-peerings list --network=default

    Pule a próxima etapa se a saída for semelhante a esta:

    network: projects/493573376485/global/networks/default
peering: servicenetworking-googleapis-com
reservedPeeringRanges:
- default-ip-range
service: services/servicenetworking.googleapis.com

    Nessa saída, o valor de reservedPeeringRanges é default-ip-range, que pode ser usado como IP_RANGE_NAME para criar uma conexão particular na etapa 3.

  2. (Pule ao usar o valor padrão de reservedPeeringRanges) Para alocar endereços IP não utilizados na VPC, use o seguinte comando:

    gcloud compute addresses create IP_RANGE_NAME \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=16 \
    --description="VPC private service access" \
    --network=default

    Substitua IP_RANGE_NAME pelo nome dos endereços IP internos disponíveis em uma sub-rede do AlloyDB, como alloydb-gke-psa-01.

  3. Para configurar o acesso ao serviço usando o intervalo de IP alocado, execute o seguinte comando:

    gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=IP_RANGE_NAME \
    --network=default

  4. Para implantar o cluster do AlloyDB, execute o seguinte comando:

    gcloud alloydb clusters create CLUSTER_ID \
    --database-version=POSTGRES_VERSION \
    --password=CLUSTER_PASSWORD \
    --network=default \
    --region=REGION \
    --project=PROJECT_ID

    Substitua:

    • CLUSTER_ID: o ID do cluster que você está criando. Ele precisa começar com uma letra minúscula e pode conter letras minúsculas, números e hifens, como alloydb-cluster.

    • VERSION: a versão principal do PostgreSQL com que você quer que os servidores de banco de dados do cluster sejam compatíveis. Escolha uma destas opções:

      • 14: para compatibilidade com o PostgreSQL 14

      • 15: para compatibilidade com o PostgreSQL 15

      • 16: para compatibilidade com o PostgreSQL 16

      • 17: para compatibilidade com o PostgreSQL 17

      • 18: para compatibilidade com o PostgreSQL 18, que é a versão padrão compatível do PostgreSQL

    • CLUSTER_PASSWORD: a senha a ser usada para o usuário padrão postgres.

    • PROJECT_ID: o ID do projeto do Google Cloud em que você quer colocar o cluster.

    • REGION: o nome da região em que o cluster do AlloyDB é criado, como us-central1.

  5. Para implantar a instância principal do AlloyDB, execute o seguinte:

    gcloud alloydb instances create INSTANCE_ID \
    --instance-type=PRIMARY \
    --cpu-count=NUM_CPU \
    --region=REGION \
    --cluster=CLUSTER_ID \
    --project=PROJECT_ID

    Substitua:

    • INSTANCE_ID pelo nome da instância do AlloyDB que você escolher, como alloydb-primary.
    • CLUSTER_ID pelo nome do cluster do AlloyDB, como alloydb-cluster.
    • NUM_CPU pelo número de unidades de processamento virtual, como 2.
    • PROJECT_ID pelo ID do projeto do Google Cloud .
    • REGION pelo nome da região em que o cluster do AlloyDB foi criado, como us-central1.

    Aguarde a criação da instância do AlloyDB. Isso pode levar alguns minutos.

Conectar-se à instância principal e criar um banco de dados e um usuário do AlloyDB

Para criar um banco de dados e um usuário de banco de dados na instância principal, siga estas etapas:

Console

  1. Se você não estiver na página Visão geral do cluster recém-criado, acesse a página Clusters no console do Google Cloud .

    Acessar Clusters

  2. Para exibir a página Visão geral do cluster, clique no nome do cluster CLUSTER_ID.

  3. No menu de navegação, clique em AlloyDB Studio.

  4. Na página Fazer login no AlloyDB Studio, faça o seguinte:

    1. Na lista Banco de dados, selecione postgres.

    2. Na lista Usuário, selecione postgres.

    3. No campo Senha, insira a CLUSTER_PASSWORD que você criou em Criar um cluster do AlloyDB e a instância principal dele.

    4. Clique em Autenticar. O painel Explorer mostra uma lista dos objetos no seu banco de dados.

  5. Na guia Editor 1, faça o seguinte:

    1. Crie um banco de dados do AlloyDB:

      CREATE DATABASE DATABASE_NAME;

      Substitua DATABASE_NAME pelo nome de sua escolha, como tutorial_db.

    2. Clique em Executar. Aguarde até que a mensagem Statement executed successfully apareça no painel Resultados.

    3. Clique em Limpar.

    4. Crie um usuário e uma senha do banco de dados do AlloyDB:

      CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

      Substitua:

      • USERNAME: o nome do usuário do AlloyDB, como tutorial_user.

      • DATABASE_PASSWORD: a senha do banco de dados do AlloyDB, como tutorial.

    5. Clique em Executar. Aguarde até que a mensagem Statement executed successfully apareça no painel Resultados.

  6. No painel Explorador do AlloyDB Studio, clique em Trocar usuário/banco de dados.

  7. Na página Fazer login no AlloyDB Studio, faça o seguinte:

    1. Na lista Banco de dados, selecione DATABASE_NAME, como tutorial_db.

    2. Na lista Usuário, selecione postgres.

    3. No campo Senha, insira a CLUSTER_PASSWORD que você criou em Criar um cluster do AlloyDB e a instância principal dele.

    4. Clique em Autenticar. O painel Explorer mostra uma lista dos objetos no seu banco de dados.

  8. Na guia Editor 1, faça o seguinte:

    1. Conceda todas as permissões ao usuário do banco de dados do AlloyDB:

      GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";

    2. Clique em Executar. Aguarde até que a mensagem Statement executed successfully apareça no painel Resultados.

    3. Clique em Limpar.

    4. Conceda permissões ao usuário do banco de dados do AlloyDB no esquema público:

      GRANT CREATE ON SCHEMA public TO "USERNAME";

    5. Clique em Executar. Aguarde até que a mensagem Statement executed successfully apareça no painel Resultados.

  9. Anote o nome do banco de dados, o nome de usuário e a senha. Você usará essas informações em Criar um secret do Kubernetes.

gcloud

  1. Para criar um usuário de banco de dados do AlloyDB, execute o seguinte comando no Cloud Shell:

    gcloud alloydb users create USERNAME \
    --cluster=CLUSTER_ID \
    --region=REGION \
    --password=DATABASE_PASSWORD

    Substitua:

    • USERNAME: o nome do usuário do AlloyDB, como tutorial_user.
    • CLUSTER_ID: o ID do cluster, como alloydb-cluster.
    • REGION: a região em que o cluster está localizado, como us-central1.
    • DATABASE_PASSWORD: a senha do banco de dados do AlloyDB, como tutorial.

  2. Para criar um banco de dados e conceder permissões, conecte-se ao cluster e execute comandos SQL. No Cloud Shell, use o cliente psql para se conectar à instância.

  3. Depois de se conectar à instância como o usuário postgres, crie o banco de dados:

    CREATE DATABASE DATABASE_NAME;

    Substitua DATABASE_NAME pelo nome de sua escolha, como tutorial_db.

  4. Conceda todas as permissões ao usuário do banco de dados do AlloyDB no novo banco de dados:

    GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";

  5. Conecte-se ao novo banco de dados e conceda permissões no esquema public:

    \c DATABASE_NAME
GRANT CREATE ON SCHEMA public TO "USERNAME";

  6. Anote o nome do banco de dados, o nome de usuário e a senha. Você usará essas informações em Criar um secret do Kubernetes.

Criar um cluster do Autopilot do GKE

Um cluster contém pelo menos uma máquina de plano de controle de clusters e várias máquinas de worker chamadas de nós. Os nós são instâncias de máquina virtual (VM) do Compute Engine que executam os processos do Kubernetes necessários para integrá-los ao cluster. Você implanta os aplicativos nos clusters para que eles sejam executados nos nós.

Console

  1. No console do Google Cloud , acesse a página de clusters do Kubernetes.

    Acesse os clusters do Kubernetes

  2. Clique em Criar.

  3. Especifique GKE_CLUSTER_ID para o cluster do Autopilot no campo Nome da página Noções básicas sobre clusters, como ap-cluster.

  4. No campo Região, selecione REGION, como us-central1.

  5. Clique em Criar.

    Aguarde a criação do cluster do GKE. Isso pode levar alguns minutos.

gcloud

Criar um cluster do Autopilot:

gcloud container clusters create-auto GKE_CLUSTER_ID \
    --location=REGION

Substitua:

  • GKE_CLUSTER_ID: o nome do cluster do Autopilot, como ap-cluster.
  • REGION: o nome da região em que o cluster do GKE está implantado, como us-central1.

Aguarde a criação do cluster do GKE. Isso pode levar alguns minutos.

Conectar-se ao AlloyDB usando o proxy de autenticação do AlloyDB

Use o proxy de autenticação do AlloyDB para se conectar ao AlloyDB. O proxy de autenticação do AlloyDB fornece criptografia e autenticação fortes usando o Identity and Access Management (IAM), o que pode ajudar a proteger o banco de dados.

Quando você se conecta usando o proxy de autenticação do AlloyDB, ele é adicionado ao pod usando o padrão de contêiner sidecar. O contêiner do proxy de autenticação do AlloyDB está no mesmo pod que o aplicativo, o que permite que o aplicativo se conecte ao proxy por meio de localhost, aumentando a segurança e o desempenho.

Conceder acesso do Artifact Registry à conta de serviço padrão do Compute Engine

Conceda o papel de Leitor do Artifact Registry (roles/artifactregistry.reader) à conta de serviço padrão do Compute Engine para que os nós do Google Kubernetes Engine possam extrair imagens de contêiner do Artifact Registry.

Console

  1. No console do Google Cloud , acesse a página IAM.

    Acessar IAM

  2. Na página Permissões do projeto "PROJECT_ID", encontre a linha que contém a conta de serviço de computação padrão PROJECT_NUMBER-compute@ e clique em Editar principal nessa linha.

    Para receber o PROJECT_NUMBER, que é um identificador exclusivo gerado automaticamente para seu projeto, faça o seguinte:

    1. Acesse a página Painel no console do Google Cloud .

      Ir para o painel

    2. Clique na lista suspensa Selecionar de na parte superior da página. Na janela que aparecer, selecione seu projeto.

    O PROJECT_NUMBER é exibido no card Informações do projeto do Painel.

  3. Clique em Adicionar outro papel.

  4. Para conceder o papel roles/artifactregistry.reader, clique em Selecionar um papel, escolha Artifact Registry em Por produto ou serviço e escolha Artifact Registry Reader em Papéis.

  5. Clique em Salvar. O principal recebe o papel.

gcloud

Conceda o papel de Leitor do Artifact Registry (roles/artifactregistry.reader) no projeto à conta de serviço padrão do Compute Engine:

PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:$PROJECT_NUMBER-compute@" \
    --role="roles/artifactregistry.reader" \
    --condition=None

Substitua PROJECT_ID pelo ID do projeto.

Configurar a Federação de Identidade da Carga de Trabalho para GKE para o aplicativo de exemplo

Configure o Google Kubernetes Engine para autenticar o proxy de autenticação do AlloyDB usando a Federação de Identidade da Carga de Trabalho para GKE. Com a Federação de Identidade da Carga de Trabalho para GKE, você cria uma conta de serviço do Kubernetes para seu aplicativo no cluster do Google Kubernetes Engine e concede papéis do IAM a essa conta de serviço do Kubernetes. Crie uma conta de serviço do Kubernetes exclusiva para cada aplicativo para limitar as permissões por aplicativo.

Console

  1. Para iniciar o Cloud Shell, siga estas etapas.

  2. No console do Google Cloud , ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do console do Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

  3. No Cloud Shell, receba as credenciais do cluster:

    gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID

    Esse comando configura kubectl para usar o cluster do GKE que você criou.

  4. No editor de sua escolha, siga estas etapas:

    1. Abra service-account.yaml usando o nano, por exemplo:

      nano service-account.yaml

    2. No editor, cole o seguinte conteúdo:

      apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT

      Substitua KUBERNETES_SERVICEACCOUNT pelo nome da conta de serviço do Kubernetes, como alloydb-sa.

    3. Pressione Control+O, ENTER para salvar as mudanças e Control+X para sair do editor.

  5. Crie uma conta de serviço do Kubernetes para o aplicativo de amostra:

    kubectl apply -f service-account.yaml

  6. Para conceder papéis do IAM à conta de serviço do Kubernetes, siga estas etapas no console do Google Cloud :

    1. No console do Google Cloud , acesse a página IAM.

      Acessar IAM

    2. Selecione o projeto.

    3. Clique em Conceder acesso.

    4. No campo Novos participantes, insira o seguinte:

      principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID./subject/ns/default/sa/KUBERNETES_SERVICEACCOUNT

      Substitua:

      • PROJECT_NUMBER: o número do projeto.
      • PROJECT_ID: o ID do projeto.
      • KUBERNETES_SERVICEACCOUNT: o nome da ServiceAccount do Kubernetes, como alloydb-sa.

    5. Para conceder o papel roles/alloydb.client, na lista Selecionar um papel, escolha AlloyDB para PostgreSQL > Cliente do AlloyDB.

    6. Clique em Adicionar outro papel.

    7. Para conceder o papel roles/serviceusage.serviceUsageConsumer, na lista Selecionar um papel, escolha Service Usage > Consumidor do Service Usage.

    8. Clique em Salvar.

gcloud

  1. No console do Google Cloud , abra o Cloud Shell.

    Abra o Cloud Shell

  2. No Cloud Shell, receba as credenciais do cluster:

    gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID

    Esse comando configura kubectl para usar o cluster do GKE que você criou.

  3. No editor de sua escolha, siga estas etapas:

    1. Abra service-account.yaml usando o nano, por exemplo:

      nano service-account.yaml

    2. No editor, cole o seguinte conteúdo:

      apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT

      Substitua KUBERNETES_SERVICEACCOUNT pelo nome da conta de serviço do Kubernetes, como alloydb-sa.

    3. Pressione Control+O, ENTER para salvar as mudanças e Control+X para sair do editor.

  4. Crie uma conta de serviço do Kubernetes para o aplicativo de amostra:

    kubectl apply -f service-account.yaml

  5. Conceda os papéis de cliente do AlloyDB (roles/alloydb.client) e de consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer) no projeto à conta de serviço do Kubernetes:

    PROJECT_ID="PROJECT_ID"
KUBERNETES_SERVICEACCOUNT="KUBERNETES_SERVICEACCOUNT"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID./subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/alloydb.client" \
    --condition=None
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID./subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/serviceusage.serviceUsageConsumer" \
    --condition=None

    Substitua:

    • PROJECT_ID: o ID do projeto.
    • KUBERNETES_SERVICEACCOUNT: o nome da ServiceAccount do Kubernetes, como alloydb-sa.

Preencher o Artifact Registry com uma imagem do aplicativo de amostra

Para criar uma imagem de contêiner do aplicativo de amostra e enviá-la para um repositório, siga as etapas abaixo.

Console

  1. No console do Google Cloud , acesse a página do Artifact Registry.

    Acessar o Artifact Registry

  2. Para criar um repositório, clique em .

  3. No campo Nome, insira REPOSITORY_ID, como gke-alloydb-sample-app.

  4. Na seção Formato, selecione Docker.

  5. Na seção Tipo de local, selecione Região e escolha REGION, como us-central1.

  6. Clique em Criar.

  7. Para criar a imagem do aplicativo de amostra, inicie o Cloud Shell e siga as etapas abaixo.

  8. No console do Google Cloud , ative o Cloud Shell.

    Ativar o Cloud Shell

    Na parte inferior do console do Google Cloud , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

    1. No Cloud Shell, clone o repositório com o código do aplicativo de amostra gke-alloydb-app do GitHub:

        git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

    2. Na caixa de diálogo Autorizar o Cloud Shell, clique em Autorizar. Essa solicitação não vai aparecer se você já tiver concluído essa etapa.

    3. Para criar o contêiner do Docker e publicá-lo no Artifact Registry, execute o seguinte comando:

        gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID

      Substitua:

      • PROJECT_ID: ID do projeto.
      • REPOSITORY_ID: o nome do repositório, como gke-alloydb-sample-app.
      • SAMPLE_APPLICATION: o nome do seu aplicativo da Web de exemplo, como gke-alloydb-app.

gcloud

  1. No Cloud Shell, use o seguinte comando para clonar o repositório com o código do aplicativo de exemplo gke-alloydb-app do GitHub:

     git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

  2. Crie um repositório no Artifact Registry para imagens Docker:

    gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID

    Substitua:

    • PROJECT_ID: ID do projeto.
    • REPOSITORY_ID: o nome do repositório, como gke-alloydb-sample-app.

  3. Na caixa de diálogo Autorizar o Cloud Shell, clique em Autorizar. Essa solicitação não vai aparecer se você já tiver concluído essa etapa.

  4. Para criar um contêiner do Docker e publicá-lo no Artifact Registry, use o seguinte comando:

     gcloud builds submit --tag  REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID

    Substitua:

    • PROJECT_ID: ID do projeto.
    • REPOSITORY_ID: o nome do repositório, como gke-alloydb-sample-app.
    • SAMPLE_APPLICATION: o nome do seu aplicativo da Web de exemplo, como gke-alloydb-app.

Criar um secret do Kubernetes

Crie secrets do Kubernetes para o banco de dados, o usuário e a senha do usuário que serão usados pelo aplicativo de amostra. Os valores de cada secret são baseados nos valores especificados na etapa Conectar-se à instância primária e criar um banco de dados e um usuário do AlloyDB deste tutorial. Para mais informações, consulte Secrets.

Console

No Cloud Shell aberto, use um SECRET do Kubernetes, como gke-alloydb-secret, para armazenar as informações de conexão:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

gcloud

Use um SECRET do Kubernetes, como gke-alloydb-secret, para armazenar as informações de conexão:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

Implantar e executar o proxy de autenticação do AlloyDB em um padrão de arquivo secundário

Execute o proxy de autenticação em um padrão sidecar como um contêiner adicional que compartilha um pod com o aplicativo pelos seguintes motivos:

  • Impede que o tráfego SQL seja exposto localmente. O proxy de autenticação fornece criptografia nas conexões de saída, mas você precisa limitar a exposição das conexões de entrada.
  • Evita um ponto único de falha. O acesso de cada aplicativo ao seu banco de dados é independente dos outros, tornando-o mais resiliente.
  • Limita o acesso ao proxy de autenticação, permitindo o uso de permissões do IAM por aplicativo, em vez de expor o banco de dados a todo o cluster.
  • Permite que você defina o escopo das solicitações de recursos com mais precisão. Como o proxy de autenticação consome recursos linearmente ao uso, esse padrão permite que você defina o escopo com mais precisão e solicite recursos para corresponder aos seus aplicativos à medida que eles são escalonados.
  • Permite configurar o aplicativo para se conectar usando 127.0.0.1 no DB_PORT especificado na seção de comando.

Depois de criar um cluster do GKE e uma imagem de contêiner para o aplicativo, implante o aplicativo conteinerizado no cluster do GKE.

Console

Neste tutorial, você vai implantar o aplicativo da Web de exemplo para coleta de votos, gke-alloydb-app, que usa o AlloyDB como repositório de dados.

  1. Consiga o URI de conexão (INSTANCE_URI) da instância primária do AlloyDB:

    1. No Google Cloud console, acesse a página Clusters.

      Acessar Clusters

    2. Para exibir a página Visão geral do cluster, clique no nome dele na coluna Nome do recurso.

    3. Na seção Instâncias no cluster, localize a instância primária e acesse a seção Conectividade (ou clique em Visualizar configuração de conectividade).

    4. No campo URI de conexão, clique no botão Copiar para a área de transferência .

    Especifique esse INSTANCE_URI no arquivo de definição proxy_sidecar_deployment.yaml na etapa 2.b desta seção.

  2. No Cloud Shell aberto, conclua as seguintes etapas:

    1. Abra proxy_sidecar_deployment.yaml usando o editor de sua preferência, por exemplo, nano:

      nano proxy_sidecar_deployment.yaml

    2. No editor, cole o seguinte conteúdo:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.17.2
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          - "INSTANCE_URI"
        securityContext:
          runAsNonRoot: true
        resources:
          requests:
            memory: "2Gi"
            cpu:    "1"

      Substitua KUBERNETES_SERVICEACCOUNT pelo nome da sua conta de serviço do Kubernetes e substitua INSTANCE_URI pelo caminho que você copiou na etapa 1.

    3. Pressione Control+O, ENTER para salvar as mudanças e Control+X para sair do editor.

  3. Para implantar o aplicativo gke-alloydb-app, aplique o arquivo de definição:

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. Para verificar se o aplicativo está em execução, acesse a página Cargas de trabalho no console do Google Cloud :

    Acesse "Cargas de trabalho"

    Verifique se o status da implantação gke-alloydb é OK.

  5. Para se conectar ao aplicativo de amostra usando um balanceador de carga externo, conclua as seguintes etapas no Cloud Shell aberto:

    1. Abra service.yaml:

      nano service.yaml

    2. Cole o seguinte conteúdo:

      apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080

      Substitua SAMPLE_APPLICATION pelo nome do aplicativo, como gke-alloydb-app.

    3. Salve e saia do editor e aplique o serviço:

      kubectl apply -f service.yaml

  6. Para ver o endereço IP externo do aplicativo, acesse a página Serviços e entradas no console do Google Cloud :

    Acesse "Serviços e Entrada"

  7. Use o valor na coluna Endpoints externos para acessar o aplicativo no seguinte URL:

    http://EXTERNAL_IP

gcloud

Neste tutorial, você vai implantar o aplicativo da Web de exemplo para coleta de votos, gke-alloydb-app, que usa o AlloyDB como repositório de dados.

  1. Consiga a conexão de instância INSTANCE_URI para a instância principal do AlloyDB em que você quer que o proxy de autenticação se conecte:

       gcloud alloydb instances describe INSTANCE_ID \
   --cluster=CLUSTER_ID \
   --region=REGION \
   --format="value(name)"

    Substitua:

    • INSTANCE_ID: nome da instância, como alloydb-primary.
    • CLUSTER_ID: nome do cluster, como alloydb-cluster.

    A saída contém o INSTANCE_URI que você especificou no arquivo de definição proxy_sidecar_deployment.yaml na etapa 2.b desta seção.

  2. No editor de sua escolha, por exemplo, nano, conclua as seguintes etapas:

    1. Abra proxy_sidecar_deployment.yaml usando o editor de sua preferência, por exemplo, nano:

      nano proxy_sidecar_deployment.yaml

    2. No editor, cole o seguinte conteúdo:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        # This project uses environment variables to determine
        # how you would like to run your application
        # To use the Go connector (recommended) - use INSTANCE NAME
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        # To use Automatic IAM Authentication (recommended)
        # use DB_IAM_USER instead of DB_USER
        # you may also remove the DB_PASS environment variable
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
     # If you are using the Go connector (recommended), you can
      # remove alloydb-proxy (everything below this line)
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/alloydb-auth-proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.17.2
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          # Use <INSTANCE_URI>
          - "INSTANCE_URI"
        securityContext:
          # The default AlloyDB Auth proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

      Substitua KUBERNETES_SERVICEACCOUNT pelo nome da sua conta de serviço do Kubernetes e INSTANCE_URI pelo caminho para a instância principal do AlloyDB da etapa 1, como projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

    3. Pressione Control+O, ENTER para salvar as mudanças e Control+X para sair do editor.

  3. Para implantar o aplicativo gke-alloydb-app, aplique o arquivo de definição proxy_sidecar_deployment.yaml que você criou na etapa anterior:

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. Verifique se o status dos dois contêineres no pod é running:

    kubectl get pods

    Exemplo de resposta:

     NAME                          READY   STATUS    RESTARTS   AGE
 gke-alloydb-8d59bb4cc-62xgh   2/2     Running   0          2m53s

  5. Para se conectar ao aplicativo de amostra gke-alloydb-app, use um serviço, como um balanceador de carga HTTP externo. No editor de sua escolha, siga estas etapas:

    1. Abra service.yaml usando o nano, por exemplo:

      nano service.yaml

    2. No editor nano, cole o seguinte conteúdo:

      apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080

      Substitua SAMPLE_APPLICATION pelo nome do aplicativo da Web de amostra, como gke-alloydb-app.

    3. Pressione Control+O, ENTER para salvar as mudanças e Control+X para sair do editor.

  6. Para implantar o aplicativo de serviço gke-alloydb-app, aplique o arquivo service.yaml:

     kubectl apply -f service.yaml

  7. Para ver os detalhes do serviço, incluindo o endereço IP externo, use o seguinte comando:

    kubectl get service

    Exemplo de resposta:

    NAME              TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
gke-alloydb-app   LoadBalancer   34.118.229.246   35.188.16.172   80:32712/TCP   45s
kubernetes        ClusterIP      34.118.224.1     <none>          443/TCP        85m

  8. Use o valor do IP externo da etapa anterior para acessar o aplicativo de exemplo no seguinte URL:

    http://EXTERNAL-IP

Exemplos de arquivos de configuração

proxy_sidecar_deployment.yaml 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <YOUR-DEPLOYMENT-NAME>
spec:
  selector:
    matchLabels:
      app: <YOUR-APPLICATION-NAME>
  template:
    metadata:
      labels:
        app: <YOUR-APPLICATION-NAME>
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      # Your application container goes here.
      - name: <YOUR-APPLICATION-NAME>
        image: <YOUR-APPLICATION-IMAGE-URL>
        env:
        - name: DB_HOST
          # The port value here (5432) should match the --port flag below.
          value: "localhost:5432"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: database
      # The Auth Proxy sidecar goes here.
      - name: alloydb-auth-proxy
        # Make sure you have automation that upgrades this version regularly.
        # A new version of the Proxy is released monthly with bug fixes,
        # security updates, and new features.
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        args:
          # If you're connecting over public IP, enable this flag.
          # - "--public-ip"

          # If you're connecting with PSC, enable this flag:
          # - "--psc"

          # If you're using auto IAM authentication, enable this flag:
          # - "--auto-iam-authn"

          # Enable structured logging with Google's LogEntry format:
          - "--structured-logs"

          # Listen on localhost:5432 by default.
          - "--port=5432"
          # Specify your instance URI, e.g.,
          # "projects/myproject/locations/us-central1/clusters/mycluster/instances/myinstance"
          - "<INSTANCE-URI>"

        securityContext:
          # The default AlloyDB Auth Proxy image runs as the "nonroot" user and
          # group (uid: 65532) by default.
          runAsNonRoot: true
        # You should use resource requests/limits as a best practice to prevent
        # pods from consuming too many resources and affecting the execution of
        # other pods. You should adjust the following values based on what your
        # application needs. For details, see
        # https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

service.yaml 

apiVersion: v1
kind: Service
metadata:
  name: <YOUR-SERVICE-NAME>
spec:
  type: LoadBalancer
  selector:
    app: <YOUR-APPLICATION-NAME>
  ports:
  - port: 80
    targetPort: 8080

service-account.yaml 

apiVersion: v1
kind: ServiceAccount
metadata:
  name: <YOUR-KSA-NAME> # TODO(developer): replace this value

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados neste tutorial, exclua o projeto que contém os recursos ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para este tutorial.

Para excluir o projeto:

  1. No console Google Cloud , acesse a página Gerenciar recursos.

    Gerenciar recursos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.

  3. Na caixa de diálogo, digite o PROJECT_ID e clique em Encerrar para excluir o projeto.

A seguir