Coolify v4 : Le PaaS Open-Source qui Remplace Heroku et Vercel

Introduction : La révolution du PaaS self-hosted

Le monde du déploiement d'applications web a connu une transformation profonde ces dernières années. D'un côté, les plateformes cloud comme Heroku, Vercel et Railway ont démocratisé le déploiement en un clic, mais à quel prix ? Factures imprévisibles, vendor lock-in, limitations sur les ressources, et surtout une dépendance totale à des tiers pour héberger vos applications.

De l'autre côté, le mouvement self-hosting a explosé en 2024-2025, porté par des préoccupations de souveraineté des données, de contrôle des coûts et de vie privée. C'est dans ce contexte qu'émerge Coolify v4, un PaaS (Platform as a Service) open-source qui promet de vous offrir l'expérience Heroku/Vercel sur vos propres serveurs.

Architecture en un coup d'œil

Développé par Andras Bacsai et une communauté active, Coolify v4 a été entièrement réécrit depuis la version 3 et représente un bond en avant considérable. Avec plus de 35 000 étoiles sur GitHub en 2025, le projet s'est imposé comme la référence du PaaS self-hosted. Ce guide complet vous montrera comment l'installer, le configurer et déployer vos applications en toute autonomie.

Qu'est-ce que Coolify ? Un Heroku sur votre propre serveur

Coolify est une plateforme de déploiement d'applications open-source et auto-hébergée. Concrètement, elle vous permet de :

• Déployer des applications depuis un dépôt Git (GitHub, GitLab, Gitea, Bitbucket) en un clic.
• Déployer des Dockerfiles et Docker Compose existants sans modification.
• Provisionner des bases de données (PostgreSQL, MySQL, MongoDB, Redis, MariaDB, etc.) en un clic.
• Gérer automatiquement les domaines et le SSL via Let's Encrypt.
• Déclencher des déploiements automatiques via webhooks à chaque push Git.
• Monitorer vos applications avec des métriques intégrées.
• Gérer plusieurs serveurs depuis une seule interface.

Architecture de Coolify v4

Coolify v4 est construit avec une stack moderne :

• Backend : Laravel (PHP 8.3) avec API REST.
• Frontend : Livewire (Laravel) avec Alpine.js pour l'interactivité.
• Base de données : PostgreSQL pour stocker la configuration.
• Reverse proxy : Traefik (par défaut) ou Caddy pour le routage et le SSL.
• Runtime : Docker et Docker Compose pour l'exécution des applications.
• Build : Nixpacks (détection automatique) ou Dockerfiles personnalisés.
• Communication serveurs : SSH pour la gestion des serveurs distants.

Point clé : Coolify ne nécessite pas Kubernetes. Il utilise Docker et Docker Compose, ce qui le rend accessible à tout développeur familier avec les conteneurs, sans la complexité d'un orchestrateur.

Installation de Coolify v4 : Une seule commande

Prérequis

Avant d'installer Coolify, assurez-vous d'avoir :

• Un serveur Linux (Ubuntu 22.04/24.04 LTS recommandé, Debian 12, CentOS Stream 9).
• 2 CPU / 2 Go RAM minimum (4 CPU / 4 Go recommandé).
• 30 Go d'espace disque minimum.
• Un accès root ou sudo.
• Un nom de domaine (optionnel mais fortement recommandé pour le SSL).
• Les ports 80, 443 et 8000 ouverts dans le firewall.

Installation automatique

L'installation de Coolify se fait en une seule commande. C'est l'un de ses points forts :

# Installation en une commande (en tant que root)
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

Cette commande va :

