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

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

<ph type="x-smartling-placeholder"></ph> Vous consultez la documentation Apigee Edge.
Accédez à la page Documentation sur Apigee X. En savoir plus

OBSOLÈTE : Exécution d'Edge Microgateway Kubernetes Engine accepte le modèle de proxy side-car. Toutefois, le edgemicroctl et les outils associés décrits dans cette rubrique sont obsolètes. Cet outil s'appuie sur le framework d'injecteur side-car qui n'est plus compatible.

Introduction

Cet article explique comment exécuter Edge Microgateway dans un cluster Kubernetes en tant que Un proxy side-car Deux options s'offrent à vous pour le déploiement side-car: manuel et automatique. l'injection. Cet article décrit les deux options.

Pour en savoir plus, 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 "hello" simple et vérifier 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 avant de le pod passe à l'état "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 READY (PRÊT) de 1/1 signifie qu'il existe l'une des valeurs suivantes : services s'exécutant dans le pod. Dans les étapes suivantes, vous configurer le cluster de sorte qu'Edge Microgateway soit automatiquement injecté en tant que dans tous les pods que vous créez. Lorsque cela se produit, le message suivant s'affiche : lorsque vous exécutez kubectl get pods, il y a "deux sur deux" services en cours d'exécution dans le pod: le service et le side-car.
Supprimez le déploiement de service de test. Vous la réinstallerez plus tard, après avoir activé Injection side-car:
```
 kubectl delete -f samples/helloworld/helloworld.yaml --namespace=default
```

Utiliser l'injection side-car manuelle

Parmi les deux options d'injection side-car, l'injection manuelle side-car est la plus simple et la plus directe. et peut se faire à 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 un administrateur de l'organisation).
env: environnement dans votre organisation (par exemple, test ou production).
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 : 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 : indiquez le chemin d'accès au fichier de déploiement du service dont le pod pour récupérer 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 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 side-car d'Edge Microgateway. Accéder à Testez le proxy pour connaître la procédure détaillée.

Utiliser l'injection side-car automatique

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

Installer l'injecteur de side-car

Installer 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 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 fichier de certificat ou de clé obtenu est stocké en tant que secret Kubernetes pour le side-car. d'injecteur à utiliser. L'approbation de l'autorité de certification Kubernetes nécessite des autorisations pour créer et approuver demande de signature de certificat (CSR). Pour en savoir plus, consultez également Gérer les objets 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 groupe d'autorités de certification au fichier d'installation du webhook. L'API Kubernetes api-server 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 side-car est en cours d'exécution dans votre cluster. Espace de noms edgemicro-system est l'endroit où sont installés les services système, y compris le Contrôleur d'entrée, backend HTTP par défaut et 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 passerelle Edge Microgateway associée à un espace de noms Kubernetes. Ensuite, vous allez injecter dans votre cluster Kubernetes.

Exécutez le script interactif suivant et indiquez les paramètres demandés. La 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. 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 à 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 webhooks. 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 du webhook:
```
kubectl label namespace default edgemicro-injection=enabled
```

Affichez à nouveau l'état de l'injection de webhooks. 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 sera automatiquement injecté dans le pod du service.

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

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

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. Accéder à Testez le proxy pour connaître la procédure détaillée.

Tester le proxy

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

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. Toi 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 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 bien é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é à une règle 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é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 apparaît.
Remplissez la page "Produit" comme suit. Pour les champs qui ne sont pas mentionnés ci-dessous, vous peuvent 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 d'accès /.
Cliquez à nouveau sur + Ressource personnalisée et ajoutez le chemin d'accès /**.
Dans la section "API Proxies" (Proxys 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 + App (+ Application). La page "Informations sur l'application pour les développeurs" s'affiche.
Renseignez la page "Application de développeur" comme suit. Ne pas enregistrer tant que vous n'y êtes pas invité le faire.

Nom hello-world-app

Nom à afficher Edge Micro hello app

Developer Sélectionnez un développeur dans le menu déroulant.
Dans la section "Credentials" (Identifiants), cliquez sur + Product (+ Produit) et sélectionnez le hello-world-product que vous venez de créer.
Cliquez sur Enregistrer.
Vous êtes de retour sur la page qui liste toutes les applications pour les développeurs.
Sélectionnez l'application que vous venez de créer, hello-world-app.
Cliquez sur Show (Afficher) à côté de Consumer Key (Clé client).
Copiez la valeur de la clé client. Cette valeur correspond au Clé API que vous utiliserez pour effectuer des appels d'API sécurisés le service helloworld.
Attendez quelques minutes. Les modifications que vous avez apportées dans Apigee prennent quelques minutes de se synchroniser avec l'instance Edge Microgateway déployée dans cluster.

Remarque :Edge Microgateway interroge toutes les 600 modifications Apigee Edge secondes (par défaut), et extrait toutes les modifications de configuration apportées aux proxys, les produits d'API et les applications de développement. Vous pouvez changer la valeur 600 par défaut en modifiant Edge Fichier de configuration Microgateway. Découvrez la passerelle Edge Microgateway documentation pour en savoir plus.

Appeler l'API

Une fois les modifications de configuration importées dans la micropasserelle, vous pouvez effectuez les tests suivants.

Appelez l'API sans clé API. Vous recevrez alors un message d'erreur, comme illustré 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 de développement que vous avez créée. Cette valeur correspond au 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
```
Sortie :
```
Hello world
```
"Hello world" est renvoyée par le service helloworld au pod. L'appel à ce service est passé d'abord par Edge Microgateway, où l'authentification a été effectuée. Si le message "Hello world" s'affiche , cela signifie que vous avez correctement configuré Edge Microgateway pour de servir de proxy side-car dans le pod de service helloworld

Étape suivante

Consultez la section Tâches pour plus d'informations. sur l'ajout de plug-ins personnalisés, le scaling du déploiement, les modifications de configuration d'autres tâches que vous voudrez peut-être 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.