Effectuer le provisionnement d'une organisation payante 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 Apigee à partir de la ligne de commande sans appairage de VPC. Ces étapes s'appliquent aux modèles de tarification par abonnement et par paiement à l'usage, pour les organisations payantes, avec ou sans résidence des données activée.

Consultez également Options de provisionnement.

Limites

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

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

Pour obtenir la liste complète des fonctionnalités et des approches de mise en réseau compatibles avec la configuration sans appairage de VPC, consultez la page 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 l'identité du service Apigee : ce compte de service est utilisé par les bibliothèques clientes Google Cloud pour s'authentifier auprès des API Google Cloud.
Étape 4 : 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 5 : Créez une instance d'exécution : une instance ou un environnement d'exécution correspond à l'emplacement de stockage de votre projet et des services associés. Il fournit le point de terminaison aux utilisateurs pour vos services.
Étape 6 : Créez un environnement : un proxy d'API doit être déployé sur un environnement et ajouté à un groupe d'environnements pour que les API exposées soient accessibles sur le réseau.
Étape 7 : Configurez le routage : autorisez l'accès externe ou seulement l'accès interne à votre API.
Étape 8 : Déployez un exemple de proxy : 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 de configuration répertoriées dans la section Avant de commencer.
Le SDK Cloud doit être installé. Si vous devez l'installer, consultez la page Installer le SDK Cloud.
Initialisez le SDK Cloud comme décrit sur la page Initialiser gcloud CLI ou vérifiez 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 dans votre terminal de commande. Sélectionnez l'onglet correspondant au type d'organisation dont vous avez besoin : Sans résidence des données ou avec Résidence des données :
Conseil : Enregistrez vos variables d'environnement dans un fichier texte afin de pouvoir les restaurer facilement si nécessaire.
Sans résidence des données
```
AUTH="$(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
ANALYTICS_REGION="YOUR_ANALYTICS_REGION"
BILLING_TYPE="YOUR_BILLING_TYPE"
```
Remarque : Si vous provisionnez une nouvelle organisation Apigee dans un projet Google Cloud avec une contrainte d'emplacement de ressource appliquée dans une règle d'administration, confirmez que cette contrainte d'emplacement est définie sur global. Étant donné que le plan de contrôle Apigee est par défaut une entité globale, le provisionnement échouera si une contrainte autre que global est appliquée. Pour en savoir plus, consultez la page Présentation de la résidence des données.

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.
- PROJECT_NUMBER est le numéro du projet Cloud que vous avez créé dans la section Prérequis.
- RUNTIME_LOCATION est l'emplacement physique dans lequel se trouve l'instance Apigee que vous allez créer plus tard. 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.
- BILLING_TYPE est le type de facturation pour l'organisation que vous créez. Les valeurs possibles sont les suivantes :
  - PAYG pour les organisations utilisant le paiement à l'usage.
  - SUBSCRIPTION pour les organisations avec abonnement.
Résidence des données
```
AUTH="$(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
CONTROL_PLANE_LOCATION="YOUR_CONTROL_PLANE_LOCATION"
CONSUMER_DATA_REGION="YOUR_CONSUMER_DATA_REGION"
BILLING_TYPE="YOUR_BILLING_TYPE"
```
Important : Lorsque vous utilisez la résidence des données, l'emplacement du plan de contrôle correspond à la région qui contient ces données. Toutes les autres régions doivent se trouver dans l'emplacement du plan de contrôle. Lorsque l'emplacement du plan de contrôle est us, la région des données client et l'emplacement d'exécution doivent également se trouver dans us. Par exemple, us-west1 est acceptable, où europe-west1 ne l'est pas.

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.
- PROJECT_NUMBER est le numéro du projet Cloud que vous avez créé dans la section Prérequis.
- RUNTIME_LOCATION est l'emplacement physique dans lequel se trouve l'instance Apigee que vous allez créer plus tard. 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.
  L'emplacement d'exécution doit se trouver dans l'emplacement du plan de contrôle.
- CONTROL_PLANE_LOCATION est l'emplacement physique dans lequel les données du plan de contrôle Apigee seront stockées. Pour obtenir la liste des emplacements du plan de contrôle disponibles, consultez la section Emplacements Apigee.
- CONSUMER_DATA_REGION est une sous-région de la région du plan de contrôle. Vous devez spécifier les paramètres CONTROL_PLANE_LOCATION et CONSUMER_DATA_REGION. Pour obtenir la liste des régions de données client disponibles, consultez la section Emplacements Apigee.
- BILLING_TYPE est le type de facturation pour l'organisation que vous créez. Les valeurs possibles sont les suivantes :
  - PAYG pour les organisations utilisant le paiement à l'usage.
  - SUBSCRIPTION pour les organisations avec abonnement.

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

