Transférer des fichiers entre votre ordinateur et votre serveur : Tous les moyens expliqués

Vous avez passé des heures à coder votre application en local. Elle tourne nickel sur votre machine. Et maintenant, vous vous demandez : "Comment je mets tout ça sur mon serveur ?" 🤔

Ou alors, l'inverse : vous voulez récupérer des logs, une base de données, ou un fichier de config depuis votre serveur vers votre PC.

Si votre première idée c'est de copier-coller le code dans le terminal ligne par ligne... STOP ! Il y a beaucoup mieux. Et c'est même pas compliqué.

Il existe plein de méthodes pour transférer des fichiers, du simple au sophistiqué. Chacune a ses avantages selon votre situation.

Dans ce guide, on va voir toutes les façons de bouger vos fichiers entre local et serveur, avec des exemples concrets pour chaque cas d'usage.

Ce que vous allez apprendre :

SCP : rapide et simple pour quelques fichiers
SFTP : interface intuitive, parfait pour débuter
rsync : synchronisation puissante, idéal pour les gros projets
Git : la méthode pro pour le code
GUI (FileZilla, WinSCP) : si vous préférez le clic
Méthodes avancées (sshfs, webhook) pour les pros

Allez, on commence ! 🚀

Prérequis : Ce dont vous avez besoin

Avant de transférer quoi que ce soit, assurez-vous d'avoir :

Accès SSH à votre serveur
L'adresse IP (ou domaine) de votre serveur
Votre nom d'utilisateur serveur
Vos clés SSH configurées (recommandé) ou votre mot de passe

Test rapide :

ssh votre-user@votre-serveur.com

Si ça marche, vous êtes prêt ! Si non, allez d'abord configurer SSH voir mon guide serveur.

Méthode 1 : SCP (Secure Copy) - La méthode rapide

SCP, c'est le couteau suisse du transfert de fichiers. Simple, rapide, et ça fonctionne partout où SSH fonctionne.

Envoyer un fichier vers le serveur

# Syntaxe de base
scp fichier-local.txt user@serveur:/chemin/destination/

# Exemple concret
scp app.py doe@192.168.7.500:/var/www/mon-app/

Décortiquons :

scp : la commande
app.py : le fichier local à envoyer
doe@192.168.7.500 : utilisateur@adresse-serveur
:/var/www/mon-app/ : destination sur le serveur (notez le :)

Envoyer un dossier complet

# Avec l'option -r (récursif)
scp -r mon-projet/ user@serveur:/var/www/

# Exemple
scp -r mon-app-flask/ doe@192.168.7.500:/var/www/

Récupérer un fichier depuis le serveur

# Syntaxe
scp user@serveur:/chemin/fichier-distant.txt /chemin/local/

# Exemple : récupérer un log
scp doe@192.168.7.500:/var/log/mon-app.log ~/Downloads/

# Récupérer dans le dossier actuel
scp doe@192.168.7.500:/var/log/mon-app.log .

Récupérer un dossier complet

scp -r user@serveur:/var/www/mon-app/ ~/Desktop/backup-app/

Options utiles de SCP

# Voir la progression
scp -v fichier.txt user@serveur:/destination/

# Préserver les permissions et dates
scp -p fichier.txt user@serveur:/destination/

# Compresser pendant le transfert (plus rapide pour gros fichiers)
scp -C gros-fichier.zip user@serveur:/destination/

# Port SSH non-standard
scp -P 2222 fichier.txt user@serveur:/destination/

# Limiter la bande passante (en Kbit/s)
scp -l 1000 fichier.txt user@serveur:/destination/

# Combiner plusieurs options
scp -Cpr mon-dossier/ user@serveur:/destination/

Cas d'usage typiques de SCP

1. Déployer rapidement une mise à jour :

scp app.py requirements.txt user@serveur:/var/www/mon-app/

2. Récupérer une base de données :

# Sur le serveur, dump la DB
ssh user@serveur "pg_dump madb > /tmp/backup.sql"

# Récupérer le dump
scp user@serveur:/tmp/backup.sql ~/backups/

3. Envoyer plusieurs fichiers :

scp *.py user@serveur:/var/www/mon-app/

Avantages de SCP :

Simple et direct
Déjà installé partout (avec SSH)
Parfait pour des transferts ponctuels
Sécurisé (chiffré comme SSH)

Inconvénients :

Pas de synchronisation (copie tout à chaque fois)
Pas de reprise en cas d'interruption
Écrase les fichiers destination sans confirmation

