Redes Privadas Virtuales

El Jueves 29 de Octubre de 2009 fue liberada la versión 9.10 de Ubuntu/Kubuntu, más conocida como Karmic Koala.



Entre sus principales novedades podemos citar las siguientes:

• Kernel 2.6.31.
• KDE 4.3.2.
• Compilador gcc 4.4.
• Sistema de archivos ext4 por defecto.
• GRUB2 como nuevo gestor de arranque.
• Nuevos plasmoides (Microblogging, Google Calendar, Facebook, conector de imágenes a Flickr y otros sitios de fotos, etc.).
• Edición especial para notebooks.

Una de las cosas que llama la atención al arrancar Kubuntu 9.10 es la reducción del tiempo de carga del sistema operativo. Para Kubuntu 8.04 teníamos los siguientes tiempos:

• Arranque: 15 sg
• Apagado: 12 sg

Y ahora para Kubuntu 9.10:

• Arranque: 12 sg
• Apagado: 12 sg

Otra de las características a destacar es la integración de KDE4 con OpenOffice, con lo que todas las aplicaciones de esta suite se mostrarán con el tema de por defecto de KDE4, Oxígeno, aparte de poder utilizar los cuadros de diálogo de abrir y guardar documentos de KDE.


Ayatana ha sido integrado con el propio escritorio. De esta forma todas las notificaciones generadas por las aplicaciones aparecen de forma nativa en la barra de tareas.


Kubuntu 9.10 también incluye la última versión de KPackageKit, el cual ofrece nuevas notificaciones, historial y mayor eficacia debido a la correción de errores.


El popular grabador de CDs/DVDs también ha sido portado a KDE4.


El plasmoide KNetworkManager ha sido notablemente mejorado, ganando en robustez e incorporando nuevas funcionalidades adicionales.


Por otra parte, QtCurve aporta un refinamiento a las aplicaciones GNOME, otorgándolas una apariencia más acorde con KDE. Esta integración con GTK+ puede ser configurada ahora desde KDE.


Y por último, también destacaría el nuevo sistema de navegación para las Preferencias del sistema.

A lo largo de varios artículos se van a analizar distintas arquitecturas de almacenamiento compartido en red, con el objetivo de evaluar sus rendimientos en base a distintos tipos de operaciones: lectura, escritura, latencias, creación de ficheros, búsquedas, etc. Para ello se utilizarán varias herramientas de benchmarking que se tienen en Linux para tal fin: cp, IOZone y Bonnie++.

Un sistema de almacenamiento compartido es una arquitectura formada por un área de datos a la que podrán acceder de manera concurrente múltiples procesos, teniendo en cuenta que dicho espacio deberá estar correctamente protegido por alguna clase de mecanismo que arbitre su acceso, todo ello con el objetivo de evitar posibles casos de corrupción de datos.

La forma tradicional de acceso compartido suele diseñarse en base a un sistema de ficheros ext3 exportado a través de un servicio NFS. Ext3 no es un sistema de archivos válido para compartir datos, ya que no está diseñado para arbitrar bloqueos entre accesos, y en consecuencia, se podrían dar situaciones de corrupción de datos en caso de que varias máquinas montasen paralelamente el mismo sistema de archivos.

Por lo tanto lo que se hace es exportar dicho sistema a través de NFS, el cual sí que proporciona control de acceso, permitiendo de esta forma que varios nodos puedan acceder concurrentemente al mismo área de almacenamiento sin ningún tipo de problema.

Otra de las alternativas pasa por la utilización de sistemas de ficheros (GFS, OCFS, etc.) especialmente diseñados para que varias máquinas puedan acceder simultáneamente a ellos, y sea el propio sistema de archivos el que ofrezca los mecanismos necesarios para arbitrar las operaciones de entrada/salida.

Esta clase de sistemas de archivos podrá exportarse mediante NFS, o bien a través de otras clases de tecnologías (GNBD, iSCSI, etc.) que permitan exportar los dispositivos de bloque directamente en crudo, sin necesidad de tener que montar previamente un sistema de ficheros.

Los sistemas de almacenamiento compartido en red que van a ser analizados en los próximos artículos con el objetivo de evaluar su rendimiento serán los siguientes:

• GFS2 + GNBD
• GFS2 + iSCSI
• GFS2 + NFS
• ext3 + NFS

