Configura Vector Search con Private Service Connect

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Private Service Connect permite el consumo privado de servicios en las redes de VPC que pertenecen a distintos grupos, equipos, proyectos y organizaciones. Puedes publicar y consumir servicios usando direcciones IP que definas y que sean internas a tu red de VPC, y para que los extremos de Vector Search realicen búsquedas de similitud de vectores.

La habilitación de Private Service Connect en un extremo de Vector Search es adecuada para casos de uso que tienen las siguientes características:

1. Requieren latencia baja y una conexión segura con los backends de entrega de Vector Search.
2. Tienen espacio de IP limitado para la reserva de intercambio de tráfico de VPC exclusiva.
3. Deben acceder a los backends activos desde varias redes de VPC de usuario.

Para obtener más información sobre cómo configurar Private Service Connect, consulta la Descripción general de Private Service Connect en la documentación de la nube privada virtual (VPC).

Crea el extremo del índice

Debes habilitar Private Service Connect cuando crees tu extremo. Este procedimiento es similar a crear otros extremos en Vertex AI.

PROJECT=PROJECT_ID
VPC_PROJECT=VPC_PROJECT_ID
REGION=us-central1
VERTEX_ENDPOINT=REGION-aiplatform.googleapis.com
curl -H "Content-Type: application/json" \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  https://REGION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/REGION/indexEndpoints \
  -d '{
     "displayName": "DISPLAY_NAME",
     "privateServiceConnectConfig": {
       "enablePrivateServiceConnect": true,
       "projectAllowlist": [ "VPC_PROJECT_1", "VPC_PROJECT_2", "VPC_PROJECT_N"]
     }
   }

Acerca de las opciones de implementación de índices

Puedes implementar tu índice con conectividad de servicio automática o manual.

• Implementa con la automatización de Private Service Connect: Configura una política de conexión de servicio y, luego, implementa tus índices. Configurar una política de conexión de servicio te permite implementar en una red específica sin crear una dirección de procesamiento y una regla de reenvío cada vez.
• Implementación con conexión manual: Implementa tu índice y crea manualmente una dirección de procesamiento y una regla de reenvío. Puedes elegir esta opción si necesitas usar varias direcciones IP para el mismo URI de archivo adjunto del servicio, aunque este no es un caso de uso común.

Implementa con la automatización de Private Service Connect

Puedes configurar una política de conexión de servicio para que no tengas que crear manualmente una dirección de procesamiento y una regla de reenvío después de cada implementación de índice.

1. Primero, crea una política de conexión de servicio que especifique la red, la clase de servicio y la región en la que se implementarán los índices. Esta es una configuración que solo deberás realizar una vez. Si ya lo hiciste, ve al siguiente procedimiento.
2. Implementa el índice.

Limitaciones

La automatización solo permite una dirección IP por proyecto y por red. Si necesitas usar varias direcciones IP, consulta Cómo implementar el índice de forma manual.

Crea una política de conexión de servicio

Debes ser administrador de red para crear una política de conexión de servicio que automatice la implementación de índices.

Para automatizar la implementación de índices, sigue estos pasos:

1. Crea tu política de conexión de servicio.

   • PROJECT: Es el proyecto de servicio en el que creas recursos de Vertex AI.

   • VPC_PROJECT: Es el proyecto en el que se encuentra tu VPC cliente. Para una configuración de VPC única, es igual a $PROJECT. Para la configuración de la VPC compartida, este es el proyecto host de VPC.

   • NETWORK_NAME: Es el nombre de la red en la que se implementará, en el formato projects//global/networks/.

   • REGION: Es la región de la red.

   • PSC_SUBNETS: Son las subredes de Private Service Connect que se usarán.

   gcloud network-connectivity service-connection-policies create <policy_name> \
   --project=<vpc_project> --network=<network_name> # in the format projects/<project_id>/global/networks/<network_name> \
   --service-class=gcp-vertexai --region=<region> --subnets=<psc subnets>
   

2. Consulta tu política de conexión de servicio.

   gcloud network-connectivity service-connection-policies list --project=<vpc_project> -–region=<region>
   

Para obtener más información sobre las políticas de conexión de servicios, consulta Configura las políticas de conexión de servicios.

Implementa el índice

