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

Configurer MongoDB Atlas à l'aide du peering VPC

Cette page explique comment configurer une base de données source MongoDB Atlas pour qu'elle fonctionne avec Datastream à l'aide de l'appairage de réseaux cloud privés virtuels. Notez que la procédure décrite n'est pas une solution de haute disponibilité. Si le nœud MongoDB échoue au test du profil de connexion, vous devez exécuter manuellement le script de démarrage référencé plus loin sur cette page sur la machine virtuelle (VM) de traduction d'adresse réseau (NAT).

Étant donné que l'appairage de cloud privé virtuel n'est pas transitif, vous devez configurer une passerelle NAT à l'aide d'une VM Compute Engine pour acheminer le trafic de Datastream vers MongoDB Atlas.

Configurer un utilisateur de base de données MongoDB

Pour utiliser Datastream avec une instance MongoDB Atlas, vous devez d'abord créer un utilisateur de base de données et lui accorder des droits d'accès :

Dans le tableau de bord de MongoDB Atlas, sous Security (Sécurité), cliquez sur Database access (Accès à la base de données).
Cliquez sur New database user (Nouvel utilisateur de base de données), puis sélectionnez la méthode d'authentification par mot de passe pour votre utilisateur.
Saisissez le nom d'utilisateur et le mot de passe de votre utilisateur Datastream.
Sous Droits d'utilisateur de la base de données, sélectionnez Accorder des droits d'utilisateur spécifiques.
Sous Specific privileges (Droits spécifiques), ajoutez le rôle suivant :
- readAnyDatabase
Cliquez sur Ajouter un utilisateur.

Configurer votre réseau de cloud privé virtuel

Identifiez le réseau de cloud privé virtuel (VPC) de votre projet Google Cloud à appairer avec Datastream et MongoDB Atlas. Cette page suppose que vous utilisez le VPC par défaut et son sous-réseau, par exemple le sous-réseau par défaut dans la région us-central1.

Assurez-vous que le réseau que vous avez identifié ne comporte pas de plages d'adresses IP qui se chevauchent avec vos réseaux Datastream ou MongoDB Atlas.
Créez une configuration de connectivité privée pour appairer Datastream à votre réseau Virtual Private Cloud :
1. Assurez-vous de sélectionner Appairage de VPC dans le menu déroulant Méthode de connectivité privée.
2. Sélectionnez votre réseau VPC default.
3. Indiquez une plage d'adresses IP non utilisées, par exemple 10.0.0.0/29, que Datastream pourra utiliser.
4. Notez la plage d'adresses IP attribuée à votre règle de pare-feu d'entrée.
Configurez une connexion d'appairage réseau dans MongoDB Atlas pour appairer votre réseau de cloud privé virtuel avec votre réseau MongoDB Atlas. Pour en savoir plus, consultez Configurer une connexion d'appairage de réseau dans la documentation MongoDB :
1. Indiquez l'ID de votre projet Google Cloud et le nom de votre VPC par défaut dans MongoDB Atlas.
2. Notez l'ID du projet et le nom du VPC que MongoDB Atlas vous fournit pour finaliser l'appairage côté Google Cloud .
Une fois la connexion créée, dans votre projet MongoDB Atlas, accédez à l'onglet Network Access (Accès réseau) > VPC Peering (Peering VPC) et notez le bloc CIDR (Classless Inter-Domain Routing) pour votre règle de pare-feu de sortie.

Créer une VM NAT

Dans la console Google Cloud , accédez à la page Instances de VM.

Accéder à la page Instances de VM
Cliquez sur Créer une instance.
Dans le champ Nom, saisissez un nom pour la VM (par exemple, mongo-nat-gateway).
Dans le champ Région, sélectionnez une région dans votre VPC par défaut, par exemple us-central1.
Dans le menu de navigation, cliquez sur Mise en réseau.
Dans le champ Tags réseau, ajoutez un tag, tel que mongo-nat-vm. Ce tag est utilisé par les règles de pare-feu.
Sous Transfert IP, cochez la case Activer.
Sous Interfaces réseau, sélectionnez votre VPC par défaut et son sous-réseau, par exemple default dans us-central1.
Dans le menu de navigation, cliquez sur Avancé.

Dans la section Automatisation, collez le script suivant dans le champ Script de démarrage. Remplacez PRIVATE_SRV_RECORD par l'enregistrement SRV privé de votre cluster MongoDB Atlas, par exemple 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."

Cliquez sur Créer pour lancer la VM.
Une fois la VM en cours d'exécution, notez son adresse IP interne, par exemple 10.128.0.2.

Créer des règles de pare-feu d'entrée et de sortie

Vous devez créer deux règles de pare-feu dans votre réseau VPC.

Créez une règle de pare-feu d'entrée avec les caractéristiques suivantes :
- Nom : INGRESS_RULE_NAME
- Direction : entrée
- Action : autoriser
- Paramètre cible : tag cible mongo-nat-vm
- Paramètre source : plage d'adresses IP utilisée par la configuration de connectivité privée Datastream, par exemple 10.0.0.0/29
- Protocole : TCP
- Port : 27017
Créez une règle de pare-feu de sortie présentant les caractéristiques suivantes :
- Nom : EGRESS_RULE_NAME
- Direction : sortie
- Action : autoriser
- Paramètre cible : tag cible mongo-nat-vm
- Paramètre de destination : bloc CIDR MongoDB Atlas, par exemple 192.168.240.0/21
- Protocole : TCP
- Port : 27017

Configurer des listes d'autorisation d'adresses IP dans MongoDB Atlas

Autorisez l'adresse IP interne de la VM NAT dans vos paramètres de sécurité MongoDB Atlas :

Connectez-vous à votre compte MongoDB Atlas.
Dans le menu de navigation, cliquez sur Sécurité, puis sur Accès au réseau.
Cliquez sur Ajouter une adresse IP.
Dans le champ Entrée de la liste d'accès, saisissez l'adresse IP interne de l'instance de VM NAT que vous avez créée dans votre réseau VPC.
Cliquez sur Confirmer et attendez que l'état passe à Actif.

Créer le profil de connexion

Créez un profil de connexion Datastream pour votre base de données.

Accédez à la page Profils de connexion dans la console Google Cloud .

Accéder à la page Profils de connexion
Cliquez sur Créer un profil, puis sélectionnez MongoDB.
Dans le champ Nom d'hôte, saisissez l'adresse IP interne de l'instance de VM NAT que vous avez créée dans votre réseau VPC.
Dans le champ Port, saisissez 27017.
Saisissez le nom d'utilisateur et le mot de passe de votre utilisateur de base de données.
Ajoutez les libellés tls et tls_allow_invalid_hostnames, et définissez leur valeur sur true. Pour en savoir plus sur la définition des libellés, consultez Créer un profil de connexion pour une base de données MongoDB.
Sélectionnez Connectivité privée comme méthode de connectivité.
Sélectionnez la configuration de connectivité privée que vous avez créée.
Cliquez sur Créer pour enregistrer le profil de connexion.
Effectuez un test pour vérifier la connexion à votre base de données.

Configurer MongoDB Atlas à l'aide du peering VPC Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.