Git pour Data Engineers

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

Prérequis

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 ?

💡 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 le CI/CD

Qu'est-ce que GitLab ?

GitLab est une plateforme DevOps complète pouvant être hébergée en cloud ou sur vos propres serveurs.

• CI/CD intégré nativement
• Très utilisé en entreprise
• Peut être auto-hébergé (contrôle total des données)

Qu'est-ce qu'Azure Repos ?

Azure Repos est le service de gestion de code source de Microsoft, intégré dans Azure DevOps.

┌─────────────────────────────────────────────────────────────────┐
│                     AZURE DEVOPS                                │
├──────────────┬──────────────┬──────────────┬────────────────────┤
│ Azure Repos  │ Azure        │ Azure        │ Azure              │
│ (Code/Git)   │ Pipelines    │ Boards       │ Artifacts          │
│              │ (CI/CD)      │ (Tickets)    │ (Packages)         │
└──────────────┴──────────────┴──────────────┴────────────────────┘

• Dépôts Git illimités (privés et publics)
• Intégration native avec Azure Pipelines pour le CI/CD
• Sécurité entreprise : contrôle d'accès granulaire, Active Directory
• Branch policies : règles pour protéger les branches importantes
• Très utilisé dans les entreprises utilisant l'écosystème Microsofts 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️⃣ Comparatif des plateformes Git

┌─────────────────────────────────────────────────────────────────────────────┐
│                    QUAND UTILISER QUOI ?                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   GitHub    → Tu contribues à l'open source ou tu travailles en startup    │
│   GitLab    → Ton entreprise veut héberger son propre Git (souveraineté)   │
│   Azure     → Ton entreprise est dans l'écosystème Microsoft/Azure         │
│   Repos       (Active Directory, Azure Data Factory, Synapse...)            │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

💡 Pour ce cours, tu peux utiliser l'un ou l'autre. Les commandes Git sont identiques sur les trois plateformes !

2️⃣ bis — Azure Repos en pratique

Créer un compte Azure DevOps gratuit

1. Aller sur dev.azure.com
2. Se connecter avec un compte Microsoft (ou en créer un)
3. Créer une organisation (ex: mon-entreprise)
4. Créer un projet (ex: data-engineering)
5. Aller dans Repos → ton dépôt Git est prêt !

✅ Gratuit pour 5 utilisateurs — idéal pour les petites équipes

Cloner un dépôt Azure Repos

# Cloner via HTTPS
git clone https://dev.azure.com/organisation/projet/_git/mon-repo

# Cloner via SSH (recommandé)
git clone git@ssh.dev.azure.com:v3/organisation/projet/mon-repo

Configurer l'authentification

# Option 1 : Personal Access Token (PAT)
# Générer sur dev.azure.com → User Settings → Personal Access Tokens
git config --global credential.helper store

# Option 2 : SSH (même principe que GitHub)
ssh-keygen -t ed25519 -C "ton-email@exemple.com"
# Ajouter la clé publique dans Azure DevOps → User Settings → SSH Keys

Branch Policies (protection des branches)

Azure Repos permet de protéger main avec des règles strictes :

Settings → Branches → main → Branch policies

✅ Require a minimum number of reviewers (ex: 2)
✅ Check for linked work items
✅ Check for comment resolution
✅ Require a merge strategy (Squash merge)
✅ Build validation (lancer les tests avant merge)

💡 En entreprise, ces policies sont quasi-systématiques — connais-les !

Azure Repos + Azure Pipelines : le combo Data Engineering

┌──────────────┐    push     ┌──────────────────┐    trigger    ┌─────────────────┐
│  Azure Repos │ ──────────► │ Azure Pipelines  │ ────────────► │ Azure Data      │
│  (ton code)  │             │ (CI/CD)          │               │ Factory / Synapse│
└──────────────┘             └──────────────────┘               └─────────────────┘

Exemple : tu pushs un script PySpark → Azure Pipelines le teste
          automatiquement → le déploie sur ton cluster Synapse

🎓 Certifications pour aller plus loin

💡 Recommandation : AZ-900 d'abord (gratuit à préparer sur Microsoft Learn), puis DP-203 si tu vises l'écosystème Azure.

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 :

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...)

3. Sur GitHub : Settings → SSH and GPG keys → New SSH key
4. 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

# 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

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

Terminal vs GUI : quand utiliser quoi ?

💡 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

# 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

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 :

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)

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

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é)

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)

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

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

Quiz de fin de module

❓ Q1. Git est un outil de :

a) Design graphique
b) Gestion de versions
c) Stockage cloud
d) Déploiement automatique

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

a) git start
b) git init
c) git create
d) git new

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

a) commit enregistre localement, push envoie au serveur distant
b) commit supprime des fichiers
c) push crée un dépôt local
d) Aucune différence

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

a) Les fichiers Python
b) Les fichiers de données (CSV, Parquet) et les secrets
c) Le README
d) Tous les fichiers

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

a) git branch new
b) git create-branch nom
c) git switch -c nom
d) git branch -m nom

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

a) git delete commit
b) git reset --hard HEAD~1
c) git reset --soft HEAD~1
d) git undo

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

# 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

</details>