Conéctate desde Google Kubernetes Engine (GKE) a AlloyDB para PostgreSQL

En este instructivo, se describe cómo configurar una conexión desde una aplicación que se ejecuta en el clúster de Autopilot de Google Kubernetes Engine hasta una instancia de AlloyDB.

AlloyDB es un servicio de base de datos completamente administrado y compatible con PostgreSQL en Google Cloud.

Google Kubernetes Engine te ayuda a implementar, escalar y administrar Kubernetes de forma automática.

Objetivos

  • Compila una imagen de Docker para AlloyDB.
  • Ejecutar una aplicación en Google Kubernetes Engine
  • Conéctate a una instancia de AlloyDB con el proxy de autenticación de AlloyDB y la IP interna.

Costos

En este instructivo, se usan componentes facturables de Google Cloud, incluidos los siguientes:

  • AlloyDB
  • Google Kubernetes Engine
  • Artifact Registry

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

Console

  1. 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.

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

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

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

    Go to project selector

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Habilita las API de Cloud necesarias para crear AlloyDB para PostgreSQL y conectarte a él.

    Habilitar las API

    1. En el paso Confirmar proyecto, haz clic en Siguiente para confirmar el nombre del proyecto en el que realizarás cambios.

    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 de Cloud Resource Manager
      • API de Cloud Build
      • API de Container Registry
      • API de Kubernetes Engine
      • API de Service Networking

Para los fines de este instructivo, usa la aplicación web de muestra para recopilar votos llamada gke-alloydb-app.

Inicia Cloud Shell

Cloud Shell es un entorno de shell que se usa para administrar recursos alojados en Google Cloud.

Cloud Shell ya viene instalado en Google Cloud CLI y la herramienta de línea de comandos de kubectl. Gcloud CLI proporciona la interfaz de línea de comandos principal para Google Cloud. kubectl proporciona la interfaz de línea de comandos principal para ejecutar comandos en clústeres de Kubernetes.

Console

Para iniciar Cloud Shell, sigue estos pasos.

  1. Ve a la consola de Google Cloud.

    Consola de Google Cloud

  2. Haz clic en Botón para activar Cloud Shell Activar Cloud Shell en la parte superior de la consola de Google Cloud.

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

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

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

      gcloud config set project PROJECT_ID

      Reemplaza PROJECT_ID por el ID del proyecto.

Crea un clúster de AlloyDB y su instancia principal

Tu clúster de AlloyDB consta de varios nodos dentro de una nube privada virtual (VPC) de Google. Cuando creas un clúster, también configuras el acceso privado a servicios entre una de tus VPC y la VPC administrada por Google que contiene tu clúster nuevo. Te recomendamos que uses un acceso de IP interno para evitar que la base de datos se exponga a la Internet pública.

Para conectarte a un clúster de AlloyDB para PostgreSQL desde fuera de su VPC configurada, debes configurar el acceso privado a servicios en la VPC de AlloyDB y usar la red de VPC predeterminada para ejecutar consultas desde una aplicación implementada en un clúster de GKE.

gcloud

  1. En Cloud Shell, verifica si el rango de direcciones IP (IPv4) sin usar ya está asignado al servicio de vinculación:

    gcloud services vpc-peerings list --network=default

    Omite el siguiente paso si el resultado es similar al 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 puedes 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 sin usar 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

    Reemplaza IP_RANGE_NAME por tu nombre para las direcciones IP internas disponibles dentro de una subred de AlloyDB, como alloydb-gke-psa-01.

  3. Para configurar el acceso al servicio con el rango de IP asignado, ejecuta el siguiente comando:

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

  4. Para implementar 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

    Reemplaza lo siguiente:

    • CLUSTER_ID: Es el ID del clúster que creas. Debe comenzar con una letra minúscula y puede contener letras minúsculas, números y guiones, como alloydb-cluster.

    • VERSION: Es la versión principal de PostgreSQL con la que deseas 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, que es la versión predeterminada de PostgreSQL compatible

      • 16: Para la compatibilidad con PostgreSQL 16 (versión preliminar).

        Para obtener más información sobre las restricciones que se aplican al uso de PostgreSQL 16 en la versión preliminar, consulta Compatibilidad de la versión preliminar de PostgreSQL 16.

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

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

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

  5. Para implementar 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

    Reemplaza lo siguiente:

    • INSTANCE_ID por el nombre de la instancia de AlloyDB que elijas, como alloydb-primary.
    • CLUSTER_ID por el nombre del clúster de AlloyDB, como alloydb-cluster.
    • NUM_CPU por la cantidad de unidades de procesamiento virtuales, como 2.
    • PROJECT_ID con el ID de tu proyecto de Google Cloud .
    • REGION con 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. Esto puede tomar varios minutos.