1. Installer Docker et Docker Compose s'ils ne sont pas déjà présents.
2. Télécharger les images Docker de Coolify.
3. Configurer le reverse proxy Traefik.
4. Lancer tous les services Coolify.
5. Afficher l'URL d'accès (par défaut http://VOTRE_IP:8000).

Installation manuelle (alternative)

Si vous préférez contrôler chaque étape :

# 1. Installer les prérequis
apt update && apt upgrade -y
apt install -y curl wget git jq

# 2. Installer Docker
curl -fsSL https://get.docker.com | sh
systemctl enable --now docker

# 3. Créer les répertoires nécessaires
mkdir -p /data/coolify/{source,ssh,applications,databases,backups,services,proxy,webhooks-during-maintenance,metrics,logs}
mkdir -p /data/coolify/ssh/{keys,mux}

# 4. Générer une clé SSH pour Coolify
ssh-keygen -t ed25519 -f /data/coolify/ssh/keys/id.root@host.docker.internal -N "" -C "coolify"

# 5. Ajouter la clé publique aux clés autorisées
cat /data/coolify/ssh/keys/id.root@host.docker.internal.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

# 6. Télécharger les fichiers de configuration
cd /data/coolify/source
curl -fsSL https://cdn.coollabs.io/coolify/docker-compose.yml -o docker-compose.yml
curl -fsSL https://cdn.coollabs.io/coolify/.env.production -o .env

# 7. Générer les secrets
sed -i "s|APP_KEY=.*|APP_KEY=base64:$(openssl rand -base64 32)|" .env
sed -i "s|DB_PASSWORD=.*|DB_PASSWORD=$(openssl rand -base64 32)|" .env

# 8. Lancer Coolify
docker compose up -d --pull always --remove-orphans --force-recreate

# 9. Vérifier que tout fonctionne
docker compose ps

Configuration initiale

Après l'installation, accédez à http://VOTRE_IP:8000 dans votre navigateur. Vous serez guidé à travers la configuration initiale :

1. Création du compte administrateur : définissez votre email et mot de passe.
2. Configuration du serveur local : Coolify détecte automatiquement le serveur sur lequel il est installé.
3. Configuration du domaine : si vous avez un domaine, configurez-le pour accéder à Coolify via HTTPS.

# Configurer un domaine pour l'interface Coolify elle-même
# Dans .env, modifiez :
# APP_URL=https://coolify.votredomaine.fr

# Redémarrer après modification
cd /data/coolify/source
docker compose up -d --force-recreate

L'interface web : Tour d'horizon

L'interface de Coolify v4 est moderne, intuitive et réactive. Voici les sections principales :

Dashboard

La page d'accueil affiche un aperçu de tous vos déploiements, serveurs et ressources. Vous voyez immédiatement le statut de chaque application (running, stopped, deploying, failed).

Projects

Coolify organise vos déploiements en projets. Chaque projet peut contenir plusieurs environnements (production, staging, development), et chaque environnement contient des ressources (applications, bases de données, services).

Servers

Gestion de tous vos serveurs connectés. Coolify peut gérer des serveurs distants via SSH, ce qui vous permet de déployer sur une flotte de machines depuis une seule interface.

Sources

Configuration des connexions Git (GitHub App, GitLab, Gitea, Bitbucket). C'est ici que vous autorisez Coolify à accéder à vos dépôts.

Destinations

Les réseaux Docker sur lesquels vos applications seront déployées. Par défaut, un réseau est créé pour chaque serveur.

Déployer depuis Git : GitHub, GitLab et Gitea

Connecter GitHub

La méthode recommandée pour GitHub est de créer une GitHub App, ce qui offre des permissions granulaires et des webhooks automatiques.

1. Allez dans Sources → Add → GitHub App.
2. Coolify vous guide pour créer l'application GitHub avec les permissions nécessaires.
3. Installez l'application sur votre compte/organisation GitHub.
4. Sélectionnez les dépôts auxquels Coolify a accès.

Connecter GitLab

Pour GitLab (y compris les instances self-hosted) :

1. Allez dans Sources → Add → GitLab.
2. Créez une application OAuth dans GitLab (Settings → Applications).
3. Copiez le Client ID et Client Secret dans Coolify.
4. Configurez l'URL de votre instance GitLab si elle est self-hosted.

Déployer une application depuis Git

1. Créez un Project et un Environment.
2. Cliquez sur "+ New Resource" → "Application".
3. Sélectionnez votre source Git et le dépôt.
4. Choisissez la branche à déployer.
5. Coolify détecte automatiquement le type d'application (via Nixpacks) ou vous pouvez spécifier un Dockerfile.
6. Configurez le domaine, les variables d'environnement, les ports.
7. Cliquez sur "Deploy".

Nixpacks : La détection automatique du langage

Nixpacks est le moteur de build par défaut de Coolify. Développé par Railway, il détecte automatiquement le langage et le framework de votre application, puis génère un Dockerfile optimisé. C'est l'équivalent open-source des buildpacks de Heroku.

Langages et frameworks supportés

• JavaScript/TypeScript : Node.js, Next.js, Nuxt.js, Remix, Astro, SvelteKit, Express, Fastify.
• Python : Django, Flask, FastAPI, Streamlit.
• PHP : Laravel, Symfony, WordPress.
• Ruby : Ruby on Rails, Sinatra.
• Go : applications Go standard.
• Rust : applications Cargo.
• Java : Spring Boot, Maven, Gradle.
• .NET : ASP.NET Core.
• Elixir : Phoenix.
• Et bien d'autres : Haskell, Clojure, Crystal, Dart, Zig, Swift...

Comment ça fonctionne

Nixpacks analyse votre projet et détecte automatiquement :

1. Le langage : via les fichiers caractéristiques (package.json, requirements.txt, go.mod, Cargo.toml, etc.).
2. Les dépendances : installe les bonnes versions (Node 20, Python 3.12, etc.).
3. Le build : exécute les commandes de build appropriées (npm run build, pip install, cargo build, etc.).
4. Le start : détermine la commande de démarrage (npm start, gunicorn, etc.).

Vous pouvez personnaliser le comportement de Nixpacks via un fichier nixpacks.toml à la racine de votre projet :

# nixpacks.toml - Exemple de configuration personnalisée

[phases.setup]
nixPkgs = ["...", "ffmpeg", "imagemagick"]

[phases.install]
cmds = ["npm ci"]

[phases.build]
cmds = ["npm run build"]

[start]
cmd = "npm start"

[variables]
NODE_ENV = "production"
NEXT_TELEMETRY_DISABLED = "1"

Astuce : Si Nixpacks ne détecte pas correctement votre application ou si vous avez des besoins spécifiques, vous pouvez toujours fournir votre propre Dockerfile. Coolify utilisera automatiquement un Dockerfile présent à la racine du projet plutôt que Nixpacks.

Déployer des Dockerfiles et Docker Compose

Déploiement avec un Dockerfile

Si votre projet contient un Dockerfile, Coolify le détectera et l'utilisera automatiquement. Vous pouvez aussi spécifier un chemin personnalisé vers le Dockerfile dans les paramètres de l'application.

# Exemple de Dockerfile pour une app Node.js
FROM node:20-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:20-alpine AS runner
WORKDIR /app
ENV NODE_ENV=production

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs
EXPOSE 3000
ENV PORT=3000
CMD ["node", "server.js"]

Déploiement avec Docker Compose

Coolify supporte nativement les fichiers Docker Compose, ce qui est particulièrement utile pour les applications multi-conteneurs.

1. Créez une nouvelle ressource → "Docker Compose".
2. Collez ou liez votre fichier docker-compose.yml.
3. Coolify parse le fichier et vous permet de configurer les domaines, volumes et variables d'environnement pour chaque service.

# docker-compose.yml - Exemple d'application WordPress complète
version: '3.8'

services:
  wordpress:
    image: wordpress:6.7-php8.3-apache
    restart: always
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: ${DB_PASSWORD}
      WORDPRESS_DB_NAME: wordpress
    volumes:
      - wp_data:/var/www/html
    depends_on:
      - db

  db:
    image: mariadb:11.4
    restart: always
    environment:
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: ${DB_PASSWORD}
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql

volumes:
  wp_data:
  db_data:

Exemple complet : Déployer une application Next.js

Voyons pas à pas comment déployer une application Next.js complète sur Coolify, du code au déploiement en production avec domaine personnalisé et SSL.

Étape 1 : Préparer l'application

# Créer une nouvelle application Next.js
npx create-next-app@latest mon-app-nextjs --typescript --tailwind --app --src-dir
cd mon-app-nextjs

# Vérifier que l'application fonctionne localement
npm run dev

# Initialiser Git et pousser sur GitHub
git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/votre-user/mon-app-nextjs.git
git push -u origin main

Étape 2 : Configurer Next.js pour le déploiement

Pour un déploiement optimal avec Coolify, configurez Next.js en mode standalone :

# next.config.ts
import type { NextConfig } from 'next'

const nextConfig: NextConfig = {
  output: 'standalone',
  // Optionnel : si vous utilisez des images
  images: {
    remotePatterns: [
      {
        protocol: 'https',
        hostname: '**.example.com',
      },
    ],
  },
}

export default nextConfig

Étape 3 : Déployer sur Coolify

1. Connectez-vous à votre interface Coolify.
2. Allez dans Projects → Votre Projet → Production → + New Resource.
3. Sélectionnez "Application" puis votre source GitHub.
4. Choisissez le dépôt mon-app-nextjs et la branche main.
5. Coolify détecte automatiquement Next.js via Nixpacks.
6. Configurez les paramètres suivants :
   • Port exposé : 3000
   • Domaine : app.votredomaine.fr
   • Variables d'environnement : ajoutez vos variables (API keys, database URL, etc.)
7. Cliquez sur "Deploy".

Étape 4 : Vérifier le déploiement

Coolify affiche les logs de build en temps réel. Vous pouvez suivre chaque étape :

• Clonage du dépôt Git.
• Détection du projet par Nixpacks (ou build du Dockerfile).
• Installation des dépendances (npm ci).
• Build de l'application (npm run build).
• Création de l'image Docker.
• Démarrage du conteneur.
• Configuration du reverse proxy et du certificat SSL.

En quelques minutes, votre application Next.js est accessible sur https://app.votredomaine.fr avec un certificat SSL valide.

Étape 5 : Activer le déploiement automatique

Pour que chaque push sur la branche main déclenche automatiquement un redéploiement :

1. Dans les paramètres de l'application, section "General".
2. Activez "Auto Deploy".
3. Coolify configure automatiquement un webhook GitHub.

Désormais, chaque git push origin main déclenche un nouveau déploiement. L'ancien conteneur reste actif jusqu'à ce que le nouveau soit prêt, assurant un zero-downtime deployment.

Bases de données en un clic

L'un des atouts majeurs de Coolify est la possibilité de provisionner des bases de données en quelques clics, sans configuration complexe.

Bases de données supportées

Créer une base de données PostgreSQL

1. Dans votre projet, cliquez sur "+ New Resource" → "Database" → "PostgreSQL".
2. Choisissez la version (ex: PostgreSQL 17).
3. Coolify génère automatiquement un mot de passe sécurisé.
4. Optionnellement, rendez la base accessible publiquement (pour les outils de gestion distants).
5. Cliquez sur "Start".

La base de données est immédiatement disponible. Coolify vous fournit la connection string à utiliser dans vos applications :

# Connection string fournie par Coolify
postgresql://postgres:motdepasse_genere@nom-du-service:5432/postgres

# Ou les variables individuelles :
# POSTGRES_HOST=nom-du-service
# POSTGRES_PORT=5432
# POSTGRES_USER=postgres
# POSTGRES_PASSWORD=motdepasse_genere
# POSTGRES_DB=postgres

Lier une base de données à une application

Pour connecter votre application Next.js à la base PostgreSQL créée :

1. Copiez l'URL interne de la base de données depuis la page de la database.
2. Allez dans les paramètres de votre application → "Environment Variables".
3. Ajoutez la variable DATABASE_URL avec la connection string.
4. Redéployez l'application.

Astuce : Coolify v4 supporte les variables partagées entre les ressources d'un même environnement. Vous pouvez référencer dynamiquement les paramètres d'une base de données dans les variables d'une application.

Domaines et SSL automatique avec Let's Encrypt

Configuration DNS

Pour chaque application déployée, vous pouvez assigner un domaine personnalisé. Commencez par configurer vos enregistrements DNS :

# Enregistrement DNS de type A
app.votredomaine.fr    A    203.0.113.50    (IP de votre serveur Coolify)

# Ou utiliser un wildcard pour tous les sous-domaines
*.votredomaine.fr      A    203.0.113.50

# Si vous utilisez Cloudflare, désactivez le proxy (orange cloud)
# pour que Let's Encrypt puisse valider le domaine via HTTP-01
# Ou configurez le challenge DNS-01 dans Coolify

SSL automatique

Coolify gère automatiquement les certificats SSL via Let's Encrypt. Il suffit d'assigner un domaine à votre application :

1. Dans les paramètres de l'application, section "General".
2. Ajoutez votre domaine dans le champ "Domains".
3. Coolify configure automatiquement Traefik pour obtenir et renouveler le certificat SSL.

Les certificats sont renouvelés automatiquement avant expiration. Vous pouvez aussi configurer des certificats wildcard avec le challenge DNS-01 si votre fournisseur DNS est supporté (Cloudflare, DigitalOcean, AWS Route53, etc.).

Reverse proxy Traefik vs Caddy

Coolify v4 supporte deux reverse proxies :

• Traefik (par défaut) : puissant, flexible, avec dashboard intégré. Idéal pour les configurations avancées.
• Caddy : plus simple, HTTPS automatique par défaut, configuration minimaliste. Idéal pour les cas simples.

Vous pouvez changer de reverse proxy dans les paramètres du serveur. Notez que Coolify permet aussi de personnaliser la configuration du proxy pour chaque application si vous avez des besoins spécifiques (headers, rate limiting, etc.).

Variables d'environnement

La gestion des variables d'environnement dans Coolify est flexible et sécurisée :

Types de variables

• Variables d'application : spécifiques à une application, disponibles au build et/ou au runtime.
• Variables de build : uniquement disponibles pendant la phase de build (ex: API keys pour télécharger des assets privés).
• Variables partagées (Shared Variables) : définies au niveau du projet ou de l'équipe, réutilisables entre plusieurs applications.
• Variables preview : spécifiques aux déploiements de preview (branches de PR).

Bonnes pratiques

# Variables sensibles (mots de passe, API keys)
# → Toujours utiliser les "secrets" de Coolify (chiffrés dans la base)
DATABASE_URL=postgresql://user:password@host:5432/db
STRIPE_SECRET_KEY=sk_live_xxxxxxxxxxxxx

# Variables de configuration (non sensibles)
# → Peuvent être dans les variables normales
NODE_ENV=production
NEXT_PUBLIC_API_URL=https://api.votredomaine.fr
TZ=Europe/Paris

# Variables de build uniquement
# → Activez "Build Variable" pour ces variables
NPM_TOKEN=npm_xxxxxxxx
SENTRY_AUTH_TOKEN=sntrys_xxxxxxxx

Webhooks et Déploiement Automatique

Déploiement automatique via Git

Coolify supporte le déploiement automatique (CI/CD) de plusieurs manières :

• GitHub App webhooks : automatiquement configuré quand vous utilisez une GitHub App. Chaque push déclenche un déploiement.
• GitLab webhooks : configuré automatiquement via l'intégration OAuth.
• Webhook manuel : Coolify fournit une URL de webhook unique que vous pouvez configurer dans n'importe quel système de CI/CD.

Preview Deployments

Une fonctionnalité inspirée de Vercel : les Preview Deployments créent automatiquement un environnement temporaire pour chaque Pull Request.

1. Activez "Preview Deployments" dans les paramètres de l'application.
2. Quand une PR est ouverte, Coolify déploie automatiquement la branche sur un sous-domaine unique (ex: pr-42.app.votredomaine.fr).
3. Quand la PR est fusionnée ou fermée, l'environnement preview est automatiquement supprimé.

Intégration avec les pipelines CI/CD existants

# Déclencher un déploiement via webhook (depuis GitHub Actions, GitLab CI, etc.)
curl -X POST https://coolify.votredomaine.fr/api/v1/deploy \
  -H "Authorization: Bearer VOTRE_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "uuid": "uuid-de-votre-application",
    "force_rebuild": false
  }'

