Effectuer le provisionnement d'une organisation payante avec l'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, avec 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.

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 : Configurez la mise en réseau des services : la mise en réseau des services automatise la configuration de la connectivité privée (à l'aide de l'appairage de réseaux VPC) entre votre réseau et Apigee.
• Étape 5 : 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 6 : Créez une instance d'exécution : votre instance ou 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 7 : 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 8 : Configurez le routage : autorisez l'accès externe ou seulement l'accès interne à votre API.
• Étape 9 : 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 :

1. Assurez-vous de respecter les exigences de configuration répertoriées dans la section Avant de commencer.
2. Le SDK Cloud doit être installé. Si vous devez l'installer, consultez la page Installer le SDK Cloud.
3. 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.
4. 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.

5. (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.

1. 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 \
       servicenetworking.googleapis.com \
       compute.googleapis.com \
       cloudkms.googleapis.com --project=$PROJECT_ID

2. (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

Avertissement : Les comptes de service sont des comptes spéciaux requis par Apigee pour provisionner vos instances d'exécution. Si vous supprimez des comptes de service, vos instances d'exécution seront inutilisables.

1. Créez l'identité du service Apigee :

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

2. Vérifiez que l'agent a bien été créé. La réponse doit présenter le nom de l'agent au format suivant : [e-mail]. par exemple :

   Service identity created: [e-mail]

Étape 4 : Configurez la mise en réseau des services

Au cours de cette étape, vous allez allouer une paire de plages d'adresses IP (une plage CIDR /22 et /28) à Apigee, puis effectuer l'appairage de VPC entre votre réseau et le réseau d'Apigee. Chaque instance Apigee nécessite une plage CIDR /22 et /28 sans chevauchement. Les adresses IP de cette plage CIDR sont attribuées au plan d'exécution Apigee. Par conséquent, il est important que la plage soit réservée à Apigee et qu'elle ne soit pas utilisée par d'autres applications dans votre réseau VPC. Pour plus d'informations et des considérations importantes, consultez la page Comprendre les plages d'appairage.

Notez que vous créez une plage d'adresses IP réseau suffisante pour une seule instance Apigee. Si vous envisagez de créer des instances Apigee supplémentaires, vous devez répéter cette étape pour chacune d'elles. Les plages ne peuvent pas être partagées entre plusieurs instances. Consultez également la section Étendre Apigee dans plusieurs régions.

Important : Si vous disposez déjà d'une plage d'appairage et d'une connexion privée avec servicenetworking.googleapis.com, et que votre plage est suffisamment volumineuse pour gérer une autre plage CIDR /22 et /28, vous pouvez ignorer cette étape. Apigee crée les blocs CIDR nécessaires pour vous. Cette étape n'est requise que si vous n'avez pas encore créé d'espace pouvant créer un bloc /22 et /28 ou si vous souhaitez utiliser un /22 et /28 spécifiques dont vous ne disposez pas actuellement.

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 pages Rôles prédéfinis et Autorisations de mise en réseau de services.

1. Créez les variables d'environnement suivantes :

   RANGE_NAME=YOUR_RANGE_NAME
   NETWORK_NAME=YOUR_NETWORK_NAME
   

   Où :

   • RANGE_NAME est le nom de la plage d'adresses IP que vous créez. Vous pouvez donner le nom que vous voulez à la plage. Par exemple : google-svcs
   • NETWORK_NAME est le nom de la ressource réseau dans laquelle les adresses doivent être réservées.

     Google crée un réseau par défaut (nommé default) pour chaque nouveau projet afin que vous puissiez l'utiliser. Toutefois, Google ne recommande d'utiliser le réseau par défaut que pour effectuer des tests.

     Remarque : Nous vous déconseillons d'utiliser default, sauf si vous testez ce processus de configuration. Vous ne devez pas utiliser une organisation avec un réseau par défaut en production.
2. Créez une plage d'adresses IP réseau avec une longueur CIDR de /22 :

   gcloud compute addresses create $RANGE_NAME \
     --global \
     --prefix-length=22 \
     --description="Peering range for Apigee services" \
     --network=$NETWORK_NAME \
     --purpose=VPC_PEERING \
     --addresses=OPTIONAL_ADDRESSES \
     --project=$PROJECT_ID

   Où --addresses vous permet de spécifier une plage d'adresses, si vous le souhaitez. Par exemple, pour allouer le bloc CIDR 192.168.0.0/22, spécifiez 192.168.0.0 pour l'adresse et 22 pour la longueur du préfixe. Consultez également la section Créer une allocation d'adresses IP.

   Si vous ne fournissez pas de paramètre --addresses, gcloud sélectionne automatiquement une plage d'adresses disponible.

   En cas de réussite, gcloud renvoie la réponse suivante :

   Created [https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/global/addresses/google-svcs].

   Une fois que vous avez créé une plage d'adresses IP, les adresses sont associées au projet jusqu'à leur publication.

3. Vérifiez que la plage d'adresses IP du réseau a été créée avec une longueur CIDR de /22 :

   gcloud compute addresses list --global --project=$PROJECT_ID
   gcloud compute addresses describe $RANGE_NAME --global --project=$PROJECT_ID

4. Créez une plage d'adresses IP réseau avec une longueur CIDR de /28 : Cette plage est obligatoire. Elle est utilisée par Apigee à des fins de dépannage et ne peut être ni personnalisée ni modifiée.

   gcloud compute addresses create google-managed-services-support-1 \
     --global \
     --prefix-length=28 \
     --description="Peering range for supporting Apigee services" \
     --network=$NETWORK_NAME \
     --purpose=VPC_PEERING \
     --addresses=OPTIONAL_ADDRESSES \
     --project=$PROJECT_ID

   Où --addresses vous permet de spécifier une plage d'adresses, si vous le souhaitez. Par exemple, pour allouer le bloc CIDR 192.168.0.0/28, spécifiez 192.168.0.0 pour l'adresse et 28 pour la longueur du préfixe. Consultez également la section Créer une allocation d'adresses IP.

   Si vous ne fournissez pas de paramètre --addresses, gcloud sélectionne automatiquement une plage d'adresses disponible.

5. Vérifiez que la plage d'adresses IP du réseau a été créée avec une longueur CIDR de /28 :

   gcloud compute addresses list --global --project=$PROJECT_ID
   gcloud compute addresses describe google-managed-services-support-1 --global \
     --project=$PROJECT_ID

6. Connectez vos services au réseau à l'aide de la commande suivante :

   gcloud services vpc-peerings connect \
     --service=servicenetworking.googleapis.com \
     --network=$NETWORK_NAME \
     --ranges=$RANGE_NAME,google-managed-services-support-1 \
     --project=$PROJECT_ID

   Cette opération peut prendre plusieurs minutes. En cas de réussite, gcloud renvoie la réponse suivante, où OPERATION_ID correspond à l'UUID de l'opération de longue durée (LRO).

   Operation "operations/OPERATION_ID" finished successfully.

Apigee crée une connexion entre votre réseau et les services de Google. Apigee, en particulier, connecte votre projet à l'API Service Networking via l'appairage de VPC. Apigee associe également des adresses IP à votre projet.

7. Après quelques minutes, vérifiez si l'appairage de VPC a réussi :

   gcloud services vpc-peerings list \
     --network=$NETWORK_NAME \
     --service=servicenetworking.googleapis.com \
     --project=$PROJECT_ID

Étape 5 : Créez une organisation

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 pages suivantes :

• Rôles prédéfinis
• Autorisations de l'assistant de provisionnement
• Autorisations de création d'organisation (organisation payante)

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.

1. 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-$[e-mail] \
        --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:[e-mail]
        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.

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

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

2. 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.
3. 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

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

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

6. 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-$[e-mail]" \
     --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-$[e-mail]" \
    --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:[e-mail]
     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.

3. 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"'",
       "authorizedNetwork":"'"$NETWORK_NAME"'",
       "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.
     • authorizedNetwork : identifie le réseau d'appairage que vous avez spécifié dans la section Configurer la mise en réseau du service.
       Remarque  : Apigee accepte également l'utilisation d'un VPC partagé (c'est-à-dire que le projet de réseau hôte n'est pas le même que celui qui est appairé à Apigee). Pour utiliser un réseau VPC partagé, utilisez le format suivant : projects/HOST_PROJECT_ID/REGION/networks/NETWORK_NAME. Par exemple :
       projects/my-sharedvpc-host/global/networks/mynetwork

       Consultez également les pages Présentation du VPC et Ressource REST : organisations.

     • 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"'",
       "authorizedNetwork":"'"$NETWORK_NAME"'",
       "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.
   • authorizedNetwork : identifie le réseau d'appairage que vous avez spécifié dans la section Configurer la mise en réseau du service.
     Remarque  : Apigee accepte également l'utilisation d'un VPC partagé (c'est-à-dire que le projet de réseau hôte n'est pas le même que celui qui est appairé à Apigee). Pour utiliser un réseau VPC partagé, utilisez le format suivant : projects/HOST_PROJECT_ID/REGION/networks/NETWORK_NAME. Par exemple :
     projects/my-sharedvpc-host/global/networks/mynetwork

     Consultez également les pages Présentation du VPC et Ressource REST : organisations.

   • 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", ... }'

4. Attendez quelques minutes.
5. 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"
     }
   }

   Si Apigee réussit à créer une organisation, vous obtenez une réponse semblable à celle-ci :

   Sans résidence des données

   {
     "name": "my-cloud-project",
     "createdAt": "1592586495539",
     "lastModifiedAt": "1592586495539",
     "environments": [],
     "properties": {
       "property": [
         {
           "name": "features.hybrid.enabled",
           "value": "true"
         },
         {
           "name": "features.mart.connect.enabled",
           "value": "true"
         }
       ]
     },
     "analyticsRegion": "us-west1",
     "runtimeType": "CLOUD",
     "subscriptionType": "PAID",
     "caCertificate": "YOUR_CERTIFICATE",
     "authorizedNetwork": "my-network",
     "projectId": "my-cloud-project"
   }

   Résidence des données

     {
       "name": "my-cloud-project",
       "createdAt": "1681412783749",
       "lastModifiedAt": "1681412783749",
       "environments": [
         "test-env"
       ],
       "properties": {
         "property": [
           {
             "name": "features.mart.connect.enabled",
             "value": "true"
           },
           {
             "name": "features.hybrid.enabled",
             "value": "true"
           }
         ]
       },
       "authorizedNetwork": "default",
       "runtimeType": "CLOUD",
       "subscriptionType": "PAID",
       "caCertificate": "YOUR_CERTIFICATE",
       "runtimeDatabaseEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
       "projectId": "my-cloud-project",
       "state": "ACTIVE",
       "billingType": "PAYG",
       "addonsConfig": {
         "advancedApiOpsConfig": {},
         "integrationConfig": {},
         "monetizationConfig": {},
         "connectorsPlatformConfig": {}
       },
       "apiConsumerDataEncryptionKeyName": "projects/my-cloud-project/locations/us-central1/keyRings/my-key-ring/cryptoKeys/my-key-name",
       "controlPlaneEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
       "apiConsumerDataLocation": "us-central1",
       "apigeeProjectId": "i0c2a37e80f9850ab-tp"
     }
   
   

   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 6 : Créez une instance d'exécution

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'instance d'exécution.

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 :

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

