Exercice 04 : Synchroniser avec GitHub

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

• ✅ Créer un compte GitHub
• ✅ Configurer l'authentification SSH
• ✅ Créer un repository distant
• ✅ Connecter un repository local à GitHub
• ✅ Pousser (push) et tirer (pull) du code
• ✅ Cloner un repository

Durée estimée : 30 minutes

Difficulté : ⭐⭐☆☆☆ (Débutant+)

Prérequis :

• Avoir complété Exercice 01, 02, 03
• Connexion Internet
• Accès à Git sur votre ordinateur

📖 Contexte

Jusqu'à présent, vous avez travaillé localement. Maintenant, vous allez :

1. Héberger votre code - Sur un serveur (GitHub) pour le conserver
2. Collaborer - Partager le code avec d'autres
3. Sauvegarder - Avoir une copie ailleurs qu'sur votre ordinateur
4. Utiliser les remotes - Concepts clés de Git décentralisé

GitHub est la plateforme la plus populaire (acquise par Microsoft en 2018).

📋 Énoncé

Vous allez :

1. Créer un compte GitHub (si nécessaire)
2. Configurer SSH pour l'authentification
3. Créer un nouveau repository sur GitHub
4. Connecter votre repository local à GitHub (remote)
5. Pousser votre code local vers GitHub
6. Cloner le repository sur une autre destination
7. Synchroniser les changements

Résultat attendu :

• Repository visible sur GitHub.com
• Code poussé avec tous les commits
• Capable de cloner et synchroniser

🔧 Matériel Nécessaire

• GitHub : Compte gratuit (créer si nécessaire)
• Git : Installé localement
• SSH : Clés génér ées (nous le ferons)
• Repository local : celui des exercices 1-3
• Internet
• Temps : 45 minutes

🧭 Déroulement de l'exercice

Voici les grandes étapes à réaliser dans l'ordre. Chaque étape décrit ce que vous devez accomplir - à vous de trouver la commande. La solution complète est disponible si vous êtes bloqué.

Tâche 1 : Créer un compte GitHub

Rendez-vous sur github.com et créez un compte gratuit (ou connectez-vous si vous en avez déjà un).

Indice : Le compte gratuit donne accès à des repositories publics et privés illimités. Choisissez un nom d'utilisateur professionnel.

Vérification : Vous devez voir votre dashboard GitHub avec votre nom d'utilisateur en haut à droite.

Tâche 2 : Générer une clé SSH

Vérifiez si vous avez déjà des clés SSH. Si non, générez-en une paire. La clé privée reste sur votre machine, la clé publique sera partagée avec GitHub.

Indice : Les clés SSH sont stockées dans ~/.ssh/. La commande de génération est ssh-keygen. Utilisez le type rsa ou ed25519 (plus moderne).

Question à se poser : Quelle est la différence fondamentale entre la clé privée et la clé publique ? Laquelle ne faut-il JAMAIS partager ?

Vérification : Deux fichiers doivent exister dans ~/.ssh/ - l'un sans extension (privé) et l'un avec .pub (public).

Tâche 3 : Ajouter la clé publique à GitHub

Copiez le contenu de votre clé publique et ajoutez-la dans les paramètres SSH de votre compte GitHub.

Indice : Dans GitHub : Settings > SSH and GPG keys > New SSH key. Copiez le contenu du fichier .pub (pas le fichier privé !).

Vérification : Testez la connexion SSH avec la commande recommandée par GitHub. Vous devez voir un message de bienvenue avec votre nom d'utilisateur.

Tâche 4 : Créer un repository sur GitHub et le connecter localement

Créez un nouveau repository vide sur GitHub, puis connectez votre repository local à ce remote.

Indice : origin est le nom conventionnel pour désigner le repository distant principal. La commande qui connecte un remote s'appelle git remote add.

Vérification : git remote -v doit afficher l'URL de votre repository GitHub.

Tâche 5 : Pousser votre code

Envoyez tous vos commits locaux vers GitHub.

Indice : Le premier push d'une branche nécessite de préciser la destination distante (--set-upstream ou -u). Les pushes suivants seront plus simples.

