Skip to content
Esta página se tradujo con IA y puede contener imprecisiones. Ayuda a mejorarla en GitHub.

Comparativa de rendimiento ​

Esta página compara Gately con las herramientas habituales a las que puede sustituir, en la misma máquina y con los mismos límites de CPU: proxy inverso, autenticación web, WAF, prevención de intrusiones, Port Knocking, DNS dinámico y el comportamiento en un router OpenWrt. Todas las cifras proceden de mediciones de noviembre de 2026. Los scripts de prueba, las configuraciones y los resultados originales están en el directorio tools/benchmark del repositorio, de modo que puede reproducirlos.

Resumen ​

  • Proxy inverso: nginx y HAProxy, escritos en C, tienen el mayor rendimiento: unas 3.5 veces el de Gately en HTTP y unas 2.6 veces en HTTPS. Entre las pasarelas escritas en Go, Gately está en el primer grupo: su rendimiento HTTPS es un 43 % superior al de Caddy, 2.3 veces el de Lucky y un 9 % inferior al de Traefik; su tasa de nuevas conexiones TLS es la más alta de los 7 programas.
  • Sin pérdida de velocidad con muchos sitios: con 1000 sitios, el rendimiento de Gately baja solo un 6 %, por encima de HAProxy, Traefik y Caddy y solo por detrás de nginx.
  • Autenticación web: en las peticiones de usuarios que ya iniciaron sesión, Gately rinde 1.9 veces más que nginx + Authelia y 3.7 veces más que Caddy + Authelia, con una tercera parte de su memoria.
  • WAF: con el mismo OWASP CRS 4.25, Gately procesa las peticiones normales cerca de un 70 % más rápido que nginx + ModSecurity y los resultados de bloqueo son idénticos; al inspeccionar el cuerpo de las peticiones POST, ModSecurity es más rápido y usa mucha menos memoria.
  • Prevención de intrusiones: con 10,000 IP atacantes, Gately termina de bloquearlas en 12 segundos y fail2ban tarda 51; con el mismo volumen de registros, la CPU es menos de la mitad que la de fail2ban. Al leer archivos de registro, la latencia de un bloqueo individual es unos 0.2 segundos mayor que la de fail2ban.
  • Port Knocking: la latencia de llamada de Gately y de fwknop es inferior a 10 ms y, una vez abierto el acceso, el tráfico no pasa por el programa de Port Knocking; el knock de fnOS reenvía el tráfico a través de su pasarela en un Linux normal y su rendimiento con conexiones cortas es solo el 3 % del de una conexión directa.
  • Consumo de recursos: para una sola función, la memoria de Gately es mayor que la de herramientas pequeñas como fail2ban, fwknop o ddns-go; cuando un único Gately se encarga a la vez de proxy inverso, WAF, autenticación, DDNS, prevención de intrusiones y Port Knocking, ocupa unos 91 MiB, frente a unos 204 MiB en total con herramientas independientes. Consulte Todo en uno.

Entorno de prueba ​

ElementoDescripción
HostIntel Core i5-13500T, 32 GB de memoria, fnOS (KVM)
VM de pruebas de cargaDebian 13 (kernel 6.12), 8 vCPU fijadas a 8 hilos de 4 núcleos de rendimiento del host, 8 GB de memoria, Docker 29
Reparto de CPUPrograma probado en las vCPU 0–1, nginx de origen en las vCPU 2–3, herramientas de carga en las vCPU 4–7, sin competir entre sí
RouterVM ImmortalWrt 25.12.1, 2 vCPU (dos hilos del mismo núcleo de rendimiento), 1 GB de memoria
Herramientas de cargawrk 4.1, oha 1.17, h2load 1.64 (nghttp2)
CertificadoTodos los programas comparten el mismo certificado ECDSA P-256, TLS 1.3
Origennginx devuelve 1 KB de texto; 100 MB en la prueba de archivo grande

Versiones probadas: 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, el knock de fnOS fn-knock 2.5.11, ddns-go 6.17.9. Salvo fail2ban y fwknop, que usan paquetes de Debian, todo se ejecuta desde imágenes oficiales de Docker con red en modo host.

