Comment créer une passerelle API à l'aide d'Ambassador sur Kubernetes

Passerelle API utilisant Ambassador sur Kubernetes

API Gateway est un aspect important de votre déploiement Kubernetes pour vos services. Il agit comme un point d'entrée unique et peut aider à simplifier de nombreuses tâches telles que la découverte de services, le traçage distribué, le routage, la limitation de débit. Il peut offrir une grande flexibilité et une meilleure configuration pour vos services.

Envoy est l’une des passerelles API très populaires actuellement disponibles, capable de gérer des charges importantes. Avec Kubernetes, Ambassador est le moyen le plus populaire et le plus efficace d’utiliser Envoy.

Aujourd'hui, je vais vous expliquer les étapes détaillées du déploiement d'Ambassador sur un cluster Kubernetes que nous avons déployé dans mon précédent message, et le configurer pour qu'il utilise l'équilibreur de charge AWS pour le trafic entrant et le dirige vers divers services en fonction de règles.

Ce message a été publié à l'origine sur mon blog https://krish512.com/create-api-gateway-ambassador-kubernetes/

Conditions préalables

Avant de commencer ce guide, vous aurez besoin des éléments suivants:

  • Kubernetes cluster selon mon post précédent
  • Certificat SSL utilisant ACM pour le domaine
  • Machine Linux en tant que serveur de déploiement, de préférence Ubuntu 16.04 ou ultérieure

Étape 1 - Déployer Ambassador sur le cluster Kubernetes

Le déploiement d’Ambassador est plus facile avec Kubernetes car la configuration YAML est facilement disponible sur le site d’Ambassador. Si vous avez fait référence à mon article précédent sur la création d'un cluster Kubernetes sur AWS, vous avez déjà activé RBAC.

Reportez-vous à la documentation officielle de l’Ambassadeur si RBAC n’est pas activé ou si vous rencontrez des problèmes avec la commande ci-dessus.

Connectez-vous à votre serveur de déploiement et exécutez la commande kubectl suivante,

kubectl apply -f https://getambassador.io/yaml/ambassador/ambassador-rbac.yaml

Vous pouvez également utiliser Helm pour déployer Ambassador.

Premièrement, ajoutez le repo Helm maintenu par Datawire (équipe d’ambassadeurs).

$ helm repo add datawire https://www.getambassador.io

Maintenant, déployez ambassadeur avec Helm en tant que,

$ helm upgrade -install -wait ambassador datawire / ambassador

Cela prendra un certain temps et créera un déploiement d’Ambassador et des pods dans votre espace de noms par défaut. Vérifiez si les pods ont été créés à l’aide de la commande suivante,

$ kubectl get pods

Attendez-vous à la sortie suivante

NOM READY STATUS RESTARTS AGE
ambassador-6dfd64dd49-dgmcf 2/2 Exécution 0 1d
ambassador-6dfd64dd49-mz5bf 2/2 Exécution 0 1d
ambassador-6dfd64dd49-xd6g4 2/2 Exécution 0 1d

Si vous pouvez voir 3 modules Ambassador fonctionner, vous avez correctement configuré Ambassador. Passons à l’étape suivante où nous allons créer un point de terminaison de l’équilibreur de charge pour exposer notre passerelle API.

Étape 2 - Créer un service ambassadeur et un loadbalancer

Tout le trafic entrant vers nos services Kubernetes doit être acheminé via notre API Gateway Ambassador.

Ambassador utilise un équilibreur de charge AWS pour recevoir tout le trafic et les achemine vers le service Ambassador pour pouvoir appliquer des règles et les acheminer davantage vers des services configurés.

Avant de créer notre équilibreur de charge, préparons un certificat HTTPS avec le service AWS ACM pour le domaine krish512.com et le domaine secondaire * .dev.krish512.com. Vous pouvez ajouter jusqu'à 8 domaines secondaires selon vos besoins.

Créons maintenant un service pour ambassadeur. Créez un fichier en tant qu'ambassador-service.yaml

$ touch ambassador-service.yaml

Maintenant, en utilisant VIM ou nano editor, ouvrez le fichier et insérez le contenu yaml suivant,

apiVersion: v1
genre: service
métadonnées:
  Étiquettes:
  service: ambassadeur
    nom: ambassadeur
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "arn: aws: acm: ap-sud-1: 123403005789: certificat / 1a2b3c54-b001-12fg-9h33-f98f7f65432d"
    service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "443"
    service.beta.kubernetes.io/aws-load-balancer-backend-protocol: "http"
    service.beta.kubernetes.io/aws-load-balancer-cross-zone-load-balancing-enabled: "true"
    service.beta.kubernetes.io/aws-load-balancer-proxy-protocol: "*"
    service.beta.kubernetes.io/aws-load-balancer-extra-security-groups: "sg-01a889992221b2cde"
    getambassador.io/config: |
      ---
      apiVersion: ambassadeur / v1
      type: module
      nom: tls
      config:
        serveur:
          activé: vrai
          redirect_cleartext_from: 80