Sans résidence des données

echo $AUTH
echo $PROJECT_ID
echo $PROJECT_NUMBER
echo $RUNTIME_LOCATION
echo $ANALYTICS_REGION
echo $BILLING_TYPE

Les réponses à vos commandes echo doivent se présenter comme suit :

YOUR_TOKEN
my-cloud-project
1234567890
us-west1
us-west1
SUBSCRIPTION

Résidence des données

echo $AUTH
echo $PROJECT_ID
echo $PROJECT_NUMBER
echo $RUNTIME_LOCATION
echo $CONTROL_PLANE_LOCATION
echo $CONSUMER_DATA_REGION
echo $BILLING_TYPE

Les réponses à vos commandes echo doivent se présenter comme suit :

YOUR_TOKEN
my-cloud-project
1234567890
us-west1
us
us-west1
SUBSCRIPTION

É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 suivante :

gcloud services enable apigee.googleapis.com \
    compute.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.

Étape 3 : Créez l'agent de service Apigee

Créez l'identité du service Apigee :

gcloud beta services identity create --service=apigee.googleapis.com \
  --project=$PROJECT_ID

Vérifiez que l'agent a bien été créé. La réponse doit présenter le nom de l'agent au format suivant : service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. par exemple :
```
Service identity created: service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
```

Étape 4 : Créez une organisation

Autorisations requises pour cette tâche

Avant de pouvoir créer une organisation, vous devez créer un trousseau de clés et une clé de chiffrement de la base de données d'exécution (voir étape 1) et, si vous utilisez la résidence des données, les clés et les trousseaux de clés de chiffrement du plan de contrôle (voir l'étape 2). Ces clés Cloud KMS chiffrent les données stockées et répliquées dans des emplacements d'exécution et de plan de contrôle. Apigee utilise ces entités pour chiffrer les données d'application, telles que les KVM, le cache et les codes secrets des clients, qui sont ensuite stockées dans la base de données. Pour plus d'informations, voir À propos des clés de chiffrement Apigee.

