📑 Contenido

Introducción
Recursos del Cluster
Almacenamiento
Acceso y Solicitud de Cuenta
Entorno de Software
SLURM y Gestión de Trabajos
Paralelismo
Aplicaciones Gráficas (ThinLinc)
Entornos Virtuales de Python
JupyterHub
Transferencia de Archivos
Monitoreo de Trabajos y Recursos
Job Arrays
Casos de Uso en Astrofísica
Soporte y Comunidad
Reconocimientos

🛰️ Introducción

El cluster Ragnar es una infraestructura de cómputo de alto rendimiento (HPC) desarrollada por el Instituto de Astrofísica de la Universidad Andrés Bello. Está diseñado para facilitar simulaciones, análisis de datos y proyectos complejos en astronomía y física, especialmente para estudiantes, investigadores y colaboradores.

💻 Recursos del Cluster

Nodos de cómputo:

6 nodos dedicados a simulaciones y análisis.
Total de 136 núcleos de CPU.
1.28 TB de memoria RAM.

Nodo	Núcleos	Memoria (GB)
ragnar01–02	28	128
ragnar03–06	20	256

Sistema operativo: CentOS (migración a Rocky Linux en curso)
Gestor de recursos: SLURM

📂 Almacenamiento

/mnt/nfs1: espacio compartido, con respaldo diario. Ideal para código y scripts.
/scratch: almacenamiento local de alto rendimiento. No se respalda y se purga regularmente.

Recomendaciones:

Guarde resultados importantes en /mnt/nfs1.
Use /scratch para datos temporales.
Elimine archivos innecesarios para evitar eliminación automática.

🔐 Acceso y Solicitud de Cuenta

Requisitos del formulario:

Nombre, correo institucional, RUT/pasaporte, universidad y facultad.
Detalles técnicos del proyecto.
Software necesario y necesidades de almacenamiento.
Aceptación de políticas de uso.

Conexión vía SSH:

ssh usuario@172.20.1.138

🧰 Entorno de Software

Lenguajes disponibles: Python, Julia, MATLAB, R
Software astronómico: Astropy, IRAF, DS9, SExtractor
Visualización: ParaView, Matplotlib, Gnuplot
Utilidades: MPI, Git, CUDA, CMake

Se utiliza Lmod para cargar módulos de software y EasyBuild para su instalación reproducible.

Comandos útiles:

ml av                     # Ver módulos disponibles
ml spider python          # Buscar módulo
ml Python/3.11.3          # Cargar módulo
ml unload Python/3.11.3   # Descargar módulo
ml purge                  # Descargar todos los módulos

📋 SLURM y Gestión de Trabajos

SLURM organiza y gestiona los recursos del cluster. La partición por defecto es LocalQ.

Script de ejemplo: 1 tarea, 20 núcleos

#!/bin/bash
#SBATCH --job-name=python20
#SBATCH --partition=LocalQ
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=20
#SBATCH --mem=100G
#SBATCH --time=08:00:00
#SBATCH --output=python20_%j.out

module load python/3.11.3
srun python my_script.py

Comandos frecuentes:

sinfo                 # Ver estado de nodos
squeue                # Ver trabajos en cola
sbatch script.sh      # Enviar trabajo por lote
srun --pty bash       # Sesión interactiva
scancel <jobid>       # Cancelar trabajo
sacct                 # Consultar trabajos finalizados

🧬 Paralelismo

El cluster soporta tres tipos de paralelismo:

MPI: múltiples procesos independientes (paralelismo entre nodos).
OpenMP: hilos en un único proceso (paralelismo dentro del nodo).
Híbrido: combinación de MPI + OpenMP.

Ejemplo híbrido:

sbatch --ntasks=4 --cpus-per-task=7 --mem=48G --time=2:00:00 script.sh

🖥️ Aplicaciones Gráficas (ThinLinc)

ThinLinc permite el uso de aplicaciones gráficas como DS9 o TOPCAT desde el cluster, sin necesidad de transferir archivos.

Ventajas:

Visualización remota de grandes volúmenes de datos.
Sesiones persistentes.
Acceso a interfaz gráfica desde cualquier computador.

Importante: no ejecutar simulaciones pesadas en ThinLinc; solo usar SLURM para eso.

