Git pour Data Engineers

Objectif : Comprendre Git, GitHub et GitLab, savoir versionner ses scripts, notebooks et configurations.

Prérequis

Niveau Compétence
✅ Requis Avoir suivi le module 02_bash_for_data_engineers
✅ Requis Savoir utiliser un terminal
✅ Requis Avoir un compte GitHub (gratuit) — voir section ci-dessous

Objectifs du module

À la fin de ce module, tu seras capable de :

  • Comprendre les concepts de versioning
  • Initialiser et configurer un dépôt Git
  • Maîtriser le workflow : add → commit → push
  • Travailler avec les branches
  • Collaborer efficacement avec une équipe
  • Utiliser .gitignore pour protéger les données sensibles

Pourquoi Git est essentiel pour un Data Engineer ?

Cas d’usage Exemple concret
Versionner les pipelines Suivre l’évolution de tes scripts ETL
Collaborer en équipe Travailler à plusieurs sur le même projet data
Revenir en arrière Restaurer une version qui fonctionnait après un bug
Code review Valider les modifications avant mise en production
CI/CD Déclencher automatiquement des tests et déploiements
Documentation Historique complet de qui a fait quoi et pourquoi

💡 En bref : Git est le système nerveux de tout projet data moderne. Sans Git, pas de collaboration efficace ni de traçabilité.

1️⃣ Définitions : Git, GitHub et GitLab

Qu’est-ce que Git ?

Git est un logiciel de gestion de versions distribué. Il permet de :

  • Suivre l’évolution de vos fichiers au fil du temps
  • Créer des points de restauration (commits)
  • Travailler en parallèle sur différentes fonctionnalités (branches)
  • Fusionner le travail de plusieurs personnes
📁 Ton projet
    │
    ├── pipeline.py      ← Versionné par Git
    ├── config.yaml      ← Versionné par Git  
    ├── .git/            ← Dossier caché contenant l'historique
    └── data/            ← À NE PAS versionner !

Qu’est-ce que GitHub ?

GitHub est une plateforme cloud (propriété de Microsoft) qui héberge vos dépôts Git.

  • Interface web moderne
  • Très populaire pour l’open source
  • GitHub Actions pour la CI/CD

Qu’est-ce que GitLab ?

GitLab est une alternative open source à GitHub :

  • Peut être auto-hébergé (on-premise)
  • CI/CD intégré très puissant
  • Souvent utilisé en entreprise

2️⃣ GitHub vs GitLab — Comparatif

Fonctionnalité GitHub GitLab
Hébergement Cloud (Microsoft) Cloud ou auto-hébergé
CI/CD GitHub Actions GitLab CI/CD (intégré)
Communauté Très vaste (open source) Orienté entreprise
Interface Moderne, simple Complète, personnalisable
Prix Gratuit + plans payants Gratuit + plans payants
Sécurité Dépend du plan Peut être auto-hébergé
Usage recommandé Projets publics, open source Projets internes, entreprise

💡 Pour ce cours, tu peux utiliser l’un ou l’autre. Les commandes Git sont identiques !

Créer un compte GitHub gratuit

Étape 1 : Inscription

  1. Aller sur github.com
  2. Cliquer sur “Sign up” (en haut à droite)
  3. Remplir le formulaire :
    • Email : ton adresse email
    • Password : un mot de passe fort
    • Username : ton pseudo (visible publiquement)
  4. Résoudre le puzzle de vérification
  5. Valider l’email (vérifier ta boîte mail)

✅ C’est gratuit ! Le plan gratuit inclut : - Dépôts publics illimités - Dépôts privés illimités - 500 Mo de stockage pour GitHub Packages - 2000 minutes/mois de GitHub Actions

Étape 2 : Configurer l’authentification

Depuis 2021, GitHub n’accepte plus les mots de passe pour git push. Tu dois utiliser :

Méthode Difficulté Recommandation
HTTPS + Token ⭐ Facile ✅ Pour débuter
SSH ⭐⭐ Moyen ✅ Pour usage régulier

