Skip to content
Cette page a été traduite par IA et peut contenir des inexactitudes. Aidez-nous à l'améliorer sur GitHub.

Comparatif de performances ​

Cette page compare Gately aux outils courants qu'il peut remplacer, sur la même machine et avec les mêmes limites de CPU : reverse proxy, authentification web, WAF, prévention d'intrusion, Port Knocking, DNS dynamique, ainsi que le comportement sur un routeur OpenWrt. Tous les chiffres proviennent de mesures effectuées en novembre 2026. Les scripts de test, les configurations et les résultats bruts se trouvent dans le répertoire tools/benchmark du dépôt, et vous pouvez les reproduire.

Résumé ​

  • Reverse proxy : nginx et HAProxy, écrits en C, ont le débit le plus élevé : environ 3.5 fois celui de Gately en HTTP et environ 2.6 fois en HTTPS. Parmi les passerelles écrites en Go, Gately fait partie du premier groupe : son débit HTTPS est supérieur de 43 % à celui de Caddy, égal à 2.3 fois celui de Lucky et inférieur de 9 % à celui de Traefik ; son taux de nouvelles connexions TLS est le plus élevé des 7 programmes.
  • Pas de ralentissement avec de nombreux sites : avec 1000 sites, le débit de Gately ne baisse que de 6 %, ce qui dépasse HAProxy, Traefik et Caddy, derrière nginx seulement.
  • Authentification web : pour les requêtes d'utilisateurs connectés, Gately atteint 1.9 fois nginx + Authelia et 3.7 fois Caddy + Authelia, avec un tiers de leur mémoire.
  • WAF : avec le même OWASP CRS 4.25, Gately traite les requêtes ordinaires environ 70 % plus vite que nginx + ModSecurity, avec des résultats de blocage identiques ; pour l'inspection du corps des requêtes POST, ModSecurity est plus rapide et utilise beaucoup moins de mémoire.
  • Prévention d'intrusion : avec 10,000 IP d'attaque, Gately termine les bannissements en 12 secondes, contre 51 secondes pour fail2ban ; à volume de journaux égal, le CPU représente moins de la moitié de celui de fail2ban. En lecture de fichier de journal, la latence d'un bannissement individuel est supérieure d'environ 0.2 seconde à celle de fail2ban.
  • Port Knocking : la latence de frappe de Gately et de fwknop reste inférieure à 10 ms, et une fois l'accès ouvert le trafic ne passe plus par le programme de frappe ; le knock de fnOS transfère le trafic par sa passerelle sur un Linux ordinaire, et son débit en connexions courtes ne représente que 3 % de celui d'une connexion directe.
  • Consommation de ressources : pour une seule fonction, Gately utilise plus de mémoire que de petits outils comme fail2ban, fwknop ou ddns-go ; lorsqu'un seul Gately assure à la fois reverse proxy, WAF, authentification, DDNS, prévention d'intrusion et Port Knocking, il occupe environ 91 MiB, contre environ 204 MiB au total avec des outils indépendants. Voir Tout-en-un.

Environnement de test ​

ÉlémentDescription
HôteIntel Core i5-13500T, 32 GB de mémoire, fnOS (KVM)
VM de test de chargeDebian 13 (noyau 6.12), 8 vCPU liés à 8 threads de 4 cœurs performants de l'hôte, 8 GB de mémoire, Docker 29
Répartition du CPUProgramme testé sur les vCPU 0–1, nginx d'origine sur les vCPU 2–3, outils de charge sur les vCPU 4–7, sans interférence entre eux
RouteurVM ImmortalWrt 25.12.1, 2 vCPU (deux threads du même cœur performant), 1 GB de mémoire
Outils de chargewrk 4.1, oha 1.17, h2load 1.64 (nghttp2)
CertificatTous les programmes partagent le même certificat ECDSA P-256, TLS 1.3
Originenginx renvoie 1 KB de texte ; 100 MB pour le test de gros fichier