2. 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.
3. 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-$[e-mail] \
        --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.

4. Réservez une plage d'adresses IP qui sera utilisée pour la création de l'instance Apigee.
5. 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.

   Remarque : Par défaut, Apigee alloue à l'instance une plage CIDR disponible avec une taille de préfixe de /22. Dans les cas d'utilisation avancés, vous devrez peut-être spécifier exactement la plage d'adresses IP que vous souhaitez utiliser avec Apigee. Vous devez alors spécifier une plage d'adresses IP personnalisée. Le préfixe de la plage d'adresses IP personnalisée peut être /22 et/ou /28. La plage doit être disponible dans le cadre d'une connexion privée entre votre projet et Apigee.

   Pour spécifier vos propres plages d'adresses IP, utilisez le paramètre de requête ipRange comme décrit dans la documentation de référence de l'API Instances.

   Par exemple, créez une variable d'environnement contenant la plage d'adresses IP au format CIDR:

   MY_IP_RANGE=CIDR_RANGE

   Exemple :

   MY_IP_RANGE=10.0.0.1/22

   Cet exemple montre comment spécifier des plages de /22 et /28 :

   MY_22_RANGE=10.0.0.1/22,MY_28_RANGE=10.0.0.2/28

   • 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"'",
         "ipRange":"'"$MY_22_RANGE,$MY_28_RANGE"'",
         "consumerAcceptList":[ARRAY_OF_PROJECT_IDS]
       }'

   • 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"'",
         "ipRange":"'"$MY_22_RANGE,$MY_28_RANGE"'",
         "consumerAcceptList":[ARRAY_OF_PROJECT_IDS]
       }'

   Notez qu'une fois la plage d'adresses IP créée, vous ne pourrez plus la modifier. Si vous avez besoin de modifier la plage, vous devez créer une autre instance.

   Remarque : En plus de la plage /22 créée, Apigee nécessite une plage CIDR /28 disponible et sans chevauchement. Vous avez créé cette plage /28 à l'étape précédente, Configurer la mise en réseau du service. Cette plage est utilisée par Apigee pour accéder à l'instance à des fins de dépannage et ne peut pas être personnalisée ni modifiée. Consultez également la section Créer des 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.

