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

Déployer Edge MicroGate en tant que proxy side-car

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

OBSOLÈTE : L'exécution d'Edge Microgateway dans Kubernetes à l'aide du modèle de proxy side-car est prise en charge. Toutefois, edgemicroctl et les outils associés décrits dans cet article sont obsolètes. Cet outil repose sur l'injecteur de sidecar Istio, qui n'est plus pris en charge.

Introduction

Cet article explique comment exécuter Edge Microgateway dans un cluster Kubernetes en tant que proxy sidecar. Vous avez le choix entre deux options de déploiement de sidecar: l'injection manuelle et automatique. Cet article décrit les deux options.

Pour en savoir plus, consultez Présentation d'Edge Microgateway sur Kubernetes.

Avant de commencer

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

Déployer un service de test

Déployez un service "hello" simple et vérifiez le déploiement:

Déployer l'exemple d'application à l'aide de la commande suivante :

kubectl apply -f samples/helloworld/helloworld.yaml --namespace=default

Vérifiez que le service est en cours d'exécution. Vous devrez peut-être patienter quelques instants jusqu'à ce que le pod passe à l'état "Running" :
```
kubectl get pods --namespace=default
```
Exemple de résultat :
```
NAME                          READY     STATUS    RESTARTS   AGE
helloworld-569d6565f9-lwrrv   1/1       Running   0          17m
```
Remarque :Notez que l'état READY de 1/1 signifie qu'un seul service s'exécute dans le pod. Dans les étapes suivantes, vous allez configurer le cluster afin qu'Edge Microgateway soit automatiquement injecté en tant que side-car dans tous les nouveaux pods que vous créez. Dans ce cas, lorsque vous exécutez kubectl get pods, vous verrez que deux services s'exécutent dans le pod: le service et le sidecar.
Supprimez le déploiement du service de test. Vous le réinstallerez plus tard, après avoir activé l'injection de sidecar:
```
 kubectl delete -f samples/helloworld/helloworld.yaml --namespace=default
```

Utiliser l'injection manuelle de side-car

Parmi les deux options d'injection de side-car, l'injection manuelle de side-car est l'approche la plus simple et la plus directe. Elle peut être effectuée avec une seule commande kubectl.

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

Injecter Edge Microgateway en tant que side-car

Pour injecter manuellement Edge Microgateway dans un pod de service en tant que proxy side-car, exécutez cette commande:

kubectl apply -f <(edgemicroctl -org=your_org -env=your_env -key=your_key -sec=your_secret -conf=config_file_path -svc=service_deployment_file)

où :

your_org : organisation Apigee que vous avez spécifiée dans la commande edgemicro configure.
your_env : environnement que vous avez spécifié dans la commande edgemicro configure.
your_key : clé renvoyée par la commande edgemicro configure.
your_secret : secret renvoyé par la commande edgemicro configure.
config_file_path : chemin d'accès au fichier de configuration Edge Micro renvoyé par la commande edgemicro configure.
service_deployment_file : chemin d'accès au fichier de déploiement du service dont le pod recevra le service sidecar associé. Exemple : samples/helloworld/helloworld.yaml.

Exemple :

kubectl apply -f <(edgemicroctl -org=myorg -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/jdoe/.edgemicro/myorg-test-config.yaml -svc=samples/helloworld/helloworld.yaml)

Tester la configuration

Vérifiez les déploiements de services:

kubectl get services -n default

Exemple de résultat :

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
helloworld   NodePort    10.15.254.163   <none>        8081:32401/TCP   56s
kubernetes   ClusterIP   10.15.240.1     <none>        443/TCP          41m

Vous êtes maintenant prêt à tester le déploiement du sidecar d'Edge Microgateway. Pour en savoir plus, consultez Tester le proxy.

Utiliser l'injection side-car automatique

Dans les étapes suivantes, vous allez configurer l'injection automatique de sidecar pour votre cluster Kubernetes. Cette configuration permet d'injecter Edge Microgateway en tant que proxy sidecar dans Kubernetes.

Installer l'injecteur de side-car

Installez le ConfigMap qui permet l'injection de side-car d'Edge Microgateway:

kubectl apply -f install/kubernetes/edgemicro-sidecar-injector-configmap-release.yaml

Exécutez le script suivant pour installer le service webhook. Le service webhook est requis pour l'injection side-car automatique:

Remarque :Un service webhook nécessite une paire certificat/clé signée. Le script suivant génère une paire de certificat/clé signée par l'autorité de certification Kubernetes. Le fichier de certificat/clé généré est stocké en tant que secret Kubernetes pour être consommé par le webhook de l'injecteur de sidecar. L'approbation de l'autorité de certification Kubernetes nécessite des autorisations pour créer et approuver la requête de signature de certificat (CSR). Pour en savoir plus, consultez également Gérer TLS dans un cluster et examinez le script install/kubernetes/webhook-create-signed-cert.sh.
```
./install/kubernetes/webhook-create-signed-cert.sh \
    --service edgemicro-sidecar-injector \
    --namespace edgemicro-system \
    --secret sidecar-injector-certs
```

