Menyiapkan Vector Search dengan Private Service Connect

Private Service Connect memungkinkan penggunaan layanan secara pribadi di seluruh jaringan VPC yang dimiliki oleh grup, tim, project, dan organisasi yang berbeda. Anda dapat memublikasikan dan menggunakan layanan menggunakan alamat IP yang Anda tentukan dan yang bersifat internal untuk jaringan VPC Anda, serta untuk endpoint Vector Search guna melakukan penelusuran kesamaan vektor.

Private Service Connect sebaiknya diaktifkan di endpoint Vector Search untuk kasus penggunaan yang:

1. Memerlukan latensi rendah dan koneksi aman ke backend penyaluran Vector Search.
2. Memiliki ruang IP terbatas untuk pemesanan peering VPC eksklusif.
3. Perlu mengakses backend penyaluran dari beberapa jaringan VPC pengguna.

Untuk mempelajari cara menyiapkan Private Service Connect lebih lanjut, buka Ringkasan Private Service Connect dalam dokumentasi Virtual Private Cloud (VPC).

Membuat endpoint indeks

Anda harus mengaktifkan Private Service Connect saat membuat endpoint. Prosedur ini mirip dengan membuat endpoint lain di 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"]
     }
   }

Tentang opsi deployment indeks

Anda dapat men-deploy indeks dengan konektivitas layanan otomatis atau manual.

• Men-deploy dengan otomatisasi Private Service Connect: Siapkan kebijakan koneksi layanan dan deploy indeks Anda. Dengan menyiapkan kebijakan koneksi layanan, Anda dapat men-deploy ke jaringan tertentu tanpa membuat alamat komputasi dan aturan penerusan setiap kali.
• Men-deploy dengan koneksi manual: Men-deploy indeks dan membuat alamat komputasi dan aturan penerusan secara manual. Anda dapat memilih opsi ini jika perlu menggunakan beberapa alamat IP untuk URI lampiran layanan yang sama, meskipun ini bukan kasus penggunaan yang umum.

Men-deploy dengan otomatisasi Private Service Connect

Anda dapat menyiapkan kebijakan koneksi layanan sehingga tidak perlu membuat alamat komputasi dan aturan penerusan secara manual setelah setiap deployment indeks.

1. Pertama, buat kebijakan koneksi layanan yang menentukan jaringan, class layanan, dan region tempat indeks akan di-deploy. Ini adalah penyiapan satu kali. Jika Anda sudah melakukannya, lanjutkan ke prosedur berikutnya.
2. Deploy indeks.

Batasan

Otomatisasi hanya mengizinkan satu alamat IP per project per jaringan. Jika Anda perlu menggunakan beberapa alamat IP, lihat Men-deploy indeks secara manual.

Membuat kebijakan koneksi layanan

Anda harus menjadi administrator jaringan untuk membuat kebijakan koneksi layanan guna mengotomatiskan deployment indeks.

Untuk mengotomatiskan deployment indeks, ikuti langkah-langkah berikut:

1. Buat kebijakan koneksi layanan Anda.

   • PROJECT: Project layanan tempat Anda membuat resource Vertex AI.

   • VPC_PROJECT: Project tempat VPC klien Anda berada. Untuk penyiapan VPC tunggal, ini sama dengan $PROJECT. Untuk penyiapan VPC Bersama, ini adalah project host VPC.

   • NETWORK_NAME: Nama jaringan tempat deployment akan dilakukan, dalam format projects//global/networks/.

   • REGION: Region jaringan.

   • PSC_SUBNETS: Subnet Private Service Connect yang akan digunakan.

   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. Lihat kebijakan koneksi layanan Anda.

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

Untuk informasi selengkapnya tentang kebijakan koneksi layanan, buka Mengonfigurasi kebijakan koneksi layanan.

Men-deploy indeks

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" }]
    }
}'

Menghapus kebijakan koneksi layanan

Jika Anda perlu menghapus kebijakan koneksi layanan, jalankan perintah berikut:

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

Untuk informasi selengkapnya tentang kebijakan koneksi layanan, buka Mengonfigurasi kebijakan koneksi layanan.

Men-deploy dengan koneksi manual

Deploy indeks dan buat aturan penerusan di project VPC Anda.

Men-deploy indeks

Setelah indeks siap, pada langkah ini, Anda akan men-deploy indeks ke endpoint yang dibuat dengan Private Service Connect yang diaktifkan.

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)

Membuat aturan penerusan di project VPC

Setelah deployment indeks selesai, endpoint indeks akan menampilkan URI lampiran layanan, bukan alamat IP. Anda perlu membuat alamat komputasi, serta aturan penerusan di project VPC yang menargetkan lampiran layanan menggunakan alamat komputasi yang dibuat. Untuk membuat alamat komputasi, gunakan contoh berikut:

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

Untuk membuat aturan penerusan yang menargetkan URI lampiran layanan menggunakan alamat compute yang dibuat, gunakan contoh berikut:

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:?}

(Opsional) Membuat data DNS untuk alamat IP

Jika ingin menghubungkan dan memuat tanpa mengingat alamat IP yang sebenarnya, Anda dapat membuat data DNS. Langkah ini opsional.

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:?}

Mengirim kueri ke endpoint indeks

Setelah membuat endpoint dengan Private Service Connect dan membuat indeks, Anda dapat mulai menjalankan kueri.

Untuk membuat kueri indeks Anda, lihat Indeks kueri guna mendapatkan nearest neighbor.

Langkah berikutnya

• Mempelajari cara Mengupdate dan membuat kembali indeks
• Mempelajari cara Memantau endpoint indeks