6. 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 7 : Créez un environnement

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 pages suivantes :

• Rôles prédéfinis
• Autorisations de l'assistant de provisionnement

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

1. 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
2. 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.

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

4. 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"
       }
     ]
   }

5. 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"'"]
     }'

   Conseil : Associer un environnement au groupe permet simplement de rendre les proxys de cet environnement routables via les noms d'hôte du groupe.
6. 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"

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

8. 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 8 : 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 appairage de VPC	N'autorisez que l'accès interne à vos proxys API. Vous devez créer une VM à l'intérieur du réseau et vous y connecter. À partir de la nouvelle VM, vous pouvez envoyer une requête à un proxy d'API Apigee.
Externe avec un MIG	Autorisez l'accès externe à vos proxys API. Utilisez un groupe d'instances géré (MIG) pour envoyer le trafic des API du service de backend d'un équilibreur de charge global à Apigee. Avec cette configuration, Apigee ne peut se connecter qu'au VPC appairé. 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.
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 (VPC)

Pour le routage du trafic des clients internes vers Apigee, vous pouvez choisir d'utiliser la terminaison TLS ou non :

• Options TLS : vous avez le choix entre deux appels proxy d'API à partir de clients internes pour lesquels TLS est activé :
  • (Option 1) Configurez un équilibreur de charge interne (ILB) :
    1. Créez un groupe d'instances géré (MIG) dans votre projet. Pour créer le groupe d'instances géré, suivez les étapes 8a, 8b et 8c dans l'onglet Routage externe (MIG).
    2. Créez et configurez un équilibreur de charge HTTPS(S) interne, puis associez le MIG que vous avez créé au service de backend de l'équilibreur de charge interne, comme expliqué dans la section Configurer un équilibrage de charge HTTP(S) interne avec les backends de groupes d'instances de VM. Avec la configuration ILB, vous disposez d'un contrôle total sur les certificats CA utilisés avec l'ILB.
    3. Consultez la page Appeler un proxy d'API avec accès interne uniquement pour tester la configuration.
  • (Option 2) Utilisez le nom de domaine complet interne par défaut et l'adresse IP de l'équilibreur de charge interne de l'instance Apigee. Cette configuration n'est recommandée qu'à des fins de test et non pour un environnement de production. Dans ce cas, les certificats autosignés créés par Apigee sont utilisés avec l'équilibreur de charge interne d'Apigee et vous ne pouvez pas les modifier. Consultez la page Appeler un proxy d'API avec accès interne uniquement.