🐍 Entornos Virtuales de Python (venv)

Para trabajar con Python en el cluster Ragnar es recomendable crear un entorno virtual (venv), lo que permite instalar paquetes propios sin afectar el sistema ni a otros usuarios.

Antes de crear o activar un entorno virtual, siempre debe cargar el módulo de Python:

ml Python/3.11.5-GCCcore-13.2.0

1. Crear un entorno virtual

Ejecute el siguiente comando desde el directorio donde desea crear el entorno (se recomienda /mnt/nfs1 para persistencia):

python -m venv ~/mi_entorno

2. Activar el entorno

source ~/mi_entorno/bin/activate

Al activarlo, el prompt cambiará mostrando el nombre del entorno, por ejemplo: (mi_entorno) usuario@ragnar:~$

3. Instalar paquetes

Con el entorno activo, instale paquetes usando pip:

pip install numpy scipy astropy matplotlib

Para instalar desde un archivo de dependencias:

pip install -r requirements.txt

4. Usar el entorno en un script SLURM

Incluya la carga del módulo y la activación del entorno en su script de trabajo:

#!/bin/bash
#SBATCH --job-name=mi_job
#SBATCH --partition=LocalQ
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --mem=32G
#SBATCH --time=04:00:00
#SBATCH --output=mi_job_%j.out

ml Python/3.11.5-GCCcore-13.2.0
source ~/mi_entorno/bin/activate

srun python mi_script.py

5. Desactivar el entorno

Cuando termine su sesión interactiva, desactive el entorno con:

deactivate

6. Listar paquetes instalados

pip list
pip freeze > requirements.txt   # exportar lista de paquetes

⚠️ Guarde su entorno virtual en /mnt/nfs1, nunca en /scratch, ya que ese directorio se purga regularmente.

Resumen de comandos

ml Python/3.11.5-GCCcore-13.2.0        # cargar módulo
python -m venv ~/mi_entorno            # crear entorno
source ~/mi_entorno/bin/activate       # activar entorno
pip install <paquete>                  # instalar paquete
pip list                               # ver paquetes instalados
deactivate                             # desactivar entorno

📓 JupyterHub

El cluster Ragnar cuenta con un servidor JupyterHub que permite trabajar con notebooks de forma interactiva directamente desde el navegador, sin necesidad de instalar nada en su equipo local. Los notebooks se ejecutan sobre nodos del cluster a través de SLURM, con distintos perfiles de recursos disponibles.

Paso 1: Preparar el entorno de Python

Conéctese al cluster vía SSH y ejecute los siguientes comandos para crear un entorno virtual dedicado a JupyterHub:

ml Python/3.11.5-GCCcore-13.2.0
python -m venv ~/envs/jupyter
source ~/envs/jupyter/bin/activate
pip install jupyterlab jupyter_server batchspawner jupyterhub

💡 Este paso solo debe realizarse una vez. Una vez creado el entorno, no es necesario repetirlo en sesiones futuras.

Paso 2: Configurar el entorno de inicio

Ejecute el siguiente comando para crear el archivo de configuración que JupyterHub usará al lanzar sus sesiones:

cat > ~/.jupyter_env << 'EOF'
source $HOME/envs/jupyter/bin/activate
export PATH=$HOME/envs/jupyter/bin:$PATH
EOF

💡 Este archivo también debe crearse una sola vez. Indica al sistema dónde encontrar su entorno de Python al iniciar un notebook.

Paso 3: Acceder a JupyterHub

Abra su navegador e ingrese a la siguiente dirección:

http://172.20.1.138:8000/

Inicie sesión con sus credenciales del cluster. Una vez dentro, deberá seleccionar un perfil de recursos según las necesidades de su trabajo:

Perfil	Núcleos	Memoria	Tiempo máximo
LocalQ – Small	1	4 GB	8 hrs
LocalQ – Medium	4	16 GB	8 hrs
LocalQ – Large	8	32 GB	8 hrs
LocalQ – Large Memory	20	120 GB	8 hrs
GPU – NVIDIA RTX 3060 (gn001)	4	16 GB	4 hrs

⚠️ Seleccione el perfil más pequeño que sea suficiente para su tarea. Usar perfiles grandes innecesariamente bloquea recursos para otros usuarios.

