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

Console

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

   Ativar as APIs

   1. Na etapa Confirmar projeto, clique em Próxima para confirmar o nome do projeto que você vai mudar.

   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 Container Registry
      • API Kubernetes Engine
      • API Service Networking

Console

Para iniciar o Cloud Shell, siga estas etapas:

1. Acesse o console do Google Cloud .

   Google Cloud console

2. Clique em 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. 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 hífens, 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, que é a versão padrão compatível

       Para mais informações sobre as restrições aplicáveis ao uso do PostgreSQL 16 em prévia, consulte Compatibilidade da prévia do PostgreSQL 16.

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

   • PROJECT_ID: o ID do seu Google Cloud projeto 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 com o nome da instância do AlloyDB de sua escolha, como alloydb-primary.
   • CLUSTER_ID com o nome do cluster do AlloyDB, como alloydb-cluster.
   • NUM_CPU pelo número de unidades de processamento virtual, como 2.
   • PROJECT_ID com o ID do seu Google Cloud projeto.
   • REGION com o nome da região em que o cluster do AlloyDB é criado, como us-central1.

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

Console

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

   Acessar Clusters

2. Para mostrar 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 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 a mensagem Statement executed successfully aparecer 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 a mensagem Statement executed successfully aparecer no painel Resultados.

6. No painel Explorador do AlloyDB Studio, clique em manage_accounts Trocar de 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 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 a mensagem Statement executed successfully aparecer 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 a mensagem Statement executed successfully aparecer no painel Resultados.

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

Console

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

   Acesse os clusters do Kubernetes

2. Clique em Criar.

3. Especifique GKE_CLUSTER_ID para seu 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.

Console

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

   Acessar IAM

2. Na página Permissões para o projeto "PROJECT_ID", encontre a linha que contém a conta de serviço padrão do Compute PROJECT_NUMBER-compute@developer.gserviceaccount.com e clique em edit 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 Google Cloud .

      Ir para o painel

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

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

3. Clique em addAdicionar 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 selecione Artifact Registry Reader em Papéis.

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

6. Para criar uma conta de serviço para o aplicativo de exemplo do GKE, acesse a página Contas de serviço. Acessar Contas de serviço

7. Selecione o projeto.

8. Na página Contas de serviço para o projeto "PROJECT_ID", clique em Criar conta de serviço.

9. Na seção Detalhes da conta de serviço da página Criar conta de serviço, insira GSA_NAME no campo Nome da conta de serviço, como gke-alloydb-gsa.

10. Clique em Criar e continuar.

    A seção Conceda a essa conta de serviço acesso ao projeto (opcional) da página Criar conta de serviço aparece.

11. Para conceder o papel roles/alloydb.client, faça o seguinte:

    1. Clique em Selecionar papel.
    2. Escolha Cloud AlloyDB em Por produto ou serviço.
    3. Escolha Cloud AlloyDB Client em Funções.

12. Clique em addAdicionar outro papel.

13. Para conceder o papel roles/serviceusage.serviceUsageConsumer, clique em Selecionar um papel, escolha Service Usage em Por produto ou serviço e selecione Service Usage Consumer em Papéis.

14. Clique em Concluído. A conta de serviço do Google recebe papéis.

gcloud

1. Para conceder as permissões necessárias à conta de serviço padrão do Google para que o Compute Engine possa ler do Artifact Registry, execute o seguinte:

   PROGECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
   gcloud projects add-iam-policy-binding PROJECT_ID  --member="serviceAccount:$PROGECT_NUM-compute@developer.gserviceaccount.com"  --role="roles/artifactregistry.reader"

2. Para criar uma conta de serviço do Google para seu aplicativo, crie uma conta de serviço do IAM:

   gcloud iam service-accounts create GSA_NAME \
   --display-name="gke-tutorial-service-account"

   Substitua GSA_NAME pelo nome da nova conta de serviço do IAM, como gke-alloydb-gsa.

3. Para conceder os papéis alloydb.client e serviceusage.serviceUsageConsumer à GSA do aplicativo, use os seguintes comandos:

   gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/alloydb.client"
   gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/serviceusage.serviceUsageConsumer"

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 preferência, 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: KSA_NAME
      

      Substitua KSA_NAME pelo nome da conta de serviço, como ksa-alloydb.

   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 permissões para que sua conta de serviço do Kubernetes atue como a conta de serviço do Google criando uma vinculação de política do IAM entre as duas contas de serviço:

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

6. Adicione a anotação iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID à conta de serviço do Kubernetes usando o endereço de e-mail da conta de serviço do Google:

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

gcloud

1. No Cloud Shell, use o comando a seguir para clonar 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. Crie um repositório no Artifact Registry para imagens do 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 aparece se você já tiver feito 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 amostra, como gke-alloydb-app.

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

gcloud

Neste tutorial, você implanta o aplicativo da Web de coleta de votos de amostra, gke-alloydb-app, que usa o AlloyDB como o armazenamento de dados.

1. Receba a conexão de instância INSTANCE_URI da instância principal do AlloyDB a que você quer que o proxy do AlloyDB 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 especificado 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 escolha, 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: KSA_NAME
            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.10.1
              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 INSTANCE_URI pelo caminho da sua 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 criado 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, por exemplo, um balanceador de carga HTTP externo. No editor de sua preferência, 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 exemplo, 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 receber 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
   

proxy_sidecar_deployment.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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:5342"
        - 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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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