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

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

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

Consultez la documentation d'Apigee Edge.

Ce document explique comment installer et configurer Apigee à partir de la ligne de commande sans appairage de VPC. Ces étapes s'appliquent aux modèles de tarification par abonnement et par paiement à l'usage, pour les organisations payantes, avec ou sans résidence des données activée.

Consultez également Options de provisionnement.

Limites

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

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

Résumé des étapes

Les étapes de provisionnement sont les suivantes :

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

Configurez gcloud 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 :

    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"

    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.

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

    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"

    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.

      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 :

  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

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

  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 : service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. par exemple :

    Service identity created: service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com

Étape 4 : Créez une organisation

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-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
        --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
        --project $PROJECT_ID

      Cette commande associe la clé à l'agent de service Apigee.

      Si la requête réussit, gcloud envoie une réponse semblable à celle-ci :

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

      Si vous obtenez une erreur semblable à celle-ci :

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

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

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

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

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

      Si vous obtenez une erreur semblable à celle-ci :

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

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

    Consultez également la page Dépannage de CMEK.

  4. Créez l'organisation en envoyant la requête suivante à l'API Organizations d'Apigee :

    Sans résidence des données

    curl "https://apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
      -H "Authorization: Bearer $AUTH" \
      -X POST \
      -H "Content-Type:application/json" \
      -d '{
        "name":"'"$PROJECT_ID"'",
        "analyticsRegion":"'"$ANALYTICS_REGION"'",
        "runtimeType":"CLOUD",
        "billingType":"'"$BILLING_TYPE"'",
        "disableVpcPeering":"true",
        "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
      }'

    Où :

    • -d définit la charge utile des données pour la requête. Cette charge utile doit inclure les éléments suivants :
      • name : identifie votre nouvelle organisation. Il doit s'agir du même nom que votre ID de projet.

      • analyticsRegion : spécifie l'emplacement physique dans lequel vos données d'analyse seront stockées.

      • runtimeType : définissez cette valeur sur CLOUD.
      • billingType : spécifie le type de facturation de l'organisation créée.
      • disableVpcPeering : définissez cette valeur sur true si vous ne souhaitez pas utiliser l'appairage de VPC. Par défaut, false.
      • runtimeDatabaseEncryptionKeyName : ID de la clé de chiffrement de l'application que vous avez créée à l'étape précédente. Rappelez-vous que l'ID est structuré comme le chemin d'accès d'un fichier. Exemple :
        projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

    Résidence des données

    Créez une organisation à l'aide de l'API :

    curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
      -H "Authorization: Bearer $AUTH" \
      -X POST \
      -H "Content-Type:application/json" \
      -d '{
        "name":"'"$PROJECT_ID"'",
        "runtimeType":"CLOUD",
        "billingType":"'"$BILLING_TYPE"'",
        "controlPlaneEncryptionKeyName":"'"$CONTROL_PLANE_KEY_ID"'",
        "apiConsumerDataLocation":"'"$CONSUMER_DATA_REGION"'",
        "apiConsumerDataEncryptionKeyName":"'"$CONSUMER_DATA_KEY_ID"'",
        "disableVpcPeering":"true",
        "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
      }'

    Où :

    -d définit la charge utile des données pour la requête. Cette charge utile doit inclure les éléments suivants :

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

    Une fois cette commande exécutée, Apigee démarre une opération de longue durée, qui peut prendre quelques minutes.

    Si vous obtenez une erreur, vérifiez l'utilisation de guillemets autour des valeurs des variables dans la charge utile des données. Assurez-vous d'utiliser des guillemets doubles-simples-doubles autour de la variable $PROJECT_ID, comme illustré dans l'exemple suivant :

    "'"$PROJECT_ID"'"

    Si vous utilisez des chaînes brutes (et non des variables d'environnement) pour les valeurs de requête, vous pouvez les encapsuler entre guillemets doubles dans la chaîne de charge utile entre guillemets simples, comme le montre l'exemple suivant :

    '{ "name":"my-gcp-project", ... }'
  5. Attendez quelques minutes.
  6. Pour vérifier l'état de votre requête de création, vous pouvez envoyer une requête GET à l'API List organizations d'Apigee, comme illustré dans l'exemple suivant :

    Sans résidence des données

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

    Résidence des données

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

    Si la réponse suivante s'affiche, cela signifie que la création de l'organisation n'est pas encore terminée :

    {
      "error": {
        "code": 403,
        "message": "Permission denied on resource \"organizations/apigee-docs-m\" (or it may not exist)",
        "status": "PERMISSION_DENIED"
      }
    }

    En cas de réussite, l'objet de réponse indique "state": "ACTIVE", et vous pouvez passer à l'étape suivante.

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

Étape 5 : Créez une 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
  3. 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.
    • 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.
  4. Créez une clé de chiffrement du disque :
    1. Créez un trousseau de clés du disque :
      gcloud kms keyrings create $DISK_KEY_RING_NAME \
        --location $RUNTIME_LOCATION \
        --project $PROJECT_ID

      Votre trousseau de clés de disque doit être défini sur le même emplacement que l'instance. Chaque instance et chaque trousseau de clés doit avoir son propre emplacement.

    2. Créez une clé de disque :
      gcloud kms keys create $DISK_KEY_NAME \
        --keyring $DISK_KEY_RING_NAME \
        --location $RUNTIME_LOCATION \
        --purpose "encryption" \
        --project $PROJECT_ID

      La clé peut être référencée par son chemin d'accès de clé. Vous pouvez obtenir le chemin d'accès de clé à l'aide de la commande suivante :

      gcloud kms keys list \
        --location=$RUNTIME_LOCATION \
        --keyring=$DISK_KEY_RING_NAME \
        --project=$PROJECT_ID

      Le chemin d'accès de la clé ressemble à ceci :

      projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key
    3. Placez le chemin d'accès de la clé dans une variable d'environnement. Vous utiliserez cette variable dans une commande ultérieure :

      DISK_KEY_ID=YOUR_DISK_KEY_ID

      Par exemple : DISK_KEY_ID=projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

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

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

      Cette commande associe la clé à l'agent de service Apigee.

    Pour en savoir plus, consultez la page À propos des clés de chiffrement Apigee.

  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.

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

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"
    ]
  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"'"]
      }'
  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 7 : Configurez le routage

