Cómo hacer uso del clúster de supercomputación

 

Registro en el clúster

Para poder hacer uso del clúster de supercomputación del C3UPO, primero es necesario completar los datos de registro en la pestaña Registrarse. La petición será recibida por la Administración del clúster, que posteriormente facilitará al usuario su nombre de usuario y una contraseña temporal de acceso al sistema.

 

Conexión al cluster

Para poder hacer uso del clúster, es necesario acceder mediante SSH al nodo maestro. Trabajando con Linux o MacOs, se puede hacer uso del terminal; en caso de usar Windows, se puede utilizar alguna herramienta como PuTTY o Cygwin.

> ssh usuario@servidor.cluster

El usuario recibirá la dirección del servidor del clúster al darse de alta. Una vez que el acceso se realice correctamente, el usuario se ubicará en su carpeta HOME (/home/usuario) dentro del nodo00. En este nodo no se debe de ejectuar ningún programa; para ello se deben usar el resto de nodos como se detalla a continuación.

 

Uso del clúster

El clúster cuenta con un sistema de colas encargado de repartir las diferentes tareas por los nodos existentes. De este modo, el usuario, a través de comandos, sólo tendrá que lanzar su aplicación y el gestor de cola se encargará de encontrar nodos libres en los que ejecutar los cálculos. En caso de que estén todos ocupados, el gestor de colas se encargará de poner la tarea en espera y de lanzarla cuando haya recursos disponibles, sin necesidad de que el usuario esté conectado esperando.

Para poder hacer un uso responsable del clúster hay que tener una serie de pautas en mente:

  • No se deben instalar aplicaciones en el directorio HOME.
  • No se deben realizar cálculos en el nodo maestro (nodo00).
  • Para hacer cálculos en el clúster, hay que ejecutar el software mediante el gestor de colas.
  • Reservar un número de nodos ajustado a las necesidades reales.
  • Marcar un tiempo de ejecución acorde con los cálculos que se van a llevar a cabo, así se evitará que haya tareas malgastando recursos de forma innecesaria.
  • Cada usuario podrá utilizar un máximo de 120 cores simultáneamente (entre todas las colas).
 

Para intercambiar ficheros entre un equipo y el clúster se pueden usar dos métodos:

  • scp: El comando scp en el terminal (sin estar conectado al clúster) para copiar ficheros entre las máquinas.

#Copiar un archivo local a un destino remoto:
> scp /ruta/archivo-origen usuario@servidor.cluster:/ruta/directorio-destino/

#Copiar un archivo de un ordenador remoto al ordenador local:
> scp usuario@servidor.cluster:/ruta/archivo-origen /ruta/directorio-destino

 

  • Cliente SFTP: Como Filezilla, por ejemplo. Para ello, se debe descargar la aplicación en el equipo y usar las credenciales de acceso al clúster. A través de la aplicación, se podrá navegar por la carpeta HOME e intercambiar ficheros entre el quipo y el clúster.

 

 

Uso del sistema de colas

