Aller au contenu principal

Prise en main de Git · Chapitre 1 / 5

Installer Git et créer ton premier dépôt

Pas de théorie pour commencer : on installe Git, on le configure et on crée ton premier dépôt. Chaque commande est expliquée, pas à pas. Aucune connaissance préalable n'est nécessaire.

Chapitre 1 / 5

Étape 01 / 13

Dans ce chapitre

Bienvenue ! Ce premier chapitre est 100 % pratique : on installe Git, on le configure et on crée ton premier dépôt. Aucune connaissance préalable n'est nécessaire.

À la fin de ce chapitre, tu sauras :

  • Installer Git et vérifier qu'il fonctionne
  • Te présenter à Git avec ton nom et ton email
  • Expliquer ce qu'est un dépôt local et un dépôt distant
  • Créer un dépôt avec git init et le relier à GitHub
  • Récupérer un projet existant avec git clone
  • Écrire un README pour présenter ton projet

Astuce

Comment lire les encadrés sombres : le signe $ indique une commande à taper dans le terminal (ne tape pas le $). Les lignes qui commencent par # sont des commentaires, tu n'as pas à les taper. Le texte en dessous est la réponse de Git. Selon ton ordinateur, Git répond en anglais ou en français : dans ce cours, ses réponses sont en anglais.

Étape 02 / 13

Git, à quoi ça sert ?

Tu as sûrement déjà vu des fichiers comme rapport.docx, rapport-v2.docx, rapport-final.docx, rapport-final-VRAIMENT-final.docx. On garde des copies pour ne rien perdre, mais on s’y perd vite.

Git règle ce problème. C'est un logiciel de gestion de versions : il garde l'historique de toutes les versions de ton projet, dans un seul dossier, sans copies. Grâce à lui, tu peux :

  • Revenir en arrière : retrouver une version qui marchait avant une erreur.
  • Comprendre l'historique : savoir qui a changé quoi, quand et pourquoi.
  • Travailler à plusieurs : chacun avance de son côté, puis on rassemble le travail.
  • Tester sans risque : essayer une idée sans casser ce qui fonctionne déjà.

L'analogie

Imagine un photographe qui documente un chantier. À chaque étape importante, il prend une photo et la colle dans un cahier, avec la date et une légende. Git fait pareil avec ton projet : chaque version enregistrée est une photo complète, rangée dans l'ordre. On reprendra cette image tout au long du cours.

Attention

Git n'est pas GitHub. Git est le logiciel installé sur ton ordinateur. GitHub est un site web qui héberge des projets Git en ligne, pour les sauvegarder et les partager. Tu peux utiliser Git sans GitHub. GitLab et Bitbucket sont des alternatives à GitHub.

« Git et GitHub, c'est la même chose. » Vrai ou faux ?

Étape 03 / 13

Installer Git

Git s'utilise dans un terminal : une fenêtre où tu tapes des commandes au lieu de cliquer. Voici comment l'installer selon ton système.

  • Windows : télécharge l'installateur sur git-scm.com et garde les options par défaut. Il installe aussi Git Bash, le terminal que tu utiliseras pour ce cours.
  • macOS : ouvre l'app Terminal et tape git --version. Si Git n'est pas installé, macOS te propose de l'installer. Tu peux aussi utiliser Homebrew : brew install git.
  • Linux (Ubuntu, Debian) : ouvre un terminal et tape sudo apt install git.

Pour vérifier que l'installation a marché, tape cette commande. Elle affiche la version installée :

$ git --version

git version 2.47.1

Astuce

Le numéro de version peut être différent chez toi, ce n'est pas grave. Si tu vois « command not found », ferme le terminal, rouvre-le et réessaie. Sur Windows, vérifie que tu es bien dans Git Bash.

Quelle commande vérifie que Git est bien installé ?

Étape 04 / 13

Te présenter à Git

Chaque version que tu enregistres porte la signature de son auteur : un nom et un email. Avant de commencer, dis à Git qui tu es. Tu ne le fais qu'une seule fois sur ton ordinateur.

$ git config --global user.name "Camille Martin"

$ git config --global user.email "camille@example.com"

Remplace le nom et l’email par les tiens. L’option --global signifie « pour tous mes projets sur cet ordinateur ».

Profites-en pour choisir le nom de la branche principale de tes futurs projets. GitHub utilise main, faisons pareil :

$ git config --global init.defaultBranch main

Pour vérifier ta configuration, affiche-la :

$ git config --global --list

user.name=Camille Martin
user.email=camille@example.com
init.defaultbranch=main

À pratiquer

Utilise le même email que sur ton compte GitHub. Ainsi, GitHub reconnaît tes commits et les relie à ton profil.

Concept

Configuration locale : pour un projet précis (par exemple un projet pro avec un autre email), place-toi dans le dossier du projet et lance la même commande sans --global, par exemple git config user.email "camille@entreprise.com". Ce réglage ne vaut que pour ce projet et passe avant le réglage global.