• Option non-TLS : si vous n'avez pas besoin d'activer la terminaison TLS, vous pouvez appeler des proxys d'API dans lesquels le client désactive TLS. Par exemple, en utilisant l'option -k avec cURL, vous pouvez désactiver TLS. Consultez la page Appeler un proxy d'API avec accès interne uniquement.

Routage externe (MIG)

Cette section explique comment configurer le routage pour autoriser l'accès externe aux proxys d'API à l'aide d'un groupe d'instances géré (MIG) pour envoyer le trafic d'API à partir du service de backend d'un équilibreur de charge global vers Apigee. 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

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 de routage des accès.

Remarque : Pour une configuration multirégionale, vous devez utiliser les étapes de ligne de commande décrites ici. L'interface utilisateur de provisionnement vous permet uniquement d'ajouter un groupe d'instances géré à l'équilibreur de charge global. Les groupes d'instances gérés ne sont pas globaux, mais régionaux. Par conséquent, pour l'emplacement multirégional, vous devez créer un groupe d'instances géré pour chaque région et l'ajouter au service de backend de l'équilibreur de charge global.

La procédure générale est la suivante :

Étape 8a : Activez l'accès privé à Google pour un sous-réseau de votre réseau VPC
Étape 8b : Configurez des variables d'environnement
Étape 8c : Créez un groupe d'instances géré
Étape 8d : Créez un certificat SSL et une clé pour l'équilibreur de charge
Étape 8e : Créez un équilibreur de charge global
Étape 8f : Obtenez une adresse IP réservée et créez des règles de pare-feu

