Maîtrisez les commandes Git indispensables pour GitLab

Commandes Git essentielles pour GitLab

Pourquoi apprendre les commandes Git ?

Savoir utiliser GitLab via son interface web est utile mais le véritable travail de développeur se passe dans le terminal. Les commandes Git sont le langage qui vous permet de communiquer avec GitLab pour envoyer votre code, fusionner vos modifications avec celles de vos collègues ou récupérer la toute dernière version d'un projet.

Imaginez que Git est un journal de bord ultra précis. Chaque commande que vous tapez écrit une ligne dans ce journal pour dire qui a changé quoi et quand. Sans ces commandes, travailler à plusieurs sur les mêmes fichiers deviendrait vite un chaos total.

Installation par système

L'installation de Git est rapide et permet à votre terminal (ou invite de commande) de comprendre les instructions que nous allons utiliser tout au long de ce cours.

Sur Linux (Ubuntu/Debian)

C'est le système le plus simple pour installer Git car il utilise le gestionnaire de paquets natif :

sudo apt-get update
sudo apt-get install git

Sur Windows

Pour Windows, la méthode la plus courante est d'utiliser l'installateur officiel :

1. Téléchargez l'exécutable sur le site officiel git-scm.com.
2. Lancez l'installation et conservez les options par défaut (elles sont optimisées pour débuter).
3. Une fois terminé, vous disposerez de Git Bash, un terminal qui simule l'environnement Linux sur votre PC.

Sur macOS

Si vous avez installé Xcode, Git est probablement déjà présent. Sinon, vous pouvez l'installer via Homebrew :

brew install git

Vérifier que Git est prêt

Une fois l'installation terminée, quel que soit votre système, ouvrez un terminal et tapez la commande suivante pour confirmer que tout fonctionne :

git --version

Résultat attendu :

git version 2.43.0 (ou supérieur)

Configuration de votre identité

Avant de commencer à coder, vous devez indiquer à Git qui vous êtes. Cela permet à GitLab d'afficher votre nom et votre adresse email à côté de vos modifications (commits). C'est une étape que l'on ne fait qu'une seule fois après l'installation.

Définir le nom et l'email

Ouvrez votre terminal et tapez les commandes suivantes en remplaçant les valeurs par les vôtres :

git config --global user.name "VOTRE_NOM"
git config --global user.email "votre_email@example.com"

Vérifier la configuration

Pour être certain que Git a bien enregistré vos informations, vous pouvez lister la configuration actuelle :

git config --global --list

Résultat :

user.name=VOTRE_NOM
user.email=votre_email@example.com
core.repositoryformatversion=0
core.filemode=true
core.bare=false

Démarrer un nouveau projet avec Git Init

Initialiser votre dépôt local

Avant d'envoyer quoi que ce soit sur GitLab, vous devez transformer un simple dossier de votre ordinateur en un dépôt Git. Sans cette étape, Git ne surveille pas vos fichiers et ne peut pas enregistrer l'historique de vos modifications.

La commande git init est l'acte de naissance de votre projet. Elle crée un dossier caché nommé .git à la racine de votre répertoire. C'est dans ce dossier que Git va stocker toutes les versions successives de votre code.

C'est la toute première commande à taper lorsque vous commencez un nouveau développement "à partir de rien" sur votre machine.

Créer le dossier du projet

Ouvrez votre terminal et créez un nouveau répertoire pour votre application, puis entrez dedans :

mkdir mon-super-projet
cd mon-super-projet

Lancer l'initialisation

Tapez maintenant la commande magique pour activer Git :

git init

Résultat :

Initialized empty Git repository in /votre/chemin/mon-super-projet/.git/

Créer le premier fichier et lier à GitLab

Une fois le dépôt initialisé, vous pouvez créer votre premier fichier (souvent un README.md) et préparer votre premier envoi vers GitLab :

echo "# Mon Projet" >> README.md
git add README.md
git commit -m "Initial commit : création du projet"

Maintenant que votre projet local est initialisé et possède son premier commit, vous pouvez passer à la configuration de votre identité et à l'utilisation des branches pour organiser votre travail.

Envoyer vos modifications sur GitLab

Une fois que vous avez modifié vos fichiers, il faut les préparer avant de les envoyer sur le serveur. C'est un processus en trois étapes : vérifier le Status, préparer avec Add et envoyer vos modifications avec le Push.

Vérifier l'état des fichiers

Cette commande vous montre quels fichiers ont été modifiés mais ne sont pas encore enregistrés :

git status

Résultat :

On branch ma-nouvelle-fonctionnalite
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git restore ..." to discard changes in working directory)
        modified:   index.html

Untracked files:
  (use "git add ..." to include in what will be committed)
        style.css

no changes added to commit (use "git add" and/or "git commit -a")

Préparer et envoyer

Pour ajouter tous les fichiers modifiés et les nouveaux fichiers à la zone de préparation, on utilise généralement :

git add .

Maintenant que vos fichiers sont prêts, vous devez créer un commit. C'est une sorte de "point de sauvegarde" dans l'histoire de votre projet, accompagné d'un message explicatif :

git commit -m "Description claire de vos modifications"

Créer le lien avec le serveur (Remote)

