Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

MongoDB Atlas mit VPC-Peering konfigurieren

Auf dieser Seite wird beschrieben, wie Sie eine MongoDB Atlas-Quelldatenbank für die Verwendung mit Datastream mithilfe von Virtual Private Cloud-Peering konfigurieren. Die beschriebene Vorgehensweise ist keine Lösung für Hochverfügbarkeit. Wenn der Verbindungsprofiltest für den MongoDB-Knoten fehlschlägt, müssen Sie das Startskript, auf das weiter unten auf dieser Seite verwiesen wird, manuell auf der VM (Virtual Machine) für die Netzwerkadressübersetzung (Network Address Translation, NAT) ausführen.

Da Virtual Private Cloud-Peering nicht transitiv ist, müssen Sie ein NAT-Gateway mit einer Compute Engine-VM konfigurieren, um Traffic von Datastream zu MongoDB Atlas weiterzuleiten.

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 New database user (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

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

Achten Sie darauf, dass das von Ihnen ermittelte Netzwerk keine überlappenden IP-Adressbereiche mit Ihren Datastream- oder MongoDB Atlas-Netzwerken hat.
Erstellen Sie eine Konfiguration für private Verbindungen um Datastream mit Ihrem Virtual Private Cloud-Netzwerk zu verbinden:
1. Wählen Sie im Drop-down-Menü Private connectivity method (Methode für private Verbindungen) die Option VPC-Peering aus.
2. Wählen Sie Ihr default VPC-Netzwerk aus.
3. Geben Sie einen nicht verwendeten IP-Adressbereich an, z. B. 10.0.0.0/29, den Datastream verwenden kann.
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 unter Set up a network peering connection in der MongoDB-Dokumentation:
1. Geben Sie in MongoDB Atlas Ihre Google Cloud Projekt-ID und den Namen Ihrer Standard-VPC 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 Network Access > VPC Peering (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.

Zu "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 hinzu, z. B. mongo-nat-vm. Dieses Tag wird von den Firewallregeln verwendet.
Wählen Sie unter IP-Weiterleitung das Kästchen Aktivieren aus.
Wählen Sie unter Netzwerkschnittstellen Ihre Standard-VPC und ihr 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 nach dem Start der VM die interne IP-Adresse, z. B. 10.128.0.2.

Firewallregeln für eingehenden 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:Eingehend
- Aktion:Zulassen
- Zielparameter:Das Ziel-Tag mongo-nat-vm
- Quellparameter:Der IP-Adressbereich, der von der Konfiguration für private Verbindungen 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:Ausgehend
- 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 Ihren MongoDB Atlas-Sicherheitseinstellungen zu:

Melden Sie sich in Ihrem MongoDB Atlas-Konto an.
Klicken Sie im Navigationsmenü auf Security (Sicherheit) und dann auf Network access (Netzwerkzugriff).
Klicken Sie auf IP-Adresse hinzufügen.
Geben Sie im Feld Access list entry (Eintrag in der Zugriffsliste) die interne IP-Adresse der NAT-VM-Instanz ein, die Sie in Ihrem VPC-Netzwerk erstellt haben.
Klicken Sie auf Confirm (Bestätigen) und warten Sie, bis sich der Status in Active (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 im Feld Port 27017 ein.
Geben Sie den Nutzernamen und das Passwort für Ihren Datenbanknutzer ein.
Fügen Sie die Labels tls und tls_allow_invalid_hostnames hinzu und setzen Sie ihre Werte auf true. Weitere Informationen zum Festlegen von Labels finden Sie unter Verbindungsprofil für eine MongoDB-Datenbank erstellen.
Wählen Sie Private Verbindung als Verbindungsmethode aus.
Wählen Sie die von Ihnen erstellte Konfiguration für private Verbindungen aus.
Klicken Sie auf Erstellen , um das Verbindungsprofil zu speichern.
Führen Sie einen Test aus, um die Verbindung zu Ihrer Datenbank zu überprüfen.

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