Provisionner une organisation d'évaluation sans appairage de VPC

Cette page s'applique à Apigee, mais pas à Apigee hybrid.

Consultez la documentation d'Apigee Edge.

Ce document explique comment installer et configurer une organisation d'évaluation Apigee à partir de la ligne de commande sans appairage de VPC. Les organisations d'évaluation expirent au bout de 60 jours et peuvent présenter d'autres limites. Consultez également la section Comparer les organisations d'évaluation et payantes.

Limites

L'option d'installation sans appairage de VPC décrite dans ce document présente certaines limites :

VPC Service Controls n'est pas compatible.
L'appairage DNS privé n'est pas compatible.

Pour obtenir la liste complète des fonctionnalités et des approches de mise en réseau compatibles ou non avec la configuration sans appairage de VPC, consultez la section Choisir une option de mise en réseau.

Résumé des étapes

Les étapes de provisionnement sont les suivantes :

Étape 1 : Définissez des variables d'environnement : configurez gcloud définissez des variables d'environnement. Google Cloud CLI gère l'authentification, la configuration locale, le workflow du développeur et les interactions avec les API Google Cloud.
Étape 2 : Activez les API : Apigee nécessite l'activation de plusieurs API Google Cloud.
Étape 3 : Créez une organisation : une organisation Apigee (parfois appelée "org") est le conteneur de niveau supérieur dans Apigee. Elle comprend tous vos environnements et groupes d'environnement, vos utilisateurs, vos proxy d'API et les ressources associées.
Étape 4 : Configurez le routage : autorisez l'accès externe ou seulement l'accès interne à votre API.
Étape 5 : Appelez l'exemple de proxy d'API : testez le provisionnement en déployant et en appelant un proxy d'API.

Étape 1 : Définissez des variables d'environnement

Configurez gcloud et définissez les variables d'environnement à utiliser dans les étapes suivantes :

Assurez-vous de respecter les exigences répertoriées dans la section Prérequis.
Vous devez auparavant avoir installé gcloud CLI. Si vous devez l'installer, consultez la page Installer gcloud CLI.
Initialisez gcloud CLI comme décrit dans la section Initialiser gcloud CLI ou, si la CLI est déjà initialisée, assurez-vous que le projet Google Cloud que vous avez créé dans la section Prérequis est le projet par défaut pour gcloud.
Définissez les variables d'environnement suivantes :
```
AUTH="Authorization: Bearer $(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
ANALYTICS_REGION="YOUR_ANALYTICS_REGION"
```
Où :
- AUTH définit l'en-tête Authentication avec un jeton de support. Vous utiliserez cet en-tête lors de l'appel des API Apigee. Notez que le jeton expire après un certain temps. Si c'est le cas, il vous suffit de le générer à nouveau en exécutant la même commande. Pour en savoir plus, consultez la page de référence sur la commande print-access-token.
- PROJECT_ID est l'ID du projet Cloud que vous avez créé dans la section Prérequis.
- RUNTIME_LOCATION est l'emplacement physique où se trouve l'instance Apigee. Pour obtenir la liste des emplacements d'exécution disponibles, consultez la section Emplacements Apigee.
  
  Remarque : Pour RUNTIME_LOCATION, veillez à utiliser un nom de région et non un nom de zone. Par exemple, us-west1 est un nom de région, tandis que us-west1-a est une zone de la région. Consultez également la section Identifier une région ou une zone.
- ANALYTICS_REGION est l'emplacement physique dans lequel vous stockerez les données d'analyse Apigee. Pour obtenir la liste des régions Apigee API Analytics disponibles, consultez la page Emplacements Apigee.
  
  RUNTIME_LOCATION et ANALYTICS_REGION peuvent se trouver dans la même région, mais pas nécessairement. Toutefois, si elles sont identiques, cela peut améliorer les performances.
(Facultatif) Vérifiez votre travail en répercutant les valeurs que vous venez de définir. Notez que lorsque vous souhaitez utiliser une variable dans vos commandes, faites précéder le nom de la variable d'un signe dollar ($).
```
echo $AUTH
echo $PROJECT_ID
echo $RUNTIME_LOCATION
echo $ANALYTICS_REGION
```
Les réponses à vos commandes echo doivent se présenter comme suit :
```
Authorization: Bearer ya29.a123456678940B63hPSAMPLEsampleKKYVsample0f3pWDWZDuH2-hENkNa
TvgZ1PD977TMvv6edBQPJezdHw040880Ol_LoD5ZDkt-i-knizia_KhA9L20sSvztL81-SAMPLE42ELPMASk2_
1CxN
my-cloud-project
us-west1
us-west1
```

Étape 2 : Activez les API

Autorisations requises pour cette tâche