Criterios de medición

  • Rendimiento: cada prueba dura 20 segundos, se hacen 3 rondas y se toma la mediana. HTTP y HTTPS usan wrk con 128 conexiones persistentes; las nuevas conexiones TLS usan oha con 64 en paralelo y una conexión nueva por petición; HTTP/2 usa h2load con 64 conexiones y 10 flujos simultáneos cada una.
  • Memoria: suma del PSS de todos los procesos del contenedor probado (la memoria compartida entre procesos se reparte proporcionalmente, por lo que no se cuenta dos veces). «En reposo» es el valor 10 segundos después de terminar el arranque y la configuración; «pico» es el máximo durante la prueba de carga.
  • CPU: tiempo de CPU del cgroup del contenedor probado, donde el 100 % equivale a una vCPU.
  • Arranque: se reinicia el programa con la configuración lista, se mide el tiempo hasta que la primera petición se responde correctamente y se toma la mediana de 3 repeticiones.
  • Todos los programas tienen desactivado el registro de acceso. nginx tiene activado el grupo de conexiones persistentes hacia el origen y un límite de peticiones por conexión ampliado (un ajuste habitual); el resto de programas usa su configuración predeterminada.

Proxy inverso ​

El dominio bench.test se envía por proxy inverso al origen, con HTTP en el puerto 8080 y HTTPS en el 8443 (Nginx Proxy Manager solo puede usar 80/443).

Peticiones HTTPS por segundo (conexiones persistentes)Más es mejor
nginx85,434QPS
HAProxy83,953QPS
Traefik35,812QPS
Nginx Proxy Manager32,816QPS
Gately32,764QPS
Caddy22,871QPS
Lucky14,376QPS
Nuevas conexiones TLS por segundo (un handshake completo por petición)Más es mejor
Gately4,636conex./s
Traefik4,482conex./s
Nginx Proxy Manager4,015conex./s
Caddy3,987conex./s
nginx3,796conex./s
Lucky3,621conex./s
HAProxy3,293conex./s
Memoria en reposoMenos es mejor
nginx15.7MiB
HAProxy36.4MiB
Gately47.6MiB
Caddy48.8MiB
Traefik89.0MiB
Lucky124.6MiB
Nginx Proxy Manager155.7MiB

Los 47.6 MiB de Gately incluyen todos los módulos funcionales (DDNS, certificados, WAF, prevención de intrusiones, etc. se ejecutan en el mismo proceso); Lucky tiene 2 procesos y Nginx Proxy Manager 22 (nginx, el backend Node.js, etc.).

ProgramaHTTPHTTPSHTTP/2TLS nuevas/sArchivo de 100 MBCPU a 5000 QPSMemoria en reposoPico de cargaPor conexión inactivaTiempo de reinicioImagen
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 MiBpreasignada1.50 s1,959 MB
  • HTTP, HTTPS y HTTP/2 se expresan en peticiones por segundo. «CPU a 5000 QPS» es la CPU que usa el programa con una carga fija de 5000 peticiones por segundo; cuanto menos, más ahorro de energía.
  • Por defecto, nginx cierra cada conexión tras 1000 peticiones, mientras que h2load no vuelve a conectarse, así que en la columna HTTP/2 se amplió este límite tanto en nginx como en Nginx Proxy Manager (en Nginx Proxy Manager solo se amplió mediante configuración personalizada en la prueba HTTP/2; el resto de pruebas mantuvo los valores predeterminados).
  • En la columna de archivo grande, nginx y Nginx Proxy Manager quedan más bajos porque nginx escribe por defecto en un archivo temporal en disco las respuestas que superan el búfer de memoria.
  • «Por conexión inactiva» es la memoria añadida al mantener 10,000 conexiones persistentes inactivas, dividida entre el número de conexiones. Los programas en Go tienen un búfer de lectura y escritura y una goroutine por conexión, unos 20–28 KiB; nginx y HAProxy, menos de 1 KiB. Nginx Proxy Manager preasigna una tabla de conexiones según su configuración, por lo que no se pudo medir ningún aumento.
  • La imagen de Gately es mayor porque incluye la CLI de Docker y las herramientas nftables e iptables; el programa en sí es un único archivo de 40 MB y el paquete de descarga ocupa 18 MB.

