¶ Création d'un compte GitHub
Créez un compte sur https://github.com/ (option "sign up")
¶ Premiers pas
Une fois le compte créé, créer un premier dépôt appelé "hello-world" :
- ajouter une description
- visibilité "public"
- ajouter un "README"
Notre repo ne dispose que d'un seule branche principale "main"
On crée une nouvelle branche "readme-edit" :
Modifier le fichier README.md en utilisant la syntaxe Markdown
Puis on sauvegarde par un commit, en expliquant les changements :
Expérimentez différentes choses :
- naviguer entre les branches (et voir les différences dans le fichier README)
- lancer un Pull Request et voyez la représentation des différences
- lancer la fusion (merge) du Pull Request, qui devrait être automatique car il n'y a pas de conflit.
Il est possible alors de supprimer la branche devenue inutile puisque fusionnée avec la branche principale :
¶ Expérience collaborative
- créer une branche rattachée à main pour chaque collaborateur
- chacun se connecte au compte, et sur sa branche ajoute un paragraphe au fichier README où il se présente en quelques mots (par exemple).
- puis ensemble procéder à la fusion des modifications (depuis une seule session).
- il y aura une résolution de conflits à résoudre.
¶ Un projet collaboratif
Nous allons maintenant découvrir et manipuler Git et GitHub, deux outils essentiels pour le travail collaboratif en développement logiciel, au travers d'un projet simple de gestion de tâches en Python.
¶ Installation de Git
Pour chacun des collaborateurs, on utilise une VM Debian disposant d'une interface graphique (terminal supportant le copier/coller, navigateur Web) et connectée à Internet (telle que la machine debian-gui du miniLAB). On est loggé avec un utilisateur sudoer.
Installez Git à l’aide du gestionnaire de paquets :
sudo apt update && sudo apt upgrade && sudo apt install -y git
On vérifie l'installation et la version de git :
git --version
Une fois installé, configurez Git avec vos informations personnelles :
git config --global user.name "Prénom NOM"
git config --global user.email "adresse@email.com"
Pour afficher la configuration :
git config --list
Ou en consultant le fichier de configuration :
cat ~/.gitconfig
On peut également indiquer un éditeur de texte par défaut :
git config --global core.editor "/usr/bin/nano"
¶ Création du repo sur GitHub
Sur github créer un repo appelé todo-list :
- public
- ne pas cocher "add readme"
- Description : "Un projet simple de gestion de tâches"
Après avoir cliqué sur Create repository, une URL sera générée pour le dépôt, ainsi que des insctructions de déploiement :
Depuis 2021, github ne prend plus en charge l'authentification par https, il faut donc récupérer le lien pour SSH, par exemple ici :
git@github.com:pm-info/todo-list.git
¶ Création du repo local
Sur un poste local, créer un répertoire de travail pour le projet :
mkdir ~/todo-list
et se positionner dessus :
cd ~/todo-list
Initialisez un dépôt Git local :
git init
on crée un script python :
nano todo.py
qui contient donc le code source initial du projet :
taches = []
def ajouter_tache(tache):
taches.append(tache)
print(f"Tâche ajoutée : {tache}")
def lister_taches():
print("Liste des tâches :")
for i, tache in enumerate(taches, 1):
print(f"{i}. {tache}")
def main():
while True:
print("\nOptions : [1] Ajouter une tâche [2] Lister les tâches [3] Quitter")
choix = input("Choisissez une option : ")
if choix == "1":
tache = input("Entrez une tâche : ")
ajouter_tache(tache)
elif choix == "2":
lister_taches()
elif choix == "3":
print("Au revoir !")
break
else:
print("Option invalide.")
if __name__ == "__main__":
main()
Utilisez au besoin un outil d'IA pour analyser et expliquer ce que fait ce script.
Normalement, le développement en Python passe par la création d'un environnement virtuel (venv) ; pour plus de clarté nous ne l'utiliserons pas ici.
Ajoutez ce fichier au suivi Git (le stage) :
git add todo.py
Et faites votre premier commit :
git commit -m "Ajout du script initial."
¶ Mise en place du lien local/distant
L'étape suivante consiste à mettre en place la connexion authentifiée et sécurisée entre le repo local et le repo distant sur GitHub.
Créer une paire de clés SSH (RSA ou ed25519, on prendra ici le second) :
ssh-keygen -t ed25519 -b 4096 -C "adresse@email.com"
Récuperer la clé publique :
cat ~/.ssh/id_ed25519.pub
Copier le texte de la clé publique et et ajouter une clé ssh dans les settings de github : https://github.com/settings/keys
tester la connexion :
ssh -T git@github.com
Il est probable que vous ayez à confirmer l'identité de github suite à ce message :
The authenticity of host 'github.com (140.82.121.3)' can't be established.
ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU.
This key is not known by any other names.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Puis vous aurez ce message :
Hi <user> ! You've successfully authenticated, but GitHub does not provide shell access.
On peut désormais lier le dépôt local au dépôt GitHub, en ajoutant l’URL du dépôt GitHub comme dépôt distant (attention à adapter la commande ci-dessous) :
git remote add origin <url ssh du projet>
On vérifie le lien au dépôt GitHub :
git remote -v
Ce qui doit donner :
origin git@github.com:xxxxxx/todo-list.git (fetch)
origin git@github.com:xxxxxx/todo-list.git (push)
¶ Synchronisation
Créez la branche main du projet, avec :
git branch -M main
et lancez la synchronisation :
git push -u origin main
Rendez-vous sur la page du dépôt sur GitHub. Vous devriez voir :
- la branche main
- Le fichier
todo.pylisté. - Le premier commit avec son commentaire.
Dans le dossier du projet local, créez un fichier nommé README.md (attention à la casse) :
nano README.md
Et on y insère par exemple ce texte en markdown :
# Gestionnaire de Tâches (To-Do List)
Ce projet est un script Python simple pour gérer une liste de tâches en ligne de commande.
Il permet d'ajouter, lister et (potentiellement) supprimer des tâches.
## Fonctionnalités
- Ajouter une tâche.
- Lister toutes les tâches.
- Quitter le programme.
## Instructions
1. Clonez le projet sur votre machine :
```bash
git clone <url_du_dépôt>
cd todo-list
```
2. Lancez le programme avec Python :
```bash
python3 todo.py
```
## Prochaines Améliorations (Suggestions)
- Permettre de supprimer des tâches spécifiques.
- Sauvegarder les tâches dans un fichier pour les conserver entre les sessions.
- Ajouter une fonctionnalité pour marquer une tâche comme terminée.
Ajoutez ce fichier au staging :
git add README.md
Faites un commit :
git commit -m "Ajout du README.md pour la description du projet"
et "poussez" le fichier sur GitHub :
git push origin main
¶ Ajout d'un collaborateur au projet
Depuis le terminal d'un autre collaborateur (ça peut être un autre utilisateur sur votre machine Linux), on configure git de la même façon que ci-dessus.
En tant que sudoer, installez Git à l’aide du gestionnaire de paquets :
sudo apt update && sudo apt upgrade && sudo apt install -y git
Configurez ensuite Git avec vos informations personnelles :
git config --global user.name "Prénom NOM"
git config --global user.email "adresse@email.com"
Créer une paire de clés SSH (RSA ou ed25519, on prendra ici le second) :
ssh-keygen -t ed25519 -b 4096 -C "adresse@email.com"
Récuperer la clé publique :
cat ~/.ssh/id_ed25519.pub
Copier le texte de la clé publique et et ajouter une nouvelle clé ssh dans les settings de github : https://github.com/settings/keys
La commande suivant va créer une clone local du projet (à adapter selon votre propre URL:
git clone <url ssh du projet>
Puis on se positionne dans le dossier du projet :
cd todo-list
On vérifie le lien au dépôt GitHub :
git remote -v
Ce qui doit donner :
origin git@github.com:xxxxxxxx/todo-list.git (fetch)
origin git@github.com:xxxxxxxx/todo-list.git (push)
Enfin, on met à jour le dépôt local avant de commander à travailler :
git pull origin main
¶ Travail collaboratif
Désormais, chaque collaborateur va pouvoir développer une fonctionnalité du script chacun de son côté.
¶ 1. Supprimer une tâche
Un premier collaborateur va ajouter la fonctionnalité "supprimer une tâche" dans le script.
Il va créer localement un nouvelle branche appelée remove-task :
git push origin feature/remove-task
Il développe et teste la fonctionnalité dans le script, il indique les modifications dans le README file, puis il soumet la modification :
git status
git add todo.py
git add README.md
git commit -m "Développement de la fonctionnalité supprimer une tâche"
git push origin feature/remove-task
¶ 2. Ajouter la persistance
Un deuxième collaborateur va ajouter la fonctionnalité "sauvegarde locale des taches (persistance)" dans le script.
Il va créer localement un nouvelle branche appelée backup, selon le même procédé que pour le premier.
¶ 3. Fonctionnalité tâche terminée
Un troisième collaborateur va ajouter la fonctionnalité "tâche terminée" dans le script.
Il va créer localement un nouvelle branche appelée mark-done, toujours selon le même procédé que pour le premier.
¶ Pull Request (PR)
Rendez-vous sur le dépôt GitHub. GitHub affiche un message comme :
"Your branch feature/remove-task has recent pushes. Would you like to create a Pull Request?"
Cliquez sur Compare & Pull Request.
Ajoutez un titre clair et une description pour expliquer les changements apportés (par exemple : Ajout de la fonctionnalité pour supprimer une tâche).
Cliquez sur Create Pull Request.
¶ Révision du Pull Request
Le chef de projet peut examiner le code, suggérer des modifications (via des commentaires), ou approuver le PR. Si tout est bon, on passe à la fusion.
¶ Fusionner les branches sur GitHub
Une fois que le PR a été approuvé :
- Cliquez sur Merge Pull Request.
- Confirmez en cliquant sur Confirm Merge.
- Supprimez la branche fusionnée sur GitHub en cliquant sur Delete branch (optionnel mais recommandé pour garder le dépôt propre).
- Répétez ce processus pour chaque branche.
¶ Mettre à jour les copies locales
Après la fusion des branches sur GitHub, chaque collaborateur doit synchroniser sa copie locale avec les derniers changements fusionnés dans la branche main :
- Basculez sur la branche main :
git checkout main - "Tirez" les derniers changements de GitHub :
git pull origin main
¶ Résolution des conflits (si nécessaire)
Des conflits peuvent survenir si deux branches modifient la même partie d’un fichier. Voici comment les gérer :
- Identifier un conflit
Lorsque vous essayez de fusionner une branche qui a des conflits, Git vous le signale :
Auto-merging todo.py
CONFLICT (content): Merge conflict in todo.py
Automatic merge failed; fix conflicts and then commit the result.
Étapes pour résoudre un conflit :
-
Ouvrez le fichier concerné (par exemple,
todo.py). Vous verrez des marqueurs de conflit dans le fichier :<<<<<<< HEAD print("Option invalide.") ======= print("Choix non reconnu.") >>>>>>> feature/remove-task- HEAD correspond au code dans la branche actuelle.
- feature/remove-task correspond au code de la branche fusionnée.
-
Modifiez le fichier pour conserver la bonne version (ou combinez les deux). Par exemple :
print("Option invalide ou non reconnue.") -
Une fois le conflit résolu, ajoutez le fichier au staging :
git add todo.py -
Faites un commit pour enregistrer la résolution du conflit :
git commit -m "Résolution des conflits entre main et feature/remove-task" -
Relancez la fusion ou poussez les modifications :
git push origin main
¶ Glossaire des commandes
Voici un résumé des commandes qui auront pu être utilisées au cours de ces travaux :
| Commande | Rôle |
|---|---|
git config --global user.name "Nom" |
Configure le nom de l'utilisateur pour Git. |
git config --global user.email "email" |
Configure l'email de l'utilisateur pour Git. |
git init |
Initialise un dépôt Git local. |
git clone <URL> |
Clone un dépôt distant (GitHub) sur la machine locale. |
git status |
Affiche l'état des fichiers dans le dépôt (modifiés, non suivis, etc.). |
git add <fichier> |
Ajoute un fichier spécifique à la zone de staging (préparation pour un commit). |
git add . |
Ajoute tous les fichiers modifiés et non suivis à la zone de staging. |
git commit -m "Message" |
Enregistre les modifications dans le dépôt avec un message descriptif. |
git push origin <branche> |
Envoie les commits locaux vers le dépôt distant sur une branche donnée. |
git pull origin <branche> |
Récupère et fusionne les dernières modifications du dépôt distant. |
git branch |
Affiche la liste des branches locales. |
git branch -a |
Affiche toutes les branches (locales et distantes). |
git checkout <branche> |
Permet de basculer sur une branche locale. |
git checkout -b <branche> |
Crée et bascule sur une nouvelle branche locale. |
git rm --cached <fichier> |
Supprime un fichier de l'index Git sans le supprimer du système de fichiers local. |
Tout ce qui concerne la gestion des pull request et des merge est traité depuis l'administration Web de GitHub ; il existe cependant des outils clients (console ou GUI) pour gérer ces phases complexes depuis l'ordinateur local.