Blog · Guías de despliegue

Cómo desplegar una app Streamlit en 2026: un comando, HTTPS y un Dockerfile que se queda contigo

Por el equipo de Pethost · 25 de octubre de 2026 · 11 min de lectura

Tienes una app Streamlit que funciona con streamlit run en tu equipo, y quieres ponerla en línea en una dirección con HTTPS, para gente que no tiene Python. En Pethost es un comando, pethost deploy, ejecutado en la carpeta que tiene requirements.txt. Él escribe el Dockerfile, construye la app en tu máquina de Pethost e imprime su dirección. La app de las primeras páginas de la documentación de Streamlit estuvo en línea en 52 segundos, y un cambio posterior en su código, en 3.

Qué necesitas para desplegar una app Streamlit en 2026

Tres cosas: la app, el comando pethost y una cuenta de Pethost.

La app aquí es aquella con la que empieza la documentación de Streamlit. Su guía de instalación crea un entorno virtual dentro de la carpeta del proyecto e instala Streamlit en él:

$ cd my-app
$ python -m venv .venv
$ source .venv/bin/activate
$ pip install streamlit

Después, streamlit_app.py, con el slider de la primera lección de Streamlit:

import streamlit as st

st.title("My app")

x = st.slider("x")  # 👈 this is a widget
st.write(x, "squared is", x * x)

Y requirements.txt, la lista de lo que instala la app, con una línea: streamlit.

El comando es un solo programa, que se instala con una línea. Todos sus comandos están en la referencia de la CLI.

curl -fsSL https://pethost.dev/install.sh | sh      # macOS, Linux
irm https://pethost.dev/install.ps1 | iex           # Windows, in PowerShell

La cuenta necesita un plan. Si no has iniciado sesión, pethost deploy abre tu navegador e inicia la sesión. Si aún no tienes plan, te muestra dónde elegir uno, y espera.

Despliega la app Streamlit con un comando

Ve a la carpeta que tiene requirements.txt y ejecuta pethost deploy. Esta es la pantalla entera:

$ pethost deploy
Name it [my-app]:                it will live at https://my-app.sam.pethost.app
✓ Packed 2 files, 131 B   (left out .venv)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Streamlit app detected, wrote Dockerfile and .dockerignore.
✓ Packed 4 files, 601 B   (left out .venv)
✓ Uploaded straight to your machine
✓ Built and started in 52 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 8501
✓ app listens on 8501 → https://my-app.sam.pethost.app
  It answers 200.

https://my-app.sam.pethost.app

Wrote .pethost (commit it). Next:   pethost logs -f   ·   pethost open

1. Pregunta una sola cosa El nombre del proyecto, que es la primera palabra de su dirección. Con Enter se queda el nombre de la carpeta.
2. Deja fuera el entorno virtual .venv tenía 450 MB de paquetes, que la máquina instala por sí misma.
3. La máquina no encuentra nada que ejecutar La línea con la cruz: la carpeta aún no tiene ni Dockerfile ni archivo de Compose.
4. pethost escribe el Dockerfile requirements.txt nombra streamlit, así que escribe el de Streamlit y vuelve a subir la carpeta.
5. La máquina lo construye y lo inicia Ve que la app escucha en el 8501, envía ahí la dirección HTTPS, y pethost imprime la respuesta: 200.

El archivo .pethost dice qué proyecto es esta carpeta. Haz commit de él junto con el Dockerfile, y el siguiente despliegue no pregunta nada.

Abre la app: los widgets y el WebSocket

Una página de Streamlit llega a la app por un WebSocket, /_stcore/stream: cada widget que mueves pasa por él, y el script se vuelve a ejecutar en el servidor. Cuando eso falla, la página muestra su esqueleto de carga para siempre; la base de conocimiento de Streamlit culpa a CORS, o a un proxy que quita las cabeceras del WebSocket.

En Pethost no hubo que configurar nada para ello. En un navegador la app se dibujó en menos de un segundo, por wss://my-app.sam.pethost.app/_stcore/stream: “0 squared is 0”, y con el slider movido a 10, “10 squared is 100”. El healthcheck de Streamlit también responde:

$ curl https://my-app.sam.pethost.app/_stcore/health
ok

pethost logs -f sigue lo que imprime la app. La “External URL” que Streamlit imprime ahí no está abierta para nadie: la dirección es la de HTTPS.

El Dockerfile que pethost escribe para Streamlit

