Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

MongoDB Atlas mit VPC-Peering konfigurieren

Mit VPC-Peering (Virtual Private Cloud) können Sie CDC-Updates (Change Data Capture) von einer MongoDB Atlas-Datenbank über ein privates Netzwerk an Datastream streamen. Da das VPC-Peering nicht transitiv ist, leiten Sie den Traffic über eine Compute Engine-VM für die Netzwerkadressübersetzung (NAT) mit Firewallregeln weiter. Außerdem erstellen Sie einen MongoDB-Nutzer, fügen die IP-Adresse der NAT-VM der Zulassungsliste von MongoDB Atlas hinzu und erstellen ein Verbindungsprofil. Diese Konfiguration bietet keine Hochverfügbarkeit. Wenn ein MongoDB-Knoten den Verbindungsprofiltest nicht besteht, müssen Sie das Startskript manuell auf der NAT-VM ausführen.

MongoDB-Datenbanknutzer konfigurieren

Um Datastream mit einer MongoDB Atlas-Instanz zu verwenden, müssen Sie zuerst einen Datenbanknutzer erstellen und ihm Zugriffsberechtigungen gewähren:

Klicken Sie im MongoDB Atlas-Dashboard unter Security (Sicherheit) auf Database access (Datenbankzugriff).
Klicken Sie auf Neuer Datenbanknutzer und wählen Sie die Authentifizierungsmethode per Passwort für den Nutzer aus.
Geben Sie den Nutzernamen und das Passwort für den Datastream-Nutzer ein.
Wählen Sie unter Database user privileges (Berechtigungen des Datenbanknutzers) die Option Grant specific user privileges (Spezielle Nutzerberechtigungen gewähren) aus.
Fügen Sie unter Specific privileges (Spezielle Berechtigungen) die folgende Rolle hinzu:
- readAnyDatabase
Klicken Sie auf Nutzer hinzufügen.

Virtual Private Cloud-Netzwerk einrichten

Identifizieren Sie das VPC-Netzwerk (Virtual Private Cloud) in Ihrem Google Cloud -Projekt, das sowohl mit Datastream als auch mit MongoDB Atlas verbunden werden soll. Auf dieser Seite wird davon ausgegangen, dass Sie die Standard-VPC und das zugehörige Subnetz verwenden, z. B. das Standardsubnetz in der Region us-central1.

Achten Sie darauf, dass das von Ihnen identifizierte Netzwerk keine sich überschneidenden IP-Adressbereiche mit Ihren Datastream- oder MongoDB Atlas-Netzwerken hat.
Erstellen Sie eine Konfiguration für private Konnektivität, um ein Peering von Datastream mit Ihrem Virtual Private Cloud-Netzwerk durchzuführen:
1. Wählen Sie im Drop-down-Menü Methode für private Konnektivität die Option VPC-Peering aus.
2. Wählen Sie Ihr VPC-Netzwerk default aus.
3. Geben Sie einen nicht verwendeten IP-Adressbereich an, z. B. 10.0.0.0/29, den Datastream verwenden soll.
4. Notieren Sie sich den zugewiesenen IP-Bereich für Ihre Firewallregel für eingehenden Traffic.
Richten Sie in MongoDB Atlas eine Netzwerk-Peering-Verbindung ein, um Ihr Virtual Private Cloud-Netzwerk mit Ihrem MongoDB Atlas-Netzwerk zu verbinden. Weitere Informationen finden Sie in der MongoDB-Dokumentation unter Netzwerk-Peering-Verbindung einrichten:
1. Geben Sie Ihre Google Cloud -Projekt-ID und den Namen Ihrer Standard-VPC in MongoDB Atlas an.
2. Notieren Sie sich die Projekt-ID und den VPC-Namen, die Sie von MongoDB Atlas erhalten, um das Peering auf der Google Cloud -Seite abzuschließen.
Nachdem Sie die Verbindung erstellt haben, rufen Sie in Ihrem MongoDB Atlas-Projekt den Tab Netzwerkzugriff > VPC-Peering auf und notieren Sie sich den CIDR-Block (Classless Inter-Domain Routing) für Ihre Firewallregel für ausgehenden Traffic.

NAT-VM erstellen

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