Conéctate a tu instancia principal y crea una base de datos y un usuario de AlloyDB

Console

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

    Ir a los clústeres

  2. Para mostrar la página Descripción general del clúster, haz clic en el nombre del clúster CLUSTER_ID.

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

  4. En la página Sign in to 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 Contraseña, ingresa CLUSTER_PASSWORD que creaste en Crea 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 tu base de datos.

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

    1. Crea una base de datos de AlloyDB:

      CREATE DATABASE DATABASE_NAME;

      Reemplaza DATABASE_NAME por el nombre que prefieras, 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 la base de datos de AlloyDB:

      CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

      Reemplaza lo siguiente:

      • USERNAME: Es 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 Cambiar de usuario o base de datos.

  7. En la página Sign in to AlloyDB Studio, haz lo siguiente:

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

    2. En la lista Usuario, selecciona postgres.

    3. En el campo Contraseña, ingresa CLUSTER_PASSWORD que creaste en Crea 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 tu base de datos.

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

    1. Otorga 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. Otorga 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, el nombre de usuario y la contraseña de la base de datos. Usarás esta información en Cómo crear un Secret de Kubernetes.

Crea un clúster de GKE Autopilot

Un clúster contiene al menos una máquina de plano de control del clúster y varias máquinas trabajadoras llamadas nodos. Los nodos son instancias de máquina virtual (VM) de Compute Engine que ejecutan los procesos de Kubernetes necesarios para que sean parte del clúster. Las aplicaciones se implementan en los clústeres y, luego, se ejecutan en los nodos.

Console

  1. En la consola de Google Cloud, ve a la página de 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 Conceptos básicos 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. Esto puede tomar varios minutos.

gcloud

Crea un clúster de Autopilot:

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

Reemplaza lo siguiente:

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

Espera a que se cree el clúster de GKE. Esto puede tomar varios minutos.

Conéctate a AlloyDB con el proxy de autenticación de AlloyDB

Te recomendamos que uses el proxy de autenticación de AlloyDB para conectarte a AlloyDB. El proxy de autenticación de AlloyDB proporciona una encriptación sólida y autenticación mediante Identity and Access Management (IAM), lo que puede ayudar a mantener tu base de datos segura.

Cuando te conectas con el proxy de autenticación de AlloyDB, se agrega al pod con el patrón de contenedor de sidecar. El contenedor del proxy de autenticación de AlloyDB está en el mismo pod que tu aplicación, lo que permite que la aplicación se conecte al proxy de autenticación de AlloyDB mediante localhost, lo que aumenta la seguridad y el rendimiento.

Crea y otorga roles a las cuentas de servicio de Google

En Google Cloud, las aplicaciones usan cuentas de servicio para realizar llamadas a la API autorizadas mediante la autenticación como la cuenta de servicio. Cuando una aplicación se autentica como una cuenta de servicio, tiene acceso a todos los recursos a los que tiene acceso la cuenta de servicio.

Para ejecutar el proxy de Auth de AlloyDB en Google Kubernetes Engine, crea una cuenta de servicio de Google para representar tu aplicación. Te recomendamos que crees una cuenta de servicio única para cada aplicación, en lugar de usar la misma cuenta de servicio en todas partes. Este modelo es más seguro, ya que te permite limitar los permisos por aplicación.

Console

  1. En la consola de Google Cloud, ve a la página IAM.

    Ir a IAM

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

    Para obtener el PROJECT_NUMBER que es un identificador único generado automáticamente para tu proyecto, haz lo siguiente:

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

      Ir al panel

    2. Haz clic en la lista desplegable Seleccionar desde en la parte superior de la página. En la ventana Seleccionar una opción que aparece, elige tu proyecto.

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

  3. Haz clic en Agregar otro rol.

  4. Para otorgar 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 le otorga el rol al 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. Elige tu proyecto.

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

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

  10. Haz clic en Crear y continuar.

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

  11. Para otorgar el rol roles/alloydb.client, haz lo siguiente:

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

  12. Haz clic en Agregar otro rol.

  13. Para otorgar 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 le otorgan roles a la cuenta de servicio de Google.

gcloud

  1. Para otorgar los permisos necesarios a la cuenta de servicio predeterminada de Google, de modo que Compute Engine pueda leer desde 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"

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

  3. Para otorgar los roles alloydb.client y serviceusage.serviceUsageConsumer a la GSA 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"

Configura la federación de identidades para cargas de trabajo para GKE en la aplicación de ejemplo