Toutes ces étapes sont décrites plus en détail dans les sections suivantes.

Étape 8a : Activez l'accès privé à Google pour un sous-réseau de votre réseau VPC

Pour activer l'accès privé à Google pour un sous-réseau de votre réseau VPC, suivez la procédure décrite dans la section Activer l'accès privé à Google.

Remarque : Si vous effectuez une configuration multirégionale, vous devez effectuer cette étape une fois pour chaque région.

Étape 8b : Configurez des variables d'environnement

Multirégional : une configuration multirégionale nécessite un MIG distinct pour chaque région. Si vous configurez plusieurs régions, répétez les étapes 8b et 8c pour chaque région, en remplaçant les variables appropriées pour chaque région.

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. Nous vous recommandons de les définir avant de continuer :

MIG_NAME=apigee-mig-MIG_NAME   # You can choose a different name if you like
VPC_NAME=default       # If you are using a shared VPC, use the shared VPC name
VPC_SUBNET=default     # Private Google Access must be enabled for this subnet
REGION=RUNTIME_REGION        # The same region as your Apigee runtime instance
APIGEE_ENDPOINT=APIGEE_INSTANCE_IP     # See the tip below for details on getting this IP address value

Vous utiliserez ces variables plusieurs fois au cours des processus restants. Si vous souhaitez configurer plusieurs régions, créez des variables avec des valeurs spécifiques à chaque région.

Conseil : Pour obtenir l'adresse IP d'instance Apigee appropriée, utilisez l'API Instances, comme le montre l'exemple suivant :

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

Apigee répond avec des informations détaillées sur l'instance, par exemple :

