guestfs-performance: en línea en la nube

PROGRAMA:

NOMBRE

guestfs-performance: ingeniería de libguestfs para un mayor rendimiento

DESCRIPCIÓN

Esta página documenta cómo obtener el máximo rendimiento de libguestfs, especialmente cuando
espera utilizar libguestfs para manipular miles de máquinas virtuales o imágenes de disco.

Se cubren tres áreas principales. Libguestfs ejecuta un dispositivo (una pequeña distribución de Linux)
dentro de qemu / KVM. Las dos primeras áreas son: minimizar el tiempo necesario para iniciar este
aparato y el número de veces que se debe poner en marcha. La tercera área es
acortando el tiempo necesario para la inspección de las máquinas virtuales.

BASE MEDICIONES

Antes de realizar cambios en la forma en que usa libguestfs, tome medidas de referencia.

Base: Comience a las aparato
En una máquina descargada, mida el tiempo que se tarda en poner en marcha el dispositivo:

time guestfish -a / dev / null ejecutar

Ejecute este comando varias veces seguidas y descarte las primeras ejecuciones, de modo que esté
midiendo un caso típico de "caché caliente".

Explicación

Este comando inicia el dispositivo libguestfs en un disco nulo y luego se cierra inmediatamente
abajo. La primera vez que ejecute el comando, creará un dispositivo y lo almacenará en caché.
(generalmente bajo /var/tmp/.guestfs-*). Las ejecuciones posteriores deberían reutilizar el dispositivo almacenado en caché.

Esperado dE TRATAMIENTOS

Debe esperar obtener tiempos de menos de 6 segundos. Si las veces que ves en un
máquina descargada están por encima de esto, luego consulte la sección "SOLUCIÓN DE PROBLEMAS DE MAL RENDIMIENTO"
abajo.

Base: Realización inspección of a invitado
Para esta prueba, necesitará una máquina descargada y al menos una imagen de disco o invitado real.
Si planea usar libguestfs solo contra X invitados (por ejemplo, X = Windows), entonces use
un invitado X aquí sería lo más apropiado. Si planea ejecutar libguestfs contra
una combinación de invitados, luego use una combinación de invitados para probar aquí.

Mida el tiempo que se tarda en realizar la inspección y montar los discos del invitado. Utilizar el
primer comando si va a utilizar imágenes de disco, y el segundo comando si va a
usando libvirt.

tiempo guestfish --ro -a disk.img -i exit

time guestfish --ro -d GuestName -i salir

Ejecute el comando varias veces seguidas y descarte las primeras ejecuciones, de modo que esté
midiendo un caso típico de "caché caliente".

Explicación

Este comando inicia el dispositivo libguestfs en la imagen de disco nombrada o en el invitado libvirt,
realiza la inspección de libguestfs en él (ver "INSPECCIÓN" en invitados(3)), monta el invitado
discos, luego descarta todos estos resultados y se apaga.

La primera vez que ejecute el comando, creará un dispositivo y lo almacenará en caché (generalmente
bajo /var/tmp/.guestfs-*). Las ejecuciones posteriores deberían reutilizar el dispositivo almacenado en caché.

Esperado dE TRATAMIENTOS

Debe esperar tiempos que sean ≤ 5 segundos mayores que los medidos en la primera línea de base
prueba arriba. (Por ejemplo, si la primera prueba de referencia se ejecutó en 5 segundos, esta prueba
debe ejecutarse en ≤ 10 segundos).

MUNDO NATURAL EL REINO UNIDO APARATO Y CUANDO IT IS CONSTRUIDO / CACHADO

La primera vez que utilice libguestfs, creará y almacenará en caché un dispositivo. Esto suele ser
in /var/tmp/.guestfs-*, a menos que haya establecido $ TMPDIR o $ LIBGUESTFS_CACHEDIR en cuyo caso
estará bajo ese directorio temporal.

Para obtener más información sobre cómo está construido el aparato, consulte "ELECTRODOMÉSTICOS SUPERMIN" en
supermín(1).

