---
title: "Comment déployer une application Nuxt en 2026 "
description: "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."
---

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

# Comment déployer une application Nuxt en 2026 : une commande, un serveur Node et HTTPS

Par l’équipe Pethost · 10 octobre 2026 · Mis à jour le 25 octobre 2026 · 8 min de lecture

Vous avez une application Nuxt qui tourne avec `npm run dev`, et vous voulez la mettre en ligne à une adresse en HTTPS, avec le rendu côté serveur. Sur Pethost, c’est une seule commande, `pethost deploy`, lancée dans le dossier qui contient `package.json`. Elle écrit le Dockerfile à votre place, lance `nuxt build` et démarre le serveur que le build a écrit. Le starter de Nuxt a été construit et démarré en 53 secondes la première fois.

**En bref**

- **Une commande :** `pethost deploy` dans le dossier qui contient `package.json`. Il n’y a ni preset à choisir, ni script de démarrage à ajouter.
- **Ce qu’elle fait :** elle trouve `nuxt` et le script qui lance `nuxt build`, écrit un Dockerfile qui l’exécute, et démarre `node .output/server/index.mjs`.
- **Le port :** le serveur Nuxt écoute sur le 3000. Pethost le trouve et y envoie l’adresse, en HTTPS.
- **L’adresse :** `https://nuxt-app.yourname.pethost.app`, d’emblée. Votre propre domaine, c’est un enregistrement DNS.
- **Le prix :** 9,99 € par mois pour 2 vCPU, 3 GB et 30 GB, pour cette application et tous vos autres projets. Il n’y a pas d’offre gratuite.

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

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

**L’application** est ici ce que laisse la page d’installation de Nuxt, avec le template minimal et npm :

```
npm create nuxt@latest nuxt-app
```

Elle écrit `nuxt.config.ts`, le dossier `app/` et un `package.json` avec ces scripts. Aucun n’est un script de démarrage, et aucun n’est nécessaire :

```
"scripts": {
  "build": "nuxt build",
  "dev": "nuxt dev",
  "generate": "nuxt generate",
  "preview": "nuxt preview",
  "postinstall": "nuxt prepare"
}
```

**La commande** est un seul programme, qui s’installe en 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, la commande vous montre où en choisir une, et attend.

## Déployer l’application Nuxt en une commande

Allez dans le dossier qui contient `package.json` et lancez `pethost deploy`. Voici l’écran entier, pour le starter :

```
$ cd nuxt-app
$ pethost deploy
Name it [nuxt-app]:    it will live at https://nuxt-app.sam.pethost.app
✓ Packed 45 files, 450 KB   (left out node_modules)
✓ Uploaded straight to your machine
✗ /compose.yaml: the project directory has no compose.yaml at its root: add one
✓ Nuxt project detected, wrote Dockerfile.
✓ Packed 46 files, 451 KB   (left out node_modules)
✓ Uploaded straight to your machine
✓ Built and started in 53 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env
✓ app listens on 3000 → https://nuxt-app.sam.pethost.app
  It answers 200.

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

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

1. **Elle demande une seule chose** Le nom du projet, qui est le premier mot de son adresse. Entrée prend le nom du dossier.
2. **La machine ne trouve rien à lancer** Le dossier part directement sur votre machine, sans `node_modules`. 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** Il a vu `nuxt` dans `package.json` et un script qui lance `nuxt build`, et envoie le dossier une deuxième fois.
4. **La machine le construit et le démarre** Elle voit que le serveur écoute sur le 3000 et y envoie l’adresse. Puis pethost interroge l’adresse elle-même, et affiche ce qu’elle a répondu : 200.

Le fichier `.pethost` indique quel projet est ce dossier. Committez-le avec le Dockerfile, et le prochain déploiement ne demande rien.

## Le Dockerfile que pethost écrit pour Nuxt

Voici le fichier tel qu’il a été écrit dans le dossier du starter, en entier :

```
# Written by pethost deploy for this Nuxt project: Node 24 (no .nvmrc names another),
# npm installs it (package-lock.json), package.json builds it with "nuxt build", node
# runs .output/server/index.mjs (package.json has no start script).
# It is yours now: change it as you like. pethost does not write it again.

FROM node:24
WORKDIR /app

