Ir al contenido

Docker y servidores

Esta página cambió después de phonometry 4.0.0, la última versión publicada en PyPI, así que puede describir código que esa versión aún no tiene. Lo nuevo desde entonces figura en la sección Unreleased del registro de cambios.

phonometry no necesita del sistema operativo nada más que Python en una imagen python:*-slim para x86-64 o ARM64 (linux/amd64, linux/arm64): todos los extras se instalan allí desde wheels, incluida la libsndfile que va dentro del wheel de soundfile. El único paquete del sistema que merece la pena añadir es ffmpeg, y solo para los vídeos. La misma etiqueta publica otras seis arquitecturas, y Docker descarga la del anfitrión: ARM de 32 bits (linux/arm/v5, linux/arm/v7), x86 de 32 bits (linux/386), linux/ppc64le, linux/riscv64 y linux/s390x. numba ya no da soporte a Linux de 32 bits, donde sus últimos wheels, de la 0.56.4, son para Python 3.10 como mucho, así que ni [perf] ni [full], que lo incluye, tienen soporte en las tres de 32 bits, donde python -m pip install "phonometry[plot,report,audio]" instala los otros tres extras. torch no publica wheel para ninguna de las seis ni código fuente que compilar, así que [torch] no se instala en ellas desde PyPI. PyPI no tiene para ninguna de las seis wheel de Python 3.13 de NumPy, SciPy, matplotlib ni Pillow, ni de numba con el llvmlite que necesita en linux/ppc64le, linux/riscv64 y linux/s390x, que numba solo atiende en la medida de lo posible, ni para algunas de ellas de contourpy, kiwisolver, cffi o lxml, así que pip los compila allí desde el código fuente, NumPy y SciPy incluso en una instalación normal. Eso pide lo que la imagen ligera deja fuera: un compilador de C y otro de C++ y los archivos de desarrollo de las bibliotecas que enlaza cada paquete, un compilador de Fortran con BLAS y LAPACK para SciPy, y para llvmlite LLVM 22 con cmake y make en el PATH. python-soundfile instala allí su wheel de Python puro, que carga la libsndfile del sistema: apt-get install libsndfile1. En linux/arm/v5, cuya ABI de coma flotante por software no cubre ningún wheel manylinux, las compilaciones de NumPy, SciPy y matplotlib piden además ninja y patchelf, y pip también los compilaría desde el código fuente, lo que ejecuta make y autoreconf, salvo que apt-get install ninja-build patchelf haya puesto los de la imagen en el PATH. Una imagen de Alpine, hecha sobre musl, necesita más, porque allí python-soundfile no tiene ningún wheel que lleve libsndfile y numba no tiene ninguno; Primeros pasos dice qué pide allí cada extra.

Comprobado el 17 de noviembre de 2026 con phonometry 4.0.0 de PyPI, con Docker 29.9.3 y la imagen python:3.13-slim fijada por el digest sha256:09a17cad02668ae61ece136b4fd36ac3849e14f670ebedb637ea3e15580525bc (Python 3.13.18): la imagen y el trabajo de abajo, como root, como otro identificador de usuario, como nobody y con la raíz de solo lectura.

FROM python:3.13-slim
RUN python -m venv /opt/venv \
&& /opt/venv/bin/python -m pip install --no-cache-dir --upgrade pip \
&& /opt/venv/bin/python -m pip install --no-cache-dir "phonometry[full]"
ENV PATH=/opt/venv/bin:$PATH MPLCONFIGDIR=/tmp/matplotlib
COPY analyse.py /app/analyse.py
WORKDIR /tmp
CMD ["python", "/app/analyse.py"]

El entorno virtual saca del registro de la construcción el aviso de pip sobre ejecutarse como root. analyse.py hace las veces de tu propio trabajo; este escribe un espectro en bandas, su figura y una ficha:

"""Un trabajo por lotes: un análisis en tercios de octava, su figura y una ficha."""
from pathlib import Path
import numpy as np
from phonometry import building, filters
out = Path("out")
out.mkdir(exist_ok=True)
fs = 48000
t = np.arange(2 * fs) / fs
x = 0.1 * np.sin(2 * np.pi * 1000 * t)
bands = filters.octave_filter(x, fs, fraction=3)
bands.plot().figure.savefig(out / "bands.png")
impulse = filters.time_weighting(x, fs, mode="impulse")
rating = building.weighted_rating(
[30, 34, 38, 41, 45, 49, 50, 53, 54, 55, 56, 57, 58, 58, 58, 58]
)
rating.report(out / "rating.pdf")
print(f"{len(bands.frequencies)} bands, impulse maximum {float(np.max(impulse)):.4f}")
print("wrote", sorted(p.name for p in out.iterdir()))
Ventana de terminal
docker build -t acoustics .
mkdir -p out
docker run --rm --user "$(id -u):$(id -g)" -v "$PWD/out:/tmp/out" acoustics
33 bands, impulse maximum 0.0092
wrote ['bands.png', 'rating.pdf']

