Configurar o MongoDB Atlas usando o peering da VPC

Esta página descreve como configurar um banco de dados de origem do MongoDB Atlas para trabalhar com o Datastream usando o peering de nuvem privada virtual. O procedimento descrito não é uma solução de alta disponibilidade. Se o nó do MongoDB falhar no teste do perfil de conexão, será necessário executar manualmente o script de inicialização referenciado mais adiante nesta página na máquina virtual (VM) de conversão de endereços de rede (NAT).

Como o peering de nuvem privada virtual não é transitivo, é necessário configurar um gateway NAT usando uma VM do Compute Engine para rotear o tráfego do Datastream para o MongoDB Atlas.

Configurar um usuário do banco de dados do MongoDB

Para usar o Datastream com uma instância do MongoDB Atlas, primeiro é preciso criar um usuário do banco de dados e conceder a ele privilégios de acesso:

  1. No painel do MongoDB Atlas, em Security, clique em Database access.
  2. Clique em New database user e, em "Authentication method", selecione "Password" para o usuário.
  3. Digite o nome de usuário e a senha do seu usuário do Datastream.
  4. Em Database user privileges, selecione Grant specific user privileges.
  5. Em Specific privileges, adicione o seguinte papel:
    • readAnyDatabase
  6. Clique em Adicionar usuário.

Configurar sua rede de nuvem privada virtual

Identifique a rede de nuvem privada virtual no seu Google Cloud projeto para fazer peering com o Datastream e o MongoDB Atlas. Esta página pressupõe que você use a VPC padrão e a sub-rede dela, por exemplo, a sub-rede padrão na região us-central1.

  1. Verifique se a rede identificada não tem intervalos de endereços IP sobrepostos com as redes do Datastream ou do MongoDB Atlas.
  2. Crie uma configuração de conectividade particular para fazer peering do Datastream com sua rede de nuvem privada virtual:
    1. Selecione Peering de VPC no menu suspenso Método de conectividade particular.
    2. Selecione sua rede VPC default.
    3. Forneça um intervalo de endereços IP não utilizado, por exemplo, 10.0.0.0/29, para o Datastream usar.
    4. Anote o intervalo de IP alocado para sua regra de firewall de entrada.
  3. Configure uma conexão de peering de rede no MongoDB Atlas para fazer peering da sua rede de nuvem privada virtual com a rede do MongoDB Atlas. Para mais informações, consulte Configurar uma conexão de peering de rede na documentação do MongoDB:
    1. Forneça o ID do seu Google Cloud projeto e o nome da VPC padrão no MongoDB Atlas.
    2. Anote o ID do projeto e o nome da VPC que o MongoDB Atlas fornece para concluir o peering no lado. Google Cloud
  4. Depois de criar a conexão, no projeto do MongoDB Atlas, acesse a guia Network Access > VPC Peering e anote o bloco de roteamento entre domínios sem classe (CIDR, na sigla em inglês) para sua regra de firewall de saída.

Criar uma VM NAT

  1. No Google Cloud Console, acesse a página Instâncias de VM.

    Acessar instâncias de VM

  2. Clique em Criar instância.

  3. No campo Nome , insira um nome para a VM, por exemplo, mongo-nat-gateway.

  4. No campo Região , selecione uma região dentro da VPC padrão, por exemplo, us-central1.

  5. No menu de navegação, clique em Rede.

  6. No campo Tags de rede, adicione uma tag, como mongo-nat-vm. Essa tag é usada pelas regras de firewall.

  7. Em Encaminhamento de IP, marque a caixa de seleção Ativar.

  8. Em Interfaces de rede, selecione a VPC padrão e a sub-rede dela, por exemplo default em us-central1.

  9. No menu de navegação, clique em Avançado.

  10. Na seção Automação, cole o script a seguir no campo Script de inicialização. Substitua PRIVATE_SRV_RECORD pelo registro SRV particular do cluster do MongoDB Atlas, por exemplo, 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. Clique em Criar para iniciar a VM.

  12. Depois que a VM estiver em execução, anote o endereço IP interno dela, por exemplo, 10.128.0.2.

Criar regras de firewall de entrada e saída

É necessário criar duas regras de firewall na rede VPC.

  1. Crie uma regra de firewall de entrada com estas características:

    • Nome: INGRESS_RULE_NAME
    • Direção:entrada
    • Ação:permitir
    • Parâmetro de destino:a tag de destino mongo-nat-vm
    • Parâmetro de origem:o intervalo de endereços IP usado pela configuração de conectividade particular do Datastream, por exemplo, 10.0.0.0/29
    • Protocolo:TCP
    • Porta:27017

  2. Crie uma regra de firewall de saída com estas características:

    • Nome: EGRESS_RULE_NAME
    • Direção:saída
    • Ação:permitir
    • Parâmetro de destino:a tag de destino mongo-nat-vm
    • Parâmetro de destino:o bloco CIDR do MongoDB Atlas, por exemplo, 192.168.240.0/21
    • Protocolo:TCP
    • Porta:27017

Configurar listas de permissões de IP no MongoDB Atlas

Permita o endereço IP interno da VM NAT nas configurações de segurança do MongoDB Atlas:

  1. Faça login na sua conta do MongoDB Atlas.
  2. No menu de navegação, clique em Segurança e em Acesso à rede.
  3. Clique em Adicionar endereço IP.
  4. No campo Entrada da lista de acesso, insira o endereço IP interno da instância da VM NAT criada na rede VPC.
  5. Clique em Confirmar e aguarde até que o status mude para Ativo.

Criar o perfil de conexão

Crie um perfil de conexão do Datastream para seu banco de dados.

  1. Acesse a página Perfis de conexão no Google Cloud Console.

    Acessar a página "Perfis de conexão"

  2. Clique em Criar perfil e selecione MongoDB.

  3. No campo Nome do host, insira o endereço IP interno da instância da VM NAT criada na rede VPC.

  4. No campo Porta, digite 27017.

  5. Insira o nome de usuário e a senha do usuário do banco de dados.

  6. Adicione os rótulos tls e tls_allow_invalid_hostnames e defina os valores deles como true. Para mais informações sobre como definir rótulos, consulte Criar um perfil de conexão para um banco de dados do MongoDB.

  7. Selecione Conectividade particular como método de conectividade.

  8. Selecione a configuração de conectividade particular criada.

  9. Clique em Criar para salvar o perfil de conexão.

  10. Execute um teste para verificar a conexão com o banco de dados.