Méthode 2 : SFTP (SSH File Transfer Protocol) - L'interface interactive

SFTP, c'est comme FTP mais sécurisé. Vous avez une session interactive où vous pouvez naviguer et transférer des fichiers.

Mode interactif

# Se connecter
sftp user@serveur

# Vous êtes maintenant dans une session SFTP
sftp>

Commandes SFTP de base :

# Voir où vous êtes sur le SERVEUR
sftp> pwd
# /home/user

# Lister les fichiers SERVEUR
sftp> ls
# ou détaillé
sftp> ls -la

# Changer de dossier SERVEUR
sftp> cd /var/www/mon-app

# Voir où vous êtes en LOCAL
sftp> lpwd

# Lister les fichiers LOCAUX
sftp> lls

# Changer de dossier LOCAL
sftp> lcd ~/Documents

# Télécharger un fichier (serveur → local)
sftp> get fichier-distant.txt

# Télécharger un dossier
sftp> get -r dossier-distant/

# Envoyer un fichier (local → serveur)
sftp> put fichier-local.txt

# Envoyer un dossier
sftp> put -r dossier-local/

# Créer un dossier sur le serveur
sftp> mkdir nouveau-dossier

# Supprimer un fichier sur le serveur
sftp> rm fichier.txt

# Supprimer un dossier sur le serveur
sftp> rmdir dossier/

# Quitter
sftp> exit
# ou
sftp> bye

Mode non-interactif (commandes en une ligne)

# Télécharger un fichier
sftp user@serveur:/chemin/fichier.txt

# Envoyer un fichier avec une commande
echo "put fichier.txt" | sftp user@serveur:/destination/

# Batch de commandes
sftp -b script.txt user@serveur

script.txt :

cd /var/www/mon-app
put app.py
put requirements.txt
get logs/app.log
bye

Exemple pratique : Mettre à jour une app

# 1. Se connecter
sftp mpia@mon-serveur.com

# 2. Aller dans le dossier de l'app
sftp> cd /var/www/mon-app

# 3. Voir ce qu'il y a
sftp> ls -la

# 4. Sauvegarder l'ancien fichier
sftp> rename app.py app.py.backup

# 5. Envoyer la nouvelle version
sftp> put app.py

# 6. Vérifier
sftp> ls -l app.py

# 7. Quitter
sftp> exit

Avantages de SFTP :

Session interactive pratique
Peut naviguer dans les dossiers
Sécurisé (SSH)
Parfait pour explorer et transférer

Inconvénients :

Plus lent que SCP pour gros transferts
Pas de synchronisation intelligente

Méthode 3 : rsync - La synchronisation intelligente

rsync, c'est le roi du transfert de fichiers. Il ne copie que ce qui a changé, reprend où il s'était arrêté en cas d'interruption, et a 1000 options.

Installation

# Normalement déjà installé, sinon :
# Alma Linux / Rocky
sudo dnf install rsync

# Ubuntu / Debian
sudo apt install rsync

Syntaxe de base

rsync [options] source destination

Envoyer vers le serveur

# Basique
rsync -avz mon-app/ user@serveur:/var/www/mon-app/

Décortiquons :

a : archive (préserve tout : permissions, dates, liens, etc.)
v : verbose (affiche ce qui se passe)
z : compression pendant le transfert

⚠️ IMPORTANT : Le slash final change TOUT !

# SANS slash : copie le DOSSIER lui-même
rsync -avz mon-app user@serveur:/var/www/
# Résultat : /var/www/mon-app/

# AVEC slash : copie le CONTENU du dossier
rsync -avz mon-app/ user@serveur:/var/www/mon-app/
# Résultat : /var/www/mon-app/[fichiers]

Récupérer depuis le serveur

rsync -avz user@serveur:/var/www/mon-app/ ~/backup-app/

Options ultra-utiles

# Dry run (simuler sans rien faire)
rsync -avzn mon-app/ user@serveur:/var/www/mon-app/

# Afficher la progression
rsync -avz --progress mon-app/ user@serveur:/var/www/mon-app/

# Supprimer sur la destination ce qui n'existe plus à la source
rsync -avz --delete mon-app/ user@serveur:/var/www/mon-app/

# Exclure des fichiers/dossiers
rsync -avz --exclude='*.log' --exclude='__pycache__' mon-app/ user@serveur:/var/www/mon-app/

# Exclure depuis un fichier
rsync -avz --exclude-from='exclude.txt' mon-app/ user@serveur:/var/www/mon-app/