A continuación se van a detallar algunos de los comandos más utiles para gestionar correctamente tareas en el cluster. En cualquier caso, se puede obtener más información sobre los comandos existentes en el manual de SLURM.

  • Para ejecutar tareas en el clúster hay principalmente tres métodos:

    1. Usar el comando srun.

    Con el comando srun se pueden ejecutar tareas en paralelo. Se pueden especificar, entre otras cosas, en qué cola queremos añadir nuestro trabajo (p), cuántas veces se necesita que se ejecute la tarea (n) y en cuántos nodos (N). Además, también podemos darle un nombre al trabajo para poder localizarlo posteriormente con mayor facilidad (J).

    > srun -n2 -N2 -p day -J user_task_run --label hostname

    2. Usar el comando salloc.

    Con el comando salloc se reserva un espacio en un conjunto de nodos y, una vez hecha la reserva, se ejecutan los comandos necesarios. Es importante tener en cuenta que para poder hacer un uso correcto del clúster y aprovechar los recursos, hay que ejecutar los comandos haciendo uso de srun. Una vez que se hayan llevado a cabo las tareas, hay que liberar los recursos reservados con el comando exit o no serán liberados hasta salir del terminal. Al igual que con el comando srun, se puede especificar en qué cola queremos lanzar nuestro trabajo (p), cuántos nodos queremos reservar (N), en cuántos hilos queremos que se divida la tarea (n) y el nombre que se le quiere dar (J). Una vez hemos reservado el espacio podemos lanzar srun con los comandos que necesitemos, sin necesidad de volver a especificar los valores.

    > salloc -n2 -N2 -p day -J user_task_salloc -t=10
    > srun --label hostname
    > exit

    3. Usar el comando sbatch.

    Con el comando sbatch se envía a la cola un fichero batch. Por defecto, tanto la salida del fichero como la salida con los errores serán almacenadas en un fichero llamado slurm-x.out donde "x" es el ID de la tarea asignada por el gestor de cola; dicho fichero se almacenará en el directorio de trabajo actual. Esto puede ser modificado a través de los parámetros -e para especificar dónde se quieren almacenar los errores y -o para indicar dónde se quiere almacenar la salida. Además, se pueden utilizar en el nombre del fichero las variables %A, que será reemplezada con el ID de la tarea, y %a, que será sustituida por el índice del array.
    En el fichero batch debe ir la información sobre la cola en la que se van a ejecutar los cálculos (p), en cuántos nodos (N), así como en cuántos hilos como máximo se puede dividir el trabajo (n). También se le puede dar un nombre a la tarea (J).

    Se va a comenzar con un ejemplo de un programa que se va a ejecutar en un solo nodo y va a hacer uso de un solo core.

    Contenido del fichero programa.sh:
     

    #Este programa va a llamar a un script que se va a ejecutar en un solo nodo y utilizará un solo core:
    #!/bin/bash
    #SBATCH -o /home/user/outputs/programa_output_%A.out
    #SBATCH -e /home/user/errors/programa_error_%A.out
    #SBATCH -p day
    #SBATCH -N 1
    #SBATCH -n 1
    #SBATCH -w nodo40
    #SBATCH -J analisis_ejemplo

    > sbatch programa.sh

     

    • #!/bin/bash: Esta línea indica a Linux qué Shell va a ser utilizada, en este caso será bash.
      Por lo tanto, esta línea siempre se mantendrá así.
    • #SBATCH -J analisis_ejemplo: Esta línea indica al gestor de colas el nombre que va a recibir
      nuestro job
    • #SBATCH -p day: Esta línea indica la partición que vamos a utilizar para ejecutar nuestro
      trabajo
    • #SBATCH -N 1: Le indica al gestor de colas cuántos nodos va a utilizar el job
    • #SBATCH -n 1: Le indica al gestor de colas cuántos cores o núcleos va a utilizar el job
    • #SBATCH -o /home/user/outputs/programa_output_%A.out: le indica al gestor de colas en
      qué directorio se generan los archivos del flujo de salida estándar del job
    • #SBATCH -e /home/user/errors/programa_error_%A.out: le indica al gestor de colas donde
      queremos almacenar los errores.
    • #SBATCH -w nodo40 : Nos permite reservar un nodo concreto

     

    A continuación se muestra un ejemplo de un programa que se ejecuta en un solo nodo pero que hace uso de varios cores: proceso multicore. Para este ejemplo se va a utilizar blastp, que se puede ejecutar en multicore y que tiene como curiosidad que, además de especificar en el el script el número de hilos en los que se dividirá el trabajo (n), hay que especificarlo en el comando (num_threads). En caso de que no se especifique este valor en el comando, se reservarán un número determinado de cores (n) que no serán utilizados; por lo que es importante recordar que sólo hay que reservar más de un core en caso de que el programa que vamos a ejecutar soporte multicore. También es importante recordar que hay programas, como por ejemplo blastp, que no pueden ser ejecutados en más de un nodo al mismo tiempo, por lo que si se especifica un N mayor que 1 se estarán reservando más nodos de los que se usarán, por lo que quedarán ociosos.

    Contenido del fichero programa.sh:
     
    #En este programa se va a hacer uso de un solo nodo pero se van a usar varios cores:
    #!/bin/bash
    #SBATCH -p day
    #SBATCH -N 1
    #SBATCH -n 6
    #SBATCH -J user_task_sbatch
    blastp -query /home/username/data.fasta -db /mnt/beegfs/DB/uniref/Uniref50/2017_8/uniref50.fasta -num_threads 6


    > sbatch programa.sh

    Es importante tener en mente el parámetro --array, el cual sirve para ejecutar el mismo trabajo múltiples veces. Para poder ejecutar el comando sbatch con este parámetro hay que especificar los índices del array, ya sea a través de una lista o especificando un rango. Este parámetro también soporta el separador %X, con el cual se especifica que como máximo puede haber X iteraciones ejecutándose al mismo tiempo (este parámetro es opcional). Para poder hacer un uso completo de este parámetro es muy útil la variable SLURM_ARRAY_TASK_ID, la cual indica la iteración actual del programa. Como se ve en el siguiente ejemplo, esta variable puede servir para indicar al programa de una forma dinámica los parámetros de entrada que debe tomar a la hora de la ejecución. Es importante asegurarse de que existen los ficheros de entrada con el nombre de los índices que se especifican.

    Contenido del fichero programa.sh:
     
    #En este programa se va a hacer uso de un solo nodo, se van a usar varios cores y además se van a ejecutar varias iteraciones del mismo programa:
    #!/bin/bash
    #SBATCH -o /home/user/outputs/programa_output_%A_%a.out
    #SBATCH -e /home/user/errors/programa_error_%A_%a.out
    #SBATCH -p day
    #SBATCH -N 1
    #SBATCH -n 6
    #SBATCH -J user_task_sbatch
    #SBATCH --array=1-60%15
    blastp -query /home/username/data_$SLURM_ARRAY_TASK_ID.fasta -db /mnt/beegfs/DB/uniref/Uniref50/2017_8/uniref50.fasta -num_threads 6


    > sbatch programa.sh

    Nota: Si va a ejecutar una tarea prolongada en el tiempo, es una buena práctica incluir en el fichero programa.sh algunos "puntos de depuración" para saber en qué estado se encuentra la ejecución.

    ...
    # Se imprime el ID del trabajo que se está ejecutando; siguiendo el ejemplo anterior irá de 1 a 16.
    echo "Mi trabajo ID: " $SLURM_ARRAY_TASK_ID
    ...
    echo "Paso 1 Iniciado" >> my_program_status.txt
    ...
    echo "Paso 1 Finalizado" >> my_program_status.txt
    ...

     
  • Para detener una tarea se puede usar el comando scancel. Este comando nos permite terminar trabajos de diferentes maneras. Si se ha especificado un nombre a la tarea, se puede cancelar usando el nombre asignado; en otro caso, habrá que indicar el identificador de la tarea.

    #Para cancelar una tarea por su nombre:
    > scancel -n user_task_sbatch

    #Cancela el trabajo con ID 1234:
    > scancel 1234
  • A través de squeue se puede conocer el estado actual de las tareas que se están ejecutando en el clúster. También permite visualizar solamente las tareas que pertenecen a un usuario en concreto (u) o las de una partición en particular (p).

    #Muestra las tareas en la partición day del usuario nombre:
    > squeue -p day -u nombre

    #Muestra información de las tareas especificadas:
    > squeue --name user_task_run,user_task_run2

 

 