Créez un trousseau de clés et une clé de chiffrement de la base de données d'exécution :
1. Définissez une variable d'environnement pour l'emplacement du trousseau de clés et de la clé de chiffrement de la base de données d'exécution. Cela permet de garantir la cohérence lorsque vous les créez et facilite le suivi dans la documentation.
  
  La valeur est l'emplacement physique où sont stockés le trousseau de clés et la clé de chiffrement de la base de données d'exécution.
  Région unique
  
  Configurations dans une seule région (dans lesquelles vous ne disposez que d'une seule instance dans une région) : choisissez parmi les emplacements régionaux KMS compatibles.
  
  Exemple :
  RUNTIMEDBKEY_LOCATION="us-west1"
  Cette valeur peut être identique à votre valeur $RUNTIME_LOCATION (également une région), mais ce n'est pas une obligation. Toutefois, si elles sont identiques, cela peut améliorer les performances.
  Emplacement multirégional
  
  Configurations multirégionales : faites votre choix parmi les emplacements multirégionaux compatibles (tels que us ou europe) ou les emplacements birégionaux
  
  Exemple :
  RUNTIMEDBKEY_LOCATION="us"
  Si vous disposez d'une configuration multirégionale aux États-Unis, nous vous recommandons d'utiliser us pour votre emplacement si possible. Sinon, utilisez nam4.
2. Définissez des variables d'environnement pour les noms de clés et du trousseau de clés de la base de données.
  Le nom du trousseau de clés doit être unique au sein de votre organisation. Si vous créez une deuxième région ou plus, le nom ne peut pas être identique à celui des autres trousseaux de clés.
```
RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
```
3. (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 $RUNTIMEDBKEY_LOCATION
echo $RUNTIMEDB_KEY_RING_NAME
echo $RUNTIMEDB_KEY_NAME
```
4. Créez un trousseau de clés :
```
gcloud kms keyrings create $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION --project $PROJECT_ID
```
  L'emplacement de la clé de chiffrement de la base de données d'exécution Apigee est compatible avec tous les emplacements Cloud KMS qui acceptent Cloud HSM et Cloud EKM.
5. Créez une clé :
```
gcloud kms keys create $RUNTIMEDB_KEY_NAME \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID
```
  Cette commande crée la clé et l'ajoute au trousseau.
  
  Obtenez l'ID de la clé :
```
gcloud kms keys list \
  --location=$RUNTIMEDBKEY_LOCATION \
  --keyring=$RUNTIMEDB_KEY_RING_NAME \
  --project=$PROJECT_ID
```
  L'ID de clé utilise la syntaxe suivante (semblable à un chemin de fichier) :
```
projects/PROJECT_ID/locations/RUNTIMEDBKEY_LOCATION/keyRings/RUNTIMEDB_KEY_RING_NAME/cryptoKeys/RUNTIMEDB_KEY_NAME
```
6. Placez l'ID de la clé dans une variable d'environnement. Vous utiliserez cette variable dans une commande ultérieure :
```
RUNTIMEDB_KEY_ID=YOUR_RUNTIMEDB_KEY_ID
```
7. Autorisez l'agent de service Apigee à utiliser la nouvelle clé :
```
gcloud kms keys add-iam-policy-binding $RUNTIMEDB_KEY_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID
```
  Cette commande associe la clé à l'agent de service Apigee.
  
  Si la requête réussit, gcloud envoie une réponse semblable à celle-ci :
```
Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1
```
  Si vous obtenez une erreur semblable à celle-ci :
```
INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.
```
  Assurez-vous d'avoir utilisé le numéro du projet, et non le nom du projet dans l'adresse e-mail du compte de service.
Si vous utilisez la résidence des données, créez un trousseau de clés et une clé de chiffrement du plan de contrôle. Si vous n'utilisez pas la résidence des données, passez à l'étape 3.
Remarque : Cette étape n'est requise que si vous avez sélectionné us (multiple regions in us) ou eu (multiple regions in European Union) comme emplacement d'hébergement du plan de contrôle. Si vous avez sélectionné une autre région, passez à l'étape 3.

Pour créer un trousseau de clés et une clé de chiffrement du plan de contrôle, procédez comme suit.

Définissez une variable d'environnement pour l'emplacement du trousseau de clés et de la clé de chiffrement de la base de données du plan de contrôle :
```
CONTROL_PLANE_LOCATION=YOUR_CONTROL_PLANE_LOCATION
CONSUMER_DATA_REGION=YOUR_CONSUMER_DATA_REGION
```
Où :
- CONTROL_PLANE_LOCATION est l'emplacement physique dans lequel les données du plan de contrôle Apigee seront stockées. Pour obtenir la liste des emplacements du plan de contrôle disponibles, consultez la section Emplacements Apigee.
- CONSUMER_DATA_REGION est une sous-région de la région du plan de contrôle. Vous devez spécifier les paramètres CONTROL_PLANE_LOCATION et CONSUMER_DATA_REGION. Pour obtenir la liste des régions de données client disponibles, consultez la section Emplacements Apigee.
Définissez des variables d'environnement pour les noms de clés et du trousseau de clés du plan de contrôle.

Le nom du trousseau de clés doit être unique au sein de votre organisation.
```
CONTROL_PLANE_KEY_RING_NAME=YOUR_CONTROL_PLANE_KEY_RING_NAME
CONTROL_PLANE_KEY_NAME=YOUR_CONTROL_PLANE_KEY_NAME
CONSUMER_DATA_KEY_RING_NAME=YOUR_CONSUMER_DATA_KEY_RING_NAME
CONSUMER_DATA_KEY_NAME=YOUR_CONSUMER_DATA_REGION_KEY_NAME
```
Où :
- CONTROL_PLANE_KEY_RING_NAME est le nom du trousseau de clés que vous utilisez pour identifier votre trousseau de clés de chiffrement du plan de contrôle.
- CONTROL_PLANE_KEY_NAME est le nom de la clé que vous utiliserez pour identifier votre clé de chiffrement du plan de contrôle.
- CONSUMER_DATA_KEY_RING_NAME est le nom du trousseau de clés que vous utilisez pour identifier votre trousseau de clés de chiffrement des régions des données client.
- CONSUMER_DATA_KEY_NAME est le nom de la clé que vous utiliserez pour identifier votre clé de chiffrement de la région de données client.

Créez un trousseau de clés :

gcloud kms keyrings create $CONTROL_PLANE_KEY_RING_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --project $PROJECT_ID

gcloud kms keyrings create $CONSUMER_DATA_KEY_RING_NAME \
  --location $CONSUMER_DATA_REGION \
  --project $PROJECT_ID

Créez une clé :

gcloud kms keys create $CONTROL_PLANE_KEY_NAME \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID

gcloud kms keys create $CONSUMER_DATA_KEY_NAME \
  --keyring $CONSUMER_DATA_KEY_RING_NAME \
  --location $CONSUMER_DATA_REGION \
  --purpose "encryption" \
  --project $PROJECT_ID

Cette commande crée la clé et l'ajoute au trousseau.

Obtenez l'ID de la clé :

gcloud kms keys list \
--location=$CONTROL_PLANE_LOCATION \
--keyring=$CONTROL_PLANE_KEY_RING_NAME \
--project=$PROJECT_ID

gcloud kms keys list \
--location=$CONSUMER_DATA_REGION \
--keyring=$CONSUMER_DATA_KEY_RING_NAME \
--project=$PROJECT_ID

L'ID de clé utilise la syntaxe suivante (semblable à un chemin de fichier) :

projects/PROJECT_ID/locations/CONTROL_PLANE_LOCATION/keyRings/CONTROL_PLANE_KEY_RING_NAME/cryptoKeys/CONTROL_PLANE_KEY_NAME

projects/PROJECT_ID/locations/CONSUMER_DATA_REGION/keyRings/CONSUMER_DATA_KEY_RING_NAME/cryptoKeys/CONSUMER_DATA_KEY_NAME

Placez l'ID de la clé dans une variable d'environnement. Vous utiliserez cette variable dans une commande ultérieure :
```
CONTROL_PLANE_KEY_ID=YOUR_CONTROL_PLANE_KEY_ID
```
```
CONSUMER_DATA_KEY_ID=YOUR_CONSUMER_DATA_KEY_ID
```

Autorisez l'agent de service Apigee à utiliser la nouvelle clé :

gcloud kms keys add-iam-policy-binding $CONTROL_PLANE_KEY_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID

gcloud kms keys add-iam-policy-binding $CONSUMER_DATA_KEY_NAME \
 --location $CONSUMER_DATA_REGION \
 --keyring $CONSUMER_DATA_KEY_RING_NAME \
 --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
 --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
 --project $PROJECT_ID

Cette commande associe la clé à l'agent de service Apigee. Si la requête réussit, gcloud envoie une réponse semblable à celle-ci :

Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1

Si vous obtenez une erreur semblable à celle-ci :

INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

Assurez-vous d'avoir utilisé le numéro du projet, et non le nom du projet dans l'adresse e-mail du compte de service.

Consultez également la page Dépannage de CMEK.

Créez l'organisation en envoyant la requête suivante à l'API Organizations d'Apigee :
Sans résidence des données
```
curl "https://apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
  -H "Authorization: Bearer $AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$PROJECT_ID"'",
    "analyticsRegion":"'"$ANALYTICS_REGION"'",
    "runtimeType":"CLOUD",
    "billingType":"'"$BILLING_TYPE"'",
    "disableVpcPeering":"true",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'
```
Où :
- -d définit la charge utile des données pour la requête. Cette charge utile doit inclure les éléments suivants :
  - name : identifie votre nouvelle organisation. Il doit s'agir du même nom que votre ID de projet.
  - analyticsRegion : spécifie l'emplacement physique dans lequel vos données d'analyse seront stockées.
  - runtimeType : définissez cette valeur sur CLOUD.
  - billingType : spécifie le type de facturation de l'organisation créée.
  - disableVpcPeering : définissez cette valeur sur true si vous ne souhaitez pas utiliser l'appairage de VPC. Par défaut, false.
  - runtimeDatabaseEncryptionKeyName : ID de la clé de chiffrement de l'application que vous avez créée à l'étape précédente. Rappelez-vous que l'ID est structuré comme le chemin d'accès d'un fichier. Exemple :
    projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
Résidence des données

Créez une organisation à l'aide de l'API :
```
curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
  -H "Authorization: Bearer $AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$PROJECT_ID"'",
    "runtimeType":"CLOUD",
    "billingType":"'"$BILLING_TYPE"'",
    "controlPlaneEncryptionKeyName":"'"$CONTROL_PLANE_KEY_ID"'",
    "apiConsumerDataLocation":"'"$CONSUMER_DATA_REGION"'",
    "apiConsumerDataEncryptionKeyName":"'"$CONSUMER_DATA_KEY_ID"'",
    "disableVpcPeering":"true",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'
```
Où :

-d définit la charge utile des données pour la requête. Cette charge utile doit inclure les éléments suivants :
- name : identifie votre nouvelle organisation. Il doit s'agir du même nom que votre ID de projet.
- runtimeType : définissez cette valeur sur CLOUD.
- billingType : spécifie le type de facturation de l'organisation créée.
- controlPlaneEncryptionKeyName : est l'ID de votre clé de plan de contrôle.
- apiConsumerDataLocation : vous devez également spécifier une sous-région pour l'utilisation par les ressources internes. Consultez la section Régions de résidence des données pour connaître les valeurs acceptées.
- apiConsumerDataEncryptionKeyName : est votre ID de clé de région des données client.
- disableVpcPeering : définissez cette valeur sur true si vous ne souhaitez pas utiliser l'appairage de VPC. Par défaut, false.
- runtimeDatabaseEncryptionKeyName : ID de la clé de chiffrement de l'application que vous avez créée à l'étape précédente. Rappelez-vous que l'ID est structuré comme le chemin d'accès d'un fichier. Par exemple :
  projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
Une fois cette commande exécutée, Apigee démarre une opération de longue durée, qui peut prendre quelques minutes.

Si vous obtenez une erreur, vérifiez l'utilisation de guillemets autour des valeurs des variables dans la charge utile des données. Assurez-vous d'utiliser des guillemets doubles-simples-doubles autour de la variable $PROJECT_ID, comme illustré dans l'exemple suivant :
```
"'"$PROJECT_ID"'"
```
Si vous utilisez des chaînes brutes (et non des variables d'environnement) pour les valeurs de requête, vous pouvez les encapsuler entre guillemets doubles dans la chaîne de charge utile entre guillemets simples, comme le montre l'exemple suivant :
```
'{ "name":"my-gcp-project", ... }'
```
Attendez quelques 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 :
Sans résidence des données
```
curl -H "Authorization: Bearer $AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Résidence des données
```
curl -H "Authorization: Bearer $AUTH" "https://$CONTROL_PLANE_LOCATION-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.

Si Apigee renvoie une réponse d'erreur HTTP, consultez la page Créer une organisation Apigee.

Conseil : Pour répertorier les organisations Apigee et les projets Google Cloud associés auxquels vous êtes autorisé à accéder, envoyez une requête GET au point de terminaison suivant à l'aide de l'API Organizations :

Sans résidence des données :

curl -H "Authorization: Bearer $AUTH" https://apigee.googleapis.com/v1/organizations/

Résidence des données :

curl -H "Authorization: Bearer $AUTH" https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/

Apigee renvoie une liste de projets, comme illustré dans l'exemple suivant :

{
  "organizations": [
    {
      "organization": "my-cloud-project",
      "projectIds": [
        "my-cloud-project"
      ],
      "projectId": "my-cloud-project",
      "location": "northamerica-northeast1"
    },
    {
      "organization": "my-cloud-project-2",
      "projectIds": [
        "my-cloud-project-2"
      ],
      "projectId": "my-cloud-project-2",
      "location": "northamerica-northeast1"
    }
  ]
}

Étape 5 : Créez une instance d'exécution

Autorisations requises pour cette tâche

Une instance d'environnement d'exécution correspond à l'emplacement de stockage de votre projet Apigee et des services associés. Elle fournit le point de terminaison aux utilisateurs pour vos services. Pour créer une instance d'environnement d'exécution, procédez comme suit :

Vérifiez qu'Apigee a fini de créer votre organisation. Vous avez envoyé une requête pour créer une organisation à l'étape Créez une organisation Apigee, mais vous devez vous assurer que la création est terminée avant de poursuivre.

Pour ce faire, envoyez la requête suivante à l'API Organisations :
Sans résidence des données
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Résidence des données
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Si l'organisation existe (et que vous disposez des autorisations appropriées pour l'afficher), Apigee envoie des détails. Si Apigee renvoie un message d'erreur, attendez quelques minutes et renvoyez la requête.
Comme pour la tâche précédente où vous avez créé une clé de chiffrement pour la base de données, vous devez maintenant créer une clé Cloud KMS servant à chiffrer les données côté serveur. Pour commencer, définissez les variables d'environnement suivantes :
```
INSTANCE_NAME=YOUR_INSTANCE_NAME
RUNTIME_LOCATION=YOUR_RUNTIME_LOCATION
DISK_KEY_RING_NAME=YOUR_DISK_KEY_RING_NAME
DISK_KEY_NAME=YOUR_DISK_KEY_NAME
```

Où :

INSTANCE_NAME : nom de votre nouvelle instance. Par exemple, my-runtime-instance. Le nom doit commencer par une lettre minuscule, peut comporter jusqu'à 32 caractères et ne peut contenir que des lettres minuscules, des chiffres et des traits d'union. Il ne peut pas commencer, ni se terminer par un trait d'union et doit comporter au moins deux caractères.
Conseil : Le nom de votre instance doit correspondre à l'expression régulière suivante :
```
^[a-z][a-z\-\d]{0,30}[a-z\d]$
```
RUNTIME_LOCATION est l'emplacement physique dans lequel votre cluster est hébergé. Les valeurs valides correspondent à tout emplacement autorisé par Compute Engine. (Consultez la page Régions et zones disponibles.) Cet exemple utilise us-west1.
DISK_KEY_RING_NAME est le nom du trousseau de clés de chiffrement du disque.
DISK_KEY_NAME est le nom de la clé de chiffrement du disque.

Créez une clé de chiffrement du disque :
1. Créez un trousseau de clés du disque :
```
gcloud kms keyrings create $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --project $PROJECT_ID
```
  Votre trousseau de clés de disque doit être défini sur le même emplacement que l'instance. Chaque instance et chaque trousseau de clés doit avoir son propre emplacement.
2. Créez une clé de disque :
```
gcloud kms keys create $DISK_KEY_NAME \
  --keyring $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID
```
  La clé peut être référencée par son chemin d'accès de clé. Vous pouvez obtenir le chemin d'accès de clé à l'aide de la commande suivante :
```
gcloud kms keys list \
  --location=$RUNTIME_LOCATION \
  --keyring=$DISK_KEY_RING_NAME \
  --project=$PROJECT_ID
```
  Le chemin d'accès de la clé ressemble à ceci :
```
projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key
```
3. Placez le chemin d'accès de la clé dans une variable d'environnement. Vous utiliserez cette variable dans une commande ultérieure :
```
DISK_KEY_ID=YOUR_DISK_KEY_ID
```
  Par exemple : DISK_KEY_ID=projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
4. Autorisez l'agent de service Apigee à utiliser la nouvelle clé :
```
gcloud kms keys add-iam-policy-binding $DISK_KEY_NAME \
  --location $RUNTIME_LOCATION \
  --keyring $DISK_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID
```
  Cette commande associe la clé à l'agent de service Apigee.
Pour en savoir plus, consultez la page À propos des clés de chiffrement Apigee.
Créez une instance d'exécution pour votre projet en envoyant une requête POST à l'API Instances d'Apigee :
Sans résidence des données
```
curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
  -X POST -H "Authorization: Bearer $AUTH" \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$INSTANCE_NAME"'",
    "location":"'"$RUNTIME_LOCATION"'",
    "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
    "consumerAcceptList":["'"$PROJECT_ID"'"]
  }'
```
Résidence des données
```
curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
  -X POST -H "Authorization: Bearer $AUTH" \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$INSTANCE_NAME"'",
    "location":"'"$RUNTIME_LOCATION"'",
    "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
    "consumerAcceptList":["'"$PROJECT_ID"'"]
  }'