Ajoutez le bundle d'autorités de certification au fichier d'installation du webhook. Le serveur d'API Kubernetes utilise ce fichier pour appeler le webhook:

cat install/kubernetes/edgemicro-sidecar-injector.yaml | \
     ./install/kubernetes/webhook-patch-ca-bundle.sh > \
     install/kubernetes/edgemicro-sidecar-injector-with-ca-bundle.yaml

Installez le webhook d'injecteur side-car Edge Microgateway:

kubectl apply -f install/kubernetes/edgemicro-sidecar-injector-with-ca-bundle.yaml

Exemple de résultat :

service "edgemicro-sidecar-injector" created
serviceaccount "edgemicro-sidecar-injector-service-account" created
deployment "edgemicro-sidecar-injector" created
mutatingwebhookconfiguration "edgemicro-sidecar-injector" created

Vérifiez que le webhook de l'injecteur de side-car de la micro-passerelle Edge est en cours d'exécution:

kubectl -n edgemicro-system get deployment -ledgemicro=sidecar-injector

Exemple de résultat :

NAME                         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
edgemicro-sidecar-injector   1         1         1            1           12m

Vérifiez que le pod d'injection de side-car est en cours d'exécution dans votre cluster. L'espace de noms edgemicro-system est l'emplacement où les services système sont installés, y compris le contrôleur d'entrée, le backend HTTP par défaut et l'injecteur de sidecar:

kubectl get pods -n edgemicro-system

Exemple de résultat :

NAME                                            READY     STATUS    RESTARTS   AGE
default-http-backend-55c6c69b88-gfnfd           1/1       Running   0          1h
edgemicro-ingress-controller-64444469bf-jhn8b   1/1       Running   3          1h
edgemicro-sidecar-injector-7d95698fbf-cq84q     1/1       Running   0          3m

Configurer et injecter Edge Microgateway

À l'étape suivante, vous allez exécuter un script interactif pour créer une configuration Edge Microgateway associée à un espace de noms Kubernetes. Vous allez ensuite injecter la configuration dans votre cluster Kubernetes.

Exécutez le script interactif suivant et fournissez les paramètres demandés. La commande génère un profil de configuration que vous utiliserez à l'étape suivante.
```
./install/kubernetes/webhook-edgemicro-patch.sh
```
Pour en savoir plus sur les paramètres d'entrée, consultez la section Documentation de référence.

Exemples d'entrées:
1. Namespace to deploy application [default]:
  
  Appuyez sur Entrée.
2. Authenticate with OAuth Token ("n","Y") [N/y]
  
  Saisissez n.
3. Apigee username [required]:
  
  Saisissez votre nom d'utilisateur Apigee (adresse e-mail). Exemple : jdoe@google.com.
4. Apigee password [required]:
  
  Saisissez votre mot de passe Apigee.
5. Apigee organization [required]:
  
  Saisissez le nom de votre organisation Apigee.
6. Apigee environment [required]:
  
  Saisissez un nom d'environnement pour votre organisation. Par exemple, "test".
7. Virtual Host [default]:
  
  Appuyez sur Entrée.
8. Is this Private Cloud ("n","y") [N/y]:
  
  Saisissez n si vous utilisez le cloud public.
9. Edgemicro Key. Press Enter to generate:
  
  Appuyez sur Entrée.
10. Edgemicro Secret. Press Enter to generate:
  
  Appuyez sur Entrée.
11. Edgemicro org-env-config.yaml. Press Enter to generate:
  
  Appuyez sur Entrée.
  
  Exemple de résultat :
```
current nodejs version is v6.9.1
current edgemicro version is 2.5.25
config initialized to /Users/jdoe/.edgemicro/default.yaml
Configure for Cloud
******************************************************************************************
Config file is Generated in /Users/jdoe/Work/GITHUB/microgateway_2.5.25_Darwin_x86_64/config directory.

Please make changes as desired.
*****************************************************************************************
```
12. Do you agree to proceed("n","y") [N/y]:
  
  Saisissez y.
  
  Exemple de résultat :
```
Configuring Microgateway with

key:daacf75dd660d160b801c9117fb1ec0935896615479e39dbbae88be81a2d84
secret:a60fd57c1db9f3a06648173fb541cb9c59188d3b6037a76f490ebf7a6584b0
config:~/.edgemicro/jdoe-test-config.yaml

********************************************************************************************************
kubectl apply -f install/kubernetes/edgemicro-config-namespace-bundle.yaml
********************************************************************************************************
```
Remarque :Vous pouvez également transmettre des paramètres au script pour une utilisation non interactive. Pour en savoir plus, consultez les commentaires fournis dans ./install/kubernetes/webhook-edgemicro-patch.sh.
Exécutez la commande indiquée dans la dernière ligne de la sortie. Cette commande kubectl injecte le profil de configuration Edge Microgateway généré dans Kubernetes:
```
kubectl apply -f install/kubernetes/edgemicro-config-namespace-bundle.yaml
```

