Guía Interactiva BioContainer | BioContainer MCPS-HPC

⚡ Ejecución Básica

Comando interactivo (shell):

apptainer shell /mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif

Ejecutar un comando directo:

apptainer exec /mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif bwa mem 2>&1 | head -n 30

Con acceso a tus datos:

apptainer exec \
  --bind /mnt/cephfs/hot_nvme:/data:ro \
  --bind /mnt/cephfs/orgs/home/$USER:/output:rw \
  /mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif \
  samtools view -c /data/mi_archivo.bam

🐍 Activar Entornos Conda

jupyter Principal

apptainer exec $BIOCONTAINER \
  /opt/miniforge3/envs/jupyter/bin/python mi_script.py

jax-gpu GPU

apptainer exec --nv $BIOCONTAINER \
  /opt/miniforge3/envs/jax-gpu/bin/python gpu_script.py

r-bio R + Bioconductor

apptainer exec $BIOCONTAINER \
  /opt/miniforge3/envs/r-bio/bin/Rscript mi_analisis.R

💡 Alias Útiles para tu .bashrc

# Añade esto a ~/.bashrc para acceso rápido
export BIOCONTAINER="/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif"
export DATOS="/mnt/cephfs/hot_nvme"
export MYHOME="/mnt/cephfs/orgs/home/$USER"

alias bio='apptainer exec --bind $DATOS:/data:ro --bind $MYHOME:/output:rw --bind /mnt/cephfs:/mnt/cephfs $BIOCONTAINER'
alias bioshell='apptainer shell --bind $DATOS:/data:ro --bind $MYHOME:/output:rw --bind /mnt/cephfs:/mnt/cephfs $BIOCONTAINER'
alias biopy='apptainer exec --bind /mnt/cephfs:/mnt/cephfs $BIOCONTAINER /opt/miniforge3/envs/jupyter/bin/python'
alias biovcf='apptainer exec --bind /mnt/cephfs:/mnt/cephfs $BIOCONTAINER /opt/miniforge3/envs/vcf2zarr/bin/python'
alias biojax='apptainer exec --nv --bind /mnt/cephfs:/mnt/cephfs $BIOCONTAINER /opt/miniforge3/envs/jax-gpu/bin/python'

# CuPy GPU (requiere NVRTC)
alias biocupy='apptainer exec --nv --bind /mnt/cephfs:/mnt/cephfs $BIOCONTAINER bash -lc "export LD_LIBRARY_PATH=\$LD_LIBRARY_PATH:/opt/miniforge3/envs/jax-gpu/lib/python3.10/site-packages/nvidia/cuda_nvrtc/lib; /opt/miniforge3/envs/jax-gpu/bin/python"'


# Ejemplos de uso después de añadir los alias:
bio samtools view -c /data/sample.bam
bio bcftools stats /data/variants.vcf.gz
biojax -c "import jax; print(jax.devices())"
biocupy -c "import cupy as cp; print(cp.arange(5))"

🪐

jupyter

Entorno principal con 565 paquetes científicos • Python 3.11

Análisis general ▼

Casos de uso

Entorno principal para análisis bioinformático general, machine learning, análisis de datos genómicos, RNA-seq, single-cell, visualización de datos, notebooks interactivos con JupyterHub.

🧬 Bioinformática

biopython, pysam, cyvcf2

scanpy, anndata, scvelo

HTSeq, pybedtools, pyBigWig

bio2zarr, scikit-allel

PyVCF3, pyfaidx

🤖 ML/Deep Learning

tensorflow 2.20, torch 2.2.2+cuda

jax 0.8.1, transformers

scikit-learn, xgboost, catboost

pytorch-lightning, keras

lightgbm, optuna

📊 Datos & Viz

pandas, numpy, scipy

dask, pyarrow, zarr

matplotlib, seaborn, plotly

bokeh, holoviews, datashader

polars, xarray

🎮

jax-gpu