exclude.txt :

*.log
*.pyc
__pycache__/
venv/
.env
.git/
node_modules/

Synchronisation bidirectionnelle (attention !)

rsync est unidirectionnel par défaut. Pour du bidirectionnel, utilisez plutôt des outils spécialisés, mais vous pouvez faire :

# Push (local → serveur)
rsync -avz --delete mon-app/ user@serveur:/var/www/mon-app/

# Pull (serveur → local)
rsync -avz --delete user@serveur:/var/www/mon-app/ mon-app/

Exemples concrets

1. Déploiement d'application Flask :

rsync -avz --delete \
  --exclude='venv/' \
  --exclude='__pycache__/' \
  --exclude='.env' \
  --exclude='.git/' \
  ~/mon-app-flask/ user@serveur:/var/www/mon-app/

2. Backup du serveur vers local :

rsync -avz --delete \
  user@serveur:/var/www/mon-app/ \
  ~/backups/mon-app-$(date +%Y%m%d)/

3. Synchroniser seulement les fichiers modifiés récemment :

# Fichiers modifiés dans les dernières 24h
rsync -avz --update mon-app/ user@serveur:/var/www/mon-app/

4. Limiter la bande passante :

# Limite à 1000 Ko/s
rsync -avz --bwlimit=1000 gros-dossier/ user@serveur:/destination/

5. Port SSH non-standard :

rsync -avz -e "ssh -p 2222" mon-app/ user@serveur:/var/www/mon-app/

6. Voir exactement ce qui va être transféré :

rsync -avzn --itemize-changes mon-app/ user@serveur:/var/www/mon-app/

Script de déploiement avec rsync

deploy.sh :

#!/bin/bash

# Configuration
LOCAL_DIR="$HOME/projets/mon-app"
REMOTE_USER="mpia"
REMOTE_HOST="mon-serveur.com"
REMOTE_DIR="/var/www/mon-app"

echo "🚀 Déploiement de mon-app vers $REMOTE_HOST"

# Dry run d'abord (pour vérifier)
echo "📋 Simulation..."
rsync -avzn --delete \
  --exclude-from="$LOCAL_DIR/.rsyncexclude" \
  "$LOCAL_DIR/" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR/"

read -p "Continuer avec le déploiement réel ? (y/n) " -n 1 -r
echo

if [[ $REPLY =~ ^[Yy]$ ]]; then
    echo "📤 Transfert en cours..."
    rsync -avz --delete --progress \
      --exclude-from="$LOCAL_DIR/.rsyncexclude" \
      "$LOCAL_DIR/" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR/"

    echo "✅ Déploiement terminé !"
    echo "🔄 Redémarrage de l'application..."
    ssh "$REMOTE_USER@$REMOTE_HOST" "sudo systemctl restart mon-app"
    echo "🎉 Fait !"
else
    echo "❌ Déploiement annulé"
fi

.rsyncexclude :

*.pyc
__pycache__/
venv/
.env
.git/
.vscode/
*.log
.DS_Store
node_modules/

Utilisation :

chmod +x deploy.sh
./deploy.sh

Avantages de rsync :

Transfert SEULEMENT ce qui a changé (ultra-rapide)
Reprend en cas d'interruption
Plein d'options de filtrage
Préserve permissions, dates, etc.
Mode dry-run pour tester avant

Inconvénients :

Courbe d'apprentissage (beaucoup d'options)
Unidirectionnel (pas de sync automatique bidirectionnelle)

Méthode 4 : Git - La méthode pro pour le code

Pour du code, Git est LA solution. Pourquoi se compliquer avec SCP quand Git fait tout mieux ?

Setup initial

Sur votre machine locale :

cd mon-projet
git init
git add .
git commit -m "Initial commit"

# Pusher vers GitHub/GitLab
git remote add origin https://github.com/votre-user/mon-projet.git
git push -u origin main

Sur le serveur :

cd /var/www
git clone https://github.com/votre-user/mon-projet.git

Déploiement (la méthode simple)

1. Sur votre machine locale, après des modifications :

git add .
git commit -m "Fix bug dans app.py"
git push origin main

2. Sur le serveur :

cd /var/www/mon-projet
git pull origin main

# Redémarrer l'app si nécessaire
sudo systemctl restart mon-app

Script de déploiement automatique

deploy-git.sh (sur le serveur) :

#!/bin/bash

APP_DIR="/var/www/mon-app"
SERVICE_NAME="mon-app"

echo "🚀 Déploiement via Git..."

cd $APP_DIR