1000 sitios ​

Cada programa se configura con 1000 sitios de proxy inverso con dominios distintos, y en la prueba de carga cada petición elige un dominio al azar.

Peticiones HTTP por segundo con 1000 sitiosMás es mejor
nginx122,958QPS
Gately33,211QPS
Traefik24,229QPS
HAProxy24,057QPS
Caddy9,819QPS
ProgramaPeticiones/sFrente a 1 sitioLatencia p99Reinicio hasta que el último sitio está disponibleMemoria en reposoPico de carga
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 compara regla por regla con use_backend ... if { hdr(host) -i dominio }, por lo que se vuelve más lento cuantos más sitios hay; usar un archivo map lo evita, pero aquí se mantiene la forma habitual de «una regla por sitio».
  • El pico de memoria de Gately procede sobre todo de las estadísticas de acceso de cada sitio: en v0.6.8.1 cada sitio con tráfico guarda un bloque entero de estadísticas por minuto de 24 horas y cuantiles de latencia (unos 108 KiB). La versión de desarrollo las guarda en bloques por hora, lo que baja el pico a 225 MiB; consulta Optimizaciones de la versión de desarrollo.

Autenticación web ​

El sitio exige iniciar sesión, y la prueba mide las peticiones de usuarios autenticados y el propio inicio de sesión. Gately usa la autenticación web y la autenticación básica integradas del sitio; el grupo de comparación es nginx o Caddy con Authelia delante (auth_request / forward_auth), además del auth_basic propio de nginx. Todo va por HTTPS.

Peticiones por segundo de usuarios autenticados (con cookie de sesión)Más es mejor
Gately26,726QPS
nginx + Authelia14,291QPS
Lucky10,786QPS
Caddy + Authelia7,141QPS
ConfiguraciónPeticiones autenticadas/sSin autenticaciónAutenticación básica (bcrypt)Inicios de sesión correctos/sPico de memoria al iniciar sesiónMemoria en reposo
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,107ver notas209 MiB127 MiB
  • Hash de contraseñas: la autenticación básica de Gately y de nginx/Caddy usa bcrypt (cost 10), Authelia usa argon2id (t=3, 64 MiB, p=4) y Lucky guarda en texto plano las contraseñas de los usuarios del sitio. Cada inicio de sesión en Authelia ocupa 64 MiB de memoria, y con 8 inicios de sesión simultáneos la memoria supera 1 GB.
  • El auth_basic de nginx recalcula bcrypt en cada petición, por lo que solo alcanza 40 peticiones/s; Gately y Caddy guardan en caché el resultado de la verificación. Con apr1 (MD5), nginx alcanza 13,082 peticiones/s.
  • Contraseñas incorrectas: Gately rechaza directamente a un origen tras 10 fallos (procesa 16,000 peticiones erróneas por segundo y la CPU deja de calcular hashes); Authelia añade un retraso fijo de aproximadamente 1 segundo a cada fallo. Durante el bloqueo, ambos rechazan también la contraseña correcta de ese origen, y las sesiones ya iniciadas no se ven afectadas.
  • Con 8 inicios de sesión simultáneos, Lucky devolvió create webauth session error en todos los casos, así que no se pudo medir su rendimiento de inicio de sesión.

WAF ​

Los tres usan OWASP CRS 4.25.0, nivel de paranoia 1 y modo de bloqueo. Gately y Caddy usan el mismo motor Coraza, y nginx usa ModSecurity v3.