Option A : HTTPS + Personal Access Token (PAT)

Créer un token :

  1. Connecte-toi sur github.com
  2. Clique sur ta photo de profil → Settings
  3. Dans le menu gauche, descends jusqu’à Developer settings
  4. Clique sur Personal access tokens → Tokens (classic)
  5. Clique sur Generate new token → Generate new token (classic)
  6. Configure le token :
    • Note : git-access (ou un nom descriptif)
    • Expiration : 90 days (ou plus)
    • Scopes : cocher repo (accès complet aux dépôts)
  7. Clique sur Generate token
  8. COPIE LE TOKEN MAINTENANT — tu ne pourras plus le voir après !

Utiliser le token :

# Quand Git demande ton mot de passe, colle le TOKEN (pas ton mot de passe !)
git push origin main
Username: ton-username
Password: ghp_xxxxxxxxxxxxxxxxxxxx   # ← Coller le token ici

Sauvegarder le token (optionnel) :

# Mémoriser les credentials pour 1 heure
git config --global credential.helper cache

# Ou mémoriser indéfiniment (moins sécurisé)
git config --global credential.helper store

Option B : Clé SSH (recommandé pour usage régulier)

1. Générer une clé SSH :

# Générer une paire de clés (appuie sur Entrée pour les valeurs par défaut)
ssh-keygen -t ed25519 -C "ton.email@exemple.com"

# Démarrer l'agent SSH
eval "$(ssh-agent -s)"

# Ajouter la clé à l'agent
ssh-add ~/.ssh/id_ed25519

2. Ajouter la clé à GitHub :

# Copier la clé publique
cat ~/.ssh/id_ed25519.pub
# Copie le résultat (commence par ssh-ed25519...)
  1. Sur GitHub : Settings → SSH and GPG keys → New SSH key
  2. Coller la clé publique et sauvegarder

3. Tester la connexion :

ssh -T git@github.com
# Réponse attendue : "Hi username! You've successfully authenticated..."

4. Utiliser SSH pour cloner :

# Cloner avec SSH (au lieu de HTTPS)
git clone git@github.com:username/repo.git

# Ou changer un dépôt existant vers SSH
git remote set-url origin git@github.com:username/repo.git

Étape 3 : Créer ton premier dépôt sur GitHub

Via l’interface web :

  1. Connecte-toi sur github.com
  2. Clique sur “+” (en haut à droite) → New repository
  3. Configure le dépôt :
    • Repository name : mon-projet-data
    • Description : “Mon premier projet Data Engineering”
    • Visibility : Public ou Private
    • ❌ Ne PAS cocher “Add a README file” (on le fera localement)
  4. Clique sur Create repository
  5. GitHub affiche les commandes à exécuter — copie-les !

Lier ton projet local au dépôt GitHub :

# Si tu as déjà un projet local avec des commits
cd mon_projet_data
git remote add origin https://github.com/ton-username/mon-projet-data.git
git branch -M main
git push -u origin main
# Ou cloner un dépôt existant
git clone https://github.com/ton-username/mon-projet-data.git
cd mon-projet-data

Récapitulatif : Workflow complet

1. Créer compte GitHub ────► github.com/signup
                                    │
2. Configurer auth ────────► Token (HTTPS) ou SSH
                                    │
3. Créer dépôt sur GitHub ─► github.com → New repository
                                    │
4. Lier projet local ──────► git remote add origin ...
                                    │
5. Pousser le code ────────► git push -u origin main
                                    │
                              ✅ Code sur GitHub !

3️⃣ Installation et configuration de Git

Installation

Système Commande
🪟 Windows Télécharger depuis git-scm.com
🍎 macOS brew install git
🐧 Linux (Debian/Ubuntu) sudo apt install git
🐧 Linux (Fedora) sudo dnf install git
Voir le code 
%%bash
# Vérifier la version installée
git --version

# Configuration obligatoire (identité)
git config --global user.name "Ton Nom"
git config --global user.email "ton.email@exemple.com"