Básicamente se utilizarán dos sistemas de archivos distintos, GFS2 y ext3, los cuales serán accedidos a través de diferentes tecnologías (GNBD, iSCSI y NFS), todas ellas empleando redes TCP/IP de tipo Ethernet.


El espacio de almacenamiento compartido residirá en el nodo centos01, el cual será el encargado de exportarlo a los otros dos nodos restantes que conforman el sistema de almacenamiento en red: centos02 y centos03.

GFS2 (Global File System 2) es un sistema de ficheros nativo creado por Red Hat y distribuido bajo licencia GNU, que puede ser utilizado de forma local (como por ejemplo ext3) o en cluster, de manera que varios nodos puedan estar trabajando simultáneamente sobre él sin peligro a que se corrompan los datos. El tamaño máximo de almacenamiento soportado es de 8 EB.

Ext3 (third EXtended Filesystem) es un sistema de ficheros basado en journaling, en donde se emplean registros temporales o journals antes de realizar el grabado de los datos en los bloques, todo ello con el objetivo de asegurar la integridad de la información. El tamaño máximo de almacenamiento que soporta ext3 es de 32 TB.

GNBD (Global Network Block Device) proporciona acceso a almacenamiento de bloques sobre una red Ethernet. GNBD es una solución totalmente software que permite compartir de forma directa un dispositivo de bloque a través de una LAN.

iSCSI (Internet Small Computer Systems Interface) permite la interconexión directa entre dispositivos de almacenamiento y computadores, encapsulando para ello el protocolo SCSI (familia de protocolos para comunicaciones con dispositivos de entrada/salida, especialmente dispositivos de almacenamiento) a través de una red TCP/IP. iSCSI puede utilizar tarjetas hardware dedicadas o emplear iniciadores iSCSI junto con targets (objetivos) SCSI para establecer la conectividad a través de tarjetas Ethernet.

NFS (Network File System) es un protocolo perteneciente al nivel de aplicación utilizado para crear sistemas de ficheros distribuidos, el cual permite que varios nodos puedan acceder de forma simultánea a distintos archivos remotos. Todas las operaciones de escritura son síncronas, es decir, la tarea se da por finalizada cuando realmente se ha terminado de escribir el último byte.

Los tres nodos empleados se corresponderán con sendas máquinas virtualizadas a través de una VMware ESX Server 3.5. El sistema operativo de cada uno de los equipos será una distribución Linux de tipo CentOS, concretamente la versión estable 5.3 de 64 bits.

Las características hardware asignadas a cada máquina virtual serán las mismas para todas ellas, pudiéndose observar en la siguiente tabla:


El nodo centos01 contará con un disco duro adicional de 64 GB sobre el cual se realizarán las pruebas de rendimiento, y estará compartido para las máquinas centos02 y centos03 a través de una red TCP/IP.

Y ya por último, decir también que todas las áreas de almacenamiento de los tres sistemas residirán en la misma LUN (Logical Unit Number), estando ésta ubicada en un datastore de NetApp (conjunto de discos duros externos accedidos a través de fibra óptica).

Ya se encuentra disponible en los repositorios de CentOS su nueva versión 5.4.

CentOS (Community ENTerprise Operating System) es una distribución de Linux que viene a ser un clon binario de RHEL (Red Hat Enterprise Linux), compilada y generada a partir del código fuente que Red Hat libera, y destinada principalmente al ámbito empresarial o corporativo, ya que es un sistema operativo especialmente diseñado para realizar tareas de servidor.


Entre las principales novedades de CentOS 5.4 cabe destacar las siguientes:

• El kernel continúa siendo el mismo (2.6.18), pero se ha incluido soporte para el sistema de ficheros ext4.
• Soporte oficial para KVM como tecnología de virtualización (se mantiene el soporte a XEN hasta el año 2014).
• Actualización del soporte ofrecido a HBAs (Host Bus Adapter), tarjetas de red y chipsets.
• Soporte para FCoE (Fiber Channel over Ethernet).
• Nuevos drivers para tarjetas de red que funcionan a 10 Gb.
• Activación del parámetro GRO (Generic Receive Offload) en los paquetes TCP/IP, con el objetivo de aumentar el rendimiento de las comunicaciones sobre redes de alta velocidad.
• Actualización del compilador gcc a la versión 4.4.
• CIFS clusterizado. La actualización a la versión 3.3 de Samba configurado junto con GFS2, permite implementar un cluster activo-activo de nodos de almacenamiento basados en el protocolo CIFS.
• FUSE. El módulo de FUSE (Filesystem in Userspace) incluido en el sistema posibilita a los usuarios el montaje de sistemas de archivos basados en esta clase de tecnología (GlusterFS, SSHFS, GmailFS, etc.).
• KDE 3.5.4 y GNOME 2.16.