Vous pouvez attribuer à l'approvisionneur Apigee un rôle prédéfini qui inclut les autorisations nécessaires pour effectuer cette tâche, ou définir des autorisations plus précises selon le principe du moindre privilège. Consultez les sections Rôles prédéfinis et Autorisations d'activation des API.

Apigee requiert l'activation de plusieurs API Google Cloud. Activez-les en exécutant la commande services enable :
```
gcloud services enable apigee.googleapis.com \
  cloudkms.googleapis.com --project=$PROJECT_ID
```
(Facultatif) Pour vérifier votre travail, utilisez la commande services list pour afficher toutes les API activées :
```
gcloud services list
```
La réponse affiche tous les services activés, y compris les API que vous venez d'activer (Apigee, Cloud KMS et Compute Engine).

Étape 3 : Créez une organisation

Une organisation est le conteneur de niveau supérieur dans Apigee. Elle contient tous les proxys d'API et les ressources associées. Pour en savoir plus, consultez la page Comprendre les organisations.

Autorisations requises pour cette tâche

Créez une organisation d'évaluation avec l'API provisionOrganization :
Remarque : L'API provisionOrganization ne peut créer que des éléments suivants : organisations d'évaluation. Vous ne pouvez pas l'utiliser pour créer des organisations de production.
```
 suppresswarning="true">curl "https://apigee.googleapis.com/v1/projects/$PROJECT_ID:provisionOrganization"  \
  -H "$AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "analyticsRegion":"'"$ANALYTICS_REGION"'",
    "runtimeLocation":"'"$RUNTIME_LOCATION"'",
    "disableVpcPeering":"true",
  }'
```
Où :
- -d définit la charge utile des données pour la requête. Cette charge utile doit inclure les éléments suivants :
  - ANALYTICS_REGION : spécifie l'emplacement physique dans lequel vos données d'analyse seront stockées.
  - RUNTIME_LOCATION : emplacement physique où se trouve l'instance Apigee.
  - disableVpcPeering : dans ce flux de provisionnement, nous n'utilisons pas l'appairage de VPC. Cette option doit donc être définie sur true. Par défaut, false.