# Ou utiliser l'API Coolify directement dans un pipeline
# GitHub Actions exemple :
# .github/workflows/deploy.yml
# name: Deploy to Coolify
# on:
#   push:
#     branches: [main]
# jobs:
#   deploy:
#     runs-on: ubuntu-latest
#     steps:
#       - name: Trigger Coolify Deployment
#         run: |
#           curl -X POST "${{ secrets.COOLIFY_WEBHOOK_URL }}"

Serveurs multiples : Gérer une flotte de machines

Coolify peut gérer plusieurs serveurs distants depuis une seule interface. C'est idéal pour séparer les environnements (production, staging) ou distribuer la charge.

Ajouter un serveur distant

1. Allez dans Servers → Add Server.
2. Renseignez l'adresse IP, le port SSH et l'utilisateur (root recommandé).
3. Coolify utilise sa clé SSH pour se connecter au serveur distant.
4. Sur le serveur distant, ajoutez la clé publique de Coolify aux clés autorisées.

# Sur le serveur distant, préparer pour Coolify
# 1. Installer Docker
curl -fsSL https://get.docker.com | sh
systemctl enable --now docker

# 2. Ajouter la clé publique de Coolify
# (récupérez-la depuis l'interface Coolify → Servers → votre serveur → SSH Key)
echo "ssh-ed25519 AAAAC3NzaC... coolify" >> /root/.ssh/authorized_keys
chmod 600 /root/.ssh/authorized_keys