Para actualizar desde una versión de CentOS 5.3 a una 5.4, tendríamos que ejecutar los siguientes comandos:

[root@centos ~]# yum -y upgrade --skip-broken

[root@centos ~]# yum -y update

Al finalizar el proceso de actualización, sólo nos que quedará reiniciar el sistema.

Unlocker es una de esas herramientas que cuando te ves obligado a trabajar con sistemas Windows, te puede salvar la vida.

Puede darse el caso de que un momento dado tengamos la necesidad de leer, modificar o borrar un determinado archivo, y también puede ocurrir que ese archivo esté bloqueado.

Un virus por ejemplo ha podido infectar una DLL del sistema y al tratar de borrarla, Windows nos lo impide por tratarse de una librería del sistema operativo. O por ejemplo que una cierta aplicación tenga bloqueado un fichero y nosotros no podamos editarlo debido a que lo tiene abierto.

Para situaciones de este tipo podemos recurrir a una herramienta cuya misión es la de desbloquear dicho archivo bloqueado y darle el control al usuario: Unlocker.

Cuando se instala Unlocker en Windows, éste se integra con el propio explorador, de tal forma que si hacemos clic con el botón derecho del ratón sobre un archivo, tendremos a nuestra disposición un nuevo comando denominado Unlocker, el cual tendrá la finalidad de desbloquear dicho archivo en caso de que éste se encontrara bloqueado.


Además Unlocker da la posibilidad de realizar una serie de acciones adicional en el objeto sobre el que ha sido ejecutado: Eliminar, Renombrar y Mover.

En esta segunda parte del artículo Almacenamiento compartido en red: ext3 + NFS, vamos a ver cómo securizar la infraestructura con TCP wrappers e iptables.

TCP wrappers

Para securizar el servidor centos01 con TCP wrappers, vamos a habilitar los servicios portmap (demonio de asignación de puertos dinámicos) y mountd (demonio encargado de la gestión de volúmenes NFS) para el rango de direcciones IP de los nodos centos02 y centos03.

[root@centos01 ~]# cat /etc/hosts.deny
ALL: ALL

[root@centos01 ~]# cat /etc/hosts.allow
sshd: ALL
portmap: 192.168.1.
mountd: 192.168.1.

Para que el servicio NFS pueda ser posteriormente protegido por iptables, tendremos que añadir los siguientes puertos al fichero /etc/sysconfig/nfs.

[root@centos01 ~]# cat /etc/sysconfig/nfs
...
MOUNTD_PORT="4002"
STATD_PORT="4003"
LOCKD_TCPPORT="4004"
LOCKD_UDPPORT="4004"
RQUOTAD_PORT="4005"

Iptables

Los puertos que hay que abrir en iptables son los utilizados por el servicio NFS (Network File System, 111 TCP y UDP, 2049 TCP y UDP, 4002:4005 TCP y UDP).

A continuación se muestra el contenido del fichero de configuración de iptables para el nodo centos01.

[root@centos01 ~]# cat /etc/sysconfig/iptables
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
:RH-Firewall-1-INPUT - [0:0]
-A INPUT -j RH-Firewall-1-INPUT
-A FORWARD -j RH-Firewall-1-INPUT
-A RH-Firewall-1-INPUT -i lo -j ACCEPT
-A RH-Firewall-1-INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
-A RH-Firewall-1-INPUT -p tcp --dport ssh -j ACCEPT
-A RH-Firewall-1-INPUT -p icmp -j ACCEPT
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -p tcp --dport 111 -j ACCEPT
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -p udp --dport 111 -j ACCEPT
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -p tcp --dport 2049 -j ACCEPT
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -p udp --dport 2049 -j ACCEPT
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -p tcp --dport 4002:4005 -j ACCEPT
-A RH-Firewall-1-INPUT -s 192.168.1.0/24 -p udp --dport 4002:4005 -j ACCEPT
-A RH-Firewall-1-INPUT -j LOG
-A RH-Firewall-1-INPUT -j REJECT
COMMIT

[root@centos01 ~]# service iptables restart

[root@centos01 ~]# chkconfig iptables on

