Déployer une application Replit sur VPS LWS avec Gitea + Dokploy – Guide complet DevOps

Mettre en place un workflow DevOps moderne est aujourd’hui indispensable pour garantir un déploiement d’application rapide, fiable et reproductible.⚡ Ce tutoriel vous guide pas à pas dans la création d’un pipeline performant basé sur le trio Replit ➜ Gitea ➜ Dokploy, un flux simple mais extrêmement puissant pour passer du code au serveur de production en quelques secondes. Grâce à l’éditeur cloud Replit, vous développez et versionnez votre code n’importe où. 💥Avec Gitea, vous centralisez vos dépôts dans un espace totalement maîtrisé. Enfin, Dokploy orchestre vos containers Docker et automatise vos déploiements.🐱‍👓

L’ensemble s’appuie sur un VPS LWS, reconnu pour sa stabilité, ses performances et sa compatibilité native avec Docker, Docker Compose et les environnements DevOps modernes. ✨Vous profitez ainsi d’une infrastructure sécurisée, d’une gestion serveur simplifiée et d’une base parfaitement adaptée aux workflows professionnels. Que vous développiez un projet personnel, une API, une application SaaS ou un environnement multi-services, ce guide vous permettra d’implémenter une architecture DevOps robuste, évolutive et entièrement automatisée. Préparez-vous à déployer une application Replit tout en mettant en place un pipeline rapide, sécurisé et prêt pour la montée en charge.🎉

Objectif

✨Cet article a pour objectif d’expliquer comment construire un workflow DevOps complet, moderne et automatisé, en reliant Replit, Gitea et Dokploy dans un pipeline simple et performant. ⚡Il vise à aider les développeurs à comprendre comment gérer un déploiement d’application fluide, sécurisé et reproductible, depuis l’écriture du code jusqu’à la mise en production. 👇L’objectif est aussi de montrer comment utiliser un VPS LWS, Docker et le déploiement continu pour obtenir une infrastructure professionnelle. Grâce à ce guide, vous pourrez déployer plus vite, éviter les erreurs et améliorer fortement votre productivité quotidienne.🎉

Pré-requis

Pour réussir ce workflow DevOps, vous devez vous appuyer sur une infrastructure stable, performante et compatible Docker. Les VPS LWS offrent précisément l’environnement idéal pour un pipeline Replit ➜ Gitea ➜ Dokploy fiable.

Voici les prérequis recommandés :

• Un VPS LWS KVM M ou supérieur, doté d’un CPU dédié, de 4 à 8 Go de RAM, et d’un stockage NVMe, indispensable pour accélérer les builds Docker, les dépôts Gitea, et les déploiements Dokploy.

• Le template Dokploy LWS préinstallé, compatible Docker Engine + Docker Compose, avec un kernel optimisé et isolement KVM complet.

• Un réseau 1 Gbit/s LWS, garantissant des pushes rapides depuis Replit et des pulls instantanés dans Dokploy.

• Un nom de domaine configuré (A/AAAA) pointant vers l’IP du VPS (ex : git.mondomaine.com, app.mondomaine.com).

• Un environnement VPS sécurisé LWS : firewall actif, ports restreints, snapshots automatiques, monitoring système intégré, accès SSH protégé.

• Des tokens dédiés pour Replit, Gitea et Dokploy afin d’isoler chaque étape du pipeline.

• Un projet Replit propre contenant votre code source prêt à être dockerisé.

Besoin d’un serveur VPS performant et flexible ?

Découvrez nos offres VPS KVM haut de gamme : des ressources garanties et un contrôle total pour vos projets. Profitez d’un hébergement 100 % SSD, d’un accès root complet, le tout dans un datacenter en France. Démarrez dès maintenant à partir de 4,99 €/mois !

Je choisis mon VPS KVM

Déployer une application Replit : comment connecter Gitea, Replit et Dokploy

Étape 1 : Installer Gitea via Dokploy