Cada vez que se ejecuta libguestfs, verificará que no haya archivos de host utilizados por el dispositivo.
cambió. Si alguno lo ha hecho, entonces se reconstruye el aparato. Esto suele ocurrir cuando un paquete
está instalado o actualizado en el host (por ejemplo, usando programas como "yum" o "apt-get"). los
La razón para reconstruir el dispositivo es la seguridad: el nuevo programa que ha sido
instalado puede contener una solución de seguridad, por lo que queremos incluir el programa fijo en el
aparato automáticamente.

Estas son las implicaciones de rendimiento:

· El proceso de construcción (o reconstrucción) del dispositivo en caché es lento y puede
Evite que esto suceda utilizando un aparato fijo (ver más abajo).

· Si no utiliza un dispositivo fijo, tenga en cuenta que la actualización del software en el host provocará
una reconstrucción única del dispositivo.

· / var / tmp (o $ TMPDIR, $ LIBGUESTFS_CACHEDIR) debe estar en un disco rápido y tener muchos
de espacio para el aparato.

USO A FIJO APARATO

Para controlar completamente cuándo se construye el dispositivo, puede construir un dispositivo fijo. Esta
El dispositivo debe almacenarse en un disco local rápido.

Para construir el dispositivo, ejecute el comando:

libguestfs-make-fixed-appliance

reemplazando " "con el nombre de un directorio donde se almacenará el dispositivo
(normalmente nombraría un subdirectorio, por ejemplo: / usr / local / lib / guestfs / appliance or
/ dev / shm / appliance).

Luego configure $ LIBGUESTFS_PATH (y asegúrese de que esta variable de entorno esté configurada en su libguestfs
program), o modifique su programa para que llame a "guestfs_set_path". Por ejemplo:

exportar LIBGUESTFS_PATH = / usr / local / lib / guestfs / appliance

Ahora puede ejecutar los programas libguestfs, virt tools, guestfish, etc. de forma normal. Los programas
utilizará su dispositivo fijo y nunca creará, reconstruirá ni almacenará en caché su propio
electrodoméstico

(Para obtener información detallada sobre este tema, consulte: libguestfs-hacer-dispositivo-reparado(1)).

Rendimiento of las fijas aparato
En nuestras pruebas, no encontramos que el uso de un aparato fijo proporcionara ninguna
beneficio de rendimiento, incluso cuando el dispositivo estaba ubicado en la memoria (es decir, en / dev / shm).
Sin embargo, hay dos puntos a considerar:

1. El uso de un dispositivo fijo impide que libguestfs reconstruya el dispositivo, lo que significa
que libguestfs tendrá tiempos de inicio más predecibles.

2. El aparato se carga a pedido. Una prueba sencilla como:

time guestfish -a / dev / null ejecutar

no carga mucho del aparato. Un programa libguestfs real que usa complicados
Las llamadas a la API exigirían una mayor carga del dispositivo. Poder almacenar el
dispositivo en una ubicación específica hace que el rendimiento sea más predecible.

REDUCIR EL REINO UNIDO NÚMERO OF DE ENTREGA EL REINO UNIDO APARATO IS LANZADO

Con mucho, la forma más eficaz, aunque no siempre la más sencilla, de obtener un buen rendimiento es
para asegurarse de que el dispositivo se inicie el número mínimo de veces. Esto probablemente
implica cambiar su aplicación libguestfs.

Intente llamar a "guestfs_launch" como máximo una vez por máquina virtual de destino o imagen de disco.

En lugar de utilizar una instancia separada de pez invitado(1) para realizar una serie de cambios en el
mismo invitado, use una sola instancia de guestfish y / o use guestfish --escucha .

Considere escribir su programa como un demonio que mantiene a un invitado abierto mientras crea una serie
de cambios. O organice todas las operaciones que desee realizar antes de abrir el invitado.

También puede intentar agregar discos de varios invitados a un solo dispositivo. Antes de intentar
esto, tenga en cuenta los siguientes puntos:

1. Agregar varios invitados a un dispositivo es un problema de seguridad porque puede permitir que uno
invitado para interferir con los discos de otro invitado. Solo hazlo si confías en todos los
invitados, o si puede agrupar invitados por confianza.

2. Existe un límite estricto para la cantidad de discos que puede agregar a un solo dispositivo. Llama
"guestfs_max_disks" en invitados(3) para obtener este límite. Para obtener más información, consulte
"LÍMITES" en invitados(3).