{
"instances": [
  {
    "name": "my-runtime-instance",
    "location": "us-west1",
    "host": "10.16.0.2",
    "port": "443"
  },
  ...
]
}

L'adresse IP de l'instance, que vous pouvez attribuer à la variable d'environnement $APIGEE_ENDPOINT, correspond à la valeur du champ host. Dans cet exemple, la valeur est 10.16.0.2.

Dans une installation multirégionale, l'appel d'API renvoie les détails de l'instance pour chaque emplacement régional. En pareil cas, vous devez créer un groupe d'instances géré (MIG) distinct pour chaque emplacement lorsque vous effectuez la procédure de la section suivante.

Étape 8c : Créez un groupe d'instances géré

Multirégional : une configuration multirégionale nécessite un MIG distinct pour chaque région. Si vous configurez plusieurs régions, répétez les étapes 8b et 8c pour chaque région, en remplaçant les variables appropriées pour chaque région.

Au cours de cette étape, vous allez créer et configurer un groupe d'instances géré. Lors d'une prochaine étape, vous ajouterez le MIG à un service de backend associé à un équilibreur de charge global. Un groupe d'instances géré est requis pour envoyer le trafic d'API du service de backend de l'équilibreur de charge global à Apigee.

Pour créer un groupe d'instances géré :

1. Créez un modèle d'instance en exécutant la commande suivante.

   gcloud compute instance-templates create $MIG_NAME \
   --project $PROJECT_ID \
   --region $REGION \
   --network $VPC_NAME \
   --subnet $VPC_SUBNET \
   --tags=https-server,apigee-mig-proxy,gke-apigee-proxy \
   --machine-type e2-medium --image-family debian-10 \
   --image-project debian-cloud --boot-disk-size 20GB \
   --no-address \
   --metadata ENDPOINT=$APIGEE_ENDPOINT,startup-script-url=gs://apigee-5g-saas/apigee-envoy-proxy-release/latest/conf/startup-script.sh

   Comme vous pouvez le voir avec cette commande, les machines sont de type e2-medium. Elles exécutent Debian 10 et disposent de 20 Go d'espace disque. Le script startup-script.sh configure le groupe d'instances géré pour acheminer le trafic entrant de l'équilibreur de charge vers l'instance Apigee.

2. Créez un groupe d'instances géré en exécutant la commande suivante :

   gcloud compute instance-groups managed create $MIG_NAME \
   --project $PROJECT_ID --base-instance-name apigee-mig \
   --size 2 --template $MIG_NAME --region $REGION

3. Configurez l'autoscaling pour le groupe en exécutant la commande suivante :
   Remarque : Un MIG régional avec des instances e2-medium peut accepter un maximum de 6 Gbit/s. Si cela ne suffit pas à vos besoins en débit, envisagez de redimensionner la VM et/ou d'augmenter le nombre d'instances répliquées.

   gcloud compute instance-groups managed set-autoscaling $MIG_NAME \
   --project $PROJECT_ID --region $REGION --max-num-replicas 3 \
   --target-cpu-utilization 0.75 --cool-down-period 90

4. Pour définir un port nommé, exécutez la commande suivante :

   gcloud compute instance-groups managed set-named-ports $MIG_NAME \
   --project $PROJECT_ID --region $REGION --named-ports https:443

Étape 8d : Créez un certificat SSL et une clé pour l'équilibreur de charge

Vous ne devez créer les identifiants qu'une seule fois, que vous procédiez à l'installation dans une ou plusieurs régions. Lors d'une prochaine étape, vous associerez ces identifiants au proxy HTTPS cible de l'équilibreur de charge.

Vous pouvez créer les identifiants avec :

• Votre propre certificat émis par une autorité de certification
• Un certificat SSL géré par Google
• Un certificat autosigné (non recommandé en production)

