Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Configura MongoDB Atlas utilizzando il peering VPC

Il peering Virtual Private Cloud (VPC) consente di trasmettere in streaming gli aggiornamenti di Change Data Capture (CDC) da un database MongoDB Atlas a Datastream su una rete privata. Poiché il peering VPC non è transitivo, instradi il traffico tramite una macchina virtuale (VM) Network Address Translation (NAT) di Compute Engine con regole firewall. Inoltre, crei un utente MongoDB, aggiungi l'indirizzo IP della VM NAT alla lista consentita di MongoDB Atlas e crei un profilo di connessione. Questa configurazione non offre l'alta affidabilità. Se un nodo MongoDB non supera il test del profilo di connessione, devi eseguire manualmente lo script di avvio sulla VM NAT.

Configura un utente del database MongoDB

Per utilizzare Datastream con un'istanza MongoDB Atlas, devi prima creare un utente del database e concedergli i privilegi di accesso:

Nella dashboard di MongoDB Atlas, in Security (Sicurezza), fai clic su Database access (Accesso al database).
Fai clic su Nuovo utente del database e seleziona il metodo di autenticazione tramite password per l'utente.
Inserisci il nome utente e la password per l'utente Datastream.
In Privilegi utente del database, seleziona Concedi privilegi utente specifici.
In Specific privileges (Privilegi specifici), aggiungi il seguente ruolo:
- readAnyDatabase
Fai clic su Aggiungi utente.

Configura la rete Virtual Private Cloud

Identifica la rete Virtual Private Cloud nel tuo progetto Google Cloud per eseguire il peering sia con Datastream che con MongoDB Atlas. Questa pagina presuppone che tu utilizzi il VPC predefinito e la relativa subnet, ad esempio la subnet predefinita nella regione us-central1.

Assicurati che la rete identificata non abbia intervalli di indirizzi IP sovrapposti con le reti Datastream o MongoDB Atlas.
Crea una configurazione di connettività privata per eseguire il peering di Datastream con la tua rete Virtual Private Cloud:
1. Assicurati di selezionare Peering VPC dal menu a discesa Metodo di connettività privata.
2. Seleziona la tua rete VPC default.
3. Fornisci un intervallo di indirizzi IP non utilizzato, ad esempio 10.0.0.0/29, che Datastream possa utilizzare.
4. Prendi nota dell'intervallo IP allocato per la regola firewall in entrata.
Configura una connessione di peering di rete in MongoDB Atlas per eseguire il peering della tua rete Virtual Private Cloud con la tua rete MongoDB Atlas. Per saperne di più, consulta Configura una connessione di peering di rete nella documentazione di MongoDB:
1. Fornisci l'ID progetto Google Cloud e il nome del VPC predefinito in MongoDB Atlas.
2. Prendi nota dell'ID progetto e del nome del VPC forniti da MongoDB Atlas per completare il peering sul lato Google Cloud .
Dopo aver creato la connessione, nel progetto MongoDB Atlas, vai alla scheda Accesso alla rete > Peering VPC e prendi nota del blocco CIDR (Classless Inter-Domain Routing) per la regola firewall in uscita.

Crea una VM NAT

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Fai clic su Crea istanza.
Nel campo Nome, inserisci un nome per la VM, ad esempio mongo-nat-gateway.
Nel campo Regione, seleziona una regione all'interno del VPC predefinito, ad esempio us-central1.
Nel menu di navigazione, fai clic su Networking.
Nel campo Tag di rete, aggiungi un tag, ad esempio mongo-nat-vm. Questo tag viene utilizzato dalle regole firewall.
In Inoltro IP, seleziona la casella di controllo Abilita.
In Interfacce di rete, seleziona il VPC predefinito e la relativa subnet, ad esempio default in us-central1.
Nel menu di navigazione, fai clic su Avanzate.

Nella sezione Automazione, incolla il seguente script nel campo Script di avvio. Sostituisci PRIVATE_SRV_RECORD con il record SRV privato del tuo cluster MongoDB Atlas, ad esempio 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."

Fai clic su Crea per avviare la VM.
Dopo aver avviato la VM, prendi nota del suo indirizzo IP interno, ad esempio 10.128.0.2.

Crea regole firewall in entrata e in uscita

Devi creare due regole firewall nella tua rete VPC.

Crea una regola firewall in entrata con queste caratteristiche:
- Nome: INGRESS_RULE_NAME
- Direzione: in entrata
- Azione:Consenti
- Parametro target: il tag target mongo-nat-vm
- Parametro di origine: l'intervallo di indirizzi IP utilizzato dalla configurazione della connettività privata di Datastream, ad esempio 10.0.0.0/29
- Protocollo: TCP
- Porta: 27017
Crea una regola firewall in uscita con queste caratteristiche:
- Nome: EGRESS_RULE_NAME
- Direzione: in uscita
- Azione:Consenti
- Parametro target: il tag target mongo-nat-vm
- Parametro di destinazione: il blocco CIDR di MongoDB Atlas, ad esempio 192.168.240.0/21
- Protocollo: TCP
- Porta: 27017

Configura le liste consentite IP in MongoDB Atlas

Consenti l'indirizzo IP interno della VM NAT nelle impostazioni di sicurezza di MongoDB Atlas:

Accedi al tuo account MongoDB Atlas.
Nel menu di navigazione, fai clic su Sicurezza, quindi su Accesso alla rete.
Fai clic su Aggiungi indirizzo IP.
Nel campo Voce dell'elenco per gli accessi, inserisci l'indirizzo IP interno dell'istanza VM NAT che hai creato nella rete VPC.
Fai clic su Conferma e attendi che lo stato diventi Attivo.

Crea il profilo di connessione

Crea un profilo di connessione Datastream per il tuo database.

Vai alla pagina Profili di connessione nella console Google Cloud .

Vai alla pagina Profili di connessione
Fai clic su Crea profilo e seleziona MongoDB.
Nel campo Hostname (Nome host), inserisci l'indirizzo IP interno dell'istanza VM NAT che hai creato nella rete VPC.
Nel campo Porta, inserisci 27017.
Inserisci il nome utente e la password per l'utente del database.
Aggiungi le etichette tls e tls_allow_invalid_hostnames e imposta i relativi valori su true. Per saperne di più sull'impostazione delle etichette, consulta Crea un profilo di connessione per un database MongoDB.
Seleziona Connettività privata come metodo di connettività.
Seleziona la configurazione di connettività privata che hai creato.
Fai clic su Crea per salvare il profilo di connessione.
Esegui un test per verificare la connessione al database.

Configura MongoDB Atlas utilizzando il peering VPC Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.