JAX optimizado para GPU con CUDA 12 • Python 3.12

GPU ▼

Casos de uso

Experimentos numéricos y machine learning con aceleración GPU usando JAX. Ideal para cómputo diferenciable, autograd, paralelización automática en GPU, y modelos que requieren alta performance en CUDA.

Paquetes Principales

jax 0.6.2, jaxlib 0.6.2, cupy-cuda12x 13.6, numpy 2.2.6, scipy 1.15.3, dask, zarr 2.18.3

CUDA Libraries

nvidia-cublas-cu12, nvidia-cudnn-cu12 9.16, nvidia-nccl-cu12 2.28, nvidia-cusolver-cu12

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif

apptainer exec --nv --bind /mnt/cephfs:/mnt/cephfs "$SIF" bash -lc '
  export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/opt/miniforge3/envs/jax-gpu/lib/python3.10/site-packages/nvidia/cuda_nvrtc/lib"
  /opt/miniforge3/envs/jax-gpu/bin/python - << EOF
import cupy as cp
print("cupy:", cp.__version__)
print("device:", cp.cuda.runtime.getDevice())
print("arr:", cp.arange(5))
EOF
'

🗃️

vcf2zarr

Conversión VCF → Zarr + análisis genómico • Python 3.11

Multi-Nodo ▼

Casos de uso

Pipelines de conversión VCF a formato Zarr para análisis escalable de datos genómicos masivos. Análisis GWAS, genómica de poblaciones, y procesamiento de datos de variantes con sgkit/xarray.

Paquetes Clave

bio2zarr 0.1.6, sgkit 0.10.0, cyvcf2 0.31.1, zarr 2.18.7, dask 2024.8, numba 0.62.1

Para GWAS/Genómica

bed-reader 0.2.36, pandas 2.3.3, xarray 2025.3, scipy 1.16.3, dask-ml 2024.4, scikit-learn 1.7.2

apptainer exec $BIOCONTAINER \
  /opt/miniforge3/envs/vcf2zarr/bin/python mi_script_vcf2zarr.py

📊

r-bio

R 4.4.3 + Bioconductor 3.20 (467 paquetes)

R + Bioconductor ▼

Casos de uso

Stack completo de R para bioinformática: RNA-seq, single-cell, genómica, análisis de expresión diferencial, visualización avanzada (ComplexHeatmap, ggplot2, ggtree), análisis estadístico y tidyverse.

RNA-seq

DESeq2, edgeR, limma

tximport, tximeta

clusterProfiler, DOSE

enrichplot, fgsea

Single-Cell

Seurat 5.3.1

SingleCellExperiment

scater, scran, scuttle

cellranger, mudata

Genómica

GenomicRanges

Biostrings, BSgenome

rtracklayer, Rsamtools

VariantAnnotation

Visualización

ggplot2, tidyverse

ComplexHeatmap

ggtree, ggrepel

plotly, pheatmap

🔬

variants

TensorFlow 2.11 para análisis de variantes con ML • Python 3.10

TF 2.11 ▼

Casos de uso

Análisis de variantes genéticas usando machine learning con TensorFlow 2.11. Predicción de efectos funcionales, clasificación de variantes, modelos de deep learning para genómica.

Stack Principal

tensorflow 2.11, keras 2.11, tensorboard 2.11, numpy 1.26.4, scipy 1.15.2, h5py 3.15.1

🧬 Pipeline NGS: FASTQ → VCF

fastqc → bwa-mem2 → samtools → bcftools → VCF

#!/bin/bash
#SBATCH --job-name=ngs_pipeline
#SBATCH --account=researchers
#SBATCH --qos=#small,normal,large,gpu,vip,interective
#SBATCH --partition=normal
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=16
#SBATCH --mem=64G
#SBATCH --time=24:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
DATA=/mnt/cephfs/hot_nvme
OUT=/mnt/cephfs/orgs/home/$USER/results/ngs_pipeline

