Effectuer le provisionnement d'une organisation payante avec l'appairage de VPC

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

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

  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.

  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

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

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

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

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

    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.

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

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

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

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.

Étape 8b : Configurez des 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. 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.

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

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

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

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

  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
  3. Ajoutez le MIG à votre service de backend à l'aide de la commande suivante :
    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

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

É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",
        "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"
      }
    ]
    }
  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 9 : 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.