# Docker y servidores

> Una página de la documentación de phonometry, en Markdown. Índice: https://docs.jmrp.io/phonometry/llms.txt

Canonical: https://docs.jmrp.io/phonometry/es/start/environments/docker/
Language: es
Alternate: https://docs.jmrp.io/phonometry/start/environments/docker/index.md
Version: phonometry 4.0.0
Install: pip install "phonometry[full]"
Unreleased: 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 Unreleased en https://github.com/jmrplens/phonometry/blob/main/CHANGELOG.md#unreleased
Author: José Manuel Requena Plens (https://orcid.org/0000-0003-1250-6212)
Published: 2026-11-11
Updated: 2026-11-18T01:01:07Z
License: MIT (https://github.com/jmrplens/phonometry/blob/main/LICENSE)
Summary: Ejecuta phonometry en un contenedor o un servidor: una imagen ligera con un entorno virtual, cualquier usuario, una raíz de solo lectura y ffmpeg para vídeos.

---

phonometry no necesita del sistema operativo nada más que Python en una imagen
[`python:*-slim`](https://hub.docker.com/_/python) 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](https://docs.docker.com/) 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](https://docs.jmrp.io/phonometry/es/start/getting-started/#desde-pypi-recomendada) 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.

## Una imagen

```dockerfile
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:

```python
"""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()))
```

```bash
docker build -t acoustics .
mkdir -p out
docker run --rm --user "$(id -u):$(id -g)" -v "$PWD/out:/tmp/out" acoustics
```

```text
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](https://podman.io/docs) 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

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`.

## Vídeos

`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:

```dockerfile
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](https://docs.jmrp.io/phonometry/es/io/videos/) trata los codificadores y un nodo con GPU.

## Servidores e hilos

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](https://docs.jmrp.io/phonometry/es/simulation/remote-node/) trata una simulación
FDTD que el servidor no debe calcular por sí mismo.