En el presente artículo vamos a desarrollar una arquitectura de almacenamiento compartido a la que accederán de forma concurrente un par de máquinas. Las pruebas van a ser realizadas bajo un sistema operativo de tipo CentOS 5.3.

El área de datos sobre el que se configurará el acceso compartido será un volumen lógico (LogVol00) cuyo sistema de archivos será ext3.

Ext3 es un sistema de ficheros basado en journaling, en donde se emplean registros temporales o journals antes de realizar el grabado de los datos en los bloques, todo ello con el objetivo de asegurar la integridad de la información. El tamaño máximo de almacenamiento que soporta ext3 es de 32 TB.

En la figura siguiente puede observarse que el espacio de almacenamiento compartido se instalará sobre la máquina centos01, el cual será exportado a los nodos centos02 y centos03 a través de NFS4 (Network File System v4).


NFS es un protocolo perteneciente al nivel de aplicación utilizado para sistemas de ficheros distribuidos, que permite que varios nodos puedan acceder de forma simultánea a distintos archivos remotos. Todas las operaciones de escritura son síncronas, es decir, la tarea se da por finalizada cuando realmente se ha terminado de escribir el último byte.

Cada una de las máquinas deberá tener registrado los nombres de todos los nodos en el fichero /etc/hosts.

[... ~]# cat /etc/hosts
...
192.168.1.11    centos01 centos01.local
192.168.1.12    centos02 centos02.local
192.168.1.13    centos03 centos03.local

Iptables y TCP wrappers deberán estar desactivados en el nodo centos01; SELinux podrá estar activado. Al final del artículo veremos la forma de configurarlos correctamente para que no interfieran en el sistema de almacenamiento.

[root@centos01 ~]# service iptables stop

[root@centos01 ~]# cat /etc/hosts.deny
...
#ALL: ALL

[root@centos01 ~]# getenforce
Enforcing

En los nodos centos02 y centos03 estos tres mecanismos de seguridad podrán estar activados:

[... ~]# getenforce
Enforcing

[... ~]# cat /etc/hosts.deny
...
ALL: ALL

[... ~]# iptables -nL
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
RH-Firewall-1-INPUT  all  --  0.0.0.0/0            0.0.0.0/0

Chain FORWARD (policy ACCEPT)
target     prot opt source               destination
RH-Firewall-1-INPUT  all  --  0.0.0.0/0            0.0.0.0/0

Chain OUTPUT (policy ACCEPT)
target     prot opt source               destination

Chain RH-Firewall-1-INPUT (2 references)
target     prot opt source               destination
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0
ACCEPT     all  --  0.0.0.0/0            0.0.0.0/0           state RELATED,ESTABLISHED
ACCEPT     tcp  --  0.0.0.0/0            0.0.0.0/0           tcp dpt:22
ACCEPT     icmp --  0.0.0.0/0            0.0.0.0/0
LOG        all  --  0.0.0.0/0            0.0.0.0/0           LOG flags 0 level 4
REJECT     all  --  0.0.0.0/0            0.0.0.0/0           reject-with icmp-port-unreachable

Lo primero que vamos a hacer es crear el volumen lógico que se empleará como espacio compartido en centos01, empleando para ello una partición de 64 GB que ya tendremos creada previamente y etiquetada como Linux.

[root@centos01 ~]# fdisk -l
...
Disposit. Inicio    Comienzo      Fin      Bloques  Id  Sistema
/dev/sdb1               1        8354    67103473+  83  Linux

Primero habrá que crear un volumen físico sobre esa partición, después el grupo de volúmenes (VolGroup01) y por último el volumen lógico (LogVol00).

[root@centos01 ~]# pvcreate /dev/sdb1

[root@centos01 ~]# vgcreate VolGroup01 /dev/sdb1

[root@centos01 ~]# lvcreate -l 100%FREE -n LogVol00 VolGroup01

Una vez que ya se tiene creado el volumen lógico, crearemos dentro de él un sistema de archivos ext3.

[root@centos01 ~]# mkfs.ext3 /dev/VolGroup01/LogVol00

Una vez que se tiene el sistema de archivos construido, crearemos un directorio sobre el cual montarlo, con el objetivo de poder exportarlo posteriormente. A su vez en los nodos centos02 y centos03 también crearemos el mismo directorio en el cual montaremos el volumen NFS importado.

[root@centos01 ~]# mkdir /mnt/ext3_nfs

