Cette page a été traduite par l'API Cloud Translation.

Utiliser des points de terminaison privés dédiés basés sur Private Service Connect pour l'inférence en ligne

Les informations de cette page s'appliquent aux modèles entraînés personnalisés et aux modèles AutoML. Pour le déploiement de Model Garden, consultez Utiliser des modèles dans Model Garden.

Private Service Connect vous permet de déployer votre modèle Vertex AI entraîné sur mesure et de diffuser des inférences en ligne de manière sécurisée vers plusieurs projets clients et réseaux VPC, sans avoir besoin d'adresses IP publiques, d'un accès à Internet public ni d'une plage d'adresses IP internes explicitement appariées.

Nous vous recommandons d'utiliser Private Service Connect pour les cas d'utilisation d'inférence en ligne qui présentent les exigences suivantes :

Exiger des connexions privées et sécurisées
Nécessitent une faible latence
Ne doivent pas être accessibles au public

Private Service Connect utilise une règle de transfert dans votre réseau VPC pour envoyer du trafic unidirectionnel au service d'inférence en ligne Vertex AI. La règle de transfert se connecte à un rattachement de service qui expose le service Vertex AI à votre réseau VPC. Pour en savoir plus, consultez À propos de l'accès aux services Vertex AI via Private Service Connect. Pour en savoir plus sur la configuration de Private Service Connect, consultez la présentation de Private Service Connect dans la documentation du cloud privé virtuel (VPC).

Les points de terminaison privés dédiés sont compatibles avec les protocoles de communication HTTP et gRPC. Pour les requêtes gRPC, l'en-tête x-vertex-ai-endpoint-id doit être inclus pour identifier correctement le point de terminaison. Les API suivantes sont compatibles :

Prédiction
RawPredict
StreamRawPredict
Chat Completion (Model Garden uniquement)

Vous pouvez envoyer des requêtes d'inférence en ligne à un point de terminaison privé dédié à l'aide du SDK Vertex AI pour Python. Pour en savoir plus, consultez Obtenir des inférences en ligne.

Rôles requis

Pour obtenir l'autorisation dont vous avez besoin pour créer un point de terminaison Private Service Connect, demandez à votre administrateur de vous accorder le rôle IAM Utilisateur Vertex AI (roles/aiplatform.user) sur votre projet. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient l'autorisation aiplatform.endpoints.create, qui est requise pour créer un point de terminaison Private Service Connect.

Vous pouvez également obtenir cette autorisation avec des rôles personnalisés ou d'autres rôles prédéfinis.

Pour en savoir plus sur les rôles et les autorisations Vertex AI, consultez Contrôle des accès avec Vertex AI et IAM et Autorisations IAM Vertex AI.

Créer le point de terminaison d'inférence en ligne

Utilisez l'une des méthodes suivantes pour créer un point de terminaison d'inférence en ligne avec Private Service Connect activé.

Le délai avant expiration par défaut des requêtes pour un point de terminaison Private Service Connect est de 10 minutes. Dans le SDK Vertex AI pour Python, vous pouvez éventuellement spécifier un autre délai avant expiration en spécifiant une nouvelle valeur inference_timeout, comme illustré dans l'exemple suivant. La valeur maximale du délai avant expiration est de 3 600 secondes (1 heure).

Console

Dans la console Google Cloud , dans Vertex AI, accédez à la page Prédiction en ligne.

Accéder à la page Prédiction en ligne
Cliquez sur Créer.
Indiquez un nom à afficher pour le point de terminaison.
Sélectionnez Privé.
Sélectionnez Private Service Connect.
Cliquez sur Sélectionner des ID de projet.
Sélectionnez les projets à ajouter à la liste d'autorisation pour le point de terminaison.
Cliquez sur Continuer.
Choisissez les caractéristiques de votre modèle. Pour en savoir plus, consultez la section Déployer un modèle sur un point de terminaison.
Cliquez sur Créer pour créer votre point de terminaison et y déployer votre modèle.
Notez l'ID du point de terminaison dans la réponse.

API

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