Peticiones GET por segundo con el WAF activadoMás es mejor
Gately2,498QPS
Caddy + Coraza2,265QPS
nginx + ModSecurity1,491QPS
ProgramaGETGET con 8 parámetrosPOST de formulario de 4 KBTráfico de ataquePico de memoria bajo cargaMemoria en reposo (act./desact.)
Gately2,4981,067721,218754 MiB88 / 48 MiB
nginx + ModSecurity1,4915911021,01473 MiB62 / 24 MiB
Caddy + Coraza2,265943461,004792 MiB96 / 55 MiB
Eficacia de detecciónGatelynginx + ModSecurityCaddy + Coraza
Muestras de ataque bloqueadas (557)77.2%77.2%77.2%
Falsos positivos en muestras normales (389)20.1%20.1%20.1%
Casos de regresión de CRS detectados (2049)95.9%95.2%95.7%
  • Las propias reglas CRS son pesadas: con el WAF activado, el rendimiento de los tres baja a solo el 1 %–10 % del valor con el WAF desactivado, por lo que en los sitios que necesiten WAF conviene activarlo únicamente en las interfaces dinámicas.
  • Al inspeccionar el cuerpo de las peticiones POST, el motor Coraza (tanto en Gately como en Caddy) supera los 700 MiB de memoria en su pico, mientras que ModSecurity se mantiene en 73 MiB; conviene tenerlo en cuenta al activar la inspección del cuerpo en dispositivos con poca memoria.
  • Las muestras proceden de gotestwaf (MIT), de las pruebas de regresión incluidas en CRS (Apache-2.0) y de peticiones normales escritas a mano; los falsos positivos son sobre todo artículos técnicos con palabras clave de SQL/shell y las interfaces PUT/DELETE (CRS no permite estos métodos por defecto).

Prevención de intrusiones ​

Escenario: un servicio web recibe un escaneo y se bloquea la IP tras 5 respuestas 404 en 60 segundos (nftables). fail2ban lee el registro de acceso de nginx con pyinotify; Gately lee el mismo registro con una regla de archivo de registro equivalente, y se mide además otro grupo con la detección de rutas integrada en los servicios web de Gately.

Tiempo necesario para bloquear las 10,000 IP atacantesMenos es mejor
Gately12.3s
fail2ban51.2s
MétricaGately (lectura de archivo de registro)Gately (detección integrada en el servicio web)fail2ban
Latencia de bloqueo de un solo atacante p50 / p99478 / 996 ms10 / 13 ms280 / 864 ms
CPU con 1000 líneas/s de registro2.9%—20.4%
CPU con 20,000 líneas/s de registro35.7%—83.2%
10,000 IP atacantes: todas bloqueadas12.3 s—51.2 s
10,000 IP atacantes: CPU consumida10.1 s de CPU—60.3 s de CPU
Memoria en reposo44.1 MiB40.7 MiB17.6 MiB
Sin bloquear / bloqueos erróneos0 / 00 / 00 / 0
  • Gately lee el archivo de registro una vez por segundo, por lo que la latencia de un bloqueo individual está entre 0 y 1 segundo y, de media, es unos 0.2 segundos más lenta que el inotify de fail2ban; la detección integrada en el servicio web cuenta directamente al procesar la petición y no tiene ese retraso.
  • fail2ban lanza un proceso nft en cada bloqueo, por lo que se forma cola cuando hay muchos atacantes: con 10,000 IP, la última se bloqueó 41 segundos después de terminar la inyección.
  • fail2ban en sí ocupa 2 MB, pero depende de un entorno de ejecución de Python de unos 24 MB.

Port Knocking ​

Se comparan tres enfoques: el Port Knocking de Gately (autorización de paquete único SPA compatible con fwknop, bloqueo con nftables), fwknop 2.6.11 (también SPA, bloqueo con iptables) y el knock de fnOS fn-knock 2.5.11 (permite la IP de origen tras iniciar sesión en la web, y su pasarela reenvía el tráfico). Gately también ofrece una entrada que permite el acceso tras iniciar sesión en la web, que se mide como un grupo aparte. Lo protegido es un servicio nginx en un puerto TCP, y el cliente usa una dirección de prueba pública, por lo que no le afecta la excepción «la red local no necesita llamar».

Peticiones por segundo con conexiones cortas por el puerto protegido tras la aperturaMás es mejor
fwknop65,046QPS
Gately64,763QPS
Gately acceso web63,556QPS
fn-knock1,886QPS