spec:
  loadBalancerSourceRanges:
  - 0.0.0.0/0
  type: LoadBalancer
  ports:
  - nom: ambassador-http
    port: 80
    targetPort: 80
  - nom: ambassador-https
    port: 443
    targetPort: 80
  sélecteur:
    service: ambassadeur

Dans la section ci-dessus, la section annotations spécifie les détails de notre équilibreur de charge. Comme AWS ALB n'est actuellement pas pris en charge par Kubernetes, cela créera un équilibreur de charge classique pour Ambassador.

  • La valeur du champ service.beta.kubernetes.io/aws-loadbalancer-ssl-cert est l'ARN de notre certificat AWS ACM.
  • La valeur de service.beta.kubernetes.io/aws-loadbalancer-ssl-ports indique notre port HTTPS pour l'équilibreur de charge
  • La clé service.beta.kubernetes.io/aws-loadbalancer-extra-security-groups est facultative et nous permet d'ajouter des règles de groupe de sécurité supplémentaires et de les associer à notre équilibreur de charge en spécifiant l'ID du groupe de sécurité comme valeur.

Dans la section Spécifications, loadBalancerSourceRanges est à nouveau une clé facultative utilisée pour restreindre l'accès à l'équilibreur de charge à l'aide de son groupe de sécurité par défaut. Nous l'avons gardé ouvert, ceci est juste à des fins de démonstration. Vous pouvez supprimer ce champ ou modifier la valeur selon vos besoins.

Laissez-nous créer le service maintenant.

$ kubectl apply -f ambassador-service.yaml

Cela devrait immédiatement créer un service et lancer une création d'équilibreur de charge dans votre console AWS EC2.

Pour éviter de spécifier le mappage DNS pour chaque sous-domaine, pointez * .dev.krish512.com sur cet équilibreur de charge dans le service AWS Route53.

Étape 3 - Déployer des services et acheminer à l'aide d'Ambassador

Pour tester notre configuration Ambassador et ses fonctionnalités, nous allons déployer 2 services sur Kubernetes et leur acheminer le trafic via Ambassador via des annotations.

Commençons par créer un espace de noms de développement pour nos nouveaux services.

{
  "kind": "Namespace",
  "apiVersion": "v1",
  "métadonnées": {
    "nom": "développement",
    "Étiquettes": {
      "nom": "développement"
    }
  }
}

Enregistrez le fichier json ci-dessus sous le nom développement-namespace.json et exécutez la commande kubectl suivante pour créer un espace de noms.

$ kubectl create -f development-namespace.json

Créons maintenant le pod httpd en utilisant un déploiement et exposons-le à ambassador en utilisant un service.

---
apiVersion: v1
genre: service
métadonnées:
  nom: httpd-service
  espace de noms: développement
  annotations:
    getambassador.io/config: |
      ---
      apiVersion: ambassadeur / v1
      genre: cartographie
      nom: httpd-service_mapping
      hôte: service1.dev.krish512.com
      préfixe: /
      service: httpd-service.development: 80
spec:
  sélecteur:
    app: httpd
    environnement: développement
    rôle: web
  ports:
  - protocole: TCP
    port: 80
---
apiVersion: extensions / v1beta1
genre: déploiement
métadonnées:
  nom: httpd
  espace de noms: développement
spec:
  répliques: 1
  stratégie:
    type: RollingUpdate
  modèle:
    métadonnées:
      Étiquettes:
        app: httpd
        environnement: développement
        rôle: web
    spec:
      conteneurs:
      - nom: httpd
        image: "httpd"
        ports:
        - containerPort: 80

Enregistrez le yaml ci-dessus sous httpd.yaml.

Dans ce qui précède yaml, nous avons créé une annotation getambassador.io/config qui est utilisée pour la configuration d’ambassador. Ces annotations peuvent être configurées dans le service Ambassador si vous souhaitez les gérer de manière centralisée.

Dans cette annotation, nous avons mappé la configuration d'ambassador sur un service et spécifié le nom httpd-service_mapping.

À des fins de routage, nous avons demandé à Ambassador de router toutes les demandes provenant de l'hôte service1.dev.krish512.com avec la route de base / service httpd-service.development: 80 où httpd-service est le nom du service, le développement est l'espace de noms et 80 port exposé pour le service.