Apigee démarre une opération de longue durée pour créer l'organisation d'évaluation. Cette opération peut prendre jusqu'à 40 minutes.
Pour vérifier l'état de votre requête de création, vous pouvez envoyer une requête GET à l'API List organizations d'Apigee, comme illustré dans l'exemple suivant :
```
curl -H "$AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Si la réponse suivante s'affiche, cela signifie que la création de l'organisation n'est pas encore terminée :
```
{
"error": {
"code": 403,
"message": "Permission denied on resource \"organizations/apigee-docs-m\" (or it may not exist)",
"status": "PERMISSION_DENIED"
}
}
```
En cas de réussite, l'objet de réponse indique "state": "ACTIVE", et vous pouvez passer à l'étape suivante.

Étape 4 : Configurez le routage

Au cours de cette étape, vous allez configurer la manière dont les applications clientes communiquent avec Apigee. Le trafic client vers Apigee est également appelé trafic "Northbound". Les options de configuration Northbound incluent les éléments suivants :

Type d'accès	Description du processus de configuration et de déploiement
Interne avec PSC	N'autorisez l'accès interne à vos proxys d'API que depuis l'un de vos projets Google Cloud utilisant Private Service Connect (PSC). PSC permet d'établir une connexion privée entre un producteur de services (Apigee) et un client du service (le projet VPC appairé et/ou un ou plusieurs autres projets Cloud que vous contrôlez). Avec cette méthode, les requêtes transitent par un point de terminaison de service ou par un équilibreur de charge interne régional vers un même point de rattachement (que l'on appelle un rattachement de service). Cette configuration permet à vos clients internes d'envoyer des requêtes de proxy d'API Apigee à partir de n'importe quelle machine compatible avec le réseau.
Externe avec PSC	Autorisez l'accès externe à vos proxys API utilisant Private Service Connect (PSC). Utilisez Private Service Connect (PSC) pour activer la connexion privée entre un producteur de services (Apigee) et un client du service (le projet VPC appairé et/ou un ou plusieurs autres projets Cloud que vous contrôlez). Avec cette méthode, les requêtes transitent par un équilibreur de charge externe global ou par un équilibreur de charge externe régional vers un même point de rattachement (que l'on appelle un rattachement de service). Cette configuration vous permet d'envoyer des requêtes de proxy d'API Apigee à partir de n'importe quelle machine compatible avec le réseau.

Type d'accès

Description du processus de configuration et de déploiement

Interne avec PSC

N'autorisez l'accès interne à vos proxys d'API que depuis l'un de vos projets Google Cloud utilisant Private Service Connect (PSC).

PSC permet d'établir une connexion privée entre un producteur de services (Apigee) et un client du service (le projet VPC appairé et/ou un ou plusieurs autres projets Cloud que vous contrôlez). Avec cette méthode, les requêtes transitent par un point de terminaison de service ou par un équilibreur de charge interne régional vers un même point de rattachement (que l'on appelle un rattachement de service). Cette configuration permet à vos clients internes d'envoyer des requêtes de proxy d'API Apigee à partir de n'importe quelle machine compatible avec le réseau.

Externe avec PSC

Autorisez l'accès externe à vos proxys API utilisant Private Service Connect (PSC).

Utilisez Private Service Connect (PSC) pour activer la connexion privée entre un producteur de services (Apigee) et un client du service (le projet VPC appairé et/ou un ou plusieurs autres projets Cloud que vous contrôlez). Avec cette méthode, les requêtes transitent par un équilibreur de charge externe global ou par un équilibreur de charge externe régional vers un même point de rattachement (que l'on appelle un rattachement de service). Cette configuration vous permet d'envoyer des requêtes de proxy d'API Apigee à partir de n'importe quelle machine compatible avec le réseau.

Chacune de ces approches de routage est présentée sous la forme d'un onglet dans les instructions ci-dessous.

Routage interne (PSC)

Cette section explique comment n'autoriser l'accès interne à vos proxys API que depuis vos projets Google Cloud utilisant Private Service Connect (PSC).

Deux options s'offrent à vous pour configurer l'accès interne avec PSC :

Point de terminaison de service : les requêtes transitent par un point de terminaison de service vers un point de rattachement unique (que l'on appelle rattachement de service).
Équilibreur de charge régional interne : les requêtes transitent par un équilibreur de charge HTTP(S) interne régional. Consultez également la section Équilibrage de charge global ou régional.

Sélectionnez l'onglet ci-dessous pour votre choix de configuration et suivez les étapes :

Point de terminaison du service

Autorisations requises pour cette tâche

Créer un point de terminaison de service PSC pour le rattachement de service

Obtenez le rattachement de service à partir de l'instance Apigee :

curl -i -X GET -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Dans l'exemple de résultat suivant, la valeur serviceAttachment est indiquée en gras :

{
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "runtimeVersion": "1-7-0-20220228-190814",
      "consumerAcceptList": [
        "my-project"
      ],
      "serviceAttachment": "projects/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
    }
  ]
}

Remarque : L'ID du projet que vous avez utilisé pour créer votre organisation Apigee apparaît toujours dans la liste consumerAcceptList. Dans l'exemple de résultat présenté ci-dessus, il s'agit du seul projet de la liste.

Créez un point de terminaison de service PSC qui pointe vers le rattachement de service obtenu à partir du corps de réponse de l'instance à l'étape précédente, comme expliqué dans la section Créer un point de terminaison Private Service Connect.
Notez et mémorisez l'adresse IP du point de terminaison de service. Vous aurez besoin de l'adresse IP ultérieurement pour tester la configuration en appelant un proxy d'API. Par exemple : 10.138.0.2.

Le provisionnement d'Apigee est terminé. Accédez à la page Déployer un exemple de proxy.

Équilibreur de charge régional interne

Autorisations requises pour cette tâche

Restrictions : Notez les restrictions suivantes pour la configuration PSC :

L'équilibreur de charge HTTP(S) externe global (classique) n'est pas compatible avec cette configuration.
Dans le cas de basculements avec plusieurs NEG PSC, les vérifications d'état actives ne sont pas acceptées. Utilisez plutôt la détection d'anomalies.
Le nombre de projets Google Cloud pouvant se connecter à une instance Apigee via PSC est limité à 50 et chaque projet peut créer jusqu'à 20 connexions. Consultez la page Configurer le routage. Consultez également la section Limites.
Remarque : Vous contrôlez la liste des projets Google Cloud connectés à une instance via le champ consumerAcceptList de l'API d'instances.
Si un projet Google Cloud est supprimé de la liste consumerAcceptList, les NEG PSC existants de ce projet supprimé continuent de fonctionner. Cependant, tous les nouveaux NEG seront refusés. Vous devez supprimer les NEG existants si vous supprimez leurs projets associés de la liste consumerAcceptList. Vous pouvez également recréer l'instance Apigee, qui recrée le rattachement de service dans le projet Apigee.

Étape 8a : Configurer les variables d'environnement

Les instructions de cette section utilisent des variables d'environnement pour faire référence à des chaînes utilisées de manière répétée. Assurez-vous d'avoir défini les variables de la section Définir des variables d'environnement.

De plus, définissez les variables d'environnement suivantes :

Définissez les variables d'environnement suivantes dans votre terminal de commande :

NEG_NAME=YOUR_NEG_NAME"
TARGET_SERVICE=YOUR_TARGET_SERVICE"
NETWORK_NAME=YOUR_NETWORK_NAME"
SUBNET_NAME=YOUR_SUBNET_NAME"

Où :

NEG_NAME : nom du groupe de points de terminaison du réseau.
TARGET_SERVICE : rattachement de service auquel vous souhaitez vous connecter. Par exemple : projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
NETWORK_NAME (facultatif) : nom du réseau dans lequel le NEG est créé. Si vous omettez ce paramètre, le réseau de projet default est utilisé.
SUBNET_NAME : nom du sous-réseau utilisé pour la connectivité privée au producteur. La taille du sous-réseau peut être faible : le NEG PSC n'a besoin que d'une adresse IP du sous-réseau. Pour Apigee, un seul NEG PSC est nécessaire par région. Le sous-réseau peut être partagé et utilisé par des VM ou d'autres entités. Si aucun sous-réseau n'est spécifié, les points de terminaison du réseau peuvent appartenir à n'importe quel sous-réseau de la région dans laquelle le groupe de points de terminaison du réseau est créé.
REMARQUE : Si vous spécifiez le paramètre --network, vous devez également spécifier --subnet.

Étape 8b : Créez un sous-réseau proxy réservé

gcloud compute networks subnets create testproxyonlysubnet \
  --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE --region=$RUNTIME_REGION --network=$NETWORK_NAME \
  --range=100.0.0.0/24 --project=$PROJECT_ID

Étape 8c : Créer un groupe de points de terminaison du réseau (NEG)

Récupérez le rattachement de service à partir de l'instance que vous avez créée précédemment :

curl -i -X GET -H "$AUTH" \
"https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Dans l'exemple de résultat suivant, la valeur serviceAttachment est indiquée en gras :

{
"instances": [
  {
    "name": "us-west1",
    "location": "us-west1",
    "createdAt": "1645731488019",
    "lastModifiedAt": "1646504754219",
    "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
    "state": "ACTIVE",
    "runtimeVersion": "1-7-0-20220228-190814",
    "consumerAcceptList": [
      "my-project"
    ],
    "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
  }
]
}

Remarque : L'ID du projet que vous avez utilisé pour créer votre organisation Apigee apparaît toujours dans la liste consumerAcceptList. Dans l'exemple de résultat présenté ci-dessus, il s'agit du seul projet de la liste.

Créez un NEG Private Service Connect qui pointe vers le rattachement de service que vous avez obtenu à partir du corps de réponse de l'instance à l'étape précédente.

gcloud compute network-endpoint-groups create $NEG_NAME \
--network-endpoint-type=private-service-connect \
--psc-target-service=$TARGET_SERVICE \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID

Étape 8d : Configurer l'équilibreur de charge interne régional

Réservez une adresse IPv4 interne pour l'équilibreur de charge.

gcloud compute addresses create ADDRESS_NAME \
--ip-version=IPV4 --subnet=$SUBNET_NAME \
  --region=$RUNTIME_LOCATION --project=$PROJECT_ID

Remplacez ADDRESS_NAME par le nom de la ressource d'adresse IP

Exécutez la commande suivante pour afficher l'adresse IP réservée :

gcloud compute addresses describe ADDRESS_NAME \
--format="get(address)" --region=RUNTIME_LOCATION --project=$PROJECT_ID

Créez un service de backend pour le NEG.

gcloud compute backend-services create BACKEND_SERVICE_NAME \
--load-balancing-scheme=INTERNAL_MANAGED \
--protocol=HTTPS \
--region=$RUNTIME_REGION \
--project=$PROJECT_ID

Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

Ajoutez le service de backend au NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
--network-endpoint-group=NEG_NAME \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID
```
Remplacez les éléments suivants :
- BACKEND_SERVICE_NAME : nom du service de backend.
- NEG_NAME : nom du groupe de points de terminaison du réseau.
Vous devez disposer d'une ressource de certificat SSL à utiliser dans le proxy HTTPS cible.