3. Usar libguestfs de esta manera es complicado. Los discos pueden tener interacciones inesperadas: por
ejemplo, si dos invitados usan el mismo UUID para un sistema de archivos (porque fueron clonados),
o tener grupos de volúmenes con el mismo nombre (pero consulte "guestfs_lvm_set_filter").

virt-df(1) agrega varios discos de forma predeterminada, por lo que el código fuente de este programa sería un
buen lugar para empezar.

ACORTAMIENTO EL REINO UNIDO HORA TOMADO PARA INSPECCIÓN OF VMs

El consejo principal es obvio: no realice una inspección (que es costosa) a menos que necesite
Los resultados.

Si anteriormente realizó una inspección en el invitado, entonces puede ser seguro almacenar en caché y
reutilizar los resultados de la última vez.

Algunos discos no necesitan ser inspeccionados en absoluto: por ejemplo, si está creando un disco
imagen, o si la imagen del disco no es una máquina virtual, o si la imagen del disco tiene un diseño conocido.

Incluso cuando se requiere una inspección básica ("guestfs_inspect_os"), la inspección auxiliar
las operaciones pueden evitarse:

· El montaje de discos solo es necesario para obtener más información sobre el sistema de archivos.

· Listar aplicaciones ("guestfs_inspect_list_applications") es una operación costosa
en Linux, pero casi gratis en Windows.

· Generar un icono de invitado ("guestfs_inspect_get_icon") es barato en Linux pero caro
en Windows.

PARALELA APARATOS

Los dispositivos Libguestfs están en su mayoría vinculados a E / S y puede iniciar varios dispositivos en
paralelo. Siempre que haya suficiente memoria libre, debería haber poca diferencia en
Lanzamiento de 1 dispositivo frente a N dispositivos en paralelo.

En una computadora portátil de 2 núcleos (4 subprocesos) con 16 GB de RAM, utilizando la prueba (no especialmente realista)
Perl script a continuación, el siguiente gráfico muestra una excelente escalabilidad cuando se ejecuta entre 1
y 20 aparatos en paralelo:

12 ++ --- + ---- + ---- + ---- + ----- + ---- + ---- + ---- + ---- + - - ++
+ + + + + + + + + + + *
| |
| * |
11 ++ ++
| |
| |
| * * |
10 ++ ++
| * |
| |
s | |
9 ++ ++
mi | |
| * |
do | |
8 ++ * ++
o | * |
| |
norte 7 ++ ++
| * |
re | * |
| |
6 ++ ++
| * * |
| * |
| |
5 ++ ++
| |
| * |
| * * |
4 ++ ++
| |
| |
+ * * * + + + + + + + +
3 ++ - * - + ---- + ---- + ---- + ----- + ---- + ---- + ---- + ---- + - - ++
0 2 4 XNUM 6 8 10 12 14 16 18
número de aparatos en paralelo

Es posible ejecutar muchos más de 20 dispositivos en paralelo, pero si está utilizando el
libvirt backend, entonces debe tener en cuenta que libvirt limita el número de
conexiones de cliente a 20.

La secuencia de comandos de Perl simple que se muestra a continuación se utilizó para recopilar los datos del gráfico anterior, pero hay
mucha más información sobre este tema, incluidos guiones de prueba y gráficos más avanzados,
disponible en las siguientes publicaciones del blog:

http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-1/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-2/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-3/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-4/

#!/ usr / bin / env perl

uso estricto
usar hilos;
use advertencias;
use Sys :: Guestfs;
use Time :: HiRes qw (tiempo);

subprueba {
my $ g = Sys :: Guestfs-> nuevo;
$ g-> add_drive_ro ("/ dev / null");
$ g-> lanzamiento ();

# Podrías agregar algo de trabajo para libguestfs aquí.

$ g-> cerrar ();
}

# Pon todo en caché.
prueba (); prueba (); prueba ();