Uso del cluster Hadoop para trabajos Big Data

 

La incorporación de los nuevos nodos (cc y cr)  permiten la creación de un clúster Hadoop basado en Magpie. Se encuentra compuesto por un NameNode, que controla la asignación de recursos, y varios DataNodes, que realizan el almacenamiento de datos real y procesamiento.

Magpie proporciona una forma de integrar Hadoop y Spark en infraestructuras de HPC y HCT. Contiene una serie de scripts para ejecutar software de Big Data en entornos HPC, creando un clúster Hadoop / Spark temporal en varios nodos en el contexto de un trabajo por lotes o grupos (batch)

Al finalizar el trabajo, el clúster se destruye, quedando los jobs slots utilizados disponibles para otras cargas de trabajo. Además, Magpie permite ejecutar trabajos de forma interactiva o vía scripts

Por tanto, los pasos que se llevarán a cabo serán los siguientes:

  • El script batch de Magpie reserva los nodos del clúster utilizando el gestor de colas de Slurm 

  • Este script genera los archivos de configuración para el proyecto seleccionado (Hadoop / Spark …). En ellos se identifica al nodo rank 0 como nodo maestro. Todos los nodos de cómputo tendrán archivos de configuración creados que apuntan al nodo designado como nodo maestro

  • Posteriormente se inician los servicios o demonios en todos los nodos. El nodo rank 0 ejecutará los demonios de Hadoop NameNode. El resto de nodos, Hadoop DataNodes

  • En este momento ya disponemos de un clúster de Big Data anidado ejecutándose en el clúster HPC sobre el que podremos interactuar como si de un clúster dedicado se tratase

  • Cuando se complete el trabajo o se agote el tiempo de asignación, Magpie limpiará el entorno de Big Data creado deteniendo y eliminando los demonios o servicios previamente creados

 

