Sommaire > Chapitre 5 > Chapitre 6
6

Travailler avec GitHub à distance

🎯 Objectifs de ce chapitre

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

Rappel du chapitre précédent

Au chapitre 5, tu as appris à travailler en local. Maintenant, nous allons connecter ton travail local à GitHub !

🔗 Comprendre les dépôts distants (remotes)

💻

Dépôt Local

Sur ton ordinateur

  • 📝 Tes modifications
  • 💾 Tes commits
  • 🔧 Ton environnement
↑ push
Envoie vers GitHub
↓ pull
Récupère de GitHub
☁️

Dépôt Distant

Sur GitHub

  • 🌍 Code partagé
  • 👥 Collaboration
  • 💽 Sauvegarde

Vérifie la connexion remote

Dans ton dossier de projet, vérifie si Git connaît déjà ton dépôt distant :

git remote -v
Explication : Cette commande montre tous les dépôts distants configurés. Le -v signifie "verbose" (détaillé).

Si tu as cloné ton dépôt (chapitre 5), tu devrais voir :

origin  https://github.com/ton-username/mon-premier-projet.git (fetch)
origin  https://github.com/ton-username/mon-premier-projet.git (push)

Comprendre "origin"

origin est le nom par défaut que Git donne au dépôt distant principal. C'est comme un surnom pour l'URL de ton dépôt GitHub.

Pourquoi "origin" ?

Quand tu clones un dépôt, Git appelle automatiquement le dépôt source "origin" (origine). Tu peux avoir plusieurs remotes avec des noms différents !

Si tu n'as pas de remote configuré

Si git remote -v ne montre rien, tu peux ajouter un remote manuellement :

git remote add origin https://github.com/ton-username/mon-premier-projet.git
Explication : Cette commande dit à Git : "Associe l'URL GitHub au nom 'origin'".

🚀 Envoyer tes commits avec git push

Maintenant que ta connexion est établie, envoyons ton travail vers GitHub !

1

Vérifie ton travail local

Assure-toi d'avoir des commits à envoyer :

git log --oneline

Tu devrais voir tes commits du chapitre 5.

↓
2

Pousse vers GitHub

Utilise la commande git push :

git push origin main
Explication : "Pousse la branche 'main' vers le remote 'origin'"
↓
3

Vérifie sur GitHub

Va sur ta page GitHub et actualise. Tes fichiers et commits doivent être là !

🎉 Félicitations ! Ton code est maintenant en ligne.

Comprendre la commande push

Décomposons git push origin main :

  • git push : Commande pour envoyer des commits
  • origin : Nom du dépôt distant (GitHub)
  • main : Nom de la branche à envoyer

Première connexion ? Authentification requise

Si c'est ta première fois, GitHub va te demander de t'authentifier :

Méthodes d'authentification

Token personnel (recommandé) : Crée un token dans tes paramètres GitHub
SSH (avancé) : Configuration sécurisée avec clés
HTTPS : Mot de passe (déprécié)

Suis les instructions à l'écran pour t'authentifier.

Vérifie le résultat

Si tout fonctionne, tu devrais voir :

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 285 bytes | 285.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To https://github.com/ton-username/mon-premier-projet.git
   1a2b3c4..5e6f7g8  main -> main

Push simplifié

Une fois configuré, tu peux souvent utiliser juste git push. Git se souvient de ta branche par défaut.

📥 Récupérer les changements avec git pull

Maintenant, voyons comment récupérer les changements depuis GitHub.

1

Simule un changement sur GitHub

Va sur GitHub et édite ton README.md en ligne. Ajoute une ligne comme :

Modifié directement sur GitHub !

Fais un commit de ce changement.

↓
2

Récupère les changements

Dans ton terminal, utilise git pull :

git pull origin main
Explication : "Récupère et fusionne les changements de la branche 'main' depuis 'origin'"
↓
3

Vérifie localement

Ouvre ton README.md local. Tu devrais voir la modification que tu as faite sur GitHub !

Comprendre git pull

git pull fait deux choses :

  1. Télécharge les nouveaux commits depuis GitHub
  2. Fusionne ces changements dans ta branche locale

Pull avant de travailler

Bonnes pratiques : Toujours faire git pull avant de commencer à travailler pour avoir la version la plus récente.

Vérifie le résultat

Tu devrais voir quelque chose comme :

remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Total 3 (delta 0), reused 0 (delta 0)
Dépaquetage des objets: 100% (3/3), 285 bytes | 1024 bytes/s, fait.
Depuis https://github.com/ton-username/mon-premier-projet
   1a2b3c4..5e6f7g8  main     -> origin/main
Mise à jour 1a2b3c4..5e6f7g8
Fast-forward
 README.md | 1 +
 1 file changed, 1 insertion(+)

🔄 Workflow de synchronisation complet

Maintenant, pratiquons le cycle complet :

Étape 1 : Commence avec la dernière version

git pull

Étape 2 : Travaille localement

Crée un nouveau fichier instructions.md :

# Instructions d'installation

1. Cloner le projet
2. Lire le README
3. Profiter !

Étape 3 : Commit tes changements

git add instructions.md
git commit -m "Ajoute les instructions d'installation"

Étape 4 : Envoie vers GitHub

git push

Étape 5 : Vérifie sur GitHub

Actualise ta page GitHub. Ton nouveau fichier doit être là !

🎉 Cycle maîtrisé !

Tu viens d'exécuter le workflow de base de collaboration Git/GitHub :
pull → travail → add → commit → push

🚨 Gestion des erreurs courantes

Erreur : "non-fast-forward"

Si tu vois cette erreur, cela signifie que GitHub a des commits que tu n'as pas localement.

Solution :

git pull
# Résous les conflits si nécessaire
git push

Erreur : "failed to push some refs"

Souvent due à des conflits entre tes commits et ceux sur GitHub.

Solution :

git pull --rebase
git push

Conseil de sécurité

Toujours faire git status avant git push pour vérifier que tout est en ordre.

✅ Résumé du chapitre

Ce que tu as accompli

  • ✅ Compris le concept de remote et vérifié ta connexion
  • ✅ Envoyé tes commits vers GitHub avec git push
  • ✅ Récupéré des changements avec git pull
  • ✅ Pratiqué le workflow complet pull → travail → commit → push
  • ✅ Géré l'authentification GitHub
  • ✅ Compris les erreurs courantes et leurs solutions

Félicitations ! Tu maîtrises maintenant la synchronisation entre ton ordinateur et GitHub. Dans le prochain chapitre, nous aborderons les branches pour travailler sur plusieurs fonctionnalités en parallèle.

Pour t'entraîner

Fais quelques cycles complets : modifie un fichier sur GitHub, pull localement, modifie localement, push vers GitHub. Plus tu pratiques, plus ça deviendra naturel !