Conectando directamente al origen sin ningún programa de Port Knocking se obtienen 67,034 peticiones/s.

MétricaGately (SPA)Gately (acceso web)fwknopfn-knock
De la llamada a puerto accesible p50 / p998.4 / 13.4 ms58 / 73 ms9.0 / 18.1 ms84 / 143 ms
Puerto protegido sin autorizaciónDescarte (tiempo agotado)Descarte (tiempo agotado)Descarte (tiempo agotado)Reinicio tras el handshake (detectable)
Peticiones/s con conexión persistente / corta tras la apertura143,867 / 64,764143,839 / 63,556148,371 / 65,046140,137 / 1,886
CPU del reenvío tras la apertura (conexiones cortas)2%1%0%134%
Llamadas legítimas con 50,000 paquetes inválidos/s desde un único origen10/10 (CPU 26%)—3/8 (CPU 102%)—
Llamadas legítimas con 10,000 paquetes inválidos/s desde orígenes falsificados1/7—10/10 (CPU 54%)—
Memoria en reposo48.7 MiB48.7 MiB2.2 MiB63.2 MiB (3 procesos)
  • En Gately y fwknop, tras la apertura el cortafuegos deja pasar el tráfico directamente y este no pasa por el programa de Port Knocking, por lo que el rendimiento es igual al de una conexión directa; fn-knock reenvía a través de su pasarela en un Linux normal y además consulta una vez al plano de control la autorización en cada conexión nueva, de modo que su rendimiento con conexiones cortas es solo el 3 % del de una conexión directa. En la versión fpk de fnOS, fn-knock tiene además un modo de conexión directa con el cortafuegos; aquí se midió la versión Docker.
  • El inicio de sesión de fn-knock exige resolver primero una prueba de trabajo ALTCHA (en esta prueba, p50 de 28 ms para resolverla); sin contar la resolución, 50 ms.
  • fwknopd procesa cada paquete en un único hilo; con 50,000 paquetes/s desde un único origen satura un núcleo y las llamadas legítimas empiezan a fallar. Gately limita la tasa por origen, por lo que una inundación desde un único origen casi no consume CPU.
  • Problema conocido: cuando un atacante falsifica muchas direcciones de origen distintas, la tabla de límite de tasa por origen de Gately se llena, la cuota de desbordamiento compartida por los orígenes nuevos se agota con la inundación y la mayoría de las llamadas legítimas fallan (en ese momento la CPU de Gately es de solo un 19 % aproximadamente). fwknop no limita la tasa y no se ve afectado hasta que la CPU se satura.

DNS dinámico ​

Cada programa se configura con 20 tareas DDNS y un período de comprobación de 30 segundos. La IP pública se consulta en el origen local y las actualizaciones se envían al origen local mediante una «devolución de llamada personalizada», sin tocar ningún proveedor de DNS real. Tras el arranque y la primera sincronización, se toma una muestra durante 5 minutos.

Memoria media con 20 tareas DDNSMenos es mejor
ddns-go16.9MiB
Gately51.6MiB
Lucky131.3MiB
ProgramaMemoria mediaMemoria picoCPU mediaImagen
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
  • Los tres solo consultan al proveedor cuando cambia la IP o llega el período de sincronización forzada, por lo que el consumo permanente es pequeño en todos. Si solo se necesita DDNS, ddns-go es el que menos memoria usa; la cifra de Gately incluye todos sus módulos y el mismo proceso puede ejecutar a la vez certificados, proxy inverso y otras funciones.

Router OpenWrt ​

Cada programa se ejecuta en una VM de router ImmortalWrt 25.12.1 (2 vCPU, 1 GB de memoria). La máquina de carga accede al router mediante un puente de la red local y el router envía por proxy inverso al origen de la máquina de carga. nginx 1.26.3 y HAProxy 3.2.21 proceden del repositorio de paquetes de ImmortalWrt, Gately usa el paquete apk oficial de OpenWrt y Lucky usa el binario oficial de Linux.

