Linux benchmark III

Dentro de la serie de entradas que hablan sobre cómo comprobar el rendimiento de servidores GNU/Linux hoy vamos a ver cómo realizar pruebas de rendimiento sobre un servidor Apache que contenga una página web. Para ello, vamos a emplear ab (Apache Benchmark tool), que se instala automáticamente al instalara apache2-utils en nuestro sistema.

ab permite simular una solicitud de conexión a una web, pero también simular la conexión de cientos de clientes, así como la concurrencia de varios thread's simultáneamente. De esta forma podemos comprobar, más o menos, el rendimiento que tendría nuestra web con una carga de trabajo real.

Instalación

Como ya se mencionó, únicamente hay que instalar el paquete apache2-utils,

shell> apt-get install apache2-utils

Uso

ab únicamente requiere que le pasemos como argumento la URL que deseamos examinar, pero como era de esperar, también permite el paso de parámetros, lo cual facilitará enormemente el chequeo del sistema. En nuestros caso vamos a indicarle dos parámetros, el primer de ellos, opción -n, indica el número de conexiones que se van a realizar. El segundo, opción -c, indica la concurrencia de las conexiones, es decir, el número de conexiones simultáenas a la web.

shell> ab -n 1000 -c 25 http://www.your_URL.com/

Tras la ejecución del comando, nos presentará unos resultados,

Server Software:        Apache/2.2.16
Server Hostname:        www.your_URL.com
Server Port:            80

Document Path:          /
Document Length:        46701 bytes