VERTEX_AI_PROJECT_ID : ID du projet Google Cloud dans lequel vous créez le point de terminaison de prédiction en ligne.
REGION : région dans laquelle vous utilisez Vertex AI.
VERTEX_AI_ENDPOINT_NAME: nom à afficher du point de terminaison de prédiction en ligne.
ALLOWED_PROJECTS : liste d'ID de projet Google Cloud séparés par une virgule, chacun entre guillemets, par exemple ["PROJECTID1", "PROJECTID2"]. Si un projet ne figure pas dans cette liste, vous ne pourrez pas envoyer de requêtes de prédiction au point de terminaison Vertex AI à partir de ce projet. Veillez à inclure VERTEX_AI_PROJECT_ID dans cette liste afin de pouvoir appeler le point de terminaison à partir du même projet.
INFERENCE_TIMEOUT_SECS (facultatif) : nombre de secondes dans le champ inferenceTimeout facultatif.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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"

PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"
    }
  }
}

Notez ENDPOINT_ID.

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le guide de démarrage rapide de Vertex AI à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vertex AI pour Python.

Pour vous authentifier auprès de Vertex AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Remplacez les éléments suivants :

VERTEX_AI_PROJECT_ID : ID du Google Cloud projet dans lequel vous créez le point de terminaison d'inférence en ligne
REGION : région dans laquelle vous utilisez Vertex AI
VERTEX_AI_ENDPOINT_NAME : nom à afficher du point de terminaison d'inférence en ligne.
ALLOWED_PROJECTS : liste d'ID de projet Google Cloudséparés par une virgule, chacun entre guillemets. Exemple : ["PROJECTID1", "PROJECTID2"]. Si un projet ne figure pas dans cette liste, vous ne pourrez pas envoyer de requêtes d'inférence au point de terminaison Vertex AI à partir de ce projet. Veillez à inclure VERTEX_AI_PROJECT_ID dans cette liste afin de pouvoir appeler le point de terminaison à partir du même projet.
INFERENCE_TIMEOUT_SECS (facultatif) : nombre de secondes dans le champ inference_timeout facultatif.

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,
)

Notez ENDPOINT_ID à la fin de l'URI du point de terminaison renvoyé :

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')

Créer le point de terminaison d'inférence en ligne avec l'automatisation PSC (preview)

L'inférence en ligne s'intègre à l'automatisation de la connectivité des services, qui vous permet de configurer des points de terminaison d'inférence avec l'automatisation PSC. Cela simplifie le processus en créant automatiquement des points de terminaison PSC. C'est particulièrement utile pour les développeurs ML qui n'ont pas l'autorisation de créer des ressources réseau telles que des règles de transfert dans un projet.

Pour commencer, votre administrateur réseau doit établir une règle de connexion de service. Cette règle est une configuration unique par projet et par réseau qui permet à Vertex AI (classe de service gcp-vertexai) de générer des points de terminaison PSC dans vos projets et réseaux.

Vous pouvez ensuite créer des points de terminaison à l'aide de la configuration d'automatisation PSC, puis déployer vos modèles. Une fois le déploiement terminé, les informations sur le point de terminaison PSC concerné sont accessibles dans les points de terminaison.

Limites

VPC Service Controls n'est pas compatible.
Une limite régionale de 500 points de terminaison s'applique aux configurations d'automatisation PSC.
Les résultats de l'automatisation PSC sont supprimés lorsqu'aucun modèle n'est déployé ou en cours de déploiement sur le point de terminaison. Après le nettoyage et le déploiement du modèle, la nouvelle fonctionnalité de résultats d'automatisation présente des adresses IP et des règles de transfert distinctes.

Créer une règle de connexion de service

Vous devez être administrateur réseau pour créer la règle de connexion de service. Une règle de connexion de service est requise pour permettre à Vertex AI de créer des points de terminaison PSC dans vos réseaux. Sans règle valide, l'automatisation échoue et renvoie une erreur CONNECTION_POLICY_MISSING.

