Blog · Guias de deploy

Como fazer deploy de um app Streamlit em 2026: um comando, HTTPS e um Dockerfile que fica com você

Pela equipe da Pethost · 25 de outubro de 2026 · 11 min de leitura

Você tem um app Streamlit que roda com streamlit run no seu notebook e quer colocá-lo no ar em um endereço com HTTPS, para pessoas que não têm Python. No Pethost, isso é um comando, pethost deploy, rodado na pasta que tem o requirements.txt. Ele escreve o Dockerfile, faz o build do app na sua máquina do Pethost e mostra o endereço dele. O app das primeiras páginas do próprio Streamlit ficou no ar em 52 segundos, e uma alteração posterior no código, em 3.

O que você precisa para fazer deploy de um app Streamlit em 2026

Três coisas: o app, o comando pethost e uma conta no Pethost.

O app aqui é aquele com que a documentação do Streamlit começa. O guia de instalação cria um ambiente virtual dentro da pasta do projeto e instala o Streamlit nele:

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

Depois, o streamlit_app.py, com o slider da primeira lição do Streamlit:

import streamlit as st

st.title("My app")

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

E o requirements.txt, a lista do que o app instala, com uma linha: streamlit.

O comando é um programa, instalado com uma linha. Todos os comandos dele estão na referência da CLI.

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

A conta precisa de um plano. Se você não entrou, o pethost deploy abre o seu navegador e faz o login. Se você ainda não tem um plano, ele mostra onde escolher um e espera.

Faça o deploy do app Streamlit com um comando

Vá até a pasta que tem o requirements.txt e rode pethost deploy. Esta é a tela inteira:

$ 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. Ele pergunta uma coisa O nome do projeto, a primeira palavra do endereço. O Enter aceita o nome da pasta.
2. Ele deixa o ambiente virtual de fora O .venv tinha 450 MB de pacotes, que a própria máquina instala.
3. A máquina não encontra nada para rodar A linha com o X: a pasta ainda não tem Dockerfile nem arquivo Compose.
4. O pethost escreve o Dockerfile O requirements.txt cita streamlit, então ele escreve o do Streamlit e envia a pasta de novo.
5. A máquina faz o build e inicia o app Ela vê o app escutar na 8501, manda o endereço HTTPS para lá, e o pethost mostra a resposta: 200.

O arquivo .pethost diz qual projeto é esta pasta. Faça o commit dele com o Dockerfile, e o próximo deploy não pergunta nada.

Abra o app: os widgets e o WebSocket

Uma página do Streamlit fala com o app por um WebSocket, /_stcore/stream: cada widget que você mexe passa por ele, e o script roda de novo no servidor. Quando isso falha, a página mostra o esqueleto de carregamento para sempre; a base de conhecimento do Streamlit põe a culpa no CORS ou em um proxy que corta os cabeçalhos do WebSocket.

No Pethost, nada foi configurado para isso. Em um navegador, o app foi desenhado em menos de um segundo, por wss://my-app.sam.pethost.app/_stcore/stream: “0 ao quadrado é 0” e, com o slider em 10, “10 ao quadrado é 100”. O health check do Streamlit também responde:

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

O pethost logs -f acompanha o que o app imprime. A “External URL” que o Streamlit imprime ali não está aberta para ninguém: o endereço é o HTTPS.

O Dockerfile que o pethost escreve para o Streamlit

Este é o arquivo como foi escrito na pasta, inteiro:

# 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"]

As primeiras linhas dizem o que o pethost leu na sua pasta:

• O Python é o 3.14, a não ser que o .python-version indique outro.
• Os pacotes vêm do requirements.txt pelo pip, cujos downloads ficam na sua máquina, ou do uv.lock pelo uv.
• O arquivo do app é o streamlit_app.py, o app.py ou o main.py, ou o único outro arquivo .py na raiz que importa o Streamlit.

O requirements.txt precisa citar streamlit. Um app feito para o Streamlit Community Cloud pode não ter essa linha, já que o Community Cloud instala o Streamlit sozinho; nesse caso, o pethost não escreve Dockerfile. Com a linha adicionada, esse app ficou no ar em 30 segundos.

Altere o código e faça deploy de novo em 3 segundos

Edite o app e rode o mesmo comando. Na primeira vez, levou 42 segundos: o arquivo copia a pasta antes do pip install, então uma linha alterada instala os pacotes de novo. O Dockerfile é seu, então copie o requirements.txt primeiro:

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

COPY . .

O deploy que alterou o arquivo levou 34 segundos. Depois dele, uma alteração no código pula a instalação:

$ 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 fazer deploy a cada push, conecte o repositório uma vez: pethost github sam/my-app. O pethost rollback coloca a versão anterior de volta. Um agente de IA pode fazer tudo isso pelo servidor MCP do Pethost: como um agente faz o deploy de um projeto e cuida dele.

Faça deploy de um app Streamlit que lê um CSV