Mettre en place un serveur Gitea constitue la première fondation essentielle de votre workflow DevOps. Cette étape transforme votre VPS LWS en véritable plateforme Git privée, parfaitement adaptée au déploiement d’application, à la gestion de versions et au travail collaboratif. L’objectif est de disposer d’un espace sécurisé où centraliser votre code avant son envoi vers Dokploy, qui se chargera ensuite du déploiement.

Grâce aux templates intégrés, Dokploy simplifie l’installation de Gitea au point qu’aucune compétence avancée n’est requise. Vous allez créer un projet, ajouter un service, configurer votre domaine, vérifier le SSL, puis finaliser l’installation depuis l’interface web Gitea.

Avant de commencer, assurez-vous toujours que votre VPS KVM fonctionne correctement. Le modèle recommandé reste le KVM M, car il offre des ressources suffisantes pour supporter Gitea, Dokploy et les applications que vous déploierez plus tard. Sur le serveurs LWS, Dokploy est déjà installé. Si ce n’est pas encore fait, utilisez simplement le template fourni par LWS, puis suivez la documentation officielle. Une fois connecté à Dokploy, vous verrez un tableau de bord clair, avec un menu latéral donnant accès aux projets, services, logs, déploiements et configurations Git.

Commencez par créer un espace dédié à Gitea. Dans le menu principal de Dokploy, cliquez sur l’onglet « Projects », puis sur le bouton «+ Créer un projet ».

Nommez ce projet “gitea” afin de garder une structure cohérente. Les noms courts et explicites facilitent la maintenance et l’organisation générale de votre pipeline DevOps. Une fois le projet créé, vous êtes redirigé vers un espace vide prêt à accueillir des services.

Dans ce projet, cliquez sur le bouton « + Créer un service ». Une fenêtre vous propose plusieurs options, notamment Dockerfile, Compose, et surtout Template. Cette dernière option correspond à des services préconfigurés maintenus par l’équipe Dokploy. Cliquez donc sur le champ « Template ». Puis faites défiler la liste jusqu’à trouver l’option « Gitea (SQLite) ». SQLite convient parfaitement pour un usage personnel ou pour un petit projet, car il évite la gestion d’une base externe. Cliquez ensuite sur le bouton « Confirmer » pour déclencher l’installation initiale.

Lorsque Dokploy ouvre la page de votre service Gitea, vous découvrez plusieurs onglets. Celui qui nous intéresse immédiatement est l’onglet “Domains”. Vous devez y définir le domaine ou le sous-domaine qui pointera vers votre interface Gitea en cliquant sur le bouton « Ajouter un domaine ».

Par exemple, vous pouvez choisir git.mondomaine.com. Dans la même section, activez le SSL automatique. Dokploy utilise Let’s Encrypt pour générer un certificat sécurisé en un clic. Le https est indispensable pour Gitea, car vous allez y manipuler des identifiants, des tokens et des dépôts privés. Cliquez sur le bouton « Create » pour valider la configuration du domaine.Rendez-vous maintenant dans l’onglet « Général ». Cliquez sur le bouton « Deployer » afin de lancer la création des conteneurs.

Dokploy construit le service Gitea, démarre les conteneurs nécessaires, puis signale le statut « Running » lorsque tout fonctionne correctement. Cette étape marque la mise en ligne technique de votre serveur Git. Gitea est désormais accessible depuis votre domaine.

Il est temps de finaliser l’installation depuis l’interface Gitea. Cliquez sur votre domaine pour ouvrir la page d’installation. Gitea détecte automatiquement la configuration Dokploy. La majorité des paramètres peuvent rester tels quels. Laissez la base SQLite activée. Vérifiez les chemins préremplis, puis validez.

La page suivante vous demande de créer votre compte Administrateur. Utilisez un mot de passe sécurisé et conservez vos identifiants.Ce compte vous permettra de gérer les dépôts, les permissions et les tokens d’accès nécessaires lors du déploiement d’application. Une fois connecté, explorez rapidement l’interface Gitea. Vous verrez des menus pour les dépôts, les organisations, les applications, les tokens personnels et les paramètres.

