Cómo instalar SingularityCE (y Apptainer) en Debian 13 sin morir en el intento.

Introducción

Singularity es un runtime de contenedores orientado sobre todo a entornos científicos y HPC (High Performance Computing, computación de alto desempeño); se usa para ejecutar software empaquetado de forma reproducible, aislada y portable entre estaciones de trabajo, servidores y clústeres, sin romper fácilmente la integración con el sistema anfitrión.

SIF (Singularity Image Format) es el formato de imagen usado por Singularity para empaquetar contenedores en un único archivo portable, verificable y fácil de compartir.

Comparativamente con Docker, en términos prácticos, éste está más orientado a microservicios y despliegues tipo DevOps (daemon, imágenes OCI, orquestación), mientras que Singularity prioriza ejecución científica/HPC con integración más directa con el host y sin exigir el mismo modelo de privilegios que Docker clásico.

Singularity fue creado originalmente por Gregory M. Kurtzer. No nació como proyecto “cerrado” ni puramente comercial: durante años se usó como software abierto en academia y HPC. Con el tiempo cambiaron la gobernanza y la propiedad de marca cuando Sylabs impulsó su oferta comercial (soporte empresarial y productos asociados). A partir de ahí, los caminos se separaron: SingularityCE (Community Edition) continuó bajo Sylabs, mientras que Apptainer surgió en 2021 como fork comunitario en la Linux Foundation para mantener una gobernanza abierta y neutral. En la práctica, hoy conviven ambos runtimes, con CLI y soporte SIF muy parecidos, pero con mantenedores y hojas de ruta diferentes.

Tabla de contenido

Objetivos

Esta guía explica cómo instalar SingularityCE en Debian 13 Trixie de forma controlada, reproducible y razonablemente segura. El enfoque principal será compilar SingularityCE desde código fuente, porque los paquetes .deb oficiales de SingularityCE publicados por Sylabs están orientados principalmente a Ubuntu LTS, no específicamente a Debian 13.

También se incluye la instalación de Apptainer, porque en muchos entornos académicos, científicos y HPC se usa el nombre Singularity de forma genérica, aunque hoy (2026) existen dos proyectos relacionados pero distintos, como se mencionó.

SingularityCE vs Apptainer

Históricamente, Singularity fue una herramienta muy usada en HPC porque permitía ejecutar contenedores de forma más compatible con entornos multiusuario que Docker. En particular, Singularity se volvió popular porque facilitaba ejecutar cargas científicas, pipelines bioinformáticos, software de machine learning y aplicaciones empaquetadas sin requerir que cada usuario tuviera privilegios administrativos.

Con el tiempo, el ecosistema se dividió:

En la práctica:

singularity exec imagen.sif comando

Y:

apptainer exec imagen.sif comando

son comandos conceptualmente muy similares.

Estrategia de instalación recomendada en Debian 13

En Debian 13 hay tres caminos razonables:

1. Instalación de SingularityCE

En esta guía instalaremos SingularityCE desde una versión publicada en GitHub por Sylabs.

1.1 Cuándo elegir SingularityCE

Elige SingularityCE si:

• Tu documentación interna pide explícitamente SingularityCE.
• Quieres mantener compatibilidad con flujos Sylabs.
• Tu equipo ya usa SingularityCE y quiere evitar diferencias entre runtimes.
• Necesitas reproducir exactamente el comportamiento de una instalación SingularityCE existente.

Si no necesitas SingularityCE de Sylabs de forma estricta, Apptainer suele ser la opción más directa en Debian 13 porque se integra bien con apt.

1.2 Esquema de directorios

La instalación quedará, por defecto, bajo:

/usr/local

Por tanto, el binario principal quedará normalmente en:

/usr/local/bin/singularity

Y la configuración global quedará bajo una ruta similar a:

/usr/local/etc/singularity/