para mis $ nr_threads (1..20) {
my $ start_t = hora ();
mis @hilos;
foreach (1 .. $ nr_threads) {
empujar @threads, threads-> crear (\ & prueba)
}
foreach (@hilos) {
$ _-> unirse ();
if (my $ err = $ _-> error ()) {
die "error en el lanzamiento con subprocesos $ nr_threads: $ err"
}
}
my $ end_t = tiempo ();
printf ("% d% .2f \ n", $ nr_threads, $ end_t - $ start_t);
}

USO MODO DE USUARIO LINUX

Desde libguestfs 1.24, ha sido posible utilizar el backend de Linux en modo de usuario (uml)
en lugar de KVM (consulte "BACKEND LINUX EN MODO DE USUARIO" en invitados(3)). Esta sección hace algunos
comentarios generales sobre este backend, pero es altamente aconsejable para medir el tuyo
carga de trabajo bajo UML en lugar de confiar en los comentarios o la intuición.

· UML suele funcionar igual o ligeramente más lento que KVM, en baremetal.

· Sin embargo, UML a menudo tiene el mismo rendimiento en virtualización que en baremetal,
mientras que KVM puede funcionar mucho más lento en virtualización (ya que la aceleración de virtudes del hardware
no está disponible).

· La carga y descarga es hasta 10 veces más lenta en UML que en KVM. Libguestfs envía
estos datos a través del puerto serie emulado UML, que es mucho menos eficiente que KVM
virtio-serie.

· UML carece de algunas características (por ejemplo, compatibilidad con qcow2), por lo que puede que no sea aplicable en absoluto.

Para conocer algunas cifras reales, consulte:
http://rwmj.wordpress.com/2013/08/14/performance-of-user-mode-linux-as-a-libguestfs-backend/# Content

SOLUCIÓN DE PROBLEMAS POBRE ACTUACIÓN

Asegurar hardware virtualización is Hoy Disponibles
Uso / proc / cpuinfo y esta página:

http://virt-tools.org/learning/check-hardware-virt/

para garantizar que la virtualización de hardware esté disponible. Tenga en cuenta que es posible que deba habilitarlo
en su BIOS.

El hardware virt no suele estar disponible dentro de las máquinas virtuales, y libguestfs se ejecutará lentamente en el interior
otra máquina virtual, hagas lo que hagas. La virtualización anidada no funciona bien en nuestro
experiencia, y ciertamente no es un sustituto de ejecutar libguestfs en baremetal.

Asegurar KVM is Hoy Disponibles
Asegúrese de que KVM esté habilitado y disponible para el usuario que ejecutará libguestfs. Debería
asegúrese de establecer 0666 permisos en / dev / kvm y la mayoría de las distribuciones ahora hacen esto.

TÉRMICO a evitar
Evite los procesadores que no tienen virtualización de hardware y algunos procesadores que son
simplemente muy lento (AMD Geode es un gran ejemplo).

Xen dom0
En Xen, dom0 es una máquina virtual, por lo que la virtualización de hardware no está disponible.

DETALLADO Tiempos USO TS

Ingrese al ts(1) comando (de moreutils) para mostrar tiempos detallados:

$ pez invitado -a / dev / null ejecutar -v | & ts -i '% .s'
0.000022 libguestfs: lanzamiento: programa = pez invitado
0.000134 libguestfs: lanzamiento: versión = 1.29.31fedora = 23, lanzamiento = 2.fc23, libvirt
0.000044 libguestfs: lanzamiento: backend registrado: unix
0.000035 libguestfs: lanzamiento: backend registrado: uml
0.000035 libguestfs: lanzamiento: backend registrado: libvirt
0.000032 libguestfs: lanzamiento: backend registrado: directo
0.000030 libguestfs: lanzamiento: backend = libvirt
0.000031 libguestfs: lanzamiento: tmpdir = / tmp / libguestfsw18rBQ
0.000029 libguestfs: lanzamiento: umask = 0002
0.000031 libguestfs: lanzamiento: euid = 1000
0.000030 libguestfs: libvirt versión = 1002012 (1.2.12)
[Etc.]

Las marcas de tiempo son segundos (incrementalmente desde la línea anterior).

DETALLADO Tiempos USO SISTEMATAP

Puede usar SystemTap (golpe(1)) para obtener tiempos detallados de los programas libguestfs.

Guarde el siguiente script como paso.de.tiempo:

último global;

