Provisionner une organisation d'évaluation sans appairage de VPC

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

Consultez la documentation d'Apigee Edge.

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

Limites

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

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

Résumé des étapes

Les étapes de provisionnement sont les suivantes :

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

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

  1. Assurez-vous de respecter les exigences répertoriées dans la section Prérequis.
  2. Vous devez auparavant avoir installé gcloud CLI. Si vous devez l'installer, consultez la page Installer gcloud CLI.
  3. Initialisez gcloud CLI comme décrit dans la section Initialiser gcloud CLI ou, si la CLI est déjà initialisée, assurez-vous que le projet Google Cloud que vous avez créé dans la section Prérequis est le projet par défaut pour gcloud.
  4. Définissez les variables d'environnement suivantes : 
    AUTH="Authorization: Bearer $(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
ANALYTICS_REGION="YOUR_ANALYTICS_REGION"

    Où :

    • AUTH définit l'en-tête Authentication avec un jeton de support. Vous utiliserez cet en-tête lors de l'appel des API Apigee. Notez que le jeton expire après un certain temps. Si c'est le cas, il vous suffit de le générer à nouveau en exécutant la même commande. Pour en savoir plus, consultez la page de référence sur la commande print-access-token.
    • PROJECT_ID est l'ID du projet Cloud que vous avez créé dans la section Prérequis.

    • RUNTIME_LOCATION est l'emplacement physique où se trouve l'instance Apigee. Pour obtenir la liste des emplacements d'exécution disponibles, consultez la section Emplacements Apigee.

    • 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 Emplacements Apigee.

      RUNTIME_LOCATION et RUNTIME_LOCATION peuvent se trouver dans la même région, mais pas nécessairement. Toutefois, si elles sont identiques, cela peut améliorer les performances.

  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 ($). 
    echo $AUTH
echo $PROJECT_ID
echo $RUNTIME_LOCATION
echo $ANALYTICS_REGION

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

    Authorization: Bearer ya29.a123456678940B63hPSAMPLEsampleKKYVsample0f3pWDWZDuH2-hENkNa
TvgZ1PD977TMvv6edBQPJezdHw040880Ol_LoD5ZDkt-i-knizia_KhA9L20sSvztL81-SAMPLE42ELPMASk2_
1CxN
my-cloud-project
us-west1
us-west1

Étape 2 : Activez les API

  1. Apigee requiert l'activation de plusieurs API Google Cloud. Activez-les en exécutant la commande services enable :

    gcloud services enable apigee.googleapis.com \
  cloudkms.googleapis.com --project=$PROJECT_ID

  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 (Apigee, Cloud KMS et Compute Engine).

Étape 3 : Créez une organisation

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

  1. Créez une organisation d'évaluation avec l'API provisionOrganization : 
     suppresswarning="true">curl "https://apigee.googleapis.com/v1/projects/$PROJECT_ID:provisionOrganization"  \
  -H "$AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "analyticsRegion":"'"$ANALYTICS_REGION"'",
    "runtimeLocation":"'"$RUNTIME_LOCATION"'",
    "disableVpcPeering":"true",
  }'

    Où :

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

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

      • RUNTIME_LOCATION : emplacement physique où se trouve l'instance Apigee.

      • disableVpcPeering : dans ce flux de provisionnement, nous n'utilisons pas l'appairage de VPC. Cette option doit donc être définie sur true. Par défaut, false.

  2. Apigee démarre une LRO pour créer l'organisation d'évaluation. Cette opération peut prendre jusqu'à 40 minutes.

  3. Pour vérifier l'état de votre requête de création, vous pouvez envoyer une requête GET à l'API List organizations d'Apigee, comme illustré dans l'exemple suivant :
    curl -H "$AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"

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

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

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

Étape 4 : Configurez le routage

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

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

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

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

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

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

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

Routage interne (PSC)

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

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

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

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

Point de terminaison du service

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

  1. Obtenez le rattachement de service à partir de l'instance Apigee : 
    curl -i -X GET -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

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

    {
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "runtimeVersion": "1-7-0-20220228-190814",
      "consumerAcceptList": [
        "my-project"
      ],
      "serviceAttachment": "projects/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
    }
  ]
}
  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. Notez et mémorisez l'adresse IP du point de terminaison de service. Vous aurez besoin de l'adresse IP ultérieurement pour tester la configuration en appelant un proxy d'API. Par exemple : 10.138.0.2.

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

Équilibreur de charge régional interne