Zur Seite „VM-Instanzen“
Klicken Sie auf Instanz erstellen.
Geben Sie im Feld Name einen Namen für die VM ein, z. B. mongo-nat-gateway.
Wählen Sie im Feld Region eine Region in Ihrer Standard-VPC aus, z. B. us-central1.
Klicken Sie im Navigationsmenü auf Netzwerk.
Fügen Sie im Feld Netzwerk-Tags ein Tag wie mongo-nat-vm hinzu. Dieses Tag wird von den Firewallregeln verwendet.
Klicken Sie unter IP-Weiterleitung das Kästchen Aktivieren an.
Wählen Sie unter Netzwerkschnittstellen Ihre Standard-VPC und das zugehörige Subnetz aus, z. B. default in us-central1.
Klicken Sie im Navigationsmenü auf Erweitert.

Fügen Sie im Abschnitt Automatisierung das folgende Skript in das Feld Startskript ein. Ersetzen Sie PRIVATE_SRV_RECORD durch den privaten SRV-Eintrag Ihres MongoDB Atlas-Clusters, z. B. my-cluster-pri.abcde.mongodb.net.

#!/bin/bash

# --- Startup script for MongoDB Atlas NAT gateway ---
# This script has two main functions:
# 1. Resolves the IP address of a MongoDB Atlas node from its SRV record.
# 2. Configures iptables to forward traffic to the resolved MongoDB IP.
# --------------------------------------------------------------------------

# --- Part 1: Resolve MongoDB node IP address ---

#
# EDIT THIS LINE to match your Mongo Atlas private SRV record
#
export SRV_RECORD=PRIVATE_SRV_RECORD

echo "Resolving SRV record for: $SRV_RECORD"

# Function to install DNS utilities if needed
install_dns_tools() {
    echo "'dig' not found. Attempting to install DNS utilities..."
    if command -v apt-get &> /dev/null; then
        # Wait for any existing apt processes to finish before trying to install packages.
        # This is common on VM startup where the system might be running automatic updates.
        echo "Checking for and waiting on existing apt-get processes..."
        while fuser /var/lib/apt/lists/lock /var/lib/dpkg/lock /var/lib/dpkg/lock-frontend >/dev/null 2>&1; do
            echo "Another apt process is running. Waiting 10 seconds..."
            sleep 10
        done
        echo "Apt lock is free. Proceeding with installation."

        apt-get update && apt-get install -y dnsutils
    else
        echo "Error: Could not find apt-get to install DNS utilities."
        exit 1
    fi

    # Verify that dig is now available
    if ! command -v dig &> /dev/null; then
        echo "Error: Failed to install DNS utilities."
        exit 1
    fi
}

# Check if 'dig' is installed. If not, install it.
if ! command -v dig &> /dev/null; then
    install_dns_tools
fi

echo "Using 'dig' for DNS resolution."
# The `+short` option provides a concise output.
# We use `awk` to grab the 4th column (the hostname) and `head` to get the first one.
NODE_HOSTNAME=$(dig +short SRV "_mongodb._tcp.${SRV_RECORD}" | awk '{print $4}' | head -n 1)
if [ -n "$NODE_HOSTNAME" ]; then
    NODE_IP=$(dig +short A "$NODE_HOSTNAME")
fi

# Check if the SRV lookup was successful and we got a hostname.
if [ -z "$NODE_HOSTNAME" ]; then
    echo "Error: Could not resolve SRV record. Check the hostname and your
    network connection."
    exit 1
fi

echo "Found node hostname: $NODE_HOSTNAME"

# Check if the A record lookup was successful.
if [ -z "$NODE_IP" ]; then
    echo "Error: Could not resolve the IP address for node: $NODE_HOSTNAME"
    exit 1
fi

# 3. Print the final result of the lookup.
echo "Successfully resolved IP address of a node: $NODE_IP"

# --- Part 2: Configure iptables for NAT ---

# Substitute the resolved IP address into the DB_ADDR variable.
export DB_ADDR=$NODE_IP
export DB_PORT=27017

# Enable the VM to receive packets whose destinations do
# not match any running process local to the VM
echo 1 > /proc/sys/net/ipv4/ip_forward

# Ask the Metadata server for the IP address of the VM nic0
# network interface:
md_url_prefix="http://169.254.169.254/computeMetadata/v1/instance"
vm_nic_ip="$(curl -H "Metadata-Flavor: Google" ${md_url_prefix}/network-interfaces/0/ip)"