# 3. Vérifier la connectivité depuis le serveur Coolify
ssh -i /data/coolify/ssh/keys/id.root@host.docker.internal root@IP_SERVEUR_DISTANT

Stratégies de déploiement multi-serveurs

• Par environnement : production sur le serveur principal, staging sur un serveur secondaire.
• Par type de charge : applications sur un serveur, bases de données sur un autre.
• Par géographie : serveurs dans différentes régions pour la latence.
• Haute disponibilité : déployer la même application sur plusieurs serveurs avec un load balancer en amont.

Monitoring intégré

Coolify v4 intègre un système de monitoring basique mais fonctionnel :

• Métriques serveur : CPU, RAM, disque, réseau en temps réel.
• Logs d'application : accès aux logs stdout/stderr de chaque conteneur.
• Statut des déploiements : historique complet avec logs de build.
• Healthchecks : vérification automatique de la santé des applications.
• Notifications : alertes par email, Discord, Telegram, Slack quand un déploiement réussit ou échoue.

Configurer les notifications

1. Allez dans Settings → Notifications.
2. Ajoutez un canal de notification (Discord webhook, Telegram bot, Slack webhook, email SMTP).
3. Sélectionnez les événements à notifier : déploiement réussi, déploiement échoué, serveur hors ligne, backup terminé.

