Menggunakan endpoint pribadi khusus berdasarkan Private Service Connect untuk inferensi online

Private Service Connect memungkinkan Anda mengakses inferensi online Vertex AI secara aman dari beberapa project konsumen dan jaringan VPC tanpa memerlukan alamat IP publik, akses internet publik, atau rentang alamat IP internal yang di-peering secara eksplisit.

Kami merekomendasikan Private Service Connect untuk kasus penggunaan inferensi online yang memiliki persyaratan berikut:

• Mewajibkan koneksi pribadi dan aman
• Memerlukan latensi rendah
• Tidak perlu dapat diakses secara publik

Private Service Connect menggunakan aturan penerusan di jaringan VPC Anda untuk mengirim traffic secara satu arah ke layanan inferensi online Vertex AI. Aturan penerusan terhubung ke lampiran layanan yang mengekspos layanan Vertex AI ke jaringan VPC Anda. Untuk mengetahui informasi selengkapnya, lihat Tentang mengakses layanan Vertex AI melalui Private Service Connect. Untuk mempelajari lebih lanjut cara menyiapkan Private Service Connect, lihat Ringkasan Private Service Connect dalam dokumentasi Virtual Private Cloud (VPC).

Endpoint pribadi khusus mendukung protokol komunikasi HTTP dan gRPC. Untuk permintaan gRPC, header x-vertex-ai-endpoint-id harus disertakan untuk identifikasi endpoint yang tepat. API berikut didukung:

• Prediksi
• RawPredict
• StreamRawPredict
• Penyelesaian Chat (khusus Model Garden)

Anda dapat mengirim permintaan inferensi online ke endpoint pribadi khusus menggunakan Vertex AI SDK untuk Python. Untuk mengetahui detailnya, lihat Mendapatkan inferensi online.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan untuk membuat endpoint Private Service Connect, minta administrator Anda untuk memberi Anda peran IAM Vertex AI User (roles/aiplatform.user) di project Anda. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran bawaan ini berisi izin aiplatform.endpoints.create , yang diperlukan untuk membuat endpoint Private Service Connect.

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Untuk mengetahui informasi selengkapnya tentang peran dan izin Vertex AI, lihat Kontrol akses Vertex AI dengan IAM dan Izin IAM Vertex AI.

Membuat endpoint inferensi online

Gunakan salah satu metode berikut untuk membuat endpoint inferensi online dengan Private Service Connect yang diaktifkan.

Waktu tunggu permintaan default untuk endpoint Private Service Connect adalah 10 menit. Di Vertex AI SDK untuk Python, Anda dapat secara opsional menentukan waktu tunggu permintaan yang berbeda dengan menentukan nilai inference_timeout baru, seperti yang ditunjukkan dalam contoh berikut. Nilai waktu tunggu maksimum adalah 3.600 detik (1 jam).

POST https://REGION-aiplatform.googleapis.com/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints

{
  "displayName": "VERTEX_AI_ENDPOINT_NAME",
  "privateServiceConnectConfig": {
    "enablePrivateServiceConnect": true,
    "projectAllowlist": ["ALLOWED_PROJECTS"],
    "clientConnectionConfig": {
      "inferenceTimeout": {
        "seconds": INFERENCE_TIMEOUT_SECS
      }
    }
  }
}

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

$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://REGION-aiplatform.googleapis.com/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints" | Select-Object -Expand Content

{
  "name": "projects/VERTEX_AI_PROJECT_NUMBER/locations/REGION/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}

PROJECT_ID = "VERTEX_AI_PROJECT_ID"
REGION = "REGION"
VERTEX_AI_ENDPOINT_NAME = "VERTEX_AI_ENDPOINT_NAME"
INFERENCE_TIMEOUT_SECS = "INFERENCE_TIMEOUT_SECS"

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=REGION)