# Sauvegarder les changements locaux éventuels
git stash

# Pull les derniers changements
git pull origin main

# Réappliquer les changements locaux si nécessaire
# git stash pop

# Installer les dépendances si requirements.txt a changé
if git diff HEAD@{1} --name-only | grep -q "requirements.txt"; then
    echo "📦 Mise à jour des dépendances..."
    source venv/bin/activate
    pip install -r requirements.txt
fi

# Redémarrer le service
echo "🔄 Redémarrage..."
sudo systemctl restart $SERVICE_NAME

# Vérifier
if sudo systemctl is-active --quiet $SERVICE_NAME; then
    echo "✅ Déploiement réussi !"
else
    echo "❌ Erreur lors du démarrage"
    sudo journalctl -u $SERVICE_NAME -n 20
    exit 1
fi

Utilisation :

# Depuis votre machine locale
ssh user@serveur "bash /var/www/mon-app/deploy-git.sh"

Git avec deploy keys (pour les repos privés)

Sur le serveur :

# Générer une clé SSH spécifique pour le déploiement
ssh-keygen -t ed25519 -C "deploy-key-mon-app" -f ~/.ssh/deploy_key

# Afficher la clé publique
cat ~/.ssh/deploy_key.pub

Sur GitHub/GitLab :

Allez dans Settings → Deploy keys
Ajoutez la clé publique
Donnez un nom (ex: "Production Server")
Cochez "Allow write access" si nécessaire

Sur le serveur, configurez SSH :

nano ~/.ssh/config

Ajoutez :

Host github.com
    HostName github.com
    User git
    IdentityFile ~/.ssh/deploy_key
    IdentitiesOnly yes

Testez :

ssh -T git@github.com
# Doit afficher : "Hi username! You've successfully authenticated..."

Maintenant vous pouvez cloner :

git clone git@github.com:votre-user/mon-projet.git

Webhooks pour déploiement automatique

Déployez automatiquement à chaque push sur GitHub/GitLab !

1. Installer le serveur webhook :

# Script simple avec Flask
pip install flask

# webhook-server.py

webhook-server.py :

from flask import Flask, request
import subprocess
import hmac
import hashlib

app = Flask(__name__)

# Secret partagé avec GitHub/GitLab
WEBHOOK_SECRET = "votre-secret-super-complexe"

@app.route('/webhook', methods=['POST'])
def webhook():
    # Vérifier la signature (sécurité)
    signature = request.headers.get('X-Hub-Signature-256')
    if signature:
        hash_object = hmac.new(
            WEBHOOK_SECRET.encode('utf-8'),
            msg=request.data,
            digestmod=hashlib.sha256
        )
        expected_signature = "sha256=" + hash_object.hexdigest()

        if not hmac.compare_digest(signature, expected_signature):
            return "Invalid signature", 403

    # Exécuter le script de déploiement
    try:
        result = subprocess.run(
            ['/var/www/mon-app/deploy-git.sh'],
            capture_output=True,
            text=True
        )
        return f"Deployed successfully!\n{result.stdout}", 200
    except Exception as e:
        return f"Deployment failed: {str(e)}", 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

2. Créer un service systemd pour le webhook :

sudo nano /etc/systemd/system/webhook.service

[Unit]
Description=Webhook Server for Auto Deploy
After=network.target

[Service]
User=votre-user
WorkingDirectory=/var/www/mon-app
ExecStart=/usr/bin/python3 /var/www/mon-app/webhook-server.py
Restart=always

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl start webhook
sudo systemctl enable webhook

3. Configurer nginx pour le webhook :