# Exemple de configuration SMTP pour les notifications email
# SMTP Host: smtp.mailgun.org
# SMTP Port: 587
# SMTP Username: postmaster@votredomaine.fr
# SMTP Password: votre-mot-de-passe
# From Address: coolify@votredomaine.fr
# To Address: admin@votredomaine.fr

Backups automatiques

Coolify intègre un système de sauvegarde pour les bases de données :

Configuration des backups

1. Dans les paramètres de chaque base de données, section "Backups".
2. Configurez la fréquence (cron expression) et la rétention.
3. Choisissez la destination : locale ou S3-compatible (AWS S3, MinIO, Backblaze B2, Cloudflare R2).

# Exemples de cron expressions pour les backups
# Toutes les heures
0 * * * *

# Tous les jours à 3h du matin
0 3 * * *

# Toutes les 6 heures
0 */6 * * *

# Chaque dimanche à minuit
0 0 * * 0

Stockage S3-compatible

Pour sauvegarder vos bases de données vers un stockage objet S3-compatible :

1. Allez dans Settings → S3 Storages → Add.
2. Configurez les paramètres de connexion.

# Configuration S3 pour Backblaze B2
# Endpoint: s3.us-west-001.backblazeb2.com
# Region: us-west-001
# Bucket: coolify-backups
# Access Key ID: votre-key-id
# Secret Access Key: votre-secret-key