Étape 8a : Configurer les variables d'environnement

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

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

  • Définissez les variables d'environnement suivantes dans votre terminal de commande : 
    NEG_NAME=YOUR_NEG_NAME"
TARGET_SERVICE=YOUR_TARGET_SERVICE"
NETWORK_NAME=YOUR_NETWORK_NAME"
SUBNET_NAME=YOUR_SUBNET_NAME"

    Où :

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

    • É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 : 
      curl -i -X GET -H "$AUTH" \
"https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

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

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

    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

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

    3. Ajoutez le NEG au service de backend.
      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.

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

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

      gcloud compute ssl-certificates create CERTIFICATE \
--certificate LB_CERT \
--private-key LB_PRIVATE_KEY
--region=RUNTIME_LOCATION --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • CERTIFICATE : nom du certificat.
      • LB_CERT : chemin d'accès au fichier de certificat au format PEM de votre certificat autogéré.
      • LB_PRIVATE_KEY : chemin d'accès au fichier de clé privée au format PEM pour votre certificat autogéré.

    5. Créez un mappage d'URL pour l'équilibreur de charge.

      Un mappage d'URL doit faire référence à un service de backend par défaut. Définissez le service de backend que vous venez de créer comme service par défaut.

      gcloud compute url-maps create URL_MAP_NAME \
    --default-service=DEFAULT_BACKEND_SERVICE_NAME \
    --global --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • URL_MAP_NAME : nom du mappage d'URL.
      • DEFAULT_BACKEND_SERVICE_NAME : nom du service de backend par défaut de l'équilibreur de charge. La valeur par défaut est utilisée lorsqu'aucune règle d'hôte ne correspond au nom d'hôte demandé.

    6. Utilisez la ressource de certificat SSL pour créer un proxy HTTPS cible.

      gcloud compute target-https-proxies create PROXY_NAME \
--url-map=URL_MAP_NAME \
--ssl-certificates=CERTIFICATE \
--region=$RUNTIME_LOCATION --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • PROXY_NAME : nom du proxy HTTPS cible.
      • URL_MAP_NAME : nom du mappage d'URL.
      • CERTIFICATE : nom de la ressource de certificat.
    7. Créez la règle de transfert. 
      gcloud compute forwarding-rules create FWD_RULE \