Utilisez cette commande pour créer une ressource de certificat SSL autogéré. Pour créer un certificat SSL autogéré, vous avez besoin d'un fichier de clé privée locale et d'un fichier de certificat local. Si vous devez créer ces fichiers, consultez l'étape 1 de la page sur l'utilisation des certificats SSL autogérés.

Remarque : Les certificats gérés par Google ne sont pas compatibles avec l'équilibreur de charge régional interne.
```
gcloud compute ssl-certificates create CERTIFICATE \
--certificate LB_CERT \
--private-key LB_PRIVATE_KEY
--region=RUNTIME_LOCATION --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- CERTIFICATE : nom du certificat.
- LB_CERT : chemin d'accès au fichier de certificat au format PEM de votre certificat autogéré.
- LB_PRIVATE_KEY : chemin d'accès au fichier de clé privée au format PEM pour votre certificat autogéré.
Créez un mappage d'URL pour l'équilibreur de charge.

Un mappage d'URL doit faire référence à un service de backend par défaut. Définissez le service de backend que vous venez de créer comme service par défaut.
```
gcloud compute url-maps create URL_MAP_NAME \
    --default-service=DEFAULT_BACKEND_SERVICE_NAME \
    --global --project=$PROJECT_ID
```
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é.
Utilisez la ressource de certificat SSL pour créer un proxy HTTPS cible.
```
gcloud compute target-https-proxies create PROXY_NAME \
--url-map=URL_MAP_NAME \
--ssl-certificates=CERTIFICATE \
--region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- PROXY_NAME : nom du proxy HTTPS cible.
- URL_MAP_NAME : nom du mappage d'URL.
- CERTIFICATE : nom de la ressource de certificat.

