Se usó la API de Cloud Translation para traducir esta página.

Ejemplo: Conectividad privada para un clúster de MongoDB Atlas

En esta página, se explica cómo habilitar la conectividad de los Integration Connectors a tu clúster de MongoDB Atlas que se ejecuta en una red privada dentro de Google Cloud.

Configura la conectividad privada para un clúster de Atlas

Para configurar la conectividad privada de un clúster de Atlas, haz lo siguiente:

Accede a la consola de administración de Atlas.
Abre el proyecto de Atlas para el que necesitas establecer la conectividad de red.
Abre la página Acceso a la red del proyecto y, luego, selecciona Extremo privado.
Selecciona Clúster dedicado y, luego, haz clic en Agregar extremo privado.
Se abrirá el cuadro de diálogo para elegir un proveedor de nube.

Nota: De forma predeterminada, puedes crear solo un extremo en cada región o varios extremos en una sola región. No puedes crear varios extremos en varias regiones. Para anular este comportamiento, debes habilitar varios extremos privados regionalizados.
Selecciona Google Cloud y, luego, haz clic en Siguiente.
Selecciona una región de Atlas y, luego, haz clic en Siguiente.
Esta es la región de Google Cloud en la que se crea tu clúster de Atlas y debe ser la misma que la del proyecto de Google Cloud en la que creas tus conexiones. Para obtener la lista de todas las regiones compatibles de Integration Connectors, consulta Ubicaciones.

Nota: El extremo que estás creando ahora proporciona acceso a todos los clústeres de Atlas en la región especificada.
Ingresa el ID del proyecto de Google Cloud. Este es el ID del proyecto del directorio de servicios del entorno de ejecución de Integration Connectors. Para obtener más información, consulta Cómo obtener el ID del proyecto del directorio de servicios.
En el campo Nombre de la VPC, ingresa default.
En el campo Nombre de la subred, ingresa default.
En el campo Prefijo de extremo de Private Service Connect, ingresa un prefijo.
Este texto se antepone a todos los nombres de extremos y se puede usar para identificar los extremos privados que creaste.
Instala la CLI (interfaz de línea de comandos) de gcloud. Para obtener más información, consulta Instala gcloud CLI.

Copia y guarda la siguiente secuencia de comandos de shell como setup_psc.sh en tu sistema local.

Establece los valores adecuados para las siguientes variables en la secuencia de comandos:

ID DEL PROYECTO
REGIÓN
PREFIX
SERVICE_ATTACHMENT_ID_PREFIX

#!/bin/bash

alias gcurl='curl -H "Authorization: Bearer $(gcloud auth print-access-token)"'

# Set PROJECT_ID to the ID of the Google Cloud project where you create your connections.
export PROJECT_ID=PROJECT_ID

# Set REGION to the Google Cloud region where Atlas cluster is installed.
export REGION=REGION

export HOSTNAME=https://connectors.googleapis.com/v1

# Set ENDPOINT_PREFIX to the prefix value that you entered for the
# "Private service connect endpoint prefix" field (in step 10).
export PREFIX=ENDPOINT_PREFIX

# Set SERVICE_ATTACHMENT_ID_PREFIX to the prefix of the service attachments
# created by Atlas. The service attachments are present in the script
# displayed on the Atlas UI and have the following naming format:
# projects/{google-cloud-project-id-of-atlas-cluster}/regions/{region}/serviceAttachment/{prefix}-{index}
# For example, if the service attachment is
# "projects/p-ditnerelrvndieqhe3kh9pop/regions/us-west1/serviceAttachments/sa-us-west1-37204mg5wr0j6-$i",
# you must set the value of SERVICE_ATTACHMENT_ID_PREFIX to
# "projects/p-ditnerelrvndieqhe3kh9pop/regions/us-west1/serviceAttachments/sa-us-west1-37204mg5wr0j6"
export SERVICE_ATTACHMENT_ID_PREFIX=SERVICE_ATTACHMENT_ID_PREFIX

# Set ENDPOINT_GLOBAL_ACCESS to true if you want to enable global access for the endpoint, else false.
export ENDPOINT_GLOBAL_ACCESS=ENDPOINT_GLOBAL_ACCESS

if [ "$ENDPOINT_GLOBAL_ACCESS" != "true" ] && [ "$ENDPOINT_GLOBAL_ACCESS" != "false" ]; then
    echo "Error: Variable ENDPOINT_GLOBAL_ACCESS must be either 'true' or 'false'."
    exit 1
fi

function poll_operation() {
  OPERATION_ID="$1"
  INDEX="$2"
  RESULT=''

  while [[ "$RESULT" != *"true"* ]];
  do
    RESULT=$(gcurl -s -X GET "${HOSTNAME}/${OPERATION_ID}" | grep '"done"')
    sleep 5
  done

  echo "${PREFIX}-${INDEX} created"
}

echo "Creating Endpoint Attachments..."
for i in {0..49}
do
  export ENDPOINT=${HOSTNAME}/projects/${PROJECT_ID}/locations/${REGION}/endpointAttachments?endpointAttachmentId=${PREFIX}-$i
  OPERATION_ID=$(gcurl -s -X POST -H "Content-Type: application/json" -d '{"name": "'"projects/${PROJECT_ID}/locations/${REGION}/endpointAttachments/${PREFIX}-$i"'","serviceAttachment": "'"${SERVICE_ATTACHMENT_ID_PREFIX}-$i"'", "endpointGlobalAccess":'${ENDPOINT_GLOBAL_ACCESS}'}' "${ENDPOINT}" | sed 's/  //' | grep -E '"name"' | sed -E 's/"name": "//' | sed 's/",//')
  poll_operation "$OPERATION_ID" "$i" &