El software de Hadoop y Magpie está instalado y disponible en todos los nodos del cluster HPC en la ruta /apps/bigdata:

 

[acorreal@nodo00 ~]$ cd /apps/bigdata/
[acorreal@nodo00 bigdata]$ ls -l
total 12
drwxr-xr-x 9 root root 139 sep 10 2019 hadoop-3.2.1
drwxr-xr-x 12 root root 4096 may 22 06:54 magpie-master
drwxr-xr-x 9 root root 4096 jul 31 2017 OpenJDK-1.8.0.141-x86_64-bin
drwxrwxr-x 7 root root 83 ene 10 2022 scala-2.13.8
drwxr-xr-x 13 root root 4096 ene 20 2022 spark-3.2.1-bin-hadoop3.2

 

[acorreal@nodo00 script-sbatch-srun]$ pwd
/apps/bigdata/magpie-master/submission-scripts/script-sbatch-srun
[acorreal@nodo00 script-sbatch-srun]$ ls -l
total 604
-rw-r--r-- 1 root root 80367 jul 10 16:13 magpie.sbatch-srun
-rw-r--r-- 1 root root 19206 jul 10 16:13 magpie.sbatch-srun-alluxio
-rw-r--r-- 1 root root 32686 jul 10 16:13 magpie.sbatch-srun-hadoop
-rw-r--r-- 1 root root 41043 jul 10 16:13 magpie.sbatch-srun-hadoop-and-hive
-rw-r--r-- 1 root root 35731 jul 10 16:13 magpie.sbatch-srun-hadoop-and-pig
-rw-r--r-- 1 root root 41618 jul 10 16:13 magpie.sbatch-srun-hbase-with-hdfs
-rw-r--r-- 1 root root 44771 jul 10 16:13 magpie.sbatch-srun-hbase-with-hdfs-with-phoenix
-rw-r--r-- 1 root root 13912 jul 10 16:13 magpie.sbatch-srun-ray
-rw-r--r-- 1 root root 27083 jul 10 16:13 magpie.sbatch-srun-spark
-rw-r--r-- 1 root root 33146 jul 10 16:13 magpie.sbatch-srun-spark-with-alluxio
-rw-r--r-- 1 root root 46639 jul 10 16:13 magpie.sbatch-srun-spark-with-hdfs
-rw-r--r-- 1 root root 46731 jul 10 16:13 magpie.sbatch-srun-spark-with-yarn
-rw-r--r-- 1 root root 46749 jul 10 16:13 magpie.sbatch-srun-spark-with-yarn-and-hdfs
-rw-r--r-- 1 root root 30682 jul 10 16:13 magpie.sbatch-srun-spark-with-zeppelin
-rw-r--r-- 1 root root 20336 jul 10 16:13 magpie.sbatch-srun-storm
-rw-r--r-- 1 root root 11223 jul 10 16:13 magpie.sbatch-srun-tensorflow
-rw-r--r-- 1 root root 14114 jul 10 16:13 magpie.sbatch-srun-tensorflow-horovod
 
 
  • Accedemos vía ssh a uno de los nodos de cálculo: ssh cc01
  • Creamos nuestro directorio en /tmp/nombre_usuario
  • Creamos en los nodos de cálculo directorios para guardar configuración, logs y scratch:

 