Debes configurar GKE para proporcionar la cuenta de servicio al proxy de Auth de AlloyDB con la función Workload Identity Federation for GKE. Este método te permite vincular una cuenta de servicio de Kubernetes a una cuenta de servicio de Google. Luego, las aplicaciones podrán acceder a la cuenta de servicio de Google con la cuenta de servicio de Kubernetes coincidente.

Una cuenta de servicio de Google es una identidad de IAM que representa a la aplicación en Google Cloud. Una cuenta de servicio de Kubernetes es una identidad que representa a la aplicación en un clúster de Google Kubernetes Engine.

La federación de identidades para cargas de trabajo para GKE vincula una cuenta de servicio de Kubernetes a una de Google. Esta vinculación hace que cualquier implementación con esa cuenta de servicio de Kubernetes se autentique como la cuenta de servicio de Google en sus interacciones con Google Cloud.

gcloud

  1. En la consola de Google Cloud, abre Cloud Shell.

    Abra 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 usar el clúster de GKE que creaste.

  3. En el editor que elijas, completa los siguientes 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

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

    3. Presiona Control+O, presiona Intro para guardar los cambios y presiona 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. Para otorgar permisos a tu cuenta de servicio de Kubernetes para que actúe en nombre de la cuenta de servicio de Google, crea una vinculación de política de IAM 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. Agrega la anotación iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID a la cuenta de servicio de Kubernetes mediante la dirección de correo electrónico 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

Propaga Artifact Registry con una imagen de la aplicación de ejemplo

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

    Reemplaza lo siguiente:

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

  3. En el diálogo Autorizar Cloud Shell, haz clic en Autorizar. Esta indicación no aparecerá si ya realizaste este paso anteriormente.

  4. Para compilar un contenedor de 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

    Reemplaza lo siguiente:

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

Crea un secreto de Kubernetes

Creas secretos de Kubernetes para la base de datos, el usuario y la contraseña de usuario que usará la aplicación de ejemplo. Los valores de cada secreto se basan en los valores especificados en el paso Conéctate a tu instancia principal y crea una base de datos y un usuario de AlloyDB de este instructivo. Para obtener más información, consulta Secretos.

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

Implementa y ejecuta el proxy de AlloyDB en un patrón de archivo adicional

Te recomendamos que ejecutes el proxy de AlloyDB en un patrón sidecar como un contenedor adicional que comparte un Pod con tu aplicación por los siguientes motivos:

  • Evita que el tráfico de SQL se exponga de forma local. El proxy de AlloyDB proporciona encriptación en conexiones salientes, pero debes limitar la exposición para las conexiones entrantes.
  • Evita un punto único de fallo. El acceso de cada aplicación a la base de datos es independiente de las demás, por lo que es más resistente.
  • Limita el acceso al proxy de AlloyDB, lo que te permite usar permisos de IAM por aplicación, en lugar de exponer la base de datos a todo el clúster.
  • Te permite definir el alcance de las solicitudes de recursos con mayor precisión. Debido a que el proxy de AlloyDB consume recursos de forma lineal según el uso, este patrón te permite definir el alcance y solicitar recursos con mayor precisión para que se ajusten a las aplicaciones a medida que se realiza el escalamiento.
  • Te permite configurar la aplicación para que se conecte mediante 127.0.0.1 en el DB_PORT que especificaste en la sección de comandos.

Después de crear un clúster de GKE y compilar una imagen de contenedor para tu aplicación, implementa la aplicación alojada en contenedores en el clúster de GKE.

gcloud

En este instructivo, implementarás la aplicación web de muestra para recopilar votos, gke-alloydb-app, que usa AlloyDB como almacén de datos.

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

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

    Reemplaza lo siguiente:

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

    El resultado contiene el INSTANCE_URI que especificaste en el archivo de definición proxy_sidecar_deployment.yaml en el paso 2.b de esta sección.

  2. En el editor que prefieras, por ejemplo, nano, completa los siguientes 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"

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

    3. Presiona Control+O, presiona Intro para guardar los cambios y presiona Control+X para salir del editor.

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

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. Verifica que el estado de ambos contenedores en el Pod sea running:

    kubectl get pods

    Resultado de muestra:

     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, por ejemplo, un balanceador de cargas 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

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

    3. Presiona Control+O, presiona Intro para guardar los cambios y presiona Control+X para salir del editor.

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

     kubectl apply -f service.yaml

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

    kubectl get service

    Resultado de muestra:

    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

Archivos de configuración de muestra

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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, haz lo siguiente:

  1. En la consola de Google Cloud, ve a la página Administrar recursos.

    Administrar recursos

  2. En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.

  3. En el cuadro de diálogo, escribe tu PROJECT_ID y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?