Private IP-Adressen für Worker-Pools mit Cloud DNS registrieren

Benutzerdefiniertes Dienstkonto erstellen

Erstellen Sie ein benutzerdefiniertes Dienstkonto mit den erforderlichen Mindestberechtigungen zum Registrieren von DNS-Einträgen. So richten Sie das Dienstkonto ein:

1. Erstellen Sie ein Dienstkonto mit dem folgenden Befehl:

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

   Ersetzen Sie SERVICE_ACCOUNT_NAME durch einen Namen für Ihr benutzerdefiniertes Dienstkonto, z. B. dns-worker-sa.

2. Weisen Sie dem Dienstkonto die Rolle „Cloud DNS-Administrator“ zu:

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

Cloud DNS-Zone erstellen

Erstellen Sie eine private verwaltete Cloud DNS-Zone mit dem Namen test-wp, um die Instanz-IP Ihres Worker-Pools zu registrieren.

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

Node.js-Anwendung erstellen

Erstellen Sie eine Node.js-Anwendung, die die IP-Adresse der Worker-Pool-Instanz über den Metadatenserver abruft und sie dann bei Cloud DNS registriert.

1. Erstellen Sie einen Ordner mit dem Namen worker und wechseln Sie in dieses Verzeichnis:

   mkdir worker
   cd worker
   

2. Erstellen Sie eine Datei mit dem Namen setup_dns.sh und fügen Sie ihr das folgende Skript hinzu, das beim Start der Worker-Pool-Instanz ausgeführt wird. In diesem Skript wird der DNS-Eintragsname aus dem Hostnamen der Instanz generiert. Wenn es mehr als eine Instanz gibt, können mehrere Instanzen denselben Hostnamen verwenden, was zur Erstellung sich überschneidender DNS-Einträge führt.

   #!/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. Erstellen Sie eine server.js-Datei mit dem folgenden Code, um den Ingress der privaten IP-Adresse zu verarbeiten:

   // 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. Erstellen Sie ein start.sh-Skript mit dem folgenden Code, um zuerst die DNS-Einrichtung vorzunehmen, bevor Sie Ihre Node.js-Anwendung ausführen:

   #!/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. Erstellen Sie das folgende Dockerfile, um die Anwendung in einem Image zu verpacken:

   # 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 []
   

Worker-Pool mit Direct VPC-Verbindung für eingehenden Traffic bereitstellen

Stellen Sie einen Worker-Pool mit dem Namen test-cli-dns bereit und hängen Sie ihn an ein VPC-Netzwerk an.

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

Ersetzen Sie PROJECT_ID durch Ihre Cloud de Confiance by S3NS Projekt-ID und SERVICE_ACCOUNT_NAME durch den Namen des von Ihnen erstellten Dienstkontos.

Anwendung testen

Cloud Run-Worker-Pools mit Direct VPC-Ingress sind für rein internen Traffic konzipiert. Sie haben keine öffentliche IP-Adresse. So prüfen Sie die Ingress-Funktionalität: Führen Sie mit curl eine Anfrage von einer Compute Engine-VM aus, die im selben VPC-Netzwerk und ‑Subnetz gehostet wird:

1. Erstellen Sie eine Test-VM im selben Netzwerk und in derselben Region wie Ihr Worker-Pool:

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

2. Stellen Sie mit dem folgenden Befehl eine SSH-Verbindung zur Test-VM her:

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

3. Rufen Sie Ihren Dienst über das VM-Terminal mit der privaten IP-Adresse der Workerpool-Instanz auf, die bei Cloud DNS registriert ist:

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

   Es sollte folgende Ausgabe angezeigt werden:

   Hello World!

Fertig! Sie haben Ihren Cloud Run-Worker-Pool erfolgreich mit Direct VPC Ingress über eine private IP-Adresse und Cloud DNS konfiguriert.