PROJECT=PROJECT
VPC_PROJECTS=VPC_PROJECTS
REGION=REGION
curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)"
-H "Content-Type: application/json; charset=utf-8" "https://REGIONAL_ENDPOINT.googleapis.com/v1/projects/PROJECT_NUMBER/locations/REGION/indexEndpoints/INDEX_ENDPOINT_ID:deployIndex"
-d '{
  "deployedIndex": {
    "id": "DEPLOYED_INDEX_ID",
    "index": "projects/PROJECT/locations/us-central1/indexes/INDEX_ID ",
    "displayName": "DISPLAY_NAME",
    "psc_automation_configs": [
      { "project_id": "PROJECT_1", "network": "NETWORK_NAME_1" },
      { "project_id": "PROJECT_2", "network": "NETWORK_NAME_2" },
      { "project_id": "PROJECT_N", "network": "NETWORK_NAME_N" }]
    }
}'

Borra la política de conexión de servicio

Si necesitas borrar la política de conexión de servicio, ejecuta el siguiente comando:

gcloud network-connectivity service-connection-policies delete --project=<vpc_project> –-region=<region> <policy_name>

Para obtener más información sobre las políticas de conexión de servicios, consulta Configura las políticas de conexión de servicios.

Implementa con conexión manual

Implementa el índice y crea una regla de reenvío en tu proyecto de VPC.

Implementa el índice

Ahora que el índice está listo, en este paso, implementarás el índice en el extremo que creaste con Private Service Connect habilitado.

gcloud ai index-endpoints deploy-index INDEX_ENDPOINT_ID \
    --deployed-index-id=DEPLOYED_INDEX_ID \
    --display-name=DEPLOYED_INDEX_ENDPOINT_NAME \
    --index=INDEX_ID \
    --region=LOCATION \
    --project=PROJECT_ID

