Utiliser Apigee Adapter for Envoy avec Apigee hybrid

Cette page s'applique à Apigee et à Apigee hybrid.

Consultez la documentation d'Apigee Edge.

Cet exemple montre comment utiliser Apigee Adapter for Envoy avec un déploiement hybride Apigee.

Prérequis

Avant de commencer :
Téléchargez et installez Apigee Adapter for Envoy Remote Service et la CLI, comme expliqué dans la section Premiers pas.
Assurez-vous que le SDK Google Cloud est installé. Le SDK comprend l'outil de ligne de commande `gcloud`.
Assurez-vous que `kubectl` est installé.

Aperçu

Cet exemple explique comment utiliser Apigee Adapter for Envoy avec Apigee hybride. Dans cet exemple, vous allez déployer un service HTTP simple dans le même cluster Kubernetes où est déployé Apigee hybride. Vous allez ensuite configurer Apigee Adapter for Envoy pour gérer les appels d'API à ce service avec Apigee.

La figure suivante illustre l'architecture de base pour l'intégration hybride Apigee :

Vue d'ensemble de l'adaptateur Envoy intégré à un environnement hybride Apigee, y compris le plan de gestion, le plan d'exécution et les services GCP

Un proxy Envoy est déployé avec le service HTTP cible en tant que side-car Istio dans le maillage de services Istio. Le side-car gère le trafic de l'API vers et depuis le service cible, et communique avec le service distant. Le service distant communique également avec le plan de gestion hybride pour récupérer des informations sur le proxy et le produit d'API.

Vérifier votre configuration gcloud

Vérifiez que votre configuration gcloud est définie sur le projet GCP associé à votre organisation hybride.
Pour répertorier les paramètres actuels :
```
gcloud config list
```
Si nécessaire, définissez l'ID correct du projet GCP avec la commande suivante :
```
gcloud config set project project-id
```
Vous devez être authentifié avec le SDK Google Cloud (gcloud) pour votre projet GCP:
```
gcloud auth login
```

Déployer un service de test sur le cluster

Au cours de cette étape, vous allez déployer un service de test de requêtes/réponse HTTP simple sur le même cluster que celui où Apigee hybrid est déployé.

Accédez au répertoire du service distant:
```
cd $REMOTE_SERVICE_HOME
```
Activez l'injection Istio dans l'espace de noms default du cluster. Dans une étape ultérieure, vous allez déployer un side-car Envoy sur ce même cluster. L'activation de l'injection Istio permet le déploiement side-car. Cet exemple utilise l'espace de noms default et toutes les instructions suivantes utilisent le même.
```
kubectl label namespace default istio-injection=enabled
```
Appliquez le service httpbin simple au cluster dans l'espace de noms par défaut :
```
kubectl apply -f samples/istio/httpbin.yaml
```
Testez maintenant le service. Démarrez un service curl exécuté dans le cluster et ouvrez un terminal :
```
kubectl run -it curl --image=curlimages/curl --restart=Never -- sh
```

Testez le service en l'appelant à partir du cluster :

curl -i httpbin.default.svc.cluster.local/headers

Si l'opération réussit, l'état 200 s'affiche et le service renvoie une liste d'en-têtes. Exemple :

HTTP/1.1 200 OK
server: envoy
date: Tue, 12 May 2020 17:09:01 GMT
content-type: application/json
content-length: 328
access-control-allow-origin: *
access-control-allow-credentials: true
x-envoy-upstream-service-time: 7

{
  "headers": {
    "Accept": "*/*",
    "Content-Length": "0",
    "Host": "httpbin.default.svc.cluster.local",
    "User-Agent": "curl/7.70.0-DEV",
    "X-B3-Parentspanid": "69f88bc3e322e157",
    "X-B3-Sampled": "0",
    "X-B3-Spanid": "8dd725f30e393d8b",
    "X-B3-Traceid": "38093cd817ad30a569f88bc3e322e157"
  }
}

CONSEIL : Laissez le client curl en cours d'exécution et l'interface système ouverte. Vous en aurez besoin lors d'une prochaine étape.

Provisionner Apigee hybrid

Au cours de cette étape, vous allez utiliser la CLI du service distant pour provisionner Apigee hybrid avec le proxy d'API remote-service. La commande de provisionnement configure également un certificat sur Apigee et génère des identifiants que le service distant utilisera pour se reconnecter de manière sécurisée à Apigee.

Accédez au répertoire $CLI_HOME :
```
cd $CLI_HOME
```
Si vous n'êtes pas propriétaire du projet GCP associé à l'organisation Apigee hybrid, assurez-vous que votre compte utilisateur GCP inclut le rôle Apigee Organization Admin. Consultez la section Accorder, modifier et révoquer les accès à des ressources.
Exécutez la commande suivante pour obtenir un jeton d'accès :
```
TOKEN=$(gcloud auth print-access-token);echo $TOKEN
```

Créez les variables d'environnement suivantes. Ces variables seront utilisées en tant que paramètres du script de provisionnement :

export ORG=organization_name
export ENV=environment_name
export RUNTIME=host_alias_url
export NAMESPACE=hybrid_runtime_namespace