Peticiones HTTPS por segundo en el router (conexiones persistentes)Más es mejor
nginx40,665QPS
HAProxy36,266QPS
Gately15,669QPS
Lucky8,113QPS
ProgramaHTTPHTTPSTLS nuevas/sCPU a 2000 QPSMemoria en reposoPico de cargaTamaño del programa
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
  • En el router, el cuello de botella está sobre todo en el envío y la recepción de red del kernel (interrupciones software), y ningún programa llega a usar por completo los dos núcleos, por lo que las diferencias son menores que en la máquina de carga. El rendimiento de Gately es aproximadamente el doble que el de Lucky, con una tercera parte menos de memoria.
  • El kernel de OpenWrt no tiene smaps, así que aquí la memoria se estima a partir de /proc/<pid>/statm (suma de la memoria residente privada de cada proceso más una copia de la parte compartida). Durante la prueba se desactivó temporalmente la protección contra inundaciones SYN que trae el cortafuegos por defecto (unas 25 conexiones nuevas por segundo), porque de lo contrario limitaría la prueba de nuevas conexiones TLS.
  • Si solo se necesita proxy inverso, el nginx del repositorio de paquetes es el más pequeño en tamaño y memoria; los 40 MB de Gately incluyen todos los módulos, y en build.gately.cn puede elegir solo los módulos necesarios para generar un paquete de instalación más pequeño. En routers con poca memoria flash, conviene comprobar antes el espacio libre.

Todo en uno ​

Un único Gately con todo esto activado a la vez: dos sitios de proxy inverso (HTTP y HTTPS, ambos con WAF), un sitio con autenticación web, 20 tareas DDNS, una regla de registro de prevención de intrusiones y una regla de Port Knocking. El grupo de comparación es una combinación de herramientas independientes que ofrecen las mismas funciones, sumando la memoria en reposo medida antes para cada una.

Memoria en reposo total para el mismo conjunto de funcionesMenos es mejor
Gately90.8MiB
nginx + ModSecurity + Authelia + ddns-go + fail2ban + fwknop203.5MiB
Nginx Proxy Manager + Authelia + ddns-go + fail2ban + fwknop297.3MiB

El grupo de Nginx Proxy Manager no incluye WAF.

FunciónHerramienta independienteMemoria en reposoTamaño de instalación
Proxy inverso + WAFnginx + ModSecurity (CRS 4.25)61.9 MiBImagen de 156 MB
Proxy inverso (interfaz gráfica)Nginx Proxy Manager155.7 MiBImagen de 1,959 MB
Autenticación webAuthelia104.4 MiBImagen de 110 MB
DNS dinámicoddns-go17.4 MiBImagen de 43 MB
Prevención de intrusionesfail2ban17.6 MiB24 MB (con Python)
Port Knockingfwknop2.2 MiB0.3 MB
TodoGately90.8 MiBPrograma de 40 MB (descarga de 18 MB)
  • La instancia todo en uno de Gately, con 1000 peticiones/s de tráfico HTTPS a través del WAF, alcanza un pico de memoria de 114 MiB y una CPU del 71 %; las 20 tareas DDNS se sincronizaron correctamente.
  • La emisión de certificados (certbot, acme.sh) solo se ejecuta en las renovaciones y no se incluye en la memoria residente.

Optimizaciones de la versión de desarrollo ​

A partir de los resultados anteriores, la versión de desarrollo (sin publicar, posterior al commit 3d579389) introdujo los cambios siguientes y se volvió a medir en el mismo entorno. El proxy inverso usa la compilación del commit 3d579389; los 1000 sitios y la prevención de intrusiones usan una compilación que incluye los cambios posteriores. La columna de referencia es v0.6.8.1 medida de nuevo el mismo día (ese día solo se repitieron las filas de HTTP y HTTPS; las demás referencias proceden de los datos anteriores).

  • Los sitios de un mismo oyente que hacen proxy inverso al mismo backend con la misma configuración de conexión comparten un grupo de conexiones.
  • Con al menos 1 GiB de memoria disponible, el valor por defecto del porcentaje de GC pasa de 100 a 200 (se puede cambiar en los ajustes; los dispositivos con poca memoria mantienen 100).
  • El proxy inverso copia la petición una vez menos y crea tres valores de contexto menos por petición.
  • Las estadísticas por minuto de 24 horas de cada sitio se guardan en bloques por hora que se reservan al usarse, y los campos de los cubos pasan a contadores de 32 bits (un sitio con tráfico durante una sola hora baja de unos 108 KiB a unos 5 KiB, y uno con tráfico todo el día ocupa unos 50 KiB).
  • La prevención de intrusiones lee los archivos de registro con inotify, de modo que lee en cuanto se escribe (se mantiene el sondeo cada segundo como respaldo); las escrituras de bloqueos en el firewall se combinan como máximo una vez cada 250 milisegundos.
