Un bref guide de l'orchestration des plugins APISIX et de la configuration de la passerelle

Dans les architectures modernes de passerelles API, la capacité d'orchestrer dynamiquement des plugins représente une avancée critique dans la gestion du trafic et le traitement des requêtes. Le système d'orchestration de plugins d'Apache APISIX met en œuvre une approche sophistiquée pour gérer des scénarios API complexes grâce à un modèle d'exécution de graphe acyclique dirigé (DAG).

Orchestration de plugins d'APISIX, un aperçu rapide

À la base, l'orchestration de plugins dans APISIX permet des chemins de traitement conditionnels basés sur les résultats de l'exécution des plugins, ce qui permet une gestion dynamique des requêtes sans nécessiter de code personnalisé. Ce système fonctionne grâce à une architecture distribuée qui maintient la séparation entre les plans de contrôle et de données tout en garantissant des performances élevées grâce à une gestion optimisée de l'état et au traitement en mémoire.

Le moteur d'orchestration traite les plugins grâce à un système sophistiqué de gestion d'état qui maintient le contexte d'exécution tout en permettant une logique conditionnelle complexe. Chaque plugin de la chaîne peut influencer le chemin d'exécution des plugins suivants, créant ainsi un flux de traitement dynamique et réactif. Cette approche permet des scénarios tels que :

• Flux d'authentification conditionnels basés sur les attributs de la requête
• Limitation dynamique du débit basée sur les résultats d'authentification
• Journalisation contextuelle basée sur les résultats du traitement des requêtes
• Routage de trafic adaptatif basé sur les états d'exécution des plugins

L'implémentation technique s'appuie sur plusieurs composants clés :

1. Un moteur d'exécution DAG qui gère les dépendances et le flux des plugins
2. Un système de gestion d'état pour maintenir le contexte d'exécution des plugins
3. Un système de traitement en mémoire optimisé pour un fonctionnement à hautes performances
4. Un système de configuration distribué utilisant etcd pour les mises à jour en temps réel

Cette architecture permet des scénarios complexes de gestion des API tout en maintenant des performances élevées grâce à une optimisation minutieuse de la gestion de l'état et des chemins d'exécution des plugins. Le système prend en charge le chargement dynamique des plugins, l'intégration de plugins personnalisés et une logique conditionnelle complexe, tout en conservant les caractéristiques de performance requises pour les déploiements en production.

Dans l'orchestration de plugins d'APISIX, « Context » représente un état partagé qui persiste tout au long du cycle de vie de l'exécution du plugin. Ce contexte fonctionne sur plusieurs phases d'exécution : rewrite, access, before_proxy, header_filter, body_filter et log. Par exemple, le contexte d'exécution maintient :

• Données de la requête : en-têtes HTTP, corps et informations du client
• États des plugins : résultats d'authentification et données de requête/réponse modifiées
• Contrôle de flux : chemin d'exécution actuel et résultats des plugins

En mettant en œuvre cette architecture, APISIX fournit un système flexible mais puissant pour gérer les exigences complexes de gestion des API grâce à la configuration plutôt qu'au code, ce qui réduit considérablement la complexité opérationnelle tout en maintenant la fiabilité et les performances du système.

Configuration de l'infrastructure, avant tout

La base d'un déploiement APISIX sécurisé commence par une isolation et une configuration réseau appropriées. Tout d'abord, créez un réseau dédié avec des configurations de sous-réseau spécifiques :

docker network create \
--driver=bridge \
--subnet=172.18.0.0/16 \
--ip-range=172.18.5.0/24 \
--gateway=172.18.5.254 \
apisix

Cette configuration réseau garantit une isolation et une communication appropriées entre les composants APISIX.

Déployer les composants principaux

Configuration d'ETCD

ETCD sert de centre de configuration. Déployez-le avec les paramètres de sécurité appropriés :

docker run -it --name etcd-server \
-v $(pwd)/example/etcd_conf/etcd.conf.yml:/opt/bitnami/etcd/conf/etcd.conf.yml \
-p 2379:2379 \
-p 2380:2380 \
--network apisix \
--ip 172.18.5.10 \
--env ALLOW_NONE_AUTHENTICATION=yes bitnami/etcd:3.4.9

Cette configuration garantit une persistance des données et une accessibilité réseau appropriées.

Installation du noyau APISIX

Déployez APISIX avec une journalisation et une configuration complètes :

docker run --name test-api-gateway \
-v $(pwd)/example/apisix_conf/config.yaml:/usr/local/apisix/conf/config.yaml \
-v $(pwd)/example/apisix_log:/usr/local/apisix/logs \
-p 9080:9080 \
-p 9091:9091 \
-p 9443:9443 \
--network apisix \
--ip 172.18.5.11 \
-d apache/apisix