```
Où :
- consumerAcceptList (Facultatif) Spécifie une liste d'ID de projet Google Cloud pouvant se connecter en privé au rattachement de service du VPC Apigee. Le rattachement de service est une entité utilisée avec Private Service Connect de Google Cloud pour permettre aux producteurs de services (dans ce cas, Apigee) d'exposer des services aux consommateurs (dans ce cas, un ou plusieurs projets Cloud que vous possédez). Par défaut, nous utilisons le projet Cloud qui est déjà associé à votre organisation Apigee. Par exemple : "consumerAcceptList": ["project1", "project2", "project3"]
  Notez que vous pouvez également définir et modifier la liste des projets acceptés dans l'interface utilisateur de l'instance. Pour en savoir plus, consultez la page Gérer les instances.
Cette requête peut prendre jusqu'à 20 minutes, car Apigee doit créer et lancer un nouveau cluster Kubernetes, installer les ressources Apigee sur ce cluster et configurer l'équilibrage de charge.

Si Apigee renvoie une erreur, consultez la section Créer une instance.

Pour vérifier l'état de votre requête de création d'instance d'exécution, exécutez la commande suivante. Lorsque l'état est ACTIF, vous pouvez passer à l'étape suivante.

Sans résidence des données

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

Résidence des données

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

Étape 6 : Créez un environnement

Autorisations requises pour cette tâche

Pour créer un environnement et l'associer à l'environnement d'exécution sur la ligne de commande, procédez comme suit :

Définissez les variables d'environnement à utiliser dans cette section. Les variables d'environnement spécifiques que vous créez varient selon que vous créez un environnement pour une organisation avec abonnement ou paiement à l'usage.
Abonnement

Pour un environnement avec abonnement, créez les variables suivantes :
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Où :
- ENVIRONMENT_NAME correspond à un nom de chaîne. Par exemple : test
- ENV_GROUP_NAME correspond à un nom de chaîne. Par exemple : test-group
- ENV_GROUP_HOSTNAME est le nom d'un hébergeur de domaine valide. Par exemple : foo.example.com
Paiement à l'usage

Pour un environnement avec paiement à l'usage, créez les variables suivantes :
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENVIRONMENT_TYPE="YOUR_ENV_TYPE"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Où :
- ENVIRONMENT_NAME correspond à un nom de chaîne. Par exemple : test
- ENVIRONMENT_TYPE est le type d'environnement pour cet environnement et ne s'applique qu'aux utilisateurs qui disposent d'un paiement à l'usage qui doivent spécifier l'une des valeurs suivantes : BASE, INTERMEDIATE ou COMPREHENSIVE. Les autres utilisateurs doivent omettre le type d'environnement.
- ENV_GROUP_NAME correspond à un nom de chaîne. Par exemple : test-group
- ENV_GROUP_HOSTNAME est le nom d'un hébergeur de domaine valide. Par exemple : foo.example.com

Créez un nouvel environnement avec l'API Environnements. Les commandes spécifiques à utiliser varient selon que vous créez un environnement pour une organisation avec abonnement ou paiement à l'usage.

Abonnement

Pour un nouvel environnement avec abonnement, exécutez la commande suivante :

Sans résidence des données

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'"
  }'

Résidence des données

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'"
  }'

Apigee crée un environnement.

Paiement à l'usage

Pour un nouvel environnement avec paiement à l'usage, exécutez la commande suivante :

Sans résidence des données

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'",
      "type":"'"$ENVIRONMENT_TYPE"'"
  }'

Résidence des données

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'",
      "type":"'"$ENVIRONMENT_TYPE"'"
  }'

Apigee crée un environnement.

Avant de continuer, vérifiez qu'Apigee a fini de créer l'environnement en appelant l'API Environments :

Sans résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments"

Résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments"

Apigee répond avec une liste des environnements disponibles ; par exemple, si le nom de votre environnement est test, Apigee répond comme suit :

[
  "test"
]

Conseil : Vous pouvez vérifier l'état d'un environnement spécifique en envoyant une commande comme suit :

Sans résidence des données :

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

Résidence des données :

curl -i -X GET -H "Authorization: Bearer $AUTH" \
              "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME"

Apigee répond en fournissant des détails sur cet environnement uniquement. Exemple :

{
  "name": "my-cloud-project",
  "createdAt": "1592589683002",
  "lastModifiedAt": "1592589683002",
  "state": "ACTIVE"
}

Associez le nouvel environnement à l'instance d'exécution :

Sans résidence des données

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
    -X POST -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
    }'

Résidence des données

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
    -X POST -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
    }'

Cette opération peut prendre plusieurs minutes. Pour vérifier si le rattachement a bien été créé, exécutez la commande suivante :

Sans résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

Résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
  "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

Lorsque la sortie ci-dessous s'affiche, vous pouvez passer à l'étape suivante :

{
  "attachments": [
    {
      "name": "ed628782-c893-4095-b71c-f4731805290a",
      "environment": "test",
      "createdAt": "1641604447542"
    }
  ]
}

Créez un groupe d'environnements à l'aide de la commande suivante. Pour en savoir plus, consultez la section À propos des environnements et des groupes d'environnements :

Sans résidence des données

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name": "'"$ENV_GROUP_NAME"'",
      "hostnames":["'"$ENV_GROUP_HOSTNAME"'"]
  }'

Résidence des données

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name": "'"$ENV_GROUP_NAME"'",
      "hostnames":["'"$ENV_GROUP_HOSTNAME"'"]
  }'

Patientez jusqu'à la fin de l'opération. Vous pouvez vérifier l'état de votre nouveau groupe à l'aide d'une requête semblable à celle-ci :

Sans résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME"

Résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME"

Associez le nouvel environnement au nouveau groupe d'environnements à l'aide de la commande suivante :

Sans résidence des données

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
    -X POST \
    -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
  }'

Résidence des données

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
    -X POST \
    -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
  }'

Pour vérifier l'état de l'opération, appelez cette API :

Sans résidence des données

curl -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments"

Résidence des données

curl -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments"

Étape 7 : 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. Accédez à l'option de configuration que vous souhaitez utiliser et suivez les étapes correspondantes :

Type d'accès	Description du processus de configuration et de déploiement
Interne avec PSC (nouveau)	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 (nouveau)	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 (nouveau)

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

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

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

Sans résidence des données

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

Résidence des données

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://$CONTROL_PLANE_LOCATION-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.
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 :

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éer 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 :

Sans résidence des données

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

Résidence des données

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://$CONTROL_PLANE_LOCATION-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"
    }
  ]
  }

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
```
$PROJECT_ID peut être le projet Cloud déjà associé à votre organisation Apigee, ou le projet Cloud inclus dans consumerAcceptlist lors de la création de l'instance d'exécution Apigee.