Créez la règle de transfert.

gcloud compute forwarding-rules create FWD_RULE \
--load-balancing-scheme=INTERNAL_MANAGED \
--address=ADDRESS_NAME \
--target-https-proxy=PROXY_NAME \
--ports=443 \
--target-https-proxy-region=$RUNTIME_REGION \
--region=$RUNTIME_REGION
--project=$PROJECT_ID

Remplacez les éléments suivants :

FWD_RULE : nom de la règle de transfert.
ADDRESS_NAME : ressource d'adresse IP que vous avez réservée pour la règle de transfert.
PROXY_NAME : nom du proxy HTTPS cible.

Le provisionnement d'Apigee est terminé. Accédez à la page Déployer un exemple de proxy.

Routage externe (PSC)

Cette section explique comment configurer le routage externe à l'aide de Private Service Connect (PSC) pour permettre la communication entre Apigee et les VPC que vous contrôlez. Vous devez effectuer cette opération avant de pouvoir envoyer une requête à partir d'un client externe vers votre instance d'exécution Apigee.

Autorisations requises pour cette tâche

Restrictions : Notez les restrictions suivantes pour la configuration PSC :

L'équilibreur de charge HTTP(S) externe global (classique) n'est pas compatible avec cette configuration.
Dans le cas de basculements avec plusieurs NEG PSC, les vérifications d'état actives ne sont pas acceptées. Utilisez plutôt la détection d'anomalies.
Le nombre de projets Google Cloud pouvant se connecter à une instance Apigee via PSC est limité à 50 et chaque projet peut créer jusqu'à 20 connexions. Consultez la page Configurer le routage. Consultez également la section Limites.
Remarque : Vous contrôlez la liste des projets Google Cloud connectés à une instance via le champ consumerAcceptList de l'API d'instances.
Si un projet Google Cloud est supprimé de la liste consumerAcceptList, les NEG PSC existants de ce projet supprimé continuent de fonctionner. Cependant, tous les nouveaux NEG seront refusés. Vous devez supprimer les NEG existants si vous supprimez leurs projets associés de la liste consumerAcceptList. Vous pouvez également recréer l'instance Apigee, qui recrée le rattachement de service dans le projet Apigee.

Étape 8b : Créer un NEG et configurer l'équilibreur de charge

Vous pouvez créer un équilibreur de charge global ou régional.

Équilibreur de charge externe global