Cette configuration inclut des montages de volume pour la configuration et les journaux.

Mettre en œuvre la sécurité

Couche d'authentification

APISIX fournit une authentification robuste basée sur les clés. Voici une implémentation complète :

# Créer un consommateur avec authentification
curl http://127.0.0.1:9180/apisix/admin/consumers -H "X-API-KEY: $admin_key" -X PUT -d '
{
    "username": "jack",
    "plugins": {
        "key-auth": {
            "key": "auth-one"
        }
    }
}'

# Configurer l'itinéraire avec authentification
curl http://127.0.0.1:9180/apisix/admin/routes/1 -H "X-API-KEY: $admin_key" -X PUT -d '
{
    "methods": ["GET"],
    "uri": "/index.html",
    "plugins": {
        "key-auth": {}
    },
    "upstream": {
        "type": "roundrobin",
        "nodes": {
            "127.0.0.1:1980": 1
        }
    }
}'

Cette configuration crée une couche d'authentification sécurisée nécessitant des clés API pour l'accès.

Implémentation de la limitation du débit

Protégez vos API contre les abus grâce à une limitation du débit sophistiquée :

curl http://127.0.0.1:9180/apisix/admin/routes/1 -H "X-API-KEY: $admin_key" -X PUT -d '
{
    "uri": "/index.html",
    "plugins": {
        "limit-count": {
            "count": 2,
            "time_window": 60,
            "rejected_code": 503,
            "key": "remote_addr",
            "policy": "redis",
            "redis_host": "127.0.0.1",
            "redis_port": 6379,
            "redis_password": "password",
            "redis_database": 1,
            "redis_timeout": 1001
        }
    },
    "upstream": {
        "type": "roundrobin",
        "nodes": {
            "127.0.0.1:1980": 1
        }
    }
}'

Cette configuration met en œuvre une limitation du débit distribuée basée sur Redis.

Stratégies avancées de limitation du débit

Pour la limitation du débit au niveau du cluster avec différenciation des consommateurs :

curl -i http://127.0.0.1:9180/apisix/admin/routes/1 \
-H "X-API-KEY: $admin_key" -X PUT -d '
{
    "uri": "/index.html",
    "plugins": {
        "limit-count": {
            "count": 2,
            "time_window": 60,
            "rejected_code": 503,
            "key_type": "var_combination",
            "key": "$consumer_name $remote_addr"
        }
    },
    "upstream": {
        "type": "roundrobin",
        "nodes": {
            "127.0.0.1:9001": 1
        }
    }
}'

Cette configuration permet une limitation du débit sophistiquée basée à la fois sur l'identité du consommateur et l'adresse IP.

Surveillance de l'état et métriques

Intégration de Prometheus

Activez la collecte de métriques complètes :

curl -i http://127.0.0.1:9180/apisix/admin/routes/1 \
-H "X-API-KEY: $admin_key" -X PUT -d '
{
    "uri": "/metrics",
    "plugins": {
        "prometheus": {
            "prefer_name": true,
            "metrics": {
                "http_status": true,
                "latency": true,
                "bandwidth": true
            }
        }
    },
    "upstream": {
        "type": "roundrobin",
        "nodes": {
            "prometheus:9090": 1
        }
    }
}'

Cette configuration permet une collecte de métriques détaillée pour la surveillance et l'analyse.

Gestion du système

Initialisation du service

Après l'installation, initialisez le système avec les configurations appropriées :

# Initialiser la configuration
sudo apisix init

# Démarrer le service
sudo apisix start

# Pour les systèmes basés sur systemd
systemctl start apisix

Ces commandes garantissent une initialisation et une gestion de service appropriées du système.

Mises à jour de la configuration

Mettez à jour la clé API d'administration pour une sécurité renforcée :

deployment:
  admin:
    admin_key:
      - name: "admin"
        key: newsupersecurekey
        role: admin

Cette configuration améliore la sécurité de l'API d'administration.

Conclusion

La mise en œuvre complète de ces configurations crée une infrastructure de passerelle API robuste, sécurisée et évolutive. La combinaison de l'authentification, de la limitation du débit et de la surveillance garantit à la fois la sécurité et la fiabilité. Une maintenance régulière, y compris la mise à jour des clés d'administration et la surveillance des métriques du système, est cruciale pour maintenir la santé du déploiement.

N'oubliez pas d'ajuster ces configurations en fonction de vos exigences spécifiques et de vos besoins en matière de sécurité. La nature modulaire d'APISIX permet une expansion et une personnalisation faciles grâce à son système de plugins, ce qui le rend adapté aux scénarios de gestion d'API simples et complexes.