Versions testées : Gately v0.6.8.1, nginx 1.29.8, HAProxy 3.2.26, Caddy 2.11.9, Traefik 3.7.19, Lucky 3.8.1, Nginx Proxy Manager 2.17.0 (OpenResty 1.31.8), Authelia 4.39.28, ModSecurity 3.0.16 (OWASP CRS 4.25.0), fail2ban 1.1.0, fwknop 2.6.11, le knock de fnOS fn-knock 2.5.11, ddns-go 6.17.9. À l'exception de fail2ban et fwknop, qui utilisent les paquets Debian, tout tourne à partir d'images Docker officielles avec le réseau en mode host.

Méthode de mesure

  • Débit : chaque test dure 20 secondes, sur 3 passes, et l'on retient la médiane. HTTP et HTTPS utilisent wrk avec 128 connexions persistantes ; les nouvelles connexions TLS utilisent oha avec 64 en parallèle et une nouvelle connexion par requête ; HTTP/2 utilise h2load avec 64 connexions et 10 flux simultanés par connexion.
  • Mémoire : somme du PSS de tous les processus du conteneur testé (la mémoire partagée entre processus est répartie proportionnellement, donc comptée une seule fois). « Au repos » est la valeur 10 secondes après la fin du démarrage et de la configuration ; « pic » est le maximum pendant le test de charge.
  • CPU : temps CPU du cgroup du conteneur testé, où 100 % correspond à un vCPU.
  • Démarrage : le programme est redémarré une fois la configuration prête, on mesure le temps jusqu'à la première requête correctement servie, et l'on retient la médiane de 3 essais.
  • Les journaux d'accès sont désactivés pour tous les programmes. nginx a le pool de connexions persistantes vers l'origine activé et une limite de requêtes par connexion relevée (réglage courant) ; les autres programmes gardent leurs réglages par défaut.

Reverse proxy ​

Le domaine bench.test est proxifié vers l'origine, avec HTTP sur le port 8080 et HTTPS sur le port 8443 (Nginx Proxy Manager ne peut utiliser que 80/443).

Requêtes HTTPS par seconde (connexions persistantes)Plus c’est grand, mieux c’est
nginx85,434QPS
HAProxy83,953QPS
Traefik35,812QPS
Nginx Proxy Manager32,816QPS
Gately32,764QPS
Caddy22,871QPS
Lucky14,376QPS
Nouvelles connexions TLS par seconde (un handshake complet par requête)Plus c’est grand, mieux c’est
Gately4,636conn./s
Traefik4,482conn./s
Nginx Proxy Manager4,015conn./s
Caddy3,987conn./s
nginx3,796conn./s
Lucky3,621conn./s
HAProxy3,293conn./s
Mémoire au reposPlus c’est petit, mieux c’est
nginx15.7MiB
HAProxy36.4MiB
Gately47.6MiB
Caddy48.8MiB
Traefik89.0MiB
Lucky124.6MiB
Nginx Proxy Manager155.7MiB

Les 47.6 MiB de Gately comprennent tous les modules fonctionnels (DDNS, certificats, WAF, prévention d’intrusion, etc. tournent dans le même processus) ; Lucky compte 2 processus et Nginx Proxy Manager 22 (nginx, le backend Node.js, etc.).