El trabajo escribe en out bajo su directorio de trabajo, /tmp/out en el contenedor, y --rm borra el contenedor con sus archivos cuando el trabajo termina. El montaje -v lleva esa carpeta a tu máquina como out en el directorio desde el que lo ejecutas, donde la figura y la ficha se quedan. Con un demonio de Docker que se ejecuta como root, --user ejecuta el trabajo como tú, así que los archivos son tuyos y no de root. Crea antes la carpeta: la que ese demonio crea para el montaje pertenece a root, y el trabajo, que corre como tú, no puede escribir en ella.

Docker y Podman sin root (rootless) ya ejecutan el root del contenedor como tú, y llevan cualquier otro identificador de usuario del contenedor, el tuyo incluido, a un identificador subordinado de tu máquina que no puede escribir en tu out: ahí --user detiene el trabajo con un PermissionError. Quítalo, o pasa --userns=keep-id en Podman, y los archivos son tuyos. La carpeta creada antes sirve para los dos: Docker sin root crearía como tú una que faltase, y Podman se niega a montar una que no existe.

matplotlib elige por sí solo su backend Agg en un contenedor sin pantalla, así que nada tiene que fijar MPLBACKEND.

Cualquier usuario, cualquier sistema de archivos

Sección titulada «Cualquier usuario, cualquier sistema de archivos»

La imagen ejecuta el mismo trabajo como root, como un identificador de usuario cualquiera (docker run --user 12345:12345), como nobody y sobre un sistema de archivos raíz de solo lectura con un /tmp escribible (docker run --read-only --tmpfs /tmp). Una carpeta montada para los resultados tiene que ser escribible para el usuario con el que corre el trabajo, como lo es out para ti arriba. Dos cachés y un directorio deciden lo callado que lo hace:

  • MPLCONFIGDIR. matplotlib guarda su configuración y su caché bajo el directorio personal del usuario. Para un usuario sin directorio personal escribible imprime “Matplotlib created a temporary cache directory at …” cada vez que arranca; la línea ENV de arriba lo lleva a /tmp, y no dice nada.
  • La caché de numba. numba guarda el núcleo compilado de impulse junto al paquete o bajo el directorio personal. Donde no puede escribir en ninguno de los dos, compila el núcleo una vez en cada proceso y no dice nada. Con NUMBA_CACHE_DIR=/tmp/numba lo escribe ahí, para los procesos que vengan después en el mismo contenedor.
  • Una raíz de solo lectura. El trabajo necesita algún sitio donde escribir: aquí su directorio de trabajo, /tmp, que --tmpfs /tmp mantiene escribible, y la carpeta out montada dentro de él desde tu máquina. Sin ningún montaje escribible, el trabajo se detiene en su propio out.mkdir.

io.write_video y las funciones que escriben animaciones FDTD ejecutan ffmpeg. Instálalo desde los paquetes de la propia imagen antes del entorno virtual:

FROM python:3.13-slim
RUN apt-get update \
&& apt-get install -y --no-install-recommends ffmpeg \
&& rm -rf /var/lib/apt/lists/*
RUN python -m venv /opt/venv \
&& /opt/venv/bin/python -m pip install --no-cache-dir --upgrade pip \
&& /opt/venv/bin/python -m pip install --no-cache-dir "phonometry[full]"
ENV PATH=/opt/venv/bin:$PATH MPLCONFIGDIR=/tmp/matplotlib

WebM y MP4 se codifican entonces en la CPU, igual como nobody que sobre una raíz de solo lectura con un /tmp escribible. Escribir vídeos trata los codificadores y un nodo con GPU.

Un servidor que atiende peticiones en un grupo de hilos puede importar desde esos hilos los dominios que necesita, varios a la vez. Enviar una simulación a un nodo remoto trata una simulación FDTD que el servidor no debe calcular por sí mismo.