Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

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

Vous consultez la documentation Apigee Edge.
Accédez à la documentation Apigee X.

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

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 de sidecars : l'injection manuelle et l'injection 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 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 patienter quelques instants jusqu'à ce que le pod passe à l'état "running" (en cours 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 PRÊT 1/1 signifie qu'un service sur un est en cours d'exécution dans le pod. Dans les étapes suivantes, vous allez configurer le cluster pour 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 sur deux" sont en cours d'exécution dans le pod : le service et le side-car.
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 side-car, l'injection manuelle 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 : un environnement dans 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 (dont un exemple est présenté 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 : 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 : code 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 de 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 Tester le proxy.

Utiliser l'injection side-car automatique

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

Installer l'injecteur de side-car

Installez la 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 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 clé-certificat signée par l'autorité de certification (CA) Kubernetes. Le fichier certificat/clé obtenu est stocké en tant que secret Kubernetes pour que le webhook de l'injecteur de side-car puisse l'utiliser. L'approbation de l'autorité de certification Kubernetes nécessite des autorisations pour créer et approuver la demande 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é 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 de l'injecteur de 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 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'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 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 exécuterez 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 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 dans ./install/kubernetes/webhook-edgemicro-patch.sh.
Exécutez la commande indiquée sur 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 de l'injection de webhook. Notez qu'il n'est pas activé pour le moment :

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 désormais 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 obtenir la procédure détaillée, 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".

Récupérer l'adresse IP de l'entrée

Grâce à l'adresse IP externe de l'entrée, vous pouvez appeler le service depuis l'extérieur 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 pour l'entrée 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
```
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 réussit 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 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.
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 d'accès", cliquez sur + Ressource personnalisée.
Ajoutez le chemin /.
Cliquez à nouveau sur + Ressource personnalisée et ajoutez le chemin d'accès /**.
Dans la section "Proxys d'API", cliquez sur + 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 de 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 le hello-world-product que vous venez de créer.
Cliquez sur Enregistrer.
Vous êtes redirigé vers la page listant toutes les applications pour les développeurs.
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 est la clé API que vous utiliserez pour effectuer des appels d'API sécurisés au service helloworld.
Attendez quelques minutes. La synchronisation des modifications apportées à Apigee Edge avec l'instance d'Edge Microgateway déployée dans le cluster prend quelques minutes.

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

Appeler l'API

Une fois les modifications de configuration extraites dans la passerelle de microservices, 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, vous avez besoin de la clé API.
Obtenez la clé client de l'application pour les développeurs 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 helloworld déployé sur le pod. L'appel à ce service est d'abord passé 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 proxy side-car dans le pod de service helloworld.

Étape suivante

Consultez la section Tâches pour savoir comment ajouter des plug-ins personnalisés, mettre à l'échelle le déploiement, modifier la configuration et effectuer d'autres tâches.

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.