# Configuration recommandée
git config --global init.defaultBranch main    # Branche par défaut
git config --global core.editor "code --wait"  # Éditeur (VS Code)
git config --global pull.rebase false          # Merge par défaut lors du pull

# Vérifier la configuration
git config --list

4️⃣ Comprendre le workflow Git

Les 4 zones de Git

┌─────────────────┐    git add     ┌─────────────────┐
│  Working Dir    │ ─────────────▶ │  Staging Area   │
│  (tes fichiers) │                │  (index)        │
└─────────────────┘                └────────┬────────┘
                                            │ git commit
                                            ▼
┌─────────────────┐    git push    ┌─────────────────┐
│  Remote         │ ◀───────────── │  Local Repo     │
│  (GitHub/GitLab)│                │  (.git)         │
└─────────────────┘                └─────────────────┘

Cycle de vie d’un fichier

État Description Commande pour passer à l’état suivant
Untracked Nouveau fichier, non suivi git add <fichier>
Staged Prêt à être commité git commit -m "message"
Committed Enregistré localement git push
Pushed Envoyé sur le serveur distant ✅ Terminé

Clients Git (alternatives aux commandes)

Tu n’es pas obligé d’utiliser le terminal ! Il existe des interfaces graphiques (GUI) pour Git qui facilitent la visualisation et certaines opérations.

📱 Clients populaires

Client Plateforme Points forts Prix
GitHub Desktop Windows, Mac Simple, parfait pour débuter, intégration GitHub Gratuit
GitKraken Windows, Mac, Linux Interface visuelle puissante, graphe des branches Gratuit (public)
Sourcetree Windows, Mac Complet, supporte Git et Mercurial Gratuit
VS Code Tous Git intégré + extension GitLens Gratuit
PyCharm / IntelliJ Tous Git intégré dans l’IDE Gratuit / Payant

Terminal vs GUI : quand utiliser quoi ?

Situation Recommandation
Visualiser l’historique et les branches 🖥️ GUI — Plus clair visuellement
Résoudre des conflits de merge 🖥️ GUI — Comparaison côte à côte
Opérations quotidiennes (add, commit, push) ⌨️ Terminal ou 🖥️ GUI — Au choix
Scripts et automatisation (CI/CD) ⌨️ Terminal — Obligatoire
Serveurs distants (SSH) ⌨️ Terminal — Pas de GUI disponible
Apprendre Git en profondeur ⌨️ Terminal — Comprendre ce qui se passe

💡 Conseil : Apprends d’abord les commandes pour comprendre Git, puis utilise un client GUI pour gagner en productivité au quotidien.

5️⃣ Utilisation de Git pas à pas

Étape 1 : Créer un projet et initialiser Git

Voir le code 
%%bash
# Créer un dossier de projet
mkdir mon_projet_data
cd mon_projet_data

# Initialiser Git (crée le dossier .git)
git init

# Vérifier le statut
git status

Étape 2 : Ajouter des fichiers et commiter

Voir le code 
%%bash
cd mon_projet_data

# Créer un fichier Python
echo "print('Hello Data Engineering!')" > main.py

# Voir le statut (fichier untracked)
git status

# Ajouter le fichier à la staging area
git add main.py

# Voir le statut (fichier staged)
git status

# Commiter avec un message descriptif
git commit -m "feat: ajouter script principal"

# Voir l'historique
git log --oneline

Conventions de commits (Conventional Commits)

Utilise des préfixes standardisés pour des messages clairs :

Préfixe Usage Exemple
feat: Nouvelle fonctionnalité feat: ajouter extraction API
fix: Correction de bug fix: corriger parsing dates
docs: Documentation docs: mettre à jour README
refactor: Refactoring (sans changer le comportement) refactor: simplifier fonction ETL
test: Ajout/modification de tests test: ajouter tests unitaires
chore: Maintenance, config chore: mettre à jour dépendances

Exemple de bon message :

feat: ajouter pipeline d'extraction des données clients

