---
title: "Como fazer deploy de um app Streamlit em 2026"
description: "Faça o deploy de um app Streamlit com um comando: o pethost deploy escreve o Dockerfile, roda streamlit run e serve o app com HTTPS, por € 9,99 por mês."
---

[Blog](https://pethost.dev/pt/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.

**Em resumo**

- **Um comando:** `pethost deploy` na pasta que tem o `requirements.txt`. Sem arquivo de configuração, sem porta para abrir, sem Docker no seu notebook.
- **O que ele faz:** escreve um Dockerfile que instala seus pacotes e roda `streamlit run streamlit_app.py`, e manda o endereço para a porta 8501.
- **Os widgets funcionam:** o WebSocket do Streamlit passa pelo proxy do Pethost, sem nada para configurar.
- **As chaves de API** ficam no `.env`, que o primeiro deploy leva junto; o `pethost env set` altera uma chave depois.
- **O preço:** € 9,99 por mês por 2 vCPU, 3 GB e 30 GB, para todos os projetos que você tiver. Não existe plano gratuito.

## 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](https://pethost.dev/docs/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](https://pethost.dev/pt/blog/hosting-for-ai-coding-agents/).

## 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](https://pethost.dev/pt/blog/always-on-hosting-no-cold-starts/). 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](https://pethost.dev/pt/blog/european-hosting-postgres-flat-price/).

## 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](https://pethost.dev/pt/blog/unlimited-projects-flat-monthly-fee/).

- **€ 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](https://pethost.dev/pt/#pricing) da página inicial.

**Cada projeto, identificado.** Sete projetos em uma máquina Starter: os apps com os endereços e as requisições do último dia, os bancos de dados com os apps que os usam.

![A página inicial do painel do Pethost: a CPU, a memória e o disco da máquina, e os projetos dela como cards.](https://pethost.dev/shots/projects.webp)

### O Pethost é a melhor escolha para

- **Quem trabalha com dados e tem um app Streamlit** para compartilhar com colegas ou clientes em um endereço próprio
- **Desenvolvedores solo** com vários dashboards, bots e projetos paralelos, e uma só fatura para pagar
- **Quem deixa o agente fazer o deploy**: o Claude Code ou o Codex coloca o app no ar e lê os logs dele
- **Startups no começo** que querem um custo mensal fixo enquanto o produto é pequeno

### Procure outra opção se

- Sua aplicação precisa de várias regiões ou de autoscaling

## Perguntas

### Como fazer deploy de um app Streamlit sem escrever um Dockerfile?

Rode `pethost deploy` na pasta que tem o `requirements.txt`. Ele escreve o Dockerfile que roda `streamlit run` e faz o deploy; o arquivo fica na sua pasta, e é seu para alterar.

### Por que meu app Streamlit no ar nunca termina de carregar?

A página fala com o app por um WebSocket em `/_stcore/stream` e, quando isso falha, mostra o esqueleto de carregamento para sempre. No Pethost, o WebSocket passa pelo proxy sem nada para configurar.

### Qual porta um app Streamlit usa no Pethost?

A do próprio Streamlit, 8501. A máquina encontra a porta em que o app escuta e manda o endereço HTTPS para lá: você não abre nada.

### Onde colocar as chaves de API de um app Streamlit em produção?

No `.env` do projeto, que o primeiro deploy leva da sua pasta; o `pethost env set NAME` altera uma chave sem mostrá-la, e o app lê `os.environ`. O `st.secrets` funciona para uma pasta enviada com o `secrets.toml` dela.

### Quanto custa hospedar um app Streamlit no Pethost?

€ 9,99 por mês no Starter, com 2 vCPU, 3 GB e 30 GB e sem taxa por projeto: seus outros apps e bancos de dados também rodam lá. Não existe plano gratuito. Os preços são sem IVA.

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](https://docs.streamlit.io/get-started/installation/command-line)
2. [Streamlit: conceitos básicos](https://docs.streamlit.io/get-started/fundamentals/main-concepts)
3. [Streamlit: fazer deploy do Streamlit com Docker](https://docs.streamlit.io/deploy/tutorials/docker)
4. [Streamlit: o app não carrega quando roda remotamente](https://docs.streamlit.io/knowledge-base/deploy/remote-start)
5. [Streamlit: gerenciamento de segredos](https://docs.streamlit.io/develop/concepts/connections/secrets-management)
6. [Streamlit: dependências do app no Community Cloud](https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/app-dependencies)
7. [NASA: APIs abertas](https://api.nasa.gov/)
8. [Pinguins de Palmer: os dados](https://allisonhorst.github.io/palmerpenguins/)
9. [pethost, a linha de comando do Pethost](https://pethost.dev/docs/cli/)

## Coloque seus projetos no ar hoje

Publique apps, bots e bancos de dados pelo seu agente, pelo GitHub ou pelo navegador, quantos couberem, a um preço fixo. Nada medido, nada cobrado à parte.

[Hospede tudo por € 9,99/mês](https://console.pethost.dev/)

## Continue lendo

- 24 de outubro de 2026 [Como fazer deploy de um app PHP em 2026: Laravel, Symfony ou páginas PHP puras com um comando](https://pethost.dev/pt/blog/deploy-php-app/) Faça deploy de um app PHP com um comando: o pethost deploy escreve o Dockerfile de Laravel, Symfony ou páginas PHP puras e o serve com HTTPS por € 9,99 por mês.
- 10 de outubro de 2026 [Como fazer deploy de um app Gin em 2026: um comando, HTTPS e um Dockerfile que fica com você](https://pethost.dev/pt/blog/deploy-gin-app/) Faça o deploy de um app Go Gin com um comando: o pethost deploy escreve o Dockerfile, faz o build do programa e o serve com HTTPS, por € 9,99 por mês.
- 10 de outubro de 2026 [Como fazer deploy de um app Go Fiber em 2026: um comando, HTTPS e um Dockerfile que fica com você](https://pethost.dev/pt/blog/deploy-fiber-app/) Faça o deploy de um app Go Fiber com um comando: o pethost deploy escreve o Dockerfile, faz o build em 45 segundos e o serve com HTTPS, por € 9,99 por mês.
- 10 de outubro de 2026 [Como fazer deploy de um app Nuxt em 2026: um comando, um servidor Node e HTTPS](https://pethost.dev/pt/blog/deploy-nuxt-app/) Faça o deploy de um app Nuxt 4 com um comando: o pethost deploy escreve o Dockerfile, roda o nuxt build e inicia o servidor Node com HTTPS, por € 9,99 por mês.

[Todos os artigos](https://pethost.dev/pt/blog/) · [Sobre a Pethost](https://pethost.dev/about/) · [Preços](https://pethost.dev/pt/#pricing)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/pt/templates/)
- [Sobre nós](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pt/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Termos](https://pethost.dev/terms/)
- [Privacidade](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bancos de dados

- [Postgres](https://pethost.dev/pt/postgres/)

Comparativos

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pt/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pt/blog/coolify-cloud-vs-dokploy-cloud/)
- [Preços Railway vs Render vs Fly.io](https://pethost.dev/pt/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hospedagem gerenciada de Docker Compose](https://pethost.dev/pt/blog/managed-docker-compose-hosting/)

Alternativas

- [Alternativas ao Railway](https://pethost.dev/pt/blog/railway-alternatives/)
- [Alternativas ao Heroku](https://pethost.dev/pt/blog/heroku-alternatives/)
- [Alternativas ao Dokploy](https://pethost.dev/pt/blog/dokploy-alternatives/)
- [Alternativas ao Coolify](https://pethost.dev/pt/blog/coolify-alternatives/)
- [Alternativas ao Render](https://pethost.dev/pt/blog/render-alternatives/)
- [Alternativas ao Sliplane](https://pethost.dev/pt/blog/sliplane-alternatives/)