Que signifie --global dans git config --global user.name ?

Étape 05 / 13

Un dépôt, c'est quoi ?

Concept

Dépôt (en anglais repository, ou repo) : un dossier de projet suivi par Git. Il contient tes fichiers et un dossier caché, .git, où Git range tout l’historique.

Il existe deux sortes de dépôts, et tu vas souvent utiliser les deux en même temps :

  • Le dépôt local : il est sur ton ordinateur. C'est là que tu travailles, même sans connexion internet.
  • Le dépôt distant (en anglais remote) : il est en ligne, sur GitHub par exemple. Il sert de sauvegarde et permet de partager ton travail.

Ta machine

ton historique local

Dépôt distant

GitHub, GitLab…

Tu travailles en local ; push envoie tes commits, fetch/pull rapatrie ceux des autres.

Tu travailles en local, puis tu envoies tes versions vers le dépôt distant. Tes collègues font pareil et récupèrent ton travail. On verra ces échanges au chapitre 3.

Attention

Ne supprime jamais le dossier .git. Il contient tout l'historique de ton projet : sans lui, ton dossier redevient un dossier ordinaire et l'historique est perdu.

Pour démarrer, deux situations sont possibles : ton projet n'a jamais été suivi par Git (tu crées le dépôt), ou il existe déjà sur GitHub (tu le récupères). Voyons les deux.

Dépôt local
— Sur ton ordinateur, là où tu travailles
Dépôt distant
— En ligne, pour sauvegarder et partager
Dossier .git
— Le dossier caché qui contient l'historique
GitHub
— Un site qui héberge des dépôts distants

Étape 06 / 13

Créer un dépôt : git init

Premier cas : tu as un dossier de projet sur ton ordinateur, et Git ne le suit pas encore. Place-toi dans ce dossier avec cd (change directory), puis lance git init :

$ cd mon-portfolio

$ git init

Initialized empty Git repository in /Users/camille/mon-portfolio/.git/

Git vient de créer le dossier caché .git : ton dossier est maintenant un dépôt. Pour le vérifier, affiche aussi les fichiers cachés :

$ ls -a

.  ..  .git  index.html  style.css

Et git status te confirme que le dépôt existe, mais qu'aucune version n'est encore enregistrée :

$ git status

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	index.html
	style.css

nothing added to commit but untracked files present (use "git add" to track)

À pratiquer

Lance git init une seule fois par projet, à la racine du dossier du projet. Jamais dans ton dossier personnel ou sur tout le Bureau : Git suivrait tous tes fichiers.

Où faut-il lancer git init ?

Étape 07 / 13

Relier ton dépôt à GitHub : git remote

Ton dépôt existe en local. Pour le sauvegarder en ligne, crée un dépôt vide sur GitHub :

1

Connecte-toi sur github.com (le compte est gratuit).

2

Clique sur le bouton « New » pour créer un nouveau dépôt.

3

Donne-lui le même nom que ton dossier, par exemple mon-portfolio.

4

Ne coche pas « Add a README file » : ton projet existe déjà en local.

5

Clique sur « Create repository » et copie l’adresse affichée (elle finit par .git).

Ensuite, dis à ton dépôt local où se trouve le dépôt distant :

$ git remote add origin https://github.com/camille-dev/mon-portfolio.git

origin est le surnom donné à l'adresse du dépôt distant. Tu pourrais choisir un autre nom, mais origin est la convention : tout le monde l'utilise. Pour vérifier :

$ git remote -v

origin  https://github.com/camille-dev/mon-portfolio.git (fetch)
origin  https://github.com/camille-dev/mon-portfolio.git (push)

Astuce

Pour l'instant, rien n'a été envoyé sur GitHub : tu as seulement enregistré l'adresse. L'envoi se fait avec git push, une fois que tu auras des versions enregistrées (chapitre 3).

Étape 08 / 13

Récupérer un projet existant : git clone