É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 :
- NEG_NAME : nom du groupe de points de terminaison du réseau.
- Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.
Pour créer un équilibreur de charge HTTPS, vous devez disposer d'une ressource de certificat SSL à utiliser dans le proxy cible HTTPS.

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 local 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 :

Sans résidence des données

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

Résidence des données

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-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 :
- NEG_NAME : nom du groupe de points de terminaison du réseau.
- TARGET_SERVICE : rattachement de service auquel vous souhaitez vous connecter. Utilisez la valeur du rattachement de service renvoyée par la commande précédente. 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.
- $PROJECT_ID Le projet Cloud déjà associé à votre organisation Apigee, ou le projet Cloud inclus dans consumerAcceptlist lors de la création de l'instance d'exécution Apigee. Si vous ne l'avez pas déjà fait, créez une variable d'environnement destinée à contenir l'ID de projet, car il sera utilisé dans la plupart des commandes suivantes.

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.

Pour créer un équilibreur de charge HTTPS, vous devez disposer d'une ressource de certificat SSL à utiliser dans le proxy cible HTTPS. 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.

É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 pour les é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 les éléments suivants :
- SUBNET_NAME : nom du sous-réseau
- (Facultatif) NETWORK_NAME : 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 :

Sans résidence des données

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

Résidence des données

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-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.

