---
title: Récupérer un projet via Git : du clone au serveur
source: https://synapx.fr/blog/recuperer-projet-git-serveur/
date: 2026-06-26
category: Développement
site: SynapxLab
---

# Récupérer un projet via Git : du clone au serveur

Reprendre un projet existant — sur sa machine ou directement sur un serveur — repose sur quelques commandes essentielles. Ce guide va à l'essentiel : **cloner rapidement**, **installer**, **lancer**, puis aborder la **version serveur** pour déployer et mettre à jour en production.

> L'objectif : passer d'« un dépôt Git disponible » à « un projet opérationnel » le plus rapidement possible, sans erreur de séquence.

## 1. Récupérer le projet rapidement

```bash
# Cloner le dépôt
git clone https://github.com/compte/projet.git
cd projet

# Plus rapide sur un gros dépôt : clone superficiel (1 seul niveau d'historique)
git clone --depth 1 https://github.com/compte/projet.git

# Récupérer une branche précise directement
git clone -b ma-branche --single-branch <url>
```

**Mettre à jour un projet déjà cloné :**

```bash
git pull                      # récupère et fusionne les derniers changements
git fetch --all              # récupère tout sans fusionner (pour inspecter d'abord)
git checkout <branche>        # basculer sur la bonne branche
```

## 2. Installer les dépendances

Selon la stack du projet, le fichier manifeste vous indique la commande adaptée :

```bash
# Node.js  (package.json)
npm install            # ou : npm ci  (plus rapide et fiable en CI/prod)

# PHP  (composer.json)
composer install

# Python  (requirements.txt)
pip install -r requirements.txt

# Flutter / Dart  (pubspec.yaml)
flutter pub get
```

> 💡 En production, privilégiez les variantes **déterministes** : `npm ci` (respecte le lockfile), `composer install --no-dev --optimize-autoloader`.

## 3. Configurer

La plupart des projets fournissent un fichier d'exemple à copier :

```bash
cp .env.example .env          # puis éditer .env (BDD, clés API, etc.)
nano .env
```

> ⚠️ Le fichier `.env` contient des **secrets** : il est, et doit rester, dans le `.gitignore`. Il ne doit **jamais** être versionné.

## 4. Lancer en local

```bash
# Node
npm run dev            # ou npm start

# PHP (serveur intégré)
php -S localhost:8000 -t public

# Python
python app.py          # ou : flask run / uvicorn main:app

# Flutter
flutter run
```

## 5. Version serveur (déploiement & mises à jour)

Sur un serveur, le principe reste identique, avec quelques précautions supplémentaires.

### Première mise en place

```bash
# Se connecter au serveur
ssh utilisateur@mon-serveur.fr

# Cloner dans le dossier web
cd /var/www
git clone <url> monprojet
cd monprojet

# Installer en mode production
composer install --no-dev --optimize-autoloader   # (exemple PHP)
cp .env.example .env && nano .env                  # config de prod
```

### Authentifier le serveur auprès de Git

Pour un dépôt **privé**, le serveur doit disposer d'un accès. La méthode la plus propre consiste à utiliser une **clé de déploiement** (*deploy key*) en lecture seule.

```bash
# Sur le serveur : générer une clé dédiée (sans passphrase pour l'automatisation)
ssh-keygen -t ed25519 -f ~/.ssh/deploy_monprojet -N ""

# Afficher la clé publique → à ajouter dans GitHub
#   Repo → Settings → Deploy keys → Add deploy key (lecture seule)
cat ~/.ssh/deploy_monprojet.pub
```

### Mettre à jour (le déploiement au quotidien)

```bash
cd /var/www/monprojet
git pull origin main           # récupère la dernière version
composer install --no-dev      # met à jour les dépendances si nécessaire
# (recharger le service : php-fpm, pm2 restart, systemctl restart…)
```

> 🛟 **Bonne pratique :** déployez depuis une **branche stable** (`main` ou `prod`), jamais depuis une branche de travail. Conservez également une copie de `.env` **hors du dépôt** (sauvegarde).

### Le piège classique : les modifications locales sur le serveur

Si un fichier a été modifié directement sur le serveur, `git pull` peut se bloquer. Pour repartir **proprement** depuis la version du dépôt :

```bash
git fetch origin
git reset --hard origin/main   # ⚠️ écrase les modifs locales du serveur
git clean -fd                  # supprime les fichiers non suivis
```

> ⚠️ Cette opération est destructrice : ne l'utilisez que si les modifications locales du serveur **ne doivent pas être conservées** (le serveur doit refléter le dépôt, et non l'inverse).

## 6. Récapitulatif express

```bash
git clone <url> && cd projet      # 1. récupérer
npm ci            # (ou composer install / pip install -r…)  2. installer
cp .env.example .env              # 3. configurer
npm run dev       # (ou la commande de lancement)  4. lancer
# Sur serveur : git pull + install + recharger le service
```

---

> Récupérer un projet Git suit **toujours la même logique** : *cloner → installer → configurer → lancer*. Sur un serveur, il faut simplement ajouter l'**authentification** (*deploy key*) et la **discipline d'exploitation** (branche stable, `.env` hors dépôt). Une fois cette méthode acquise, une mise à jour se déploie en trois commandes.