Pour en savoir plus sur la création et l'utilisation de certificats SSL pour l'équilibreur de charge Google Cloud, consultez les pages Certificats SSL et Présentation des certificats SSL.

Dans l'exemple suivant, nous créons un certificat SSL géré par Google :

1. Créez les variables d'environnement suivantes :

   CERTIFICATE_NAME=YOUR_CERT_NAME
   DOMAIN_HOSTNAME=YOUR_DOMAIN_HOSTNAME 

   Définissez DOMAIN_HOSTNAME sur un nom d'hôte de domaine valide que vous avez enregistré. Lors d'une prochaine étape, vous obtiendrez l'adresse IP de l'équilibreur de charge et mettrez à jour l'enregistrement A du domaine afin qu'il pointe vers cette adresse. Par exemple, un nom d'hôte de domaine pourrait ressembler à ceci : foo.example.com.

2. Exécutez la commande gcloud compute ssl-certificates create :

   gcloud compute ssl-certificates create $CERTIFICATE_NAME \
     --domains=$DOMAIN_HOSTNAME \
     --project $PROJECT_ID \
     --global

   Le provisionnement du certificat peut prendre jusqu'à une heure. Pour vérifier l'état du provisionnement, exécutez la commande suivante :

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

   Remarque : Vous pouvez créer plusieurs enregistrements DNS A pour les noms d'hôte de votre groupe d'environnements, pointant tous vers la même adresse IP d'équilibreur de charge.

Étape 8e : Créez un équilibreur de charge global

1. Créez une vérification d'état :

   gcloud compute health-checks create https HEALTH_CHECK_NAME \
   --project $PROJECT_ID --port 443 --global \
   --request-path /healthz/ingress

   Cette vérification d'état vous permettra de vous assurer que le service de backend est en cours d'exécution. Pour configurer des vérifications d'état plus avancées sur un proxy spécifique, consultez la page Effectuer des vérifications d'état.

   Remarque : Si vous rencontrez l'erreur suivante lors de la tentative de création d'une vérification d'état :

   ERROR: unrecognized arguments: --global,

   Essayez de mettre à jour gcloud à l'aide de la commande gcloud components update.

2. Créez un service de backend :

   gcloud compute backend-services create PROXY_BACKEND_NAME \
   --project $PROJECT_ID \
   --protocol HTTPS \
   --health-checks HEALTH_CHECK_NAME \
   --port-name https \
   --timeout 302s \
   --connection-draining-timeout 300s \
   --global

   Remarque : Comme indiqué dans la documentation de référence sur les propriétés des points de terminaison Apigee, l'entrée d'Apigee (équilibreur de charge interne) a un délai avant expiration de 300 secondes par défaut. Le fait de définir le délai avant expiration des services de backend de l'équilibreur de charge sur 302 secondes permet à la commande backend-services de se terminer entièrement dans Apigee en cas de transactions de longue durée. Si vous définissez cette valeur sur une valeur inférieure, par exemple 60 secondes, le délai d'expiration risque d'être dépassé par l'équilibreur de charge avant la fin de la requête, ce qui génère 502 réponses.
3. Ajoutez le MIG à votre service de backend à l'aide de la commande suivante :
   Multirégional : pour une configuration multirégionale, vous devez créer un MIG distinct pour chaque région. Ensuite, répétez cette étape pour ajouter chaque MIG au service de backend. Veillez à spécifier les variables REGION et MIG_NAME appropriées pour chacune des régions.

   gcloud compute backend-services add-backend PROXY_BACKEND_NAME \
   --project $PROJECT_ID --instance-group $MIG_NAME \
   --instance-group-region $REGION \
   --balancing-mode UTILIZATION --max-utilization 0.8 --global

4. Créez un mappage d'URL d'équilibrage de charge à l'aide de la commande suivante :

   gcloud compute url-maps create MIG_PROXY_MAP_NAME \
   --project $PROJECT_ID --default-service PROXY_BACKEND_NAME