Métricav0.6.8.1Versión de desarrolloCambio
Peticiones HTTP/s (referencia del mismo día)35,96838,358+6.6%
Peticiones HTTPS/s (referencia del mismo día)34,07236,079+5.9%
Conexiones TLS nuevas/s4,6364,942+6.6%
Peticiones HTTP/2/s21,59123,788+10%
1000 sitios: peticiones/s33,21137,423+13%
1000 sitios: latencia p9929.8 ms12.9 ms-57%
1000 sitios: pico de memoria durante la prueba463 MiB225 MiB-51%
Pico de memoria en la prueba HTTP64.5 MiB81.1 MiB+26%
Prevención de intrusiones: latencia de bloqueo de un solo atacante p50 / p99478 / 996 ms9.8 / 129 ms
Prevención de intrusiones: latencia de bloqueo con ataque sostenido p50 / p99 (20,000 líneas/s)509 / 1006 ms143 / 269 ms
Prevención de intrusiones: CPU a 1000 líneas/s2.9%8.0%mayor
Prevención de intrusiones: CPU a 20,000 líneas/s35.7%26.5%-26%
Prevención de intrusiones: bloquear las 10,000 IP atacantes12.3 s, 10.1 s de CPU10.1 s, 2.5 s de CPU
  • La mejora del rendimiento procede sobre todo del ajuste de GC, a cambio de un pico de memoria unos diez MiB mayor durante la prueba. El análisis de perfil muestra que casi toda la sobrecarga restante en la ruta del proxy está en la implementación HTTP de la biblioteca estándar de Go y en el GC; la diferencia con nginx y HAProxy corresponde al lenguaje y al entorno de ejecución.
  • Con 1000 sitios, el rendimiento sube y la latencia baja porque, al compartir el grupo de conexiones, hay muchas menos conexiones hacia el origen; el pico de memoria se reduce a la mitad gracias al almacenamiento de las estadísticas en bloques.
  • La latencia de un bloqueo individual ya es menor que la de fail2ban (280 / 864 ms). Con pocas líneas de registro por segundo, la CPU es mayor que en la versión anterior porque el firewall se escribe como máximo 4 veces por segundo, frente a 1 vez antes; sigue siendo cuatro décimas partes de la de fail2ban (20.4%).

Reproducir ​

bash
git clone https://github.com/wangwanjie/gately && cd gately/tools/benchmark
# Ejecutar como root en una VM Debian 13; requiere Docker, wrk, oha y h2load
bash provision-debian.sh
python3 lib/run.py gately 3     # proxy inverso; sustituya por nginx, haproxy, caddy, traefik, lucky, npm
bash auth/run.sh                # autenticación web
bash waf/run.sh                 # WAF
bash guard/run.sh               # prevención de intrusiones
bash knock/run.sh               # Port Knocking
bash scale/run.sh 1000          # 1000 sitios
bash ddns/run.sh 20             # DNS dinámico
bash bundle/run.sh              # todo en uno
bash router/run.sh              # router (requiere además una máquina OpenWrt)

El README de cada directorio describe la configuración, los criterios de medición y las limitaciones conocidas. Los resultados dependen del hardware, de la virtualización y de la configuración, por lo que conviene repetir las pruebas con su propia carga de trabajo.

Publicado bajo la licencia Apache-2.0.