Pour créer un équilibreur de charge HTTPS, vous devez disposer d'une ressource de certificat SSL à utiliser dans le proxy cible HTTPS.

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é.
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 page Déployer un exemple de proxy.

Étape 8 : Déployez un exemple de 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.

Téléchargez l'exemple de proxy depuis GitHub. La cible du proxy est le service httpbin.org, qui est un service de requête et de réponse public couramment utilisé.

Importez le groupe de proxys d'API dans l'environnement d'exécution à l'aide de l'API Apigee apis :

Sans résidence des données

curl -i -X POST -H "Authorization: Bearer $AUTH" \
    -H "Content-Type:multipart/form-data" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
    -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

Résidence des données

curl -i -X POST -H "Authorization: Bearer $AUTH" \
    -H "Content-Type:multipart/form-data" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
    -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

Où PATH_TO_ZIP_FILE est le chemin d'accès au répertoire contenant le fichier ZIP téléchargé.

Déployez le proxy d'API dans l'environnement que vous avez créé précédemment :

Sans résidence des données

curl -i -H "Authorization: Bearer $AUTH" -X POST \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Résidence des données

curl -i -H "Authorization: Bearer $AUTH" -X POST \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Vérifiez que le déploiement a bien été effectué avec cet appel d'API :

Sans résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/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: ENV_GROUP_HOSTNAME" \
    "https://ENV_GROUP_HOSTNAME/httpbin/headers"

