---
title: "Como fazer deploy de um app PHP em 2026"
description: "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."
---

[Blog](https://pethost.dev/pt/blog/) · Guias de deploy

# Como fazer deploy de um app PHP em 2026: Laravel, Symfony ou páginas PHP puras com um comando

Pela equipe da Pethost · 24 de outubro de 2026 · Atualizado em 28 de outubro de 2026 · 12 min de leitura

Você tem um app PHP que roda no seu notebook: um projeto Laravel, um Symfony ou uma pasta de páginas `.php`. Você quer colocá-lo no ar com HTTPS, sem configurar um servidor. No Pethost, isso é um comando, `pethost deploy`, rodado na pasta do app: ele escreve o Dockerfile, faz o build do app na sua máquina Pethost e mostra o endereço dele. Um projeto recém-criado com `laravel new` teve o build feito e foi iniciado em 1 minuto e 29 segundos, e uma pasta com duas páginas em 12 segundos.

**Em resumo**

- **Um comando:** `pethost deploy` na pasta que tem o `composer.json`, ou o `index.php` no caso de páginas puras. Não há arquivo de configuração para escrever.
- **Laravel e Symfony** rodam no FrankenPHP com PHP 8.4. O pethost roda `composer install`, faz o build dos assets do Vite e inicia o app em modo de produção.
- **Páginas PHP puras** rodam no Apache, com os seus arquivos `.htaccess` e o `mod_rewrite`.
- **O banco SQLite do Laravel** fica guardado em um volume e recebe as migrations a cada início, então um novo deploy mantém os dados.
- **O preço:** € 9,99 por mês por 2 vCPU, 3 GB e 30 GB, para todos os seus projetos. Não existe plano gratuito.

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

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

**O app** é uma pasta no seu computador: aqui, um projeto criado pelo `laravel new`, um skeleton do Symfony com uma página e duas páginas de PHP puro. Você não precisa de Docker no seu computador: a imagem é construída na sua máquina Pethost.

**O comando** é um programa só, 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 estiver logado, o `pethost deploy` abre o seu navegador e faz o login. Se você ainda não tiver um plano, ele mostra onde escolher um e espera.

## Faça o deploy de um app Laravel

O app é o que o instalador do Laravel deixa pronto: `laravel new example-app`, sem starter kit, com SQLite como banco de dados, Pest, e o `npm install` e o build que o instalador roda. Entre na pasta dele e rode `pethost deploy`. Esta é a tela inteira:

```
$ cd example-app
$ pethost deploy
Name it [example-app]:      it will live at https://example-app.sam.pethost.app
✓ Packed 10.4k files, 51 MB   (left out node_modules · took .env from this folder)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Laravel project detected, wrote Dockerfile and .dockerignore.
~ The database starts empty on the machine and is migrated at each start: pethost run -- php artisan db:seed --force fills it from the project's seeders.
✓ Packed 10.4k files, 51 MB   (left out node_modules · took .env from this folder)
✓ Uploaded straight to your machine
✓ Built and started in 1 min 29 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80, a named volume at /app/storage/app
✓ app listens on 80 → https://example-app.sam.pethost.app
  It answers 200.

https://example-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 dele. O Enter aceita o nome da pasta.
2. **A máquina não encontra nada para rodar** A linha com o X é a resposta dela: um projeto roda a partir de um Dockerfile ou de um arquivo Compose, e a pasta ainda não tem nenhum dos dois.
3. **O pethost escreve o Dockerfile** O `composer.json` exige o `laravel/framework`, então ele escreve o do Laravel e envia a pasta de novo.
4. **A máquina faz o build e o inicia** Depois o pethost acessa o endereço e mostra a resposta: 200, a página de boas-vindas do Laravel.

O seu `.env`, com o `APP_KEY`, virou o do próprio projeto na máquina. O `.pethost` diz qual projeto é esta pasta: faça o commit dele junto com o Dockerfile, e o próximo deploy não pergunta nada.

### O Dockerfile que o pethost escreve para o Laravel

Estas são as linhas que importam do arquivo escrito na pasta. As 54 linhas dele dizem em comentários por que cada passo está ali:

```
# check=skip=JSONArgsRecommended
# Written by pethost deploy for this Laravel project: composer.json requires
# laravel/framework, package.json builds the assets with "vite build", npm installs it
# (package-lock.json), its SQLite database is kept in storage/app, with the files the
# site is given, it runs in production mode, set over the folder's .env.
# It is yours now: change it as you like. pethost does not write it again.

FROM dunglas/frankenphp:1-php8.4
…
COPY . .

RUN composer install
…
RUN npm run build

ENV DB_DATABASE=/app/storage/app/database.sqlite
# The machine keeps this directory across deploys.
VOLUME /app/storage/app
EXPOSE 80
…
CMD export APP_ENV=production APP_DEBUG=false LOG_CHANNEL=stderr DB_DATABASE=/app/storage/app/database.sqlite && \
    php artisan migrate --force && \
    exec frankenphp run --config /etc/frankenphp/Caddyfile
```

- **O servidor** é o FrankenPHP, construído sobre o Caddy, com PHP 8.4. O app sabe que roda atrás de HTTPS, então as URLs que o Laravel escreve começam com `https://`. As extensões que o `composer.json` exige como `ext-…` são instaladas.
- **O modo de produção** é definido no início, por cima do `.env` do seu notebook, e os logs vão para a saída do container, onde o `pethost logs` os lê.
- **O arquivo SQLite** fica em `storage/app`, que a máquina guarda em um volume entre os deploys, e as migrations rodam antes de o servidor iniciar.

## Rode comandos do artisan na máquina

O `pethost run` roda um comando no container do app. Aqui, as próprias migrations do Laravel, depois de três deploys:

```
$ pethost run -- php artisan migrate:status
example-app (.pethost)

  Migration name .............................................. Batch / Status
  0001_01_01_000000_create_users_table ............................... [1] Ran
  0001_01_01_000001_create_cache_table ............................... [1] Ran
  0001_01_01_000002_create_jobs_table ................................ [1] Ran
```

As três estão no batch 1: rodaram no primeiro início, e o banco de dados passou intacto pelos dois deploys seguintes. O `pethost run -- php artisan db:seed --force` preenche o banco a partir dos seus seeders, como dizia a linha com o til, e o `pethost shell` abre um shell para o `php artisan tinker`.

Um projeto Laravel cujo `.env` aponta para MySQL ou Postgres não recebe Dockerfile, já que o banco de dados precisa rodar ao lado dele. O pethost avisa:

```
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
  .env names a database other than SQLite (DB_CONNECTION=pgsql), and the machine runs none beside a Dockerfile: the project needs a compose.yaml with the site and its database.
```

Um `compose.yaml` com o app e o banco de dados dele roda como está escrito. Ou crie um banco de dados com um clique, sem custo extra, e conecte-o ao app: um MariaDB para um app feito para MySQL, ou um Postgres ([Postgres a preço fixo](https://pethost.dev/pt/blog/european-hosting-postgres-flat-price/)).

## Faça o deploy de um app Symfony

O app é o skeleton do Symfony, `composer create-project symfony/skeleton my-project` (o mesmo que `symfony new my-project`), com o controller do “Create your First Page” do Symfony: `src/Controller/LuckyController.php`, cuja rota `/lucky/number` responde um número aleatório. O mesmo comando faz o deploy:

```
$ cd my-project
$ pethost deploy
Name it [my-project]:        it will live at https://my-project.sam.pethost.app
✓ Packed 1.7k files, 7.9 MB   (took .env from this folder)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Symfony project detected, wrote Dockerfile and .dockerignore.
✓ Packed 1.7k files, 7.9 MB   (took .env from this folder)
✓ Uploaded straight to your machine
✓ Built and started in 57 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80
✓ app listens on 80 → https://my-project.sam.pethost.app
  It answers 404.

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

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

A resposta é 404 porque o app não tem rota em `/`, e em produção o Symfony não mostra página de boas-vindas. Acesse a rota que existe:

```
$ curl https://my-project.sam.pethost.app/lucky/number
<html><body>Lucky number: 27</body></html>
```

O Dockerfile do Symfony é o do Laravel sem o Node e sem o banco de dados. O `APP_ENV=prod` é definido para o `composer install`, que aquece o cache, e no início, por cima do `.env` que o Symfony coloca no commit com `APP_ENV=dev`. Os assets do AssetMapper são compilados no build. Um projeto com entidades do Doctrine em `src/Entity` não recebe Dockerfile: ele precisa de um `compose.yaml` com o banco de dados dele.

## Faça o deploy de páginas PHP puras

Sem framework e sem Composer: uma pasta com o `index.php`, que mostra um formulário, e o `hello.php`, que lê `$_POST['name']` e diz olá.

```
$ cd my-site
$ pethost deploy
Name it [my-site]:              it will live at https://my-site.sam.pethost.app
✓ Packed 2 files, 604 B
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ PHP site detected, wrote Dockerfile.
~ Every file of the folder is public at its address, but for the Dockerfile and names that begin with a dot.
✓ Packed 3 files, 1 KB
✓ Uploaded straight to your machine
✓ Built and started in 12 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80
✓ app listens on 80 → https://my-site.sam.pethost.app
  It answers 200.

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

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

```
$ curl -d name=Sam https://my-site.sam.pethost.app/hello.php
…
  <p>Hello, Sam!</p>
```

O Dockerfile é a imagem oficial do PHP, `php:8.4-apache`, servindo a pasta, com as configurações de produção do PHP. Os arquivos `.htaccess` funcionam, com o `mod_rewrite` ativado. Leia a linha com o til: todos os arquivos da pasta são públicos, então um segredo vai nas variáveis do projeto. Páginas que abrem um banco de dados com `mysqli` ou `PDO` precisam de um `compose.yaml` com ele, e o pethost avisa.

## Altere o código e faça o deploy de novo

Adicione uma rota em `routes/web.php` e rode o mesmo comando:

```
Route::get('/hello', function () {
    return 'Hello from Laravel!';
});
```

```
$ pethost deploy
example-app (.pethost)
✓ Packed 10.4k files · uploaded · built and started in 48 s
  · kept the project's .env in place of the version's own: after the first deploy the project's is kept
  · wrote compose.yaml for the Dockerfile: the service app, reading .env, port 80, a named volume at /app/storage/app
  · kept the project's x-pethost
  It answers 200.
https://example-app.sam.pethost.app
To send this folder's .env:  pethost env push
```

Repare na segunda linha: depois do primeiro deploy, a máquina mantém o `.env` do projeto, não o do seu notebook. O `pethost env set` altera uma variável e faz o deploy na hora:

```
$ pethost env set APP_URL=https://example-app.sam.pethost.app
example-app (.pethost)
✓ /.env has APP_URL now. Deployed in 48 s.
```

Só o nome pede um segredo sem mostrá-lo: `pethost env set MAIL_PASSWORD`. O `pethost github sam/example-app` faz o deploy de cada push dali em diante, e o `pethost rollback` coloca de volta a versão anterior. 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/).

## Use seu próprio domínio no app PHP

Todo nome sob o domínio da sua conta funciona na hora, com HTTPS. Um domínio seu leva um comando e um registro DNS:

```
pethost domain add www.example.com
```

Ele mostra o registro: um CNAME para o nome da sua máquina. O certificado chega assim que o nome resolve, e se renova sozinho.

## O que você recebe 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. Isso dá espaço para o app Laravel, o worker de fila dele, um banco de dados e o seu próximo projeto, [sem taxa por projeto](https://pethost.dev/pt/blog/unlimited-projects-flat-monthly-fee/) e sem nada medido. A máquina está sempre ligada, então um visitante [nunca espera um cold start](https://pethost.dev/pt/blog/always-on-hosting-no-cold-starts/).

- **€ 9,99** por mês por todos os seus projetos, nada medido
- **1min 29s** para fazer o build e iniciar um app Laravel novo, na primeira vez
- **12s** para uma pasta de páginas PHP

O que já vem 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 nenhum 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 com seu nome.** Sete projetos em uma máquina Starter: os apps com seus endereços e as requisições do último dia, os bancos de dados com os apps que os usam.

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

### O Pethost é a melhor escolha para

- **Desenvolvedores PHP com um app Laravel ou Symfony** que querem colocá-lo no ar sem administrar um servidor
- **Quem está saindo da hospedagem compartilhada** com uma pasta de páginas PHP e mais alguns projetos por vir
- **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 PHP sem escrever um Dockerfile?

Rode `pethost deploy` na pasta do app. Para um projeto Laravel ou Symfony, ou uma pasta com `index.php`, ele escreve o Dockerfile e faz o deploy. O arquivo fica na sua pasta para você alterar.

### Qual versão do PHP o Pethost roda?

Os Dockerfiles que o pethost escreve rodam PHP 8.4: no FrankenPHP para Laravel e Symfony, no Apache para páginas puras. A versão está na linha `FROM` do Dockerfile, que é seu.

### O banco SQLite do Laravel sobrevive a um novo deploy?

Sim. O arquivo fica em `storage/app`, que a máquina guarda em um volume, e cada início roda `php artisan migrate --force`. Dois deploys depois, as migrations ainda mostravam o batch 1.

### Dá para fazer deploy de um app Laravel com MySQL ou Postgres?

Sim, com um `compose.yaml` que roda o app ao lado do banco de dados: o pethost não escreve Dockerfile para ele, e avisa. Ou conecte o app a um banco de dados criado com um clique, sem custo extra: um MariaDB para um app feito para MySQL, ou um Postgres.

### Quanto custa hospedar um app PHP 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: um projeto criado pelo instalador do Laravel 5.32.0 (Laravel 13.38.0), o skeleton do Symfony 8.1.9 e duas páginas de PHP puro, todos com PHP 8.4.27. O deploy do Laravel veio primeiro; o do Symfony usou a imagem do FrankenPHP que ele tinha baixado. A conta nelas é a de exemplo, `sam`.

1. [Laravel: instalação](https://laravel.com/docs/13.x/installation)
2. [Laravel: deploy](https://laravel.com/docs/13.x/deployment)
3. [Symfony: instalação e configuração do framework](https://symfony.com/doc/current/setup.html)
4. [Symfony: crie sua primeira página](https://symfony.com/doc/current/page_creation.html)
5. [FrankenPHP: documentação](https://frankenphp.dev/docs/)
6. [PHP: a imagem oficial do Docker](https://hub.docker.com/_/php)
7. [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

- 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.
- 10 de outubro de 2026 [Como fazer deploy de um app React Router em 2026: o Dockerfile do template, um comando e HTTPS](https://pethost.dev/pt/blog/deploy-react-router-app/) Faça o deploy de um app React Router renderizado no servidor: o pethost deploy faz o build do Dockerfile do template e serve com HTTPS em 11 s, por € 9,99/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/)