Implementación de referencia del equilibrio de carga del servidor en un entorno virtualizado

El autor recientemente realizó una demostración relacionada con la virtualización, que involucraba el equilibrio de carga del servidor en un entorno virtualizado. Usamos un caso simple donde la migración en vivo ocurre cuando la carga está "desequilibrada". Como solo es una demostración, nuestra carga solo considera temporalmente la utilización de la CPU. En la preparación real, debido a la falta de presión del cliente, es difícil lograr un control preciso de la utilización de la CPU. Aquí hay un programa de script simple, a través de un ajuste adaptativo, para lograr la utilización de la CPU del servidor dentro de un cierto rango, a fin de garantizar que cuando la CPU del servidor sea demasiado alta, la máquina virtual se migrará automáticamente a Las pruebas se realizaron en otras máquinas con bajo uso de CPU.

La secuencia de comandos implementada por Python es la siguiente. Esta secuencia de comandos requiere la introducción de 5 parámetros numéricos, respectivamente:

Utilización mínima de la CPU, utilización máxima de la CPU, cuenta inicial de subprocesos, subproceso para cada ajuste Cantidad, el tiempo que duerme cada hilo (milisegundos)

Por supuesto, en gran medida, estos parámetros son altamente empíricos debido a los diferentes entornos de hardware.

 #! /usr /bin /python 
 tiempo de importación de subprocesos de importación 
 cadena de importación de importación 
 import sys clase ControlThread (threading.Thread): 
 def __init __ (self): threading.Thread .__ init __ (self) 
 self.runflag = Verdadero #Thread indicador de ejecución, utilizado para finalizar def run (self) al reducir hilos en el futuro: 
 while self.runflag: os.popen ('usleep 'sys.argv [5]) 
 # time.sleep (string.atof (sys.argv [5])) # Este es el uso de la cáscara bajo Linux, no la función sleep que viene con python. 
 # En contraste, el tiempo de inactividad es bastante potente y el de Python en segundos. Aunque puede ingresar números de punto flotante, 
 sigue siendo relativamente débil def stop (self): 
 self.runflag = Falso # Deje que termine el bucle normalmente 
 threadList = [] print 'Start Thread Number:' sys.argv [3] '\\ tSleep Time (ms):' sys.argv [5] 
 #Inicializar una cierta cantidad El subproceso, a partir de cero, puede tardar mucho tiempo en alcanzar el rango especificado para i en el rango (0, string.atoi (sys.argv [3])): 
 thread = ControlThread () threadList.append ( Hilo) 
 thread.start () # Use sar aquí para capturar la utilización de la CPU, que se refiere a la utilización total de la CPU. Luego haga un ajuste adaptativo comparando 
 mientras que Verdadero: output = 100 - string.atof (os.popen ('sar 1 1 |
  Grep ^ Promedio |
  Awk \\ '
 {print $ 8} \\' '). Read ()) 
 print' CPU Usage: 'str (output)' \\ tCurrent Thread Number: 'str (len (threadList)) si output < String.atoi (sys.argv [1]): # Agregar hilo 
 para i en el rango (0, string.atoi (sys.argv [4])): thread = ControlThread () 
 thread.start ( threadList.append (thread) 
 imprime "" si la salida > string.atoi (sys.argv [2]): # reduce thread 
 para i en el rango (0, string.atoi (sys.argv [ ,null,null,3],4])): thread = threadList.pop () 
 thread.stop () print "-----" 
 
 
 
 En general, esta secuencia de comandos es relativamente simple. Y en diferentes máquinas, se requiere la experiencia del operador para inicializarse para lograr los mejores resultados. Pero este es mi primer programa de Python, y ha logrado el propósito deseado. Lo anterior es solo el código central que puede ejecutarse. En cuanto al uso, manejo de errores, salida del programa, etc., no está disponible :)