COPY . .

# Every dependency: what builds the project, and may start it, is among the ones for
# development.
RUN --mount=type=cache,target=/root/.npm \
    npm install

RUN npm run build

ENV NODE_ENV=production
CMD ["node", ".output/server/index.mjs"]
```

Ses premières lignes disent ce que pethost a lu dans votre dossier. Trois choses en viennent :

- **Le gestionnaire de paquets** est celui que nomme votre lockfile : npm, pnpm, Yarn ou Bun.
- **La version de Node** est celle que nomme `.nvmrc` ou `.node-version`, et Node 24 s’il n’y a ni l’un ni l’autre.
- **Le démarrage** est votre script `start` si `package.json` en a un. Le starter n’en a pas, alors le fichier lance ce que `nuxt build` écrit avec son preset par défaut, le serveur Node : `.output/server/index.mjs`.

Le starter en marche occupait 30 MB de mémoire. Si la machine ne parvient pas à construire ou à démarrer le Dockerfile écrit par pethost, pethost retire le fichier de votre dossier et dit ce qui a échoué.

## Runtime config et variables d’environnement

Nuxt lit sa runtime config dans les variables qui commencent par `NUXT_`, au démarrage du serveur. Sur Pethost, une variable, c’est une commande. Elle va dans le fichier `.env` du projet sur la machine, que le service lit et que chaque déploiement suivant conserve :

```
pethost env set NUXT_PUBLIC_API_BASE=https://api.example.com
pethost env set NUXT_API_SECRET          # asks for the value without showing it
```

L’application redémarre avec la nouvelle valeur. `pethost env` liste les noms, et `pethost env --show` affiche le fichier avec ses valeurs.

## Modifier une page et redéployer

Modifiez `app/app.vue` et lancez la même commande. Le deuxième déploiement du starter a pris 12 secondes, car la machine garde les couches du build et le cache de npm :

```
$ pethost deploy
nuxt-app (.pethost)
✓ Packed 47 files · uploaded · built and started in 12 s
  · wrote compose.yaml for the Dockerfile: the service app, reading .env
  · kept the project's x-pethost
  It answers 200.
