Registra direcciones IP privadas para grupos de trabajadores con Cloud DNS

En este instructivo, se describe cómo registrar la dirección IP privada de una instancia de grupo de trabajadores de Cloud Run dentro de una zona administrada de Cloud DNS. En este instructivo, usarás una secuencia de comandos de inicio para detectar de forma dinámica la IP de la instancia a través del servidor de metadatos y crear una aplicación de Node.js para controlar el tráfico de entrada directamente dentro de tu red de VPC.

Objetivos

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios Google Cloud nuevos decumplan con los requisitos para acceder a una prueba gratuita.

Antes de comenzar

  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. Habilita las APIs de Cloud DNS, Cloud Run, Compute Engine, Artifact Registry y Cloud Build.

    Roles necesarios para habilitar las APIs

    Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol Propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol Administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén información para otorgar roles.

    Habilitar las API

  4. Instala e inicializa gcloud CLI.
  5. Actualiza los componentes, como se indica a continuación: 
    gcloud components update
  6. Ejecuta el siguiente comando para configurar el ID del proyecto: 
    gcloud config set project PROJECT_ID
     Reemplaza PROJECT_ID por el ID de tu Google Cloud proyecto.

Roles obligatorios

Si quieres obtener los permisos que necesitas para completar el instructivo, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Crea una cuenta de servicio personalizada

Crea una cuenta de servicio personalizada con los permisos mínimos necesarios para registrar registros DNS. Para configurar la cuenta de servicio, haz lo siguiente:

  1. Ejecuta el siguiente comando para crear una cuenta de servicio:

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
  --display-name="DNS Worker Pool Service Account"

    Reemplaza SERVICE_ACCOUNT_NAME por un nombre para tu cuenta de servicio personalizada, por ejemplo, dns-worker-sa.

  2. Otorga el rol Administrador de Cloud DNS a la cuenta de servicio:

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID." \
  --role="roles/dns.admin"

Crear una zona de Cloud DNS

Crea una zona administrada privada de Cloud DNS llamada test-wp para registrar la IP de la instancia de tu grupo de trabajadores.

gcloud dns managed-zones create test-wp --description="new DNS zone for worker pools"  --dns-name="workerpools.example.com."  --visibility="private" --networks=default

Crea una aplicación de Node.js

Crea una aplicación de Node.js que recupere la dirección IP de la instancia del grupo de trabajadores con el servidor de metadatos y, luego, la registre en Cloud DNS.

  1. Crea una carpeta llamada worker y cambia el directorio a ella:

    mkdir worker
cd worker

  2. Crea un archivo llamado setup_dns.sh y agrega la siguiente secuencia de comandos que se ejecuta cuando se inicia la instancia del grupo de trabajadores. Esta secuencia de comandos usa el nombre de host de la instancia para generar el nombre del registro DNS. Si hay más de una instancia, varias instancias pueden usar el mismo nombre de host, lo que lleva a la creación de registros DNS superpuestos.

    #!/bin/bash

# --- Variables ---
# The name of your Cloud DNS managed zone.
ZONE_NAME="test-wp"
# The base domain suffix for the DNS entry. Use the part *after* the hostname.
# For example, for "testinstance.workerpools.example.com.", the suffix is ".workerpools.example.com."
DNS_SUFFIX=".workerpools.example.com."
# The Time-To-Live (TTL) in seconds.
TTL="300"
# The record type (A for IPv4).
RECORD_TYPE="A"
# -----------------

# 1. Dynamically generate DNS_NAME
# Get the simple hostname (e.g., "testinstance") and append the defined suffix.
# We use 'hostname -s' to get the short hostname.
SHORT_HOSTNAME=$(hostname -s)
DNS_NAME="${SHORT_HOSTNAME}${DNS_SUFFIX}"

# 2. Dynamically assign NEW_IP
# Get the IP address from metadata server using predefined key.
NEW_IP=$(curl "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip" -H "Metadata-Flavor: Google")

# --- Input Validation ---
if [ -z "$NEW_IP" ]; then
    echo "❌ ERROR: Could not obtain a valid IP address from metadata server. Aborting."
    exit 1
fi

echo "Starting DNS record update for ${DNS_NAME} in zone ${ZONE_NAME}..."
echo "New IP detected on this instance: ${NEW_IP}"

# 3. Get the current existing IP address (if any)
# This is required to know what to put in the --rrdatas for the delete command.
EXISTING_IP=$(gcloud dns record-sets list \
    --zone="${ZONE_NAME}" \
    --name="${DNS_NAME}" \
    --type="${RECORD_TYPE}" \
    --format="value(rrdatas[0])" 2>/dev/null)

# --- Conditional Deletion/Skip Check ---
if [ -n "$EXISTING_IP" ] && [ "$EXISTING_IP" != "$NEW_IP" ]; then
    echo "Found existing IP: ${EXISTING_IP}. It is different from the new IP."

    # Delete the existing record
    echo "Deleting old record..."
    gcloud dns record-sets delete "${DNS_NAME}" \
        --zone="${ZONE_NAME}" \
        --type="${RECORD_TYPE}" \
        --quiet

    if [ $? -ne 0 ]; then
        echo "❌ ERROR: Failed to delete existing record. Aborting."
        exit 1
    fi