[acorreal@cr01 acorreal]$ pwd
/tmp/acorreal
[acorreal@cr01 acorreal]$ ls -l
total 16
drwxrwxr-x 3 acorreal acorreal 4096 Jul 12 16:06 hadoop
drwxr-xr-x 2 acorreal acorreal 4096 Jul 11 15:03 hdfs
drwxrwxr-x 4 acorreal acorreal 4096 Jul 12 12:28 magpie
drwxrwxr-x 4 acorreal acorreal 4096 Jul 12 12:23 spark

 

[acorreal@cr01 acorreal]$ pwd
/mnt/beegfs-nvme/acorreal
[acorreal@cr01 acorreal]$ ls -l
total 1
drwxrwxr-x 10 acorreal acorreal 10 Jul 12 17:16 hdfsovernetworkfs
drwxrwxr-x 3 acorreal acorreal 1 Jul 12 12:23 sparkscratch

 

  • Spark

 

Generamos el fichero de configuración /home/acorreal/magpie/spark_magpie a partir de /apps/bigdata/magpie-master/submission-scripts/script-sbatch-srun/magpie.sbatch-srun-spark para lanzar un trabajo en Spark desde Magpie

Modificamos en el script la partición que va a utilizarse, en este caso la partición bd (requería permisos para poder hacer uso de la misma) así como los parámetros necesarios en nuestro job

# Partition to launch job in
#SBATCH --partition=bd

 

Actualmente sólo funciona correctamente solicitar nodos completos, por lo que se recomienda no modificar ese valor. El solicitar menos de un nodo completo provoca la creación de un DataNode por core en cada nodo, causando una importante penalización de rendimiento

 

#SBATCH –ntasks-per-node=1
#SBATCH --exclusive
#SBATCH --no-kill

 

Podremos ejecutar nuestro job de forma interactiva (obteniendo los resultados de nuestro job por pantalla) o mediante script. Para ello, sería necesario modificar la siguiente línea en nuestro script “interactive”/”script”) 

 

acorreal@nodo00 magpie]$ cat spark_magpie | grep MAGPIE_JOB_TYPE
export MAGPIE_JOB_TYPE="interactive"

 

 Lanzamos el job con el siguiente comando:

 

[acorreal@nodo00 magpie]$ sbatch -s -k spark_magpie

 

Una vez que el trabajo ha terminado:

1. Para finalizar la prueba, destruimos el entorno de Spark creado. Para ello en primer lugar abrimos el fichero .out de nuestro job

 

[acorreal@nodo00 magpie]$ ls -l
total 2196
-rwxrwxr-x 1 acorreal acorreal 198 oct 27 12:26 env-hadoop.sh
-rwxrwxr-x 1 acorreal acorreal 206 oct 27 11:20 env-spark.sh
-rw-rw-r-- 1 acorreal acorreal 45971 oct 28 11:13 hadoop-23042311.out
-rw-rw-r-- 1 acorreal acorreal 34700 oct 28 11:24 hadoop-23042312.out
-rwxr-xr-x 1 acorreal acorreal 949 jul 10 18:10 hadoop-example-job-script
-rw-r--r-- 1 acorreal acorreal 32755 jul 12 16:05 hadoop_magpie
-rw-r--r-- 1 acorreal acorreal 32753 oct 27 12:01 hadoop_magpie_script
-rw-r--r-- 1 acorreal acorreal 32753 oct 27 12:14 hadoop_magpie_terasort
-rw-r--r-- 1 acorreal acorreal 316534 oct 27 15:46 hadoop-mapreduce-examples-3.2.1.jar
-rw-rw-r-- 1 acorreal acorreal 2053 oct 28 11:14 hadoop_minimal
-rw-r--r-- 1 acorreal acorreal 2411 oct 27 12:56 JavaBisectingKMeansExample.java
drwxrwxr-x 2 acorreal acorreal 82 oct 27 08:35 out
-rw-rw-r-- 1 acorreal acorreal 43973 oct 28 10:45 spark-23042308.out
-rw-rw-r-- 1 acorreal acorreal 8188 oct 28 10:52 spark-23042309.out
-rwxr-xr-x 1 acorreal acorreal 970 jul 10 17:24 spark-example-job-script
-rw-r--r-- 1 acorreal acorreal 27168 jul 18 09:55 spark_magpie
-rw-r--r-- 1 acorreal acorreal 27166 oct 27 09:17 spark_magpie_interactive
-rw-r--r-- 1 acorreal acorreal 27161 oct 27 10:13 spark_magpie_script
-rw-rw-r-- 1 acorreal acorreal 1701 oct 28 10:47 spark_minimal
-rw-rw-r-- 1 acorreal acorreal 1573044 oct 27 15:41 texto_hadoop.txt
[acorreal@nodo00 magpie]$ tail spark-23042308.out

 