SAMPLE="sample001"
REF="$DATA/reference/hg38.fa"
R1="$DATA/fastq/${SAMPLE}_R1.fastq.gz"
R2="$DATA/fastq/${SAMPLE}_R2.fastq.gz"

THREADS=${SLURM_CPUS_PER_TASK}

mkdir -p "$OUT"/{qc,bam,vcf,logs}

# Validaciones
[[ -f "$REF" ]] || { echo "No existe REF: $REF"; exit 1; }
[[ -f "$R1"  ]] || { echo "No existe R1:  $R1"; exit 1; }
[[ -f "$R2"  ]] || { echo "No existe R2:  $R2"; exit 1; }

# 0) Index (solo si no existe)
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" bash -lc "
  set -euo pipefail
  if [ ! -f '${REF}.fai' ]; then
    echo '[INFO] Indexando referencia con samtools faidx...'
    samtools faidx '${REF}'
  fi
  if [ ! -f '${REF}.bwt.2bit.64' ] && [ ! -f '${REF}.0123' ]; then
    echo '[INFO] Indexando referencia con bwa-mem2 index...'
    bwa-mem2 index '${REF}'
  fi
"

# 1) QC
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  fastqc -t "$THREADS" -o "$OUT/qc" "$R1" "$R2"

# 2) Alineamiento + sort (TODO dentro del contenedor)
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" bash -lc "
  set -euo pipefail
  bwa-mem2 mem -t $THREADS '${REF}' '${R1}' '${R2}' \
  | samtools sort -@ $((THREADS/2)) -o '${OUT}/bam/${SAMPLE}.sorted.bam' -
"

# 3) Index BAM
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  samtools index "$OUT/bam/${SAMPLE}.sorted.bam"

# 4) Variantes (mpileup|call dentro del contenedor)
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" bash -lc "
  set -euo pipefail
  bcftools mpileup -Ou -f '${REF}' '${OUT}/bam/${SAMPLE}.sorted.bam' \
  | bcftools call -mv -Oz -o '${OUT}/vcf/${SAMPLE}.vcf.gz'
"

# 5) Index VCF
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  bcftools index -t "$OUT/vcf/${SAMPLE}.vcf.gz"

echo "Pipeline completado: $OUT/vcf/${SAMPLE}.vcf.gz"

🧪 Pipeline RNA-seq con DESeq2

STAR → featureCounts → DESeq2 (R) → Volcano Plot

#!/bin/bash
#SBATCH --job-name=rnaseq
#SBATCH --account=researchers
#SBATCH --qos=#small,normal,large,gpu,vip,interective
#SBATCH --partition=normal
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=24
#SBATCH --mem=64G
#SBATCH --time=48:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
DATA=/mnt/cephfs/hot_nvme
OUT=/mnt/cephfs/orgs/home/$USER/rnaseq_results
THREADS=${SLURM_CPUS_PER_TASK}

GENOME_DIR="$DATA/reference/star_index"
GTF="$DATA/reference/gencode.gtf"

SAMPLES=(sample1 sample2 sample3)

mkdir -p "$OUT"/{star,counts,plots,logs}

# 1) STAR
for SAMPLE in "${SAMPLES[@]}"; do
  R1="$DATA/fastq/${SAMPLE}_R1.fastq.gz"
  R2="$DATA/fastq/${SAMPLE}_R2.fastq.gz"
  [[ -f "$R1" && -f "$R2" ]] || { echo "Faltan FASTQ para $SAMPLE"; exit 1; }

  apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
    STAR --runThreadN "$THREADS" \
         --genomeDir "$GENOME_DIR" \
         --readFilesIn "$R1" "$R2" \
         --readFilesCommand zcat \
         --outFileNamePrefix "$OUT/star/${SAMPLE}_" \
         --outSAMtype BAM SortedByCoordinate
done