[root@centos02 ~]# mkdir /mnt/ext3_nfs

[root@centos03 ~]# mkdir /mnt/ext3_nfs

Para montar el volumen en el directorio creado dentro del nodo centos01, ejecutaremos el siguiente comando:

[root@centos01 ~]# mount /dev/VolGroup01/LogVol00 /mnt/ext3_nfs/

Para que este cambio se quede de forma permanente tras sucesivos reinicios de la máquina, habrá que añadir una entrada al fichero /etc/fstab.

[root@centos01 ~]# cat /etc/fstab
...
/dev/VolGroup01/LogVol00        /mnt/ext3_nfs   ext3    defaults        0 0

El siguiente paso consistirá en exportar el directorio a través de NFS. Para ello editaremos el fichero /etc/exports, reiniciaremos el servicio nfs y haremos que el demonio se inicie automáticamente durante el arranque del nodo. También tendremos que asignar permisos de escritura para el resto de usuarios al directorio exportado.

[root@centos01 ~]# cat /etc/exports
/mnt/ext3_nfs   centos02.local(rw,sync,root_squash,fsid=0)
/mnt/ext3_nfs   centos03.local(rw,sync,root_squash,fsid=0)

[root@centos01 ~]# service nfs restart

[root@centos01 ~]# chkconfig nfs on

[root@centos01 ~]# chmod -R o+w /mnt/ext3_nfs/

Las opciones de exportación empleadas para NFS han sido rw (permitir la lectura y escritura), sync (escrituras síncronas) , root_squash (root accederá como usuario anónimo - nobody) y fsid=0 (habilitar NFSv4).

Si en este momento ejecutamos la siguiente orden en los nodo centos02 o centos03, obtendremos la lista de directorios exportados por centos01.

[root@centos02 ~]# showmount -e centos01.local
Export list for centos01.local:
/mnt/ext3_nfs centos03,centos02

Para montar a través de NFS dicho directorio, ejecutaremos el siguiente comando en los nodos centos02 y centos03.

[... ~]# mount -t nfs4 centos01.local:/ /mnt/ext3_nfs/

Para que los nodos puedan importar automáticamente dicho directorio durante el arranque, tendremos que añadir a sus ficheros /etc/fstab el siguiente contenido:

[... ~]# cat /etc/fstab
...
centos01.local:/        /mnt/ext3_nfs           nfs4    defaults        0 0

En el presente artículo vamos a analizar distintas herramientas que se tienen en Linux para hacer pruebas de rendimiento sobre un sistema de almacenamiento.

Esta clase de aplicaciones pueden llegar a ser muy interesantes cuando se quiere medir el rendimiento o alcance de un determinado sistema de archivos (ext4, ext3, NTFS, GFS, etc.) o una clase concreta de acceso a datos (NFS, GNBD, iSCSI, etc.), obteniendo información como la velocidad de escritura, lectura, latencias, etc.

Por ejemplo, se puede tener la necesidad de montar un espacio de almacenamiento en red al que accedan concurrentemente múltiples servidores, y en una primera etapa de evaluación se planteen dos posibles escenarios: acceso mediante NFS a un sistema de ficheros ext3 o GFS2.

cp

Comando utilizado para copiar archivos desde un origen a un destino. La siguiente orden lo que hará será medir el tiempo empleado en escribir un determinado fichero de XXXX · YYYY bytes en disco (directorio /tmp).

# dd if=/dev/zero of=file bs=XXXX count=YYYY && time cp file /mnt/tmp

Una forma habitual de uso del comando cp puede ser por ejemplo transferir el directorio /etc (122 MB, 1999 archivos) o /lib (207 MB, 3746 archivos). De esta forma se consigue el copiado de múltiples ficheros de diferentes tamaños, los cuales se encuentran ubicados en distintos subdirectorios.

dd

Permite el copiado de datos bit a bit independientemente del sistema de ficheros origen y destino. Como información de salida ofrece la velocidad de lectura/escritura con la que se ha realizado la operación, así como el tiempo empleado.

El formato que utilizaremos para el comando dd será el siguiente:

• Lectura de XXXX · YYYY bytes desde el disco /dev/sda al dispositivo /dev/null.
  

  # dd if=/dev/sda of=/dev/null bs=XXXX count=YYYY
  

• Escritura de XXXX · YYYY bytes desde el dispositivo origen /dev/zero al fichero /tmp/output.
  

  # dd if=/dev/zero of=/tmp/output bs=XXXX count=YYYY
  