Exemple typique

Pour illustrer cette étape, supposons que vous créez un dépôt nommé fastapi-demo dans votre Gitea. Ce dépôt reste entièrement vide, sans README, ni .gitignore, ni licence — conformément à la structure attendue par Replit et Dokploy.

Nom du dépôt : fastapi-demo
Visibilité : Privé
Branche par défaut : main
Description : Petite application FastAPI destinée au déploiement via Dokploy.

Ensuite, vous créez un token personnel appelé replit-sync-token, avec uniquement :

repo: read/write

user: none

admin: none

Ce token permet à Replit d’envoyer du code, sans exposer d’accès administratifs dangereux.

Ce dépôt servira ensuite de source Git officielle pour Dokploy. Grâce à cette organisation, vous avez une base propre, sans fichiers parasites, conforme aux bonnes pratiques DevOps recommandées dans le document d’amélioration.

Pour accompagner cette installation, il est utile de consulter la documentation officielle de Dokploy afin d’approfondir vos connaissances sur les paramètres utilisés et d’autres conditions techniques qui peuvent s’averer nécéssaire.

Étape 2 : Dockeriser l’application sur Replit

La dockerisation permet d’assurer un déploiement d’application propre, stable et reproductible. Votre serveur Dokploy ne peut lancer votre projet que si vous lui fournissez une configuration claire. Cette configuration prend la forme d’un Dockerfile pour construire l’application, et d’un fichier docker-compose.yml pour orchestrer l’ensemble des services nécessaires. Sur Replit, ces fichiers peuvent être générés automatiquement grâce à l’IA intégrée. Cela simplifie le travail et garantit une structure fiable dès le début.

Commencez par ouvrir votre projet dans Replit. Ouvrez ensuite la zone de discussion de l’IA. Vous allez demander à l’assistant de produire deux fichiers essentiels. Ces fichiers doivent être optimisés pour la production, propres et compatibles avec Dokploy. Utilisez le prompt suivant afin d’obtenir une configuration complète :

• « Génère un Dockerfile optimisé pour cette application, idéalement en multi-stage build ».

• Génère ensuite un fichier docker-compose.yml comportant deux services :
  • app : construit à partir du Dockerfile,
  • db : basé sur l’image officielle PostgreSQL.

• Ajoute un volume persistant pour Postgres afin de conserver les données.

• Utilise des variables d’environnement pour les identifiants de la base. »

Une fois que les fichiers sont générés, vérifiez que docker-compose.yml se trouve bien à la racine du projet. Ouvrez ensuite le Dockerfile pour valider chaque instruction. Replit vous permet également de tester la construction localement afin de corriger d’éventuelles erreurs. Cette étape garantit une base solide pour le futur déploiement sur Dokploy.

Dans notre exemple typique

Voici une petite application FastAPI idéale pour illustrer la création des fichiers Docker :

project/
│── main.py
│── requirements.txt
│── Dockerfile
│── docker-compose.yml
│── .env.example

• Contenu du fichier main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def home():
    return {"message": "Déploiement d'application réussi avec Replit ➜ Gitea ➜ Dokploy 🚀"}

• requirements.txt

fastapi
uvicorn[standard]
psycopg2-binary

• Dockerfile sécurisé

FROM python:3.11-slim AS base

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "5000"]

• docker-compose.yml sécurisé

version: '3.9'

services:
  app:
    build: .
    ports:
      - "5000:5000"
    env_file:
      - .env
    depends_on:
      - db

  db:
    image: postgres:16
    environment:
      POSTGRES_DB: appdb
      POSTGRES_USER: appuser
      POSTGRES_PASSWORD: appsecret
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Cette documentation Replit vous permettra d’explorer les formats de fichiers, les configurations multi-services et les optimisations possibles pour un environnement de production.

Étape 3 : Connecter Replit à Gitea