server {
    listen 80;
    server_name webhook.mon-domaine.com;

    location /webhook {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

4. Sur GitHub/GitLab :

Settings → Webhooks
URL : http://webhook.mon-domaine.com/webhook
Secret : votre secret
Events : "Just the push event"

Maintenant, chaque git push déclenche automatiquement un déploiement ! 🎉

Avantages de Git :

Versioning (historique complet)
Rollback facile en cas de problème
Collaboration facilitée
Automatisation possible (webhooks, CI/CD)
Standard de l'industrie

Inconvénients :

Pas adapté pour les gros fichiers binaires
Courbe d'apprentissage pour Git
Nécessite un repo (GitHub, GitLab, etc.)

Méthode 5 : GUI (FileZilla, WinSCP) - Pour ceux qui préfèrent cliquer

Si le terminal vous fait peur, ou si vous préférez une interface graphique, il existe d'excellents clients SFTP.

FileZilla (Windows, Mac, Linux)

Installation :

Téléchargez depuis https://filezilla-project.org
Installez normalement

Configuration :

Ouvrir FileZilla
Fichier → Gestionnaire de Sites
Nouveau site :

Protocole : SFTP
Hôte : votre-serveur.com
Port : 22 (ou votre port SSH)
Type d'authentification : Clé publique (ou mot de passe)
Utilisateur : votre-user
Fichier de clés : ~/.ssh/id_rsa (si clé SSH)

Connecter

Utilisation :

Gauche : Votre ordinateur
Droite : Le serveur
Glissez-déposez les fichiers entre les deux
Double-clic pour naviguer

Astuces FileZilla :

- Ctrl + Clic : Sélection multiple

- F5 : Rafraîchir

- Clic droit : Options (permissions, renommer, etc.)

- Transfert → Synchroniser : Sync automatique

WinSCP (Windows uniquement)

Installation :

Téléchargez depuis https://winscp.net
Installez

Configuration :

Nouveau site

Protocole : SFTP
Nom d'hôte : votre-serveur.com
Utilisateur : votre-user
Mot de passe : (ou clé SSH)

Avancé → SSH → Authentification → Fichier clé privée
Sauvegarder et Se connecter

Fonctionnalités cool de WinSCP :

Synchronisation de dossiers
Éditeur intégré (modifiez les fichiers directement)
Ligne de commande intégrée
Comparaison de fichiers

Cyberduck (Mac, Windows)

Même principe que FileZilla, interface plus moderne.

Avantages des GUI :

Intuitive (pas de commandes à retenir)
Visualisation claire
Glisser-déposer
Parfait pour les débutants

Inconvénients :

Pas scriptable/automatisable
Plus lent pour les opérations en masse
Consomme plus de ressources

Méthode 6 : sshfs - Monter le serveur comme un disque local

Imaginez pouvoir accéder aux fichiers de votre serveur comme s'ils étaient sur votre ordinateur. C'est ça, sshfs !

Installation

# Ubuntu / Debian
sudo apt install sshfs

# Alma Linux / Rocky (activer EPEL d'abord)
sudo dnf install epel-release
sudo dnf install fuse-sshfs

# macOS (avec Homebrew)
brew install macfuse
brew install sshfs

Monter un dossier distant

# Créer un point de montage
mkdir ~/serveur-distant

# Monter
sshfs user@serveur:/var/www/mon-app ~/serveur-distant

# Maintenant, ~/serveur-distant contient les fichiers du serveur !
ls ~/serveur-distant

Utiliser les fichiers

# Éditer directement
nano ~/serveur-distant/app.py

# Copier des fichiers
cp fichier-local.txt ~/serveur-distant/

# C'est comme si c'était local !

Démonter

# Linux
fusermount -u ~/serveur-distant

# macOS
umount ~/serveur-distant

Montage automatique au démarrage

Linux - dans /etc/fstab :

user@serveur:/var/www/mon-app /home/votre-user/serveur-distant fuse.sshfs defaults,_netdev,identityfile=/home/votre-user/.ssh/id_rsa,allow_other,uid=1000,gid=1000 0 0

Ensuite :

sudo mount -a

Options utiles

# Compression (plus rapide sur connexions lentes)
sshfs -C user@serveur:/chemin ~/montage

# Reconnexion automatique en cas de déconnexion
sshfs -o reconnect user@serveur:/chemin ~/montage

# Cache pour meilleures performances
sshfs -o cache=yes user@serveur:/chemin ~/montage

# Port SSH non-standard
sshfs -p 2222 user@serveur:/chemin ~/montage

Avantages de sshfs :

Accès transparent aux fichiers distants
Pas de transfert explicite nécessaire
Fonctionne avec tous vos outils locaux

Inconvénients :

Latence réseau pour chaque opération
Pas idéal pour de gros transferts
Performances dépendent de la connexion

Méthode 7 : Méthodes avancées et alternatives

1. Tar + SSH (pour gros dossiers compressés)

# Compresser et envoyer en un coup
tar czf - mon-app/ | ssh user@serveur "tar xzf - -C /var/www/"

# Récupérer depuis le serveur
ssh user@serveur "tar czf - /var/www/mon-app" | tar xzf -

Avantage : Ultra-rapide pour gros dossiers (compression à la volée).

2. nc (netcat) - Transfert direct sans SSH

# Sur le serveur (receveur)
nc -l 9999 > fichier-recu.txt

# Sur votre machine (envoyeur)
nc serveur-ip 9999 < fichier-a-envoyer.txt

⚠️ Attention : Pas chiffré ! Utilisez seulement sur réseau privé.

3. Python SimpleHTTPServer (dépannage)

Sur le serveur :

cd /var/www/mon-app
python3 -m http.server 8000

Sur votre machine :

wget http://serveur-ip:8000/fichier.txt

⚠️ Attention : Pas sécurisé, seulement pour du dépannage temporaire !

4. rclone (pour le cloud)

Synchroniser avec S3, Google Drive, Dropbox, etc.

# Installation
curl https://rclone.org/install.sh | sudo bash

# Configurer
rclone config

# Sync avec S3
rclone sync /var/www/mon-app s3:mon-bucket/backups/

# Sync depuis Google Drive
rclone sync gdrive:mon-dossier /var/www/mon-app

5. Docker Registry (pour containers)

# Build et push
docker build -t mon-app:latest .
docker push mon-registry.com/mon-app:latest

# Sur le serveur, pull et run
docker pull mon-registry.com/mon-app:latest
docker run -d mon-app:latest

Tableaux comparatifs : Quelle méthode choisir ?

Par cas d'usage

Situation	Méthode recommandée	Pourquoi
Transférer 1-2 fichiers rapidement	SCP	Simple et direct
Explorer et transférer	SFTP ou GUI	Navigation facile
Déployer du code	Git	Versioning + rollback
Synchroniser régulièrement	rsync	Intelligent, rapide
Grosse quantité de données	rsync + compression	Optimisé
Vous préférez cliquer	FileZilla/WinSCP	Interface graphique
Éditer des fichiers distant	sshfs	Accès transparent
Automatisation	Git + webhooks ou rsync script	Pas d'intervention manuelle

Par vitesse (1GB de données)

Méthode	Temps approximatif	Notes
SCP	~10 min	Baseline
SCP -C (compressé)	~7 min	Si fichiers compressibles
rsync (1ère fois)	~10 min	Pareil que SCP
rsync (sync suivants)	~30 sec	Seulement les changements !
Git	Variable	Dépend de l'historique
GUI (FileZilla)	~12 min	Overhead graphique
sshfs	~15 min	Latence réseau

Par sécurité

Méthode	Chiffrement	Authentification	Note
SCP	✅ SSH	✅ Clés/MDP	Excellent
SFTP	✅ SSH	✅ Clés/MDP	Excellent
rsync	✅ via SSH	✅ Clés/MDP	Excellent
Git (SSH)	✅ SSH	✅ Clés	Excellent
Git (HTTPS)	✅ TLS	✅ Token	Très bon
GUI	✅ Selon protocole	✅ Selon protocole	Bon
sshfs	✅ SSH	✅ Clés/MDP	Excellent
nc	❌ Aucun	❌ Aucun	⚠️ Dangereux

Script tout-en-un : Déploiement flexible

Voici un script qui combine le meilleur de plusieurs méthodes :

deploy.sh :

#!/bin/bash

# Script de déploiement flexible
# Supporte : rsync, git, scp

set -e

# Configuration
APP_NAME="mon-app"
LOCAL_DIR="$HOME/projets/$APP_NAME"
REMOTE_USER="mpia"
REMOTE_HOST="mon-serveur.com"
REMOTE_DIR="/var/www/$APP_NAME"
METHOD="${1:-rsync}"  # Par défaut : rsync

# Couleurs
GREEN='\033[0;32m'
RED='\033[0;31m'
YELLOW='\033[1;33m'
NC='\033[0m'

echo -e "${GREEN}🚀 Déploiement de $APP_NAME via $METHOD${NC}"

case $METHOD in
    rsync)
        echo "📤 Utilisation de rsync..."
        rsync -avz --delete --progress \
            --exclude-from="$LOCAL_DIR/.deployignore" \
            "$LOCAL_DIR/" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR/"
        ;;

    git)
        echo "📤 Utilisation de Git..."
        cd "$LOCAL_DIR"

        # Vérifier qu'il n'y a pas de changements non commités
        if [[ -n $(git status -s) ]]; then
            echo -e "${RED}❌ Changements non commités détectés${NC}"
            git status -s
            exit 1
        fi

        # Push
        git push origin main

        # Pull sur le serveur
        ssh "$REMOTE_USER@$REMOTE_HOST" "cd $REMOTE_DIR && git pull origin main"
        ;;

    scp)
        echo "📤 Utilisation de SCP..."
        scp -r "$LOCAL_DIR/"* "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR/"
        ;;

    *)
        echo -e "${RED}❌ Méthode inconnue: $METHOD${NC}"
        echo "Utilisez : rsync, git, ou scp"
        exit 1
        ;;