# Create the forwarding rule in the consumer project
psc_endpoint = aiplatform.PrivateEndpoint.create(
display_name=VERTEX_AI_ENDPOINT_NAME,
project=PROJECT_ID,
location=REGION,
private_service_connect_config=aiplatform.PrivateEndpoint.PrivateServiceConnectConfig(
    project_allowlist=["ALLOWED_PROJECTS"],
    ),
inference_timeout=INFERENCE_TIMEOUT_SECS,
)

INFO:google.cloud.aiplatform.models:To use this PrivateEndpoint in another session:
INFO:google.cloud.aiplatform.models:endpoint = aiplatform.PrivateEndpoint('projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID')

Membuat endpoint inferensi online dengan otomatisasi PSC (Pratinjau)

Inferensi online terintegrasi dengan otomatisasi konektivitas layanan, yang memungkinkan Anda mengonfigurasi endpoint inferensi dengan otomatisasi PSC. Hal ini menyederhanakan proses dengan membuat endpoint PSC secara otomatis, dan sangat bermanfaat bagi developer ML yang tidak memiliki izin untuk membuat resource jaringan seperti aturan penerusan dalam project.

Untuk memulai, administrator jaringan Anda harus membuat kebijakan koneksi layanan. Kebijakan ini merupakan konfigurasi sekali per project dan jaringan yang memungkinkan Vertex AI (class layanan gcp-vertexai) membuat endpoint PSC dalam project dan jaringan Anda.

Selanjutnya, Anda dapat membuat endpoint menggunakan konfigurasi otomatisasi PSC, lalu men-deploy model Anda. Setelah deployment selesai, informasi endpoint PSC yang relevan dapat diakses dalam endpoint.

Batasan

• Kontrol Layanan VPC tidak didukung.
• Batas regional 500 endpoint berlaku untuk konfigurasi otomatisasi PSC.
• Hasil otomatisasi PSC dihapus jika tidak ada model yang di-deploy atau sedang dalam proses di-deploy ke endpoint. Setelah pembersihan dan deployment model berikutnya, fitur hasil otomatisasi baru akan menampilkan alamat IP dan aturan penerusan yang berbeda.

Membuat kebijakan koneksi layanan

Anda harus menjadi administrator jaringan untuk membuat kebijakan koneksi layanan. Kebijakan koneksi layanan diperlukan agar Vertex AI dapat membuat endpoint PSC di jaringan Anda. Tanpa kebijakan yang valid, otomatisasi akan gagal dengan error CONNECTION_POLICY_MISSING.

1. Buat kebijakan koneksi layanan Anda.

   • POLICY_NAME: Nama yang ditentukan pengguna untuk kebijakan.

   • PROJECT_ID: ID project layanan tempat Anda membuat resource Vertex AI.

   • VPC_PROJECT: Project ID 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 yang akan di-deploy.

   • 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=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 penyiapan VPC tunggal, contohnya akan terlihat seperti ini:

       gcloud network-connectivity service-connection-policies create test-policy \
           --network=default \
           --project=YOUR_PROJECT_ID \
           --region=us-central1 \
           --service-class=gcp-vertexai \
           --subnets=default \
           --psc-connection-limit=500 \
           --description=test

Buat endpoint inferensi online dengan konfigurasi otomatisasi PSC

Di PSCAutomationConfig, periksa untuk memastikan bahwa projectId ada dalam daftar yang diizinkan.

POST https://REGION-aiplatform.googleapis.com/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints

{
  {
    displayName: "VERTEX_AI_ENDPOINT_NAME",
    privateServiceConnectConfig: {
      enablePrivateServiceConnect: true,
      projectAllowlist: ["VERTEX_AI_PROJECT_ID"],
      pscAutomationConfigs: [
        { "project_id": "VERTEX_AI_PROJECT_ID", "network": "projects/VERTEX_AI_PROJECT_ID/global/networks/NETWORK_NAME" },
      ],
    },
  },

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

$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://REGION-aiplatform.googleapis.com/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints" | Select-Object -Expand Content

{
  "name": "projects/VERTEX_AI_PROJECT_NUMBER/locations/REGION/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}

PROJECT_ID = "VERTEX_AI_PROJECT_ID"
REGION = "REGION"
VERTEX_AI_ENDPOINT_NAME = "VERTEX_AI_ENDPOINT_NAME"

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=REGION)

config =
aiplatform.compat.types.service_networking.PrivateServiceConnectConfig(
        enable_private_service_connect=True,
        project_allowlist="VERTEX_AI_PROJECT_ID"
        psc_automation_configs=[
            aiplatform.compat.types.service_networking.PSCAutomationConfig(
                project_id="VERTEX_AI_PROJECT_ID"
network=projects/"VERTEX_AI_PROJECT_ID"/global/networks/"NETWORK_NAME",
            )
        ]
    )
psc_endpoint = aiplatform.PrivateEndpoint.create(
     display_name="VERTEX_AI_ENDPOINT_NAME"
     private_service_connect_config=config,
)

Men-deploy model

Setelah membuat endpoint inferensi online dengan Private Service Connect yang diaktifkan, deploy model Anda ke endpoint tersebut dengan mengikuti langkah-langkah yang diuraikan dalam Men-deploy model ke endpoint.

Membuat Endpoint PSC Secara Manual

Mendapatkan URI lampiran layanan

Saat Anda men-deploy model, lampiran layanan akan dibuat untuk endpoint inferensi online. Lampiran layanan ini merepresentasikan layanan inferensi online Vertex AI yang diekspos ke jaringan VPC Anda. Jalankan perintah gcloud ai endpoints describe untuk mendapatkan URI lampiran layanan.

1. Hanya mencantumkan nilai serviceAttachment dari detail endpoint:

   gcloud ai endpoints describe ENDPOINT_ID \
   --project=VERTEX_AI_PROJECT_ID \
   --region=REGION \
   | grep -i serviceAttachment
   

   Ganti kode berikut:

   • ENDPOINT_ID: ID endpoint inferensi online Anda
   • VERTEX_AI_PROJECT_ID: ID project Google Cloud tempat Anda membuat endpoint inferensi online
   • REGION: region untuk permintaan ini

   Outputnya mirip dengan hal berikut ini:

   serviceAttachment: projects/ac74a9f84c2e5f2a1-tp/regions/us-central1/serviceAttachments/gkedpm-c6e6a854a634dc99472bb802f503c1
   

2. Catat seluruh string di kolom serviceAttachment. Ini adalah URI lampiran layanan.

Membuat aturan penerusan

Anda dapat mencadangkan alamat IP internal dan membuat aturan penerusan dengan alamat tersebut. Untuk membuat aturan penerusan, Anda memerlukan URI lampiran layanan dari langkah sebelumnya.

1. Untuk mencadangkan alamat IP internal untuk aturan penerusan, gunakan perintah gcloud compute addresses create:

   gcloud compute addresses create ADDRESS_NAME \
   --project=VPC_PROJECT_ID \
   --region=REGION \
   --subnet=SUBNETWORK \
   --addresses=INTERNAL_IP_ADDRESS
   

   Ganti kode berikut:

   • ADDRESS_NAME: nama untuk alamat IP internal
   • VPC_PROJECT_ID: ID project Google Cloud yang menghosting jaringan VPC Anda. Jika endpoint inferensi online dan aturan penerusan Private Service Connect dihosting di project yang sama, gunakan VERTEX_AI_PROJECT_ID untuk parameter ini.
   • REGION: Google Cloud region tempat aturan penerusan Private Service Connect akan dibuat
   • SUBNETWORK: nama subnet VPC yang berisi alamat IP

   • INTERNAL_IP_ADDRESS: alamat IP internal yang akan dicadangkan. Parameter ini bersifat opsional.

     • Jika parameter ini ditentukan, alamat IP harus berada dalam rentang alamat IP utama subnet. Alamat IP dapat berupa alamat RFC 1918 atau subnet dengan rentang non-RFC.
     • Jika parameter ini tidak disertakan, alamat IP internal akan dialokasikan secara otomatis.
     • Untuk mengetahui informasi selengkapnya, lihat Mencadangkan alamat IPv4 atau IPv6 internal statis yang baru.

2. Untuk memverifikasi bahwa alamat IP sudah dicadangkan, gunakan perintah gcloud compute addresses list:

   gcloud compute addresses list --filter="name=(ADDRESS_NAME)" \
   --project=VPC_PROJECT_ID
   

   Dalam respons, pastikan bahwa status RESERVED muncul untuk alamat IP.

3. Untuk membuat aturan penerusan dan mengarahkannya ke lampiran layanan inferensi online, gunakan perintah gcloud compute forwarding-rules create:

   gcloud compute forwarding-rules create PSC_FORWARDING_RULE_NAME \
       --address=ADDRESS_NAME \
       --project=VPC_PROJECT_ID \
       --region=REGION \
       --network=VPC_NETWORK_NAME \
       --target-service-attachment=SERVICE_ATTACHMENT_URI
   

   Ganti kode berikut:

   • PSC_FORWARDING_RULE_NAME: nama untuk aturan penerusan
   • VPC_NETWORK_NAME: nama jaringan VPC tempat endpoint akan dibuat
   • SERVICE_ATTACHMENT_URI: lampiran layanan yang Anda catat sebelumnya

4. Untuk memverifikasi bahwa lampiran layanan menerima endpoint, gunakan perintah gcloud compute forwarding-rules describe:

   gcloud compute forwarding-rules describe PSC_FORWARDING_RULE_NAME \
   --project=VPC_PROJECT_ID \
   --region=REGION
   

   Dalam respons, pastikan status ACCEPTED muncul di kolom pscConnectionStatus.

Opsional: Dapatkan alamat IP internal

Jika Anda tidak menentukan nilai untuk INTERNAL_IP_ADDRESS saat membuat aturan penerusan, Anda bisa mendapatkan alamat yang dialokasikan secara otomatis menggunakan perintah gcloud compute forwarding-rules describe:

gcloud compute forwarding-rules describe PSC_FORWARDING_RULE_NAME \
--project=VERTEX_AI_PROJECT_ID \
--region=REGION \
| grep -i IPAddress

Ganti kode berikut:

• VERTEX_AI_PROJECT_ID: project ID Anda
• REGION: nama region untuk permintaan ini

Opsional: Dapatkan endpoint PSC dari hasil otomatisasi PSC

Anda bisa mendapatkan alamat IP dan aturan penerusan yang dihasilkan dari endpoint inferensi. Berikut contohnya:

"privateServiceConnectConfig": {
  "enablePrivateServiceConnect": true,
  "projectAllowlist": [
    "your-project-id",
  ],
  "pscAutomationConfigs": [
    {
      "projectId": "your-project-id",
      "network": "projects/your-project-id/global/networks/default",
      "ipAddress": "10.128.15.209",
      "forwardingRule": "https://www.googleapis.com/compute/v1/projects/your-project-id/regions/us-central1/forwardingRules/sca-auto-fr-47b0d6a4-eaff-444b-95e6-e4dc1d10101e",
      "state": "PSC_AUTOMATION_STATE_SUCCESSFUL"
    },
  ]
}

Berikut beberapa detail penanganan error.

• Kegagalan otomatisasi tidak memengaruhi hasil deployment model.
• Keberhasilan atau kegagalan operasi ditunjukkan dalam status.
  • Jika berhasil, alamat IP dan aturan penerusan akan ditampilkan.
  • Jika tidak berhasil, pesan error akan ditampilkan.
• Konfigurasi otomatisasi dihapus jika tidak ada model yang di-deploy atau dalam proses di-deploy ke endpoint. Hal ini akan menyebabkan perubahan pada alamat IP dan aturan penerusan jika model di-deploy nanti.
• Otomatisasi yang gagal tidak akan dipulihkan. Jika gagal, Anda tetap dapat membuat endpoint PSC secara manual, lihat Membuat Endpoint PSC Secara Manual.

Mendapatkan inferensi online

Mendapatkan inferensi online dari endpoint dengan Private Service Connect mirip dengan mendapatkan inferensi online dari endpoint publik, kecuali untuk pertimbangan berikut:

• Permintaan harus dikirim dari project yang ditentukan dalam projectAllowlist saat endpoint inferensi online dibuat.
• Jika akses global tidak diaktifkan, permintaan harus dikirim dari region yang sama.
• Ada dua port yang terbuka, 443 dengan TLS menggunakan sertifikat yang ditandatangani sendiri dan 80 tanpa TLS. Kedua port mendukung HTTP dan GRPC. Semua traffic akan berada di jaringan pribadi dan tidak akan melalui internet publik.

• Untuk mendapatkan inferensi, koneksi harus dibuat menggunakan alamat IP statis endpoint, kecuali jika data DNS dibuat untuk alamat IP internal. Misalnya, kirim permintaan predict ke endpoint berikut:

  https://INTERNAL_IP_ADDRESS/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID:predict
  

  Ganti INTERNAL_IP_ADDRESS dengan alamat IP internal yang Anda cadangkan sebelumnya.

• Untuk permintaan gRPC: Untuk memastikan identifikasi endpoint yang tepat untuk permintaan gRPC, Anda harus menyertakan header x-vertex-ai-endpoint-id. Hal ini diperlukan karena informasi endpoint tidak disampaikan dalam jalur permintaan untuk komunikasi gRPC.

• Koneksi aman (Port 443): Saat membuat koneksi aman menggunakan port 443, server menggunakan sertifikat yang ditandatangani sendiri. Untuk melanjutkan koneksi, sebaiknya gunakan salah satu pendekatan berikut:

  • Opsi 1: Melewati validasi sertifikat: Konfigurasi klien untuk mengabaikan validasi sertifikat dan membuat koneksi menggunakan alamat IP server atau metode resolusi DNS pilihan.
  • Opsi 2: Integrasi trust store: Dapatkan sertifikat yang ditandatangani sendiri oleh server, tambahkan ke trust store lokal sistem klien, dan gunakan nama DNS dalam format *.prediction.p.vertexai.goog untuk membuat koneksi. Metode ini memastikan komunikasi yang aman melalui validasi sertifikat.

Bagian berikut memberikan contoh cara mengirim permintaan predict menggunakan Python.

Contoh pertama

psc_endpoint = aiplatform.PrivateEndpoint("projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID")
REQUEST_FILE = "PATH_TO_INPUT_FILE"
import json

import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

with open(REQUEST_FILE) as json_file:
    data = json.load(json_file)
    response = psc_endpoint.predict(
        instances=data["instances"], endpoint_override=INTERNAL_IP_ADDRESS
    )
print(response)

Ganti PATH_TO_INPUT_FILE dengan jalur ke file JSON yang berisi input permintaan.

Contoh kedua

import json
import requests
import urllib3
import google.auth.transport.requests

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

REQUEST_FILE = "PATH_TO_INPUT_FILE"

# Programmatically get credentials and generate an access token
creds, project = google.auth.default()
auth_req = google.auth.transport.requests.Request()
creds.refresh(auth_req)
access_token = creds.token
# Note: the credential lives for 1 hour by default
# After expiration, it must be refreshed
# See https://cloud.google.com/docs/authentication/token-types#at-lifetime

with open(REQUEST_FILE) as json_file:
    data = json.load(json_file)
    url = "https://INTERNAL_IP_ADDRESS/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID:predict"
    headers = {
      "Content-Type": "application/json",
      "Authorization": f"Bearer {access_token}"  # Add access token to headers
    }
    payload = {
      "instances": data["instances"],
    }

response = requests.post(url, headers=headers, json=payload, verify=False)

print(response.json())

Opsional: Buat data DNS untuk alamat IP internal

Sebaiknya buat data DNS agar Anda bisa mendapatkan inferensi online dari endpoint tanpa perlu menentukan alamat IP internal.

Untuk mengetahui informasi selengkapnya, lihat Cara lain untuk mengonfigurasi DNS.

1. Buat zona DNS pribadi menggunakan perintah gcloud dns managed-zones create. Zona ini dikaitkan dengan jaringan VPC tempat aturan penerusan dibuat.

   DNS_NAME_SUFFIX="prediction.p.vertexai.goog."  # DNS names have "." at the end.
   gcloud dns managed-zones create ZONE_NAME \
   --project=VPC_PROJECT_ID \
   --dns-name=$DNS_NAME_SUFFIX \
   --networks=VPC_NETWORK_NAME \
   --visibility=private \
   --description="A DNS zone for Vertex AI endpoints using Private Service Connect."
   
   

   Ganti kode berikut:

   • ZONE_NAME: nama zona DNS

2. Untuk membuat data DNS di zona, gunakan perintah gcloud dns record-sets create:

   DNS_NAME=ENDPOINT_ID-REGION-VERTEX_AI_PROJECT_NUMBER.$DNS_NAME_SUFFIX
   gcloud dns record-sets create $DNS_NAME \
   --rrdatas=INTERNAL_IP_ADDRESS \
   --zone=ZONE_NAME \
   --type=A \
   --ttl=60 \
   --project=VPC_PROJECT_ID
   

   Ganti kode berikut:

   • VERTEX_AI_PROJECT_NUMBER: nomor project untuk project VERTEX_AI_PROJECT_ID Anda. Anda dapat menemukan nomor project ini di konsol Google Cloud . Untuk mengetahui informasi selengkapnya, lihat Mengidentifikasi project.
   • INTERNAL_IP_ADDRESS: alamat IP internal endpoint inferensi online Anda

   Sekarang Anda dapat mengirim permintaan predict ke:

   https://ENDPOINT_ID-REGION-VERTEX_AI_PROJECT_NUMBER.prediction.p.vertexai.goog/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID:predict
   

Berikut adalah contoh cara mengirim permintaan predict ke zona DNS menggunakan Python:

REQUEST_FILE = "PATH_TO_INPUT_FILE"
import json

import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

with open(REQUEST_FILE) as json_file:
    data = json.load(json_file)
    response = psc_endpoint.predict(
        instances=data["instances"], endpoint_override=DNS_NAME
    )
print(response)

Ganti DNS_NAME dengan nama DNS yang Anda tentukan dalam perintah gcloud dns record-sets create.

Batasan

Endpoint Vertex AI dengan Private Service Connect tunduk pada batasan berikut:

• Deployment model Gemini yang di-tune tidak didukung.
• Egress pribadi dari dalam endpoint tidak didukung. Karena aturan penerusan Private Service Connect bersifat satu arah, beban kerja pribadi lainnya tidak dapat diakses di dalam penampung Anda.Google Cloud
• Nilai projectAllowlist endpoint tidak dapat diubah.
• Vertex Explainable AI tidak didukung.
• Sebelum menghapus endpoint, Anda harus membatalkan deployment model dari endpoint tersebut.
• Jika semua model tidak di-deploy selama lebih dari 10 menit, lampiran layanan dapat dihapus. Periksa status koneksi Private Service Connect; jika CLOSED, buat ulang aturan penerusan.
• Setelah menghapus endpoint, Anda tidak akan dapat menggunakan kembali nama endpoint tersebut hingga 7 hari.
• Project dapat memiliki hingga 10 nilai projectAllowlist yang berbeda dalam konfigurasi Private Service Connect-nya.

Langkah berikutnya

• Men-deploy model ke endpoint
• Mendapatkan inferensi online