Pour réussir un workflow DevOps moderne, vous devez créer un lien fluide entre Replit et Gitea. Cette étape vous permet de transformer votre projet local en code versionné et immédiatement prêt pour le déploiement d’application sur Dokploy. L’idée est simple : Replit écrit, Gitea centralise, Dokploy déploie. Vous allez donc créer un dépôt Git propre, générer un token sécurisé, puis envoyer votre projet vers votre serveur privé.

1. Préparer le dépôt sur Gitea

Commencez par ouvrir votre tableau de bord Gitea. Cliquez sur « + » pour créer un nouveau dépôt. Donnez-lui un nom clair, par exemple mon-app, afin de structurer votre organisation. Laissez l’option « Initialiser le dépôt » décochée, car Replit enverra les premiers fichiers.Ensuite, ouvrez votre profil utilisateur. Accédez à la section « Configuration → Applications » pour créer un token sécurisé.

Ce token servira d’identifiant entre Replit et Gitea. Choisissez un nom lisible, comme replit-sync, puis cochez l’accès « Lecture/écriture » pour autoriser la modification du dépôt. Cliquez sur le bouton « Generer un jeton ».

Copiez-le immédiatement, et conservez-le dans un endroit sûr.

2. Connecter Replit à Gitea

Revenez dans Replit et ouvrez le Shell, car c’est ici que la synchronisation sera configurée.

Ajoutez l’origine Git en utilisant votre utilisateur Gitea et votre token :

git remote add origin https://VOTRE_USER:VOTRE_TOKEN@git.votre-domaine.com/VOTRE_USER/mon-app.git

Exemple que vous pouvez utiliser :

git remote add origin https://cedric:0caa38ebfa…@git.monserveur.com/cedric/taskflowhub.git

Ensuite, poussez votre code vers Gitea :

git push -u origin main

git init
git add .
git commit -m "Initial commit"
git branch -M main
git remote add origin https://cedric:REPLIT_TOKEN@git.mondomaine.com/cedric/fastapi-demo.git
git push -u origin main

git remote add origin https://cedric:$GITEA_TOKEN@git.mondomaine.com/cedric/fastapi-demo.git

Étape 4 : Déployer l’application sur Dokploy (Méthode HTTPS + Token)

Le déploiement d’application constitue le cœur du workflow DevOps. À cette étape, votre code déjà synchronisé avec Gitea doit être récupéré automatiquement par Dokploy, qui lancera ensuite votre infrastructure Docker selon votre fichier docker-compose.yml. Cette étape repose sur l’authentification HTTPS via token, une méthode simple, sécurisée et parfaitement adaptée aux environnements modernes.

L’objectif est clair : créer une connexion stable entre Gitea et Dokploy, configurer un service Compose pleinement fonctionnel, assigner un domaine, activer le SSL et préparer votre application pour la suite du pipeline DevOps.

1. Créer un Token pour Dokploy (sur Gitea)

Pour commencer, connectez-vous à votre instance Gitea. Ce token permettra à Dokploy d’accéder à votre dépôt sans utiliser de mot de passe ou de clé SSH. Ouvrez votre profil utilisateur, puis accédez à la section « Configuration → Applications ». Cliquez sur l’option « Nouvelle OAuth2 Application ». Entrez un nom explicite comme dokploy-pull, afin d’identifier facilement son rôle.

Dans le champ “Redirect URI”, renseignez précisément l’URL de callback Dokploy. Par exemple :

https://votre-vps.serveur-vps.net/api/providers/gitea/callback

Il est essentiel d’indiquer l’URL correcte pour permettre l’échange sécurisé entre Dokploy et Gitea.

Validez la création. Gitea génère alors un Client ID et un Client Secret. Le secret n’apparaît qu’une seule fois : copiez-le immédiatement dans un endroit sûr. Ce token fait office de certificat d’accès entre votre forge Git et votre orchestrateur de déploiement.

2. Connecter Gitea à Dokploy

Rendez-vous maintenant dans votre tableau de bord Dokploy. Sur la barre latérale, ouvrez la section « Git », puis sélectionnez l’option « Gitea ». Vous allez ici ajouter la connexion sécurisée à votre instance Git.