Vérification : Rafraîchissez la page de votre repository sur GitHub - vous devez voir vos fichiers et votre historique de commits.

Tâche 6 : Cloner le repository

Clonez votre repository dans un nouveau dossier pour simuler un autre développeur qui récupère le projet.

Indice : git clone URL destination crée une copie locale complète avec tout l'historique et le remote déjà configuré.

Vérification : Le clone doit avoir exactement le même git log --oneline que votre repository original.

� Mini-Projet : Publier un portfolio DevOps

Vous allez créer et publier un repository "portfolio" sur GitHub qui présente vos compétences DevOps en cours d'acquisition.

Scénario : Vous créez un repository public devops-portfolio sur GitHub pour documenter votre progression.

Ce que vous devez réaliser :

1. Créez un nouveau repository public devops-portfolio sur GitHub (sans initialisation automatique)
2. En local, créez le dossier devops-portfolio/ et initialisez-le avec Git
3. Créez un README.md structuré avec : votre nom, les technologies apprises, et un lien fictif vers un projet
4. Faites un premier commit
5. Connectez le repository local au remote GitHub
6. Poussez sur main avec la configuration du upstream
7. Vérifiez sur GitHub que le README est bien affiché
8. Ajoutez une ligne "En cours d'apprentissage : Docker" dans le README et faites un second commit
9. Poussez le second commit
10. Clonez le repository dans un dossier devops-portfolio-backup pour simuler une récupération

Checkpoints de validation :

