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

OBSOLÈTE : Vous pouvez exécuter Edge Microgateway dans Kubernetes à l'aide du modèle de proxy side-car. Toutefois, edgemicroctl et les outils associés décrits dans cet article sont obsolètes. Ces outils reposent sur l'injecteur de side-car Istio, qui n'est plus accepté.

Introduction

Cet article explique comment exécuter Edge Microgateway dans un cluster Kubernetes en tant que proxy side-car. Vous disposez de deux options pour le déploiement side-car: l'injection manuelle et l'injection automatique. Cet article décrit les deux options.

Pour plus d'informations, consultez la page Présentation d'Edge Microgateway sur Kubernetes.

Avant de commencer

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

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 attendre quelques instants jusqu'à ce que le pod passe à l'état d'exécution:
```
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 (PRÊT) 1/1 signifie que des services "un seul" sont en cours d'exécution dans le pod. Dans les étapes suivantes, vous allez configurer le cluster de sorte qu'Edge Microgateway soit automatiquement injecté en tant que side-car dans tous les pods que vous créez. Dans ce cas, lorsque vous exécutez kubectl get pods, vous verrez que "deux des deux" services sont en cours d'exécution dans le pod: le service et le side-car.
Supprimez le déploiement du service de test. Vous la réinstallerez ultérieurement, après avoir activé l'injection side-car:
```
 kubectl delete -f samples/helloworld/helloworld.yaml --namespace=default
```

Utiliser l'injection manuelle de side-car

Parmi les deux options d'injection side-car, l'injection manuelle de side-car est l'approche la plus simple et la plus directe. Elle peut être effectuée à l'aide d'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 (test ou production, par exemple).
username: adresse e-mail associée à votre compte Apigee.

Exemple

edgemicro configure -o myorg -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!

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 la commande suivante:

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 : l'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 : la clé renvoyée par la commande edgemicro configure.
your_secret : le 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 side-car 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 du service:

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 side-car d'Edge Microgateway. Pour obtenir la procédure détaillée, consultez la page Tester le proxy.

Utiliser l'injection side-car automatique

Dans les étapes suivantes, vous allez configurer l'injection automatique de side-car pour votre cluster Kubernetes. Cette configuration permet à Edge Microgateway d'être injecté en tant que proxy side-car dans Kubernetes.

Installez l'injecteur de side-car

Installez le ConfigMap qui permet l'injection 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 de webhook. Le service de webhook est requis pour l'injection side-car automatique:

Remarque :Un service de webhook nécessite une paire certificat/clé signée. Le script suivant génère une paire certificat/clé signée par l'autorité de certification Kubernetes. Le certificat/fichier de clé obtenu est stocké en tant que secret Kubernetes pour que le webhook d'injecteur de side-car puisse l'utiliser. L'approbation par l'autorité de certification Kubernetes nécessite des autorisations pour créer et approuver la demande de signature de certificat. Consultez également la page Gérer les données tls dans un cluster et examinez le script install/kubernetes/webhook-create-signed-cert.sh pour en savoir plus.
```
./install/kubernetes/webhook-create-signed-cert.sh \
    --service edgemicro-sidecar-injector \
    --namespace edgemicro-system \
    --secret sidecar-injector-certs
```

Ajoutez le groupe 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 d'injecteur side-car Edge Microgateway 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'endroit 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 side-car:

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 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 un 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 dans ./install/kubernetes/webhook-edgemicro-patch.sh.
Exécutez la commande indiquée dans la dernière ligne du résultat. 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
```

Affichez l'état d'injection du webhook. Notez qu'elle n'est actuellement pas 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 la commande suivante pour activer l'injection de webhooks:
```
kubectl label namespace default edgemicro-injection=enabled
```

Affichez à nouveau l'état de l'injection du webhook. Notez qu'elle est désormais activée:

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

À présent, redéployez le service de test. Edge Microgateway est 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 side-car automatique d'Edge Microgateway. Pour obtenir la procédure détaillée, consultez la page Tester le proxy.

Tester le proxy

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

Obtenir l'adresse IP d'entrée

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

Copiez la valeur EXTERNAL-IP 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 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
```
Résultat :
```
{"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éveloppeur 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

Ensuite, créez un produit d'API et une application de développement sur 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.
Remplissez la page "Product" (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

Display Name Edge Micro hello product

Environment test
Dans la section "Chemin d'accès", cliquez sur + Ressource personnalisée.
Ajoutez le chemin /.
Cliquez à nouveau sur + Ressource personnalisée et ajoutez le chemin /**.
Dans la section "API Proxies" (Proxies d'API), cliquez sur + API Proxy (+ Proxy d'API) et 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 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 un développeur dans le menu déroulant.
Dans la section "Identifiants", cliquez sur + Produit, puis sélectionnez le hello-world-product que vous venez de créer.
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 le service helloworld.
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.

Appeler l'API

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

Appelez l'API sans clé API. Vous recevrez un message d'erreur, 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 à 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
```
Exemple :
```
curl -H "x-api-key:DeX2eEesYAdRJ5Gdbo77nT9uUfJZql19" $GATEWAY_IP
```
Résultat :
```
Hello world
```
La réponse "Hello World" est renvoyée par le service bonjour déployé sur le pod. L'appel à ce service est d'abord transmis par Edge Microgateway, où l'authentification a été effectuée. Si la réponse "Hello world" s'affiche, cela signifie que vous avez correctement configuré Edge Microgateway pour qu'il fonctionne comme un proxy side-car dans le pod de service bonjour.

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

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