Au cours de cette étape, vous allez configurer la manière dont les applications clientes communiquent avec Apigee. Le trafic client vers Apigee est également appelé trafic "Northbound". Les options de configuration Northbound incluent les éléments suivants. Accédez à l'option de configuration que vous souhaitez utiliser et suivez les étapes correspondantes :

Type d'accès Description du processus de configuration et de déploiement
Interne avec PSC (nouveau)

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

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

Externe avec PSC (nouveau)

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

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

Chacune de ces approches de routage est présentée dans les instructions ci-dessous.

Routage interne (PSC)

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

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

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

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

Point de terminaison du service

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",
          "createdAt": "1645731488019",
          "lastModifiedAt": "1646504754219",
          "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
          "state": "ACTIVE",
          "runtimeVersion": "1-7-0-20220228-190814",
          "consumerAcceptList": [
            "my-project"
          ],
          "serviceAttachment": "projects/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
        }
      ]
    }
  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. Le provisionnement d'Apigee est terminé. Accédez à la page Déployer un exemple de proxy.

Équilibreur de charge régional interne

Étape 8a : Configurer les variables d'environnement

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

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

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

Où :

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

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

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

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

  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",
          "createdAt": "1645731488019",
          "lastModifiedAt": "1646504754219",
          "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
          "state": "ACTIVE",
          "runtimeVersion": "1-7-0-20220228-190814",
          "consumerAcceptList": [
            "my-project"
          ],
          "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
        }
      ]
      }
  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
  3. Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

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

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

É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"
        }
      ]
    }
  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éé.
    • $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
  6. Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

  7. 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.
  8. 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é.
  9. 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.
  10. 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é :
    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"
        }
      ]
    }
  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
  6. Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

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

    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.
  10. 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
  11. Créez la règle de transfert.
    gcloud compute forwarding-rules create FWD_RULE \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --network-tier=STANDARD \
      --address=ADDRESS_NAME \
      --target-https-proxy=PROXY_NAME \
      --ports=443  --region=$RUNTIME_LOCATION \
      --target-https-proxy-region=$RUNTIME_LOCATION --project=$PROJECT_ID

    Remplacez les éléments suivants :

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

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

Étape 8 : Déployez un exemple de proxy

  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'

    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.