# Clear any existing iptables NAT table entries (all chains):
iptables -t nat -F

# Create a NAT table entry in the prerouting chain, matching
# any packets with destination database port, changing the destination
# IP address of the packet to the MongoDB instance IP address:
iptables -t nat -A PREROUTING \
     -p tcp --dport $DB_PORT \
     -j DNAT \
     --to-destination $DB_ADDR

# Create a NAT table entry in the postrouting chain, matching
# any packets with destination database port, changing the source IP
# address of the packet to the NAT VM's primary internal IPv4 address:
iptables -t nat -A POSTROUTING \
     -p tcp --dport $DB_PORT \
     -j SNAT \
     --to-source $vm_nic_ip

# Save iptables configuration:
iptables-save

echo "Startup script completed successfully. iptables rules are configured and saved."

Klicken Sie auf Erstellen, um die VM zu starten.
Notieren Sie sich die interne IP-Adresse der VM, z. B. 10.128.0.2, sobald sie ausgeführt wird.

Firewallregeln für ein- und ausgehenden Traffic erstellen

Sie müssen zwei Firewallregeln in Ihrem VPC-Netzwerk erstellen.

Erstellen Sie eine Firewallregel für eingehenden Traffic mit den folgenden Merkmalen:
- Name: INGRESS_RULE_NAME
- Richtung: Eingehender Traffic
- Aktion: Zulassen
- Zielparameter: das Ziel-Tag mongo-nat-vm
- Quellparameter: Der IP-Adressbereich, der von der Konfiguration für private Konnektivität von Datastream verwendet wird, z. B. 10.0.0.0/29.
- Protokoll: TCP
- Port: 27017
Erstellen Sie eine Firewallregel für ausgehenden Traffic mit den folgenden Merkmalen:
- Name: EGRESS_RULE_NAME
- Richtung: ausgehender Traffic
- Aktion: Zulassen
- Zielparameter: das Ziel-Tag mongo-nat-vm
- Zielparameter: Der MongoDB Atlas-CIDR-Block, z. B. 192.168.240.0/21
- Protokoll: TCP
- Port: 27017

IP-Zulassungslisten in MongoDB Atlas konfigurieren

Lassen Sie die interne IP-Adresse der NAT-VM in den MongoDB Atlas-Sicherheitseinstellungen zu:

Melden Sie sich in Ihrem MongoDB Atlas-Konto an.
Klicken Sie im Navigationsmenü auf Sicherheit und dann auf Netzwerkzugriff.
Klicken Sie auf IP-Adresse hinzufügen.
Geben Sie im Feld Zugriffslisteneintrag die interne IP-Adresse der NAT-VM-Instanz ein, die Sie in Ihrem VPC-Netzwerk erstellt haben.
Klicken Sie auf Bestätigen und warten Sie, bis sich der Status in Aktiv ändert.

Verbindungsprofil erstellen

Erstellen Sie ein Datastream-Verbindungsprofil für Ihre Datenbank.

Rufen Sie in der Google Cloud Console die Seite Verbindungsprofile auf.

Zur Seite „Verbindungsprofile“
Klicken Sie auf Profil erstellen und wählen Sie MongoDB aus.
Geben Sie im Feld Hostname die interne IP-Adresse der NAT-VM-Instanz ein, die Sie in Ihrem VPC-Netzwerk erstellt haben.
Geben Sie in das Feld Port die Zahl 27017 ein.
Geben Sie den Nutzernamen und das Passwort für den Datenbanknutzer ein.
Fügen Sie die Labels tls und tls_allow_invalid_hostnames hinzu und legen Sie ihre Werte auf true fest. Weitere Informationen zum Festlegen von Labels finden Sie unter Verbindungsprofil für eine MongoDB-Datenbank erstellen.
Wählen Sie Private Konnektivität als Verbindungsmethode aus.
Wählen Sie die von Ihnen erstellte Konfiguration für private Konnektivität aus.
Klicken Sie auf Erstellen, um das Verbindungsprofil zu speichern.
Führen Sie einen Test durch, um die Verbindung zu Ihrer Datenbank zu prüfen.

MongoDB Atlas mit VPC-Peering konfigurieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.