Instalar paquetes adicionales en el notebook

Puede instalar paquetes directamente desde una celda del notebook usando:

!pip install numpy astropy matplotlib

📦 Transferencia de Archivos

Para copiar datos hacia o desde el cluster se pueden usar tres herramientas: scp, rsync y sftp. Todos los comandos se ejecutan desde su computador local, no desde el cluster.

SCP — copia simple de archivos

scp funciona de manera similar a cp, pero entre equipos remotos.

Copiar un archivo local al cluster:

scp archivo.txt usuario@172.20.1.138:/mnt/nfs1/usuario/

Copiar un archivo desde el cluster a su equipo:

scp usuario@172.20.1.138:/mnt/nfs1/usuario/resultado.txt ./

Copiar una carpeta completa (opción -r):

scp -r mi_carpeta/ usuario@172.20.1.138:/mnt/nfs1/usuario/

RSYNC — sincronización eficiente

rsync es más eficiente que scp para transferencias grandes o repetidas, ya que solo copia los archivos que han cambiado.

Sincronizar carpeta local hacia el cluster:

rsync -avz mi_carpeta/ usuario@172.20.1.138:/mnt/nfs1/usuario/mi_carpeta/

Sincronizar carpeta desde el cluster a su equipo:

rsync -avz usuario@172.20.1.138:/mnt/nfs1/usuario/resultados/ ./resultados/

Opciones más usadas:

-a: modo archivo, preserva permisos y fechas.
-v: muestra el progreso en pantalla.
-z: comprime los datos durante la transferencia.
--progress: muestra el avance archivo por archivo.
--delete: elimina en destino los archivos que ya no existen en origen.

💡 Se recomienda usar rsync para transferencias de grandes volúmenes de datos o cuando se repite la misma transferencia varias veces.

SFTP — transferencia interactiva

sftp abre una sesión interactiva para navegar y transferir archivos, similar a un cliente FTP tradicional.

Conectarse al cluster:

sftp usuario@172.20.1.138

Comandos dentro de la sesión SFTP:

ls                        # listar archivos remotos
lls                       # listar archivos locales
cd /mnt/nfs1/usuario/     # cambiar directorio remoto
lcd ~/Descargas/          # cambiar directorio local
get resultado.txt         # descargar archivo al equipo local
put script.py             # subir archivo al cluster
get -r resultados/        # descargar carpeta completa
bye                       # cerrar sesión

💡 También puede usar clientes gráficos compatibles con SFTP como FileZilla o Cyberduck, ingresando 172.20.1.138 como servidor y sus credenciales de acceso.

📊 Monitoreo de Trabajos y Recursos

SLURM ofrece varias herramientas para monitorear el estado de los trabajos en ejecución y analizar la eficiencia de los trabajos terminados.

Ver trabajos en cola y en ejecución

squeue                        # todos los trabajos del cluster
squeue -u usuario             # solo sus trabajos
squeue -u usuario --format="%.10i %.9P %.20j %.8T %.10M %.5C %.10m"  # formato detallado

Los estados más comunes son:

PD (Pending): en espera de recursos.
R (Running): en ejecución.
CG (Completing): finalizando.
F (Failed): terminó con error.

Detalles de un trabajo específico

scontrol show job <jobid>     # información completa del trabajo

Eficiencia de trabajos terminados con seff

seff muestra un resumen de cuánta CPU y memoria realmente usó un trabajo, útil para ajustar futuros envíos:

seff <jobid>

Ejemplo de salida:

Job ID: 12345
Cores per node: 20
CPU Utilized: 02:45:00
CPU Efficiency: 87.50% of 03:08:20 core-walltime
Memory Utilized: 18.20 GB
Memory Efficiency: 91.00% of 20.00 GB

💡 Una eficiencia de CPU o memoria por debajo del 50% indica que está solicitando más recursos de los necesarios. Ajustar estos valores libera recursos para otros usuarios.

Historial de trabajos con sacct

sacct                                                              # trabajos recientes
sacct -u usuario                                                   # sus trabajos
sacct -j <jobid> --format=JobID,State,Elapsed,MaxRSS,CPUTime      # detalles específicos

Estado de los nodos

