Oui, vous pouvez déployer une application Next.js sur un VPS avec Coolify, et l'opération prend environ 45 minutes la première fois. Coolify 4.6.0, la version stable listée le 6 novembre 2026, s'installe avec une commande, lit votre dépôt GitHub, construit l'image et route le domaine avec un certificat Let's Encrypt. Next.js 16.4.5 est la version publiée sur npm à la même date ; la méthode vaut aussi pour une application restée sur Next.js 15.
Le serveur compte plus que le logiciel. Coolify demande 2 cœurs, 2 Go de RAM et 10 Go de disque. Un Hetzner CPX22 (2 vCPU AMD, 4 Go de RAM, 80 Go de NVMe, 20 To de trafic) coûte 19,99 € HT par mois. Un droplet DigitalOcean de 2 vCPU et 2 Go avec 60 Go de SSD coûte 18 $, et la version 2 vCPU et 4 Go coûte 24 $. Avec une sauvegarde, comptez environ 21,20 € HT ou 21,60 $ par mois, avant le domaine. Pour une seule application sans exploitation, Vercel Pro à 20 $ reste moins cher une fois votre temps compté ; notre comparatif Vercel, Cloudflare et Coolify détaille ce calcul.
Ce tutoriel suit le chemin le plus reproductible : un Dockerfile multi-étapes et output: "standalone". Coolify sait aussi détecter Next.js avec Nixpacks, et la variante est donnée pour un premier test. Les prix, versions et limites cités ont été relevés le 6 novembre 2026.
Ce qu'il faut préparer#
Partez d'une image Ubuntu 24.04 LTS à jour, avec un accès SSH par clé et un utilisateur root ou sudo. Coolify accepte Debian, Ubuntu, AlmaLinux, Rocky Linux et d'autres distributions Linux, mais Ubuntu LTS reste le chemin le mieux documenté. Évitez un serveur qui héberge déjà des applications : le script d'installation installe Docker, réorganise des répertoires sous /data/coolify et démarre ses propres conteneurs.
Il vous faut aussi un nom de domaine, un dépôt GitHub contenant l'application, et une application qui construit correctement en local. Lancez npm ci puis npm run build sur votre machine avant de toucher au serveur : une erreur de build sur le VPS est plus lente à diagnostiquer, et les journaux Coolify défilent vite.
Ouvrez uniquement les ports nécessaires. Le port 22 sert à SSH, les ports 80 et 443 au proxy et aux certificats, et le port 8000 au panneau Coolify pendant l'installation. Le port 8000 sera fermé ensuite.
ssh [email protected]
apt update && apt upgrade -y
apt install -y ufw curl
ufw allow OpenSSH
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8000/tcp
ufw enable
ufw statusVérifiez que Docker n'a pas été installé par snap, ce que la documentation Coolify déconseille. Si docker --version pointe vers une version snap, retirez-la et laissez le script d'installation poser Docker Engine, ou suivez la procédure officielle Docker pour Ubuntu.
Installer Coolify#
Une commande suffit sur un serveur neuf. Le script installe les paquets nécessaires, Docker Engine, prépare /data/coolify, configure les répertoires et démarre Coolify.
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bashLe panneau répond ensuite sur http://203.0.113.10:8000. Créez le compte administrateur immédiatement : la documentation Coolify prévient que la première personne qui atteint la page d'inscription devient administrateur de l'instance et obtient un accès root au serveur. Ne laissez pas cette page ouverte sur Internet entre deux cafés.
Sauvegardez /data/coolify/source/.env hors du serveur, dans un gestionnaire de mots de passe ou une archive chiffrée. Ce fichier contient APP_KEY, la clé qui chiffre les valeurs stockées par Coolify. Sans elle, une restauration de l'instance est incomplète, même si vous avez sauvegardé les bases de vos applications. C'est le premier piège de l'auto-hébergement : on sauvegarde les données des projets et pas les secrets de la plateforme.
Mettre le panneau derrière un domaine#
Coolify peut servir son propre panneau avec HTTPS. Créez un enregistrement DNS A pour coolify.example.com vers l'adresse du VPS, puis ouvrez Settings > General et renseignez l'URL https://coolify.example.com. Coolify redémarre son proxy et demande le certificat. Vérifiez que https://coolify.example.com répond avant de fermer le port 8000.
dig +short coolify.example.com A
curl -I https://coolify.example.com
ufw delete allow 8000/tcpGardez le port 22 ouvert. Si vous ne configurez pas tout de suite un domaine pour le panneau, limitez le port 8000 à votre adresse IP au lieu de l'ouvrir à tous :
ufw delete allow 8000/tcp
ufw allow from 198.51.100.7 to any port 8000 proto tcpCette règle reste une protection temporaire. Un panneau accessible en HTTP sur http://IP:8000 expose vos variables d'environnement, vos bases et vos conteneurs à quiconque connaît l'adresse.
Préparer l'application Next.js#
Le Dockerfile officiel de Next.js utilise le mode standalone. Activez-le dans next.config.ts pour que next build produise un serveur minimal avec les seuls fichiers nécessaires :
import type { NextConfig } from "next";
const nextConfig: NextConfig = {
output: "standalone",
};
export default nextConfig;Sans cette option, le dossier .next/standalone n'existe pas et le Dockerfile ci-dessous échoue à l'étape COPY. Le mode standalone copie les dépendances réellement utilisées, mais pas public ni .next/static : le Dockerfile doit les copier lui-même. La documentation Next.js sur output décrit ce comportement.
Créez un Dockerfile à la racine du dépôt. Cette version reprend les trois étapes de l'exemple Docker officiel, avec npm et Node.js 24.13.0 :
ARG NODE_VERSION=24.13.0-slim
FROM node:${NODE_VERSION} AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
FROM node:${NODE_VERSION} AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .
ENV NEXT_TELEMETRY_DISABLED=1
RUN npm run build
FROM node:${NODE_VERSION} AS runner
WORKDIR /app
ENV NODE_ENV=production
ENV PORT=3000
ENV HOSTNAME=0.0.0.0
RUN apt-get update \
&& apt-get install -y --no-install-recommends curl \
&& rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/public ./public
RUN mkdir .next && chown node:node .next
COPY --from=builder --chown=node:node /app/.next/standalone ./
COPY --from=builder --chown=node:node /app/.next/static ./.next/static
USER node
EXPOSE 3000
CMD ["node", "server.js"]Trois détails évitent des heures perdues. HOSTNAME=0.0.0.0 oblige le serveur à écouter sur toutes les interfaces ; un serveur lié à 127.0.0.1 est invisible pour le proxy Coolify. curl est installé dans l'image finale pour que le healthcheck HTTP de Coolify puisse s'exécuter : l'image node:slim ne le fournit pas. Enfin, npm ci exige un package-lock.json versionné ; si votre dépôt utilise pnpm ou yarn, adaptez la commande d'installation.
Ajoutez un .dockerignore pour ne pas envoyer les fichiers inutiles au démon Docker :
node_modules
.next
.git
.env*Testez le build en local avant de pousser :
npm ci
npm run build
npm run start
curl -I http://127.0.0.1:3000Créer l'application dans Coolify#
Dans Coolify, créez un projet, puis + New. Pour un dépôt privé, configurez d'abord une source GitHub App dans Sources > New source > GitHub App et laissez Coolify enregistrer l'application GitHub automatiquement. Pour un dépôt public, collez simplement son URL HTTPS. La documentation GitHub App détaille les permissions et l'installation.
Choisissez ensuite le serveur localhost de l'instance, la branche main, et le pack de build. Deux chemins fonctionnent :
- Nixpacks détecte Next.js, lance
npm run buildet démarre le serveur. C'est le plus rapide pour un premier essai. Vérifiez les commandes détectées dans General et gardez le port interne3000. - Dockerfile construit l'image à partir du fichier ci-dessus. Réglez Base Directory sur
/, Dockerfile Location sur/Dockerfile, Ports Exposes sur3000. Le résultat est plus prévisible et l'image finale ne contient pas les outils de build.
Pour une application de production, prenez le Dockerfile. Nixpacks reste pratique pour valider le dépôt et le domaine en quelques minutes, mais il dépend de la détection automatique et des versions installées par le builder.
Avant le premier déploiement, ajoutez les variables d'environnement dans Environment Variables. Une variable NEXT_PUBLIC_* est intégrée au bundle JavaScript pendant le build : si vous la changez, il faut redéployer, pas seulement redémarrer. Une variable serveur comme DATABASE_URL peut rester en runtime. La documentation Coolify sépare ces deux portées et permet de retirer une variable du build.
DATABASE_URL=postgresql://app:mot-de-passe@db:5432/app
AUTH_SECRET=remplacez-par-un-secret-long
NEXT_PUBLIC_APP_URL=https://app.example.comPour la base, deux options courantes. Un service PostgreSQL créé dans Coolify tourne sur le même VPS et fournit une URL interne ; c'est le plus simple pour un projet solo, à condition de configurer ses sauvegardes. Une base managée externe, comme Neon, Supabase ou un PostgreSQL chez un hébergeur, déporte les sauvegardes et les mises à jour. Dans les deux cas, ne mettez pas le mot de passe dans l'image : il vit dans les variables Coolify.
Les migrations demandent une étape séparée. Le pre-deployment de Coolify s'exécute dans le conteneur actuellement en cours, avant de le remplacer, et il est ignoré au premier déploiement. Pour une application Prisma, lancez la première migration dans le terminal du conteneur après le démarrage, puis ajoutez npx prisma migrate deploy en pre-deployment pour les suivantes. Vérifiez que la migration est compatible avec l'ancienne version tant que les deux conteneurs peuvent tourner ensemble.
Domaine, DNS et HTTPS#
Créez l'enregistrement DNS de l'application, par exemple app.example.com en type A vers l'adresse du VPS. Attendez que la résolution soit correcte avant de demander le certificat :
dig +short app.example.com ADans Coolify, ouvrez l'application, puis Domains > Add domain. Choisissez le protocole https, saisissez app.example.com, et laissez le port interne 3000 ou indiquez-le. Redéployez ou redémarrez pour que le proxy prenne la nouvelle route. Coolify demande alors le certificat à Let's Encrypt et le renouvelle ensuite.
Les domaines générés en sslip.io sont utiles pour un test, mais ils restent en HTTP : Let's Encrypt limite la zone partagée sslip.io, et un certificat HTTPS y échoue souvent. Utilisez votre domaine pour la production. Si un CDN ou un proxy se trouve devant le serveur, vérifiez que les ports 80 et 443 atteignent bien le proxy Coolify, sinon la validation du certificat échoue.
Déployer et vérifier#
Cliquez sur Deploy et suivez les journaux. La première construction prend quelques minutes : npm installe les dépendances, Next.js compile, Docker assemble l'image, puis Coolify démarre le conteneur et met à jour le proxy. Une fois le déploiement terminé, testez le domaine et un endpoint de santé :
curl -I https://app.example.com
curl -fsS https://app.example.com/api/healthAjoutez une route de santé légère si l'application n'en a pas. Cette route ne doit pas toucher à la base ni écrire de données :
export function GET() {
return Response.json({ ok: true });
}Dans Healthcheck, choisissez HTTP, le chemin /api/health, le port 3000, un intervalle de 30 secondes, un timeout de 5 secondes et 3 tentatives. Le start period de 20 secondes laisse le temps au serveur Next.js de démarrer. Le healthcheck HTTP de Coolify s'exécute depuis le conteneur : sans curl ou wget dans l'image finale, Docker marque le conteneur unhealthy et Traefik peut renvoyer No available server.
Les erreurs de premier déploiement sont souvent les mêmes. No available server ou une 502 signifie que le port exposé ne correspond pas au port d'écoute, que le processus écoute sur 127.0.0.1 au lieu de 0.0.0.0, ou que le proxy Coolify est arrêté. Un certificat absent vient d'un DNS incorrect, d'un port 80 fermé ou d'un enregistrement AAAA cassé. Un build tué vient de la mémoire. Ces trois vérifications règlent la majorité des cas.
Automatiser les déploiements et revenir en arrière#
Avec une GitHub App, ouvrez Advanced > Deployment et choisissez Deploy on push (webhooks). Un push sur la branche configurée lance un déploiement, et les journaux affichent le commit. Pour un dépôt public ou une clé de déploiement, Coolify ne reçoit pas les événements GitHub : il faut créer un webhook manuel avec l'URL et le secret affichés dans Webhooks, puis activer l'événement push.
Si les tests tournent dans GitHub Actions, gardez Coolify en déploiement manuel et appelez le webhook après les tests. Le jeton doit rester dans les secrets du dépôt :
curl --fail --request POST "$COOLIFY_WEBHOOK" \
--header "Authorization: Bearer $COOLIFY_TOKEN"Coolify conserve les images des déploiements précédents et permet un rollback depuis Rollback. Réglez Images to keep pour garder assez d'images. Un rollback ne restaure ni la base ni les volumes : si la nouvelle version a exécuté une migration destructive, revenir à l'image précédente ne suffit pas. Prévoyez la compatibilité des migrations et une sauvegarde avant chaque changement de schéma.
Les mises à jour progressives existent pour les applications Nixpacks, Railpack, Dockerfile et Docker Image : Coolify démarre le nouveau conteneur, attend le healthcheck, puis arrête l'ancien. Ce n'est pas une garantie de zéro coupure. Un port publié sur l'hôte, un nom de conteneur fixe ou une application qui ne gère pas l'arrêt proprement empêchent le chevauchement. Configurez le Stop Grace Period et testez le déploiement avec du trafic réel avant de compter sur cette fonction.
Sauvegardes et exploitation#
Sauvegardez la configuration de Coolify, la base de l'application et les fichiers persistants. Ce sont trois choses différentes. Le fichier /data/coolify/source/.env contient la clé de l'instance ; une copie hors serveur évite de perdre les secrets si le disque tombe. Les sauvegardes de bases Coolify acceptent PostgreSQL, MySQL, MariaDB, MongoDB, ClickHouse et SQLite, s'écrivent dans /data/coolify/backups et peuvent être envoyées vers un stockage S3. Réglez une fréquence, une rétention et vérifiez qu'une restauration fonctionne sur une base jetable. La documentation des sauvegardes insiste sur ce point : un fichier créé n'est pas une sauvegarde testée.
Un snapshot du fournisseur ne remplace pas un dump logique. Le snapshot capture le disque à un instant donné ; si vous supprimez une ligne à 14 h, le snapshot de la nuit précédente ne vous sauve pas. Chez Hetzner, les sauvegardes automatiques commencent à 1,1980 € HT par mois avec sept emplacements. Chez DigitalOcean, elles coûtent 20 % du prix du droplet en hebdomadaire ou 30 % en quotidien. Pour un CPX22 à 19,99 € HT, comptez environ 21,20 € HT avec la sauvegarde ; pour un droplet à 18 $, comptez 21,60 $ en hebdomadaire ou 23,40 $ en quotidien.
Côté système, activez les mises à jour de sécurité automatiques, surveillez l'espace disque et les journaux Docker. docker system df montre les images et volumes qui prennent de la place ; df -h montre le disque du serveur ; docker stats --no-stream donne la mémoire et le CPU par conteneur. Mettez à jour Coolify depuis le panneau ou avec la procédure de mise à jour de la documentation, et lisez les notes de version avant de cliquer. Une instance oubliée pendant six mois peut contenir une faille corrigée depuis.
Enfin, surveillez l'application depuis l'extérieur. Un moniteur qui interroge https://app.example.com/api/health toutes les cinq minutes prévient avant vos utilisateurs. Un VPS auto-hébergé n'est pas un SaaS : les certificats, les mises à jour, les sauvegardes et les restaurations font partie du prix.
Les erreurs qui coûtent du temps#
- Le build meurt sans message clair. La mémoire manque. Ajoutez du swap, réduisez la taille du build ou utilisez un serveur de build séparé.
- Le domaine répond en 502. Vérifiez le port exposé, l'écoute sur
0.0.0.0et l'état du proxy Coolify.docker pset les journaux d'exécution donnent la réponse. - Le certificat n'arrive pas. Le DNS doit pointer vers le bon serveur, les ports 80 et 443 doivent être ouverts, et un
AAAAcassé peut bloquer la validation même si l'IPv4 fonctionne. - Les assets manquent après le passage en standalone.
publicet.next/staticn'ont pas été copiés dans l'image. LeDockerfiledoit les copier explicitement. - Une variable
NEXT_PUBLIC_*reste vide. Elle est figée au build. Modifiez-la puis redéployez, un simple redémarrage ne la réinjecte pas. - Le conteneur est unhealthy. Le healthcheck HTTP a besoin de
curlouwgetdans l'image finale, et doit viser le port interne, pas le port public. - Le rollback ne répare pas la base. Une image précédente ne défait pas une migration. Restaurez la base séparément si le schéma a changé.
Quand un PaaS managé reste le meilleur choix#
Si vous déployez une seule application Next.js, sans base ni outil interne, et que vous ne voulez pas patcher un serveur, Vercel Pro à 20 $ par mois reste le chemin le plus court. Les aperçus par branche, les rollbacks et les certificats sont inclus, et vous ne gérez pas Docker. Notre comparatif Vercel, Cloudflare et Coolify chiffre ce choix.
Coolify devient intéressant dès que vous mutualisez plusieurs services sur la même machine : une application, une base PostgreSQL, un wiki, un outil d'analyse et une boîte à outils interne. Le coût par application baisse, et les données restent chez votre hébergeur. Si vous hésitez entre plusieurs plateformes auto-hébergées, notre comparatif Coolify, Dokploy et CapRover donne les limites de RAM et les fonctions de chacune. Pour un premier service à héberger à côté de Next.js, le tutoriel Docmost avec Docker Compose montre la mécanique d'une application et de sa base sur un VPS.
Questions fréquentes
Combien de RAM faut-il pour Coolify avec Next.js ?
La documentation Coolify demande 2 cœurs, 2 Go de RAM et 10 Go de disque. Pour une application Next.js et une base PostgreSQL sur la même machine, 4 Go sont plus confortables, surtout pendant les builds. Sur 2 Go, surveillez la mémoire et ajoutez du swap si le build est tué.
Coolify est-il vraiment gratuit ?
L'auto-hébergement est gratuit, sans restriction de fonctionnalités. L'offre Cloud coûte 5 $ par mois pour deux serveurs connectés, puis 3 $ par mois par serveur supplémentaire ; elle fait tourner le panneau sur l'infrastructure de l'éditeur, pas vos applications. Le VPS, les sauvegardes et votre temps restent à votre charge.
Nixpacks ou Dockerfile pour une application Next.js ?
Nixpacks détecte Next.js et déploie plus vite pour un premier test. Un Dockerfile multi-étapes avec output: "standalone" donne une image plus prévisible, plus petite, et ne dépend pas des versions choisies par le builder. Pour la production, prenez le Dockerfile.
Comment mettre à jour l'application ?
Un push sur la branche configurée déclenche le déploiement si l'auto-deploy est activé. Sinon, cliquez sur Deploy ou Redeploy. Les migrations de base ne sont pas automatiques : exécutez-les dans une étape séparée et gardez une sauvegarde avant chaque changement de schéma.
Où sont stockées les sauvegardes ?
Les sauvegardes de bases Coolify sont écrites dans /data/coolify/backups sur le serveur et peuvent être copiées vers un stockage S3. Sauvegardez aussi /data/coolify/source/.env hors du serveur. Testez une restauration sur une base jetable : un fichier jamais restauré ne prouve rien.
Le HTTPS est-il automatique ?
Oui, si vous ajoutez un domaine en https:// dans Coolify et que son enregistrement DNS pointe vers le serveur. Les ports 80 et 443 doivent être ouverts pour que Let's Encrypt valide le domaine. Les domaines de test sslip.io restent en HTTP et ne conviennent pas à la production.
Sources#
Pages officielles consultées le 6 novembre 2026. Prix relevés en novembre 2026, hors taxes lorsqu'ils sont indiqués HT.
- Coolify — installation auto-hébergée
- Coolify — tarifs
- Coolify — déployer sa première application
- Coolify — variables d'environnement
- Coolify — domaines
- Coolify — DNS
- Coolify — health checks
- Coolify — sauvegardes de bases
- Coolify — restauration de base
- Coolify — mises à jour progressives
- Coolify — rollbacks
- Coolify — GitHub App
- Coolify — Nixpacks
- Coolify — Dockerfile
- Coolify — versions stables
- Dépôt GitHub coollabsio/coolify
- Next.js — auto-hébergement
- Next.js — output standalone
- Next.js — exemple Docker officiel
- Next.js — version publiée sur npm
- Vercel — tarifs
- Docker — installer sur Ubuntu
- Hetzner — cloud Regular Performance
- DigitalOcean — tarifs des droplets



Commentaires
Chargement des commentaires…