Para nosotros, los ingenieros de redes, el mundo de la codificación, las habilidades de desarrollador y la programabilidad se están convirtiendo en algo imprescindible. Nadie concibe ya una red en la que el administrador o los ingenieros, el NOC o quienquiera que realice las tareas cotidianas en ella no tenga conocimientos de codificación, no sepa codificar o automatice tareas.

Así que, llegados a este punto, todos deberíamos tener al menos conocimientos básicos de Python. Y podemos asumir con seguridad que todos hemos hecho algunos scripts para automatizar tareas. Si estas tareas involucran múltiples dispositivos, entonces usualmente implementamos bucles donde recorremos la lista de dispositivos que queremos automatizar y la lista de comandos que queremos ejecutar, y los ejecutamos, secuencialmente.

Si bien es cierto que esto funciona, implica un lento proceso de iteración en el que tenemos que terminar con uno de los dispositivos y luego pasar al siguiente, y así sucesivamente. Como todos imaginamos, hacer esto uno a uno tiene algunos inconvenientes. Tenemos que terminar con un dispositivo antes de pasar al siguiente, lo que lo hace lento. Tenemos que depurar condiciones de fallo para que en caso de fallo en una de las iteraciones, siga funcionando con la siguiente. Y algunas más, pero la más crítica es el tiempo. Cuantos más dispositivos tengamos en nuestro bucle, más tiempo tardará en completarse todo el script.

¿Hemos pensado ya en el multithreading?

Pues es la solución. Vamos a disparar la secuencia de comandos que queremos ejecutar en cada dispositivo, en más de un dispositivo a la vez. Eso dividirá el tiempo total de ejecución, y con suerte estaremos sorbiendo café antes de que se nos ocurra.

Abajo tienes un script de ejemplo que ejecuta 3 hilos a la vez en tu ordenador. Cada hilo no hace nada destacable en realidad, pero como hilo es perfecto para el ejemplo. Cada hilo registrará la hora de inicio y fin, y entre medias dormirá durante 2 segundos. Tiempo suficiente para verlo funcionando. Como vemos hemos utilizado la librería concurrent.futures para lanzar los hilos llamando a ThreadPoolExecutor y mapeando la función thread. El resto es bastante fácil de entender.

Ahí lo tenéis:

import logging  
 import time  
 import concurrent.futures  
 def thread_function(name):  
 logging.info("Thread %s: START", name)  
 time.sleep(2)  
 logging.info("Thread %s: FINISH", name)  
 if __name__ == "__main__":  
 format = "%(asctime)s: %(message)s"  
 logging.basicConfig(format=format, level=logging.INFO, datefmt="%H:%M:%S")  
 with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:  
 executor.map(thread_function, range(3))

threads.py

Y aquí tenemos el resultado:

user@deb:~$ python3 threads.py
 13:01:05: Thread 0: starting  
 13:01:05: Thread 1: starting  
 13:01:05: Thread 2: starting  
 13:01:07: Thread 0: finishing  
 13:01:07: Thread 2: finishing  
 13:01:07: Thread 1: finishing

output

Eso es todo. Ahora usted tiene la forma más fácil que conozco para desencadenar hilos y ejecutar tareas simultáneamente. ¡Espero que te ayude a ahorrar ese valioso tiempo!