sinfo                         # resumen de particiones y nodos
sinfo -N -l                   # detalle por nodo

Estados de nodo más comunes:

idle: disponible, sin trabajos.
alloc: completamente ocupado.
mix: parcialmente ocupado.
drain: fuera de servicio por mantenimiento.
down: nodo caído.

🔁 Job Arrays

Los job arrays permiten lanzar múltiples trabajos similares con un único script, variando un índice numérico. Son ideales para barridos de parámetros, procesamiento de múltiples archivos o repetición de simulaciones con distintas condiciones iniciales.

Script básico de job array

#!/bin/bash
#SBATCH --job-name=simulacion
#SBATCH --partition=LocalQ
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4
#SBATCH --mem=16G
#SBATCH --time=02:00:00
#SBATCH --array=1-10                          # lanza 10 trabajos (índices 1 al 10)
#SBATCH --output=simulacion_%A_%a.out         # %A = jobid, %a = índice del array

ml Python/3.11.5-GCCcore-13.2.0
source ~/mi_entorno/bin/activate

echo "Ejecutando tarea número: $SLURM_ARRAY_TASK_ID"
srun python simulacion.py --caso $SLURM_ARRAY_TASK_ID

La variable $SLURM_ARRAY_TASK_ID toma el valor del índice actual (1, 2, 3… 10) y puede usarse dentro del script para seleccionar archivos, parámetros o configuraciones distintas.

Variantes de definición del array

#SBATCH --array=1-100           # índices del 1 al 100
#SBATCH --array=0-9             # índices del 0 al 9
#SBATCH --array=1-100:2         # índices impares: 1, 3, 5... 99
#SBATCH --array=1-50%5          # del 1 al 50, máximo 5 corriendo simultáneamente

Ejemplo: procesar múltiples archivos

Si tiene una lista de archivos a procesar, puede usar el índice para seleccionar cada uno:

#!/bin/bash
#SBATCH --job-name=procesar_fits
#SBATCH --partition=LocalQ
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=2
#SBATCH --mem=8G
#SBATCH --time=01:00:00
#SBATCH --array=1-50
#SBATCH --output=fits_%A_%a.out

ml Python/3.11.5-GCCcore-13.2.0
source ~/mi_entorno/bin/activate

# Leer línea N del archivo de lista
ARCHIVO=$(sed -n "${SLURM_ARRAY_TASK_ID}p" lista_fits.txt)

echo "Procesando: $ARCHIVO"
srun python procesar.py --input $ARCHIVO

Donde lista_fits.txt contiene un nombre de archivo por línea:

galaxia_001.fits
galaxia_002.fits
galaxia_003.fits
...

Gestión de job arrays

squeue -u usuario                   # ver todos los trabajos del array
scancel <jobid>                     # cancelar todo el array
scancel <jobid>_3                   # cancelar solo el índice 3
scancel <jobid>_[5-10]             # cancelar índices 5 al 10

💡 Use --array=1-N%M para limitar los trabajos simultáneos y evitar saturar el cluster cuando el array es muy grande.

🌌 Casos de Uso en Astrofísica

Simulación de formación de galaxias y cúmulos.
Modelado de ondas gravitacionales.
Procesamiento de catálogos y detección de eventos transitorios.
Comparación de rendimiento entre laptop y cluster.

📢 Soporte y Comunidad

📄 Documentación y formulario: disponible en esta misma página.
📧 Soporte técnico: ia_cluster@unab.cl
🎓 Capacitación: el Instituto ofrece talleres y cursos sobre HPC y astrofísica computacional.

Reconocimientos / Acknowledgements

Para toda publicación científica (artículos, tesis, pósters, informes) que utilice recursos del cluster Ragnar, solicitamos incluir una mención de reconocimiento. Puede elegir una de las siguientes frases en inglés:

“This work made partial use of the RAGNAR computer server at Universidad Andrés Bello for calculations.“
“The computations were carried out using the RAGNAR computer server at Universidad Andrés Bello.“

Recomendación: añada esta mención en la sección de Agradecimientos (Acknowledgements).

Sugerencia adicional: al publicar, por favor envíe el DOI o referencia al equipo de soporte en ia_cluster@unab.cl para registro de impacto.