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.
Consultez la documentation Apigee X. en savoir plus

Introduction

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

Pour en savoir plus, consultez la page Présentation de l'intégration d'Edge Microgateway avec Kubernetes.

Avant de commencer

Suivez la procédure décrite dans la section Conditions préalables.

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 (test ou production, par exemple).
username: adresse e-mail associée à votre compte Apigee.

Exemple

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

Le résultat (voir l'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 : l'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 : la clé renvoyée par la commande edgemicro configure.
- edgemicro-secret : le 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, vous obtenez le résultat suivant:
```
ingress "edge-microgateway-ingress" created
```
Le contrôleur d'entrée est maintenant configuré pour autoriser l'accès externe au service edge-microgateway.

Déployer un service de test

Les étapes suivantes déploient un service de test simple sur votre cluster. Le contrôleur Ingress ne permet pas d'appeler le service depuis l'extérieur du cluster. Par la suite, vous configurerez Edge Microgateway pour appeler le service en tant que cible. Le contrôleur d'entrée autorise l'accès extérieur au service edge-microgateway.

Déployez l'exemple de service helloworld. Étant donné que l'objet Ingress ne connaît pas ce service, celui-ci ne peut pas être appelé depuis l'extérieur 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'il n'existe pas d'adresse IP externe pour le service helloworld. Dans les étapes suivantes, vous allez configurer Edge Microgateway pour accéder à 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 vers un proxy pour le service

Obtenez l'adresse IP interne du service helloworld et ajoutez-la en tant que cible d'un proxy "compatible avec les micro-passerelles". La création d'un proxy compatible avec les micro-passerelles 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 internes du cluster 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. Dans l'exemple ci-dessus, les valeurs suivantes sont: 10.55.254.255 et 8081. Les valeurs de votre système seront différentes.

Créer un proxy compatible avec la micro-passerelle sur Edge

Connectez-vous à l'interface utilisateur Edge.
Sélectionnez la même organisation que celle que vous avez spécifiée précédemment lors de la configuration d'Edge Microgateway.
Sélectionnez Develop > API Proxies (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, procédez comme suit. Assurez-vous de remplir l'assistant exactement comme indiqué. Assurez-vous que le nom du proxy commence par 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 de 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 "Sécurité" de l'assistant, sélectionnez Passthrough (none).
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 Création de l'assistant, vérifiez vos paramètres 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 la boîte de dialogue pour créer un développeur. Vous pouvez utiliser le nom ou l'adresse e-mail de développeur de votre choix.

Créer un produit d'API

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

Pour en savoir plus sur les options de configuration du produit, consultez la section Ce que vous devez savoir sur la configuration de produit d'API.

Dans le menu de navigation latéral, sélectionnez Publier > Produits API.
Cliquez sur + Produit API. La page "Informations détaillées sur le produit" s'affiche.
Remplissez la page "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

Display Name Edge Micro hello product

Environment test

Accès Public

Type d'approbation de clé Automatic
Dans la moitié inférieure de la page, cliquez sur + Custom Resource (+ Ressource personnalisée).
Définissez la ressource sur / (une seule barre oblique).
Sélectionnez à nouveau + Ressource personnalisée et ajoutez le chemin /**.
Dans la partie inférieure 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 d'informations sur l'application du développeur s'affiche.
Renseignez la page "Application de développeur" comme suit. N'enregistrez pas tant que vous n'y êtes pas invité.

Nom hello-world-app

Display Name Edge Micro hello app

Developer Sélectionnez le développeur de test que vous avez créé (ou n'importe quel 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 revenu sur la page qui répertorie toutes les applications de développement.
Sélectionnez l'application que vous venez de créer (hello-world-app).
Cliquez sur Afficher à côté de Clé client.
Copiez la valeur de la clé client. Cette valeur correspond à la clé API que vous utiliserez pour effectuer des appels d'API sécurisés vers /hello.
Attendez quelques minutes. Il faut quelques minutes pour que les modifications que vous avez apportées à Apigee Edge se synchronisent avec l'instance Edge Microgateway déployée dans le cluster.

Remarque :Edge Microgateway recherche les modifications apportées sur Apigee Edge toutes les 600 secondes (par défaut) et extrait toutes les modifications de configuration apportées aux proxys, aux produits d'API et aux applications de développement. Vous pouvez modifier la valeur 600 par défaut en modifiant le fichier de configuration Edge Microgateway. Pour en savoir plus, consultez la documentation d'Edge Microgateway.

Tester le proxy

Obtenir l'adresse IP d'entrée

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

Obtenez l'adresse IP externe du contrôleur d'entrée:

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'entrée et exportez-la dans 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 la commande suivante pour la 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 micropasserelle, vous pouvez essayer d'appeler l'API. Vous utiliserez 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 IP vous permet d'appeler le proxy depuis l'extérieur du cluster Kubernetes). Le mappage de l'entrée avec Edge Microgateway a été créé lorsque vous avez déployé Edge Microgateway sur le cluster.

Appelez l'API sans clé API. Vous recevrez un message d'erreur, 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 jusqu'à ce 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 à partir de l'application pour développeur que vous avez créée. Cette valeur correspond à la clé 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/
```
Résultat :
```
Hello world
```
Si la réponse "Hello world" s'affiche, cela signifie que vous avez correctement configuré Edge Microgateway pour appeler le service bonjour dans le cluster Kubernetes.

Étape suivante

Consultez la section Tâches pour en savoir plus sur l'ajout de plug-ins personnalisés, le scaling du déploiement, les modifications de configuration et les autres tâches que vous souhaitez effectuer.

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

Nom	`hello-world-app`
Display Name	`Edge Micro hello app`
Developer	Sélectionnez le développeur de test que vous avez créé (ou n'importe quel autre développeur).