- Connexion à l'API CRM
- Transformation des données JSON
- Export en format Parquet

6️⃣ Le fichier .gitignore — ESSENTIEL pour Data Engineers

Le .gitignore indique à Git quels fichiers NE PAS versionner.

⚠️ Ne JAMAIS versionner :

  • Fichiers de données (CSV, Parquet, JSON volumineux)
  • Secrets et credentials (mots de passe, clés API)
  • Dépendances (node_modules, venv)
  • Fichiers temporaires (cache, logs)
Voir le code 
%%bash
cd mon_projet_data

# Créer un .gitignore pour projet Data Engineering
cat << 'EOF' > .gitignore
# ==== DONNÉES ====
*.csv
*.parquet
*.json
*.xlsx
data/
raw/
processed/

# ==== SECRETS ====
.env
*.pem
*.key
credentials.json
secrets.yaml

# ==== PYTHON ====
__pycache__/
*.py[cod]
venv/
.venv/
*.egg-info/
.pytest_cache/

# ==== JUPYTER ====
.ipynb_checkpoints/
*.ipynb_checkpoints

# ==== IDE ====
.idea/
.vscode/
*.swp

# ==== LOGS ====
*.log
logs/

# ==== OS ====
.DS_Store
Thumbs.db
EOF

echo "✅ .gitignore créé"
cat .gitignore

💡 Astuces .gitignore

# Ignorer un dossier
data/

# Ignorer tous les .csv sauf un
*.csv
!schema.csv