5. Créez un proxy HTTPS cible d'équilibrage de charge à l'aide de la commande suivante :

   gcloud compute target-https-proxies create MIG_HTTPS_PROXY_NAME \
   --project $PROJECT_ID --url-map MIG_PROXY_MAP_NAME \
   --ssl-certificates $CERTIFICATE_NAME

Étape 8f : Obtenez une adresse IP réservée et créez des règles de pare-feu

Vous devez attribuer une adresse IP à l'équilibreur de charge, puis créer des règles permettant à l'équilibreur de charge d'accéder au groupe d'instances géré. Vous ne devez effectuer cette étape qu'une seule fois, que vous procédiez à l'installation dans une ou plusieurs régions.

1. Réservez une adresse IP pour l'équilibreur de charge :

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

2. Créez une règle de transfert globale à l'aide de la commande suivante :

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
   --project $PROJECT_ID --address ADDRESSES_NAME --global \
   --target-https-proxy MIG_HTTPS_PROXY_NAME --ports 443

3. Obtenez une adresse IP réservée en exécutant la commande suivante :

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

4. Étape importante : Accédez au site, à l'hôte DNS ou au FAI sur lequel vos enregistrements DNS sont gérés, et assurez-vous que l'enregistrement DNS de votre domaine renvoie l'adresse IP de l'équilibreur de charge Google Cloud. Cette adresse est la valeur de l'adresse IP renvoyée à la dernière étape. Pour en savoir plus, consultez la section Mettre à jour les enregistrements DNS A et AAAA pour qu'ils pointent vers l'adresse IP de l'équilibreur de charge.
5. Créez une règle de pare-feu qui permet à l'équilibreur de charge d'accéder au groupe d'instances géré à l'aide de la commande suivante :

   gcloud compute firewall-rules create FIREWALL_RULE_NAME \
   --description "Allow incoming from GLB on TCP port 443 to Apigee Proxy" \
   --project $PROJECT_ID --network $VPC_NAME --allow=tcp:443 \
   --source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gke-apigee-proxy

   Notez que les plages d'adresses IP 130.211.0.0/22 et 35.191.0.0/16 sont les plages d'adresses IP sources pour Google Load Balancing. Cette règle de pare-feu permet à Google Cloud Load Balancing de passer des requêtes de vérification d'état au groupe d'instances géré.

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

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

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 de routage des accès.

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

1. 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/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.
2. 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.
3. Pour tester la configuration, consultez la page Appeler un proxy d'API avec accès interne uniquement.

Équilibreur de charge régional interne

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 de routage des accès.

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 :

Conseil : Enregistrez vos variables d'environnement dans un fichier texte afin de pouvoir les restaurer facilement si nécessaire.

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é

Remarque : Il s'agit d'une opération unique. Ce sous-réseau proxy réservé n'est requis qu'une seule fois pour n'importe quel é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 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)

1. 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"
     }
   ]
   }

   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.

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

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

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

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

4. 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é.

5. 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é.

6. 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.
7. 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.
8. 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

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 de routage des accès.

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.

1. Assurez-vous d'avoir défini les variables d'environnement de la section Définir des variables d'environnement.
2. 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"
       }
     ]
   }

   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.

3. 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.
4. 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

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

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

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

8. 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.
9. 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.

1. Assurez-vous d'avoir défini les variables de la section Définir des variables d'environnement.
2. 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é.
3. 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"
       }
     ]
   }

   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.
4. 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
5. 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.

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

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

8. 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.
9. 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

10. 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 9 : 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.

Suivez cette procédure si vous avez terminé la configuration des éléments suivants :

• Routage externe (MIG)
• Routage externe (PSC)
• Routage interne (PSC)

Si vous avez configuré le routage interne (VPC), ignorez ces étapes et passez à l'étape Appeler un proxy d'API avec accès interne uniquement.

1. 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é.
2. 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é.

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

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

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