# Configuration S3 pour MinIO (self-hosted)
# Endpoint: minio.votredomaine.fr
# Region: us-east-1
# Bucket: coolify-backups
# Access Key ID: minioadmin
# Secret Access Key: minioadmin
# Path Style: activé (important pour MinIO)

Services pré-configurés

Coolify propose un catalogue de services pré-configurés déployables en un clic. Parmi les plus populaires :

• CMS : WordPress, Ghost, Strapi, Directus, Payload CMS
• Analytics : Plausible, Umami, Matomo, PostHog
• Monitoring : Grafana, Uptime Kuma, Glances
• Communication : Mattermost, Rocket.Chat
• Stockage : MinIO, Nextcloud
• Development : Gitea, GitLab Runner, Supabase
• Email : Listmonk
• Automatisation : n8n, Activepieces
• Et bien d'autres : Appwrite, PocketBase, Dokuwiki, Trilium, Vaultwarden...

Chaque service est déployé avec sa configuration optimale et peut être personnalisé selon vos besoins.

Équipes et Permissions

Coolify v4 supporte la gestion multi-utilisateurs avec des rôles et permissions :

• Admin : accès complet à tous les serveurs, projets et paramètres.
• Member : accès aux projets assignés, peut déployer et gérer les applications.
• Viewer : accès en lecture seule aux projets assignés.