El dispositivo /dev/null descarta toda la información volcada en él de forma instantánea. De esta forma, al aplicar el primer comando el tiempo de cómputo se invertirá exclusivamente en la lectura de datos.

Decir que /dev/zero es un dispositivo especial que cuando se lee de él proporciona caracteres NULL, es decir, su tiempo de lectura es prácticamente nulo. De esta forma, al aplicar el segundo comando el tiempo de cómputo se invertirá exclusivamente en la escritura de datos.

Una forma habitual de uso de dd es por ejemplo leer y escribir un fichero superior a la memoria RAM total (por ejemplo 5 GB en caso de disponer de 4 GB de memoria RAM). Esa transferencia se realizará seis veces, tanto en lectura (R) como en escritura (W). Se irá variando los valores de XXXX e YYYY de tal forma que su multiplicación dé 5 GB. De esta forma mediremos la tasa de transferencia y el tiempo empleado.

bs (bytes)  count  velocidad-R (MB/sg)  tiempo-R (sg)   velocidad-W (MB/sg)  tiempo-W (sg)
65536       78125
131072      39062
262144      19531
524288      9765
1048576     4882
2097152     2441

Con bs igual a 65536 se emplearán registros de 64 KB para hacer las transferencias.

IOzone

IOzone es una herramienta de benchmark destinada a comprobar el rendimiento de un sistema de archivos. La aplicación genera y mide una gran cantidad de operaciones sobre ficheros. La forma de ejecutar IOzone es la siguiente:

# iozone [options] > logfile

IOzone dispone de distintas opciones para poder pasar por la línea de órdenes; a continuación vamos a exponer las más interesantes de cara a medir el rendimiento de un sistema de archivos:

• -a: modo automático completo.
• -b excel_file: genera un archivo en formato Excel con los resultados obtenidos (formato binario).
• -c: incluye en los resultados los tiempos empleados para cerrar los ficheros.
• -f filename: especifica el archivo temporal que se empleará para los tests.
• -g size: tamaño máximo del archivo (Ej. -g 2G, igual o superior al tamaño de la memoria RAM) para el modo auto (-a).
• -i test: especifica el tipo de test a utilizar (0: escritura/re-escritura, 1: lectura/re-lectura, 2: lectura/escritura aleatoria, ...).
• -l num: número mínimo de procesos.
• -r size: tamaño fijo del registro utilizado para hacer las transferencias.
• -s size: tamaño fijo del archivo utilizado para hacer las transferencias.
• -u num: número máximo de procesos.
• -z: esta opción utilizada junto con el parámetro -a, fuerza a IOzone a emplear archivos pequeños durante las pruebas.
• -F filename1 filename2 ...: especifica los archivos temporales que se emplearán para los tests.
• -R: genera un informe Excel.
• -U mountpoint: punto de montaje a desmontar y montar durante el transcurso de los tests.

Las distintas definiciones de los tests son las siguientes:

• Escritura: mide el rendimiento de escritura secuencial en un nuevo archivo.
• Re-escritura: mide el rendimiento de escritura secuencial sobre un archivo que ya existe.
• Lectura: mide el rendimiento de lectura secuencial sobre un archivo existente.
• Re-lectura: mide el rendimiento de lectura secuencial sobre un archivo que ha sido recientemente leído.
• Escritura aleatoria: mide el rendimiento de escritura aleatoria en un nuevo archivo.
• Lectura aleatoria: mide el rendimiento de lectura aleatoria sobre un archivo ya existente.

Una forma habitual de uso de IOzone puede ser la siguiente:

# iozone -Razc -i 0 -i 1 -g 4G -f /mnt/tmp/file -b fichero.xls

La orden anterior ejecuta un test de lectura/escritura secuencial, variando los tamaños de los ficheros empleados desde 64 KB a 4 GB, utilizando buffers de transferencia comprendidos entre 4 KB y 16 MB. Como resultado final se generará un fichero Excel a partir del cual podremos crear las correspondientes gráficas.

Esto último es lo que se conoce como barrido de un determinado espectro de almacenamiento, y tiene como principal objetivo el de poder generar una gráfica de superficie que determine el comportamiento del sistema ante variaciones de los registros y ficheros empleados.

Para este caso le hemos indicado a iozone que utilice el fichero file, el cual deberá encontrarse sobre el sistema de archivos que queremos comprobar, siendo en este caso /mnt/tmp.