Créons ce service httpd dans Kubernetes à l’aide de la commande kubectl suivante,

$ kubectl apply -f httpd.yaml

Cela devrait prendre une minute pour créer le pod pour notre déploiement et être disponible. Vérifiez si le pod est disponible en utilisant ce qui suit,

$ kubectl get développement de pods -n

Attendez-vous à la sortie suivante,

NOM READY STATUS RESTARTS AGE
httpd-56ddd7c88b-ddksp 1/1 En cours d'exécution 0 28m

Maintenant, allez sur votre navigateur et entrez l'URL https://service1.dev.krish512.com, vous devriez pouvoir voir la sortie comme ci-dessous

Page par défaut du serveur Web Httpd

De même, créons un pod Nginx en utilisant un déploiement et exposons-le à ambassador en utilisant un service en tant que,

---
apiVersion: v1
genre: service
métadonnées:
  nom: nginx-service
  espace de noms: développement
  annotations:
    getambassador.io/config: |
      ---
      apiVersion: ambassadeur / v1
      genre: cartographie
      nom: nginx-service_mapping
      hôte: service2.dev.krish512.com
      préfixe: / nginx
      service: nginx-service.development: 80
spec:
  sélecteur:
    application: nginx
    environnement: développement
    rôle: web
  ports:
  - protocole: TCP
    port: 80
---
apiVersion: extensions / v1beta1
genre: déploiement
métadonnées:
  nom: nginx
  espace de noms: développement
spec:
  répliques: 1
  stratégie:
    type: RollingUpdate
  modèle:
    métadonnées:
      Étiquettes:
        application: nginx
        environnement: développement
        rôle: web
    spec:
      conteneurs:
      - nom: nginx
        image: "nginx"
        ports:
        - containerPort: 80

Enregistrez le yaml ci-dessus sous le nom nginx.yaml et exécutez-le.

$ kubectl apply -f nginx.yaml

Cela devrait à nouveau prendre une minute pour créer le pod. Vérifiez si le pod a été créé avec succès en utilisant les éléments suivants,

$ kubectl get développement de pods -n

Attendez-vous à la sortie suivante,

NOM READY STATUS RESTARTS AGE
httpd-56ddd7c88b-ddksp 1/1 En cours d'exécution 0 10m
nginx-6455785f94-z992f 1/1 En cours d'exécution 0 1 m

Dans cette yaml, nous avons pointé le domaine service2.dev.krish512.com avec route / nginx au service Nginx.

Dans votre navigateur, essayez l’URL https://service2.dev.krish512.com/nginx et attendez-vous à l’écran suivant,

Page par défaut du serveur Web Nginx

Essayez d'ajouter plus de pods et de les exposer à l'aide du service avec des annotations Ambassador pour pouvoir les acheminer et les gérer. Reportez-vous à la documentation Ambassador pour plus d'options de configuration.

Étapes supplémentaires

Ambassador dispose d'une interface de diagnostic pouvant être utilisée à des fins de débogage et de diagnostic. Chaque pod Ambassadeur expose cette interface utilisateur sur le port 8877. Nous pouvons créer un service pour exposer cette interface exécutée sur le port 8877 des pods et le mapper sur un domaine ambassador.dev.krish512.com.

Créons un service pour exposer l’interface utilisateur de diagnostic comme suit:

---
apiVersion: v1
genre: service
métadonnées:
  nom: ambassador-diagnostic
  annotations:
    getambassador.io/config: |
      ---
      apiVersion: ambassadeur / v1
      genre: cartographie
      nom: ambassador-diagnostic_mapping
      hôte: ambassador.dev.krish512.com
      timeout_ms: 30000
      préfixe: /
      service: ambassador-diagnostic: 8877
spec:
  sélecteur:
    service: ambassadeur
  ports:
  - protocole: TCP
    port: 8877

Maintenant, il suffit de visiter https://ambassador.dev.krish512.com/ et vous devriez pouvoir voir quelque chose comme cette interface utilisateur:

Conclusion

Nous avons créé une passerelle API pour nos services hébergés dans Kubernetes. Grâce à cela, nous pouvons acheminer le trafic vers un service spécifique en fonction d'en-têtes de requête tels que le nom d'hôte, l'URI, etc. Nous l'utiliserons à l'avenir pour exposer davantage de services via notre passerelle API Ambassador.

Rejoignez notre communauté Slack et lisez nos sujets hebdomadaires sur Faun ⬇

Si ce message vous a été utile, veuillez cliquer plusieurs fois sur le bouton clap below ci-dessous pour montrer votre soutien à l'auteur! ⬇