Este es el archivo tal como se escribió en la carpeta, entero:

# Written by pethost deploy for this Streamlit app: Python 3.14 (no .python-version
# names another), pip installs it (requirements.txt), streamlit_app.py is what it starts
# with.
# It is yours now: change it as you like. pethost does not write it again.

FROM python:3.14
WORKDIR /app

COPY . .

RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

ENV PYTHONUNBUFFERED=1
EXPOSE 8501
CMD ["streamlit", "run", "streamlit_app.py"]

Sus primeras líneas dicen lo que pethost leyó en tu carpeta:

• El Python es el 3.14, salvo que .python-version nombre otro.
• Los paquetes vienen de requirements.txt con pip, cuyas descargas se quedan en tu máquina, o de uv.lock con uv.
• El archivo de la app es streamlit_app.py, app.py o main.py, o el único otro archivo .py de la raíz que importa Streamlit.

requirements.txt debe nombrar streamlit. Una app hecha para Streamlit Community Cloud puede omitirlo, porque Community Cloud instala Streamlit por sí mismo; en ese caso pethost no escribe ningún Dockerfile. Con la línea agregada, esa app estuvo en línea en 30 segundos.

Cambia el código y vuelve a desplegar en 3 segundos

Edita la app y ejecuta el mismo comando. La primera vez tardó 42 segundos: el archivo copia la carpeta antes de pip install, así que una sola línea cambiada vuelve a instalar los paquetes. El Dockerfile es tuyo, así que copia primero requirements.txt:

COPY requirements.txt .
RUN --mount=type=cache,target=/root/.cache/pip \
    pip install -r requirements.txt

COPY . .

El despliegue que cambió el archivo tardó 34 segundos. Después, un cambio en el código se salta la instalación:

$ pethost deploy
my-app (.pethost)
✓ Packed 5 files · uploaded · built and started in 3 s
…
  It answers 200.
https://my-app.sam.pethost.app

Para desplegar en cada push, conecta el repositorio una vez: pethost github sam/my-app. pethost rollback vuelve a poner la versión anterior. Un agente de IA puede hacer todo esto a través del servidor MCP de Pethost: cómo un agente despliega y cuida un proyecto.

Despliega una app Streamlit que lee un CSV

La mayoría de las apps Streamlit muestran datos, a menudo de un archivo junto al código. Esta lee una vez la tabla de los pingüinos de Palmer, la guarda con st.cache_data y dibuja la gráfica de la isla elegida en un cuadro de selección:

@st.cache_data
def load_data():
    return pd.read_csv("data/penguins.csv")

Con streamlit y pandas en requirements.txt, el mismo comando empaquetó sus 3 archivos, 15 KB, y la app estuvo en línea en 27 segundos. El CSV se fue con la carpeta, y el path que funciona en tu equipo funciona en la máquina. En el navegador, al elegir Dream se volvieron a dibujar el recuento, la gráfica y la tabla.

La máquina está siempre encendida, así que lo que guarda st.cache_data sigue caliente para el siguiente visitante, y nadie espera a que la app despierte. Un archivo que la app escribe mientras se ejecuta se pierde cuando un despliegue crea un contenedor nuevo. Guarda lo que deba durar en una base de datos: un Postgres está a un clic, sin pagar nada más.

Guarda la clave de API en .env, no en el código

Una clave de API no va ni en el código ni en Git. Esta app le pregunta a la API de la NASA qué asteroides pasan cerca de la Tierra el día elegido en un campo de fecha. En tu equipo, python-dotenv lee la clave de .env:

load_dotenv()  # the .env beside this file, when you run it on your laptop
…
answer = requests.get(
    "https://api.nasa.gov/neo/rest/v1/feed",
    params={"start_date": day, "end_date": day, "api_key": os.environ["NASA_API_KEY"]},
)

.env tiene una línea, NASA_API_KEY=DEMO_KEY, la clave de la NASA para probar la API (api.nasa.gov te da una propia a cambio de un nombre y un correo). El primer despliegue se lleva .env consigo:

$ pethost deploy
Name it [asteroids]:          it will live at https://asteroids.sam.pethost.app
✓ Packed 4 files, 863 B   (took .env from this folder)
…
✓ app listens on 8501 → https://asteroids.sam.pethost.app
  It answers 200.