ProgrammeHTTPHTTPSHTTP/2TLS nouvelles/sFichier de 100 MBCPU à 5000 QPSMémoire au reposPic en chargePar connexion inactiveTemps de redémarrageImage
Gately35,36432,76421,5914,6364,157 MB/s67%47.6 MiB107 MiB21.2 KiB0.40 s229 MB
nginx123,34385,43478,1103,7962,161 MB/s55%15.7 MiB25 MiB0.6 KiB0.32 s93 MB
HAProxy117,92383,95390,6333,2933,912 MB/s52%36.4 MiB56 MiB1.0 KiB0.33 s58 MB
Caddy24,45922,87111,7463,9874,116 MB/s68%48.8 MiB132 MiB27.8 KiB0.45 s92 MB
Traefik39,11235,81219,6064,4824,311 MB/s66%89.0 MiB253 MiB24.4 KiB0.53 s250 MB
Lucky15,15014,37610,2613,6213,963 MB/s80%124.6 MiB193 MiB26.2 KiB3.47 s58 MB
Nginx Proxy Manager45,25732,81634,7104,0152,150 MB/s58%155.7 MiB215 MiBpréalloué1.50 s1,959 MB
  • HTTP, HTTPS et HTTP/2 sont exprimés en requêtes par seconde. « CPU à 5000 QPS » est le CPU utilisé par le programme sous une charge fixe de 5000 requêtes par seconde ; plus c'est bas, plus c'est économe en énergie.
  • Par défaut, nginx ferme une connexion après 1000 requêtes, alors que h2load ne se reconnecte pas ; dans la colonne HTTP/2, cette limite a donc été relevée pour nginx et pour Nginx Proxy Manager (Nginx Proxy Manager ne l'a été par configuration personnalisée que pour le test HTTP/2, les autres tests gardant les valeurs par défaut).
  • Dans la colonne gros fichier, nginx et Nginx Proxy Manager sont plus bas parce que nginx écrit par défaut dans un fichier temporaire sur disque les réponses qui dépassent le tampon mémoire.
  • « Par connexion inactive » est la mémoire ajoutée en maintenant 10,000 connexions persistantes inactives, divisée par le nombre de connexions. Les programmes Go ont un tampon de lecture et d'écriture et une goroutine par connexion, soit environ 20–28 KiB ; nginx et HAProxy utilisent moins de 1 KiB. Nginx Proxy Manager préalloue une table de connexions selon sa configuration, si bien qu'aucune augmentation n'a pu être mesurée.
  • L'image de Gately est plus grosse parce qu'elle contient la CLI Docker et les outils nftables et iptables ; le programme lui-même est un fichier unique de 40 MB, et l'archive à télécharger fait 18 MB.

1000 sites ​

Chaque programme est configuré avec 1000 sites en reverse proxy aux domaines différents, et pendant le test de charge chaque requête choisit un domaine au hasard.

Requêtes HTTP par seconde avec 1000 sitesPlus c’est grand, mieux c’est
nginx122,958QPS
Gately33,211QPS
Traefik24,229QPS
HAProxy24,057QPS
Caddy9,819QPS
ProgrammeRequêtes/sPar rapport à 1 siteLatence p99Redémarrage jusqu'à la disponibilité du dernier siteMémoire au reposPic en charge
Gately33,211-6%29.8 ms0.43 s94 MiB463 MiB
nginx122,9580%1.2 ms0.54 s57 MiB58 MiB
HAProxy24,057-80%30.0 ms0.37 s51 MiB58 MiB
Caddy9,819-60%52.7 ms0.80 s80 MiB361 MiB
Traefik24,229-38%18.8 ms0.74 s115 MiB157 MiB
  • HAProxy compare les règles une par une avec use_backend ... if { hdr(host) -i domaine }, ce qui le ralentit à mesure que les sites se multiplient ; un fichier map permet de l'éviter, mais le test conserve ici l'écriture courante « une règle par site ».
  • Le pic de mémoire de Gately vient surtout des statistiques d'accès de chaque site : dans v0.6.8.1, chaque site qui reçoit du trafic conserve d'un seul bloc 24 heures de statistiques à la minute et les quantiles de latence (environ 108 KiB). La version de développement les stocke par blocs d'une heure, ce qui ramène le pic à 225 MiB ; voir Optimisations de la version de développement.

Authentification web ​

Le site exige une connexion, et le test porte sur les requêtes d'utilisateurs connectés et sur la connexion elle-même. Gately utilise l'authentification web et l'authentification basique intégrées au site ; le groupe de comparaison est nginx ou Caddy avec Authelia en frontal (auth_request / forward_auth), ainsi que l'auth_basic propre à nginx. Tout passe en HTTPS.

Requêtes par seconde d’utilisateurs connectés (avec cookie de session)Plus c’est grand, mieux c’est
Gately26,726QPS
nginx + Authelia14,291QPS
Lucky10,786QPS
Caddy + Authelia7,141QPS
ConfigurationRequêtes connectées/sSans authentificationAuthentification basique (bcrypt)Connexions réussies/sPic de mémoire à la connexionMémoire au repos
Gately26,72632,52028,59838.370 MiB45 MiB
nginx + Authelia14,29183,4744013.41,082 MiB120 MiB
Caddy + Authelia7,14122,70321,21313.41,271 MiB149 MiB
Lucky10,78613,84110,107voir notes209 MiB127 MiB
  • Hachage des mots de passe : l'authentification basique de Gately et de nginx/Caddy utilise bcrypt (cost 10), Authelia utilise argon2id (t=3, 64 MiB, p=4), et Lucky enregistre en clair les mots de passe des utilisateurs du site. Chaque connexion à Authelia occupe 64 MiB de mémoire, et avec 8 connexions simultanées la mémoire dépasse 1 GB.
  • L'auth_basic de nginx recalcule bcrypt à chaque requête, ce qui ne donne que 40 requêtes/s ; Gately et Caddy mettent en cache le résultat de la vérification. Avec apr1 (MD5), nginx atteint 13,082 requêtes/s.
  • Mauvais mots de passe : Gately rejette directement une source après 10 échecs (il traite 16,000 requêtes erronées par seconde et le CPU ne calcule plus de hachage) ; Authelia ajoute à chaque échec un délai fixe d'environ 1 seconde. Pendant le verrouillage, les deux rejettent aussi le bon mot de passe de cette source, et les sessions déjà ouvertes ne sont pas touchées.
  • Avec 8 connexions simultanées, Lucky a renvoyé create webauth session error à chaque fois, et son débit de connexion n'a donc pas pu être mesuré.

WAF ​

Les trois utilisent OWASP CRS 4.25.0, niveau de paranoïa 1, en mode blocage. Gately et Caddy utilisent le même moteur Coraza, et nginx utilise ModSecurity v3.

Requêtes GET par seconde avec le WAF activéPlus c’est grand, mieux c’est
Gately2,498QPS
Caddy + Coraza2,265QPS
nginx + ModSecurity1,491QPS
ProgrammeGETGET avec 8 paramètresPOST de formulaire de 4 KBTrafic d'attaquePic de mémoire en chargeMémoire au repos (activé/désactivé)
Gately2,4981,067721,218754 MiB88 / 48 MiB
nginx + ModSecurity1,4915911021,01473 MiB62 / 24 MiB
Caddy + Coraza2,265943461,004792 MiB96 / 55 MiB
Efficacité de détectionGatelynginx + ModSecurityCaddy + Coraza
Échantillons d'attaque bloqués (557)77.2%77.2%77.2%
Faux positifs sur échantillons normaux (389)20.1%20.1%20.1%
Cas de régression CRS détectés (2049)95.9%95.2%95.7%
  • Les règles CRS sont lourdes en elles-mêmes : avec le WAF activé, le débit des trois ne représente plus que 1 %–10 % de celui obtenu sans WAF ; pour les sites qui ont besoin d'un WAF, il est conseillé de ne l'activer que sur les interfaces dynamiques.
  • Lors de l'inspection du corps des requêtes POST, le moteur Coraza (dans Gately comme dans Caddy) dépasse 700 MiB de mémoire au pic, alors que ModSecurity reste à 73 MiB ; soyez prudent en activant l'inspection du corps sur les appareils à peu de mémoire.
  • Les échantillons proviennent de gotestwaf (MIT), des tests de régression fournis avec CRS (Apache-2.0) et de requêtes normales écrites à la main ; les faux positifs viennent surtout d'articles techniques contenant des mots-clés SQL/shell et des interfaces PUT/DELETE (CRS n'autorise pas ces méthodes par défaut).