https://nuxt-app.sam.pethost.app
```

Pour déployer plutôt à chaque push, connectez le dépôt une fois :

```
pethost github sam/nuxt-app          # from now on, every push deploys itself
```

Pethost ne lit que les dépôts que vous avez donnés à son application GitHub. Si un déploiement tourne mal, `pethost rollback` remet la version d’avant, et votre machine garde les trois versions qui précèdent l’actuelle. Un agent IA peut faire tout cela pour vous grâce au 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 Nuxt

Tout nom sous le domaine de votre compte est une adresse d’emblée, en HTTPS. Un domaine qui vous appartient demande une commande et un enregistrement DNS :

```
pethost domain add app.example.com
```

La commande affiche l’enregistrement à créer : un CNAME de votre nom vers le nom de votre machine. Le certificat arrive tout seul dès que le nom pointe vers la machine, et se renouvelle tout seul. `pethost password` place une page de mot de passe devant toute l’application, pour une application qui n’est pas encore publique.

## Ce que vous obtenez pour ce prix

Pethost, c’est 9,99 € par mois pour tout ce que vous hébergez, sur 2 vCPU, 3 GB de mémoire et 30 GB de disque. Le serveur du starter en occupait 30 MB de mémoire, alors la machine a de la place pour l’API qu’appelle l’application, sa base de données et vos autres projets. Il n’y a [pas de frais par projet](https://pethost.dev/fr/blog/unlimited-projects-flat-monthly-fee/) et [rien n’est facturé à l’usage](https://pethost.dev/fr/blog/paas-without-usage-based-billing/) : le rendu côté serveur n’est pas facturé à la requête.

- **9,99 €** par mois pour tous vos projets, rien de facturé à l’usage
- **53 s** pour construire et démarrer le starter, la première fois
- **12 s** pour le déploiement suivant

Ce qui est déjà fait pour vous : le HTTPS avec des certificats qui se renouvellent tout seuls, les déploiements depuis GitHub, des sauvegardes chaque nuit conservées 14 jours, SSH dans n’importe quel conteneur, et chaque requête comptée, avec les chemins les plus sollicités et le taux d’erreur des 30 derniers jours. La machine est toujours allumée, alors une page [n’attend jamais un démarrage à froid](https://pethost.dev/fr/blog/always-on-hosting-no-cold-starts/). Les offres sont dans la partie [tarifs](https://pethost.dev/fr/#pricing) de la page d’accueil.

**Ce que prend chaque projet.** La page Capacité : chaque projet avec sa mémoire, son CPU et son disque.

![La page Capacité de la console Pethost : chaque projet avec sa mémoire, son CPU et son disque.](https://pethost.dev/shots/capacity.webp)

### Pethost est le meilleur choix pour

- **Les développeurs Vue avec une application full-stack** : le serveur Nuxt, ses routes d’API et sa base de données sur une seule machine, sur une seule facture
- **Les développeurs solo** qui ont plusieurs projets perso, chacun à sa propre adresse
- **Ceux dont l’agent déploie pour eux** : 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

### Faut-il un Dockerfile pour déployer une application Nuxt ?

Sur Pethost, un projet tourne à partir d’un Dockerfile ou d’un fichier Compose, et vous n’avez pas à l’écrire : dans un dossier qui n’a ni l’un ni l’autre, `pethost deploy` écrit le Dockerfile d’un projet Nuxt et le déploie. Le fichier reste dans votre dossier, et vous pouvez le modifier.

### Quel preset Nitro faut-il pour Nuxt sur Pethost ?

Aucun n’est à définir. `nuxt build` écrit par défaut un serveur Node dans `.output`, et le Dockerfile le démarre avec `node .output/server/index.mjs`.

### Sur quel port écoute le serveur Nuxt ?

Le 3000 par défaut. Pethost trouve le port sur lequel écoute le serveur en marche et y envoie l’adresse, en HTTPS : il n’y a donc aucun port à déclarer.

### Comment définir les variables d’environnement d’une application Nuxt en production ?

Lancez `pethost env set NUXT_API_SECRET` dans le dossier de l’application. La commande demande la valeur sans l’afficher et la met dans le fichier `.env` du projet sur la machine. Nuxt lit les variables qui commencent par `NUXT_` dans sa runtime config au démarrage du serveur.

### Peut-on déployer une application Nuxt depuis GitHub à chaque push ?

Oui. Déployez le dossier une fois avec `pethost deploy`, puis lancez `pethost github owner/repository`. Dès lors, chaque push sur le dépôt se déploie tout seul, et `pethost rollback` revient à un commit précédent.

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

9,99 € par mois pour Starter, avec 2 vCPU, 3 GB et 30 GB, sans frais par projet ni facturation à la requête : vos autres applications, sites 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 de l’application que `npm create nuxt@latest` écrit à partir de son template minimal, avec Nuxt 4.6.1 et pethost 0.2.1, sur une de nos machines de test. Le compte qu’on y voit est celui de l’exemple, `sam`.

1. [Nuxt : installation](https://nuxt.com/docs/getting-started/installation)
2. [Nuxt : déploiement](https://nuxt.com/docs/getting-started/deployment)
3. [Nuxt : runtime config](https://nuxt.com/docs/guide/going-further/runtime-config)
4. [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 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.
- 10 octobre 2026 [Comment déployer une application TanStack Start en 2026 : Nitro, un script start et une commande](https://pethost.dev/fr/blog/deploy-tanstack-start-app/) Déployez TanStack Start sur un serveur Node : ajoutez Nitro et un script start, lancez pethost deploy, et c’est en ligne en HTTPS en 29 s, pour 9,99 €/mois.
- 10 octobre 2026 [Comment déployer un site VitePress en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous](https://pethost.dev/fr/blog/deploy-vitepress-site/) Déployez un site VitePress en une commande : pethost deploy écrit le Dockerfile, construit le site et le sert en HTTPS, pour 9,99 € par mois.
- 10 octobre 2026 [Comment déployer un site Eleventy en 2026 : une commande, HTTPS et un Dockerfile qui reste à vous](https://pethost.dev/fr/blog/deploy-eleventy-site/) Déployez un site Eleventy (11ty) en une commande : pethost deploy écrit le Dockerfile, construit _site et le sert en HTTPS, pour 9,99 € par 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/)