Configura MongoDB Atlas utilizzando il peering VPC

Questa pagina descrive come configurare un database di origine MongoDB Atlas per l'utilizzo con Datastream tramite il peering di Virtual Private Cloud. Tieni presente che la procedura descritta non è una soluzione di alta affidabilità. Se il test del profilo di connessione del nodo MongoDB non riesce, devi eseguire manualmente lo script di avvio a cui viene fatto riferimento più avanti in questa pagina sulla macchina virtuale (VM) di Network Address Translation (NAT).

Poiché il peering di Virtual Private Cloud non è transitivo, devi configurare un gateway NAT utilizzando una VM Compute Engine per instradare il traffico da Datastream a MongoDB Atlas.

Configurare 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:

  1. Nella dashboard di MongoDB Atlas, in Security (Sicurezza), fai clic su Database access (Accesso al database).
  2. Fai clic su New database user (Nuovo utente del database) e seleziona il metodo di autenticazione tramite password per l'utente.
  3. Inserisci il nome utente e la password per l'utente Datastream.
  4. In Database user privileges (Privilegi utente del database), seleziona Grant specific user privileges (Concedi privilegi utente specifici).
  5. In Specific privileges (Privilegi specifici), aggiungi il seguente ruolo:
    • readAnyDatabase
  6. Fai clic su Add user (Aggiungi utente).

Configurare la rete Virtual Private Cloud

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

  1. Assicurati che la rete che hai identificato non abbia intervalli di indirizzi IP sovrapposti con le reti Datastream o MongoDB Atlas.
  2. Crea una configurazione di connettività privata per il peering di Datastream con la rete Virtual Private Cloud:
    1. Assicurati di selezionare Peering VPC dal menu a discesa Private connectivity method (Metodo di connettività privata).
    2. Seleziona la rete VPC default.
    3. Fornisci un intervallo di indirizzi IP inutilizzato, ad esempio 10.0.0.0/29, da utilizzare per Datastream.
    4. Prendi nota dell'intervallo IP allocato per la regola firewall in entrata.
  3. Configura una connessione di peering di rete in MongoDB Atlas per il peering della rete Virtual Private Cloud con la rete MongoDB Atlas. Per ulteriori informazioni, consulta la sezione Configurare una connessione di peering di rete nella documentazione di MongoDB:
    1. Fornisci l'ID progetto e il nome del VPC predefinito in MongoDB Atlas. Google Cloud
    2. Prendi nota dell'ID progetto e del nome del VPC forniti da MongoDB Atlas per completare il peering sul Google Cloud lato.
  4. Dopo aver creato la connessione, nel progetto MongoDB Atlas, vai alla scheda Network Access (Accesso alla rete) > VPC Peering (Peering VPC) e prendi nota del blocco di routing interdominio senza classi (CIDR) per la regola firewall in uscita.

Creare una VM NAT

  1. Nella Google Cloud console, vai alla pagina Istanze VM.

    Vai a Istanze VM

  2. Fai clic su Crea istanza.

  3. Nel campo Nome, inserisci un nome per la VM, ad esempio mongo-nat-gateway.

  4. Nel campo Regione, seleziona una regione all'interno del VPC predefinito, ad esempio us-central1.

  5. Nel menu di navigazione, fai clic su Networking.

  6. Nel campo Tag di rete, aggiungi un tag, ad esempio mongo-nat-vm. Questo tag viene utilizzato dalle regole firewall.

  7. In Inoltro IP, seleziona la casella di controllo Attiva.

  8. In Interfacce di rete, seleziona il VPC predefinito e la relativa subnet, ad esempio default in us-central1.

  9. Nel menu di navigazione, fai clic su Avanzate.

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

  11. Fai clic su Crea per avviare la VM.

  12. Dopo l'avvio della VM, prendi nota del suo indirizzo IP interno, ad esempio 10.128.0.2.

Creare regole firewall in entrata e in uscita

Devi creare due regole firewall nella rete VPC.

  1. Crea una regola firewall in entrata con queste caratteristiche:

    • Nome: INGRESS_RULE_NAME
    • Direzione: in entrata
    • Azione: consentire
    • Parametro di destinazione: il tag di destinazione mongo-nat-vm
    • Parametro di origine: l'intervallo di indirizzi IP utilizzato dalla configurazione di connettività privata di Datastream, ad esempio 10.0.0.0/29
    • Protocollo: TCP
    • Porta: 27017

  2. Crea una regola firewall in uscita con queste caratteristiche:

    • Nome: EGRESS_RULE_NAME
    • Direzione: in uscita
    • Azione: consentire
    • Parametro di destinazione: il tag di destinazione mongo-nat-vm
    • Parametro di destinazione: il blocco CIDR di MongoDB Atlas, ad esempio 192.168.240.0/21
    • Protocollo: TCP
    • Porta: 27017

Configurare le liste consentite IP in MongoDB Atlas

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

  1. Accedi al tuo account MongoDB Atlas.
  2. Nel menu di navigazione, fai clic su Security (Sicurezza), quindi su Network access (Accesso alla rete).
  3. Fai clic su Add IP address (Aggiungi indirizzo IP).
  4. Nel campo Access list entry (Voce dell'elenco per gli accessi), inserisci l'indirizzo IP interno dell'istanza VM NAT che hai creato nella rete VPC.
  5. Fai clic su Confirm (Conferma) e attendi che lo stato diventi Active (Attivo).

Creare il profilo di connessione

Crea un profilo di connessione Datastream per il tuo database.

  1. Vai alla pagina Profili di connessione nella Google Cloud console.

    Vai alla pagina Profili di connessione

  2. Fai clic su Crea profilo e seleziona MongoDB.

  3. Nel campo Hostname (Nome host), inserisci l'indirizzo IP interno dell'istanza VM NAT che hai creato nella rete VPC.

  4. Nel campo Port (Porta), inserisci 27017.

  5. Inserisci il nome utente e la password per l'utente del database.

  6. Aggiungi le etichette tls e tls_allow_invalid_hostnames e imposta i relativi valori su true. Per ulteriori informazioni sull'impostazione delle etichette, consulta Creare un profilo di connessione per un database MongoDB.

  7. Seleziona Connettività privata come metodo di connettività.

  8. Seleziona la configurazione di connettività privata che hai creato.

  9. Fai clic su Crea per salvare il profilo di connessione.

  10. Esegui un test per verificare la connessione al database.