Prévention d'intrusion ​

Scénario : un service web est scanné, et une IP est bannie après 5 réponses 404 en 60 secondes (nftables). fail2ban lit le journal d'accès de nginx avec pyinotify ; Gately lit le même journal avec une règle de fichier de journal équivalente, et un autre groupe mesure la détection de chemins intégrée aux services web de Gately.

Temps nécessaire pour bannir les 10,000 IP d’attaquePlus c’est petit, mieux c’est
Gately12.3s
fail2ban51.2s
IndicateurGately (lecture du fichier de journal)Gately (détection intégrée au service web)fail2ban
Latence de bannissement d'un attaquant p50 / p99478 / 996 ms10 / 13 ms280 / 864 ms
CPU à 1000 lignes/s de journal2.9%—20.4%
CPU à 20,000 lignes/s de journal35.7%—83.2%
10,000 IP d'attaque : toutes bannies12.3 s—51.2 s
10,000 IP d'attaque : CPU consommé10.1 s de CPU—60.3 s de CPU
Mémoire au repos44.1 MiB40.7 MiB17.6 MiB
Manquées / bannies à tort0 / 00 / 00 / 0
  • Gately lit le fichier de journal une fois par seconde, si bien que la latence d'un bannissement individuel se situe entre 0 et 1 seconde, soit en moyenne environ 0.2 seconde de plus que l'inotify de fail2ban ; la détection intégrée au service web compte directement pendant le traitement de la requête et n'a pas ce délai.
  • fail2ban lance un processus nft à chaque bannissement, ce qui crée une file d'attente quand les attaquants sont nombreux : avec 10,000 IP, la dernière a été bannie 41 secondes après la fin de l'injection.
  • fail2ban lui-même pèse 2 MB, mais dépend d'un environnement d'exécution Python d'environ 24 MB.