Créez votre règle de connexion de service.
- POLICY_NAME : nom de la règle spécifié par l'utilisateur.
- PROJECT_ID : ID du projet de service dans lequel vous créez des ressources Vertex AI.
- VPC_PROJECT : ID du projet dans lequel se trouve votre VPC client. Pour une configuration VPC simple, cette valeur est identique à $PROJECT. Pour une configuration de VPC partagé, il s'agit du projet hôte du VPC.
- NETWORK_NAME : nom du réseau sur lequel le déploiement sera effectué.
- REGION : région du réseau.
- PSC_SUBNETS : sous-réseaux Private Service Connect à utiliser.
```
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
```

Affichez votre règle de connexion de service.

gcloud network-connectivity service-connection-policies list \
    --project=VPC_PROJECT -–region=REGION

Voici un exemple de configuration VPC unique :

    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

Créer le point de terminaison d'inférence en ligne avec la configuration d'automatisation PSC

Dans PSCAutomationConfig, vérifiez que projectId figure dans la liste d'autorisation.

REST

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

REGION : région dans laquelle vous utilisez Vertex AI.
VERTEX_AI_PROJECT_ID : ID du projet Google Cloud dans lequel vous créez le point de terminaison d'inférence en ligne.
VERTEX_AI_ENDPOINT_NAME : nom à afficher du point de terminaison de prédiction en ligne.
NETWORK_NAME : nom complet de la ressource, y compris l'ID du projet, au lieu du numéro de projet.

Méthode HTTP et URL :

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

Corps JSON de la requête :

{
  {
    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" },
      ],
    },
  },

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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"

PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"
    }
  }
}

Notez ENDPOINT_ID.

Python

Remplacez les éléments suivants :

VERTEX_AI_PROJECT_ID : ID du Google Cloud projet dans lequel vous créez le point de terminaison d'inférence en ligne
REGION : région dans laquelle vous utilisez Vertex AI
VERTEX_AI_ENDPOINT_NAME : nom à afficher du point de terminaison d'inférence en ligne.
NETWORK_NAME : nom complet de la ressource, y compris l'ID du projet, au lieu du numéro de projet.

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,
)

Déployer le modèle

Après avoir créé votre point de terminaison d'inférence en ligne avec Private Service Connect activé, déployez votre modèle sur ce point de terminaison en suivant les étapes décrites dans Déployer un modèle sur un point de terminaison.

Créer manuellement un point de terminaison PSC

Obtenir l'URI du rattachement de service

Lorsque vous déployez le modèle, un rattachement de service est créé pour le point de terminaison d'inférence en ligne. Ce rattachement de service représente le service d'inférence en ligne Vertex AI qui est exposé à votre réseau VPC. Exécutez la commande gcloud ai endpoints describe pour obtenir l'URI du rattachement de service.

Indiquez uniquement la valeur serviceAttachment dans les détails du point de terminaison :
```
gcloud ai endpoints describe ENDPOINT_ID \
--project=VERTEX_AI_PROJECT_ID \
--region=REGION \
| grep -i serviceAttachment
```
Remplacez les éléments suivants :
- ENDPOINT_ID : ID de votre point de terminaison d'inférence en ligne
- VERTEX_AI_PROJECT_ID : ID du projet Google Cloud dans lequel vous avez créé votre point de terminaison d'inférence en ligne
- REGION : région de la requête.
Le résultat ressemble à ce qui suit :
```
serviceAttachment: projects/ac74a9f84c2e5f2a1-tp/regions/us-central1/serviceAttachments/gkedpm-c6e6a854a634dc99472bb802f503c1
```
Notez la chaîne entière dans le champ serviceAttachment. Il s'agit de l'URI de rattachement de service.

Créer une règle de transfert

Vous pouvez réserver une adresse IP interne et créer une règle de transfert avec cette adresse. Pour créer la règle de transfert, vous avez besoin de l'URI du rattachement de service de l'étape précédente.