Si nécessaire, vous pouvez utiliser cette API pour obtenir la valeur ENV_GROUP_HOSTNAME :

Sans résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"

Résidence des données

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"

Si vous obtenez une erreur du type CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure, vérifiez que le certificat SSL que vous avez créé précédemment a été provisionné. Exécutez cette commande pour vérifier l'état du provisionnement. Une fois le certificat provisionné, son état est ACTIVE.

gcloud compute ssl-certificates describe CERTIFICATE \
    --global \
    --format="get(name,managed.status, managed.Status)"

En cas de réussite, l'exemple de proxy d'API renvoie une réponse semblable à la suivante :

{
    "headers": {
      "Accept": "*/*",
      "Grpc-Trace-Bin": "AAD/8WC/I4AUSrMEch0E9yj+AYck1x9afwckAgA",
      "Host": "httpbin.org",
      "Traceparent": "00-fff160bf2380144ab304721d04f728fe-8724d71f5a7f0724-00",
      "User-Agent": "curl/7.77.0",
      "X-Amzn-Trace-Id": "Root=1-61d785ef-7613aa8a7fde7a910441fab9",
      "X-B3-Sampled": "0",
      "X-B3-Spanid": "8724d71f5a7f0724",
      "X-B3-Traceid": "fff160bf2380144ab304721d04f728fe",
      "X-Cloud-Trace-Context": "fff160bf2380144ab304721d04f728fe/9738144823944087332;o=0",
      "X-Envoy-Attempt-Count": "1"
    }
}