Configurez un équilibreur de charge HTTP(S) externe global (schéma d'équilibrage de charge défini sur EXTERNAL_MANAGED).

Bien que le NEG Private Service Connect soit régional, tous les autres composants d'équilibrage de charge de cette configuration sont globaux.

Assurez-vous d'avoir défini les variables d'environnement de la section Définir des variables d'environnement.

Récupérez le rattachement de service à partir de l'instance que vous avez créée précédemment :

curl -i -X GET -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Dans l'exemple de résultat suivant, la valeur serviceAttachment est indiquée en gras :

{
      "instances": [
        {
          "name": "us-west1",
          "location": "us-west1",
          "host": "10.82.192.2",
          "port": "443",
          "createdAt": "1645731488019",
          "lastModifiedAt": "1646504754219",
          "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
          "state": "ACTIVE",
          "peeringCidrRange": "SLASH_22",
          "runtimeVersion": "1-7-0-20220228-190814",
          "ipRange": "10.82.192.0/22,10.82.196.0/28",
          "consumerAcceptList": [
            "875609189304"
          ],
          "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
        }
      ]
    }

Créez un NEG Private Service Connect qui pointe vers le rattachement de service que vous avez obtenu à partir du corps de réponse de l'instance à l'étape précédente.
```
    gcloud compute network-endpoint-groups create $NEG_NAME \
      --network-endpoint-type=private-service-connect \
      --psc-target-service=$TARGET_SERVICE \
      --region=$RUNTIME_LOCATION \
      --network=NETWORK_NAME \
      --subnet=SUBNET_NAME \
      --project=$PROJECT_ID
    
```
Remplacez les éléments suivants :
- NETWORK_NAME (facultatif) : nom du réseau dans lequel le NEG est créé. Si vous omettez ce paramètre, le réseau de projet default est utilisé.
- SUBNET_NAME : nom du sous-réseau utilisé pour la connectivité privée au producteur. La taille du sous-réseau peut être faible : le NEG PSC n'a besoin que d'une adresse IP du sous-réseau. Pour Apigee, un seul NEG PSC est nécessaire par région. Le sous-réseau peut être partagé et utilisé par des VM ou d'autres entités. Si aucun sous-réseau n'est spécifié, les points de terminaison du réseau peuvent appartenir à n'importe quel sous-réseau de la région dans laquelle le groupe de points de terminaison du réseau est créé.
  REMARQUE : Si vous spécifiez le paramètre --network, vous devez également spécifier --subnet.
- PROJECT_ID : projet Cloud déjà associé à votre organisation Apigee, ou projet Cloud inclus dans consumerAcceptlist lors de la création de l'instance d'exécution Apigee.

Réservez une adresse IPv4 externe globale pour l'équilibreur de charge.

gcloud compute addresses create ADDRESS_NAME \
  --ip-version=IPV4 --global --project=$PROJECT_ID

Remplacez ADDRESS_NAME par le nom de la ressource d'adresse IP

Exécutez la commande suivante pour afficher l'adresse IP réservée :

gcloud compute addresses describe ADDRESS_NAME \
  --format="get(address)" --global --project=$PROJECT_ID

Créez un service de backend pour le NEG.

gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --global --project=$PROJECT_ID

Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

Ajoutez le service de backend au NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --network-endpoint-group-region=$REGION \
  --global --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- BACKEND_SERVICE_NAME : nom du service de backend.
- NEG_NAME : nom du groupe de points de terminaison du réseau.
- REGION : région du groupe de points de terminaison du réseau.
Créez un mappage d'URL pour l'équilibreur de charge.

Un mappage d'URL doit faire référence à un service de backend par défaut. Définissez le service de backend que vous venez de créer comme service par défaut.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --global --project=$PROJECT_ID
```
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é.
Créez le proxy HTTPS cible.

Vous devez disposer d'une ressource de certificat SSL à utiliser dans le proxy HTTPS cible. Vous pouvez créer une ressource de certificat SSL à l'aide d'un certificat SSL géré par Google ou d'un certificat SSL autogéré. L'utilisation de certificats gérés par Google est recommandée, car Google Cloud obtient, gère et renouvelle automatiquement ces certificats.

Pour créer un certificat géré par Google, vous devez disposer d'un domaine.

Utilisez cette commande pour créer une ressource de certificat SSL géré par Google :
```
gcloud compute ssl-certificates create CERTIFICATE \
  --domains DOMAIN --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- CERTIFICATE : nom du certificat.
- DOMAIN : nom de domaine de votre équilibreur de charge
Utilisez cette commande pour créer une ressource de certificat SSL autogéré. Pour créer un certificat SSL autogéré, vous avez besoin d'un fichier de clé privée locale et d'un fichier de certificat local. Si vous devez créer ces fichiers, consultez l'étape 1 de la page sur l'utilisation des certificats SSL autogérés.
```
gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- CERTIFICATE : nom du certificat.
- LB_CERT : chemin d'accès au fichier de certificat au format PEM de votre certificat autogéré.
- LB_PRIVATE_KEY : chemin d'accès au fichier de clé privée au format PEM pour votre certificat autogéré.
Utilisez la ressource de certificat SSL pour créer un proxy HTTPS cible.
```
gcloud compute target-https-proxies create PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --ssl-certificates=CERTIFICATE --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- PROXY_NAME : nom du proxy HTTPS cible.
- URL_MAP_NAME : nom du mappage d'URL.
- CERTIFICATE : nom de la ressource de certificat.

Créez la règle de transfert.

gcloud compute forwarding-rules create FWD_RULE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=ADDRESS_NAME \
  --target-https-proxy=PROXY_NAME \
  --ports=443 \
  --global --project=$PROJECT_ID

Remplacez les éléments suivants :

FWD_RULE : nom de la règle de transfert.
ADDRESS_NAME : ressource d'adresse IP que vous avez réservée pour la règle de transfert.
PROXY_NAME : nom du proxy HTTPS cible.

Le provisionnement d'Apigee est terminé. Accédez à la page Déployer un exemple de proxy.

Équilibreur de charge externe régional

Configurez un équilibreur de charge HTTP(S) externe régional. Consultez également la page Présentation de l'équilibreur de charge HTTP(S) externe.

Assurez-vous d'avoir défini les variables de la section Définir des variables d'environnement.
Créez un sous-réseau proxy réservé :
Remarque : Cette opération n'est à effectuer qu'une seule fois. Ce sous-réseau proxy réservé n'est requis qu'une seule fois par projet Google Cloud pour tout équilibreur de charge régional basé sur Envoy. Consultez également la section Sous-réseaux proxy réservés aux équilibreurs de charge basés sur Envoy.
```
gcloud compute networks subnets create SUBNET_NAME \
  --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE \
  --region=$RUNTIME_LOCATION --network=NETWORK_NAME \
  --range=100.0.0.0/24 --project=$PROJECT_ID
```
- Remplacez SUBNET_NAME par le nom du sous-réseau.
- (Facultatif) Remplacez NETWORK_NAME par le nom du réseau dans lequel le sous-réseau est créé. Si vous omettez ce paramètre, le réseau par défaut du projet est utilisé.

Récupérez le rattachement de service à partir de l'instance que vous avez créée précédemment :

curl -i -X GET -H "$AUTH" \
        "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Dans l'exemple de résultat suivant, la valeur serviceAttachment est indiquée en gras :

{
        "instances": [
          {
            "name": "us-west1",
            "location": "us-west1",
            "host": "10.82.192.2",
            "port": "443",
            "createdAt": "1645731488019",
            "lastModifiedAt": "1646504754219",
            "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
            "state": "ACTIVE",
            "peeringCidrRange": "SLASH_22",
            "runtimeVersion": "1-7-0-20220228-190814",
            "ipRange": "10.82.192.0/22,10.82.196.0/28",
            "consumerAcceptList": [
              "875609189304"
            ],
            "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
          }
        ]
      }

Créez un groupe de points de terminaison du réseau
```
gcloud compute network-endpoint-groups create NEG_NAME \
        --network-endpoint-type=private-service-connect \
        --psc-target-service=TARGET_SERVICE \
        --region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- NEG_NAME : nom du groupe de points de terminaison du réseau.
- TARGET_SERVICE : nom du rattachement de service auquel vous souhaitez vous connecter. Par exemple : projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7

Créez un service de backend pour le NEG.

gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID

Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

Ajoutez le service de backend au NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- BACKEND_SERVICE_NAME : nom du service de backend.
- NEG_NAME : nom du groupe de points de terminaison du réseau.
Créez un mappage d'URL pour l'équilibreur de charge.

Un mappage d'URL doit faire référence à un service de backend par défaut. Définissez le service de backend que vous venez de créer comme service par défaut.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
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é.
Créez le proxy HTTPS cible.

Vous devez disposer d'une ressource de certificat SSL à utiliser dans le proxy HTTPS cible.

Utilisez cette commande pour créer une ressource de certificat SSL autogéré. Pour créer un certificat SSL autogéré, vous avez besoin d'un fichier de clé privée locale et d'un fichier de certificat local. Si vous devez créer ces fichiers, consultez l'étape 1 de la page sur l'utilisation des certificats SSL autogérés.

Remarque : Les certificats gérés par Google ne sont pas compatibles avec l'équilibreur de charge régional externe.
```
gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION \
  --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- CERTIFICATE : nom du certificat.
- LB_CERT : chemin d'accès au fichier de certificat au format PEM de votre certificat autogéré.
- LB_PRIVATE_KEY : chemin d'accès au fichier de clé privée au format PEM pour votre certificat autogéré.

Ajoutez le domaine au groupe d'environnements Apigee qui a été créé pour vous. Le nom du groupe d'environnements est eval-group :

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/eval-group" \
      -H "$AUTH" \
      -X PATCH \
      -H "Content-Type:application/json" \
      -d '{
        "hostnames":["'"DOMAIN"'"]
      }'