Este esquema tiene una ventaja importante: mantiene separada la instalación manual de los paquetes gestionados por apt. En Debian, los archivos instalados por el administrador local suelen vivir bajo /usr/local, mientras que los paquetes del sistema suelen instalarse bajo /usr.

1.3 Requisitos previos

Esta guía asume lo siguiente:

• Tienes Debian 13 Trixie instalado.
• Tienes acceso a una cuenta con permisos de sudo.
• Tienes conexión a Internet para descargar dependencias y código fuente.
• Estás en una arquitectura amd64 / x86_64, que es la más habitual en servidores y estaciones de trabajo.
• Vas a instalar SingularityCE para uso local o para un servidor administrado por ti.

Verifica la versión de Debian:

cat /etc/os-release

En Debian 13 deberías ver algo parecido a:

PRETTY_NAME="Debian GNU/Linux 13 (trixie)"
VERSION_ID="13"
VERSION_CODENAME=trixie

Verifica también la arquitectura:

uname -m

Lo más común es que el resultado sea:

x86_64

1.4 Preparar el sistema

Actualiza los índices de paquetes:

sudo apt update

Actualiza el sistema base si tienes paquetes pendientes:

sudo apt full-upgrade -y

Instala herramientas básicas:

sudo apt install -y \
  ca-certificates \
  curl \
  wget \
  git \
  gnupg \
  lsb-release \
  build-essential

Donde:

• ca-certificates permite validar certificados TLS al descargar desde HTTPS.
• curl y wget sirven para descargar archivos.
• git será necesario si decides clonar el repositorio en vez de usar un tarball de release.
• gnupg es útil para verificar firmas o manejar llaves.
• build-essential instala compilador C/C++, make y herramientas básicas de compilación.

1.5 Instalar dependencias de compilación de SingularityCE

Instala las dependencias indicadas por la documentación de SingularityCE para sistemas Debian/Ubuntu, añadiendo libsubid-dev, conveniente en Debian 13. Esta combinación evita instalar runc para no forzar la eliminación de docker-ce/containerd.io en sistemas que ya usan Docker CE:

sudo apt install -y \
  autoconf \
  automake \
  cryptsetup \
  fuse \
  fuse2fs \
  libfuse3-dev \
  libseccomp-dev \
  libtool \
  pkg-config \
  squashfs-tools \
  squashfs-tools-ng \
  uidmap \
  zlib1g-dev \
  libsubid-dev

1.6 Dependencias a detalle

1.6.1 autoconf, automake, libtool, pkg-config

Estas herramientas participan en el proceso clásico de generación de scripts de configuración y compilación. SingularityCE usa un proceso de construcción que necesita preparar un árbol de compilación antes de ejecutar make.

1.6.2 cryptsetup

Permite soporte para contenedores cifrados. Puedes compilar SingularityCE sin cryptsetup, pero si planeas usar imágenes cifradas, conviene instalarlo desde el inicio.

1.6.3 fuse, fuse2fs, libfuse3-dev

FUSE permite montar sistemas de archivos en espacio de usuario. En el contexto de SingularityCE y herramientas similares, FUSE es importante para varios modos de montaje y ejecución no privilegiada.

1.6.4 libseccomp-dev

seccomp permite aplicar filtros de llamadas al sistema. Es una pieza relevante de aislamiento y control de seguridad en runtimes de contenedores.

1.6.5 runc

runc es un runtime OCI. SingularityCE puede operar con modo OCI en algunas situaciones. Si no usarás comandos singularity oci, puedes omitirlo.

OCI significa Open Container Initiative: un conjunto de especificaciones abiertas para formatos de imagen y ejecución de contenedores. En términos prácticos, “modo OCI” se refiere a trabajar con ese estándar (imágenes y runtimes compatibles con OCI).

1.6.6 squashfs-tools y squashfs-tools-ng

Las imágenes SIF suelen incluir sistemas de archivos comprimidos basados en SquashFS. Estas herramientas permiten crear, inspeccionar y manipular ese tipo de contenido.