Pour réserver une adresse IP interne pour la règle de transfert, utilisez la commande gcloud compute addresses create :
```
gcloud compute addresses create ADDRESS_NAME \
--project=VPC_PROJECT_ID \
--region=REGION \
--subnet=SUBNETWORK \
--addresses=INTERNAL_IP_ADDRESS
```
Remplacez les éléments suivants :
- ADDRESS_NAME: nom de l'adresse IP interne.
- VPC_PROJECT_ID : ID du projet Google Cloud qui héberge votre réseau VPC. Si votre point de terminaison d'inférence en ligne et votre règle de transfert Private Service Connect sont hébergés dans le même projet, utilisez VERTEX_AI_PROJECT_ID pour ce paramètre.
- REGION : région Google Cloud dans laquelle la règle de transfert Private Service Connect doit être créée
- SUBNETWORK: nom du sous-réseau VPC contenant l'adresse IP
- INTERNAL_IP_ADDRESS: adresse IP interne à réserver. Ce paramètre est facultatif.
  - Si ce paramètre est spécifié, l'adresse IP doit être comprise dans la plage d'adresses IP principale du sous-réseau. L'adresse IP peut être une adresse RFC 1918 ou un sous-réseau avec des plages non-RFC.
  - Si ce paramètre est omis, une adresse IP interne est attribuée automatiquement.
  - Pour plus d'informations, consultez la page Réserver une nouvelle adresse IPv4 ou IPv6 interne statique.