Vérifiez l'état de l'opération du groupe d'environnements :

curl -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/eval-group/attachments"

Utilisez la ressource de certificat SSL pour créer un proxy HTTPS cible.
```
gcloud compute target-https-proxies create PROXY_NAME \
  --url-map=URL_MAP_NAME --region=$RUNTIME_LOCATION \
  --ssl-certificates=CERTIFICATE --project=$PROJECT_ID
```
Remplacez les éléments suivants :
- PROXY_NAME : nom du proxy HTTPS cible.
- URL_MAP_NAME : nom du mappage d'URL.
- CERTIFICATE : nom de la ressource de certificat.

Réservez une adresse externe régionale pour l'équilibreur de charge. Notez que le niveau de réseau doit être défini sur STANDARD.

gcloud compute addresses create ADDRESS_NAME \
      --region=$RUNTIME_LOCATION --network-tier=STANDARD \
      --project=$PROJECT_ID

Remplacez ADDRESS_NAME par le nom de la ressource d'adresse IP

Exécutez la commande suivante pour afficher l'adresse IP réservée :

gcloud compute addresses describe ADDRESS_NAME \
      --format="get(address)" --region=$RUNTIME_LOCATION \
      --project=$PROJECT_ID

Créez la règle de transfert.

gcloud compute forwarding-rules create FWD_RULE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --address=ADDRESS_NAME \
  --target-https-proxy=PROXY_NAME \
  --ports=443  --region=$RUNTIME_LOCATION \
  --target-https-proxy-region=$RUNTIME_LOCATION --project=$PROJECT_ID