Port Knocking ​

Trois approches sont comparées : le Port Knocking de Gately (autorisation par paquet unique SPA compatible avec fwknop, blocage par nftables), fwknop 2.6.11 (également SPA, blocage par iptables) et le knock de fnOS fn-knock 2.5.11 (autorise l'IP source après une connexion web, sa passerelle transférant le trafic). Gately propose aussi une entrée qui autorise l'accès après une connexion web, mesurée comme un groupe à part. Le service protégé est un nginx sur un port TCP, et le client utilise une adresse de test publique, donc l'exemption « le réseau local n'a pas besoin de frapper » ne s'applique pas.

Requêtes par seconde en connexions courtes via le port protégé après ouverturePlus c’est grand, mieux c’est
fwknop65,046QPS
Gately64,763QPS
Gately accès web63,556QPS
fn-knock1,886QPS

Une connexion directe à l’origine, sans aucun programme de frappe, donne 67,034 requêtes/s.

IndicateurGately (SPA)Gately (accès web)fwknopfn-knock
De la frappe au port joignable p50 / p998.4 / 13.4 ms58 / 73 ms9.0 / 18.1 ms84 / 143 ms
Port protégé sans autorisationRejet (délai dépassé)Rejet (délai dépassé)Rejet (délai dépassé)Réinitialisation après le handshake (détectable)
Requêtes/s en connexion persistante / courte après ouverture143,867 / 64,764143,839 / 63,556148,371 / 65,046140,137 / 1,886
CPU du transfert après ouverture (connexions courtes)2%1%0%134%
Frappes légitimes avec 50,000 paquets invalides/s depuis une seule source10/10 (CPU 26%)—3/8 (CPU 102%)—
Frappes légitimes avec 10,000 paquets invalides/s depuis des sources usurpées1/7—10/10 (CPU 54%)—
Mémoire au repos48.7 MiB48.7 MiB2.2 MiB63.2 MiB (3 processus)
  • Avec Gately et fwknop, le pare-feu laisse passer directement le trafic après ouverture et celui-ci ne traverse pas le programme de frappe, si bien que le débit est identique à celui d'une connexion directe ; fn-knock transfère par sa passerelle sur un Linux ordinaire et interroge en plus le plan de contrôle pour l'autorisation à chaque nouvelle connexion, d'où un débit en connexions courtes de seulement 3 % de celui d'une connexion directe. Dans sa version fpk pour fnOS, fn-knock propose aussi un mode de connexion directe au pare-feu ; c'est la version Docker qui a été mesurée ici.
  • La connexion à fn-knock exige de résoudre d'abord une preuve de travail ALTCHA (p50 de 28 ms pour la résolution dans ce test) ; sans la résolution, 50 ms.
  • fwknopd traite chaque paquet dans un seul thread ; à 50,000 paquets/s depuis une seule source, il sature un cœur et les frappes légitimes se mettent à échouer. Gately limite le débit par source, si bien qu'une inondation depuis une seule source ne consomme presque pas de CPU.
  • Problème connu : quand un attaquant usurpe un grand nombre d'adresses sources différentes, la table de limitation de débit par source de Gately se remplit, le quota de débordement partagé par les nouvelles sources est épuisé par l'inondation et la plupart des frappes légitimes échouent (le CPU de Gately n'est alors qu'à environ 19 %). fwknop ne limite pas le débit et n'est pas affecté tant que le CPU n'est pas saturé.

DNS dynamique ​

Chaque programme est configuré avec 20 tâches DDNS et une période de vérification de 30 secondes. L'IP publique est interrogée auprès de l'origine locale et les mises à jour sont envoyées à l'origine locale par un « rappel personnalisé », sans toucher à un vrai fournisseur DNS. Après le démarrage et la première synchronisation, on échantillonne pendant 5 minutes.

Mémoire moyenne avec 20 tâches DDNSPlus c’est petit, mieux c’est
ddns-go16.9MiB
Gately51.6MiB
Lucky131.3MiB
ProgrammeMémoire moyenneMémoire de pointeCPU moyenImage
ddns-go 6.17.916.9 MiB18.2 MiB0.04%43 MB
Gately51.6 MiB55.4 MiB0.16%229 MB
Lucky 3.8.1131.3 MiB134.9 MiB0.48%58 MB
  • Les trois ne sollicitent le fournisseur que lorsque l'IP change ou que la période de synchronisation forcée arrive, de sorte que la charge permanente reste faible pour tous. Si seul le DDNS est nécessaire, ddns-go est le plus économe en mémoire ; le chiffre de Gately inclut tous ses modules, et le même processus peut aussi faire tourner les certificats, le reverse proxy et d'autres fonctions.

Routeur OpenWrt ​

Chaque programme tourne sur une VM de routeur ImmortalWrt 25.12.1 (2 vCPU, 1 GB de mémoire). La machine de charge accède au routeur par un pont du réseau local, et le routeur proxifie vers l'origine située sur la machine de charge. nginx 1.26.3 et HAProxy 3.2.21 proviennent du dépôt de paquets d'ImmortalWrt, Gately utilise le paquet apk officiel d'OpenWrt et Lucky le binaire Linux officiel.

Requêtes HTTPS par seconde sur le routeur (connexions persistantes)Plus c’est grand, mieux c’est
nginx40,665QPS
HAProxy36,266QPS
Gately15,669QPS
Lucky8,113QPS
ProgrammeHTTPHTTPSTLS nouvelles/sCPU à 2000 QPSMémoire au reposPic en chargeTaille du programme
Gately16,43915,6692,66527%43 MiB65 MiB40.5 MB
nginx49,56640,6653,11112%15 MiB22 MiB0.8 MB
HAProxy43,04636,2662,33712%24 MiB29 MiB3.7 MB
Lucky8,6428,1132,02144%64 MiB81 MiB17.9 MB
  • Sur le routeur, le goulot d'étranglement se situe surtout dans l'envoi et la réception réseau du noyau (interruptions logicielles), et aucun programme n'utilise entièrement les deux cœurs, d'où des écarts plus faibles que sur la machine de charge. Le débit de Gately est environ 2 fois celui de Lucky, avec un tiers de mémoire en moins.
  • Le noyau d'OpenWrt n'a pas de smaps ; la mémoire est donc estimée ici à partir de /proc/<pid>/statm (somme de la mémoire résidente privée de chaque processus plus une copie de la partie partagée). Pendant le test, la protection contre les inondations SYN du pare-feu par défaut (environ 25 nouvelles connexions par seconde) a été désactivée temporairement, faute de quoi elle aurait plafonné le test de nouvelles connexions TLS.
  • Pour un simple reverse proxy, le nginx du dépôt de paquets est le plus petit en taille comme en mémoire ; les 40 MB de Gately comprennent tous les modules, et sur build.gately.cn vous pouvez ne choisir que les modules nécessaires pour générer un paquet d'installation plus petit. Sur les routeurs dotés de peu de flash, vérifiez d'abord l'espace restant.

Tout-en-un ​

Un même Gately active simultanément : deux sites en reverse proxy (HTTP et HTTPS, tous deux avec WAF), un site avec authentification web, 20 tâches DDNS, une règle de journal de prévention d'intrusion et une règle de Port Knocking. Le groupe de comparaison est une combinaison d'outils indépendants assurant les mêmes fonctions, en additionnant la mémoire au repos mesurée plus haut pour chacun.

Mémoire au repos totale pour le même ensemble de fonctionsPlus c’est petit, mieux c’est
Gately90.8MiB
nginx + ModSecurity + Authelia + ddns-go + fail2ban + fwknop203.5MiB
Nginx Proxy Manager + Authelia + ddns-go + fail2ban + fwknop297.3MiB

Le groupe Nginx Proxy Manager n’a pas de WAF.

FonctionOutil indépendantMémoire au reposTaille d'installation
Reverse proxy + WAFnginx + ModSecurity (CRS 4.25)61.9 MiBImage de 156 MB
Reverse proxy (interface graphique)Nginx Proxy Manager155.7 MiBImage de 1,959 MB
Authentification webAuthelia104.4 MiBImage de 110 MB
DNS dynamiqueddns-go17.4 MiBImage de 43 MB
Prévention d'intrusionfail2ban17.6 MiB24 MB (avec Python)
Port Knockingfwknop2.2 MiB0.3 MB
ToutGately90.8 MiBProgramme de 40 MB (téléchargement de 18 MB)
  • L'instance tout-en-un de Gately, sous 1000 requêtes/s de trafic HTTPS passant par le WAF, atteint un pic de mémoire de 114 MiB et un CPU de 71 % ; les 20 tâches DDNS se sont toutes synchronisées avec succès.
  • L'émission de certificats (certbot, acme.sh) ne s'exécute qu'au renouvellement et n'est pas comptée dans la mémoire résidente.

Optimisations de la version de développement ​

D'après les résultats ci-dessus, la version de développement (non publiée, postérieure au commit 3d579389) a reçu les modifications suivantes et a été retestée dans le même environnement. Le reverse proxy utilise la build du commit 3d579389 ; les 1000 sites et la prévention d'intrusion utilisent une build qui inclut les modifications suivantes. La colonne de référence est v0.6.8.1 remesurée le même jour (seules les lignes HTTP et HTTPS ont été remesurées ce jour-là ; les autres références viennent des données ci-dessus).

  • Les sites d'un même écouteur qui font du reverse proxy vers le même backend avec les mêmes réglages de connexion partagent un pool de connexions.
  • Quand au moins 1 GiB de mémoire est disponible, la valeur par défaut du pourcentage de GC passe de 100 à 200 (modifiable dans les paramètres ; les appareils à faible mémoire gardent 100).
  • Le reverse proxy copie la requête une fois de moins et crée trois valeurs de contexte de moins par requête.
  • Les statistiques à la minute sur 24 heures de chaque site sont stockées par blocs d'une heure alloués à la première utilisation, et les champs des compartiments passent à des compteurs 32 bits (un site qui n'a du trafic que pendant une heure passe d'environ 108 KiB à environ 5 KiB, et un site actif toute la journée occupe environ 50 KiB).
  • La prévention d'intrusion lit les fichiers de journal avec inotify, donc une écriture est lue aussitôt (l'interrogation chaque seconde est conservée en secours) ; les écritures de bannissements dans le pare-feu sont regroupées au plus une fois toutes les 250 millisecondes.