Pour vérifier que l'adresse IP est réservée, utilisez la commande gcloud compute addresses list :
```
gcloud compute addresses list --filter="name=(ADDRESS_NAME)" \
--project=VPC_PROJECT_ID
```
Dans la réponse, vérifiez qu'un état RESERVED s'affiche pour l'adresse IP.
Pour créer la règle de transfert et la faire pointer vers le rattachement de service d'inférence en ligne, utilisez la commande 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
```
Remplacez les éléments suivants :
- PSC_FORWARDING_RULE_NAME : nom de la règle de transfert.
- VPC_NETWORK_NAME : nom du réseau VPC dans lequel le point de terminaison doit être créé
- SERVICE_ATTACHMENT_URI: rattachement de service que vous avez noté précédemment.
Pour vérifier que le rattachement de service accepte le point de terminaison, utilisez la commande gcloud compute forwarding-rules describe :
```
gcloud compute forwarding-rules describe PSC_FORWARDING_RULE_NAME \
--project=VPC_PROJECT_ID \
--region=REGION
```
Dans la réponse, vérifiez qu'un état ACCEPTED s'affiche pour le champ pscConnectionStatus.

Obtenir l'adresse IP interne

Si vous n'avez pas spécifié de valeur pour INTERNAL_IP_ADDRESS lorsque vous avez créé la règle de transfert, vous pouvez obtenir l'adresse qui a été allouée automatiquement à l'aide de la commande gcloud compute forwarding-rules describe :

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

Remplacez les éléments suivants :

VERTEX_AI_PROJECT_ID : ID de votre projet.
REGION: nom de la région pour cette requête

Facultatif : Obtenir le point de terminaison PSC à partir du résultat de l'automatisation PSC

Vous pouvez obtenir l'adresse IP et la règle de transfert générées à partir du point de terminaison d'inférence. Exemple :

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

Voici quelques détails gestion des exceptions.

L'échec de l'automatisation n'a pas d'incidence sur le résultat du déploiement du modèle.
L'état indique si l'opération a réussi ou échoué.
- Si l'opération réussit, l'adresse IP et la règle de transfert s'affichent.
- Si l'opération échoue, un message d'erreur s'affiche.
Les configurations d'automatisation sont supprimées lorsqu'aucun modèle n'est déployé ou en cours de déploiement sur le point de terminaison. Cela entraîne une modification de l'adresse IP et de la règle de transfert si un modèle est déployé ultérieurement.
Les automatisations ayant échoué ne seront pas récupérées. En cas d'échec, vous pouvez toujours créer manuellement le point de terminaison PSC. Pour en savoir plus, consultez Créer manuellement un point de terminaison PSC.

Obtenir des inférences en ligne

L'obtention d'inférences en ligne à partir d'un point de terminaison avec Private Service Connect est semblable à l'obtention d'inférences en ligne à partir de points de terminaison publics, à l'exception des points suivants :

La requête doit être envoyée à partir d'un projet spécifié dans la projectAllowlist lors de la création du point de terminaison d'inférence en ligne.
Si l'accès mondial n'est pas activé, la requête doit être envoyée depuis la même région.
Deux ports sont ouverts : le port 443 avec TLS utilisant un certificat autosigné et le port 80 sans TLS. Les deux ports sont compatibles avec HTTP et gRPC. Tout le trafic reste sur votre réseau privé et ne transite pas par l'Internet public.
La bonne pratique consiste à utiliser HTTPS avec le certificat autosigné obtenu à partir de l'inférence en ligne Vertex AI ou à déployer votre propre certificat autosigné.
Pour obtenir des inférences, une connexion doit être établie à l'aide de l'adresse IP statique du point de terminaison, sauf si un enregistrement DNS est créé pour l'adresse IP interne. Par exemple, envoyez les requêtes predict au point de terminaison suivant :
```
http://INTERNAL_IP_ADDRESS/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID:predict
```
Remplacez INTERNAL_IP_ADDRESS par l'adresse IP publique que vous avez réservée précédemment.
Pour les requêtes gRPC : pour assurer une identification correcte du point de terminaison pour les requêtes gRPC, il est nécessaire d'inclure l'en-tête x-vertex-ai-endpoint-id. Cette opération est obligatoire, car les informations sur le point de terminaison ne sont pas transmises dans le chemin de requête pour la communication gRPC.

Créer un enregistrement DNS pour l'adresse IP interne

Nous vous recommandons de créer un enregistrement DNS afin de pouvoir obtenir des inférences en ligne à partir de votre point de terminaison sans avoir à spécifier l'adresse IP interne.

Pour en savoir plus, consultez la section Autres méthodes de configuration du DNS.

Créez une zone DNS privée à l'aide de la commande gcloud dns managed-zones create. Cette zone est associée au réseau VPC dans lequel la règle de transfert a été créée.

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

Remplacez les éléments suivants :

ZONE_NAME : nom de la zone DNS

Pour créer un enregistrement DNS dans la zone, utilisez la commande 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
```
Remplacez les éléments suivants :
- VERTEX_AI_PROJECT_NUMBER : numéro de votre projet VERTEX_AI_PROJECT_ID. Vous trouverez ce numéro de projet dans la console Google Cloud . Pour en savoir plus, consultez Identifier des projets.
- INTERNAL_IP_ADDRESS : adresse IP interne de votre point de terminaison d'inférence en ligne
Vous pouvez maintenant envoyer vos requêtes predict à :
```
http://ENDPOINT_ID-REGION-VERTEX_AI_PROJECT_NUMBER.prediction.p.vertexai.goog/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID:predict
```

Prise en charge des certificats TLS (Transport Layer Security)

L'inférence en ligne Vertex AI est sécurisée à l'aide d'un certificat autosigné. Étant donné que ce certificat n'est pas signé par une autorité de certification (CA) de confiance, les clients qui tentent d'établir une connexion HTTPS doivent être explicitement configurés pour lui faire confiance. Le certificat autosigné obtenu à partir du point de terminaison d'inférence en ligne Vertex AI est valable 10 ans. Étant donné que ce certificat n'est pas propre à un point de terminaison spécifique, un seul certificat peut être utilisé pour toutes les intégrations du magasin de confiance. Voici les grandes étapes à suivre pour établir une connexion HTTPS à l'inférence en ligne Vertex AI :

Configurer le DNS : le certificat autosigné inclut le nom alternatif de sujet (SAN) *.prediction.p.vertexai.goog. Vous devez créer un enregistrement DNS dans votre réseau qui correspond à ce format.

Pour en savoir plus sur l'implémentation, consultez Créer un enregistrement DNS pour l'adresse IP interne.
Établir la confiance du client : le client doit télécharger le certificat auto-signé et l'ajouter à son magasin de confiance local.
Établir une connexion HTTPS : pour établir une connexion HTTPS à l'inférence en ligne Vertex AI, vous devez utiliser le nom de domaine complet (FQDN). Cette étape est nécessaire, car le service utilise un certificat SSL générique valide pour le domaine *.prediction.p.vertexai.goog.