# Ignorer les fichiers dans tous les sous-dossiers
**/*.log

# Vérifier ce qui est ignoré
git status --ignored

🔗 Générateur de .gitignore : gitignore.io

7️⃣ Lier à un dépôt distant (GitHub/GitLab)

Étape 1 : Créer un dépôt sur GitHub/GitLab

  1. Va sur github.com ou gitlab.com
  2. Clique sur “New repository” / “New project”
  3. Donne un nom (ex: mon_projet_data)
  4. Ne coche PAS “Initialize with README” (on a déjà un repo local)
  5. Copie l’URL HTTPS

Étape 2 : Connecter le dépôt local

Voir le code 
%%bash
cd mon_projet_data

# Ajouter le dépôt distant (remplace par ton URL)
git remote add origin https://github.com/ton-username/mon_projet_data.git

# Vérifier les remotes
git remote -v

# S'assurer d'être sur la branche main
git branch -M main

# Pousser le code (première fois : -u pour lier la branche)
git push -u origin main

Cloner un projet existant

# Cloner un dépôt
git clone https://github.com/username/projet.git

# Cloner dans un dossier spécifique
git clone https://github.com/username/projet.git mon_dossier

Synchroniser avec le distant

# Récupérer les modifications (fetch + merge)
git pull

# Voir les modifications distantes sans les appliquer
git fetch
git log origin/main --oneline

8️⃣ Travailler avec les branches

Les branches permettent de travailler sur des fonctionnalités en parallèle sans affecter le code principal.

main         ●───●───●───────────●───●  (code stable)
                  │               ↑
feature/etl       └───●───●───●───┘     (nouvelle fonctionnalité)
Voir le code 
%%bash
cd mon_projet_data

# Voir les branches existantes
git branch

# Créer une nouvelle branche
git branch feature/add-etl

# Basculer sur la branche
git switch feature/add-etl

# OU créer + basculer en une commande
git switch -c feature/add-validation

# Faire des modifications
echo "def validate(df): pass" > validation.py
git add validation.py
git commit -m "feat: ajouter module de validation"

# Revenir sur main
git switch main

# Fusionner la branche
git merge feature/add-validation

# Supprimer la branche fusionnée
git branch -d feature/add-validation

Workflow de branches recommandé pour Data Engineers

main (production)
  │
  ├── develop (intégration)
  │     │
  │     ├── feature/etl-clients
  │     ├── feature/dashboard-ventes  
  │     └── fix/bug-parsing-dates
  │
  └── hotfix/critical-fix (urgences)
Branche Usage
main Code en production, toujours stable
develop Intégration des features avant release
feature/* Nouvelles fonctionnalités
fix/* Corrections de bugs
hotfix/* Corrections urgentes en production

9️⃣ Résoudre les conflits de merge

Un conflit survient quand deux personnes modifient la même ligne.

À quoi ressemble un conflit ?

<<<<<<< HEAD
def process_data(df):
    return df.dropna()
=======
def process_data(dataframe):
    return dataframe.fillna(0)
>>>>>>> feature/autre-branche

Comment résoudre ?

  1. Ouvrir le fichier et choisir la bonne version
  2. Supprimer les marqueurs (<<<<<<<, =======, >>>>>>>)
  3. Tester que le code fonctionne
  4. Commiter la résolution
# Après avoir édité le fichier
git add fichier_resolu.py
git commit -m "fix: résoudre conflit sur process_data"

💡 Astuce : Utilise un outil visuel comme VS Code pour résoudre les conflits plus facilement.

🔧 Commandes utiles avancées

git stash — Mettre de côté temporairement

# Sauvegarder les modifications en cours
git stash

# Voir les stash
git stash list

# Récupérer le dernier stash
git stash pop

# Récupérer un stash spécifique
git stash apply stash@{0}

Annuler des changements

# Annuler les modifications d'un fichier (non commité)
git checkout -- fichier.py

# Retirer un fichier de la staging area
git reset HEAD fichier.py

# Annuler le dernier commit (garde les fichiers)
git reset --soft HEAD~1

# Annuler le dernier commit (supprime les fichiers)
git reset --hard HEAD~1  # ⚠️ DANGEREUX

# Créer un commit qui annule un commit précédent
git revert <commit-hash>

Inspecter l’historique

# Historique compact
git log --oneline

# Historique graphique
git log --oneline --graph --all

# Voir les modifications d'un commit
git show <commit-hash>

# Voir qui a modifié chaque ligne
git blame fichier.py

# Chercher un commit par message
git log --grep="ETL"

Cheatsheet — Commandes essentielles

Catégorie Commande Description
Setup git init Initialiser un dépôt
git clone <url> Cloner un dépôt distant
git config --global user.name Configurer son nom
Basique git status Voir l’état des fichiers
git add <fichier> Ajouter à la staging area
git add . Ajouter tous les fichiers
git commit -m "msg" Enregistrer les modifications
Historique git log --oneline Voir l’historique compact
git diff Voir les modifications
git blame <fichier> Voir qui a modifié quoi
Branches git branch Lister les branches
git switch -c <nom> Créer et basculer
git merge <branche> Fusionner une branche
git branch -d <nom> Supprimer une branche
Remote git remote add origin <url> Ajouter un dépôt distant
git push Envoyer sur le serveur
git pull Récupérer du serveur
git fetch Vérifier les changements
Annuler git stash Mettre de côté
git reset --soft HEAD~1 Annuler dernier commit
git revert <hash> Créer un commit d’annulation

📥 Télécharger le Git Cheatsheet officiel (PDF)

Quiz de fin de module

❓ Q1. Git est un outil de :

  1. Design graphique
  2. Gestion de versions
  3. Stockage cloud
  4. Déploiement automatique
💡 Voir la réponse

✅ Réponse : b — Git est un système de gestion de versions distribué.

❓ Q2. Quelle commande initialise un dépôt Git ?

  1. git start
  2. git init
  3. git create
  4. git new
💡 Voir la réponse

✅ Réponse : b — git init crée un nouveau dépôt Git.

❓ Q3. Quelle est la différence entre git commit et git push ?

  1. commit enregistre localement, push envoie au serveur distant
  2. commit supprime des fichiers
  3. push crée un dépôt local
  4. Aucune différence
💡 Voir la réponse

✅ Réponse : a — commit sauvegarde localement, push synchronise avec le serveur.

❓ Q4. Que faut-il mettre dans le .gitignore pour un projet Data ?

  1. Les fichiers Python
  2. Les fichiers de données (CSV, Parquet) et les secrets
  3. Le README
  4. Tous les fichiers
💡 Voir la réponse

✅ Réponse : b — Ne jamais versionner les données volumineuses ni les credentials !

❓ Q5. Quelle commande crée une nouvelle branche et bascule dessus ?

  1. git branch new
  2. git create-branch nom
  3. git switch -c nom
  4. git branch -m nom
💡 Voir la réponse

✅ Réponse : c — git switch -c nom crée et bascule sur la branche.

❓ Q6. Comment annuler le dernier commit tout en gardant les fichiers ?

  1. git delete commit
  2. git reset --hard HEAD~1
  3. git reset --soft HEAD~1
  4. git undo
💡 Voir la réponse

✅ Réponse : c — --soft garde les fichiers, --hard les supprime.

Exercice pratique

Objectif

Créer un projet Data Engineering versionné et le pousser sur GitHub/GitLab.

Instructions

  1. Créer un dossier projet_etl
  2. Initialiser Git
  3. Créer un .gitignore approprié
  4. Créer un fichier etl.py avec un script simple
  5. Créer un fichier README.md
  6. Faire un premier commit
  7. Créer une branche feature/add-config
  8. Ajouter un fichier config.yaml sur cette branche
  9. Merger dans main
  10. Créer un dépôt sur GitHub et pousser le code

✅ Solution

📥 Afficher la solution complète 
# 1. Créer le dossier
mkdir projet_etl && cd projet_etl

# 2. Initialiser Git
git init

# 3. Créer le .gitignore
cat << 'EOF' > .gitignore
# Données
*.csv
*.parquet
data/

# Secrets
.env
credentials.json

# Python
__pycache__/
venv/
EOF

# 4. Créer le script ETL
cat << 'EOF' > etl.py
#!/usr/bin/env python3
"""Simple ETL Pipeline"""

def extract():
    print("📥 Extracting data...")
    return {"data": [1, 2, 3]}

def transform(data):
    print("🔄 Transforming data...")
    return {"data": [x * 2 for x in data["data"]]}

def load(data):
    print("💾 Loading data...")
    print(f"Result: {data}")

if __name__ == "__main__":
    raw = extract()
    transformed = transform(raw)
    load(transformed)
    print("✅ ETL completed!")
EOF

# 5. Créer le README
cat << 'EOF' > README.md
# Projet ETL

Un pipeline ETL simple pour apprendre Git.

## Usage

```bash
python etl.py

EOF

6. Premier commit

git add . git commit -m “feat: initialiser projet ETL”

7. Créer une branche

git switch -c feature/add-config

8. Ajouter la config

cat << ‘EOF’ > config.yaml database: host: localhost port: 5432 name: datawarehouse

etl: batch_size: 1000 log_level: INFO EOF

git add config.yaml git commit -m “feat: ajouter fichier de configuration”

9. Merger dans main

git switch main git merge feature/add-config git branch -d feature/add-config

10. Pousser sur GitHub

git remote add origin https://github.com/ton-username/projet_etl.git git push -u origin main

echo “🎉 Projet créé et poussé avec succès !” ```

📚 Ressources pour aller plus loin

🎮 Apprendre en pratiquant

📖 Documentation

🛠️ Outils

✅ Conclusion

Tu sais maintenant :

  • ✅ Ce qu’est Git, GitHub et GitLab
  • ✅ Comment initialiser et configurer un projet
  • ✅ Le workflow : add → commit → push
  • ✅ Travailler avec les branches
  • ✅ Utiliser .gitignore pour protéger les données sensibles
  • ✅ Résoudre les conflits de merge
  • ✅ Les commandes avancées (stash, reset, revert)

➡️ Prochaine étape

Maintenant que tu sais versionner ton code, passons aux bases de données !

👉 Module suivant : 04_python_basics_for_data_engineers — Les fondamentaux de Python

🎉 Félicitations ! Tu as terminé le module Git pour Data Engineers.

Retour au sommet