Cette page a été traduite par l'API Cloud Translation.

Déployer Edge Microgateway en tant que service

Vous consultez la documentation d'Apigee Edge.
Accédez à la documentation sur Apigee X. info

Introduction

Cet article explique comment exécuter Edge Microgateway dans un cluster Kubernetes en tant que service autonome.

Pour en savoir plus, consultez la présentation de l'intégration d'Edge Microgateway à Kubernetes.

Avant de commencer

Suivez les étapes décrites dans la section Prérequis.

Configurer Edge Microgateway

La commande suivante configure Edge Microgateway pour votre organisation Apigee et déploie le proxy edgemicro-auth.

Exécutez la commande suivante :

edgemicro configure -o [org] -e [env] -u [username]

Où :

org: nom de votre organisation Edge (vous devez être administrateur de l'organisation).
env: environnement de votre organisation (par exemple, "test" ou "prod").
username: adresse e-mail associée à votre compte Apigee.

Exemple

edgemicro configure -o docs -e test -u jdoe@example.com

Le résultat (exemple ci-dessous) est enregistré dans le fichier:

$HOME/.edgemicro/org_name-env_name-config.yaml

current nodejs version is v6.9.1
current edgemicro version is 2.5.25
password:
file doesn't exist, setting up
Give me a minute or two... this can take a while...
App edgemicro-auth deployed.
checking org for existing KVM
KVM already exists in your org
configuring host edgemicroservices.apigee.net for region us-west1

saving configuration information to: /Users/jdoe/.edgemicro/myorg-test-config.yaml

vault info:
 -----BEGIN CERTIFICATE-----
MIICpDCCAYwCCQCV9eBcO9a5WzANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAls
b2NhbGhvc3QwHhcNMagwODA5MDAzMDEzWhcNMTgwODEwMDAzMDEzWjAUMRIwEAYD
VQQDDBlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDh
nAHT7JHX/WvWHRFb8FLm53SPIDld5LyPOUfINdEyhSIEeXoOUKg4EPweJPVSC9Vm
Hw4ZMtEqWJM/XsQWvLe8ylRJa5wgmzmFCqAsuzs9+rmc9KvJqjpOh2uRTUf7KKfT
iXL2UEseprcI5g8zNyqKyEf/ecWIwz3AkkPAZebVTsrdDfIDHvkyhhvlAHZAB9kn
GtqP3N8kOlv4KQto9Gr7GYUGUIDugt7gM1F611+RBS+fYRi32GUAq/UQDkhYL8cp
oIJiF7UYkk2+9t9CdOCDuIUCvJioHJQd0xvDpkC9f6LvwjwnCwku+4F2Q63+av5I
mJoZJQPvW5aP53Qkk+kHAgMBAAEwDKYJKoZIhvcNAQELBQADggEBALyUBolXUFN8
1bf268nR+gS8MOFDTxO1bUz+bKuT/g3K1PuNUJTueT+0L1H2OiZUzazAqwn2sqzN
lQuvLg6LjxjlNkqTJGiJvGDcYVq45dv7UyxAZxhqxTxhlQ+Yu5R9pbQnzujezHpH
6gtCoCkSt/QqiJ3YsmsVu5is+HpIJepMt0CyMh5tK9j87hl46QhHklaVfQ3ycMVm
/wNPR/pjizg1FDUeq4nj/7DBVbMf9net/BDaZLeSW1HJ1vcsCXIcSZfQd4QymGFn
8ADrND7ydVjwO/s23soPDTy0g4yLIZvky2tpT8d7YahNqSv2n7sXsLxruzcyCoQ4
w+e3Z3F7IKI=
-----END CERTIFICATE-----

The following credentials are required to start edge micro
  key: 1a3b2754c7f20614817b86e09895825ecc252d34df6c4be21ae24356f09e6eb4
  secret: 16ad2431de73f07f57a6d44048f08d93b63f783bf1f2ac4221182aa7289c7cef

edgemicro configuration complete!

Déployer Edge Microgateway en tant que service

Exécutez la commande suivante pour déployer Edge Microgateway en tant que service dans votre cluster Kubernetes:
```
kubectl apply -f <(edgemicroctl -org=org -env=env -key=edgemicro-key
-sec=edgemicro-secret -conf=file path of org-env-config.yaml)
```
où :
- org : organisation Apigee que vous avez spécifiée dans la commande edgemicro configure.
- env : environnement que vous avez spécifié dans la commande edgemicro configure.
- edgemicro-key : clé renvoyée par la commande edgemicro configure.
- edgemicro-secret : secret renvoyé par la commande edgemicro configure.
- file path of org-env-config.yaml : chemin d'accès au fichier de configuration Edge Micro renvoyé par la commande edgemicro configure.
Exemple :
```
kubectl apply -f <(edgemicroctl -org=jdoe -env=test -key=989cce9d41cac94e72626d906562a1d76a19445f8901b3508858bb064988eccb -sec=ec92b793178de7b7e88e346f55a951e3fdae05e700e3ddea7d63977826379784 -conf=/Users/jdoe/.edgemicro/jdoe-test-config.yaml)
```
Exemple de résultat :
```
config/myorg-test-config.yaml)
service "edge-microgateway" created
deployment "edge-microgateway" created
secret "mgwsecret" created
```
Copiez et collez le code suivant dans votre terminal. Le code configure le contrôleur d'entrée pour autoriser l'accès externe au service edge-microgateway. Vous devrez peut-être appuyer sur Entrée après avoir collé la commande dans votre terminal:
```
cat <<EOF | kubectl apply -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: edge-microgateway-ingress
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  rules:
  - http:
      paths:
      - path: /
        backend:
          serviceName: edge-microgateway
          servicePort: 8000
EOF
```
Si l'opération réussit, le résultat suivant s'affiche:
```
ingress "edge-microgateway-ingress" created
```
Le contrôleur Ingress est maintenant configuré pour autoriser l'accès externe au service edge-microgateway.

Déployer un service de test

Les étapes suivantes permettent de déployer un service de test simple sur votre cluster. Le contrôleur d'entrée n'autorise pas l'appel du service en dehors du cluster. Vous allez ensuite configurer Edge Microgateway pour qu'il appelle le service en tant que cible. Le contrôleur Ingress autorise l'accès externe au service edge-microgateway.

Déployez l'exemple de service helloworld. Comme l'Ingress ne connaît pas ce service, il ne peut pas être appelé en dehors du cluster.
```
kubectl apply -f samples/helloworld/helloworld-service.yaml
```
Exemple de résultat :
```
service "helloworld" created deployment "helloworld" created
```

Vérifiez que le déploiement a réussi. Notez qu'aucune adresse IP externe n'est attribuée au service helloworld. Dans les étapes suivantes, vous allez configurer Edge Microgateway pour qu'il accède à l'adresse IP interne du service.

kubectl get services -n default

Exemple de résultat :

NAME                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
edge-microgateway   NodePort    10.35.247.222   <none>        8000:32000/TCP   12m
helloworld          NodePort    10.35.245.103   <none>        8081:30294/TCP   47s
kubernetes          ClusterIP   10.35.240.1     <none>        443/TCP          47m

Configurer Edge Microgateway en tant que proxy pour le service

Obtenez l'adresse IP interne du service helloworld, puis ajoutez-la comme cible d'un proxy compatible avec la micro-passerelle. La création d'un proxy "compatible avec la microgateway" est une exigence standard d'Edge Microgateway.

Consultez également la section Ce que vous devez savoir sur les proxys compatibles avec Microgateway.

Obtenir l'adresse IP interne du service de test

Obtenez l'adresse IP et le port du cluster interne pour le service helloworld:

kubectl get services helloworld

Exemple de résultat :

NAME         TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
helloworld   NodePort   10.55.254.255   <none>        8081:30329/TCP   3m

Copiez les valeurs de CLUSTER-IP et PORT. Par exemple, dans l'exemple ci-dessus, ces valeurs sont 10.55.254.255 et 8081. Les valeurs de votre système seront différentes.

Créer un proxy compatible avec Microgateway sur Edge

Connectez-vous à l'UI Edge.
Sélectionnez la même organisation que celle que vous avez spécifiée précédemment lorsque vous avez configuré la micro passerelle Edge.
Sélectionnez Développer > Proxys d'API dans le menu de navigation latéral.
Cliquez sur + Proxy. L'assistant "Créer un proxy" s'ouvre.
Sur la première page de l'assistant, sélectionnez Proxy inverse (le plus courant).
Cliquez sur Suivant.
Sur la page "Détails" de l'assistant, configurez les éléments comme suit. Veillez à remplir l'assistant exactement comme indiqué. Assurez-vous que le nom du proxy comporte le préfixe edgemicro_.
1. Nom du proxy: edgemicro_hello
2. Chemin de base du proxy: /hello
  
  Important :À l'étape suivante, utilisez l'adresse IP du cluster et le numéro de port que vous avez obtenus précédemment. Il s'agit de l'adresse IP cible du proxy.
3. API existante: http://<cluster_ip>:<port>
  
  Par exemple: http://10.55.254.255:8081
Cliquez sur Suivant.
Sur la page "Security" (Sécurité) de l'assistant, sélectionnez Pass through (none) [Direct (aucune)]
Cliquez sur Suivant.
Sur la page "Virtual Hosts" (Hôtes virtuels) de l'assistant, acceptez les valeurs par défaut.
Cliquez sur Suivant.
Sur la page "Build" (Compilation) de l'assistant, vérifiez vos paramètres de proxy. Assurez-vous que l'environnement de test est sélectionné.
Cliquez sur Build and Deploy (Compiler et déployer).

Créer un développeur

Vous pouvez utiliser un développeur existant pour effectuer des tests ou en créer un autre en procédant comme suit :

Sélectionnez Publier > Développeurs dans le menu de navigation latéral.
Cliquez sur + Développeur.
Renseignez les champs de la boîte de dialogue pour créer un développeur. Vous pouvez utiliser le nom et l'adresse e-mail du développeur de votre choix.

Créer un produit d'API

Créez un produit API comme décrit ci-dessous. Vous allez ajouter deux proxy au produit: edgemicro-auth et edgemicro_hello.

Pour en savoir plus sur les options de configuration des produits, consultez Ce que vous devez savoir sur la configuration des produits de l'API.

Dans le menu de navigation latéral, sélectionnez Publier > Produits API.
Cliquez sur + Produit API. La page "Détails du produit" s'affiche.
Renseignez la page d'informations détaillées sur le produit comme suit. Ne cliquez pas sur "Enregistrer" tant que vous n'y êtes pas invité.

Nom hello-world-product

Nom à afficher Edge Micro hello product

Environment test

Accès Public

Type d'approbation de la clé Automatic
Dans la moitié inférieure de la page, cliquez sur + Ressource personnalisée.
Définissez la ressource sur / (une seule barre oblique).
Sélectionnez à nouveau + Ressource personnalisée, puis ajoutez le chemin /**.
En bas de la page, cliquez sur + Proxy d'API.
Sélectionnez le proxy nommé edgemicro-auth.
Cliquez à nouveau sur + Proxy d'API.
Sélectionnez le proxy compatible avec la micro-passerelle nommé edgemicro_hello.
Cliquez sur Enregistrer.

Créer une application de développeur

Sélectionnez Publier > Applications dans le menu de navigation latéral.
Cliquez sur + Application. La page "Developer App Details" (Informations sur l'application de développeur) s'affiche.
Renseignez la page "Application de développeur" comme suit. Ne procédez pas à l'enregistrement tant que vous n'y êtes pas invité.

Nom hello-world-app

Nom à afficher Edge Micro hello app

Developer Sélectionnez le développeur de test que vous avez créé ou un autre développeur.
Dans la section "Identifiants", cliquez sur + Produit, puis sélectionnez le produit que vous avez créé: hello-world-product..
Cliquez sur Enregistrer.
Vous êtes redirigé vers la page qui liste toutes les applications du développeur.
Sélectionnez l'application que vous venez de créer, hello-world-app.
Cliquez sur Afficher à côté de la Clé client.
Copiez la valeur de la clé client. Cette valeur est la clé API que vous utiliserez pour effectuer des appels d'API sécurisés à /hello.
Attendez quelques minutes. Les modifications que vous avez apportées sur Apigee Edge mettent quelques minutes à se synchroniser avec l'instance de la micro passerelle Edge déployée dans le cluster.

Remarque :La micro passerelle Edge interroge les modifications apportées à Apigee Edge toutes les 600 secondes (par défaut) et récupère toutes les modifications de configuration apportées aux proxys, aux produits d'API et aux applications de développement. Vous pouvez modifier la valeur par défaut de 600 s en modifiant le fichier de configuration de la micro-passerelle Edge. Pour en savoir plus, consultez la documentation Edge Microgateway.

Tester le proxy

Obtenir l'adresse IP de l'Ingress

Avec l'adresse IP externe de l'entrée, vous pouvez appeler le service Edge Microgateway en dehors du cluster.

Récupérez l'adresse IP externe du contrôleur Ingress:

kubectl get ing -o wide

Exemple de résultat :

NAME                        HOSTS     ADDRESS          PORTS     AGE
edge-microgateway-ingress   *         35.238.249.62    80        37m

Copiez la valeur ADDRESS de l'Ingress et exportez-la vers une variable. Vous pouvez définir la variable manuellement:

export GATEWAY_IP=external_ip

Exemple :

export GATEWAY_IP=35.238.249.62

Vous pouvez également utiliser cette commande pour le définir:

export GATEWAY_IP=$(kubectl describe ing edge-microgateway --namespace default | grep "Address" | cut -d ':' -f2 | tr -d "[:space:]")

Vérifiez que la variable a été exportée. Exemple :
```
echo $GATEWAY_IP
```
Exemple de résultat :
```
35.238.249.62
```

Appeler l'API

Une fois les modifications de configuration extraites dans la micro-passerelle, vous pouvez essayer d'appeler l'API. Vous utilisez l'adresse IP du contrôleur d'entrée (que vous avez enregistrée dans la variable GATEWAY_IP) pour appeler l'API, car cette adresse vous permet d'appeler le proxy en dehors du cluster Kubernetes. La mise en correspondance de l'entrée à Edge Microgateway a été créée lorsque vous avez déployé Edge Microgateway dans le cluster.

Appelez l'API sans clé API. Un message d'erreur s'affiche, comme indiqué ci-dessous:
```
curl $GATEWAY_IP:80/hello/
```
Résultat attendu :
```
{"error":"missing_authorization","error_description":"Missing Authorization
header"}
```
Si ce message s'affiche, vous devrez peut-être attendre un peu plus longtemps que la synchronisation soit terminée:
```
{"message":"no match found for /hello/","status":404}
```
Pour effectuer des appels d'API réussis, vous avez besoin de la clé API.
Obtenez la clé client dans l'application de développement que vous avez créée. Cette valeur correspond à la clé d'API dont vous avez besoin pour appeler le proxy de test:
```
curl -H 'x-api-key:your-edge-api-key' $GATEWAY_IP:80/hello/
```
Exemple :
```
curl -H "x-api-key:DeX2eEesYAdRJ5Gdbo77nT9uUfJZql19" $GATEWAY_IP:80/hello/
```
Sortie :
```
Hello world
```
Si la réponse "Hello world" s'affiche, vous avez correctement configuré Edge Microgateway pour appeler le service helloworld dans le cluster Kubernetes.

Étape suivante

Consultez la section Tâches pour en savoir plus sur l'ajout de plug-ins personnalisés, la mise à l'échelle du déploiement, la modification de la configuration et d'autres tâches que vous pouvez effectuer.

Nom	`hello-world-product`
Nom à afficher	`Edge Micro hello product`
Environment	`test`
Accès	`Public`
Type d'approbation de la clé	`Automatic`

Nom	`hello-world-app`
Nom à afficher	`Edge Micro hello app`
Developer	Sélectionnez le développeur de test que vous avez créé ou un autre développeur.