O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Configurar o MongoDB Atlas usando o peering da VPC

O peering de nuvem privada virtual (VPC) permite transmitir atualizações de captura de dados alterados (CDC) de um banco de dados do MongoDB Atlas para o Datastream em uma rede privada. Como o peering de VPC não é transitivo, você roteia o tráfego por uma máquina virtual (VM) de conversão de endereços de rede (NAT) do Compute Engine com regras de firewall. Você também vai criar um usuário do MongoDB, adicionar o endereço IP da VM NAT à lista de permissões do MongoDB Atlas e criar um perfil de conexão. Essa configuração não oferece alta disponibilidade. Se um nó do MongoDB falhar no teste do perfil de conexão, execute manualmente o script de inicialização na VM de NAT.

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:

No painel do MongoDB Atlas, em Security, clique em Database access.
Clique em Novo usuário do banco de dados e, em "Método de autenticação", selecione "Senha" para o usuário.
Digite o nome de usuário e a senha do seu usuário do Datastream.
Em Privilégios de usuário do banco de dados, selecione Conceder privilégios de usuário específicos.
Em Specific privileges, adicione o seguinte papel:
- readAnyDatabase
Clique em Adicionar usuário.

Configurar sua rede de nuvem privada virtual

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

Verifique se a rede identificada não tem intervalos de endereços IP sobrepostos com as redes do Datastream ou do MongoDB Atlas.
Crie uma configuração de conectividade privada 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 a regra de firewall de entrada.
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. Informe o ID do projeto do Google Cloud 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 do Google Cloud .
Depois de criar a conexão, no projeto do MongoDB Atlas, acesse a guia Acesso à rede > Peering de VPC e anote o bloco de roteamento entre domínios sem classe (CIDR) da regra de firewall de saída.

Criar uma VM NAT

No console do Google Cloud , acesse a página Instâncias de VM.

Acessar instâncias de VM
Clique em Criar instância.
No campo Nome, insira um nome para a VM, por exemplo, mongo-nat-gateway.
No campo Região, selecione uma região dentro da VPC padrão, por exemplo, us-central1.
No menu de navegação, clique em Rede.
No campo Tags de rede, adicione uma tag, como mongo-nat-vm. Essa tag é usada pelas regras de firewall.
Em Encaminhamento de IP, marque a caixa de seleção Ativar.
Em Interfaces de rede, selecione a VPC padrão e a sub-rede dela, por exemplo, default em us-central1.
No menu de navegação, clique em Avançado.

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."

Clique em Criar para iniciar a VM.
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.

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 privada do Datastream, por exemplo, 10.0.0.0/29.
- Protocolo: TCP
- Porta: 27017
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 de NAT nas configurações de segurança do MongoDB Atlas:

Faça login na sua conta do MongoDB Atlas.
No menu de navegação, clique em Segurança e em Acesso à rede.
Clique em Adicionar endereço IP.
No campo Entrada da lista de acesso, insira o endereço IP interno da instância de VM de NAT que você criou na rede VPC.
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.

Acesse a página Perfis de conexão no console do Google Cloud .

Acessar a página "Perfis de conexão"
Clique em Criar perfil e selecione MongoDB.
No campo Nome do host, insira o endereço IP interno da instância de VM NAT que você criou na rede VPC.
No campo Porta, digite 27017.
Digite o nome de usuário e a senha do seu usuário do banco de dados.
Adicione os rótulos tls e tls_allow_invalid_hostnames e defina os valores 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.
Selecione Conectividade particular como o método de conectividade.
Selecione a configuração de conectividade particular que você criou.
Clique em Criar para salvar o perfil de conexão.
Faça um teste para verificar a conexão com o banco de dados.

Configurar o MongoDB Atlas usando o peering da VPC Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.