elif [ -n "$EXISTING_IP" ] && [ "$EXISTING_IP" == "$NEW_IP" ]; then
    echo "Existing IP (${EXISTING_IP}) matches the new IP. Skipping update."
    exit 0
else
    echo "No existing record found for ${DNS_NAME}. Proceeding with creation."
fi
# ----------------------------------------

# 4. Add the new record
echo "Creating new record with IP: ${NEW_IP}..."
gcloud dns record-sets create "${DNS_NAME}" \
  --zone="${ZONE_NAME}" \
  --type="${RECORD_TYPE}" \
  --ttl="${TTL}" \
  --rrdatas="${NEW_IP}"

# Final status check
if [ $? -eq 0 ]; then
    echo "✅ Successfully created/updated DNS record for ${DNS_NAME} to ${NEW_IP}."
else
    echo "❌ ERROR: Failed to create the new DNS record."
    exit 1
fi

  3. Crea un archivo server.js con el siguiente código para controlar el tráfico de entrada de la dirección IP privada:

    // server.js

// 1. Import the built-in 'http' module
console.log("hello from worker pool")
const http = require('http');

// Define the port the server will listen on
const PORT = 3000;

// 2. Create the server instance
const server = http.createServer((req, res) => {
  // Set the response HTTP header with status and type of content
  res.writeHead(200, {'Content-Type': 'text/plain'});
  // Write the response body
  res.end('Hello World!\n');
});

// 3. Start the server and listen on the specified port
server.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}/`);
});

  4. Crea una secuencia de comandos start.sh con el siguiente código para realizar la configuración de DNS primero, antes de ejecutar tu aplicación de Node.js:

    #!/bin/bash
set -e

# 1. Execute the setup script
echo "Running setup_dns.sh..."
/app/setup_dns.sh

# 2. Run the main application
echo "Starting server.js..."
exec node /app/server.js

  5. Crea el siguiente Dockerfile para empaquetar la aplicación en una imagen:

    # Choose a base image. This image includes gcloud, kubectl, etc.
FROM google/cloud-sdk:latest

# Install Node.js on top of the Cloud SDK image.
RUN apt-get update && \
    apt-get install -y curl && \
    curl -sL https://deb.nodesource.com/setup_lts.x | bash - && \
    apt-get install -y nodejs && \
    # Clean up to reduce image size
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# Set the working directory inside the container.
WORKDIR /app

# Copy the application and scripts into the container.
COPY setup_dns.sh .
COPY server.js .
COPY start.sh .

# Make both scripts executable.
RUN chmod +x setup_dns.sh start.sh

# Define the entrypoint and default command.
ENTRYPOINT ["/app/start.sh"]
CMD []

Implementa un grupo de trabajadores con entrada de VPC directa

Implementa un grupo de trabajadores llamado test-cli-dns y conéctalo a una red de VPC.

gcloud run worker-pools deploy test-cli-dns \
  --network default \
  --subnet default \
  --region us-central1 \
  --source . \
  --service-account SERVICE_ACCOUNT_NAME@PROJECT_ID. \
  --project PROJECT_ID

Reemplaza PROJECT_ID por el ID de tu Google Cloud proyecto y SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio que creaste.

Prueba tu aplicación

Los grupos de trabajadores de Cloud Run con entrada de VPC directa están diseñados para el tráfico solo interno. No tienen una IP pública. Para verificar la funcionalidad de entrada, sigue estos pasos para ejecutar una solicitud con curl desde una VM de Compute Engine alojada en la misma red de VPC y subred:

  1. Crea una VM de prueba en la misma red y región que tu grupo de trabajadores:

     gcloud compute instances create wp-test-vm \
     --zone=us-central1-a \
     --network=default \
     --subnet=default

  2. Para conectarte a la VM de prueba a través de SSH, ejecuta el siguiente comando:

     gcloud compute ssh wp-test-vm --zone=us-central1-a

  3. Desde la terminal de la VM, invoca tu servicio en la dirección IP privada de la instancia del grupo de trabajadores registrada en Cloud DNS:

    curl http://localhost.workerpools.example.com:3000

    Deberías ver el siguiente resultado:

    Hello World!

¡Listo! Configuraste correctamente tu grupo de trabajadores de Cloud Run con entrada de VPC directa mediante una dirección IP privada y Cloud DNS.

Limpia

Para evitar cargos adicionales en tu Google Cloud cuenta, borra todos los recursos que implementaste con este instructivo.

Borra el proyecto

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y necesitas conservarlo sin los cambios que agregaste en este instructivo, borra los recursos que creaste para el instructivo.

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

Para borrar el proyecto, haz lo siguiente:

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

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que deseas borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrarlo.

Elimina recursos de instructivos

  1. Borra el servicio de Cloud Run que implementaste en este instructivo. Los servicios de Cloud Run no generan costos hasta que reciben solicitudes.

    Para borrar tu servicio de Cloud Run, ejecuta el siguiente comando:

    gcloud run services delete SERVICE-NAME

    Reemplaza SERVICE-NAME por el nombre del servicio.

    También puedes borrar los servicios de Cloud Run desde la Google Cloud consola.

  2. Quita la configuración predeterminada de la región gcloud que agregaste durante la configuración del instructivo:

     gcloud config unset run/region

  3. Quita la configuración del proyecto:

     gcloud config unset project

  4. Borra otros Google Cloud recursos creados en este instructivo:

¿Qué sigue?