Pour ajouter un membre à votre équipe :

1. Allez dans Settings → Team → Invite.
2. Entrez l'adresse email du membre.
3. Un lien d'invitation est envoyé par email.
4. Le membre crée son compte et rejoint votre équipe.

Comparaison avec les alternatives

Coolify vs Heroku

Heroku a longtemps été la référence du PaaS, mais la suppression du plan gratuit en 2022 et les prix élevés ont poussé de nombreux développeurs vers des alternatives. Coolify offre une expérience similaire à Heroku mais gratuitement sur vos propres serveurs. Vous gardez le contrôle total de vos données et de vos coûts.

Coolify vs Vercel

Vercel excelle dans le déploiement d'applications frontend (Next.js en particulier). Coolify ne propose pas d'edge functions ni de CDN global, mais il supporte tous les types d'applications (pas seulement le frontend) et vous permet de déployer des bases de données, des services Docker Compose complexes et des applications backend complètes.

Coolify vs CapRover

CapRover est un concurrent direct de Coolify dans la catégorie PaaS self-hosted. Cependant, Coolify v4 le surpasse sur plusieurs points : interface plus moderne, support Docker Compose natif, preview deployments, meilleure gestion multi-serveurs, et développement plus actif.

Tarification : Vraiment gratuit ?

Coolify propose deux modèles :

Self-hosted (gratuit)

• 100% gratuit, sans limitations fonctionnelles.
• Vous payez uniquement votre serveur (VPS, serveur dédié, homelab).
• Toutes les fonctionnalités sont disponibles.
• Pas de limites sur le nombre d'applications, de serveurs ou d'utilisateurs.
• Support communautaire (Discord, GitHub).

Coolify Cloud (payant)

• Coolify gère l'infrastructure pour vous (installation, mises à jour, maintenance).
• À partir de 5$/mois par serveur géré.
• Pas de markup sur les coûts des serveurs (vous apportez votre propre serveur via Hetzner, DigitalOcean, etc.).
• Support prioritaire.

Coût réel du self-hosting

# Estimation des coûts mensuels pour héberger vos applications

# Option 1 : VPS Hetzner (excellent rapport qualité/prix)
# CX32 : 4 vCPU, 8 Go RAM, 80 Go SSD → ~7€/mois
# Peut héberger : 5-15 applications + bases de données

# Option 2 : Homelab (coût unique)
# Mini PC Intel N100 : ~150€
# + Électricité : ~5-10€/mois
# Peut héberger : 10-20 applications

# Comparaison avec Heroku :
# 5 applications Heroku en "Eco" : 5 × 5$ = 25$/mois
# + PostgreSQL Mini : 5 × 5$ = 25$/mois
# Total Heroku : ~50$/mois

# Avec Coolify sur Hetzner : ~7€/mois pour la même chose (ou plus)
# Économie annuelle : ~500€ !

Limitations et points d'attention