Pour en savoir plus sur le déploiement des proxys, y compris pour obtenir des informations supplémentaires sur le dépannage, consultez la page Déployer un proxy d'API.

Effectuer le provisionnement d'une organisation payante sans appairage de VPC

Limites

Résumé des étapes

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

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Étape 2 : Activez les API

Autorisations requises pour cette tâche

Étape 3 : Créez l'agent de service Apigee

Étape 4 : Créez une organisation

Autorisations requises pour cette tâche

Région unique

Emplacement multirégional

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Étape 5 : Créez une instance d'exécution

Autorisations requises pour cette tâche

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Étape 6 : Créez un environnement

Autorisations requises pour cette tâche

Abonnement

Paiement à l'usage

Abonnement

Sans résidence des données

Résidence des données

Paiement à l'usage

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Sans résidence des données

Résidence des données

Étape 7 : Configurez le routage

Routage interne (PSC)

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

Sans résidence des données

Résidence des données

Équilibreur de charge régional interne

Autorisations requises pour cette tâche

Étape 8a : Configurer les variables d'environnement

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

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

Sans résidence des données

Résidence des données

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

Routage externe (PSC)

Autorisations requises pour cette tâche

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

Équilibreur de charge externe global

Sans résidence des données

Résidence des données

Équilibreur de charge externe régional

Sans résidence des données

Résidence des données

Étape 8 : Déployez un exemple de proxy

Autorisations requises pour cette tâche

Sans résidence des données

Résidence des données

Sans résidence des données