1.6.7 uidmap y libsubid-dev

Estos paquetes están relacionados con mapeo de usuarios y grupos subordinados, importante para escenarios rootless, fakeroot y user namespaces.

1.7 Instalar Go

SingularityCE está escrito en Go. La documentación oficial recomienda usar una versión reciente de Go desde los binarios oficiales, especialmente porque la versión disponible en los repositorios de una distribución puede no ser suficientemente reciente para compilar la versión actual de SingularityCE.

Consulta primero si ya tienes Go instalado:

go version || true

Si tienes una instalación manual previa bajo /usr/local/go, elimínala antes de instalar otra versión encima:

sudo rm -rf /usr/local/go

Instala Go desde los binarios oficiales. Ajusta GO_VERSION a una versión estable reciente soportada por el release concreto que vas a compilar:

cd /tmp

export GO_VERSION="1.25.5"
export GO_OS="linux"
export GO_ARCH="amd64"

wget "https://go.dev/dl/go${GO_VERSION}.${GO_OS}-${GO_ARCH}.tar.gz"

sudo tar -C /usr/local -xzf "go${GO_VERSION}.${GO_OS}-${GO_ARCH}.tar.gz"

rm "go${GO_VERSION}.${GO_OS}-${GO_ARCH}.tar.gz"

Agrega Go al PATH para tu usuario:

cat <<'BASHRC_GO' >> ~/.bashrc

# Go instalado manualmente en /usr/local/go
export GOPATH="$HOME/go"
export PATH="/usr/local/go/bin:$GOPATH/bin:$PATH"
BASHRC_GO

source ~/.bashrc

Verifica:

go version

Deberías ver algo como:

go version go1.25.5 linux/amd64

1.8 Nota sobre Debian y Go

En Debian también podrías instalar Go con:

sudo apt install golang-go

Ese método es más fácil de mantener con apt, pero para compilar SingularityCE suele ser más prudente instalar la versión de Go esperada por el release concreto que vas a construir.

1.9 Elegir la versión de SingularityCE

Conviene instalar una versión etiquetada, no la rama main.

Una versión etiquetada es más estable porque corresponde a un release. En cambio, la rama main puede cambiar rápidamente y no es la mejor opción para una máquina de producción.

Para localizar versiones disponibles:

1. Revisa la página oficial de releases: https://github.com/sylabs/singularity/releases
2. Desde terminal, lista tags recientes:

curl -fsSL "https://api.github.com/repos/sylabs/singularity/releases" \
  | grep -E '"tag_name":' \
  | head -n 10

Salida típica:

"tag_name": "v4.3.6"
"tag_name": "v4.3.5"

3. Verifica que exista el tarball del release elegido:

export SINGULARITY_VERSION="4.3.6"
wget --spider "https://github.com/sylabs/singularity/releases/download/v${SINGULARITY_VERSION}/singularity-ce-${SINGULARITY_VERSION}.tar.gz"

Si wget --spider responde 200 OK, esa versión está disponible con ese formato de archivo.

Define la versión en una variable:

export SINGULARITY_VERSION="4.3.6"

Puedes cambiar ese valor por la versión estable más reciente publicada por Sylabs.

1.10 Descargar el tarball correcto

Descarga el tarball de release de SingularityCE:

cd /usr/local/src

sudo wget "https://github.com/sylabs/singularity/releases/download/v${SINGULARITY_VERSION}/singularity-ce-${SINGULARITY_VERSION}.tar.gz"

Extrae el archivo:

sudo tar -xzf "singularity-ce-${SINGULARITY_VERSION}.tar.gz"

Cambia la propiedad del árbol de código a tu usuario para compilar sin usar sudo todo el tiempo:

sudo chown -R "$USER:$USER" "singularity-ce-${SINGULARITY_VERSION}"

Entra al directorio:

cd "singularity-ce-${SINGULARITY_VERSION}"

1.11 Configurar la compilación

Genera el árbol de compilación:

./mconfig --prefix=/usr/local

1.12 Qué hace mconfig

mconfig prepara el directorio de compilación, detecta dependencias y define las rutas finales de instalación.

Con:

--prefix=/usr/local

indicamos que SingularityCE se instalará bajo /usr/local.

Eso normalmente implica:

/usr/local/bin/singularity
/usr/local/etc/singularity/singularity.conf
/usr/local/libexec/singularity/
/usr/local/var/singularity/

1.13 Compilar SingularityCE

Entra al directorio de compilación:

cd builddir

Compila:

make

Si quieres usar más núcleos de CPU:

make -j"$(nproc)"

1.14 Instalar SingularityCE

1.14.1 Instalación directa con make install

Instala:

sudo make install

Verifica que el binario exista:

which singularity

Debería responder:

/usr/local/bin/singularity

Verifica la versión:

singularity --version

Ejemplo esperado:

singularity-ce version 4.3.6

1.14.2 Instalación con checkinstall para generar .deb

Si quieres poder desinstalar con dpkg/apt en lugar de borrar rutas a mano, puedes generar e instalar un paquete .deb local desde el mismo builddir.

Instala checkinstall:

sudo apt update
sudo apt install -y checkinstall

Desde builddir (donde ya ejecutaste make), genera e instala el .deb:

sudo checkinstall \
  --fstrans=no \
  --type=debian \
  --pkgname=singularity-ce \
  --pkgversion="${SINGULARITY_VERSION}" \
  --pkglicense="BSD-3-Clause" \
  --maintainer="admin@localhost" \
  --requires="libseccomp2,uidmap,squashfs-tools,cryptsetup" \
  --nodoc \
  --install=yes \
  make install

Al terminar, checkinstall dejará también el paquete .deb en el directorio actual para reutilizarlo en otras máquinas compatibles.

Verifica:

dpkg -l | grep singularity-ce
singularity --version

1.15 Revisar la configuración instalada

SingularityCE incluye un comando útil para mostrar cómo fue construido:

singularity buildcfg

Ese comando muestra rutas relevantes como:

PREFIX=/usr/local
BINDIR=/usr/local/bin
SYSCONFDIR=/usr/local/etc
SINGULARITY_CONFDIR=/usr/local/etc/singularity
SINGULARITY_CONF_FILE=/usr/local/etc/singularity/singularity.conf

La configuración principal suele estar en:

sudo less /usr/local/etc/singularity/singularity.conf

No edites esta configuración a ciegas. Primero confirma qué comportamiento necesitas cambiar.

1.16 Prueba básica de ejecución

Ejecuta una prueba simple usando una imagen remota:

singularity exec docker://debian:13 cat /etc/os-release

La primera vez, SingularityCE descargará capas desde el registro Docker/OCI y construirá una imagen local en caché.

También puedes hacer una prueba con Alpine:

singularity exec docker://alpine:latest echo "Hola desde SingularityCE"

Salida esperada:

Hola desde SingularityCE

1.17 Descargar una imagen SIF local

En HPC suele ser preferible descargar una imagen una vez y luego ejecutarla muchas veces.

mkdir -p ~/containers
cd ~/containers

singularity pull debian-13.sif docker://debian:13

Ejecuta la imagen local:

singularity exec ~/containers/debian-13.sif cat /etc/os-release

1.18 Por qué conviene usar imágenes locales

Cuando ejecutas directamente una URL remota, SingularityCE puede necesitar acceder al registro remoto y usar caché. En servidores compartidos, NFS o clústeres, esto puede causar problemas de concurrencia o rendimiento.

Con una imagen .sif local controlas mejor cuándo descargas y cuándo ejecutas.

1.19 Caché de SingularityCE

Puedes inspeccionar la caché:

singularity cache list

Puedes limpiarla:

singularity cache clean

O limpiar sin pedir confirmación:

singularity cache clean --force

Normalmente la caché está bajo tu $HOME, en una ruta similar a:

~/.singularity/cache

Puedes moverla usando la variable de entorno:

mkdir -p /var/tmp/$USER/singularity-cache
export SINGULARITY_CACHEDIR="/var/tmp/$USER/singularity-cache"

Para hacerlo permanente:

cat <<'BASHRC_CACHE' >> ~/.bashrc

# Caché de SingularityCE en disco local
export SINGULARITY_CACHEDIR="/var/tmp/$USER/singularity-cache"
BASHRC_CACHE

1.20 Directorio temporal

SingularityCE también usa directorios temporales al construir o ejecutar contenedores.

export SINGULARITY_TMPDIR="/var/tmp/$USER/singularity-tmp"
mkdir -p "$SINGULARITY_TMPDIR"

Para hacerlo permanente:

cat <<'BASHRC_TMP' >> ~/.bashrc

# Directorio temporal de SingularityCE
export SINGULARITY_TMPDIR="/var/tmp/$USER/singularity-tmp"
BASHRC_TMP

1.21 HPC y NFS

Evita usar NFS, Lustre, GPFS o sistemas compartidos como directorio temporal para operaciones que requieran overlay, fakeroot o construcción intensiva. Es mejor usar almacenamiento local del nodo cuando sea posible.

1.22 Ejecutar comandos dentro de un contenedor

La forma más común de uso es:

singularity exec imagen.sif comando

Ejemplo:

singularity exec ~/containers/debian-13.sif uname -a

También puedes abrir una shell:

singularity shell ~/containers/debian-13.sif

Dentro de la shell verás un prompt de SingularityCE. Para salir:

exit

1.23 Ejecutar una imagen como programa

Algunas imágenes tienen un runscript. En ese caso puedes usar:

singularity run imagen.sif

Si la imagen no define un comportamiento por defecto interesante, suele ser más explícito usar exec.

1.24 Montar directorios del host

Para montar un directorio de forma explícita usa --bind o -B:

singularity exec \
  --bind /datos:/datos \
  ~/containers/debian-13.sif \
  ls -lah /datos

La sintaxis general es:

--bind ruta_host:ruta_contenedor

Ejemplo con una ruta de trabajo:

mkdir -p ~/trabajo-singularity

echo "archivo desde el host" > ~/trabajo-singularity/prueba.txt

singularity exec \
  --bind "$HOME/trabajo-singularity:/work" \
  ~/containers/debian-13.sif \
  cat /work/prueba.txt

1.25 Construir una imagen desde una receta .def

SingularityCE usa archivos de definición, normalmente con extensión .def.

Crea un ejemplo:

mkdir -p ~/singularity-recipes
cd ~/singularity-recipes

cat > debian-python.def <<'RECIPE'
Bootstrap: docker
From: debian:13