Deuxième cas : le projet existe déjà sur GitHub (le tien sur un autre ordinateur, celui d'un collègue, un projet open source). Tu le télécharges avec git clone :

$ git clone <adresse-du-depot>

Remplace <adresse-du-depot> par l'adresse copiée depuis le bouton vert « Code » de la page GitHub. Par exemple, avec le petit dépôt de démonstration de GitHub :

$ git clone https://github.com/octocat/Hello-World.git

Cloning into 'Hello-World'...
remote: Enumerating objects: 13, done.
remote: Total 13 (delta 0), reused 0 (delta 0), pack-reused 13
Receiving objects: 100% (13/13), done.

git clone fait trois choses d’un coup :

  • Il crée un dossier Hello-World avec tous les fichiers du projet.
  • Il télécharge tout l'historique : toutes les versions, depuis le début.
  • Il enregistre le dépôt distant sous le nom origin.

$ cd Hello-World

$ git remote -v

origin  https://github.com/octocat/Hello-World.git (fetch)
origin  https://github.com/octocat/Hello-World.git (push)

À pratiquer

Après un git clone, pas besoin de git init ni de git remote add : tout est déjà prêt. Pense juste à entrer dans le dossier avec cd.

« Après un git clone, il faut lancer git init. » Vrai ou faux ?

Étape 09 / 13

Le README : la notice du projet

Presque tous les projets ont un fichier README.md à la racine. C'est la notice du projet : la première chose qu'on lit en arrivant. GitHub l'affiche automatiquement sous la liste des fichiers.

Il est écrit en Markdown, un format texte très simple : # pour un titre, - pour une liste. Voici un README minimal :

# Contenu du fichier README.md

# Mon portfolio

Mon site personnel, fait en HTML et CSS.

## Voir le site

Ouvre le fichier index.html dans ton navigateur.

## Contenu

- index.html : la page d'accueil
- style.css : la mise en forme

Un bon README répond à trois questions :

  • À quoi sert ce projet ?
  • Comment l'installer ou le lancer ?
  • Comment l'utiliser ?

Astuce

Tu peux créer le fichier dans ton éditeur de code (VS Code par exemple). Il n'est pas encore enregistré dans l'historique : c'est ce qu'on apprend dans les deux prochains chapitres.

Étape 10 / 13

Récap : démarrer un projet

1

Installer Git et vérifier avec git --version

2

Te présenter avec git config --global user.name et user.email

3

Créer le dépôt avec git init (ou récupérer un projet avec git clone)

4

Relier le dépôt à GitHub avec git remote add origin <adresse>

5

Ajouter un README.md pour présenter le projet

Ton aide-mémoire du chapitre :

$ git --version # vérifier l'installation

$ git config --global user.name "Nom" # ton nom

$ git config --global user.email "email" # ton email

$ git init # créer un dépôt

$ git remote add origin <adresse> # relier un dépôt distant

$ git remote -v # voir les dépôts distants

$ git clone <adresse> # récupérer un projet existant

git --version
— Vérifier l'installation
git config --global
— Te présenter (nom, email)
git init
— Créer un dépôt
git remote add origin
— Relier un dépôt distant
git clone
— Récupérer un projet existant

Étape 11 / 13

Erreurs fréquentes

Ces messages font peur la première fois. Ils ont presque toujours une cause simple :

  • « fatal: not a git repository » : tu n'es pas dans le dossier d'un dépôt. Vérifie où tu es avec pwd, puis place-toi dans le bon dossier avec cd. Si le projet n'a jamais été initialisé, lance git init.
  • « Please tell me who you are » : Git ne connaît pas encore ton nom et ton email. Lance les deux commandes git config --global de ce chapitre.
  • « remote origin already exists » : une adresse origin est déjà enregistrée. Pour la remplacer : git remote set-url origin <nouvelle-adresse>.
  • git init lancé dans le mauvais dossier : supprime uniquement le dossier .git créé par erreur à cet endroit, puis relance git init dans le bon dossier.
  • Confondre Git et GitHub : Git est le logiciel sur ton ordinateur, GitHub est le site qui héberge tes dépôts en ligne.

Étape 12 / 13

Bonus : sous le capot

Astuce

Partie facultative, pour les curieux qui veulent savoir ce que contient le dossier .git. Tu peux passer directement au quiz.

Le dossier .git est un dossier comme un autre. Tu peux regarder ce qu’il contient :

$ ls .git

HEAD  config  description  hooks  info  objects  refs
  • objects : toutes les versions de tes fichiers, compressées. C'est le cœur de l'historique.
  • refs : les branches (on les verra au chapitre 4).
  • HEAD : indique la branche sur laquelle tu te trouves.
  • config : la configuration propre à ce dépôt, dont l'adresse du dépôt distant.

$ cat .git/config

[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
[remote "origin"]
	url = https://github.com/camille-dev/mon-portfolio.git
	fetch = +refs/heads/*:refs/remotes/origin/*

Tu retrouves l'adresse ajoutée avec git remote add. Les commandes Git ne font que lire et écrire dans ces fichiers : il n'y a pas de magie.

Attention

Regarde, mais ne modifie rien à la main dans .git : passe toujours par les commandes Git.

Étape 13 / 13

Teste tes connaissances

Avant de passer au chapitre suivant, vérifie que tu as retenu l'essentiel. Clique sur la réponse qui te semble correcte : chaque réponse est expliquée.

Quiz · Chapitre 1

1. Quelle est la différence entre Git et GitHub ?

2. Pourquoi configurer user.name et user.email ?

3. Tu as un dossier de projet que Git ne suit pas encore. Quelle commande en fait un dépôt ?

4. Que fait git clone <adresse> ?

5. Dans git remote add origin <adresse>, que représente origin ?

6. À quoi sert le fichier README.md ?

Chapitre 1 sur 5

L'enquête ne fait que commencer, la suite t'attend...

Ton avis compte

Aide-nous à améliorer cette formation en partageant ton retour.

Pour qu'on puisse te répondre si besoin.