---
title: "Comment déployer une application PHP en 2026 "
description: "Déployez une application PHP en une commande : pethost deploy écrit le Dockerfile pour Laravel, Symfony ou des pages PHP et la sert en HTTPS, pour 9,99 €/mois."
---

[Blog](https://pethost.dev/fr/blog/) · Guides de déploiement

# Comment déployer une application PHP en 2026 : Laravel, Symfony ou pages PHP simples en une commande

Par l’équipe Pethost · 24 octobre 2026 · Mis à jour le 28 octobre 2026 · 11 min de lecture

Vous avez une application PHP qui tourne sur votre ordinateur : un projet Laravel, un projet Symfony, ou un dossier de pages `.php`. Vous voulez la mettre en ligne en HTTPS, sans configurer de serveur. Sur Pethost, c’est une seule commande, `pethost deploy`, lancée dans le dossier de l’application : elle écrit le Dockerfile, construit l’application sur votre machine Pethost et affiche son adresse. Un projet tout juste sorti de `laravel new` a été construit et démarré en 1 minute 29 secondes, et un dossier de deux pages en 12 secondes.

**En bref**

- **Une commande :** `pethost deploy` dans le dossier qui contient `composer.json`, ou `index.php` pour des pages simples. Aucun fichier de configuration à écrire.
- **Laravel et Symfony** tournent sur FrankenPHP avec PHP 8.4. pethost lance `composer install`, construit les assets Vite et démarre l’application en mode production.
- **Les pages PHP simples** tournent sur Apache, avec vos fichiers `.htaccess` et `mod_rewrite`.
- **La base de données SQLite de Laravel** est gardée dans un volume et migrée à chaque démarrage : un nouveau déploiement garde donc les données.
- **Le prix :** 9,99 € par mois pour 2 vCPU, 3 GB et 30 GB, pour tous vos projets. Il n’y a pas d’offre gratuite.

## Ce qu’il faut pour déployer une application PHP en 2026

Trois choses : l’application, la commande `pethost` et un compte Pethost.

**L’application** est un dossier sur votre ordinateur : ici un projet créé par `laravel new`, un squelette Symfony avec une page, et deux pages de PHP simple. Docker n’est pas nécessaire sur votre ordinateur : l’image est construite sur votre machine Pethost.

**La commande** est un seul programme, installé par une ligne. Toutes ses commandes sont dans la [référence de la 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
```

**Le compte** a besoin d’une offre. Si vous n’êtes pas connecté, `pethost deploy` ouvre votre navigateur et vous connecte. Si vous n’avez pas encore d’offre, il vous montre où en choisir une, et attend.

## Déployer une application Laravel

L’application est celle que laisse l’installeur de Laravel : `laravel new example-app`, sans starter kit, avec SQLite comme base de données, Pest, et le `npm install` et le build que lance l’installeur. Allez dans son dossier et lancez `pethost deploy`. Voici l’écran entier :

```
$ 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. **Une seule question** Le nom du projet, le premier mot de son adresse. Entrée prend le nom du dossier.
2. **La machine ne trouve rien à lancer** La ligne avec la croix est sa réponse : un projet tourne à partir d’un Dockerfile ou d’un fichier Compose, et le dossier n’a encore ni l’un ni l’autre.
3. **pethost écrit le Dockerfile** `composer.json` requiert `laravel/framework` : pethost écrit donc celui de Laravel et envoie de nouveau le dossier.
4. **La machine le construit et le démarre** Puis pethost interroge l’adresse et affiche la réponse : 200, la page d’accueil de Laravel.

Votre `.env`, `APP_KEY` compris, est devenu celui du projet sur la machine. `.pethost` indique à quel projet correspond ce dossier : committez-le avec le Dockerfile, et le déploiement suivant ne demande plus rien.

### Le Dockerfile que pethost écrit pour Laravel

Voici les lignes qui comptent dans le fichier écrit dans le dossier. Ses 54 lignes disent en commentaire pourquoi chaque étape est là :

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

- **Le serveur** est FrankenPHP, construit sur Caddy, avec PHP 8.4. L’application sait qu’elle tourne derrière HTTPS : les URL qu’écrit Laravel commencent donc par `https://`. Les extensions que `composer.json` requiert sous la forme `ext-…` sont installées.
- **Le mode production** est fixé au démarrage, par-dessus le `.env` de votre ordinateur, et les logs vont vers la sortie du conteneur, où `pethost logs` les lit.
- **Le fichier SQLite** se trouve dans `storage/app`, que la machine garde dans un volume d’un déploiement à l’autre, et les migrations tournent avant le démarrage du serveur.

## Lancer des commandes artisan sur la machine

`pethost run` lance une commande dans le conteneur de l’application. Ici, les migrations de Laravel lui-même, après trois déploiements :

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

Les trois sont dans le batch 1 : elles ont tourné au premier démarrage, et la base de données a traversé les deux déploiements suivants. `pethost run -- php artisan db:seed --force` la remplit à partir de vos seeders, comme le disait la ligne au tilde, et `pethost shell` ouvre un shell pour `php artisan tinker`.

Un projet Laravel dont le `.env` nomme MySQL ou Postgres n’obtient pas de Dockerfile, puisque la base de données doit tourner à côté de l’application. pethost le dit :

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

Un `compose.yaml` avec l’application et sa base de données tourne tel qu’il est écrit. Vous pouvez aussi créer une base de données en un clic, sans supplément, et la connecter à l’application : une base MariaDB pour une application faite pour MySQL, ou une base Postgres ([Postgres à prix fixe](https://pethost.dev/fr/blog/european-hosting-postgres-flat-price/)).

## Déployer une application Symfony

L’application est le squelette de Symfony, `composer create-project symfony/skeleton my-project` (l’équivalent de `symfony new my-project`), avec le contrôleur du guide « Créer votre première page » de Symfony : `src/Controller/LuckyController.php`, dont la route `/lucky/number` répond un nombre au hasard. La même commande la déploie :

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

La réponse est 404 parce que l’application n’a pas de route sur `/`, et qu’en production Symfony n’affiche pas de page d’accueil. Interrogez la route qui existe :

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

Le Dockerfile de Symfony est celui de Laravel, sans Node ni base de données. `APP_ENV=prod` est fixé pour `composer install`, qui préchauffe le cache, et au démarrage, par-dessus le `.env` que Symfony committe avec `APP_ENV=dev`. Les assets d’AssetMapper sont compilés pendant le build. Un projet avec des entités Doctrine dans `src/Entity` n’obtient pas de Dockerfile : il lui faut un `compose.yaml` avec sa base de données.

## Déployer des pages PHP simples

Ni framework, ni Composer : un dossier avec `index.php`, qui affiche un formulaire, et `hello.php`, qui lit `$_POST['name']` et dit bonjour.

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

Le Dockerfile prend l’image officielle de PHP, `php:8.4-apache`, qui sert le dossier avec les réglages de production de PHP. Les fichiers `.htaccess` fonctionnent, avec `mod_rewrite` activé. Lisez la ligne au tilde : chaque fichier du dossier est public, un secret va donc dans les variables du projet. Les pages qui ouvrent une base de données avec `mysqli` ou `PDO` ont besoin d’un `compose.yaml` qui la contient, et pethost le dit.

## Modifier le code et redéployer

Ajoutez une route dans `routes/web.php` et lancez la même commande :

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

Notez la deuxième ligne : après le premier déploiement, la machine garde le `.env` du projet, pas celui de votre ordinateur. `pethost env set` change une variable et déploie aussitôt :

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

Un nom seul demande un secret sans l’afficher : `pethost env set MAIL_PASSWORD`. `pethost github sam/example-app` déploie ensuite chaque push, et `pethost rollback` remet en place la version précédente. Un agent IA peut faire tout cela par le serveur MCP de Pethost : [comment un agent déploie un projet et s’en occupe](https://pethost.dev/fr/blog/hosting-for-ai-coding-agents/).

## Utiliser votre propre domaine pour l’application PHP

Chaque nom sous le domaine de votre compte fonctionne aussitôt, en HTTPS. Un domaine à vous demande une commande et un enregistrement DNS :

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

Elle affiche l’enregistrement : un CNAME vers le nom de votre machine. Le certificat arrive dès que le nom pointe vers la machine, et se renouvelle tout seul.

## Ce que vous obtenez pour ce prix

Pethost coûte 9,99 € par mois pour tout ce que vous hébergez, sur 2 vCPU, 3 GB de mémoire et 30 GB de disque. C’est de la place pour l’application Laravel, son worker de file d’attente, une base de données et votre prochain projet, [sans frais par projet](https://pethost.dev/fr/blog/unlimited-projects-flat-monthly-fee/) et sans rien de facturé à l’usage. La machine est toujours allumée : un visiteur [n’attend jamais un démarrage à froid](https://pethost.dev/fr/blog/always-on-hosting-no-cold-starts/).

- **9,99 €** par mois pour tous vos projets, rien de facturé à l’usage
- **1 min 29 s** pour construire et démarrer une nouvelle application Laravel, la première fois
- **12 s** pour un dossier de pages PHP

Ce qui est déjà fait pour vous : HTTPS avec des certificats qui se renouvellent seuls, déploiements depuis GitHub, sauvegardes chaque nuit conservées 14 jours, SSH dans n’importe quel conteneur, et chaque requête comptée, sans script dans vos pages. Les offres sont dans la partie [tarifs](https://pethost.dev/fr/#pricing) de la page d’accueil.

**Chaque projet, bien identifié.** Sept projets sur une seule machine Starter : les applications avec leurs adresses et leurs requêtes du dernier jour, les bases de données avec les applications qui les utilisent.

![La première page de la console Pethost : le CPU, la mémoire et le disque de la machine, et ses projets sous forme de cartes.](https://pethost.dev/shots/projects.webp)

### Pethost est le meilleur choix pour

- **Les développeurs PHP avec une application Laravel ou Symfony** qui veulent la mettre en ligne sans gérer de serveur
- **Ceux qui quittent un hébergement mutualisé** avec un dossier de pages PHP et quelques projets de plus à venir
- **Ceux dont l’agent déploie à leur place** : Claude Code ou Codex met l’application en ligne et lit ses logs
- **Les jeunes startups** qui veulent un coût mensuel fixe tant que le produit est petit

### Cherchez ailleurs si

- Votre application a besoin de plusieurs régions ou d’autoscaling

## Questions

### Comment déployer une application PHP sans écrire de Dockerfile ?

Lancez `pethost deploy` dans le dossier de l’application. Pour un projet Laravel ou Symfony, ou un dossier avec `index.php`, la commande écrit le Dockerfile et le déploie. Le fichier reste dans votre dossier, et vous pouvez le modifier.

### Quelle version de PHP tourne sur Pethost ?

Les Dockerfiles qu’écrit pethost font tourner PHP 8.4 : sur FrankenPHP pour Laravel et Symfony, sur Apache pour les pages simples. La version est dans la ligne `FROM` du Dockerfile, qui est à vous.

### La base SQLite de Laravel survit-elle à un redéploiement ?

Oui. Le fichier est dans `storage/app`, que la machine garde dans un volume, et chaque démarrage lance `php artisan migrate --force`. Deux déploiements plus tard, les migrations étaient toujours dans le batch 1.

### Peut-on déployer une application Laravel avec MySQL ou Postgres ?

Oui, avec un `compose.yaml` qui fait tourner l’application à côté de sa base de données : pethost n’écrit pas de Dockerfile pour elle, et le dit. Vous pouvez aussi connecter l’application à une base de données créée en un clic, sans supplément : une base MariaDB pour une application faite pour MySQL, ou une base Postgres.

### Combien coûte l’hébergement d’une application PHP sur Pethost ?

9,99 € par mois pour Starter, avec 2 vCPU, 3 GB et 30 GB, sans frais par projet : vos autres applications et bases de données y tournent aussi. Il n’y a pas d’offre gratuite. Les prix sont hors TVA.

Les écrans sont des déploiements sur une de nos machines de test, avec pethost 0.2.4 : un projet créé par l’installeur de Laravel 5.32.0 (Laravel 13.38.0), le squelette de Symfony 8.1.9 et deux pages de PHP simple, le tout sur PHP 8.4.27. Le déploiement Laravel est venu en premier ; celui de Symfony a utilisé l’image FrankenPHP qu’il avait récupérée. Le compte qu’on y voit est celui de l’exemple, `sam`.

1. [Laravel : installation](https://laravel.com/docs/13.x/installation)
2. [Laravel : déploiement](https://laravel.com/docs/13.x/deployment)
3. [Symfony : installer et configurer le framework](https://symfony.com/doc/current/setup.html)
4. [Symfony : créer votre première page](https://symfony.com/doc/current/page_creation.html)
5. [FrankenPHP : documentation](https://frankenphp.dev/docs/)
6. [PHP : l’image Docker officielle](https://hub.docker.com/_/php)
7. [pethost, la ligne de commande de Pethost](https://pethost.dev/docs/cli/)

## Mettez vos projets en ligne dès aujourd’hui

Déployez applications, bots et bases de données depuis votre agent, GitHub ou le navigateur, autant qu’il en tient, à un prix fixe. Rien au compteur, rien facturé en plus.

[Tout héberger pour 9,99 €/mois](https://console.pethost.dev/)

## Continuer la lecture

- 10 octobre 2026 [Comment déployer une application Gin en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous](https://pethost.dev/fr/blog/deploy-gin-app/) Déployez une application Go Gin en une commande : pethost deploy écrit le Dockerfile, construit le programme et le sert en HTTPS, pour 9,99 € par mois.
- 10 octobre 2026 [Comment déployer une application Go Fiber en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous](https://pethost.dev/fr/blog/deploy-fiber-app/) Déployez une application Go Fiber en une commande : pethost deploy écrit le Dockerfile, la construit en 45 s et la sert en HTTPS, pour 9,99 € par mois.
- 10 octobre 2026 [Comment déployer une application Nuxt en 2026 : une commande, un serveur Node et HTTPS](https://pethost.dev/fr/blog/deploy-nuxt-app/) Déployez une application Nuxt 4 en une commande : pethost deploy écrit le Dockerfile, lance nuxt build et démarre le serveur Node en HTTPS, pour 9,99 €/mois.
- 10 octobre 2026 [Comment déployer une application React Router en 2026 : le Dockerfile du template, une commande et HTTPS](https://pethost.dev/fr/blog/deploy-react-router-app/) Déployez une application React Router rendue côté serveur : pethost deploy construit le Dockerfile du template et la sert en HTTPS en 11 s, pour 9,99 €/mois.

[Tous les articles](https://pethost.dev/fr/blog/) · [À propos de Pethost](https://pethost.dev/about/) · [Tarifs](https://pethost.dev/fr/#pricing)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Templates](https://pethost.dev/fr/templates/)
- [À propos](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/fr/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Conditions](https://pethost.dev/terms/)
- [Confidentialité](https://pethost.dev/privacy/)
- [Remboursements](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de données

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

Comparatifs

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/fr/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/fr/blog/coolify-cloud-vs-dokploy-cloud/)
- [Tarifs Railway vs Render vs Fly.io](https://pethost.dev/fr/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hébergement Docker Compose managé](https://pethost.dev/fr/blog/managed-docker-compose-hosting/)

Alternatives

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