Comment Amazon EKS et APISIX Ingress Controller fonctionnent ensemble pour gérer un trafic complexe

API7.ai

February 7, 2021

Ecosystem

Contexte

En tant que gestionnaire de trafic, même lorsque vous êtes préparé à l'inattendu, il est parfois difficile d'empêcher l'inattendu. La construction d'une passerelle API à quatre voies est cruciale ! Voici comment Amazon EKS + Ingress APISIX! peut vous aider aujourd'hui.

Introduction

Kubernetes est un système open source pour automatiser le déploiement, la mise à l'échelle et la gestion d'applications conteneurisées. Amazon Elastic Kubernetes Service (Amazon EKS) en tant que service Kubernetes géré vous permet d'exécuter facilement des charges de travail Kubernetes sur les technologies cloud d'Amazon sans avoir besoin d'installer et de maintenir un plan de contrôle ou des nœuds.

Apache APISIX est une passerelle API dynamique, en temps réel et haute performance. Il fournit des fonctionnalités riches de gestion du trafic telles que l'équilibrage de charge, l'amont dynamique, le déploiement en grayscale, la segmentation du trafic, l'authentification et l'observabilité. Vous pouvez utiliser Apache APISIX pour gérer le trafic nord-sud entre les clients traditionnels et les serveurs ainsi que le trafic est-ouest entre les services.

Ingress APISIX peut être utilisé comme contrôleur d'entrée pour Kubernetes, introduisant les meilleures fonctionnalités d'Apache APISIX dans Kubernetes. Cela peut être piloté par des composants Controller bien conçus pour vous aider à répondre à des besoins complexes de gestion du trafic.

architecture technique d'apisix-ingress-controller

Comment configurer et exécuter Ingress APISIX sur Amazon Elastic Kubernetes Service

Prérequis

Avant de commencer, veuillez configurer un cluster Amazon EKS disponible sur Amazon CloudTech.

Vous devriez avoir l'outil kubectl dans votre environnement, définissez le contexte sur votre propre cluster Amazon EKS en exécutant la commande suivante :

aws eks update-kubeconfig --name  --region

Une fois que le cluster Kubernetes est prêt, créez un espace de noms appelé ingress-apisix, où toutes les ressources qui seront utilisées seront créées.

kubectl create namespace ingress-apisix

Nous utiliserons Helm pour déployer tous les composants d'Ingress APISIX (Apache APISIX et apisix-ingress-controller), veuillez donc également suivre le guide d'installation pour installer Helm. Le chart Helm pour Apache APISIX et apisix-ingress-controller se trouve à apache/apisix-helm-chart et apache/apisix-ingress-controller, veuillez cloner ces chemins pour obtenir les charts correspondants.

Installation d'Apache APISIX

Apache APISIX agit comme un plan de proxy pour le apisix-ingress-controller et doit être déployé à l'avance.

cd /path/to/apisix-helm-chart
helm repo add bitnami https://charts.bitnami.com/bitnami
helm dependency update . /chart/apisix
helm install apisix . /chart/apisix \
  --set gateway.type=LoadBalancer \
  --set allow.ipList="{0.0.0.0/0}" \
  --namespace ingress-apisix
kubectl get service --namespace ingress-apisix

La commande ci-dessus créera deux ressources Kubernetes Service, apisix-gateway, qui gère le trafic réel, et apisix-admin, qui agit comme le plan de contrôle et gère tous les changements de configuration. Ici, nous créons apisix-gateway en tant que service de type LoadBalancer, qui peut être exposé à Internet avec l'aide d'Amazon Network Load Balancer. Nous pouvons trouver le nom d'hôte du load balancer avec la commande suivante :

kubectl get service apisix-gateway \
--namespace ingress-apisix \
-o jsonpath='{.status.loadBalancer.ingress[].hostname}'

Notez également : le champ allow.ipList doit être adapté aux plages CIDR d'EKS dans notre propre cluster Amazon EKS, afin que apisix-ingress-controller puisse être autorisé par Apache APISIX (pour pousser les ressources).