Afficher l'état de l'injection de webhook Notez qu'elle n'est pas encore activée:

kubectl get namespace -L edgemicro-injection

Exemple de résultat :

NAME               STATUS    AGE       EDGEMICRO-INJECTION
default            Active    1d
edgemicro-system   Active    1d
kube-public        Active    1d
kube-system        Active    1d

Exécutez cette commande pour activer l'injection de webhook pour le webhook:
```
kubectl label namespace default edgemicro-injection=enabled
```

Affichez à nouveau l'état de l'injection de webhook. Notez qu'il est maintenant activé:

kubectl get namespace -L edgemicro-injection

Exemple de résultat :

NAME               STATUS    AGE       EDGEMICRO-INJECTION
default            Active    1d        enabled
edgemicro-system   Active    1d
kube-public        Active    1d
kube-system        Active    1d

Déployer le service de test

Redéployez maintenant le service de test. Edge Microgateway sera automatiquement injecté dans le pod du service.

kubectl apply -f samples/helloworld/helloworld.yaml --namespace=default

Vérifiez qu'Edge Microgateway a été injecté dans le pod avec le service de test:

kubectl get pods --namespace=default --watch

Exemple de résultat :

NAME                          READY     STATUS            RESTARTS   AGE
helloworld-6987878fc4-pkw8h   0/2       PodInitializing   0          12s
helloworld-6987878fc4-pkw8h   2/2       Running           0         26s

Lorsque l'état passe à Running, appuyez sur ctrl-c pour quitter la commande.

Vous êtes maintenant prêt à tester le déploiement automatique de side-car d'Edge Microgateway. Pour en savoir plus, consultez Tester le proxy.

Tester le proxy

Avec le déploiement side-car, un proxy d'API est créé automatiquement pour votre service. Vous n'avez pas besoin de créer un proxy "compatible avec Edge Microgateway".

Obtenir l'adresse IP de l'Ingress

Avec l'adresse IP externe de l'entrée, vous pouvez appeler le service 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
gateway   *         35.238.13.54   80        1m

Copiez la valeur EXTERNAL-IP 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 gateway --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
```
Appelez le service:
```
curl $GATEWAY_IP
```
Sortie :
```
{"error":"missing_authorization","error_description":"Missing Authorization header"}
```
Vous allez ensuite résoudre l'erreur d'autorisation manquante en configurant un produit d'API et une application de développement sur Edge afin d'obtenir une clé API valide. Lorsque vous ajoutez la clé à un en-tête d'autorisation pour l'appel d'API, l'appel aboutit et cette erreur ne s'affiche pas.

Créer des composants sur Apigee Edge

Créez ensuite un produit d'API et une application de développeur dans Apigee Edge.

Créer un produit d'API

Connectez-vous à Apigee Edge.
Dans le menu de navigation latéral, sélectionnez Publier > Produits API.
Cliquez sur + Produit API. La page du produit s'affiche.
Renseignez la page "Produit" comme suit. Pour les champs qui ne sont pas mentionnés ci-dessous, vous pouvez utiliser les valeurs par défaut. Ne procédez pas à l'enregistrement tant que vous n'y êtes pas invité.

Nom hello-world-product

Nom à afficher Edge Micro hello product

Environment test
Dans la section "Chemin", cliquez sur + Ressource personnalisée.
Ajoutez le chemin /.
Cliquez à nouveau sur + Ressource personnalisée, puis ajoutez le chemin d'accès /**.
Dans la section "Proxys d'API", cliquez sur + Proxy d'API, puis ajoutez edgemicro-auth.
Enregistrez le produit d'API.

Créer une application de développeur

Sélectionnez 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 un développeur dans le menu déroulant.
Dans la section "Identifiants", cliquez sur + Produit et sélectionnez l'hello-world-product que vous venez de créer.
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 correspond à la clé API que vous utiliserez pour effectuer des appels d'API sécurisés au service helloworld.
Attendez quelques minutes. Les modifications que vous avez apportées sur Apigee Edge prennent 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.

Appeler l'API

Une fois les modifications de configuration extraites dans la micro-passerelle, vous pouvez effectuer les tests suivants.

Appelez l'API sans clé API. Un message d'erreur s'affiche, comme indiqué ci-dessous:
```
curl $GATEWAY_IP
```
Résultat attendu :
```
{"error":"missing_authorization","error_description":"Missing Authorization
header"}
```
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
```
Exemple :
```
curl -H "x-api-key:DeX2eEesYAdRJ5Gdbo77nT9uUfJZql19" $GATEWAY_IP
```
Sortie :
```
Hello world
```
La réponse "Hello world" est renvoyée par le service helloworld déployé dans le pod. L'appel de ce service est d'abord passé par Edge Microgateway, où l'authentification a été effectuée. Si la réponse "Hello world" s'affiche, vous avez correctement configuré Edge Microgateway pour qu'il fonctionne en tant que proxy side-car dans le pod de service helloworld.

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

Nom	`hello-world-app`
Nom à afficher	`Edge Micro hello app`
Developer	Sélectionnez un développeur dans le menu déroulant.