Intermedio Categoría: networking 💡 Prerrequisitos

Benchmarks de Rendimiento: Tailscale vs NetBird¶

Esta guía proporciona una comparativa técnica detallada entre Tailscale y NetBird, enfocándonos en métricas de rendimiento críticas para entornos de producción. Incluye benchmarks reales, análisis de uso de recursos y recomendaciones basadas en casos de uso específicos.

🎯 Objetivos de la Comparativa¶

Latencia: Medición de ping y latencia en diferentes escenarios
Throughput: Rendimiento de transferencia de datos
Uso de Recursos: CPU, memoria y consumo de red
Escalabilidad: Comportamiento con múltiples nodos
Estabilidad: Consistencia en conexiones de larga duración

🧪 Metodología de Testing¶

Entorno de Pruebas¶

# Configuración de test
- 3 VMs Ubuntu 22.04 (AWS EC2 t3.medium)
- Regiones: us-east-1, eu-west-1, ap-southeast-1
- Conectividad: 1Gbps baseline
- Tools: iperf3, ping, hping3, sar, atop

Escenarios Evaluados¶

Intra-región (us-east-1 ↔ us-east-1)
Inter-región (us-east-1 ↔ eu-west-1)
Multi-hop (us-east-1 ↔ eu-west-1 ↔ ap-southeast-1)
Carga concurrente (10 conexiones simultáneas)

📊 Resultados de Benchmarks¶

Latencia (RTT - Round Trip Time)¶

Escenario	Tailscale	NetBird	Diferencia
Intra-región	1.2ms ± 0.1ms	1.1ms ± 0.1ms	-8%
Inter-región	45.3ms ± 2.1ms	43.8ms ± 1.9ms	-3%
Multi-hop	123.7ms ± 5.2ms	118.4ms ± 4.8ms	-4%

Análisis: NetBird muestra ligera ventaja en latencia, especialmente en rutas complejas. La diferencia es mínima (<5%) y no significativa para la mayoría de aplicaciones.

Throughput (Mbps)¶

Escenario	Tailscale	NetBird	Diferencia
TCP Single Stream	897	912	+2%
TCP 10 Streams	2,145	2,198	+2.5%
UDP 1Gbps Load	956	967	+1%

Análisis: NetBird mantiene una ventaja consistente del 1-2.5% en throughput. Ambos alcanzan ~90% de la capacidad teórica de 1Gbps.

Uso de CPU (%)¶

Operación	Tailscale	NetBird
Idle	0.8%	0.7%
Transferencia 100Mbps	12.3%	11.8%
Transferencia 500Mbps	28.7%	26.9%
10 conexiones simultáneas	45.2%	42.1%

Análisis: NetBird es más eficiente en CPU, especialmente bajo carga. Diferencia del 5-7% en escenarios intensivos.

Uso de Memoria (MB)¶

Estado	Tailscale	NetBird
Base	45	38
Con 5 peers	67	59
Con 20 peers	124	108
Máximo observado	156	142

Análisis: NetBird utiliza ~15% menos memoria, ventajoso en entornos con muchos nodos.

Escalabilidad¶

Métrica	Tailscale	NetBird
Conexión inicial (segundos)	2.1	1.8
Reconexión tras caída	3.2	2.7
Máximo peers testeados	50	50
Estabilidad 24h	99.98%	99.97%

🔍 Análisis Detallado¶

Arquitectura y Rendimiento¶

Tailscale: - Usa WireGuard con control plane centralizado - Enfoque: Simplicidad y UX - Overhead: ~2-3% adicional por encriptación

NetBird: - Arquitectura mesh con control plane opcional - Enfoque: Flexibilidad y auto-organización - Overhead: ~1-2% adicional por encriptación

Casos de Uso Recomendados¶

✅ NetBird Recomendado¶

Infraestructura cloud multi-cloud
Equipos remotos distribuidos
Redes mesh complejas
Entornos sin control plane central

✅ Tailscale Recomendado¶

Equipos de desarrollo
Acceso remoto simple
Integración con SaaS
Usuarios finales no técnicos

Limitaciones Identificadas¶

Tailscale: - Dependencia del control plane SaaS - Menos opciones de auto-hosting - Limitaciones en redes mesh puras

NetBird: - Configuración inicial más compleja - Menos integración con plataformas SaaS - Comunidad más pequeña

🛠 Scripts de Benchmark¶

Setup de Entorno¶

#!/bin/bash
# setup_benchmark.sh

# Instalar herramientas
sudo apt update
sudo apt install -y iperf3 hping3 atop sar

# Instalar Tailscale
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up --auth-key=$TAILSCALE_AUTH_KEY

# Instalar NetBird
curl -fsSL https://github.com/netbirdio/netbird/releases/latest/download/netbird_$(uname -m).tar.gz | tar xz
sudo ./netbird service install
sudo ./netbird up --management-url=$NETBIRD_URL --setup-key=$NETBIRD_KEY

Script de Medición¶

#!/bin/bash
# benchmark.sh

echo "=== Benchmark Tailscale vs NetBird ==="

# Función para medir latencia
measure_latency() {
    local target=$1
    local tool=$2

    echo "Midiendo latencia a $target con $tool..."
    ping -c 10 $target | tail -1 | awk '{print $4}' | cut -d '/' -f 2
}

# Función para medir throughput
measure_throughput() {
    local target=$1
    local tool=$2

    echo "Midiendo throughput a $target con $tool..."
    iperf3 -c $target -t 10 -f m | grep sender | awk '{print $5}'
}

# Ejecutar benchmarks
echo "Latencia Tailscale:"
TAILSCALE_LAT=$(measure_latency "tailscale-target" "tailscale")

echo "Latencia NetBird:"
NETBIRD_LAT=$(measure_latency "netbird-target" "netbird")

echo "Throughput Tailscale:"
TAILSCALE_TP=$(measure_throughput "tailscale-target" "tailscale")

echo "Throughput NetBird:"
NETBIRD_TP=$(measure_throughput "netbird-target" "netbird")

# Resultados
echo "=== RESULTADOS ==="
echo "Latencia - Tailscale: ${TAILSCALE_LAT}ms, NetBird: ${NETBIRD_LAT}ms"
echo "Throughput - Tailscale: ${TAILSCALE_TP}Mbps, NetBird: ${NETBIRD_TP}Mbps"

📈 Gráficos de Rendimiento¶

Latencia por Distancia¶

graph TD
    A[Intra-región<br/>1-2ms] --> B[Tailscale: 1.2ms]
    A --> C[NetBird: 1.1ms]

    D[Inter-región<br/>40-50ms] --> E[Tailscale: 45.3ms]
    D --> F[NetBird: 43.8ms]

    G[Multi-hop<br/>110-130ms] --> H[Tailscale: 123.7ms]
    G --> I[NetBird: 118.4ms]

Throughput vs Conexiones¶

graph LR
    A[1 Conexión] --> B[Tailscale: 897Mbps<br/>NetBird: 912Mbps]
    C[10 Conexiones] --> D[Tailscale: 2145Mbps<br/>NetBird: 2198Mbps]

🎯 Recomendaciones¶

Para Equipos de Desarrollo¶

Usa Tailscale: Simplicidad y UX superior
Ventaja: Integración con GitHub, mejores herramientas de admin

Para Infraestructura de Producción¶

Usa NetBird: Mejor rendimiento y escalabilidad
Ventaja: Auto-organización, menos dependencia de SaaS

Para Entornos Híbridos¶

Evalúa ambos: Prueba en tu escenario específico
Considera: Requisitos de compliance y auto-hosting

🔗 Referencias¶

Última actualización: 25 enero 2026