esac

# Post-déploiement
echo -e "${YELLOW}🔄 Post-déploiement...${NC}"
ssh "$REMOTE_USER@$REMOTE_HOST" << 'EOF'
    cd /var/www/mon-app

    # Installer les dépendances si nécessaire
    if [ -f requirements.txt ]; then
        source venv/bin/activate
        pip install -r requirements.txt --quiet
    fi

    # Restaurer les contextes SELinux
    sudo restorecon -Rv . > /dev/null 2>&1

    # Redémarrer le service
    sudo systemctl restart mon-app

    # Vérifier
    if sudo systemctl is-active --quiet mon-app; then
        echo "✅ Service démarré avec succès"
    else
        echo "❌ Erreur au démarrage du service"
        sudo journalctl -u mon-app -n 20 --no-pager
        exit 1
    fi
EOF

echo -e "${GREEN}🎉 Déploiement terminé avec succès !${NC}"

.deployignore :

*.pyc
__pycache__/
venv/
.env
.git/
.vscode/
*.log
.DS_Store
node_modules/
*.sqlite
.pytest_cache/

Utilisation :

# Avec rsync (par défaut)
./deploy.sh

# Avec Git
./deploy.sh git

# Avec SCP
./deploy.sh scp

Bonnes pratiques et sécurité