Concurrency Level:      25
Time taken for tests:   16.897 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      47177000 bytes
HTML transferred:       46701000 bytes
Requests per second:    59.18 [#/sec] (mean)
Time per request:       422.433 [ms] (mean)
Time per request:       16.897 [ms] (mean, across all concurrent requests)
Transfer rate:          2726.54 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        1    3   3.1      2      24
Processing:   117  418  66.1    414     829
Waiting:       93  358  63.3    350     724
Total:        135  421  65.4    416     831

Percentage of the requests served within a certain time (ms)
  50%    416
  66%    428
  75%    436
  80%    440
  90%    459
  95%    490
  98%    664
  99%    725
 100%    831 (longest request)

Con los resultados delante, ya sólo queda interpretarlos. Lo primero de todo, dejar claro que el benchmark únicamente se ejecuta sobre la URL especificada, en mi caso sobre /indix.html y no sobre toda la web. Esto hay que tenerlo en cuenta, pues no es lo mismo un html estático que un html que lo genera un php con mucha información y acceso a base de datos. También tener en cuenta que todos los complementos adiciones que no sean html, léase javascript, css, imágenes, etc. no entran en la carga, ni por lo tanto en la comprobación de rendimiento. Aun así, Apache Benchmark es una muy buena herramienta para la realización de test a servidores web.

Interpretación

Es importante tener claro lo comentado anteriormente sobre el funcionamiento de ab. Si está claro, ya podemos interpretar los resultados. Aunque prácticamente toda la información mostrada es importante, cabe destacar por ejemplo el tiempo que tarda en ejecutarse el test, así como la cantidad de datos transmitidos. Esto nos dará una orientación sobre la cantidad de datos que descargará cada usuario que visite la URL de prueba. También es muy importante, especialmente para saber cómo afectará al posicionamiento, la relación entre el tiempo de conexión (Connection Time) y el tiempo  que tarda en generarse el documento de salida.

Es importante para tener más claro el comportamiento de nuestra web que esta prueba se ejecute varias veces con parámetros diferente, tanto en número de usuarios concurrentes, como el número de conexiones. Esto es lógico, pues no es lo mismo tener un único usuario navegando que tener 200 simultáneos.

Espero que esta aproximación a ab os deje con ganas de más información. Si la queréis no dudéis de dejar un comentario ni tampoco de leer el manual de la aplicación, que sin duda ayudará mucho.

La entrada Linux benchmark III la puedes leer en Puppet Linux.

Leer más

Linux benchmark II

Dentro de la serie de artículos relacionados con el benchmarcking de sistemas GNU/Linux, hoy vamos a ver cómo comprobar el rendimiento de una base de datos MySQL. Para hacerlo vamos a emplear el comando que introdujimos en el primer post, sysbench. Gracias a él, vamos a simular un número muy elevado de conexiones a MySQL y ejecutar una serie de sentencias, sacando un informe final de rendimiento.

Puesto que cuando evaluamos una base de datos, no siempre es necesario escribir en ella, sysbench lo tiene en cuenta y permite optar por hacer los test en RO o en RW. También, y para no alterar el correcto funcionamiento de las bases de datos que ya tenemos funcionando, sysbench creará la suya propia, con los datos adecuados para realizar los tests e introducirá una sería de tuplas aleatorias en ella.

Para comenzar, por lo tanto, vamos a preparar nuestro entorno de pruebas. Lo único que necesitaremos será una base de datos MySQL a la que poder conectarnos.

Preparando datos

Vamos a crear una tabla temporal dentro de la base de datos test, que tenga 1 millón de filas con las que posteriormente operar.

shell> sysbench --test=oltp --oltp-table-size=1000000 \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       prepare

Una vez el comando haya finalizado, vamos a ver qué ha creado. Esto no es para nada necesario, pero así también nos hacemos una idea de qué tipo de datos emplear para los test.

mysql> show create table sbtest;
+--------+----------------------------------------------------+
| Table  | Create Table                                       |
+--------+----------------------------------------------------+
| sbtest | CREATE TABLE `sbtest` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `k` int(10) unsigned NOT NULL DEFAULT '0',
  `c` char(120) NOT NULL DEFAULT '',
  `pad` char(60) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`),
  KEY `k` (`k`)
) ENGINE=InnoDB AUTO_INCREMENT=1000001 DEFAULT CHARSET=latin1 |
+--------+----------------------------------------------------+
1 row in set (0.00 sec)

mysql> select * from sbtest limit 3;
+----+---+---+----------------------------------------------------+
| id | k | c | pad                                                |
+----+---+---+----------------------------------------------------+
|  1 | 0 |   | qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt |
|  2 | 0 |   | qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt |
|  3 | 0 |   | qqqqqqqqqqwwwwwwwwwweeeeeeeeeerrrrrrrrrrtttttttttt |
+----+---+---+----------------------------------------------------+
3 rows in set (0.00 sec)

Lo que más destaca aquí es el tipo de columnas que emplear. Un par de ellas de tipo int y una autoincremental y otras dos de tipo char.

Realizando comprobaciones

Antes de entrar en este punto sí es bastante importante echar un vistazo al manual de sysbench, pues las diferentes opciones con las que puede trabajar son importantes. Por defecto el tipo de tabla es InnoDB, que en mi caso es correcto por lo que no lo alteraré.

shell> sysbench --test=oltp --oltp-table-size=1000000 \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       --max-time=60 --oltp-read-only=on --num-threads=8 run
...
OLTP test statistics:
    queries performed:
        read:                            261282
        write:                           0
        other:                           37326
        total:                           298608
    transactions:                        18663  (311.00 per sec.)
    deadlocks:                           0      (0.00 per sec.)
    read/write requests:                 261282 (4353.94 per sec.)
    other operations:                    37326  (621.99 per sec.)
...

Otro ejemplo podría ser,

shell> sysbench --num-threads=16 --max-requests=100000 --test=oltp \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       --oltp-table-size=1000000 --oltp-read-only=on run
...
transactions:                        100000 (304.29 per sec.)
...

Y otro más,

shell> sysbench --test=oltp \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       --max-requests=10000 --num-threads=10 run
...
transactions:                        10000  (224.58 per sec.)
...

Como podemos observar, según las opciones especificadas en el comando, el rendimiento obtenido es diferente, de ahí la importancia de combinar este comando con una buena configuración. Según el objetivo que tengamos (conseguir más lecturas, más escrituras, un término intermedio, etc. tendremos que ir alterando la configuración de MySQL (/etc/my.cfg) y volver a lanzar el test de estrés.

En mi sistemas, como en los vuestros, vemos que el rendimiento de desploma bastante de ejecutar un único thread a varios thread's simultáneamente. Y es justo en estos casos donde debemos de ganar rendimiento!

Borrando tablas temporales

Una vez hayamos finalizamos el test debemos de borrar la tabla temporal que se creó para tal efecto, para que no quede ocupando espacio tontamente en el servidor.

También tras cada ejecución si los datos son alterados, deberíamos de borrar los datos de pruebas y volver a generarlos, para trabajar siempre con la misma batería de pruebas iniciales y que ésto no influya en los resultados.

shell> sysbench --test=oltp \
       --mysql-db=test --mysql-user=root --mysql-password=your_passwd \
       cleanup

La entrada Linux benchmark II la puedes leer en Puppet Linux.

Leer más

Linux benchmark I

Hoy vamos a comenzar por una serie de artículos relacionados con los test de estrés a sistemas GNU/Linux. Todos sabemos la importancia de un buen rendimiento de nuestros equipos y mucho mayor la importación de dicho benchmark en servidores. Un servidor al que acceda un número bastante elevado de personas tendrá que tener un buen rendimiento para soportar la carga, en caso contrario los usuarios experimentarán cuelgues o paradas molestas. Dependiendo de para qué vaya a estar destinado el equipo, será mejor idea tener un buen rendimiento en CPU, en I/O, en red, etc.

Hoy para comenzar, vamos a presentar el software sysbench, que permite realizar diferentes tipos de test sobre la máquina para averiguar su rendimiento en cuanto a cálculo, I/O, memoria, etc. sysbench está disponible para prácticamente todos los sistemas, y para sistemas Debian y derivados , la instalación es inmediata desde los repositorios.

shell> apt-get install sysbench

Una vez instalado tendremos ya a nuestra disposición el comando con el que podremos realizar los tests.

Test de CPU

Con este benchmark podremos testear el rendimiento de la CPU de nuestro equipo, obligándole a realizar algunos cálculos que se consideran costosos y mostrándonos el tiempo final. Esto es especialmente útil sobre todo en máquinas virtuales o compartidas, en las que no sabemos el chip que tenemos debajo ni cuanta prioridad nos dio el administrador.

shell> sysbench --test=cpu --num-threads=1 --cpu-max-prime=20000 run
sysbench 0.4.12:  multi-threaded system evaluation benchmark

Running the test with following options:
Number of threads: 1

Doing CPU performance benchmark

Threads started!
Done.

Maximum prime number checked in CPU test: 20000


Test execution summary:
    total time:                          43.9480s
    total number of events:              10000
    total time taken by event execution: 43.9363
    per-request statistics:
         min:                                  4.28ms
         avg:                                  4.39ms
         max:                                  6.55ms
         approx.  95 percentile:               4.48ms

Threads fairness:
    events (avg/stddev):           10000.0000/0.00
    execution time (avg/stddev):   43.9363/0.00

Como podéis observar, se le indica el proceso a ejecutar y también el número de hilos que nos interesa que emplee. Esto nos da un resultado final que es el que tendremos que comparar con una máquina referencia de la que sí conozcamos el chip y el rendimiento que ofrece.

Test de I/O

Este es el otro test importante que se puede evaluar y efectuar con sysbench. Permite evaluar la potencia de I/O de los discos, algo que suele definir el rendimiento final de un equipo, la entrada/salida. Aquí existen muchas opciones que se le pueden pasar para realizar las comprobaciones, pero lo principal es preparar los ficheros con los que se operará. Se recomienda emplear ficheros que dupliquen por lo menos la cantidad de RAM disponible en el sistema. Si esto no es posible, habrá que indicarle que no emplee memoria caché, para evitar obtener resultados no reales.

Pues comenzamos por lo tanto creando el entorno de trabajo (los ficheros).

shell> sysbench --test=fileio --file-total-size=5G prepare

Una vez creados, ya sólo nos queda ejecutar el test y esperar por lo resultados.

shell> sysbench --test=fileio --file-total-size=5G \
       --file-test-mode=rndrw --init-rng=on \
       --max-time=300 --max-requests=0 run
sysbench 0.4.12:  multi-threaded system evaluation benchmark

Running the test with following options:
Number of threads: 1
Initializing random number generator from timer.


Extra file open flags: 0
128 files, 40Mb each
5Gb total file size
Block size 16Kb
Number of random requests for random IO: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 100 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing random r/w test
Threads started!
Time limit exceeded, exiting...
Done.

Operations performed:  29580 Read, 19720 Write, 62984 Other = 112284 Total
Read 462.19Mb Written 308.12Mb Total transferred 770.31Mb (2.5676Mb/sec)
  164.32 Requests/sec executed

Test execution summary:
    total time:                          300.0167s
    total number of events:              49300
    total time taken by event execution: 279.2442
    per-request statistics:
         min:                                  0.01ms
         avg:                                  5.66ms
         max:                                302.36ms
         approx.  95 percentile:              15.31ms

Threads fairness:
    events (avg/stddev):           49300.0000/0.00
    execution time (avg/stddev):   279.2442/0.00

Para finalizar, borramos todo el espacio de disco que hemos ocupado, pues ya tenemos los resultados deseados.

shell> sysbench --test=fileio --file-total-size=5G cleanup

Para más información sobre sysbench, consultar la pagina man.

En breves saldrá la nuevo entrada Linux benchmark II, donde explicaremos el benchmarck a MySQL.

La entrada Linux benchmark I la puede leer en Puppet Linux.

Leer más