--load-balancing-scheme=INTERNAL_MANAGED \
--address=ADDRESS_NAME \
--target-https-proxy=PROXY_NAME \
--ports=443 \
--target-https-proxy-region=$RUNTIME_REGION \
--region=$RUNTIME_REGION
--project=$PROJECT_ID

      Remplacez les éléments suivants :

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

    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 : 
      curl -i -X GET -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

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

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

    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 :

      • 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 : projet Cloud déjà associé à votre organisation Apigee, ou projet Cloud inclus dans consumerAcceptlist lors de la création de l'instance d'exécution Apigee.
    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.

    6. Ajoutez le service de backend au NEG. 
      gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --network-endpoint-group-region=$REGION \
  --global --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • BACKEND_SERVICE_NAME : nom du service de backend.
      • NEG_NAME : nom du groupe de points de terminaison du réseau.
      • REGION : région du groupe de points de terminaison du réseau.

    7. Créez un mappage d'URL pour l'équilibreur de charge.

      Un mappage d'URL doit faire référence à un service de backend par défaut. Définissez le service de backend que vous venez de créer comme service par défaut.

      gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --global --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • URL_MAP_NAME : nom du mappage d'URL.
      • DEFAULT_BACKEND_SERVICE_NAME : nom du service de backend par défaut de l'équilibreur de charge. La valeur par défaut est utilisée lorsqu'aucune règle d'hôte ne correspond au nom d'hôte demandé.

    8. Créez le proxy HTTPS cible.

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

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

      Utilisez cette commande pour créer une ressource de certificat SSL géré par Google : 

      gcloud compute ssl-certificates create CERTIFICATE \
  --domains DOMAIN --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • CERTIFICATE : nom du certificat.
      • DOMAIN : nom de domaine de votre équilibreur de charge

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

      gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • CERTIFICATE : nom du certificat.
      • LB_CERT : chemin d'accès au fichier de certificat au format PEM de votre certificat autogéré.
      • LB_PRIVATE_KEY : chemin d'accès au fichier de clé privée au format PEM pour votre certificat autogéré.

      Utilisez la ressource de certificat SSL pour créer un proxy HTTPS cible.

      gcloud compute target-https-proxies create PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --ssl-certificates=CERTIFICATE --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • PROXY_NAME : nom du proxy HTTPS cible.
      • URL_MAP_NAME : nom du mappage d'URL.
      • CERTIFICATE : nom de la ressource de certificat.
    9. Créez la règle de transfert. 
      gcloud compute forwarding-rules create FWD_RULE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=ADDRESS_NAME \
  --target-https-proxy=PROXY_NAME \
  --ports=443 \
  --global --project=$PROJECT_ID

      Remplacez les éléments suivants :

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

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

    Équilibreur de charge externe régional

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

    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 SUBNET_NAME par le nom du sous-réseau.
      • (Facultatif) Remplacez NETWORK_NAME par le nom du réseau dans lequel le sous-réseau est créé. Si vous omettez ce paramètre, le réseau par défaut du projet est utilisé.
    3. Récupérez le rattachement de service à partir de l'instance que vous avez créée précédemment : 
      curl -i -X GET -H "$AUTH" \
        "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

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

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

    6. Ajoutez le service de backend au NEG. 
      gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • BACKEND_SERVICE_NAME : nom du service de backend.
      • NEG_NAME : nom du groupe de points de terminaison du réseau.

    7. Créez un mappage d'URL pour l'équilibreur de charge.

      Un mappage d'URL doit faire référence à un service de backend par défaut. Définissez le service de backend que vous venez de créer comme service par défaut.

      gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID

      Remplacez les éléments suivants :

      • URL_MAP_NAME : nom du mappage d'URL.
      • DEFAULT_BACKEND_SERVICE_NAME : nom du service de backend par défaut de l'équilibreur de charge. La valeur par défaut est utilisée lorsqu'aucune règle d'hôte ne correspond au nom d'hôte demandé.

    8. Créez le proxy HTTPS cible.

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

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

      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é.
    9. Ajoutez le domaine au groupe d'environnements Apigee qui a été créé pour vous. Le nom du groupe d'environnements est eval-group : 
      curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/eval-group" \
      -H "$AUTH" \
      -X PATCH \
      -H "Content-Type:application/json" \
      -d '{
        "hostnames":["'"DOMAIN"'"]
      }'
    10. Vérifiez l'état de l'opération du groupe d'environnements : 
      curl -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/eval-group/attachments"

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

      Remplacez les éléments suivants :

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

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

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

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

    Appeler le proxy d'API avec un routage interne

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

    Appeler le proxy d'API avec un routage externe

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

    1. Configurez une entrée DNS pour votre domaine. Pour ce faire, vous deux options s'offrent à vous :
      • Au niveau de votre bureau d'enregistrement, créez un enregistrement A pointant vers votre domaine. Par exemple, si votre domaine est sales.example.com et que l'adresse IP est 10.23.0.2, faites pointer l'enregistrement pour sales.example.com vers l'adresse 10.23.0.2.

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

        gcloud compute addresses describe ADDRESS_NAME \
    --format="get(address)" --region=$RUNTIME_LOCATION \
    --project=$PROJECT_ID
      • Utilisez Cloud DNS pour mapper une URL à une adresse IP.
    2. Vérifiez que le proxy hello-world est déployé : 
      curl -i -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/eval/apis/hello-world/revisions/1/deployments"
    3. Appelez le proxy d'API à l'aide de la commande suivante :

      Envoyez une requête au proxy d'API à partir de n'importe quel ordinateur connecté au réseau en exécutant la commande suivante :

      curl -i -H "Host: DOMAIN" \
  https://DOMAIN/hello-world

      Où DOMAIN est le domaine que vous avez saisi dans le certificat et ajouté au groupe d'environnements, comme indiqué à l'Étape 5 : Configurez le routage. Si nécessaire, vous pouvez utiliser cette API pour obtenir la valeur DOMAIN du groupe d'environnements : 

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

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

      Hello, Guest!

      Conseils de dépannage

      Si vous obtenez une erreur de handshake, vérifiez l'état du certificat SSL. Pour en savoir plus sur le dépannage des certificats autogérés et gérés par Google, consultez la section Résoudre les problèmes liés aux certificats SSL.

      Assurez-vous que votre domaine enregistré possède un enregistrement A qui pointe vers l'adresse IP de l'adresse IPv4 externe globale créée à l'étape 5. Exécutez la commande suivante pour afficher l'adresse IP réservée :

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

      Si vous ne parvenez pas à résoudre la configuration du domaine, essayez d'appeler le proxy avec cette commande : 

      curl  -H Host:DOMAIN --resolve \
  DOMAIN:443:EXTERNAL_IP_ADDRESS  \
  https://DOMAIN:443/hello-world -k

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