Attention : Avant de pouvoir envoyer votre code pour la toute première fois, il y a une manipulation indispensable que beaucoup oublient. Vous devez dire à votre dossier local : "Ton serveur de référence se trouve à cette adresse". Sans cela, Git est comme un facteur qui a un colis mais pas d'adresse de livraison.

Allez sur la page de votre projet GitLab, copiez l'URL (en HTTPS ou SSH) et tapez cette commande dans votre terminal :

git remote add origin https://gitlab.votre-domaine.com/votre-nom/votre-projet.git

Explication : Le mot origin est simplement le petit nom (un alias) que l'on donne à votre serveur distant pour ne pas avoir à retaper toute l'URL à chaque fois.

Pousser vers le serveur (Push)

Ensuite, envoyez vos modifications vers votre dépôt GitLab :

git push origin ma-nouvelle-fonctionnalite

Résultat :

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 328 bytes | 328.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
To https://gitlab.com/votre-projet/repo.git
 * [new branch]      ma-nouvelle-fonctionnalite -> ma-nouvelle-fonctionnalite

Cloner un projet : Récupérer le dépôt localement

Pourquoi cloner ?

Pour commencer à travailler, vous ne pouvez pas simplement copier-coller des fichiers. Vous devez cloner le dépôt. Cette opération crée une copie exacte du projet GitLab sur votre ordinateur, tout en conservant le lien avec le serveur pour pouvoir envoyer vos modifications plus tard.

C'est l'étape qui permet de passer du "vide" à un dossier de travail complet contenant tout l'historique du projet.

Le clonage se fait généralement via une adresse URL que vous récupérez directement sur l'interface de GitLab.

Récupérer l'URL de clonage

Rendez-vous sur la page de votre projet sur GitLab. Cliquez sur le bouton bleu Clone et copiez l'adresse sous "Clone with HTTPS" ou "Clone with SSH" (on va configurer nos clés SSH dans le futur chapitre).

Lancer la commande dans le terminal

Ouvrez votre terminal, placez-vous dans le dossier où vous voulez ranger vos projets et tapez la commande suivante :

git clone https://gitlab.com/votre-nom/votre-projet.git

Résultat :

Cloning into 'votre-projet'...
remote: Enumerating objects: 150, done.
remote: Counting objects: 100% (150/150), done.
Receiving objects: 100% (150/150), 45.20 KiB | 1.20 MiB/s, done.

Maintenant que vous avez le code sur votre machine, vous pouvez utiliser la commande Pull pour récupérer les mises à jour de vos collègues.

Travailler avec les dépôts et les branches

Une branche Git est comme un univers parallèle de votre code. La branche principale s'appelle aujourd'hui main. Créer une nouvelle branche vous permet de tester de nouvelles idées ou de développer une fonctionnalité sans casser le code principal qui est en production.

Récupérer le code (Pull)

Avant de commencer à travailler, il faut toujours récupérer les nouveautés poussées par vos collègues pour éviter les conflits :

git pull origin main

Résultat :

From https://gitlab.com/votre-projet/repo
 * branch            main     -> FETCH_HEAD
Already up to date.

Gérer les branches

Pour créer une nouvelle branche et vous déplacer dessus immédiatement, la commande moderne recommande d'utiliser switch avec l'option -c :

git switch -c ma-nouvelle-fonctionnalite

Résultat :

Switched to a new branch 'ma-nouvelle-fonctionnalite'

Si vous voulez simplement revenir sur la branche principale :

git switch main

Fusionner et nettoyer

Quand votre travail est terminé et validé, vous voulez que vos modifications rejoignent la branche principale. C'est ce qu'on appelle fusionner les branches (Merge).

Préparer du contenu sur votre branche

Avant de fusionner, nous allons créer un fichier concret pour simuler un ajout réel. Assurez-vous d'être sur votre branche de travail, puis créez un fichier index.html :

git switch ma-nouvelle-fonctionnalite
echo "<h1>Bienvenue sur mon projet GitLab</h1>" > index.html
git add index.html
git commit -m "Ajout de la page d'accueil index.html"

Fusionner des branches

Pour ramener les changements de votre branche vers main, vous devez d'abord basculer sur le tronc principal, puis lancer la commande de fusion Git :

git switch main
git merge ma-nouvelle-fonctionnalite

Résultat :

Updating 34b1c23..a1b2c3d
Fast-forward
 index.html | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 index.html

Annuler des changements

Si vous avez fait une erreur et que vous voulez supprimer vos modifications non enregistrées pour retrouver un dossier propre, utilisez la commande moderne :

git restore .

Pour supprimer définitivement les fichiers qui ne sont pas suivis par Git (comme des fichiers temporaires générés par erreur) :

git clean -f

Conclusion

Vous maîtrisez maintenant les outils indispensables pour interagir avec votre serveur. Ces commandes Git vous permettent de garder votre travail organisé et de collaborer sans friction avec d'autres développeurs.

Cependant, pour envoyer votre code sur GitLab de manière sécurisée sans avoir à taper votre mot de passe à chaque fois, il existe une méthode beaucoup plus professionnelle : les clés SSH. C'est ce que nous allons configurer ensemble dans le chapitre suivant.