Où :

Variable	Description
`organization_name`	Nom de l'organisation Apigee pour l'installation Apigee hybrid.
`environment_name`	Nom d'un environnement dans votre organisation Apigee hybrid.
`host_alias_url`	URL incluant la valeur `hostAlias` pour un hôte virtuel défini dans votre configuration hybride. L'URL doit commencer par `https://`. Par exemple : `https://apitest.apigee-hybrid-docs.net`.
`hybrid_runtime_namepace`	Espace de noms dans lequel les composants d'exécution hybrides sont déployés. Remarque : L'espace de noms par défaut pour un déploiement hybride est `apigee`.

Exécutez la commande suivante pour provisionner le proxy de service distant sur Apigee hybride :
REMARQUE : Si votre installation d'exécution hybride est configurée à l'aide de certificats TLS autosignés pour l'hôte virtuel, vous devez utiliser l'option --insecure avec la commande provision ci-dessous.

REMARQUE : Le résultat de la commande est redirigé vers un fichier de configuration que vous utiliserez ultérieurement.

EN CAS DE MISE À NIVEAU : Si vous mettez à niveau Apigee Adapter for Envoy existant vers la version 1.0-beta.4 ou une version ultérieure, vous devez ajouter l'option --force-proxy-install à la commande provision. Cette option force le proxy Apigee à être remplacé par le dernier proxy.

Si vous n'effectuez pas la mise à niveau, utilisez cette commande pour provisionner Apigee :
```
./apigee-remote-service-cli provision --organization $ORG --environment $ENV \
     --runtime $RUNTIME --namespace $NAMESPACE --token $TOKEN > config.yaml
```
Si vous mettez à niveau, exécutez cette commande avec l'option --force-proxy-install pour provisionner Apigee :
```
./apigee-remote-service-cli provision --force-proxy-install --organization $ORG --environment $ENV \
     --runtime $RUNTIME --namespace $NAMESPACE --token $TOKEN > config.yaml
```

Vérifiez le contenu du fichier config.yaml. Voici un exemple :

# Configuration for apigee-remote-service-envoy
# generated by apigee-remote-service-cli provision on 2020-07-06 18:03:58
apiVersion: v1
kind: ConfigMap
metadata:
  name: apigee-remote-service-envoy
  namespace: apigee
data:
  config.yaml: |
    tenant:
      remote_service_api: https://apitest.apigee-hybrid-docs.net/remote-service
      org_name: hybrid-docs
      env_name: envoy
      allow_unverified_ssl_cert: true
    analytics:
      collection_interval: 10s
      fluentd_endpoint: apigee-udca-hybrid-docs-envoy.apigee:20001
      tls:
        ca_file: /opt/apigee/tls/ca.crt
        key_file: /opt/apigee/tls/tls.key
        cert_file: /opt/apigee/tls/tls.crt
---
apiVersion: v1
kind: Secret
metadata:
  name: hybrid-docs-envoy-policy-secret
  namespace: apigee
type: Opaque
data:
  remote-service.crt: eyJrZXlzIjpbeyJrdHkiOiJSU0EiLCJhbGci...
  remote-service.key: LS0tLS1CRUdJTiBSU0EgUFJJVkFURS...
  remote-service.properties: a2lkPTIwMjAtMDctMDZ...

Appliquez la configuration du service (la sortie du fichier par la commande de provisionnement) au cluster :
```
kubectl apply -f $CLI_HOME/config.yaml
```

Vérifiez votre proxy et votre certificat. La commande suivante doit renvoyer un JSON valide :

curl --http1.1 -i $RUNTIME/remote-service/certs

Le résultat ressemble à ceci :

{
    "keys": [
        {
            "alg": "RS256",
            "e": "AQAB",
            "kid": "2020-05-11T11:32:26-06:00",
            "kty": "RSA",
            "n": "0v-nbTQyAmtVZ-wZRP0ZPIbrVaX91YO9JZ9xCQPb4mOdOSS7yKfTDJGg0KM130sGVYBvR76alN8
            fhrrSDEG5VXG8YYMqPXarwRC7MRJWocCQ_ECYrjDD0_Q018M2HyXZYSd8fhAogi9mVUYsEmCKqJH53Dh1
            jqsHOQzBLKsX0iDO9hEZNFtjbX0UCbSxsUlmBCub7Uj2S-PahA6DEQOMhQjZM7bBMtkTMpFmaJ_RZTmow
            BHP57qMna17R8wHD4kUsO2u_-3HHs5PSj1NrEYoVU2dwLQw0GlkB__ZWeFgXTqot81vb-PmoM9YxwoZrm
            TcHdljugWy_s7xROPzTod0uw"
        }
    ]
}

Exécuter le service distant pour Envoy

Dans cette étape, vous démarrez le service distant pour Envoy client dans le maillage de services où Apigee hybride est installé. Ce service fournit les points de terminaison aux side-cars Istio installés sur les services cibles. Plus tard, vous installerez un side-car avec le service httpbin.

