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

Accéder aux API Google globales via des backends

Cette page explique comment accéder aux API Google globales à l'aide de backends Private Service Connect basés sur des équilibreurs de charge d'application internes interrégionaux.

Cette configuration vous permet de cibler une ou plusieurs API Google globales individuelles tout en appliquant la visibilité et le contrôle fournis par les backends Private Service Connect.

Vous pouvez configurer des noms d'hôte personnalisés, locaux à votre cloud privé virtuel (VPC) et aux réseaux sur site connectés, qui acheminent le trafic vers les API Google globales de votre choix.
Vous pouvez accéder aux backends depuis n'importe quelle région, et le backend peut équilibrer la charge du trafic vers les groupes de points de terminaison du réseau (NEG) Private Service Connect situés dans n'importe quelle région.
Vous pouvez envoyer du trafic aux backends à partir de réseaux VPC associés.

Pour obtenir la liste des API Google globales disponibles, consultez la section Cibles d'API Google globales.

Avant de commencer

Pour obtenir les autorisations nécessaires pour configurer un backend afin d'accéder aux API Google globales, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet Google Cloud:
- Administrateur de Compute (roles/compute.admin)
- Propriétaire du gestionnaire de certificats (roles/certificatemanager.owner)
Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.
Activez l'API Compute Engine dans votre projet.
Activez l'API Certificate Manager dans votre projet.
Créez une clé privée et un certificat signé à partir d'une autorité de certification (CA). Suivez les instructions de l'Étape 1: Créer une clé privée et un certificat. La clé privée et le certificat sont nécessaires pour créer un certificat SSL autogéré avec le Gestionnaire de certificats.
Créez une ressource de certificat pour un équilibreur de charge d'application interne interrégional à l'aide de la clé privée et du certificat signé que vous avez créés. Lorsque vous importez le certificat, vous devez définir la portée sur all-regions. Pour en savoir plus, consultez Importer un certificat autogéré dans le gestionnaire de certificats. La ressource de certificat est nécessaire pour configurer le proxy HTTPS cible de l'équilibreur de charge.
Créez un sous-réseau proxy réservé si vous n'en avez pas déjà un. Il doit y avoir un seul sous-réseau proxy réservé dans le réseau VPC et la région dans lesquels vous souhaitez créer la règle de transfert de l'équilibreur de charge d'application interne interrégional. Ce sous-réseau est utilisé par tous les équilibreurs de charge d'application internes dans ce réseau et cette région.

Créer un NEG Private Service Connect

Pour chaque API Google globale à laquelle vous souhaitez accéder, créez un NEG Private Service Connect. Les NEG Private Service Connect sont régionaux, même lorsqu'ils sont utilisés pour se connecter aux API Google globales.

Un NEG Private Service Connect ne peut pas être mis à jour une fois créé.

Console

Dans la console Google Cloud, accédez à la page Créer un groupe de points de terminaison du réseau.

Accéder à "Créer un groupe de points de terminaison du réseau"
Sur la page Créer un groupe de points de terminaison du réseau, saisissez un nom pour le groupe de points de terminaison du réseau.
Pour le type de groupe de points de terminaison du réseau, sélectionnez Private Service Connect NEG (régional).
Pour Cible, sélectionnez API Google globales.
Sélectionnez la région du groupe de points de terminaison du réseau.
Sélectionnez le service cible du groupe de points de terminaison du réseau.
Cliquez sur Créer.

gcloud

Exécutez la commande network-endpoint-groups create.

gcloud compute network-endpoint-groups create NEG_NAME \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=TARGET_SERVICE \
    --region=REGION

Remplacez les éléments suivants :

NEG_NAME : nom du groupe de points de terminaison du réseau.
TARGET_SERVICE: cible de l'API Google globale à laquelle vous souhaitez vous connecter (par exemple, pubsub.googleapis.com). Consultez la liste des cibles d'API Google globales compatibles.
REGION : région dans laquelle créer le groupe de points de terminaison du réseau.

API

Envoyez une requête POST à la méthode regionNetworkEndpointGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/networkEndpointGroups
{
  "name": "NEG_NAME",
  "networkEndpointType": "PRIVATE_SERVICE_CONNECT",
  "pscTargetService": "TARGET_SERVICE"
}