• Le repository est visible sur github.com/VOTRE_USERNAME/devops-portfolio
• La page du repository affiche votre README formaté
• git log --oneline dans le clone affiche les mêmes 2 commits qu'en local
• git remote -v dans les deux dossiers (local et clone) pointe vers GitHub
• La connexion SSH fonctionne (ssh -T git@github.com renvoie votre nom d'utilisateur)
• Aucun push n'a nécessité un mot de passe (authentification SSH)

�📚 Étapes Détaillées

Étape 1 : Créer un Compte GitHub (si nécessaire)

Objectif : Avoir un compte pour héberger le code

Instructions:

1. Aller sur github.com

1. Si vous n'avez pas de compte :

• Cliquer "Sign up"
• Entrer email, mot de passe, username
• Vérifier l'email
• Accepter les conditions

1. Se connecter à votre compte

Résultat attendu :

• Dashboard GitHub visible
• Vous voyez "Welcome to GitHub"

Étape 2 : Générer une Clé SSH (Authentification)

Objectif : Créer une clé pour communiquer de manière sécurisée avec GitHub

Instructions:

1. Ouvrir un terminal

1. Vérifier si vous avez déjà des clés SSH :

ls ~/.ssh

Résultat possible :

id_rsa         id_rsa.pub
known_hosts

Si id_rsa existe, continuer à l'Étape 3.

1. Si pas de clés : Les générer :

ssh-keygen -t rsa -b 4096 -C "votre@email.com"

1. Appuyer sur Enter pour toutes les questions (garder les valeurs par défaut) :

Enter file in which to save the key (/home/user/.ssh/id_rsa): [Enter]
Enter passphrase (empty for no passphrase): [Enter]
Enter same passphrase again: [Enter]

Résultat attendu :

Your identification has been saved in /home/user/.ssh/id_rsa
Your public key has been saved in /home/user/.ssh/id_rsa.pub

Étape 3 : Ajouter la Clé SSH à GitHub

Objectif : Dire à GitHub d'accepter votre clé SSH

Instructions:

1. Copier votre clé publique :

cat ~/.ssh/id_rsa.pub

Résultat attendu (une longue chaîne) :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDx... votre@email.com

1. Copier toute cette chaîne (Ctrl+C / Cmd+C)

1. Sur GitHub, aller à Settings → SSH and GPG keys

1. Cliquer New SSH key

1. Title : Mettre quelque chose comme "My Laptop"

1. Key : Coller la clé publique (Ctrl+V / Cmd+V)

1. Cliquer Add SSH key

Résultat attendu :

• GitHub accepte la clé
• La clé apparaît dans la liste

Étape 4 : Configurer Name et Email Global (Rappel)

Objectif : S'assurer que Git sait qui vous êtes

Instructions:

git config --global user.name "Votre Nom"
git config --global user.email "votre@email.com"

Vérifier :

git config --global user.name
git config --global user.email

Étape 5 : Créer un Repository sur GitHub

Objectif : Créer l'endroit distant où héberger votre code

Instructions:

1. Sur GitHub, cliquer New (en haut à gauche, dans la barre)

1. Remplir le formulaire :

• Repository name : ma-premiere-app (même nom qu'en local)
• Description : "Mon premier projet Git" (optionnel)
• Public/Private : Private (recommandé, voir ci-dessous)
• Initialize repository : Ne PAS cocher (nous avons déjà un repo local)

🔒 Public vs Private - quelle différence ?

Choisissez Private pour cet exercice : votre code ne sera visible que par vous (et les collaborateurs que vous invitez explicitement). Vous pourrez toujours le rendre public plus tard depuis les paramètres du repo.

1. Cliquer Create repository

Résultat attendu :

• Vous êtes redirigé vers votre nouveau repo
• Page avec des instructions (en blue)
• URL SSH visible : git@github.com:username/ma-premiere-app.git

Étape 6 : Ajouter le Remote

Objectif : Connecter votre repository local à GitHub

Instructions:

1. Copier l'URL SSH de votre nouveau repo GitHub (en haut de la page, bouton vert "Code")

Doit ressembler à :

git@github.com:username/ma-premiere-app.git

1. Dans votre terminal local (dans le dossier ma-premiere-app), initialisez le repo si ce n'est pas déjà fait :

git init
git branch -M main

1. Puis ajoutez le remote :

git remote add origin git@github.com:USERNAME/ma-premiere-app.git

Remplacer USERNAME par votre username GitHub.

1. Vérifier le remote :

git remote -v

Résultat attendu :

origin  git@github.com:username/ma-premiere-app.git (fetch)
origin  git@github.com:username/ma-premiere-app.git (push)

Explication :

• origin = nom du remote
• fetch = pour récupérer
• push = pour envoyer

Étape 7 : Pousser le Code vers GitHub

Objectif : Envoyer tous vos commits locaux vers GitHub

Instructions:

1. Vérifier que vous avez des commits :

git log --oneline -3

1. Pousser la branche main vers origin :

git push origin main

Résultat attendu (première fois) :

Enumerating objects: 10, done.
Counting objects: 100% (10/10), done.
Delta compression using up to 8 threads
Compressing objects: 100% (8/8), done.
Writing objects: 100% (10/10), 2.34 KiB | 2.34 MiB/s, done.
Total 10 (delta 2), reused 0 (delta 0), reused 1 (delta 0)
remote: Resolving deltas: 100% (2/2), done.
To github.com:username/ma-premiere-app.git
 * [new branch]      main -> main

Explication :

• Git a compressé et envoyé vos commits
• [new branch] = première fois que main est poussée

1. Vérifier sur GitHub.com :

• Rafraîchir la page
• Vous devriez voir vos fichiers (README.md, main.py, etc.)
• Voir l'historique des commits

Étape 8 : Faire un Local Change et le Pousser

Objectif : Pratiquer la séquence normale : modifier → committer → pousser

Instructions:

1. Modifier un fichier localement :

echo "
## Documentation Complète

Voir le fichier INSTALL.md pour les détails.
" >> README.md

1. Ajouter et committer :

git add README.md
git commit -m "Ajouter note de documentation au README"

1. Pousser le changement :

git push origin main

Résultat attendu :

Updating 1f9c3a4..6a2b5c8
Fast-forward
 README.md | 4 +++
 1 file changed, 4 insertions(+)

1. Vérifier sur GitHub.com :

• Vous devriez voir le README modifié
• Le commit devrait être visible

Étape 9 : Cloner le Repository

Objectif : Simuler quelqu'un d'autre qui récupère votre code

Instructions:

1. Créer un dossier de test :

cd /tmp  #(ou C:\Users\YouName\AppData\Local\Temp sur Windows)

1. Cloner votre repository depuis GitHub :

git clone git@github.com:USERNAME/ma-premiere-app.git ma-premiere-app-clone

Résultat attendu :

Cloning into 'ma-premiere-app-clone'...
remote: Enumerating objects: ...
Receiving objects: 100% (12/12), done.

1. Entrer dans le dossier :

cd ma-premiere-app-clone

1. Vérifier les fichiers :

ls -la

Résultat attendu : Tous vos fichiers sont là (README.md, main.py, CONTRIBUTING.md, etc.)

1. Vérifier l'historique :

git log --oneline -5

Résultat attendu : Tous vos commits sont présents

Étape 10 : Simuler la Collaboration

Objectif : Pratiquer push/pull avec plusieurs endroits

Instructions:

1. Dans le clone, faire un changement :

echo "# Configuration de Développement" > DEV.md
git add DEV.md
git commit -m "Ajouter guide de développement"
git push origin main

Résultat attendu :

remote: Create a pull request for ... 
To github.com:username/ma-premiere-app.git
   6a2b5c8..7c3f1e9  main -> main

1. Dans le dossier original (ma-premiere-app), récupérer les changements :

cd ../ma-premiere-app  # Revenir au dossier original
git pull origin main

Résultat attendu :

From github.com:username/ma-premiere-app
 * branch            main     -> FETCH_HEAD
Updating 6a2b5c8..7c3f1e9
Fast-forward
 DEV.md | 1 +
 1 file changed, 1 insertion(+)

1. Vérifier que DEV.md est maintenant dans le dossier original :

ls -la
cat DEV.md

C'est la collaboration ! 🎉

✅ Vérification du Résultat

Pour vérifier que vous avez réussi :

# Vérifier le remote
git remote -v                        # Doit montrer 'origin'

# Vérifier que GitHub a le code
# Aller sur github.com/USERNAME/ma-premiere-app

# Vérifier le clone
cd ../ma-premiere-app-clone
git remote -v                        # Doit montrer 'origin'
ls -la                               # Tous les fichiers présents
git log --oneline | head -5          # Historique présent

Checklist finale :

• ✅ Compte GitHub créé/accessible
• ✅ Clé SSH configurée
• ✅ Repository créé sur GitHub
• ✅ Remote 'origin' connecté
• ✅ Code poussé avec git push
• ✅ Repository cloné avec succès
• ✅ Synchronisation push/pull fonctionne

🎮 Défi Bonus

Défi 1 : Créer ensuite une Pull Request

# Créer une branche
git checkout -b feature/github-ci

# Faire un changement
echo "# Tests Automatiques" > CI.md
git add CI.md
git commit -m "Ajouter documentation CI"

# Pousser la branche
git push origin feature/github-ci

# Allez sur GitHub et créez une Pull Request
# (bouton "Compare & pull request")

Défi 2 : Ajouter un fichier .gitignore

echo "
__pycache__/
*.pyc
.env
node_modules/
.DS_Store
" > .gitignore

git add .gitignore
git commit -m "Ajouter .gitignore complet"
git push origin main

Défi 3 : Voir l'historique sur GitHub

# Sur GitHub.com, cliquer "Commits"
# Vous verrez tous les commits avec auteur et date
# Cliquer sur un commit pour voir les changements détaillés

💡 Points Clés à Retenir

1. SSH : Authentification sécurisée sans mot de passe à chaque fois
2. Remote : Serveur distant (GitHub) où stocker le code
3. Origin : Nom conventionnel du serveur principal
4. Push : Envoyer les changements locaux au serveur
5. Pull : Récupérer les changements du serveur

🎯 Prochaines Étapes

• ✅ Vous savez synchroniser avec GitHub
• 🔜 Exercice suivant : Collaboration en équipe
• 🚀 Index des exercices : Tous les exercices

Bravo ! Vous êtes maintenant sur GitHub ! 🚀