Les étapes suivantes expliquent comment télécharger le certificat d'inférence en ligne Vertex AI et l'ajouter au magasin de certificats approuvés local sur les systèmes Linux basés sur Debian, tels que Debian 11 et Ubuntu.

Mettez à jour les packages de l'OS et installez OpenSSL :
```
sudo apt update && sudo apt install openssl
```
Exécutez la commande suivante depuis votre répertoire d'accueil pour télécharger le certificat d'inférence en ligne Vertex AI et l'enregistrer dans un fichier nommé vertex_certificate.crt dans votre répertoire actuel. Effectuez les remplacements suivants :
- ENDPOINT_ID : ID du point de terminaison du modèle déployé
- REGION : région où se trouve votre point de terminaison
- VERTEX_AI_PROJECT_NUMBER : numéro de votre projet. Vous trouverez ce numéro de projet dans la console Google Cloud . Pour en savoir plus, consultez Identifier des projets.
```
openssl s_client -showcerts -connect \
ENDPOINT_ID-REGION-VERTEX_AI_PROJECT_NUMBER.prediction.p.vertexai.goog:443 </dev/null | \
openssl x509 -outform pem -out vertex_certificate.crt
```

Déplacez le certificat vers le truststore du système :

sudo mv vertex_certificate.crt /usr/local/share/ca-certificates

Mettez à jour la liste des autorités de certification de confiance du gestionnaire de certificats. Un message de confirmation indiquant qu'un certificat a été ajouté doit s'afficher.
```
sudo update-ca-certificates
```
Envoyez une requête predict à l'URL suivante, en effectuant les remplacements suivants :
- INTERNAL_IP_ADDRESS : adresse IP interne de votre point de terminaison d'inférence en ligne
- VERTEX_AI_PROJECT_ID : ID de votre projet
```
https://ENDPOINT_ID-REGION-VERTEX_AI_PROJECT_NUMBER.prediction.p.vertexai.goog/v1/projects/VERTEX_AI_PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID:predict
```

Compatibilité avec les certificats personnalisés pour TLS

Pour les organisations qui ont besoin d'un contrôle précis de la gestion et de la rotation des certificats pour les points de terminaison d'inférence en ligne Vertex AI, vous pouvez utiliser un certificat géré par le client avec un équilibreur de charge d'application (HTTPS) régional Google Cloud.

Cette architecture fonctionne avec le certificat Vertex AI par défaut, ce qui vous donne un contrôle direct.

Voici les principales étapes de déploiement :

Créez un certificat géré par le client :
- Générez un certificat autosigné (ou utilisez votre autorité de certification) pour un domaine personnalisé.
- Ce domaine doit utiliser le suffixe .prediction.p.vertexai.goog pour correspondre au certificat générique Vertex AI, par exemple my-endpoint.prediction.vertexai.goog.
Déployez un équilibreur de charge d'application régional (HTTPS) :
- Configurez l'équilibreur de charge pour qu'il utilise votre certificat géré par le client pour son interface HTTPS.
- Définissez le service de backend sur un groupe de points de terminaison du réseau (NEG) Private Service Connect (PSC). Ce NEG pointera vers le service publié de l'attachement de service de votre point de terminaison de modèle Vertex AI.
Configurez les paramètres DNS :
- Créez un enregistrement DNS A dans votre zone DNS.
- Cet enregistrement doit mapper votre domaine personnalisé complet (par exemple, my-endpoint.prediction.p.vertexai.goog) à l'adresse IP de l'équilibreur de charge d'application régional.
Mettez à jour le truststore local :
- Pour que le client authentifie le serveur, le certificat de l'équilibreur de charge d'application (ou son autorité de certification émettrice) doit être importé dans le magasin de confiance local.

Vous pouvez maintenant envoyer vos requêtes de prédiction au domaine personnalisé complet :

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