La página dijo que 8 asteroides pasan cerca de la Tierra el 20 de octubre de 2026, y 10 el 21, una vez cambiada la fecha. A partir de ahí, el .env del proyecto vive en la máquina, y un cambio en el archivo de tu equipo se queda en tu equipo. El siguiente despliegue lo dice:

$ pethost deploy
asteroids (.pethost)
✓ Packed 6 files · uploaded · built and started in 38 s
  · kept the project's .env in place of the version's own: after the first deploy the project's is kept
…
To send this folder's .env:  pethost env push

pethost env set cambia una variable y despliega al momento. Con solo el nombre, pethost env set NASA_API_KEY, pide el valor sin mostrarlo. Streamlit también lee sus opciones de variables:

$ pethost env set STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
asteroids (.pethost)
✓ /.env has STREAMLIT_BROWSER_GATHER_USAGE_STATS now. Deployed in 39 s.

La app se volvió a iniciar sin su línea sobre las estadísticas de uso. pethost env push envía en cambio todo tu .env, y antes nombra cada variable que perdería el archivo del proyecto, y pregunta.

st.secrets lee .streamlit/secrets.toml, no el entorno. Una carpeta desplegada con pethost deploy se lleva ese archivo consigo, y st.secrets funcionó en la máquina. Un repositorio no debería contenerlo, así que una app desplegada desde GitHub guarda sus claves en .env.

Despliega el Dockerfile del tutorial de Docker de Streamlit

Si seguiste el tutorial de Streamlit “Desplegar Streamlit con Docker”, tu carpeta ya tiene su Dockerfile. Consérvalo: pethost despliega el Dockerfile propio de una carpeta tal como está. Este es el del tutorial, con COPY . . en lugar de su git clone, como dice el tutorial para el código que está junto al Dockerfile:

FROM python:3.12-slim

WORKDIR /app

RUN apt-get update && apt-get install -y …

COPY . .

RUN pip3 install -r requirements.txt

EXPOSE 8501

HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health

ENTRYPOINT ["streamlit", "run", "streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]

$ pethost deploy
Name it [spiral]:                it will live at https://spiral.sam.pethost.app
✓ Packed 3 files, 2 KB
✓ Uploaded straight to your machine
✓ Built and started in 1 min 25 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 8501
✓ app listens on 8501 → https://spiral.sam.pethost.app
  It answers 200.

La espiral del tutorial volvió a dibujar su gráfica al mover los sliders. Su docker run -p 8501:8501 no hace falta aquí: la máquina encuentra el puerto y no abre nada más que HTTPS. El HEALTHCHECK se ejecuta, y para Docker el contenedor quedó en buen estado.

Usa tu propio dominio para la app Streamlit

Cualquier nombre bajo el dominio de tu cuenta funciona al instante, con HTTPS. Un dominio que es tuyo es un comando, pethost domain add dashboard.example.com, que imprime el registro CNAME que hay que crear; el certificado llega en cuanto el nombre resuelve.

Lo que obtienes por el precio

Pethost cuesta 9,99 € al mes por todo lo que alojes, con 2 vCPU, 3 GB de memoria y 30 GB de disco. Un dashboard rara vez está solo: la tarea que rellena sus datos, su base de datos y tu próxima app se ejecutan a su lado, sin pagar por proyecto.

• 9,99 € al mes por todos tus proyectos, nada se mide por uso
• 52 s para construir e iniciar la primera app
• 3 s para desplegar un cambio en su código

Lo que ya está hecho por ti: HTTPS con certificados que se renuevan solos, despliegues desde GitHub, backups cada noche conservados 14 días, SSH a cualquier contenedor y cada petición contada, sin ningún script en tus páginas. Los planes están en la parte de precios de la página principal.

Las pantallas son despliegues en una máquina de pruebas nuestra, con pethost 0.2.4, Streamlit 1.66.1 y Python 3.14.9 (3.12.15 en el Dockerfile del tutorial). my-app se desplegó primero; las apps del CSV y de la clave de API encontraron la imagen de Python 3.14 ya en la máquina. La cuenta que aparece es la de ejemplo, sam.

1. Streamlit: instalar Streamlit desde la línea de comandos
2. Streamlit: conceptos básicos
3. Streamlit: desplegar Streamlit con Docker
4. Streamlit: la app no carga cuando se ejecuta en remoto
5. Streamlit: administración de secretos
6. Streamlit: dependencias de la app en Community Cloud
7. NASA: APIs abiertas
8. Palmer penguins: los datos
9. pethost, la línea de comandos de Pethost