Malgré ses nombreuses qualités, Coolify a certaines limitations à connaître :

• Pas de CDN/Edge : contrairement à Vercel, Coolify n'offre pas de réseau de distribution de contenu global. Vos applications sont servies depuis votre serveur unique. Solution : utilisez Cloudflare en proxy devant Coolify.
• Pas de serverless/edge functions : Coolify exécute des conteneurs Docker, pas des fonctions serverless. Les applications Next.js en mode edge ne sont pas supportées de la même manière que sur Vercel.
• Scaling horizontal limité : Coolify ne gère pas nativement le load balancing entre plusieurs instances d'une même application. Vous pouvez le configurer manuellement avec un reverse proxy externe.
• Monitoring basique : le monitoring intégré est fonctionnel mais limité comparé à des solutions dédiées comme Datadog ou New Relic. Pour un monitoring avancé, déployez Grafana + Prometheus via Coolify.
• Responsabilité opérationnelle : en self-hosting, vous êtes responsable de la maintenance du serveur, des mises à jour de sécurité et des sauvegardes. C'est le prix de la liberté.
• Single point of failure : si votre serveur tombe, toutes vos applications sont indisponibles. Mitigez avec des sauvegardes régulières et un plan de disaster recovery.

Bonnes pratiques et conseils

Sécurité

• Mettez à jour Coolify régulièrement : les mises à jour se font en un clic depuis l'interface ou automatiquement.
• Utilisez un firewall (UFW ou iptables) : n'exposez que les ports 80, 443 et 22 (SSH).
• Changez le port SSH et désactivez l'authentification par mot de passe.
• Activez les sauvegardes automatiques vers un stockage S3 externe.
• Utilisez des domaines plutôt que des IPs pour le SSL.

# Configuration UFW recommandée pour un serveur Coolify
ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp    # SSH (changez si port custom)
ufw allow 80/tcp    # HTTP (Let's Encrypt + redirection)
ufw allow 443/tcp   # HTTPS
ufw enable

# Vérifier les règles
ufw status verbose

Performance

• Utilisez un SSD NVMe : les performances de build et de démarrage sont directement liées aux performances disque.
• Nettoyez régulièrement les images Docker : les builds successifs accumulent des images inutilisées.
• Utilisez le mode standalone pour Next.js : réduit la taille de l'image Docker de manière significative.
• Configurez les healthchecks : permettent à Coolify de redémarrer automatiquement les applications défaillantes.

# Nettoyage Docker périodique (à ajouter en cron)
docker system prune -af --volumes --filter "until=168h"

# Vérifier l'utilisation disque Docker
docker system df -v

Organisation

• Un projet par client ou par domaine : facilite la gestion et la facturation.
• Utilisez les environnements : production, staging, development dans chaque projet.
• Documentez vos variables d'environnement : gardez un fichier .env.example à jour dans chaque dépôt.
• Testez les déploiements en staging avant la production.

Conclusion : Coolify, la liberté du déploiement

Coolify v4 a réussi le pari ambitieux de créer un PaaS self-hosted véritablement utilisable. En 2025-2026, il n'est plus nécessaire de choisir entre la simplicité de Heroku/Vercel et le contrôle du self-hosting. Coolify vous offre les deux.

Les raisons d'adopter Coolify sont nombreuses :

• Économies considérables : un VPS à 7€/mois remplace des centaines d'euros de services cloud.
• Souveraineté des données : vos données restent sur vos serveurs, dans la juridiction de votre choix.
• Flexibilité totale : déployez n'importe quelle application, dans n'importe quel langage, avec n'importe quelle base de données.
• Simplicité d'utilisation : l'interface intuitive rend le déploiement accessible même aux développeurs sans expérience ops.
• Communauté active : un projet en pleine croissance avec des mises à jour fréquentes et un support communautaire réactif.

Si vous êtes développeur, freelance ou une petite équipe, Coolify est probablement l'outil qui transformera votre workflow de déploiement. Installez-le, déployez votre première application, et vous ne voudrez plus jamais revenir en arrière.

La commande magique pour commencer :

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

Votre propre Heroku vous attend.