Remplissez les champs :

• Nom du provider (ex : Gitea-LWS)

• URL publique de votre instance : https://git.votre-domaine.com

• Votre Client ID

• Votre Client Secret

Une fois validé, Dokploy peut officiellement communiquer avec Gitea. C’est la fondation même du pipeline : sans cette liaison, aucun déploiement automatisé n’est possible.

3. Créer un service Docker Compose pour votre application

Ouvrez ensuite le projet cible, souvent appelé Prod ou App selon l’usage. Cliquez sur l’option « Create Service », puis choisissez l’option « Compose ». Donnez-lui un nom simple, comme Appxxx, puis validez.

À l’intérieur du service nouvellement créé, sélectionnez le provider Gitea.

Choisissez votre compte, puis votre dépôt, enfin votre branche principale (généralement main). Cliquez sur le bouton « Save ». Dokploy sait désormais où récupérer votre code et quels fichiers Docker utiliser. Le fichier docker-compose.yml guidera entièrement le lancement des conteneurs. Cette approche DevOps garantit une reproductibilité parfaite, car l’infrastructure est définie dans le dépôt lui-même.

4. Déployer l’application

Cliquez maintenant sur le bouton « Deploy ». Dokploy se connecte à Gitea via votre token, télécharge le dépôt, lit le docker-compose.yml, puis construit et lance les conteneurs définis. Si votre application utilise Postgres, Redis ou toute autre dépendance, le docker-compose les gère automatiquement. Vous obtenez une architecture complète, durable et parfaitement orchestrée en quelques clics.

Une fois le statut “Running” affiché, Dokploy met à disposition les logs en temps réel. Vous pouvez vérifier chaque étape, repérer la création des conteneurs et valider l’exposition des ports.

5. Configurer le domaine et le SSL

Pour rendre votre application accessible publiquement, ouvrez l’onglet « Domains ».  Ajoutez votre domaine, par exemple :
app.votre-domaine.com.

Sélectionnez l’option « Enable SSL », puis choisissez « Let’s Encrypt ». Dokploy génère automatiquement un certificat valide et configure le HTTPS. Assurez-vous que le port indiqué dans votre service correspond bien à celui exposé dans votre Dockerfile (ex : 3000, 5000 ou 8080).

Cette étape garantit que votre application répond correctement sur votre URL publique.

6. Recharger l’application

Depuis l’onglet « General », cliquez sur l’option « Reload » . Cela permet à Dokploy de recharger la configuration sans redéployer entièrement l’application. Votre environnement est maintenant prêt pour la mise en production continue. Dès que vous pousserez une modification depuis Replit avec :

git push -u origin main

Dokploy pourra récupérer automatiquement les mises à jour et relancer le déploiement.

Étape 5 : Automatisation (CD) – Déploiement continu avec Gitea et Dokploy

L’automatisation du déploiement d’application constitue la dernière pièce essentielle de votre workflow DevOps. Après avoir relié Replit à Gitea, puis configuré Dokploy pour qu’il déploie votre application à la demande, il est maintenant temps d’activer le déploiement continu.

Cette étape permet à votre application d’être mise à jour automatiquement après chaque modification envoyée dans votre dépôt. Vous n’avez plus besoin d’intervenir manuellement : le pipeline se déclenche seul, surveille les commits, récupère le code, reconstruit les conteneurs, redémarre vos services et déploie la nouvelle version en production.

Le but est d’obtenir un environnement agile, propre et extrêmement réactif aux changements.

1. Comprendre le rôle du Webhook dans Gitea

Pour automatiser ce pipeline, vous allez utiliser un webhook Gitea. Un webhook est un petit mécanisme qui déclenche une action lorsqu’un événement se produit. Ici, l’événement est un git push depuis Replit ou un autre client Git. Dès que du code est poussé, Gitea envoie instantanément une requête HTTP vers Dokploy.

Cette requête contient des informations sur la branche, le commit et l’état du dépôt. Dokploy vérifie ensuite que le hook est valide, puis enclenche la séquence de déploiement.