En esta clase de pruebas es conveniente utilizar un tamaño de fichero máximo (parámetro -g) superior a la memoria RAM disponible. De esta forma se podrá obtener el comportamiento de la máquina cuando utiliza la memoria cache del procesador (tamaño del archivo inferior a la cache del procesador), cuando emplea la memoria RAM (tamaño del archivo comprendido entre la cache del procesador y la cantidad total de memoria RAM) o cuando hace uso directamente de las operaciones de entrada/salida a disco (tamaño del archivo superior a la memoria RAM).

Otra forma habitual de empleo de IOzone está destinada a medir el impacto de diferente número de procesos sobre dicho sistema de archivos. Por ejemplo, la orden siguiente hará que varios procesos (desde 1 a 50) vayan realizando operaciones de lectura/escritura secuencial de un fichero de 4 MB, utilizando para ello registros de 64 KB.

[... tmp]# iozone -Rc -r 64 -s 4MB -l 1 -u 50 -i 0 -i 1 -b /root/fichero.xls

A diferencia del caso anterior, esta vez nos hemos situado sobre el directorio a testear (sistema de archivos), ya que de esta forma cada uno de los procesos que lance IOzone irá creando su fichero temporal correspondiente. Otra alternativa hubiera sido no ubicarse en dicho directorio y a través de la opción -F indicar los diferentes ficheros a utilizar, uno por cada proceso implicado, es decir, en nuestro caso hasta un total de 50 ficheros deberían haberse definido con la opción -F.

El ejemplo anterior se suele utilizar para obtener el comportamiento de múltiples procesos del sistema manejando archivos pequeños. Para completar las pruebas de IOzone es conveniente repetir este test pero utilizando archivos más grandes (y aumentando a su vez el tamaño de los registros).

[... tmp]# iozone -Rc -r 1024 -s 512MB -l 1 -u 12 -i 0 -i 1 -b /root/fichero.xls

Bonnie++

Bonnie++ es un programa utilizado para comprobar el rendimiento de discos duros y sistemas de archivos. Bonnie++ permite la creación de distintos tests de lectura, escritura y borrado de archivos de diversos tamaños, etc. Bonnie++ tiene muchos parámetros que pueden ser empleados, pero la forma en la que lo utilizaremos para medir el rendimiento de un sistema de ficheros será la siguiente:

# bonnie++ -d /tmp [-n number:max:min:num-directories] [-s size] -u 0

A través de la opción -d se especifica el directorio a utilizar durante el transcurso de las pruebas. El parámetro number es el número de archivos que serán creados multiplicado por 1024, el cual vendrá precedido de la opción -n. Si se especifican los valores max y min, los archivos serán creados con un tamaño aleatorio comprendido entre esas dos cotas (bytes). Y si de declara el parámetro directories, los archivos serán distribuidos uniformemente a través de una estructura de directorios con una profundidad máxima marcada por el parámetro directories.

Con la opción -s se indica a través del valor size, el tamaño del archivo que será utilizado para las pruebas de lectura y escritura. Este tamaño debe ser como mínimo el doble de la memoria RAM. Y con la opción -u 0 se indica a Bonnie++ que ejecute las pruebas como usuario root.

Los resultados mostrados por Bonnie++ ofrecen velocidades de escritura secuencial (Sequential Output) y lectura secuencial (Sequential Input). También ofrecen valores sobre la creación secuencial (Sequential Create) y aleatoria (Random Create) de ficheros, así como de borrado secuencial (Sequential Delete) y aleatorio (Random Delete) de ficheros.

Bonnie++ trae consigo una herramienta que nos permite generar un fichero en formato HTML (bon_csv2html) a partir de los resultados obtenidos (última línea de datos). Para ello deberemos ejecutar la siguiente secuencia de órdenes:

# echo "última_línea_de_datos"  bon_csv2html > fichero.html

Una forma habitual de uso de Bonnie++ puede ser la siguiente:

# bonnie++ -n 128 -s 7544 -x 1 -u 0 -d /mnt/tmp/

La orden anterior ejecuta una sola vez (-x 1), un test de lectura y escritura de un archivo de 7,5 GB, así como la tarea de creación y borrado de 131072 ficheros (128x1024) de 0 bytes.

Por último, decir que es importante limpiar los datos cacheados en la memoria RAM al terminar cada una de las pruebas.