# 2) featureCounts (subread)
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  featureCounts -T "$THREADS" -p -t exon -g gene_id \
    -a "$GTF" \
    -o "$OUT/counts/counts_matrix.txt" \
    "$OUT"/star/*_Aligned.sortedByCoord.out.bam

# 3) DESeq2 con Rscript (sin conda activate)
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  /opt/miniforge3/envs/r-bio/bin/Rscript \
  "$OUT/scripts/deseq2_analysis.R" \
  "$OUT/counts/counts_matrix.txt" \
  "$OUT/metadata/samples.csv" \
  "$OUT/plots/volcano_plot.pdf"

echo "RNA-seq completado. Plot: $OUT/plots/volcano_plot.pdf"

📜 Ver script R (deseq2_analysis.R)

args <- commandArgs(trailingOnly=TRUE)
counts_path <- args[1]
meta_path   <- args[2]
out_pdf     <- args[3]

library(DESeq2)
library(ggplot2)
library(ggrepel)

counts <- read.table(counts_path, header=TRUE, row.names=1, check.names=FALSE)
# featureCounts trae columnas extra al inicio; normalmente hay que limpiar:
# Si tu archivo tiene columnas "Chr Start End Strand Length", elimina:
drop_cols <- intersect(colnames(counts), c("Chr","Start","End","Strand","Length"))
if (length(drop_cols) > 0) counts <- counts[, setdiff(colnames(counts), drop_cols), drop=FALSE]

coldata <- read.csv(meta_path, row.names=1)
stopifnot(all(colnames(counts) %in% rownames(coldata)))
coldata <- coldata[colnames(counts), , drop=FALSE]

dds <- DESeqDataSetFromMatrix(countData = round(as.matrix(counts)),
                              colData = coldata,
                              design = ~ condition)
dds <- DESeq(dds)
res <- results(dds, alpha=0.05)

df <- as.data.frame(res)
df$gene <- rownames(df)
df$significant <- !is.na(df$padj) & df$padj < 0.05 & abs(df$log2FoldChange) > 1

p <- ggplot(df, aes(x=log2FoldChange, y=-log10(pvalue), color=significant)) +
  geom_point(alpha=0.6) +
  theme_minimal() +
  labs(title="Volcano Plot - Expresión Diferencial")

ggsave(out_pdf, p, width=10, height=8), width=10, height=8)

📈 Pipeline GWAS con Zarr

VCF → bio2zarr → sgkit → GWAS → Manhattan

#!/bin/bash
#SBATCH --job-name=gwas_zarr
#SBATCH --account=researchers
#SBATCH --qos=#small,normal,large,gpu,vip,interective
#SBATCH --partition=normal
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=32
#SBATCH --mem=256G
#SBATCH --time=12:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
DATA=/mnt/cephfs/hot_nvme
OUT=/mnt/cephfs/orgs/home/$USER/gwas
THREADS=${SLURM_CPUS_PER_TASK}

VCF="$DATA/genotypes/chr22.vcf.gz"
ICF="$OUT/intermediate/chr22_icf"
ZARR="$OUT/zarr/chr22.zarr"
PHENO="$OUT/phenotypes.csv"

mkdir -p "$OUT"/{intermediate,zarr,plots,logs}

apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  vcf2zarr explode "$VCF" "$ICF" --worker-processes "$THREADS"

apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  vcf2zarr encode "$ICF" "$ZARR" --worker-processes "$THREADS"


apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  /opt/miniforge3/envs/vcf2zarr/bin/python - << 'PY'
import sgkit as sg
import xarray as xr
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os

zarr_path = os.environ.get("ZARR_PATH")
pheno_path = os.environ.get("PHENO_PATH")
out_png = os.environ.get("OUT_PNG")

ds = sg.load_dataset(zarr_path)

pheno = pd.read_csv(pheno_path)

trait = pheno["height"].to_numpy()
ds["sample_phenotype"] = xr.DataArray(trait, dims="samples")

dosage_var = "call_DS" if "call_DS" in ds else None
if dosage_var is None:
    raise RuntimeError("No encuentro variable de dosage (call_DS / call_dosage).")

gwas = sg.gwas_linear_regression(ds, dosage=dosage_var, covariates=None, trait="sample_phenotype")

pos = gwas["variant_position"].values
p = gwas["variant_p_value"].values

plt.figure(figsize=(15,6))
plt.scatter(pos, -np.log10(p), alpha=0.5, s=2)
plt.axhline(-np.log10(5e-8), linestyle="--")
plt.xlabel("Position")
plt.ylabel("-log10(p)")
plt.title("Manhattan Plot - Chr22")
plt.savefig(out_png, dpi=300)
print("GWAS OK ->", out_png)
PY
"

🔬 Pipeline Single-Cell RNA-seq

10X data → scanpy → clustering → UMAP

#!/bin/bash
#SBATCH --job-name=singlecell_scanpy
#SBATCH --account=researchers
#SBATCH --qos=#small,normal,large,gpu,vip,interective
#SBATCH --partition=normal
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=16
#SBATCH --mem=128G
#SBATCH --gres=gpu:1
#SBATCH --time=08:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
OUT=/mnt/cephfs/orgs/home/$USER/scrna

mkdir -p "$OUT"/{figures,results}

apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  /opt/miniforge3/envs/jupyter/bin/python - << 'EOF'
import scanpy as sc
import os

out = os.environ["OUTDIR"]
sc.settings.verbosity = 3
sc.settings.figdir = os.path.join(out, "figures")

adata = sc.read_10x_mtx(os.path.join(out, "data/filtered_feature_bc_matrix/"))

sc.pp.filter_cells(adata, min_genes=200)
sc.pp.filter_genes(adata, min_cells=3)
adata.var['mt'] = adata.var_names.str.startswith('MT-')
sc.pp.calculate_qc_metrics(adata, qc_vars=['mt'], inplace=True)
adata = adata[adata.obs.pct_counts_mt < 20, :]

sc.pp.normalize_total(adata, target_sum=1e4)
sc.pp.log1p(adata)

sc.pp.highly_variable_genes(adata, n_top_genes=2000)
sc.pp.pca(adata, n_comps=50)
sc.pp.neighbors(adata, n_neighbors=15)
sc.tl.umap(adata)
sc.tl.leiden(adata, resolution=0.5)

sc.pl.umap(adata, color=['leiden', 'n_genes'], save='_clusters.pdf')

adata.write(os.path.join(out, "results/processed_adata.h5ad"))
print("OK single-cell")
EOF
"

🌐 Herramientas Multi-Nodo Disponibles

Estas herramientas pueden escalar a múltiples nodos del cluster MCPS-HPC, aprovechando los 152 CPUs,60GBVRAM y ~1TB RAM distribuidos. Usan MPI, Spark, o Dask para paralelización.

⚡ Apache Spark

Procesamiento distribuido de grandes datasets

pyspark, spark-submit, sparkR

🔄 Dask Distributed

Paralelización Python estilo NumPy/Pandas

dask, dask-ml, dask-image

📡 MPI Tools

Ensamblaje y alineamiento distribuido

ABYSS-P, abyss-paired-dbg-mpi

📋 Catálogo de Herramientas Multi-Nodo

Herramienta	Tipo	Uso	Escalabilidad
pyspark	Spark	Big Data, ETL, ML distribuido	🟢 Excelente (100+ nodos)
dask distributed	Dask	Arrays grandes, DataFrames	🟢 Excelente
ABYSS-P / MPI	MPI	Ensamblaje de novo	🟡 Buena (10-50 nodos)
bio2zarr	Threads	Conversión VCF→Zarr	🟡 Multi-thread por nodo
PyTorch DDP	GPU	Deep Learning distribuido	🟢 Multi-GPU/Multi-nodo
JAX pmap	GPU	Cómputo paralelo GPU	🟢 Multi-GPU

⚡ Ejemplo: Spark Multi-Nodo

#!/bin/bash
#SBATCH --job-name=spark_multinode
#SBATCH --account=researchers
#SBATCH --qos=vip
#SBATCH --partition=normal
#SBATCH --nodes=4
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=24
#SBATCH --mem=50G
#SBATCH --time=12:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/spark_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/spark_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
OUT=/mnt/cephfs/orgs/home/$USER/spark_output
LOG=/mnt/cephfs/orgs/home/$USER/logs/spark_$SLURM_JOB_ID

mkdir -p "$OUT" "$LOG"

MASTER_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n1)
MASTER_URL="spark://${MASTER_NODE}:7077"

export SPARK_HOME=/opt/spark
export SPARK_MASTER_HOST="$MASTER_NODE"
export SPARK_MASTER_PORT=7077
export SPARK_WORKER_CORES=$SLURM_CPUS_PER_TASK
export SPARK_WORKER_MEMORY=100G

echo "MASTER_NODE=$MASTER_NODE"
echo "MASTER_URL=$MASTER_URL"
echo ""

# 1) Arrancar master SOLO en el primer nodo (como proceso controlado por Slurm)
srun --nodes=1 --ntasks=1 --nodelist="$MASTER_NODE" \
  apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  bash -lc "
    export SPARK_HOME=/opt/spark
    export SPARK_MASTER_HOST='$MASTER_NODE'
    export SPARK_MASTER_PORT=7077
    mkdir -p '$LOG/master'
    # Ejecutar master en foreground (NO start-master.sh)
    exec \$SPARK_HOME/bin/spark-class org.apache.spark.deploy.master.Master \
      --host '$MASTER_NODE' \
      --port 7077 \
      --webui-port 8080
  " &

sleep 8

# 2) Arrancar 1 worker por nodo (incluyendo el master node), en foreground, controlado por Slurm
srun --nodes=$SLURM_NNODES --ntasks=$SLURM_NNODES --ntasks-per-node=1 \
  apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  bash -lc "
    export SPARK_HOME=/opt/spark
    mkdir -p '$LOG/workers'
    exec \$SPARK_HOME/bin/spark-class org.apache.spark.deploy.worker.Worker \
      --cores $SLURM_CPUS_PER_TASK \
      --memory 50G \
      $MASTER_URL
  " &

sleep 8

# 3) Ejecutar aplicación Spark (client mode en el nodo que lanza el job)
apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  spark-submit \
    --master "$MASTER_URL" \
    --deploy-mode client \
    --executor-memory 50G \
    --total-executor-cores $((SLURM_NNODES * SLURM_CPUS_PER_TASK)) \
    "$OUT/scripts/process_genomics.py"

echo "Spark job terminado. Deteniendo cluster..."



echo "Listo."

🔄 Ejemplo: Dask Distributed

#!/bin/bash
#SBATCH --job-name=dask_cluster
#SBATCH --account=researchers
#SBATCH --qos=normal
#SBATCH --partition=normal
#SBATCH --nodes=3
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=32
#SBATCH --mem=10G
#SBATCH --time=08:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/dask_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/dask_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
DATA=/mnt/cephfs/hot_nvme
OUT=/mnt/cephfs/orgs/home/$USER/dask_output
LOG=/mnt/cephfs/orgs/home/$USER/logs/dask_$SLURM_JOB_ID

mkdir -p "$OUT" "$LOG"

SCHEDULER_NODE=$(scontrol show hostnames "$SLURM_JOB_NODELIST" | head -n1)
SCHEDULER_PORT=8786
SCHEDULER_ADDR="tcp://${SCHEDULER_NODE}:${SCHEDULER_PORT}"

echo "Scheduler: $SCHEDULER_ADDR"
echo ""

# 1) Scheduler (foreground) en primer nodo
srun --nodes=1 --ntasks=1 --nodelist="$SCHEDULER_NODE" \
  apptainer exec --bind /mnt/cephfs:/mnt/cephfs --bind "$DATA:/data:ro" --bind "$OUT:/out:rw" "$SIF" \
  /opt/miniforge3/envs/jupyter/bin/python -m dask.distributed.cli.dask_scheduler \
    --host "$SCHEDULER_NODE" \
    --port "$SCHEDULER_PORT" \
    --dashboard-address ":8787" &

sleep 5

# 2) Workers (1 por nodo), foreground, controlados por Slurm
srun --nodes=$SLURM_NNODES --ntasks=$SLURM_NNODES --ntasks-per-node=1 \
  apptainer exec --bind /mnt/cephfs:/mnt/cephfs --bind "$DATA:/data:ro" --bind "$OUT:/out:rw" "$SIF" \
  /opt/miniforge3/envs/jupyter/bin/python -m dask.distributed.cli.dask_worker \
    "$SCHEDULER_ADDR" \
    --nthreads "$SLURM_CPUS_PER_TASK" \
    --memory-limit 100GB \
    --name "worker-\$(hostname)" &

sleep 8

# 3) Trabajo (cliente) - aquí corre tu análisis real
apptainer exec --bind /mnt/cephfs:/mnt/cephfs --bind "$DATA:/data:ro" --bind "$OUT:/out:rw" "$SIF" \
  /opt/miniforge3/envs/jupyter/bin/python - << 'EOF'
import os
from dask.distributed import Client
import dask.dataframe as dd

sched = os.environ["SCHEDULER_ADDR"]
out = "/out/results"
os.makedirs(out, exist_ok=True)

client = Client(sched)
print(client)

# Ejemplo: procesar parquet en /data
df = dd.read_parquet("/data/genotypes/*.parquet")

result = df.groupby("chromosome").agg({"maf": "mean"}).compute()
result.to_csv(f"{out}/maf_by_chr.csv", index=True)

print("Procesamiento completado:", f"{out}/maf_by_chr.csv")
EOF
# pasamos la dirección del scheduler:
SCHEDULER_ADDR="$SCHEDULER_ADDR"

echo "Dask job terminado. Deteniendo cluster..."
jobs -p | xargs -r kill
echo "Listo."
"

Mostrando todas las herramientas

Catálogo de Herramientas

💡 Desliza horizontalmente para ver más columnas

Herramienta	Entorno	Tipo	Descripción

📋 Template Básico Slurm

#!/bin/bash
#SBATCH --job-name=mi_job
#SBATCH --account=researchers
#SBATCH --partition=normal
#SBATCH --qos=normal
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=16
#SBATCH --mem=64G
#SBATCH --time=24:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
DATA=/mnt/cephfs/hot_nvme
OUT=/mnt/cephfs/orgs/home/$USER/results/$SLURM_JOB_ID

mkdir -p /mnt/cephfs/orgs/home/$USER/logs
mkdir -p "$OUT"

echo "Job: $SLURM_JOB_ID"
echo "Node: $SLURMD_NODENAME"
echo "CPUs: $SLURM_CPUS_PER_TASK"
echo "Mem:  $SLURM_MEM_PER_NODE"
echo "Start: $(date)"
echo ""

# Ejemplo: comando dentro del SIF con binds típicos
apptainer exec \
  --bind /mnt/cephfs:/mnt/cephfs \
  --bind "$DATA:/data:ro" \
  --bind "$OUT:/out:rw" \
  "$SIF" \
  tu_comando_aqui

echo ""
echo "Job completado: $(date)"

🎮 Template con GPU

#!/bin/bash
#SBATCH --job-name=gpu_job
#SBATCH --account=researchers
#SBATCH --partition=gpu
#SBATCH --qos=gpu
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=16
#SBATCH --mem=64G
#SBATCH --gres=gpu:1
#SBATCH --time=12:00:00
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%j.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%j.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
OUT=/mnt/cephfs/orgs/home/$USER/gpu_results/$SLURM_JOB_ID

mkdir -p /mnt/cephfs/orgs/home/$USER/logs
mkdir -p "$OUT"

echo "Job: $SLURM_JOB_ID"
echo "Node: $SLURMD_NODENAME"
echo "GPU:  $CUDA_VISIBLE_DEVICES"
echo "Start: $(date)"
echo ""

# NVRTC path (necesario para CuPy)
NVRTC_DIR=/opt/miniforge3/envs/jax-gpu/lib/python3.10/site-packages/nvidia/cuda_nvrtc/lib

apptainer exec --nv \
  --bind /mnt/cephfs:/mnt/cephfs \
  --bind "$OUT:/out:rw" \
  "$SIF" \
  bash -lc "
    export LD_LIBRARY_PATH=\"\$LD_LIBRARY_PATH:$NVRTC_DIR\"
    /opt/miniforge3/envs/jax-gpu/bin/python - << 'EOF'
import jax
import jax.numpy as jnp
import cupy as cp

print('JAX devices:', jax.devices())
print('CuPy device:', cp.cuda.runtime.getDevice())
print('CuPy arange:', cp.arange(5))

x = jnp.ones((2000, 2000))
y = x @ x
print('JAX result shape:', y.shape)
EOF
"

echo ""
echo "GPU job completado: $(date)"
"

🔢 Array Jobs (Múltiples muestras)

#!/bin/bash
#SBATCH --job-name=vcf2zarr_chr
#SBATCH --account=researchers
#SBATCH --partition=normal
#SBATCH --qos=large
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=16
#SBATCH --mem=64G
#SBATCH --time=12:00:00
#SBATCH --array=1-22
#SBATCH --output=/mnt/cephfs/orgs/home/%u/logs/%x_%A_%a.out
#SBATCH --error=/mnt/cephfs/orgs/home/%u/logs/%x_%A_%a.err

set -euo pipefail

SIF=/mnt/cephfs/biocontainers/images/jupyter-biotools-1.2.sif
DATA=/mnt/cephfs/hot_nvme
OUT=/mnt/cephfs/orgs/home/$USER/vcf2zarr_array

CHR=$SLURM_ARRAY_TASK_ID
THREADS=$SLURM_CPUS_PER_TASK

VCF=$DATA/vcf/chr${CHR}.vcf.gz
ICF=$OUT/icf/chr${CHR}_icf
ZARR=$OUT/zarr/chr${CHR}.zarr

mkdir -p /mnt/cephfs/orgs/home/$USER/logs
mkdir -p "$OUT"/{icf,zarr}

[[ -f "$VCF" ]] || { echo "ERROR: no existe VCF: $VCF"; exit 1; }

echo "CHR=$CHR"
echo "VCF=$VCF"
echo "ICF=$ICF"
echo "ZARR=$ZARR"
echo "THREADS=$THREADS"
echo ""

apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  vcf2zarr explode "$VCF" "$ICF" --worker-processes "$THREADS"

apptainer exec --bind /mnt/cephfs:/mnt/cephfs "$SIF" \
  vcf2zarr encode "$ICF" "$ZARR" --worker-processes "$THREADS"

echo "chr${CHR} completado -> $ZARR"

⌨️ Comandos Slurm Útiles

Enviar y gestionar jobs

# Enviar job
sbatch mi_script.sh

# Ver cola
squeue -u $USER

# Cancelar job
scancel JOB_ID

# Ver detalles de job
scontrol show job JOB_ID

# Ver recursos disponibles
sinfo

Monitoreo y logs

# Ver output en tiempo real
tail -f logs/mi_job_123.out

# Ver uso de recursos del job
sstat -j JOB_ID

# Historial de jobs
sacct -u $USER --starttime=2024-01-01

# Job interactivo
srun --pty -p gpu -t 2:00:00 bash