Ce système est extrêmement fiable. Il évite d’avoir un serveur qui interroge régulièrement Gitea, ce qui serait lent et inefficace. À la place, Dokploy reçoit un signal immédiat et peut réagir en temps réel. C’est exactement ce que l’on attend d’un workflow DevOps moderne : des réponses rapides, des déploiements continus et une chaîne automatisée du code jusqu’à la production.

2. Récupérer l’URL du Webhook dans Dokploy

Connectez-vous à votre interface Dokploy. Ouvrez votre projet, puis votre service Compose associé à votre application. Rendez-vous dans l’onglet « Deployments ». Dokploy fournit une Webhook URL unique. Elle ressemble généralement à ceci :

https://votre-vps.serveur-vps.net/api/webhooks/project/xxxxx

Cette URL est essentielle. Chaque fois qu’elle recevra une requête POST, Dokploy lancera un nouveau déploiement basé sur votre fichier docker-compose.yml et les données de votre dépôt Gitea.
Copiez cette URL. Vous allez maintenant la coller dans votre dépôt Git pour finaliser l’automatisation.

3. Ajouter un Webhook sur Gitea

Retournez dans votre instance Gitea, ouvrez votre dépôt principal. Dans le menu latéral, cliquez sur l’option « Settings », puis sur l’option « Webhooks ». Cliquez sur le bouton « Ajouter un Webhook », puis choisissez “Gitea Webhook”.Collez l’URL Webhook fournie par Dokploy. Dans le champ « Content Type », choisissez l’option « Application/json ». Définissez ensuite la méthode sur POST, car Dokploy attend obligatoirement ce type de requête. Enfin, dans la section “Trigger On”, cochez Push Events.
Cela signifie que chaque fois qu’un push est effectué sur votre branche principale, Gitea déclenchera Dokploy. Enregistrez le webhook.

Vous pouvez lancer un test en utilisant le bouton “Test Delivery” pour vérifier que Dokploy reçoit bien les requêtes. Si la réponse est positive, la chaîne CI/CD est officiellement activée. Vous pouvez gérer tous vos webhooks depuis l’interface.

Pour notre application développée précédement, voici un exemple de webhook :

POST https://vps12345.serveur-vps.net/api/v1/webhooks/deploy/fastapi-demo

4. Comment fonctionne le déploiement automatique ?

À partir de maintenant, la séquence suivante s’exécute automatiquement :

• Vous modifiez votre code dans Replit.

• Vous committez vos changements.

• Vous envoyez votre code avec :

git push -u origin main

• Gitea détecte un nouveau push.

• Le webhook envoie immédiatement une requête POST vers Dokploy.

• Dokploy récupère le dépôt, reconstruit l’image Docker, relance vos conteneurs.

• La nouvelle version de votre application est en ligne.

Ce déploiement continu élimine totalement la nécessité de se connecter au serveur ou de relancer manuellement les services. Vous gagnez en efficacité, en rapidité, et surtout en fiabilité.

5. Avantages du déploiement continu avec Dokploy

• La fluidité : votre application évolue en permanence. Vous pouvez tester rapidement de nouvelles fonctionnalités, corriger un bug, améliorer un module, tout cela sans vous soucier de l’environnement de production.
• La cohérence : le docker-compose assure que votre infrastructure est identique entre développement et production. Aucune différence de configuration.
• Enfin, vous bénéficiez d’une sécurité accrue : en automatisant le processus, vous limitez les erreurs manuelles, les oublis de commandes, les déploiements incomplets. Tout est documenté, tracé, encadré.

6. Votre pipeline DevOps est maintenant complet

Vous avez désormais un pipeline entièrement opérationnel : Replit → Gitea → Dokploy → Production automatique
Chaque push devient un déploiement. Chaque changement devient une mise à jour en ligne.

Bonnes pratiques & sécurité DevOps 