Exemples d'obtention d'inférences en ligne

Les sections suivantes fournissent des exemples d'envoi de la requête predict à l'aide de Python.

Premier exemple

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)

Remplacez PATH_TO_INPUT_FILE par le chemin d'accès à un fichier JSON contenant l'entrée de requête.

Deuxième exemple

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#access-tokens
# for token lifetimes.

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())

Troisième exemple

Voici un exemple d'envoi de la requête predict à la zone DNS à l'aide de 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)

Remplacez DNS_NAME par le nom DNS que vous avez spécifié dans la commande gcloud dns record-sets create.

Bonnes pratiques

Lorsqu'un nouveau point de terminaison est déployé, le rattachement de service peut être mis à jour. Vérifiez toujours l'état du rattachement de service et du point de terminaison PSC avant d'effectuer l'appel d'inférence. Voici quelques bonnes pratiques à suivre :

Si un point de terminaison ne comporte aucun déploiement actif, Vertex AI peut supprimer l'association de service et la recréer. Assurez-vous que le point de terminaison PSC est dans un état connecté (en recréant la règle de transfert) lorsque le rattachement de service est recréé.
Lorsqu'un point de terminaison comporte un modèle déployé actif, le rattachement de service ne change pas. Pour conserver l'association de service, créez une répartition du trafic et migrez progressivement le trafic vers la nouvelle version du modèle avant de supprimer le déploiement de l'ancienne version.
Vertex AI autorise jusqu'à 1 000 connexions par attachement de service.
La règle de transfert est également soumise à une limite de quota. Pour en savoir plus, consultez Quotas et limites de Cloud Load Balancing.

Limites

Les points de terminaison Vertex AI avec Private Service Connect sont soumis aux limites suivantes :

Le déploiement de modèles Gemini réglés n'est pas pris en charge.
La sortie privée depuis le point de terminaison n'est pas acceptée. Comme les règles de transfert Private Service Connect sont unidirectionnelles, les autres charges de travailGoogle Cloud privées ne sont pas accessibles dans votre conteneur.
Impossible de modifier la valeur projectAllowlist d'un point de terminaison.
Vertex Explainable AI n'est pas compatible.
Avant de supprimer un point de terminaison, vous devez annuler le déploiement de votre modèle sur ce point de terminaison.
Si le déploiement de tous les modèles est annulé pendant plus de 10 minutes, le rattachement de service peut être supprimé. Vérifiez l'état de la connexion Private Service Connect. S'il est CLOSED, recréez la règle de transfert.
Une fois votre point de terminaison supprimé, vous ne pourrez pas réutiliser son nom pendant sept jours maximum.
Un projet peut comporter jusqu'à 10 valeurs projectAllowlist différentes dans ses configurations Private Service Connect.

Utiliser des points de terminaison privés dédiés basés sur Private Service Connect pour l'inférence en ligne Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Rôles requis

Créer le point de terminaison d'inférence en ligne

Console

API

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Python

Créer le point de terminaison d'inférence en ligne avec l'automatisation PSC (preview)

Limites

Créer une règle de connexion de service

Créer le point de terminaison d'inférence en ligne avec la configuration d'automatisation PSC

REST

curl (Linux, macOS ou Cloud Shell)

PowerShell (Windows)

Python

Déployer le modèle

Créer manuellement un point de terminaison PSC

Obtenir l'URI du rattachement de service

Créer une règle de transfert

Obtenir l'adresse IP interne

Facultatif : Obtenir le point de terminaison PSC à partir du résultat de l'automatisation PSC

Obtenir des inférences en ligne

Créer un enregistrement DNS pour l'adresse IP interne

Prise en charge des certificats TLS (Transport Layer Security)

Compatibilité avec les certificats personnalisés pour TLS

Exemples d'obtention d'inférences en ligne

Premier exemple

Deuxième exemple

Troisième exemple

Bonnes pratiques

Limites

Étapes suivantes

Utiliser des points de terminaison privés dédiés basés sur Private Service Connect pour l'inférence en ligne