Consultez value.yaml pour plus d'informations sur tous les éléments de configuration si vous avez d'autres exigences.

Installation de apisix-ingress-controller

Après avoir déployé avec succès Apache APISIX, il est temps d'installer le composant Controller.

cd /path/to/apisix-ingress-controller
# installer les ressources de base, par exemple ServiceAccount.
helm install ingress-apisix-base -n ingress-apisix . /charts/base
# installer apisix-ingress-controller
helm install ingress-apisix . /charts/ingress-apisix \
  --set ingressController.image.tag=dev \
  --set ingressController.config.apisix.baseURL=http://apisix-admin:9180/apisix/admin \
  --set ingressController.config.apisix.adminKey={YOUR ADMIN KEY} \
  --namespace ingress-apisix

Le chart ingress-apisix-base installera certaines dépendances de base pour apisix-ingress-controller, telles que ServiceAccount et son CRD dédié.

Le chart ingress-apisix nous guidera à travers l'installation du Controller lui-même, nous pouvons changer le tag de l'image à la version souhaitée et nous pouvons changer la valeur de ingressController.config.apisix.adminKey dans la commande ci-dessus, Ces configurations peuvent être ajustées selon les scénarios réels (et assurez-vous que la clé Admin utilisée ici est la même que celle utilisée dans le déploiement d'Apache APISIX). Si vous avez d'autres exigences, vous pouvez vous référer à value.yaml pour en savoir plus sur tous les éléments de configuration.

Ensuite, essayez d'ouvrir la console Amazon EKS, sélectionnez votre cluster et cliquez sur l'onglet Workloads, et vous verrez que tous les Pods, etcd et apisix-ingress-controller pour Apache APISIX sont prêts.

Commencer les tests

À ce stade, nous avons déployé tous les composants d'Ingress APISIX, assurez-vous donc que tout fonctionne correctement. Nous allons ensuite déployer un service httpbin et demander à Apache APISIX de router toutes les requêtes vers l'hôte "local.httpbin.org" vers ce service.

Pour ce faire, nous devons d'abord créer la charge de travail httpbin et l'exposer.

kubectl run httpbin --image kennethreitz/httpbin --port 80
kubectl expose pod httpbin --port 80

Afin qu'Apache APISIX route correctement les requêtes, nous devons créer une ressource ApisixRoute pour piloter le processus.

# ar-httpbin.yaml
apiVersion: apisix.apache.org/v1
kind: ApisixRoute
metadata:
  name: httpserver-route
spec:
  rules:
  - host: local.httpbin.org
    http:
      paths:
      - backend:
          serviceName: httpbin
          servicePort: 80
        path: /*

La ressource ApisixRoute ci-dessus permettra à Apache APISIX de router les requêtes avec un en-tête hôte de "local.httpbin.org" vers le backend httpbin (que nous venons de créer).

Cette configuration est ensuite appliquée, mais veuillez noter que le service et la ressource ApisixRoute doivent être placés dans le même espace de noms, et apisix-ingress-controller n'est pas autorisé à traverser les espaces de noms.

kubectl apply -f ar-httpbin.yaml

Testez les résultats avec un simple appel curl depuis n'importe où pouvant atteindre le service Apache APISIX.

$ curl http://{apisix-gateway-ip}:{apisix-gateway-port}/headers -s -H 'Host: local.httpbin.org'

{
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org",
    "User-Agent": "curl/7.64.1",
    "X-Amzn-Trace-Id": "Root=1-5ffc3273-2928e0844e19c9810d1bbd8a"
  }
}

Si le type de Service est ClusterIP, vous devez vous connecter à un Pod dans le cluster Amazon EKS et utiliser ensuite le ClusterIP ou le FQDN du Service pour accéder à Apache APISIX. Si déjà exposé (soit exposé en NodePort ou LoadBalancer), alors le point de terminaison externe accessible peut être atteint directement.

Note : Cet article est réimprimé du site web public WeChat d'aws.

Tags:
APISIX Ingress Controller
AWS
Traffic Management