Dans un workflow DevOps hébergé sur un VPS LWS, la sécurité n’est pas optionnelle : elle constitue le socle même de la stabilité et de la continuité de service. Avant de déployer votre première application, plusieurs mesures essentielles doivent être appliquées pour éviter les fuites de données, les intrusions ou les erreurs de configuration. Voici les pratiques indispensables :

• Utiliser des variables d’environnement sécurisées (.env) : jamais de mots de passe ou clés API dans le Dockerfile ou dans le code. Sur un VPS LWS, stockez-les via Dokploy ou via les variables système du serveur, chiffrées côté serveur.

• Activer systématiquement le firewall du VPS LWS : fermez tous les ports sauf ceux strictement nécessaires (80, 443, et éventuellement le port interne de l’app). Cela bloque la majorité des tentatives automatisées d’intrusion.

• Limiter les accès Gitea / Dokploy via tokens : utilisez un token dédié à Dokploy + un token dédié à Replit. Ne réutilisez jamais le même secret pour plusieurs services.

• Sauvegarder régulièrement via snapshots VPS LWS : avant toute mise à jour majeure (Docker, Gitea, Dokploy), créez un snapshot complet depuis le Panel LWS pour pouvoir revenir en arrière instantanément.

Erreurs fréquentes & dépannages

Même avec un workflow parfaitement configuré, certaines erreurs courantes peuvent bloquer le déploiement. Sur un VPS LWS, elles sont faciles à identifier et corriger. Voici les problèmes les plus fréquents et leurs solutions :

• Port Docker ≠ Port Dokploy : si votre app écoute en interne sur le port 5000 mais que Dokploy expose le port 80/443, vous devez ajuster ports: dans docker-compose. Sinon, le domaine affichera une erreur 502.

• Propagation DNS incomplète : lors de l’ajout d’un domaine (ex : app.mondomaine.com), attendez 5–30 minutes pour que le DNS LWS se propage correctement. Sinon, le SSL Let’s Encrypt échouera.

• Token Gitea incorrect ou expiré : lorsqu’un déploiement échoue dans Dokploy, vérifiez que le token OAuth Gitea est encore valide. Regénérez-le si nécessaire.

• Images Docker trop lourdes ou build qui échoue : sur certains VPS, un build trop lourd saturera la RAM. Utilisez un Dockerfile en multi-stage pour réduire la taille et permettre un build rapide.

• Variable d’environnement manquante (.env) : une simple variable absente peut bloquer l’app. Vérifiez la section “Environment” dans Dokploy avant chaque déploiement.

Besoin d'un serveur privé virtuel VPS sécurisé ?

LWS vous conseille sa formule d’hébergement sur VPS en promotion à -75% (offre à partir de 4,99€ par mois au lieu de 19,99 €). Non seulement les performances sont au rendez-vous mais vous profitez en plus d’un support exceptionnel.

Découvrir l'offre

Conclusion

👇Ce tutoriel vous a permis de mettre en place un workflow DevOps complet regroupant Replit, Gitea et Dokploy dans un enchaînement fluide, cohérent et moderne. Vous disposez désormais d’une chaîne d’intégration et de déploiement d’application entièrement automatisée, capable de transformer chaque modification de code en mise à jour fiable et immédiate de votre environnement de production. Grâce à cette architecture, vous gagnez en vitesse, en précision, en qualité et en productivité. ✨Ce workflow repose sur trois piliers essentiels. D’abord Replit, qui sert d’environnement de développement rapide, flexible et assisté par IA. Ensuite Gitea, qui joue le rôle de plateforme Git auto-hébergée, sécurisée et parfaitement adaptée à une infrastructure privée. ✔Enfin Dokploy, qui assure l’orchestration complète du déploiement via Docker et docker-compose. L’ensemble forme une chaîne robuste et scalable.

Vous disposez maintenant d’un socle DevOps professionnel, capable de soutenir un projet moderne et évolutif. Et sis vous avez des questions, des ajouts ou des suggestions sur la façon de connecter Replit, Dokploy et Gitea et développer des applications en continu, écrivez-nous dans la section prévue pour les commentaires.