done

wait
echo "All endpoint attachments created."

echo "[" > atlasEndpoints-${PREFIX}.json

echo "Fetching IP Addresses..."
for i in {0..49}
do
  ENDPOINT=${HOSTNAME}/projects/${PROJECT_ID}/locations/${REGION}/endpointAttachments/${PREFIX}-$i
  response=$(gcurl -s -X GET "${ENDPOINT}" | sed 's/  //g' | grep -E 'name|endpointIp' | sed 's/"endpointIp"/"IPAddress"/g' | sed -E 's/"name": "projects\/.+\/locations\/.+\/endpointAttachments\//"name": "/g' | sed '1 s/"/{"/1')
  if [ "$ENDPOINT_GLOBAL_ACCESS" = "true" ]; then
    echo "${response}" | sed '2 s/"/"}/4' >> atlasEndpoints-${PREFIX}.json
  else
    echo "${response}" | sed '2 s/"/"},/4' >> atlasEndpoints-${PREFIX}.json
  fi
done

sed -i '$s/,/]/' atlasEndpoints-${PREFIX}.json

echo "Created atlasEndpoints-${PREFIX}.json"

Ejecuta la secuencia de comandos de shell. Para ejecutar la secuencia de comandos de shell, ve al directorio en el que la guardaste y, luego, ejecuta el siguiente comando:
```
sh setup_psc.sh
```
Esta secuencia de comandos genera un archivo JSON que tiene la lista de direcciones IP y sus nombres de extremos de PSC correspondientes. El archivo JSON se guarda en el directorio en el que se ejecuta la secuencia de comandos de shell.
Haz clic en Siguiente en la consola de administración de Atlas.
Haz clic en Subir archivo JSON y, luego, sube el archivo JSON que se creó en el paso 13.
Haz clic en Crear.
El proceso de configuración del extremo puede tardar hasta 25 minutos en completarse y, si la configuración se realiza correctamente, el extremo estará en el estado Available.
Verifica tu conectividad privada. Para obtener más información, consulta Cómo verificar la conectividad privada.

Obtén el ID del proyecto del directorio de servicios

Para obtener el ID del proyecto del directorio de servicios, puedes usar la API de List Connections, como se muestra en el siguiente ejemplo.

Sintaxis

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/CONNECTORS_PROJECT_ID/locations/-/connections"

Reemplaza lo siguiente:

CONNECTORS_PROJECT_ID: El ID de tu proyecto de Google Cloud en el que creaste la conexión.

Ejemplo

En este ejemplo, se obtiene el ID del proyecto del directorio de servicios para el proyecto connectors-test de Google Cloud.

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/connectors-test/locations/-/connections"

Si ejecutas este comando en la terminal, se mostrará un resultado similar al siguiente:

.....
{
  "connections": [
    {
      "name": "projects/connectors-test/locations/asia-northeast1/connections/big-query-iam-invalid-sa",
      "createTime": "2022-10-07T09:02:31.905048520Z",
      "updateTime": "2022-10-07T09:22:39.993778690Z",
      "connectorVersion": "projects/connectors-test/locations/global/providers/gcp/connectors/bigquery/versions/1",
      "status": {
        "state": "ACTIVE"
      },
      "configVariables": [
        {
          "key": "project_id",
          "stringValue": "connectors-test"
        },
        {
          "key": "dataset_id",
          "stringValue": "testDataset"
        }
      ],
      "authConfig": {},
      "serviceAccount": "564332356444-compute@developer.gserviceaccount.com",
      "serviceDirectory": "projects/abcdefghijk-tp/locations/asia-northeast1/namespaces/connectors/services/runtime",
      "nodeConfig": {
        "minNodeCount": 2,
        "maxNodeCount": 50
      }
    },
....

En el resultado de muestra, para el proyecto de Google Cloud connectors-test, el ID del proyecto del directorio de servicios es abcdefghijk-tp.

Verifica la conectividad privada

Para verificar la conectividad privada a tus clústeres de Atlas, haz lo siguiente:

En la consola de administración de Atlas, abre la página Implementaciones de bases de datos.
Desplázate hasta el clúster requerido y, luego, haz clic en Conectar. Se abrirá el diálogo Connect to <CLUSTER_NAME>.
Haz clic en Extremo privado para el tipo de conexión.
Selecciona el prefijo de extremo privado que ingresaste en la IU de Atlas en el menú desplegable Choose a private endpoint.
Haz clic en Elige un método de conexión.
Haz clic en Controladores en la sección Conectar a tu aplicación. Este paso es para obtener la cadena de conexión srv.
Copia la cadena de conexión srv de la sección Agrega tu cadena de conexión al código de tu aplicación.
Formato de la cadena srv: mongodb+srv://{cluster-name}-pl-{index}.{unique-pin}.mongodb.net.
Crea una conexión de MongoDB con esta cadena srv como nombre de host. Para obtener más información, consulta Configura un conector de MongoDB.
La conexión debería crearse correctamente.

Nota: Cuando configures la conexión, en lugar de una cadena srv, también puedes ingresar nombres de host privados.