Remplacez les éléments suivants :

PROJECT_ID: ID de projet du groupe de points de terminaison du réseau.
REGION : région dans laquelle créer le groupe de points de terminaison du réseau.
NEG_NAME : nom du groupe de points de terminaison du réseau.
TARGET_SERVICE: cible de l'API Google globale à laquelle vous souhaitez vous connecter (par exemple, pubsub.googleapis.com). Consultez la liste des cibles d'API Google globales compatibles.

Configurer l'équilibreur de charge

Pour accéder aux API Google globales, configurez un équilibreur de charge d'application interne interrégional.

Console

Démarrer la configuration

Dans Google Cloud Console, accédez à la page Équilibrage de charge.

Accéder à la page "Équilibrage de charge"
Cliquez sur Créer un équilibreur de charge.
Dans le champ Type d'équilibreur de charge, sélectionnez Équilibreur de charge d'application (HTTP/HTTPS), puis cliquez sur Suivant.
Pour Public ou interne, sélectionnez Interne, puis cliquez sur Suivant.
Pour Déploiement interrégional ou régional, sélectionnez Recommandé pour les charges de travail interrégionales, puis cliquez sur Suivant.
Cliquez sur Configurer.

Configuration de base

Dans le champ Name (Nom), saisissez le nom de l'équilibreur de charge.
Sélectionnez un réseau pour l'équilibreur de charge.

Le réseau doit contenir un sous-réseau proxy réservé dans la région dans laquelle vous créez l'équilibreur de charge.

Configuration du frontend

Cliquez sur Configuration de l'interface.
Saisissez un nom pour la règle de transfert de l'équilibreur de charge.
Dans le champ Protocole, sélectionnez HTTPS (inclut HTTP/2 et HTTP/3).
Sélectionnez une région de sous-réseau pour le sous-réseau de l'équilibreur de charge.
Sélectionnez un sous-réseau pour l'équilibreur de charge.
Cliquez sur Adresse IP, puis effectuez l'une des opérations suivantes :
- Pour attribuer automatiquement une adresse IP éphémère, sélectionnez Éphémère (automatique).
- Pour choisir une adresse IP éphémère, sélectionnez Éphémère (personnalisée), puis saisissez une adresse IP éphémère personnalisée à partir de la plage d'adresses IP du sous-réseau de l'équilibreur de charge.
- Pour réserver et utiliser une adresse IP interne statique, cliquez sur Créer une adresse IP, puis procédez comme suit :
  1. Saisissez un nom pour l'adresse IP.
  2. Cliquez sur Adresse IP statique, puis effectuez l'une des opérations suivantes :
    - Pour attribuer automatiquement une adresse IP statique, sélectionnez Attribuer automatiquement.
    - Pour configurer une adresse IP spécifique, sélectionnez Laissez-moi choisir, puis saisissez une adresse IP personnalisée dans la plage d'adresses IP du sous-réseau de l'équilibreur de charge.
  3. Cliquez sur Réserver.
Assurez-vous que le champ Port est défini sur 443 pour autoriser le trafic HTTPS.
Cliquez sur la liste Certificat, puis sélectionnez votre certificat autogéré.
Cliquez sur OK.

Configuration du backend

Cliquez sur Configuration du backend.
Pour chaque API Google globale à laquelle vous souhaitez accéder, créez un service de backend global. Pour créer un service de backend global, procédez comme suit:
1. Dans le menu Créer ou sélectionner des services de backend, sélectionnez Créer un service backend.
2. Dans le champ Name (Nom), saisissez le nom du service de backend.
3. Définissez le type de backend sur Groupe de points de terminaison du réseau Private Service Connect.
4. Définissez le type de cible Private Service Connect sur API Google globale.
5. Sélectionnez HTTPS pour le protocole.
6. Dans la section Backends, cliquez sur le menu Nouveau backend, puis sélectionnez un groupe de points de terminaison du réseau Private Service Connect.
  
  Si vous devez créer un groupe de points de terminaison du réseau Private Service Connect, cliquez sur Créer un NEG PSC.
