Conectarse de Google Kubernetes Engine (GKE) a AlloyDB para PostgreSQL

Consola

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.

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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

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.

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 (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. Habilita las APIs de Cloud necesarias para crear una instancia de AlloyDB para PostgreSQL y conectarte a ella.

   Habilitar las APIs

   1. En el paso Confirmar proyecto, haz clic en Siguiente para confirmar el nombre del proyecto que vas a modificar.

   2. En el paso Habilitar APIs, haz clic en Habilitar para habilitar lo siguiente:

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

Consola

Para iniciar Cloud Shell, sigue estos pasos.

1. Ve a la Google Cloud consola.

   Google Cloud console

2. En la parte superior de la consola Google Cloud , haz clic en Activar Cloud Shell.

3. En el cuadro de diálogo Autorizar Cloud Shell, haz clic en Autorizar.

   Se abrirá una sesión de Cloud Shell en un marco de la parte inferior de la consola. Usa esta shell para ejecutar los comandos gcloud y kubectl.

   1. Antes de ejecutar comandos, define tu proyecto predeterminado en la CLI de Google Cloud con el siguiente comando:

      gcloud config set project PROJECT_ID

      Sustituye PROJECT_ID por el ID de tu proyecto.

gcloud

1. En Cloud Shell, comprueba si el intervalo de direcciones IP (IPv4) no utilizadas ya se ha asignado al peering de servicios:

   gcloud services vpc-peerings list --network=default

   Si el resultado es similar al siguiente, puedes saltarte el paso siguiente:

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

   En este resultado, el valor de reservedPeeringRanges es default-ip-range, que puede usar como IP_RANGE_NAME para crear una conexión privada en el paso 3.

2. (Omite este paso si usas el valor predeterminado de reservedPeeringRanges). Para asignar direcciones IP no utilizadas en la VPC, usa el siguiente comando:

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

   Sustituye IP_RANGE_NAME por el nombre que quieras dar a las direcciones IP internas disponibles de una subred de AlloyDB, como alloydb-gke-psa-01.

3. Para configurar el acceso al servicio mediante el intervalo de direcciones IP asignado, ejecuta el siguiente comando:

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

4. Para desplegar el clúster de AlloyDB, ejecuta el siguiente comando:

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

   Haz los cambios siguientes:

   • CLUSTER_ID: el ID del clúster que vas a crear. Debe empezar por una letra minúscula y puede contener letras minúsculas, números y guiones, como alloydb-cluster.

   • VERSION: la versión principal de PostgreSQL con la que quieres que sean compatibles los servidores de bases de datos del clúster. Elige una de estas opciones:

     • 14: para la compatibilidad con PostgreSQL 14

     • 15: para la compatibilidad con PostgreSQL 15

     • 16: para la compatibilidad con PostgreSQL 16, que es la versión predeterminada de PostgreSQL admitida

       Para obtener más información sobre las restricciones que se aplican al usar PostgreSQL 16 en vista previa, consulta Compatibilidad con la vista previa de PostgreSQL 16.

   • CLUSTER_PASSWORD: la contraseña que se usará para el usuario postgres predeterminado.

   • PROJECT_ID: el ID de tu Google Cloud proyecto en el que quieres colocar el clúster.

   • REGION: el nombre de la región en la que se crea el clúster de AlloyDB, como us-central1.

5. Para desplegar la instancia principal de AlloyDB, ejecuta lo siguiente:

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

   Haz los cambios siguientes:

   • INSTANCE_ID con el nombre de la instancia de AlloyDB que quieras, como alloydb-primary.
   • CLUSTER_ID con el nombre del clúster de AlloyDB, como alloydb-cluster.
   • NUM_CPU con el número de unidades de procesamiento virtuales, como 2.
   • PROJECT_ID por el ID de tu Google Cloud proyecto.
   • REGION por el nombre de la región en la que se crea el clúster de AlloyDB, como us-central1.

   Espera a que se cree la instancia de AlloyDB. Este proceso puede tardar varios minutos.

Consola

1. Si no estás en la página Información general del clúster que acabas de crear, ve a la página Clústeres de la consola Google Cloud .

   Ir a Clústeres

2. Para mostrar la página Resumen del clúster, haz clic en el nombre CLUSTER_ID del clúster.

3. En el menú de navegación, haz clic en AlloyDB Studio.

4. En la página Iniciar sesión en AlloyDB Studio, haz lo siguiente:

   1. En la lista Base de datos, selecciona postgres.

   2. En la lista Usuario, selecciona postgres.

   3. En el campo Password (Contraseña), introduce la contraseña CLUSTER_PASSWORD que creaste en Crear un clúster de AlloyDB y su instancia principal.

   4. Haz clic en Autenticar. En el panel Explorador se muestra una lista de los objetos de la base de datos.

5. En la pestaña Editor 1, haz lo siguiente:

   1. Crea una base de datos de AlloyDB:

      CREATE DATABASE DATABASE_NAME;
      

      Sustituye DATABASE_NAME por el nombre que quieras, como tutorial_db.

   2. Haz clic en Ejecutar. Espera a que aparezca el mensaje Statement executed successfully en el panel Resultados.

   3. Haz clic en Borrar.

   4. Crea un usuario y una contraseña de base de datos de AlloyDB:

      CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
      

      Haz los cambios siguientes:

      • USERNAME: el nombre del usuario de AlloyDB, como tutorial_user.

      • DATABASE_PASSWORD: la contraseña de tu base de datos de AlloyDB, como tutorial.

   5. Haz clic en Ejecutar. Espera a que aparezca el mensaje Statement executed successfully en el panel Resultados.

6. En el panel Explorador de AlloyDB Studio, haz clic en manage_accounts Cambiar de usuario o base de datos.

7. En la página Iniciar sesión en AlloyDB Studio, haz lo siguiente:

   1. En la lista Base de datos, seleccione DATABASE_NAME, como tutorial_db.

   2. En la lista Usuario, selecciona postgres.

   3. En el campo Password (Contraseña), introduce la contraseña CLUSTER_PASSWORD que creaste en Crear un clúster de AlloyDB y su instancia principal.

   4. Haz clic en Autenticar. En el panel Explorador se muestra una lista de los objetos de la base de datos.

8. En la pestaña Editor 1, haz lo siguiente:

   1. Concede todos los permisos al usuario de la base de datos de AlloyDB:

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

   2. Haz clic en Ejecutar. Espera a que aparezca el mensaje Statement executed successfully en el panel Resultados.

   3. Haz clic en Borrar.

   4. Concede permisos al usuario de la base de datos de AlloyDB en el esquema público:

      GRANT CREATE ON SCHEMA public TO "USERNAME";
      

   5. Haz clic en Ejecutar. Espera a que aparezca el mensaje Statement executed successfully en el panel Resultados.

9. Anota el nombre de la base de datos, el nombre de usuario y la contraseña. Esta información se usa en Crear un secreto de Kubernetes.

Consola

1. En la Google Cloud consola, ve a la página Clústeres de Kubernetes.

   Ir a clústeres de Kubernetes

2. Haz clic en Crear.

3. Especifica GKE_CLUSTER_ID para tu clúster de Autopilot en el campo Nombre de la página Información básica del clúster, como ap-cluster.

4. En el campo Región, selecciona REGION, como us-central1.

5. Haz clic en Crear.

   Espera a que se cree el clúster de GKE. Este proceso puede tardar varios minutos.

gcloud

Crea un clúster de Autopilot:

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

Haz los cambios siguientes:

• GKE_CLUSTER_ID: el nombre del clúster de Autopilot, como ap-cluster.
• REGION: el nombre de la región en la que se ha implementado el clúster de GKE, como us-central1.

Espera a que se cree el clúster de GKE. Este proceso puede tardar varios minutos.

Consola

1. En la consola, ve a la página Gestión de identidades y accesos. Google Cloud

   Ir a IAM

2. En la página Permisos del proyecto "PROJECT_ID", busca la fila que contiene la cuenta de servicio de computación predeterminada PROJECT_NUMBER-compute@developer.gserviceaccount.com y haz clic en edit Editar principal en esa fila.

   Para obtener el PROJECT_NUMBER, que es un identificador único generado automáticamente para tu proyecto, sigue estos pasos:

   1. Ve a la página Panel de control de la Google Cloud consola.

      Ir al panel de control

   2. En la parte superior de la página, haz clic en la lista desplegable Seleccionar de. En la ventana Seleccionar de que aparece, selecciona tu proyecto.

   El PROJECT_NUMBER se muestra en la tarjeta Información del proyecto del panel de control del proyecto.

3. Haz clic en addAñadir otro rol.

4. Para asignar el rol roles/artifactregistry.reader, haz clic en Seleccionar un rol y elige Artifact Registry en Por producto o servicio, y Artifact Registry Reader en Roles.

5. Haz clic en Guardar. Se asigna el rol a la cuenta principal.

6. Para crear una cuenta de servicio para la aplicación de ejemplo de GKE, ve a la página Cuentas de servicio. Ir a Cuentas de servicio

7. Selecciona el proyecto.

8. En la página Cuentas de servicio del proyecto "PROJECT_ID", haz clic en Crear cuenta de servicio.

9. En la sección Detalles de la cuenta de servicio de la página Crear cuenta de servicio, introduce GSA_NAME en el campo Nombre de cuenta de servicio, como gke-alloydb-gsa.

10. Haz clic en Crear y continuar.

    Aparecerá la sección Conceder a esta cuenta de servicio acceso al proyecto (opcional) de la página Crear cuenta de servicio.

11. Para asignar el rol roles/alloydb.client, sigue estos pasos:

    1. Haz clic en Seleccionar un rol.
    2. Elige Cloud AlloyDB en Por producto o servicio.
    3. Elige Cloud AlloyDB Client en Roles.

12. Haz clic en addAñadir otro rol.

13. Para asignar el rol roles/serviceusage.serviceUsageConsumer, haz clic en Seleccionar un rol y elige Service Usage en Por producto o servicio, y Service Usage Consumer en Roles.

14. Haz clic en Listo. Se asignan roles a la cuenta de servicio de Google.

gcloud

1. Para conceder los permisos necesarios a la cuenta de servicio predeterminada de Google para que Compute Engine pueda leer de Artifact Registry, ejecuta lo siguiente:

   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 crear una cuenta de servicio de Google para tu aplicación, crea una cuenta de servicio de IAM:

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

   Sustituye GSA_NAME por el nombre de tu nueva cuenta de servicio de IAM, como gke-alloydb-gsa.

3. Para conceder los roles alloydb.client y serviceusage.serviceUsageConsumer a la cuenta de servicio de Google de tu aplicación, usa los siguientes 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. En la Google Cloud consola, abre Cloud Shell.

   Abrir Cloud Shell

2. En Cloud Shell, obtén las credenciales de tu clúster:

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

   Este comando configura kubectl para que use el clúster de GKE que has creado.

3. En el editor que elijas, sigue estos pasos:

   1. Abre service-account.yaml con nano, por ejemplo:

      nano service-account.yaml

   2. En el editor, pega el siguiente contenido:

        apiVersion: v1
        kind: ServiceAccount
        metadata:
          name: KSA_NAME
      

      Sustituye KSA_NAME por el nombre de la cuenta de servicio, como ksa-alloydb.

   3. Pulsa Control+O, INTRO para guardar los cambios y Control+X para salir del editor.

4. Crea una cuenta de servicio de Kubernetes para tu aplicación de ejemplo:

   kubectl apply -f service-account.yaml

5. Concede permisos a tu cuenta de servicio de Kubernetes para suplantar la cuenta de servicio de Google creando un enlace de política de gestión de identidades y accesos entre las dos cuentas de servicio:

   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. Añade la anotación iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID a la cuenta de servicio de Kubernetes con la dirección de correo de la cuenta de servicio de Google:

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

gcloud

1. En Cloud Shell, usa el siguiente comando para clonar el repositorio con el código de la aplicación gke-alloydb-app de ejemplo de GitHub:

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

2. Crea un repositorio en Artifact Registry para las imágenes de Docker:

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

   Haz los cambios siguientes:

   • PROJECT_ID: el ID de tu proyecto.
   • REPOSITORY_ID: el nombre de tu repositorio, como gke-alloydb-sample-app.

3. En el cuadro de diálogo Autorizar Cloud Shell, haz clic en Autorizar. Esta petición no aparece si ya has completado este paso.

4. Para compilar un contenedor Docker y publicarlo en Artifact Registry, usa el siguiente comando:

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

   Haz los cambios siguientes:

   • PROJECT_ID: el ID de tu proyecto.
   • REPOSITORY_ID: el nombre de tu repositorio, como gke-alloydb-sample-app.
   • SAMPLE_APPLICATION: el nombre de tu aplicación web de muestra, como gke-alloydb-app.

gcloud

Usa un SECRET de Kubernetes, como gke-alloydb-secret, para almacenar la información de conexión:

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

gcloud

En este tutorial, desplegarás la aplicación web de ejemplo de recogida de votos, gke-alloydb-app, que usa AlloyDB como almacén de datos.

1. Obtén la cadena de conexión de la instancia principal de AlloyDB a la que quieres que se conecte el proxy de AlloyDB:INSTANCE_URI

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

   Haz los cambios siguientes:

   • INSTANCE_ID: nombre de la instancia, como alloydb-primary.
   • CLUSTER_ID: nombre del clúster, como alloydb-cluster.

   La salida contiene el INSTANCE_URI que especifiques en el archivo de definición proxy_sidecar_deployment.yaml del paso 2b de esta sección.

2. En el editor que elijas (por ejemplo, nano), sigue estos pasos:

   1. Abre proxy_sidecar_deployment.yaml con el editor que prefieras; por ejemplo, nano:

      nano proxy_sidecar_deployment.yaml

   2. En el editor, pega el siguiente contenido:

      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"
      

      Sustituye INSTANCE_URI por la ruta a tu instancia principal de AlloyDB del paso 1, como projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

   3. Pulsa Control+O, INTRO para guardar los cambios y Control+X para salir del editor.

3. Para desplegar la aplicación gke-alloydb-app, aplica el archivo de definición proxy_sidecar_deployment.yaml que has creado en el paso anterior:

   kubectl apply -f proxy_sidecar_deployment.yaml

4. Verifica que el estado de ambos contenedores del pod sea running:

   kubectl get pods

   Ejemplo de salida:

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

5. Para conectarte a la aplicación gke-alloydb-app de ejemplo, usa un servicio, como un balanceador de carga HTTP externo. En el editor que elijas, sigue estos pasos:

   1. Abre service.yaml con nano, por ejemplo:

      nano service.yaml

   2. En el editor nano, pega el siguiente contenido:

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

      Sustituye SAMPLE_APPLICATION por el nombre de tu aplicación web de ejemplo, como gke-alloydb-app.

   3. Pulsa Control+O, INTRO para guardar los cambios y Control+X para salir del editor.

6. Para desplegar la aplicación de servicio gke-alloydb-app, aplica el archivo service.yaml:

    kubectl apply -f service.yaml

7. Para obtener los detalles del servicio, incluida la dirección IP externa del servicio, utiliza el siguiente comando:

   kubectl get service

   Ejemplo de salida:

   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. Usa el valor de la IP externa del paso anterior para acceder a la aplicación de ejemplo en la siguiente 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