Indicateurv0.6.8.1Version de développementÉvolution
Requêtes HTTP/s (référence du même jour)35,96838,358+6.6%
Requêtes HTTPS/s (référence du même jour)34,07236,079+5.9%
Nouvelles connexions TLS/s4,6364,942+6.6%
Requêtes HTTP/2/s21,59123,788+10%
1000 sites : requêtes/s33,21137,423+13%
1000 sites : latence p9929.8 ms12.9 ms-57%
1000 sites : pic de mémoire pendant le test463 MiB225 MiB-51%
Pic de mémoire pendant le test HTTP64.5 MiB81.1 MiB+26%
Prévention d'intrusion : latence de bannissement d'un seul attaquant p50 / p99478 / 996 ms9.8 / 129 ms
Prévention d'intrusion : latence de bannissement sous attaque soutenue p50 / p99 (20,000 lignes/s)509 / 1006 ms143 / 269 ms
Prévention d'intrusion : CPU à 1000 lignes/s2.9%8.0%en hausse
Prévention d'intrusion : CPU à 20,000 lignes/s35.7%26.5%-26%
Prévention d'intrusion : bannissement des 10,000 IP d'attaque12.3 s, 10.1 s de CPU10.1 s, 2.5 s de CPU
  • Le gain de débit vient surtout du réglage du GC, au prix d'un pic de mémoire supérieur d'une dizaine de MiB pendant le test. Le profilage montre que presque toute la charge restante sur le chemin du proxy se trouve dans l'implémentation HTTP de la bibliothèque standard de Go et dans le GC ; l'écart avec nginx et HAProxy tient au langage et à son runtime.
  • Avec 1000 sites, le débit augmente et la latence baisse parce que le pool de connexions partagé réduit fortement le nombre de connexions vers l'origine ; le pic de mémoire est divisé par deux grâce au stockage des statistiques par blocs.
  • La latence d'un bannissement isolé est désormais inférieure à celle de fail2ban (280 / 864 ms). Avec un faible débit de journal, le CPU est plus élevé que dans l'ancienne version, car le pare-feu est écrit au plus 4 fois par seconde contre 1 fois auparavant ; il reste à quatre dixièmes de celui de fail2ban (20.4%).

Reproduire ​

bash
git clone https://github.com/wangwanjie/gately && cd gately/tools/benchmark
# À exécuter en root sur une VM Debian 13 ; nécessite Docker ainsi que wrk, oha et h2load
bash provision-debian.sh
python3 lib/run.py gately 3     # reverse proxy ; remplacez par nginx, haproxy, caddy, traefik, lucky, npm
bash auth/run.sh                # authentification web
bash waf/run.sh                 # WAF
bash guard/run.sh               # prévention d'intrusion
bash knock/run.sh               # Port Knocking
bash scale/run.sh 1000          # 1000 sites
bash ddns/run.sh 20             # DNS dynamique
bash bundle/run.sh              # tout-en-un
bash router/run.sh              # routeur (nécessite en plus une machine OpenWrt)

Le README de chaque répertoire décrit la configuration, la méthode de mesure et les limites connues. Les résultats dépendent du matériel, de la virtualisation et de la configuration ; il est conseillé de refaire les tests avec votre propre charge de travail.