función mostrar_tiempo () {
ahora = gettimeofday_us ();
delta = 0;
si (último> 0)
delta = ahora - último;
último = ahora;

printf ("% d (+% d):", ahora, delta);
}

inicio de la sonda {
último = 0;
printf ("listo \ n");
}

/ * Muestra todas las llamadas a marcadores estáticos. * /
proceso de prueba ("/ Usr / lib* / libguestfs.so.0 ")
.provider ("guestfs"). mark ("*")? {
tiempo de visualización();
printf ("\ t% s% s \ n", $$ nombre, $$ parms);
}

/ * Muestra todas las llamadas a las funciones guestfs_ *. * /
proceso de prueba ("/ Usr / lib* / libguestfs.so.0 ")
.function ("guestfs_ [az] *")? {
tiempo de visualización();
printf ("\ t% s% s \ n", probefunc (), $$ parms);
}

Ejecútelo como root en una ventana:

# paso tiempo.paso
ready

Imprime "listo" cuando SystemTap ha cargado el programa. Ejecute su programa libguestfs,
guestfish o una herramienta virt en otra ventana. Por ejemplo:

$ guestfish -a / dev / null ejecutar

En la ventana de stap verá una gran cantidad de salida, con el tiempo necesario para cada
paso mostrado (microsegundos entre paréntesis). Por ejemplo:

xxxx (+0): invitadofs_create
xxxx (+29): guestfs_set_pgroup g = 0x17a9de0 pgroup = 0x1
xxxx (+9): guestfs_add_drive_opts_argv g = 0x17a9de0 [...]
xxxx (+8): guestfs_int_safe_strdup g=0x17a9de0 str=0x7f8a153bed5d
xxxx (+19): guestfs_int_safe_malloc g = 0x17a9de0 nbytes = 0x38
xxxx (+5): guestfs_int_safe_strdup g=0x17a9de0 str=0x17a9f60
xxxx (+10): guestfs_launch g = 0x17a9de0
xxxx (+4): lanzamiento_inicio
[Etc.]

Deberá consultar, e incluso modificar, la fuente de libguestfs para comprender completamente
La salida.

DETALLADO DEPURACIÓN USO BGF

Puede adjuntarlo al BIOS / kernel del dispositivo mediante gdb. Si sabes lo que estás haciendo
esta puede ser una forma útil de diagnosticar regresiones de arranque.

En primer lugar, debe cambiar qemu para que se ejecute con las opciones "-S" y "-s". Estas opciones
hacer que qemu se detenga en el arranque y le permita adjuntar un depurador. Leer qemu(1) para más
información. Libguestfs invoca qemu varias veces (para escanear la salida de ayuda, etc.)
y solo desea que la invocación final de qemu use estas opciones, así que use un contenedor de qemu
guión como este:

#!/ bin / bash -

# Establezca esto para que apunte al binario qemu real.
qemu = / usr / bin / qemu-kvm

if ["$ 1"! = "-global"]; luego
# Salida de ayuda de escaneo, etc.
exec $ qemu "$ @"
más
# Realmente ejecutando qemu.
exec $ qemu -S -s "$ @"
fi

Ahora ejecute guestfish u otra herramienta libguestfs con el contenedor qemu (vea "QEMU WRAPPERS" en
invitados(3) para entender lo que está haciendo):

LIBGUESTFS_HV = / ruta / a / qemu-wrapper guestfish -a / dev / null -v ejecutar

Esto debería detenerse justo después de que se inicie qemu. En otra ventana, adjunte a qemu usando gdb:

$gdb
(gdb) establecer arquitectura i8086
Se supone que la arquitectura de destino es i8086
(gdb) destino remoto: 1234
Depuración remota usando: 1234
0x0000fff0 en ?? ()
(gdb) continuación

En este punto, puede utilizar técnicas gdb estándar, por ejemplo. presionando "^ C" para interrumpir el arranque
y "bt" obtienen un seguimiento de la pila, estableciendo puntos de interrupción, etc. Tenga en cuenta que cuando haya pasado el
BIOS y en el kernel de Linux, querrá volver a cambiar la arquitectura a 32 o 64
poco.

Utilice guestfs-performance en línea utilizando los servicios de onworks.net