1. Toujours utiliser SSH, jamais FTP non chiffré

# ✅ BON
scp fichier.txt user@serveur:/destination/

# ❌ MAUVAIS (mot de passe en clair !)
ftp serveur

2. Utiliser des clés SSH, pas des mots de passe

# Générer une clé si vous n'en avez pas
ssh-keygen -t ed25519 -C "votre-email@example.com"

# Copier sur le serveur
ssh-copy-id user@serveur

3. Exclure les fichiers sensibles

Toujours exclure :

.env (secrets)
venv/ (dépendances)
*.log (logs locaux)
.git/ (si vous utilisez rsync/scp)
Fichiers de base de données locales

4. Tester avant de déployer

# Avec rsync
rsync -avzn ...  # -n = dry run

# Avec Git
git diff  # Voir ce qui a changé

5. Avoir un plan de rollback

# Avant déploiement, backup
ssh user@serveur "tar czf /tmp/backup-$(date +%Y%m%d).tar.gz /var/www/mon-app"

# En cas de problème, rollback Git
ssh user@serveur "cd /var/www/mon-app && git reset --hard HEAD~1"

6. Automatiser les tâches répétitives

Si vous déployez souvent, créez un script ou utilisez un CI/CD (GitHub Actions, GitLab CI).

7. Monitorer les transferts

# Avec rsync, toujours utiliser --progress
rsync -avz --progress ...

# Log les déploiements
echo "$(date): Deployed by $USER" >> /var/log/deployments.log

Troubleshooting : Problèmes courants

"Permission denied"

# Vérifier les permissions sur le serveur
ssh user@serveur "ls -la /var/www/"

# Vérifier que vous êtes propriétaire
ssh user@serveur "sudo chown -R $USER:$USER /var/www/mon-app"

"Connection refused"

# SSH tourne ?
ssh user@serveur "sudo systemctl status sshd"

# Firewall bloque ?
ssh user@serveur "sudo firewall-cmd --list-all"

# Bon port ?
ssh -p 2222 user@serveur  # Si port non-standard

rsync : "rsync error: some files could not be transferred"

# Voir les détails
rsync -avz --itemize-changes ...

# Vérifier les permissions
ls -la fichier-problématique

Git : "fatal: could not read from remote repository"

# Clé SSH configurée ?
ssh -T git@github.com

# Bonne remote ?
git remote -v

# Ajouter la clé SSH
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Transfert très lent

# Compresser avec rsync
rsync -avz -C ...  # -C = --compress

# Limiter le nombre de fichiers simultanés
rsync --no-inc-recursive ...

# Vérifier la connexion
ping serveur
speedtest-cli  # Tester votre débit

"Disk quota exceeded"

# Vérifier l'espace disque sur le serveur
ssh user@serveur "df -h"

# Nettoyer si nécessaire
ssh user@serveur "du -sh /var/www/* | sort -h"

Checklist de transfert de fichiers

Avant chaque transfert important :

