--- title: "Cómo medir el rendimiento con sysbench en Ubuntu 24.04" description: "Instala sysbench en Ubuntu 24.04 y mide CPU, memoria, disco y MySQL con pruebas repetibles. Aprende a leer los resultados y a guardar una línea base comparable." category: "Rendimiento y Benchmarking" language: es source: https://cubepath.com/es/docs/rendimiento-y-benchmarking/benchmarking-del-servidor-con-sysbench updated: 2026-09-25 --- # Cómo medir el rendimiento con sysbench en Ubuntu 24.04 sysbench es una herramienta de benchmarking para Linux que genera carga sintética sobre CPU, memoria, disco y bases de datos MySQL o PostgreSQL. Sirve para comparar dos servidores, validar un cambio de plan o de configuración y detectar degradaciones con el tiempo. En este tutorial instalarás sysbench en Ubuntu 24.04, ejecutarás pruebas de CPU, memoria, E/S de archivos y OLTP sobre MySQL, y guardarás los resultados como línea base. ## Requisitos previos - Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. - Un usuario no root con privilegios `sudo`. - Al menos 10 GB libres en disco para la prueba de E/S. - Opcional, para el paso 5: MySQL 8.0 instalado (`sudo apt install mysql-server`). > Nota: un benchmark mide el servidor en el momento de la prueba. Ejecútalo sin otras cargas pesadas en marcha y repite cada prueba al menos tres veces para descartar valores atípicos. ## Paso 1: Instalar sysbench sysbench está en los repositorios de Ubuntu, así que no hace falta compilarlo: ```bash sudo apt update sudo apt install sysbench ``` Comprueba la versión instalada: ```bash sysbench --version ``` ```output sysbench 1.0.20 ``` Antes de empezar, anota las características del servidor. Te servirán para interpretar los números y comparar con otras máquinas: ```bash nproc lscpu | grep -E 'Model name|Socket|Thread|Core' free -h ``` ## Paso 2: Medir la CPU La prueba de CPU calcula números primos hasta un límite (`--cpu-max-prime`) y cuenta cuántas veces lo consigue por segundo. Primero ejecútala con un solo hilo para medir el rendimiento por núcleo: ```bash sysbench cpu --cpu-max-prime=20000 --threads=1 --time=30 run ``` La parte relevante de la salida es esta: ```output CPU speed: events per second: 1098.45 General statistics: total time: 30.0008s total number of events: 32955 Latency (ms): min: 0.89 avg: 0.91 max: 1.73 95th percentile: 0.94 sum: 29990.12 ``` - `events per second`: la métrica principal. Más alto es mejor. - `95th percentile`: latencia del 95 % de los eventos. Si el máximo y el percentil 95 se alejan mucho de la media, algo compite por la CPU (otros procesos o *steal time* en una VM). Después repite la prueba con tantos hilos como vCPU tenga el servidor: ```bash sysbench cpu --cpu-max-prime=20000 --threads="$(nproc)" --time=30 run ``` En un servidor con 4 vCPU deberías obtener cerca de 4 veces los eventos por segundo de la prueba de un hilo. Si la escalada es claramente peor, revisa el *steal time* con `top` (columna `st`) mientras corre la prueba. > Importante: usa siempre el mismo `--cpu-max-prime` al comparar resultados. Con otro límite, los eventos por segundo no son comparables. ## Paso 3: Medir el ancho de banda de memoria La prueba de memoria escribe o lee bloques en RAM y mide la velocidad de transferencia. Con bloques de 1 MB se mide el ancho de banda secuencial: ```bash sysbench memory --memory-block-size=1M --memory-total-size=20G --memory-oper=write --threads=1 run ``` ```output Total operations: 20480 (15234.87 per second) 20480.00 MiB transferred (15234.87 MiB/sec) ``` La cifra que interesa es `MiB/sec`. Para medir lectura, cambia `--memory-oper=write` por `--memory-oper=read`. Para ver el ancho de banda total del servidor, usa todos los hilos: ```bash sysbench memory --memory-block-size=1M --memory-total-size=50G --memory-oper=read --threads="$(nproc)" run ``` Los bloques pequeños (`--memory-block-size=4K`) y el acceso aleatorio (`--memory-access-mode=rnd`) miden más la latencia de la caché y la TLB que el ancho de banda, y dan cifras mucho menores. Es normal. ## Paso 4: Medir la E/S de disco La prueba `fileio` trabaja sobre archivos que crea en el **directorio actual**, así que crea uno dedicado en el disco que quieras medir: ```bash mkdir ~/sysbench-io && cd ~/sysbench-io ``` Genera 8 GB de archivos de prueba. Por defecto sysbench los reparte en 128 archivos: ```bash sysbench fileio --file-total-size=8G prepare ``` ```output 128 files, 65536Kb each, 8192Mb total Creating files for the test... ``` Ahora ejecuta una prueba de lectura y escritura aleatoria. `--file-extra-flags=direct` usa `O_DIRECT` para saltarse la caché de páginas del sistema, de modo que mides el disco y no la RAM: ```bash sysbench fileio --file-total-size=8G --file-test-mode=rndrw --file-extra-flags=direct --time=60 --threads=4 run ``` ```output File operations: reads/s: 9512.33 writes/s: 6341.55 fsyncs/s: 202.87 Throughput: read, MiB/s: 148.63 written, MiB/s: 99.09 ``` Con bloques de 16 KB (el valor por defecto), `reads/s` y `writes/s` equivalen a IOPS. Para medir el rendimiento secuencial, usa `seqrd` (lectura) o `seqwr` (escritura) con bloques grandes: ```bash sysbench fileio --file-total-size=8G --file-test-mode=seqrd --file-block-size=1M --file-extra-flags=direct --time=60 run ``` Los modos disponibles son `seqwr`, `seqrewr`, `seqrd`, `rndrd`, `rndwr` y `rndrw`. Cuando termines, borra los archivos de prueba: ```bash sysbench fileio --file-total-size=8G cleanup cd ~ && rmdir ~/sysbench-io ``` > Consejo: para un análisis de disco más detallado (profundidad de cola, percentiles de latencia, cargas mixtas) usa `fio`, que está pensado específicamente para almacenamiento. ## Paso 5: Medir MySQL con la prueba OLTP sysbench incluye scripts OLTP que simulan transacciones típicas de una aplicación: lecturas por clave primaria, rangos, actualizaciones e inserciones. Este paso requiere MySQL instalado. Crea una base de datos y un usuario dedicados. En Ubuntu, el usuario `root` de MySQL se autentica por socket, así que basta con `sudo`: ```bash sudo mysql ``` Dentro de la consola de MySQL, sustituye `your_strong_password` por una contraseña propia: ```sql CREATE DATABASE sbtest; CREATE USER 'sbtest'@'localhost' IDENTIFIED BY 'your_strong_password'; GRANT ALL PRIVILEGES ON sbtest.* TO 'sbtest'@'localhost'; EXIT; ``` Carga los datos de prueba: 10 tablas de 100.000 filas cada una (unos 250 MB): ```bash sysbench oltp_read_write --db-driver=mysql --mysql-user=sbtest --mysql-password=your_strong_password \ --mysql-db=sbtest --tables=10 --table-size=100000 prepare ``` Ejecuta la prueba durante 2 minutos con 8 hilos, mostrando un informe cada 10 segundos: ```bash sysbench oltp_read_write --db-driver=mysql --mysql-user=sbtest --mysql-password=your_strong_password \ --mysql-db=sbtest --tables=10 --table-size=100000 --threads=8 --time=120 --report-interval=10 run ``` ```output [ 10s ] thds: 8 tps: 812.36 qps: 16254.91 (r/w/o: 11379.64/3250.35/1624.92) lat (ms,95%): 13.46 err/s: 0.00 reconn/s: 0.00 ... SQL statistics: transactions: 97416 (811.73 per sec.) queries: 1948320 (16234.60 per sec.) ignored errors: 0 (0.00 per sec.) Latency (ms): avg: 9.85 95th percentile: 13.46 ``` Fíjate en `transactions` por segundo (TPS) y en el percentil 95 de latencia. Otros scripts útiles con la misma sintaxis son `oltp_read_only`, `oltp_write_only`, `oltp_point_select` y `oltp_update_index`. Para que el resultado refleje el disco y no solo la RAM, el tamaño total de las tablas debería superar `innodb_buffer_pool_size`. Si solo te interesa la CPU y la configuración de MySQL, un conjunto que cabe en memoria es suficiente. Al terminar, elimina las tablas de prueba: ```bash sysbench oltp_read_write --db-driver=mysql --mysql-user=sbtest --mysql-password=your_strong_password \ --mysql-db=sbtest --tables=10 cleanup ``` ## Paso 6: Guardar una línea base Un benchmark aislado dice poco. Lo útil es guardar los resultados con fecha para compararlos después de un cambio de configuración, de plan o de kernel. Crea un directorio para los resultados: ```bash mkdir -p ~/benchmarks ``` Ejecuta las pruebas de CPU y memoria guardando la salida completa con `tee`: ```bash sysbench cpu --cpu-max-prime=20000 --threads="$(nproc)" --time=30 run | tee ~/benchmarks/cpu-$(date +%F).txt sysbench memory --memory-block-size=1M --memory-total-size=50G --threads="$(nproc)" run | tee ~/benchmarks/memory-$(date +%F).txt ``` Más adelante, compara las métricas clave de todas las ejecuciones con `grep`: ```bash grep -H 'events per second' ~/benchmarks/cpu-*.txt grep -H 'MiB/sec' ~/benchmarks/memory-*.txt ``` ```output /home/your_user/benchmarks/cpu-2026-09-01.txt: events per second: 4381.20 /home/your_user/benchmarks/cpu-2026-09-25.txt: events per second: 4402.77 ``` Una variación de pocos puntos porcentuales entre ejecuciones es ruido normal. Una caída sostenida del 10 % o más merece investigación. ## Solución de problemas - **`FATAL: Missing required argument: --file-test-mode`**: la fase `run` de `fileio` necesita indicar el modo (`rndrw`, `seqrd`, etc.). - **`FATAL: Cannot open file errno = 2`** en `fileio run`: estás en un directorio distinto al de `prepare`, o no ejecutaste `prepare` con el mismo `--file-total-size`. - **`Access denied for user 'sbtest'@'localhost'`**: revisa la contraseña y que el `GRANT` se aplicó sobre la base de datos `sbtest`. - **Resultados de disco irrealmente altos**: falta `--file-extra-flags=direct` y estás midiendo la caché de páginas, o el tamaño de los archivos es menor que la RAM libre. ## Conclusión Ahora tienes sysbench instalado y sabes medir CPU, memoria, disco y MySQL en Ubuntu 24.04, además de guardar una línea base con fecha. Como siguientes pasos, puedes analizar el disco con más detalle usando `fio`, medir la red entre servidores con `iperf3` o repetir la prueba OLTP antes y después de ajustar `innodb_buffer_pool_size` para cuantificar la mejora.