Remplacez les éléments suivants :

FWD_RULE : nom de la règle de transfert.
ADDRESS_NAME : ressource d'adresse IP que vous avez réservée pour la règle de transfert.
PROXY_NAME : nom du proxy HTTPS cible.

Le provisionnement d'Apigee est terminé. Accédez à la section Appeler l'exemple de proxy d'API.

Étape 5 : Appelez l'exemple de proxy d'API

Un proxy d'API appelé hello-world a été créé et déployé pour vous pendant le provisionnement. Au cours de cette étape, vous allez tester la nouvelle organisation d'évaluation en appelant le proxy.

Autorisations requises pour cette tâche

La création et le déploiement de proxys nécessitent un ensemble minimal d'autorisations. Si vous disposez du rôle d'administrateur de l'organisation Apigee, vous pouvez effectuer cette tâche. Pour en savoir plus sur les autres rôles que vous pouvez utiliser, consultez la page sur les rôles Apigee.

Appeler le proxy d'API avec un routage interne

Si vous avez choisi un routage interne avec une option de point de terminaison de service à l'étape 5, suivez les étapes décrites dans la page Appeler un proxy d'API avec un accès interne seulement

Appeler le proxy d'API avec un routage externe

Si vous avez choisi une option de routage externe à l'étape 5, suivez les étapes décrites dans cette section.

Configurez une entrée DNS pour votre domaine. Pour ce faire, vous deux options s'offrent à vous :
- Au niveau de votre bureau d'enregistrement, créez un enregistrement A pointant vers votre domaine. Par exemple, si votre domaine est sales.example.com et que l'adresse IP est 10.23.0.2, faites pointer l'enregistrement pour sales.example.com vers l'adresse 10.23.0.2.
  Exécutez la commande suivante pour afficher l'adresse IP réservée :
```
gcloud compute addresses describe ADDRESS_NAME \
    --format="get(address)" --region=$RUNTIME_LOCATION \
    --project=$PROJECT_ID
```
- Utilisez Cloud DNS pour mapper une URL à une adresse IP.

Vérifiez que le proxy hello-world est déployé :

curl -i -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/eval/apis/hello-world/revisions/1/deployments"

Appelez le proxy d'API à l'aide de la commande suivante :
Envoyez une requête au proxy d'API à partir de n'importe quel ordinateur connecté au réseau en exécutant la commande suivante :
```
curl -i -H "Host: DOMAIN" \
  https://DOMAIN/hello-world
```
Où DOMAIN est le domaine que vous avez saisi dans le certificat et ajouté au groupe d'environnements, comme indiqué à l'Étape 5 : Configurez le routage. Si nécessaire, vous pouvez utiliser cette API pour obtenir la valeur DOMAIN du groupe d'environnements :
```
curl -i -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"
```
En cas de réussite, l'exemple de proxy d'API renvoie la réponse suivante :
```
Hello, Guest!
```
Conseils de dépannage

Si vous obtenez une erreur de handshake, vérifiez l'état du certificat SSL. Pour en savoir plus sur le dépannage des certificats autogérés et gérés par Google, consultez la section Résoudre les problèmes liés aux certificats SSL.
Assurez-vous que votre domaine enregistré possède un enregistrement A qui pointe vers l'adresse IP de l'adresse IPv4 externe globale créée à l'étape 5. Exécutez la commande suivante pour afficher l'adresse IP réservée :
```
gcloud compute addresses describe ADDRESS_NAME \
              --format="get(address)" --region=$RUNTIME_LOCATION \
              --project=$PROJECT_ID
```
Si vous ne parvenez pas à résoudre la configuration du domaine, essayez d'appeler le proxy avec cette commande :
```
curl  -H Host:DOMAIN --resolve \
  DOMAIN:443:EXTERNAL_IP_ADDRESS  \
  https://DOMAIN:443/hello-world -k
```
Remarque : Les modifications de DNS sont publiées immédiatement, mais leur propagation peut prendre un certain temps. En raison de ce délai, vous devrez peut-être attendre jusqu'à une heure avant de pouvoir appeler l'exemple de proxy.

Étape suivante : Pour en savoir plus sur la création et le déploiement de proxys d'API, consultez la section Présentation de la création de votre premier proxy d'API.