□ Backup fait côté serveur
□ .env et secrets exclus
□ Fichiers inutiles (venv, logs) exclus
□ Test en dry-run effectué (si rsync)
□ Connexion SSH fonctionne
□ Espace disque suffisant sur le serveur
□ Permissions vérifiées
□ Script de déploiement testé
□ Plan de rollback prêt

Conclusion : Transférer comme un pro !

Voilà ! Vous avez maintenant un arsenal complet de méthodes pour transférer des fichiers entre votre machine et votre serveur.

Récap rapide :

SCP : Rapide et simple pour quelques fichiers
SFTP : Session interactive pour explorer
rsync : Le roi de la synchronisation
Git : Pour le code, avec versioning
GUI : Si vous préférez cliquer
sshfs : Accès transparent aux fichiers distants

Mes recommandations :

Pour du code : Git (avec webhooks si possible)
Pour des syncs régulières : rsync (scriptez-le !)
Pour un transfert ponctuel : SCP
Pour débuter : FileZilla ou WinSCP
Pour de la production : Automatisez avec Git + CI/CD

Les points essentiels à retenir :

Toujours utiliser SSH (chiffré)
Exclure les fichiers sensibles et inutiles
Tester avant de transférer (dry-run)
Avoir un backup et un plan de rollback
Automatiser ce qui est répétitif

Et rappelez-vous : le meilleur outil, c'est celui que vous maîtrisez et qui correspond à votre workflow. Commencez simple (SCP), puis évoluez vers des solutions plus sophistiquées (rsync, Git) quand vous en avez besoin.

Vous avez une méthode préférée ? Un truc qui vous a sauvé la mise ? Partagez en commentaire ! Et si cet article vous a aidé, partagez-le avec d'autres devs qui galérent avec leurs transferts de fichiers. 😉

Articles connexes :

Transférer des fichiers entre votre ordinateur et votre serveur : Tous les moyens expliqués

Prérequis : Ce dont vous avez besoin

Méthode 1 : SCP (Secure Copy) - La méthode rapide

Envoyer un fichier vers le serveur

Envoyer un dossier complet

Récupérer un fichier depuis le serveur

Récupérer un dossier complet

Options utiles de SCP

Cas d'usage typiques de SCP

Méthode 2 : SFTP (SSH File Transfer Protocol) - L'interface interactive

Mode interactif

Mode non-interactif (commandes en une ligne)

Exemple pratique : Mettre à jour une app

Méthode 3 : rsync - La synchronisation intelligente

Installation

Syntaxe de base

Envoyer vers le serveur

Récupérer depuis le serveur

Options ultra-utiles

Synchronisation bidirectionnelle (attention !)

Exemples concrets

Script de déploiement avec rsync

Méthode 4 : Git - La méthode pro pour le code

Setup initial

Déploiement (la méthode simple)

Script de déploiement automatique

Git avec deploy keys (pour les repos privés)

Webhooks pour déploiement automatique

Méthode 5 : GUI (FileZilla, WinSCP) - Pour ceux qui préfèrent cliquer

FileZilla (Windows, Mac, Linux)

WinSCP (Windows uniquement)

Cyberduck (Mac, Windows)

Méthode 6 : sshfs - Monter le serveur comme un disque local

Installation

Monter un dossier distant

Utiliser les fichiers

Démonter

Montage automatique au démarrage

Options utiles

Méthode 7 : Méthodes avancées et alternatives

1. Tar + SSH (pour gros dossiers compressés)

2. nc (netcat) - Transfert direct sans SSH

3. Python SimpleHTTPServer (dépannage)

4. rclone (pour le cloud)

5. Docker Registry (pour containers)

Tableaux comparatifs : Quelle méthode choisir ?

Par cas d'usage

Par vitesse (1GB de données)

Par sécurité

Script tout-en-un : Déploiement flexible

Bonnes pratiques et sécurité

1. Toujours utiliser SSH, jamais FTP non chiffré

2. Utiliser des clés SSH, pas des mots de passe

3. Exclure les fichiers sensibles

4. Tester avant de déployer

5. Avoir un plan de rollback

6. Automatiser les tâches répétitives

7. Monitorer les transferts

Troubleshooting : Problèmes courants

"Permission denied"

"Connection refused"

rsync : "rsync error: some files could not be transferred"

Git : "fatal: could not read from remote repository"

Transfert très lent

"Disk quota exceeded"

Checklist de transfert de fichiers

Conclusion : Transférer comme un pro !

Commentaires (0)

Laisser un commentaire