7. Cliquez sur OK.
8. Cliquez sur Créer.
Assurez-vous que chaque service de backend que vous souhaitez ajouter est sélectionné dans le menu Créer ou sélectionner des services de backend, puis cliquez sur OK.

Règles de routage

L'ensemble de règles permettant d'acheminer les requêtes HTTPS entrantes vers des services de backend spécifiques est appelé un mappage d'URL. Pour en savoir plus sur les mappages d'URL, consultez Présentation des mappages d'URL.

Si vous ne configurez qu'un seul service de backend pour l'équilibreur de charge, la règle de routage par défaut est suffisante et vous pouvez passer directement à la section Vérification et finalisation.

Si vous configurez plusieurs services de backend, vous devez créer un outil de mise en correspondance des chemins d'accès pour chaque service de backend. Chaque règle d'hôte ne peut référencer qu'un seul outil de mise en correspondance des chemins d'accès, mais deux règles d'hôte ou plus peuvent faire référence à un même outil de mise en correspondance des chemins d'accès.

Si vous possédez plusieurs services de backend, cliquez sur Règles de routage.
Sélectionnez Règle simple d'hôte et de chemin d'accès.
Pour chaque backend, procédez comme suit :
1. Cliquez sur Ajouter une règle d'hôte et de chemin d'accès.
2. Dans le champ Hôte, saisissez le nom d'hôte qui servira à envoyer des requêtes à ce service, par exemple pubsub.example.com.
3. Dans le champ Chemins d'accès, saisissez le chemin d'accès, par exemple, /*.
4. Pour Backends, sélectionnez le service de backend.

Vérifier et finaliser

Cliquez sur Vérifier et finaliser pour vérifier la configuration.
Cliquez sur Créer.

gcloud

Pour chaque API Google globale à laquelle vous souhaitez accéder, procédez comme suit:
1. Pour créer un service de backend global, utilisez la commande gcloud compute backend-services create.
```
gcloud compute backend-services create BACKEND_SERVICE_NAME \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --protocol=HTTPS \
    --global
```
  Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.
2. Pour ajouter un NEG au service de backend correspondant, utilisez la commande gcloud compute backend-services add-backend.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
    --network-endpoint-group=NEG_NAME \
    --network-endpoint-group-region=REGION \
    --global
```
  Remplacez les éléments suivants :
  - NEG_NAME: nom du NEG Private Service Connect.
  - REGION: région du NEG Private Service Connect.
Pour créer un mappage d'URL global pour l'équilibreur de charge, exécutez la commande gcloud compute url-maps create.

Un mappage d'URL doit faire référence à un service de backend par défaut. Si vous configurez votre équilibreur de charge avec un service de backend, définissez ce service de backend par défaut. Si vous configurez votre équilibreur de charge pour qu'il utilise plusieurs services de backend, choisissez l'un des services de backend comme mappage d'URL par défaut.
```
gcloud compute url-maps create URL_MAP_NAME \
    --default-service=DEFAULT_BACKEND_SERVICE_NAME
```
Remplacez les éléments suivants :
- URL_MAP_NAME : nom du mappage d'URL.
- DEFAULT_BACKEND_SERVICE_NAME : nom du service de backend par défaut de l'équilibreur de charge. La valeur par défaut est utilisée lorsqu'aucune règle d'hôte ne correspond au nom d'hôte demandé.
Facultatif: Si vous configurez votre équilibreur de charge pour qu'il utilise plusieurs services de backend, suivez cette étape. Si votre mappage d'URL ne fait référence qu'à un seul service de backend, ignorez cette étape.

Pour ajouter des services de backend supplémentaires au mappage d'URL, utilisez la commande gcloud compute url-maps add-path-matcher.

Pour chaque service de backend, ajoutez un outil de mise en correspondance des chemins d'accès et une ou plusieurs règles d'hôte. Vous devez créer un outil de mise en correspondance des chemins d'accès pour chaque service de backend. Chaque règle d'hôte ne peut référencer qu'un seul outil de mise en correspondance des chemins d'accès, mais deux règles d'hôte ou plus peuvent faire référence à un même outil de mise en correspondance des chemins d'accès.
```
gcloud compute url-maps add-path-matcher URL_MAP_NAME \
    --path-matcher-name=PATH_MATCHER \
    --default-service=BACKEND_SERVICE_NAME \
    --new-hosts=HOSTNAMES
```
Remplacez les éléments suivants :
- PATH_MATCHER : nom de l'outil de mise en correspondance des chemins d'accès.
- BACKEND_SERVICE_NAME : nom du service de backend.
- HOSTNAMES: un ou plusieurs noms d'hôte auxquels envoyer des requêtes pour le service de backend (par exemple, pubsub.example.com). Vous pouvez fournir plusieurs noms d'hôte dans une liste séparée par des virgules.
Pour créer un proxy HTTPS cible, utilisez la commande gcloud compute target-https-proxies create.
```
gcloud compute target-https-proxies create PROXY_NAME \
    --url-map=URL_MAP_NAME \
    --certificate-manager-certificates=CERTIFICATE_NAME
```
Remplacez les éléments suivants :
- PROXY_NAME : nom du proxy HTTPS cible.
- URL_MAP_NAME : nom du mappage d'URL.
- CERTIFICATE_NAME: nom de la ressource de certificat.
Pour créer une règle de transfert globale pour votre équilibreur de charge, utilisez la commande gcloud compute forwarding-rules create.
```
gcloud compute forwarding-rules create RULE_NAME \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --network=NETWORK \
    --address=IP_ADDRESS \
    --ports=443 \
    --target-https-proxy=PROXY_NAME \
    --subnet=SUBNET \
    --subnet-region=SUBNET_REGION \
    --global
```
Remplacez les éléments suivants :
- RULE_NAME : nom de la règle de transfert.
- NETWORK: réseau VPC de la règle de transfert. Ce réseau doit contenir un sous-réseau proxy réservé dans la région dans laquelle vous créez l'équilibreur de charge.
- IP_ADDRESS: adresse IP interne de la règle de transfert, qui doit être comprise dans la plage d'adresses IP du sous-réseau de la règle de transfert. Pour utiliser une adresse IP éphémère spécifique, saisissez l'adresse IP (par exemple, 10.0.0.5). Pour utiliser une adresse IP interne statique, saisissez son nom. Pour permettre à Google Cloud de sélectionner une adresse IP éphémère, omettez cet indicateur.
- SUBNET: sous-réseau de la règle de transfert.
- SUBNET_REGION: région du sous-réseau de la règle de transfert.

API

Pour chaque API Google globale à laquelle vous souhaitez accéder, procédez comme suit:
1. Pour créer un service de backend global, envoyez une requête POST à la méthode backendServices.insert.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices
{
  "loadBalancingScheme": "INTERNAL_MANAGED",
  "name": "BACKEND_SERVICE_NAME",
  "protocol": "HTTPS"
}
```
  Remplacez les éléments suivants :
  - PROJECT_ID: ID de votre projet.
  - BACKEND_SERVICE_NAME : nom du service de backend.
2. Pour ajouter un NEG au service de backend correspondant, envoyez une requête PATCH à la méthode backendServices.patch.
```
PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
{
  "backends": [
    {
      "group": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/networkEndpointGroups/NEG_NAME"
    }
  ]
}
```
  Remplacez les éléments suivants :
  - REGION: région du NEG.
  - NEG_NAME: nom du groupe de points de terminaison du réseau à ajouter.
Pour créer un mappage d'URL global pour l'équilibreur de charge, envoyez une requête POST à la méthode urlMaps.insert.

Un mappage d'URL doit faire référence à un service de backend par défaut. Si vous configurez votre équilibreur de charge avec un service de backend, définissez ce service de backend par défaut. Si vous configurez votre équilibreur de charge pour qu'il utilise plusieurs services de backend, choisissez l'un des services de backend comme mappage d'URL par défaut.
```
 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/urlMaps
 {
   "defaultService": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/DEFAULT_BACKEND_SERVICE_NAME",
   "name": "URL_MAP_NAME"
 }
 
```
Remplacez les éléments suivants :
- DEFAULT_BACKEND_SERVICE_NAME : nom de la valeur par défaut de l'équilibreur de charge. La valeur par défaut est utilisée lorsqu'aucune règle d'hôte ne correspond au nom d'hôte demandé.
- URL_MAP_NAME : nom du mappage d'URL.
Si vous configurez votre équilibreur de charge pour qu'il utilise plusieurs services de backend, suivez cette étape. Si votre mappage d'URL ne fait référence qu'à un seul service de backend, ignorez cette étape.

Pour ajouter des services de backend supplémentaires au mappage d'URL, envoyez une requête PATCH à la méthode urlMaps.patch.

Pour chaque service de backend, ajoutez un outil de mise en correspondance des chemins d'accès et une ou plusieurs règles d'hôte. Vous devez créer un outil de mise en correspondance des chemins d'accès pour chaque service de backend. Chaque règle d'hôte ne peut référencer qu'un seul outil de mise en correspondance des chemins d'accès, mais deux règles d'hôte ou plus peuvent faire référence à un même outil de mise en correspondance des chemins d'accès.

Vous pouvez ajouter plusieurs outils de mise en correspondance des chemins d'accès et règles d'hôte en effectuant une seule requête API.
```
 PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/urlMaps/URL_MAP_NAME
 {
   "pathMatchers": [
     {
       "name": "PATH_MATCHER_NAME_1",
       "defaultService": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME_1"
     },
     {
       "name": "PATH_MATCHER_NAME_2",
       "defaultService": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME_2"
     }
   ],
   "hostRules": [
     {
       "hosts": ["HOSTNAME_1"],
       "pathMatcher": "PATH_MATCHER_NAME_1"
     },
     {
       "hosts": ["HOSTNAME_2"],
       "pathMatcher": "PATH_MATCHER_NAME_2"
     }
   ]
 }
 
```
Remplacez les éléments suivants :
- PATH_MATCHER_NAME_1: nom du premier outil de mise en correspondance des chemins d'accès.
- BACKEND_SERVICE_NAME_1: nom du premier service de backend.
- PATH_MATCHER_NAME_2: nom du deuxième outil de mise en correspondance des chemins d'accès.
- BACKEND_SERVICE_NAME_2: nom du deuxième service de backend.
- HOSTNAME_1: nom d'hôte auquel envoyer les requêtes pour le premier service (par exemple, pubsub.example.com).
- HOSTNAME_2: nom de l'hôte auquel envoyer les requêtes pour le deuxième service.

Pour créer un proxy HTTPS cible, envoyez une requête POST à la méthode targetHttpsProxies.insert.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpsProxies
 {
   "name": "PROXY_NAME",
   "sslCertificates": [
     "https://certificatemanager.googleapis.com/v1/projects/PROJECT_ID/locations/global/certificates/CERTIFICATE_NAME"
   ],
   "urlMap": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/urlMaps/URL_MAP_NAME"
 }

Remplacez les éléments suivants :

PROJECT_ID : ID du projet.
PROXY_NAME : nom du proxy HTTPS cible.
CERTIFICATE_NAME: nom de la ressource de certificat.
URL_MAP_NAME : nom du mappage d'URL.

Pour créer une règle de transfert globale pour votre équilibreur de charge, envoyez une requête POST à la méthode globalForwardingRules.insert. Le réseau de la règle de transfert doit contenir un sous-réseau proxy réservé dans le sous-réseau de la région de votre règle de transfert.
```
 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules
 {
   "IPAddress": "IP_ADDRESS",
   "loadBalancingScheme": "INTERNAL_MANAGED",
   "name": "FORWARDING_RULE_NAME",
   "network": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/NETWORK_NAME",
   "portRange": "443",
   "subnetwork": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/SUBNET_REGION/subnetworks/SUBNET_NAME",
   "target": "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpsProxies/PROXY_NAME"
 }
 
```
Remplacez les éléments suivants :
- IP_ADDRESS: adresse IP interne de la règle de transfert, qui doit être comprise dans la plage d'adresses IP du sous-réseau de la règle de transfert. Pour utiliser une adresse IP éphémère spécifique, indiquez l'adresse IP (par exemple, 10.0.0.5). Pour utiliser une adresse IP interne statique, indiquez son nom. Pour laisser Google Cloud sélectionner une adresse IP éphémère, omettez ce champ.
- FORWARDING_RULE_NAME : nom de la règle de transfert.
- NETWORK_NAME: nom du réseau VPC de la règle de transfert. Ce réseau doit contenir un sous-réseau proxy réservé dans la région dans laquelle vous créez l'équilibreur de charge.
- SUBNET_REGION: région du sous-réseau de la règle de transfert.
- SUBNET_NAME: nom du sous-réseau de la règle de transfert.

Vérifier la configuration

Pour tester la connexion de votre backend aux API Google globales, procédez comme suit:

Si vous n'en avez pas, créez une instance de machine virtuelle (VM) dans le réseau VPC sur lequel vous avez configuré le backend.
Assurez-vous de ne pas avoir créé de règles de pare-feu ni de stratégies de pare-feu qui remplacent la règle implicite d'autorisation du trafic sortant pour IPv4.
Connectez-vous à la VM.
À partir de la VM, utilisez curl pour vérifier que vous pouvez interroger chaque API. Cette commande définit l'en-tête Host et contourne la résolution DNS en spécifiant une adresse IP définie par l'utilisateur.

Vous pouvez ignorer la validation du certificat à l'aide de l'option -k. Vous devrez peut-être ignorer la validation si vous avez utilisé un certificat autosigné pour configurer le proxy HTTPS cible ou si la VM ne dispose pas du certificat de l'autorité de certification qui a signé votre certificat.
```
curl -iv --resolve HOSTNAME:443:IP_ADDRESS \
   'https://HOSTNAME/RESOURCE_URI'
```
Remplacez les éléments suivants :
- HOSTNAME: nom d'hôte que vous avez configuré dans votre mappage d'URL (par exemple, pubsub.example.com).
- IP_ADDRESS: adresse IP de la règle de transfert de votre équilibreur de charge.
- RESOURCE_URI : reste de l'URI de la ressource que vous souhaitez utiliser pour la validation. Par exemple, si l'équilibreur de charge transfère les requêtes vers un point de terminaison régional pour Pub/Sub, vous pouvez utiliser $discovery/rest?version=v1.

Configurer les enregistrements DNS

Configurez les enregistrements DNS de chaque hôte ajouté au mappage d'URL, en pointant vers l'adresse IP de la règle de transfert. Si vous gérez le DNS à l'aide de Cloud DNS, consultez la section Ajouter, modifier et supprimer des enregistrements. Sinon, configurez les enregistrements DNS sur votre serveur DNS.

Par exemple, supposons que vous ayez créé les configurations suivantes:

Un NEG Private Service Connect qui utilise le service cible pubsub.googleapis.com.
Un équilibreur de charge d'application interne interrégional qui utilise ce NEG Private Service Connect en tant que backend.
Un mappage d'URL qui définit une règle d'hôte pour pubsub.example.com.

Pour que cette configuration fonctionne correctement, vous devez créer un enregistrement DNS qui pointe pubsub.example.com vers l'adresse IP de la règle de transfert.

Avec cette configuration, toutes les requêtes envoyées à pubsub.example.com sont envoyées à l'équilibreur de charge, qui transfère la requête à pubsub.googleapis.com.

Configurer les clients pour qu'ils envoient des requêtes au backend

Pour envoyer des requêtes via le backend au lieu des points de terminaison de service publics, vous devez configurer les clients pour qu'ils envoient des requêtes au nom d'hôte que vous avez défini dans le mappage d'URL de l'équilibreur de charge (par exemple, pubsub.example.com). Consultez la documentation de votre client ou de votre bibliothèque cliente, afin de savoir comment le configurer pour qu'il utilise des points de terminaison personnalisés. Les pages suivantes incluent les étapes de configuration pour certains clients courants:

Python : vous pouvez configurer api_endpoint dans la section Options client.
Go : vous pouvez configurer WithEndpoint dans ClientOptions.
.NET : vous pouvez configurer Endpoint dans la classe de compilateur du client.
gcloud : vous pouvez configurer api_endpoint_overrides dans la gcloud CLI.