gcloud ai index-endpoints deploy-index INDEX_ENDPOINT_ID `
    --deployed-index-id=DEPLOYED_INDEX_ID `
    --display-name=DEPLOYED_INDEX_ENDPOINT_NAME `
    --index=INDEX_ID `
    --region=LOCATION `
    --project=PROJECT_ID

gcloud ai index-endpoints deploy-index INDEX_ENDPOINT_ID ^
    --deployed-index-id=DEPLOYED_INDEX_ID ^
    --display-name=DEPLOYED_INDEX_ENDPOINT_NAME ^
    --index=INDEX_ID ^
    --region=LOCATION ^
    --project=PROJECT_ID

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/indexEndpoints/INDEX_ENDPOINT_ID:deployIndex

{
 "deployedIndex": {
   "id": "DEPLOYED_INDEX_ID",
   "index": "projects/PROJECT_ID/locations/LOCATION/indexes/INDEX_ID",
   "displayName": "DEPLOYED_INDEX_ENDPOINT_NAME"
 }
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/indexEndpoints/INDEX_ENDPOINT_ID:deployIndex"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/indexEndpoints/INDEX_ENDPOINT_ID:deployIndex" | Select-Object -Expand Content

{
 "name": "projects/PROJECT_NUMBER/locations/LOCATION/indexEndpoints/INDEX_ENDPOINT_ID/operations/OPERATION_ID",
 "metadata": {
   "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployIndexOperationMetadata",
   "genericMetadata": {
     "createTime": "2022-10-19T17:53:16.502088Z",
     "updateTime": "2022-10-19T17:53:16.502088Z"
   },
   "deployedIndexId": "DEPLOYED_INDEX_ID"
 }
}

provider "google" {
  region = "us-central1"
}

resource "google_vertex_ai_index_endpoint_deployed_index" "default" {
  depends_on        = [google_vertex_ai_index_endpoint.default]
  index_endpoint    = google_vertex_ai_index_endpoint.default.id
  index             = google_vertex_ai_index.default.id
  deployed_index_id = "deployed_index_for_psc"
}

resource "google_vertex_ai_index_endpoint" "default" {
  display_name = "sample-endpoint"
  description  = "A sample index endpoint with Private Service Connect enabled"
  region       = "us-central1"
  private_service_connect_config {
    enable_private_service_connect = true
    project_allowlist = [
      data.google_project.project.project_id,
    ]
  }
}

data "google_project" "project" {}

# Cloud Storage bucket name must be unique
resource "random_id" "default" {
  byte_length = 8
}

# Create a Cloud Storage bucket
resource "google_storage_bucket" "bucket" {
  name                        = "vertex-ai-index-bucket-${random_id.default.hex}"
  location                    = "us-central1"
  uniform_bucket_level_access = true
}

# Create index content
resource "google_storage_bucket_object" "data" {
  name    = "contents/data.json"
  bucket  = google_storage_bucket.bucket.name
  content = <<EOF
{"id": "42", "embedding": [0.5, 1.0], "restricts": [{"namespace": "class", "allow": ["cat", "pet"]},{"namespace": "category", "allow": ["feline"]}]}
{"id": "43", "embedding": [0.6, 1.0], "restricts": [{"namespace": "class", "allow": ["dog", "pet"]},{"namespace": "category", "allow": ["canine"]}]}
EOF
}

resource "google_vertex_ai_index" "default" {
  region       = "us-central1"
  display_name = "sample-index-batch-update"
  description  = "A sample index for batch update"
  labels = {
    foo = "bar"
  }

  metadata {
    contents_delta_uri = "gs://${google_storage_bucket.bucket.name}/contents"
    config {
      dimensions                  = 2
      approximate_neighbors_count = 150
      distance_measure_type       = "DOT_PRODUCT_DISTANCE"
      algorithm_config {
        tree_ah_config {
          leaf_node_embedding_count    = 500
          leaf_nodes_to_search_percent = 7
        }
      }
    }
  }
  index_update_method = "BATCH_UPDATE"

  timeouts {
    create = "2h"
    update = "1h"
  }
}

def vector_search_deploy_index(
    project: str,
    location: str,
    index_name: str,
    index_endpoint_name: str,
    deployed_index_id: str,
) -> None:
    """Deploy a vector search index to a vector search index endpoint.

    Args:
        project (str): Required. Project ID
        location (str): Required. The region name
        index_name (str): Required. The index to update. A fully-qualified index
          resource name or a index ID.  Example:
          "projects/123/locations/us-central1/indexes/my_index_id" or
          "my_index_id".
        index_endpoint_name (str): Required. Index endpoint to deploy the index
          to.
        deployed_index_id (str): Required. The user specified ID of the
          DeployedIndex.
    """
    # Initialize the Vertex AI client
    aiplatform.init(project=project, location=location)

    # Create the index instance from an existing index
    index = aiplatform.MatchingEngineIndex(index_name=index_name)

    # Create the index endpoint instance from an existing endpoint.
    index_endpoint = aiplatform.MatchingEngineIndexEndpoint(
        index_endpoint_name=index_endpoint_name
    )

    # Deploy Index to Endpoint
    index_endpoint = index_endpoint.deploy_index(
        index=index, deployed_index_id=deployed_index_id
    )

    print(index_endpoint.deployed_indexes)

Crea una regla de reenvío en el proyecto de VPC

Una vez completada la implementación del índice, el extremo del índice muestra un URI de adjunto del servicio en lugar de una dirección IP. Debes crear una dirección de procesamiento y una regla de reenvío en el proyecto de VPC que se oriente al adjunto de servicio mediante la dirección de procesamiento creada. Para crear una dirección de procesamiento, usa el siguiente ejemplo:

gcloud compute addresses create ${ADDRESS_NAME:?} \
    --region=${REGION:?} \
    --subnet=${SUBNET_NAME:?} \
    --project=${VPC_PROJECT:?}

Para crear una regla de reenvío que se oriente al URI del adjunto de servicio mediante la dirección de procesamiento creada, usa el siguiente ejemplo:

SERVICE_ATTACHMENT_URI=`gcloud ai index-endpoints describe {INDEX_ENDPOINT_ID}
--format="value(deployedIndexes.privateEndpoints.serviceAttachment)"`

gcloud compute forwarding-rules create ${ENDPOINT_NAME:?} \
    --network=${NETWORK_NAME:?} \
    --address=${ADDRESS_NAME:?} \
    --target-service-attachment=${SERVICE_ATTACHMENT_URI:?} \
    --project=${VPC_PROJECT:?} \
    --region=${REGION:?}

(Opcional) Crea un registro DNS para la dirección IP

Si deseas conectarte y cargar sin memorizar la dirección IP real, puedes crear un registro DNS. Este paso es opcional.

DNS_NAME_SUFFIX=matchingengine.vertexai.goog. # Don't forget the "." in the end.
DNS_NAME=${INDEX_ENDPOINT_ID:?}.${REGION:?}.${DNS_NAME_SUFFIX:?}

gcloud dns managed-zones create ${DNS_ZONE_NAME:?} \
    --dns-name=${DNS_NAME_SUFFIX:?} \
    --visibility=private \
    --project=${VPC_PROJECT:?} \
    --region=${REGION:?}

gcloud dns record-sets create ${DNS_NAME:?} \
    --rrdatas=${IP_ADDRESS:?} \
    --type=A --ttl=60 \
    --zone=${DNS_ZONE_NAME:?} \
    --project=${VPC_PROJECT:?} \
    --region=${REGION:?}

Envía consultas al extremo del índice

Ahora que creaste un extremo con Private Service Connect y creaste el índice, puedes comenzar a ejecutar consultas.

Para consultar tu índice, consulta Índices de consulta para obtener los vecinos más cercanos.

¿Qué sigue?

• Obtén más información sobre cómo actualizar y volver a compilar el índice.
• Obtén más información sobre cómo supervisar el extremo del índice.