2. Al final de nuestro fichero encontraremos el comando necesario para destruir el entorno

            ssh cc01 kill -s 10 255273

 

3. Después ejecutamos el siguiente comando para finalizar el proceso

      ps -fea | grep spark

 

  • Hadoop

Generamos el fichero de configuración /home/nombre_usuario/magpie/hadoop_magpie a partir de /apps/bigdata/magpie-master/submission-scripts/script-sbatch-srun/magpie.sbatch-srun-hadoop para lanzar un trabajo en Hadoop desde Magpie

Modificamos nuestro script en función de las especificaciones que deseemos y lo lanzamos con la siguiente línea:

[acorreal@nodo00 magpie]$ sbatch -s -k hadoop_magpie

 

Cuando finalice nuestro job, será necesario destruir el entorno como se explicó anteriormente con Spark. En el caso de Hadop, además es necesario purgar parte de HDFS antes de lanzar nuevos trabajos Hadoop, con el fin de evitar posibles errores

cd /mnt/beegfs-nvme/nombre_usuario/hdfsovernetworksfs

 

Para ello, eliminamos los archivos mediante rm -rf

Es importante tener en cuenta que Magpie sólo proporciona un sistema de archivos HDFS transitorio, por lo que los datos deben copiarse cada vez que se inicie un trabajo de Hadoop, lo que reduce la eficiencia del trabajo

 

Uso de software

Todos los usuarios tienen acceso al software instalado en el clúster a través de la herramienta Environment Modules. Cada software se instala como módulo independiente, así como sus dependencias, y los usuarios pueden seleccionar en cada momento qué herramientas necesitan utilizar. Las dependencias se cargan automáticamente, facilitando esta tarea al usuario.

  • Comando esenciales para el uso de Modules:

#Mostrar todos los módulos (software) disponibles.
> module avail

#Cargar un módulo en concreto.
> module load módulo

#Mostrar los módulos actualmente cargados por el usuario.
> module list

#Salir de un módulo cargado.
> module unload módulo

#Salir de todos los módulos cargados y limpiar.
> module purge

 

Cuando haya disponible más de una versión del mismo software, será necesario especificar cuál se quiere cargar, salvo que haya una configurada por defecto. Siempre es de ayuda poder autocompletar gracias a la tecla de tabulación.

Todos estos comandos se pueden utilizar a través del terminal o en los scripts de Slurm para lanzar trabajos a la cola del clúster.

  • Instalación de software

Cuando un usuario necesite hacer uso de una herramienta que no esté actualmente instalada, podrá solicitar su instalación contactando con la Administración del clúster.

  • Software instalado
  • Anaconda
  • BioPerl
  • Cufflinks
  • GROMACS
  • HISAT2
  • HTSeq
  • LAMMPS
  • MultiQC
  • prokka
  • QIIME2
  • roary
  • RSeQC
  • sma3s -> incluye BLAST y BLAST+ y configura las siguientes variables de entorno:
    • $SMA3S -> ruta al fichero sma3s.pl a través del directorio /mnt/beegfs/uniprot/sma3s
    • $UNIPROT -> ruta al directorio /mnt/beegfs/uniprot/uniprot
    • $UNIREF -> ruta al directorio /mnt/beegfs/uniprot/uniref
  • SRA-Toolkit
  • STAR
  • StringTie
  • TopHat
  • Trinity

Nota: Si necesita una solución personalizada, no dude en contactar con nosotros a través de la dirección c3upo_admin@upo.es