git clone

Ce que fait git clone

La commande git clone copie un dépôt existant dans un nouveau répertoire sur votre machine. En une seule étape, elle :

• Crée le répertoire cible et initialise un nouveau dépôt local à l'intérieur (vous n'avez pas besoin d'exécuter git init au préalable).
• Télécharge l'intégralité de l'historique du projet — chaque commit, branche et tag.
• Ajoute le dépôt source comme remote nommé origin.
• Crée une branche de suivi à distance pour chaque branche du remote et extrait la branche par défaut (généralement main ou master) dans votre répertoire de travail.

C'est ainsi que presque tous les développeurs obtiennent une copie de travail d'un projet partagé, de sorte que git clone est généralement la toute première commande Git que vous exécutez sur un nouveau projet.

Utilisation de base

La forme générale de la commande prend une URL de dépôt et, optionnellement, un nom de répertoire :

git clone <repo> [<directory>]

Par exemple, cloner un projet via SSH depuis un serveur accessible à example.com en utilisant le nom d'utilisateur x_person :

git clone ssh://[email protected]/path/to/team-project.git
cd team-project
# Start editing files, committing snapshots, and pushing to the remote

Cela initialise un nouveau dépôt dans le dossier team-project et le remplit avec le contenu du dépôt central. Après le clonage, vous pouvez faire cd dans le projet et commencer à modifier des fichiers, à enregistrer des snapshots et à interagir avec le remote.

Cloner dans un dossier spécifique

Par défaut, Git nomme le nouveau répertoire d'après le dépôt. Pour cloner dans un dossier de votre choix, ajoutez un argument <directory> :

git clone https://example.com/team-project.git my-project
cd my-project

Cela clone le dépôt dans my-project au lieu de team-project.

Cloner une seule branche ou un tag

Passez --branch (abrégé : -b) avec un nom de branche ou un tag pour extraire autre chose que la branche par défaut du remote :

# Check out the develop branch instead of the default
git clone --branch develop https://example.com/team-project.git

# Check out the state at tag v1.0 (results in a detached HEAD)
git clone --branch v1.0 https://example.com/team-project.git

Lorsque vous passez un tag, l'arbre de travail est extrait à ce tag dans un état HEAD détachée, car un tag n'est pas une branche sur laquelle vous pouvez faire des commits.

Options de clonage utiles

Ces options vous permettent de personnaliser ce que git clone télécharge et comment le nouveau dépôt se comporte.

--depth (clone superficiel)

--depth <n> crée un clone superficiel qui ne conserve que les <n> derniers commits au lieu de l'intégralité de l'historique. C'est beaucoup plus rapide pour les grands dépôts et est courant dans les pipelines CI où l'historique complet n'est pas nécessaire.

git clone --depth 1 https://example.com/team-project.git

--single-branch

--single-branch télécharge l'historique d'une seule branche (la branche par défaut, ou celle nommée par --branch) au lieu de toutes les branches. Il est impliqué par --depth.

git clone --single-branch --branch main https://example.com/team-project.git

--recurse-submodules

Si le projet utilise des sous-modules, --recurse-submodules les clone et les extrait en une seule étape, afin que vous n'ayez pas à exécuter git submodule update --init par la suite.

git clone --recurse-submodules https://example.com/team-project.git

-o (renommer le remote)

Par défaut, la source est ajoutée comme remote origin. Utilisez -o <name> pour choisir un nom différent. Consultez git remote pour gérer les remotes par la suite.

git clone -o upstream https://example.com/team-project.git

--bare et --mirror

• --bare crée une copie du dépôt sans répertoire de travail. Le dépôt résultant contient l'historique du projet et peut recevoir des push ou des pull, mais il n'a pas de fichiers extraits à modifier. C'est le format utilisé pour les dépôts qui vivent sur un serveur.
• --mirror implique --bare mais va plus loin : il copie toutes les refs (branches, tags, notes, refs de suivi à distance) et configure le remote de sorte que le miroir reste un reflet exact de la source. Il est principalement utilisé pour déplacer ou sauvegarder un dépôt.

git clone --bare https://example.com/team-project.git
git clone --mirror https://example.com/team-project.git

Différence entre git init et git clone

git init et git clone sont souvent confondus. La distinction clé :

• git init crée un nouveau dépôt local vide — il n'y a pas de remote ni d'historique pour l'instant.
• git clone copie un dépôt distant existant sur votre machine, en apportant son historique complet et en configurant origin automatiquement.

git clone ne vous oblige pas à exécuter git init d'abord ; il initialise le dépôt local et configure les branches de suivi à distance pour vous.

URL Git

Git possède sa propre syntaxe URL pour indiquer aux commandes où se trouve un dépôt distant. Comme git clone cible presque toujours un remote, comprendre ces URL est important. Git prend en charge quatre familles de protocoles : Git, SSH, HTTPS et Local. Tous, à l'exception de HTTPS, nécessitent que Git soit installé et en cours d'exécution sur le serveur.

Protocole Git

Le protocole Git est propre à Git. Il est servi par un daemon qui écoute sur le port 9418 et offre un accès anonyme, principalement en lecture, similaire à SSH mais sans aucune authentification.

git clone git://host.xz/path/to/repo.git

Son avantage est un transfert rapide. Ses inconvénients sont l'absence d'authentification (il est donc rarement utilisé pour les écritures) et une configuration serveur plus complexe.

Protocole SSH

Secure Shell (SSH) est un protocole réseau permettant de se connecter d'un ordinateur à un autre de manière sécurisée. C'est le protocole le plus courant pour l'accès authentifié en lecture/écriture, et l'accès SSH est configuré par défaut sur la plupart des plateformes d'hébergement. Vous devez établir des identifiants (une clé SSH) avec le serveur avant de vous connecter.

git clone ssh://user@server/project.git

# Many hosts also accept the shorter "scp-like" form:
git clone user@server:project.git

SSH chiffre et authentifie tout le trafic, compresse les données avant le transfert et est facile à configurer. Sa principale limitation est qu'il ne prend pas en charge l'accès anonyme. Consultez notre section clé SSH pour la configuration des clés.

Protocole HTTPS

HTTPS (HyperText Transfer Protocol Secure) est le protocole utilisé pour transmettre des données de manière sécurisée sur le web, et Git peut partager des dépôts via ce protocole.

git clone https://example.com/gitproject.git

HTTPS est simple à configurer, chiffre le transfert et passe facilement les pare-feux d'entreprise (le port 443 est presque toujours ouvert), ce qui en fait l'un des protocoles les plus utilisés. Son principal inconvénient est une légère surcharge due au chiffrement, ce qui peut rendre le clonage légèrement plus lent que le protocole Git brut.

Protocole Local

Avec le protocole Local, le dépôt « distant » est simplement un autre répertoire sur le même disque ou un système de fichiers partagé. Lorsque les membres d'une équipe partagent un système de fichiers, ils peuvent cloner, pousser et tirer via des chemins simples.

git clone /opt/git/project.git

# Or with an explicit file:// URL:
git clone file:///opt/git/project.git

Commandes associées

Après le clonage, ces chapitres couvrent le flux de travail quotidien :

• git fetch et git pull — télécharger et intégrer les mises à jour depuis le remote.
• git branch et git checkout — créer et basculer entre les branches.
• git remote — afficher et gérer le remote origin configuré par git clone.

Entraînement