A maioria dos apps Streamlit mostra dados, muitas vezes de um arquivo ao lado do código. Este lê a tabela dos pinguins de Palmer uma vez, guarda com st.cache_data e faz o gráfico da ilha escolhida em uma caixa de seleção:

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

Com streamlit e pandas no requirements.txt, o mesmo comando empacotou os 3 arquivos, 15 KB, e o app ficou no ar em 27 segundos. O CSV foi junto com a pasta, e o caminho que funciona no seu notebook funciona na máquina. No navegador, escolher Dream redesenhou a contagem, o gráfico e a tabela.

A máquina está sempre ligada, então o que o st.cache_data guarda continua quente para o próximo visitante, e ninguém espera o app acordar. Um arquivo que o app escreve enquanto roda se perde quando um deploy cria um container novo. Guarde o que precisa durar em um banco de dados: um Postgres é um clique, sem custo extra.

Guarde a chave de API no .env, não no código

Uma chave de API não deve ficar nem no código nem no Git. Este app pergunta à API da NASA quais asteroides passam pela Terra em um dia escolhido em um campo de data. No notebook, o python-dotenv lê a chave do .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"]},
)

O .env tem uma linha, NASA_API_KEY=DEMO_KEY, a chave da NASA para experimentar a API (o api.nasa.gov dá a sua própria em troca de um nome e um e-mail). O primeiro deploy leva o .env junto:

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

A página disse que 8 asteroides passam pela Terra em 20 de outubro de 2026, e 10 no dia 21, depois de alterada a data. A partir daí, o .env do projeto fica na máquina, e uma alteração no arquivo do seu notebook fica no notebook. O próximo deploy avisa:

$ 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

O pethost env set altera uma variável e faz o deploy na hora. Só o nome, pethost env set NASA_API_KEY, pede o valor sem mostrá-lo. O Streamlit também lê as opções dele de variáveis:

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

O app iniciou de novo sem a linha sobre estatísticas de uso. O pethost env push envia o seu .env inteiro, e antes cita cada variável que o arquivo do projeto perderia, e pergunta.

O st.secrets lê o .streamlit/secrets.toml, não o ambiente. Uma pasta enviada com pethost deploy leva esse arquivo junto, e o st.secrets funcionou na máquina. Um repositório não deve guardá-lo, então um app com deploy a partir do GitHub mantém as chaves no .env.

Faça deploy do Dockerfile do tutorial de Docker do Streamlit

Se você seguiu o tutorial do Streamlit “Deploy Streamlit using Docker”, sua pasta já tem o Dockerfile dele. Mantenha-o: o pethost faz o deploy do Dockerfile da própria pasta como ele está. Aqui está o do tutorial, com COPY . . no lugar do git clone, como o tutorial diz para código ao lado do 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.

A espiral do tutorial redesenhou o gráfico conforme os sliders se moviam. O docker run -p 8501:8501 dele não tem papel aqui: a máquina encontra a porta e não abre nada além do HTTPS. O HEALTHCHECK roda, e o Docker considerou o container saudável.

Use seu próprio domínio no app Streamlit

Qualquer nome sob o domínio da sua conta funciona na hora, com HTTPS. Um domínio seu é um comando, pethost domain add dashboard.example.com, que mostra o registro CNAME a criar; o certificado vem assim que o nome resolve.

O que você leva pelo preço

O Pethost custa € 9,99 por mês por tudo o que você hospeda, com 2 vCPU, 3 GB de memória e 30 GB de disco. Um dashboard raramente está sozinho: o job que alimenta os dados dele, o banco de dados e o seu próximo app rodam ao lado, sem taxa por projeto.

• € 9,99 por mês por todos os seus projetos, nada medido por uso
• 52s para fazer o build e iniciar o primeiro app
• 3s para fazer o deploy de uma alteração no código

O que já está feito para você: HTTPS com certificados que se renovam sozinhos, deploys a partir do GitHub, backups noturnos guardados por 14 dias, SSH em qualquer container e cada requisição contada, sem script nas suas páginas. Os planos estão na parte de preços da página inicial.

As telas são deploys em uma máquina de teste nossa, com o pethost 0.2.4, o Streamlit 1.66.1 e o Python 3.14.9 (3.12.15 no Dockerfile do tutorial). O my-app teve o deploy feito primeiro; os apps do CSV e da chave de API encontraram a imagem do Python 3.14 já na máquina. A conta nelas é a de exemplo, sam.

1. Streamlit: instalar o Streamlit pela linha de comando
2. Streamlit: conceitos básicos
3. Streamlit: fazer deploy do Streamlit com Docker
4. Streamlit: o app não carrega quando roda remotamente
5. Streamlit: gerenciamento de segredos
6. Streamlit: dependências do app no Community Cloud
7. NASA: APIs abertas
8. Pinguins de Palmer: os dados
9. pethost, a linha de comando do Pethost