Ouvrez $REMOTE_SERVICE_HOME/samples/istio/hybrid-apigee-remote-service-envoy.yaml dans un éditeur.
Vous devrez peut-être ajuster la configuration si vous n'utilisez pas la dernière version du service distant. Si vous utilisez la dernière version, passez à l'étape suivante. Si vous n'utilisez pas la dernière version, définissez l'élément image: pour référencer votre version. Par exemple, si vous utilisez la version v1.0.0-beta.4, remplacez l'option image par:
```
image: "gcr.io/apigee-api-management-istio/apigee-remote-service-envoy:v1.0.0-beta.4"
```

Définissez l'élément tls-volume.secretName sur votre organisation et votre environnement:

...
  volumes:
    - name: tls-volume
       secret:
         defaultMode: 420
         secretName: apigee-runtime-$ORG-$ENV-tls
     - name: policy-secret
       secret:
         defaultMode: 420
         secretName: $ORG-$ENV-policy-secret

Exemple :

...
  volumes:
    - name: tls-volume
       secret:
         defaultMode: 420
         secretName: apigee-runtime-myorg-myenv-tls
     - name: policy-secret
       secret:
         defaultMode: 420
         secretName: myorg-myenv-policy-secret
...

Appliquez le service distant Apigee au maillage de services:

kubectl apply -f $REMOTE_SERVICE_HOME/samples/istio/hybrid-apigee-remote-service-envoy.yaml

Appliquez l'objet EnvoyFilter aux side-cars Istio dans l'espace de noms par défaut. EnvoyFilter permet au side-car httpbin de communiquer avec le service distant Apigee.
```
kubectl apply -f $REMOTE_SERVICE_HOME/samples/istio/envoyfilter-sidecar.yaml
```

Tester l'installation

Revenez à l'interface système curl que vous avez ouverte à l'étape Déployer un service de test sur le cluster et appelez le service httpbin :
```
curl -i httpbin.default.svc.cluster.local/headers
```
Le service est désormais géré par Apigee, et puisque vous n'avez pas fourni de clé API, cet appel renvoie l'erreur suivante.
```
curl -i httpbin.default.svc.cluster.local/headers
HTTP/1.1 403 Forbidden
date: Tue, 12 May 2020 17:51:36 GMT
server: envoy
content-length: 0
x-envoy-upstream-service-time: 11
```
Configurez un produit d'API et obtenez une clé API comme expliqué dans la section Comment obtenir une clé API.

Effectuez un appel d'API à l'aide de la clé :

export APIKEY=YOUR_API_KEY
curl -i httpbin.default.svc.cluster.local/headers -H "x-api-key: $APIKEY"

L'appel doit réussir avec un code d'état 200 et renvoyer une liste d'en-têtes dans la réponse. Exemple :

curl -i httpbin.default.svc.cluster.local/headers -H "x-api-key: kyOTalNNLMPfOSy6rnVeclmVSL6pA2zS"
HTTP/1.1 200 OK
server: envoy
date: Tue, 12 May 2020 17:55:34 GMT
content-type: application/json
content-length: 828
access-control-allow-origin: *
access-control-allow-credentials: true
x-envoy-upstream-service-time: 301

{
  "headers": {
    "Accept": "*/*",
    "Content-Length": "0",
    "Host": "httpbin.default.svc.cluster.local",
    "User-Agent": "curl/7.70.0-DEV",
    "X-Api-Key": "kyOTalNNLMPfOSy6rnVeclmVSL6pA2zS",
    "X-Apigee-Accesstoken": "",
    "X-Apigee-Api": "httpbin.default.svc.cluster.local",
    "X-Apigee-Apiproducts": "httpbin",
    "X-Apigee-Application": "httpbin",
    "X-Apigee-Authorized": "true",
    "X-Apigee-Clientid": "kyOTalNNLMPfOSy6rnVeclmVSL6pA2zS",
    "X-Apigee-Developeremail": "jdoe@example.com",
    "X-Apigee-Environment": "envoy",
    "X-Apigee-Organization": "acme-org",
    "X-Apigee-Scope": "",
    "X-B3-Parentspanid": "1476f9a2329bbdfa",
    "X-B3-Sampled": "0",
    "X-B3-Spanid": "1ad5c19bfb4bc96f",
    "X-B3-Traceid": "6f329a34e8ca07811476f9a2329bbdfa"
  }
}

Étapes suivantes

Le trafic d'API vers le service httpbin est désormais géré par Apigee. Voici quelques fonctionnalités que vous pouvez explorer et essayer:

Si vous avez configuré votre produit d'API comme expliqué dans la section Comment obtenir une clé API, la limite de quota a été définie sur 5 requêtes par minute. Essayez d'appeler le service httpbin plusieurs fois pour déclencher le quota. Lorsque vous dépassez le quota, le message d'erreur suivant s'affiche:
```
HTTP/1.1 429 Too Many Requests
```
Accédez à Apigee Analytics dans l'interface utilisateur Edge. Accédez à Analyser> Métriques API > Performances des proxys d'API.
Générez et utilisez des jetons JWT pour authentifier les appels d'API.
Utilisez l'interface de ligne de commande pour gérer, créer des jetons et contrôler les liaisons. Pour plus d'informations sur la CLI, consultez la documentation de référence.