%post
    apt-get update
    apt-get install -y python3 python3-pip ca-certificates
    apt-get clean
    rm -rf /var/lib/apt/lists/*

%runscript
    echo "Python dentro del contenedor:"
    exec python3 --version
RECIPE

Construye la imagen:

sudo singularity build debian-python.sif debian-python.def

Ejecuta:

singularity run debian-python.sif

1.26 Por qué usamos sudo para construir

Dependiendo de la configuración de SingularityCE, construir imágenes puede requerir privilegios. En estaciones personales o servidores propios, usar sudo singularity build es común.

En un clúster HPC administrado, normalmente los usuarios no tienen sudo; en esos casos se suele construir la imagen en otra máquina y luego copiar el .sif al clúster.

1.27 Construcción sin root y fakeroot

SingularityCE puede soportar modos como --fakeroot, dependiendo de la configuración del sistema.

Verifica que tu usuario tenga rangos en /etc/subuid y /etc/subgid:

grep "^$USER:" /etc/subuid /etc/subgid || true

Si no aparecen entradas, puedes agregarlas con:

sudo usermod --add-subuids 100000-165535 "$USER"
sudo usermod --add-subgids 100000-165535 "$USER"

Cierra sesión y vuelve a entrar para que algunos cambios se apliquen correctamente.

Luego prueba:

singularity build --fakeroot debian-python.sif debian-python.def

1.28 Integración con GPU NVIDIA

Si tienes GPU NVIDIA y drivers instalados en el host, SingularityCE puede exponerlos dentro del contenedor con:

singularity exec --nv imagen.sif nvidia-smi

Ejemplo:

singularity exec --nv docker://nvidia/cuda:12.4.1-base-ubuntu22.04 nvidia-smi

--nv no instala el driver dentro del contenedor. Lo que hace es enlazar bibliotecas y dispositivos relevantes del host para que el contenedor pueda usar la GPU.

El driver NVIDIA debe estar funcionando en el host:

nvidia-smi

Si nvidia-smi no funciona en el host, tampoco esperes que funcione dentro del contenedor.

1.29 Integración con SLURM o entornos HPC

En un clúster con SLURM, normalmente usarías SingularityCE dentro de un job script.

#!/bin/bash
#SBATCH --job-name=singularity-test
#SBATCH --output=singularity-test.out
#SBATCH --error=singularity-test.err
#SBATCH --time=00:10:00
#SBATCH --cpus-per-task=2
#SBATCH --mem=2G

singularity exec /ruta/a/imagen.sif hostname
singularity exec /ruta/a/imagen.sif python3 --version

En un clúster real, evita que cada job descargue imágenes desde Internet. Es mejor preparar el .sif antes y guardarlo en una ruta compartida de solo lectura o en un directorio de proyecto.

1.30 Desinstalar SingularityCE instalado desde fuente

1.30.1 Desinstalar instalación directa (make install)

Si instalaste bajo /usr/local, puedes revisar primero la configuración:

singularity buildcfg

Como la instalación manual no queda registrada en apt, la desinstalación no se hace con apt remove.

Una estrategia conservadora es eliminar los archivos principales:

sudo rm -f /usr/local/bin/singularity
sudo rm -rf /usr/local/etc/singularity
sudo rm -rf /usr/local/libexec/singularity
sudo rm -rf /usr/local/var/singularity
sudo rm -rf /usr/local/share/doc/singularity-ce
sudo rm -rf /usr/local/share/man/man1/singularity*.1

Después verifica:

which singularity || true
singularity --version || true

Si compilaste en /usr/local/src, también puedes eliminar el árbol de código:

sudo rm -rf "/usr/local/src/singularity-ce-${SINGULARITY_VERSION}"
sudo rm -f "/usr/local/src/singularity-ce-${SINGULARITY_VERSION}.tar.gz"

1.30.2 Desinstalar instalación con paquete .deb de checkinstall

Si instalaste con checkinstall, primero identifica el nombre exacto del paquete:

dpkg -l | grep singularity

Normalmente bastará con:

sudo apt remove --purge -y singularity-ce
sudo apt autoremove -y

Si apt no lo encuentra por nombre, usa dpkg con el identificador real:

sudo dpkg -r singularity-ce

Verifica:

which singularity || true
singularity --version || true

1.31 Problemas comunes

1.31.1 go: command not found

Tu shell no tiene Go en el PATH.

echo "$PATH"

Asegúrate de tener esto en ~/.bashrc:

export GOPATH="$HOME/go"
export PATH="/usr/local/go/bin:$GOPATH/bin:$PATH"

Recarga:

source ~/.bashrc

1.31.2 Error por versión vieja de Go

Si la compilación falla indicando que la versión de Go es insuficiente, instala una versión más reciente desde los binarios oficiales de Go.

No extraigas una versión nueva encima de /usr/local/go sin borrar la anterior. Haz:

sudo rm -rf /usr/local/go

Y luego instala la nueva.

1.31.3 Falta libsubid-dev

En Debian 13 conviene instalarlo:

sudo apt install -y libsubid-dev

Luego vuelve a ejecutar:

./mconfig --prefix=/usr/local

1.31.4 singularity: command not found después de instalar

Verifica si el binario existe:

ls -l /usr/local/bin/singularity

Si existe, probablemente /usr/local/bin no está en tu PATH.

Temporalmente:

export PATH="/usr/local/bin:$PATH"

Permanentemente:

cat <<'BASHRC_LOCALBIN' >> ~/.bashrc

# Binarios locales
export PATH="/usr/local/bin:$PATH"
BASHRC_LOCALBIN

source ~/.bashrc

1.31.5 Problemas con NFS, Lustre, GPFS o PanFS

Si estás en HPC, evita usar sistemas de archivos compartidos para:

• SINGULARITY_TMPDIR
• SINGULARITY_CACHEDIR
• overlays de escritura
• sandboxes con --fakeroot
• builds intensivos

Usa almacenamiento local del nodo cuando esté disponible.

export SINGULARITY_TMPDIR="/scratch/$USER/singularity-tmp"
export SINGULARITY_CACHEDIR="/scratch/$USER/singularity-cache"
mkdir -p "$SINGULARITY_TMPDIR" "$SINGULARITY_CACHEDIR"

1.31.6 Error al construir imágenes sin sudo

Prueba construir con sudo:

sudo singularity build imagen.sif receta.def

O configura fakeroot correctamente con /etc/subuid y /etc/subgid.

1.31.7 Docker fue removido al instalar runc (cómo restaurarlo)

Si al instalar dependencias viste algo como:

ELIMINANDO:
  containerd.io docker-ce

entonces apt resolvió un conflicto entre runc (repos Debian) y paquetes de Docker CE (repositorio oficial de Docker).

Para restaurar Docker:

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker
sudo docker version
sudo docker run --rm hello-world

Si falla porque falta el repositorio de Docker, vuelve a configurarlo:

sudo apt update
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo $VERSION_CODENAME) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Para evitar repetir el problema, omite runc en la instalación base de dependencias de SingularityCE y úsalo sólo si realmente necesitas el modo OCI.

1.31.8 checkinstall falla con mkdir ... El fichero ya existe

Si checkinstall falla durante make install con un error similar a:

mkdir: cannot create directory '...': El fichero ya existe

y ya verificaste que el directorio realmente no existe, suele ser un problema de installwatch (interno de checkinstall), no del Makefile.

Ejecuta checkinstall con:

--fstrans=no

Ejemplo completo:

sudo checkinstall --fstrans=no --type=debian ... make -j1 install

1.31.9 Problemas descargando desde Docker Hub

Docker Hub aplica límites de descarga. Si haces muchas pruebas, puedes encontrar errores por rate limit.

Soluciones:

• Autenticarse contra Docker Hub si corresponde.
• Usar un registry propio.
• Descargar una vez con singularity pull y reutilizar el .sif.
• Evitar que muchos jobs de SLURM descarguen la misma imagen al mismo tiempo.

1.32 Checklist final

Ejecuta este bloque para verificar la instalación:

set -e

printf '\n[1] Binario:\n'
which singularity

printf '\n[2] Versión:\n'
singularity --version

printf '\n[3] Configuración de build:\n'
singularity buildcfg | sed -n '1,25p'

printf '\n[4] Prueba con Alpine:\n'
singularity exec docker://alpine:latest echo "SingularityCE funciona"

printf '\n[5] Caché:\n'
singularity cache list || true

Si todo funciona, la instalación está lista para uso básico.

1.33 Recomendaciones operativas

Para una estación de trabajo personal:

• Instala bajo /usr/local.
• Usa imágenes .sif locales.
• Mantén una carpeta ~/containers.
• Limpia la caché periódicamente.

Para un servidor multiusuario:

• Documenta la versión instalada.
• Evita instalar desde la rama main.
• Usa almacenamiento local para caché y temporales.
• Evalúa cuidadosamente si necesitas instalación setuid.
• Define políticas de bind mounts.
• Considera cuotas de disco para cachés de usuarios.

Para HPC:

• No descargues imágenes dentro de cada job.
• Construye imágenes fuera del clúster o en nodos designados.
• Publica imágenes .sif versionadas.
• Usa rutas locales para temporales.
• Evita overlays de escritura sobre NFS/Lustre/GPFS.
• Coordina con el administrador del clúster antes de cambiar configuración global.

1.34 Fuentes consultadas

• Documentación oficial de instalación de SingularityCE: https://docs.sylabs.io/guides/main/admin-guide/installation.html
• Releases oficiales de SingularityCE en GitHub: https://github.com/sylabs/singularity/releases
• Documentación oficial de instalación de Apptainer: https://apptainer.org/docs/admin/main/installation.html
• Búsqueda de paquetes Debian para Apptainer: https://packages.debian.org/apptainer

1.35 Resumen ejecutivo

En Debian 13, la vía más limpia para instalar SingularityCE es compilar desde código fuente usando una versión etiquetada. El proceso consiste en:

1. Instalar dependencias con apt.
2. Instalar una versión reciente de Go.
3. Descargar el tarball oficial singularity-ce-X.Y.Z.tar.gz.
4. Ejecutar ./mconfig --prefix=/usr/local.
5. Compilar con make.
6. Instalar con sudo make install.
7. Verificar con singularity --version y singularity exec docker://alpine:latest ....

Si tu prioridad no es usar Sylabs SingularityCE específicamente, sino tener una herramienta compatible tipo Singularity en Debian 13, considera seriamente Apptainer, porque publica paquetes .deb específicos para Trixie.

2. Instalación de Apptainer

2.1 Alternativa: instalar Apptainer en Debian 13

Si no necesitas específicamente SingularityCE de Sylabs, Apptainer puede ser una alternativa más directa en Debian 13.

Apptainer publica paquetes .deb específicos para Trixie. Un ejemplo de instalación no setuid sería:

sudo apt update
sudo apt install -y wget
cd /tmp

wget https://github.com/apptainer/apptainer/releases/download/v1.5.0/apptainer_1.5.0-trixie+_amd64.deb

sudo apt install -y ./apptainer_1.5.0-trixie+_amd64.deb

Verifica:

apptainer --version

Prueba:

apptainer exec docker://alpine:latest echo "Hola desde Apptainer"

2.2 Cuándo elegir Apptainer

Elige Apptainer si:

• Tu entorno HPC ya lo usa.
• Quieres paquetes .deb específicamente publicados para Debian 13.
• No dependes de funcionalidades o integración específica de Sylabs.
• Te da igual usar apptainer en vez de singularity como comando principal.

2.3 Instalar desde repositorios Debian

Primero, actualiza índices e instala Apptainer:

sudo apt update
sudo apt install -y apptainer

Si en tu entorno necesitas modo setuid (depende de tu política de seguridad y del clúster), instala también el paquete correspondiente si está disponible:

sudo apt install -y apptainer-suid

2.4 Verificación básica

Comprueba versión y prueba de ejecución:

apptainer --version
apptainer exec docker://alpine:latest echo "Apptainer funciona"

2.5 Configuración recomendada de caché y temporales

Para evitar problemas en sistemas compartidos (NFS/Lustre/GPFS), usa rutas locales para caché y temporales:

mkdir -p "$HOME/.cache/apptainer" "$HOME/.apptainer/tmp"
export APPTAINER_CACHEDIR="$HOME/.cache/apptainer"
export APPTAINER_TMPDIR="$HOME/.apptainer/tmp"

Si quieres hacerlo persistente en Bash:

cat <<'BASHRC_APPTAINER' >> ~/.bashrc
export APPTAINER_CACHEDIR="$HOME/.cache/apptainer"
export APPTAINER_TMPDIR="$HOME/.apptainer/tmp"
BASHRC_APPTAINER