Git Init : Comment initialiser et configurer un dépôt Git

Tutoriels
Git

Vous avez déjà supprimé un fichier par erreur ou écrasé votre code sans moyen de le récupérer ? Sans contrôle de version, de telles erreurs peuvent être catastrophiques. C’est là qu’intervient git init : il transforme votre dossier de projet en un dépôt Git, garantissant que chaque changement est traçable et récupérable.

Dans ce tutoriel, je vais vous montrer comment configurer Git, partager des astuces personnelles de mon parcours et vous aider à créer un flux de travail robuste dès le départ.

Qu’est-ce que Git Init ?

La commande git init lance votre parcours de contrôle de version. Lorsque vous l’exécutez, Git crée un dossier caché .git à l’intérieur de votre répertoire de projet qui stocke les données de configuration, l’historique des validations et toutes les métadonnées nécessaires pour suivre vos changements.

Avec chaque modification enregistrée, vous pouvez créer des branches, fusionner et collaborer en toute confiance, sachant que l’historique complet de votre projet n’est jamais qu’à une commande.

Image par l’auteur

Comment utiliser Git Init

Avant d’aborder des sujets avancés, il est essentiel de comprendre comment utiliser git init en pratique.

Utilisation de base de git init

Suivez ces étapes pour créer un nouveau dépôt Git à partir de zéro :  

  • Ouvrez votre terminal : Lancez votre interface en ligne de commande préférée.
  • Accédez à votre répertoire de projet :
cd /path/to/your/project

Cela change votre dossier actuel pour celui que vous souhaitez suivre.

  • Initialisez le dépôt : 
git init

Après avoir exécuté cette commande, un dossier caché .git est créé. Ce dossier stocke chaque information de suivi de Git.

  • Vérifiez l’état du dépôt :
git status

À ce stade, Git est configuré mais ne suit aucun fichier.

Initialisation d’un dépôt avec un projet existant

Pour les projets qui ne sont pas encore sous contrôle de version, vous pouvez initialiser Git et commencer à suivre les modifications comme suit:

  • Naviguez jusqu’au répertoire de votre projet:
cd /path/to/your/project
  • Convertissez le projet en un dépôt Git:
git init

Comme mentionné précédemment, la commande ci-dessus crée le dossier caché .git qui permet le suivi par Git.

  • Préparez vos fichiers:Étant donné que git init ne suit pas automatiquement les fichiers, ajoutez-les avec:
git add .
  • Validez vos fichiers: Enregistrez la capture initiale en exécutant: 
git commit -m "Initial commit"

Ce processus convertit un projet non géré en un projet avec un historique de versions complet, prêt pour le développement et la collaboration.

Configuration de Git (si nécessaire)

Si vous rencontrez l’erreur « Identité de l’auteur inconnue », cela signifie que Git ne sait pas qui vous êtes. Pour corriger cela, configurez votre identité utilisateur:

  • Configurez les informations utilisateur Git: 
git config --global user.email "[email protected]"
git config --global user.name "Your Name"

L’utilisation de --global applique ces paramètres à tous les dépôts de votre machine. L’omission le définira uniquement pour le dépôt actuel.

  • Vérifiez votre configuration: 
git config --global user.email
git config --global user.name
  • Réessayez la validation: 
git commit -m "First Commit"

J’ai rencontré cette erreur lorsque j’ai commencé à utiliser Git – définir mon identité l’a résolue.

Le premier commit Git s’est exécuté avec succès dans PowerShell.

Connexion à un dépôt distant

Une fois que vous avez initialisé un dépôt Git localement, vous voudrez probablement le sauvegarder ou collaborer avec d’autres en le connectant à un dépôt distant (par exemple, GitHub, GitLab, Bitbucket).

  • Ajouter un dépôt distant: Pour lier votre dépôt local à un dépôt distant, utilisez:
git remote add origin <repository-url>

Remplacez <repository-url> par l’URL de votre dépôt distant. origin est l’alias par défaut du dépôt distant, mais vous pouvez utiliser n’importe quel nom.

  • Vous pouvez vérifier la connexion avec:
git remote -v
  • Poussez vos modifications vers le dépôt distant:
# Poussez le premier commit et suivez la branche distante
git push -u origin $(git branch --show-current)  # Fonctionne pour 'main' ou 'master'

La commande ci-dessus pousse la branche actuelle et la configure pour suivre la branche distante.

Si vous utilisez une ancienne version de Git qui ne prend pas en charge $(git branch --show-current), utilisez :

git push -u origin main  # Ou 'master' en fonction de votre branche par défaut

En continuant à travailler sur votre projet, vous devrez fusionner les modifications de différentes branches lorsque vous collaborez avec une équipe. Apprenez à gérer les fusions efficacement avec ce tutoriel sur les fusions Git.

Authentification et accès

Si vous poussez vers GitHub, GitLab ou Bitbucket, vous pourriez avoir besoin de vous authentifier. Selon votre configuration, vous pouvez :

  • Utilisez clés SSH au lieu de l’authentification HTTPS (recommandé pour la sécurité) :
git remote set-url origin [email protected]:your-username/your-repo.git
  • Utilisez un Token d’Accès Personnel (PAT) au lieu d’un mot de passe lors de l’utilisation de HTTPS. Pour GitHub, remplacez le mot de passe par un jeton :
git push https://[email protected]/your-repo.git

Se connecter à un dépôt distant a été un tournant pour moi – cela a validé que mon travail local était en sécurité sauvegardé et prêt pour la collaboration. De plus, cela m’a donné confiance en la gestion de version, sachant que mon historique était préservé même si ma machine locale échouait.

Options avancées avec Git Init

Pour ceux qui souhaitent personnaliser leurs configurations Git, les options avancées offrent une flexibilité supplémentaire.

Initialisation d’un dépôt bare

Si vous configurez un serveur Git où les développeurs poussent leurs modifications mais n’éditent pas directement les fichiers, vous aurez besoin d’un dépôt bare. Un dépôt bare exclut un répertoire de travail et contient uniquement les données de contrôle de version. Il est généralement utilisé pour les dépôts distants :

git init --bare <repository-name>

Les dépôts bare sont souvent utilisés dans les flux de travail GitOps, où l’infrastructure et le déploiement d’applications sont gérés via Git. Si vous souhaitez apprendre comment GitOps automatise et rationalise la livraison de logiciels, consultez ce guide sur GitOps.

Initialisation avec une configuration spécifique

Si vous avez besoin de hooks Git personnalisés ou de fichiers de configuration dès le départ, initialisez avec un modèle personnalisé :

git init --template=<template-directory>

J’ai une fois utilisé un modèle personnalisé pour charger automatiquement des hooks essentiels, ce qui a rationalisé le processus de déploiement de notre équipe.

Meilleures pratiques pour utiliser Git Init

Commencer du bon pied avec Git peut vous faire gagner du temps et éviter des problèmes par la suite.

Organiser la structure de votre projet

Avant d’exécuter git init, organisez vos fichiers dans une structure de dossiers logique – séparez le code, la documentation et les ressources.

Dans un projet que j’ai hérité, des fichiers de plusieurs sous-projets étaient mélangés, entraînant des conflits de fusion et de la confusion. En réorganisant tout dans des dossiers clairement définis, en réinitialisant le dépôt et en configurant un .gitignore approprié, le flux de travail s’est nettement amélioré.

Ajouter un fichier .gitignore tôt

Juste après avoir initialisé votre dépôt, créez un fichier .gitignore pour éviter que des fichiers inutiles soient suivis :

touch .gitignore

Ensuite, éditez-le pour inclure des règles telles que :

# Ignorer les dossiers de dépendances et les fichiers journaux
node_modules/
*.log
.DS_Store  # Fichier système macOS
Thumbs.db  # Fichier système Windows

Cette étape m’a épargné des historiques de commit volumineux et des conflits potentiels à l’avenir.

Pour un guide détaillé sur la configuration d’un fichier .gitignore, consultez ce tutoriel sur le fichier gitignore.

Engagez fréquemment

Effectuer de petits commits fréquents avec des messages clairs aide à construire un historique de projet détaillé et simplifie le débogage et la collaboration.

Résolution des problèmes courants lors de l’initialisation de Git

Même avec une planification adéquate, des problèmes peuvent survenir. Voici quelques problèmes courants et leurs solutions.

Initialisation accidentelle dans le mauvais répertoire

Problème : Vous avez exécuté git init dans le mauvais dossier et vous vous retrouvez avec un dépôt Git non désiré.

Solution :

  • Supprimez le dépôt Git :
rm -rf .git

> Avertissement : Cela supprime tout l’historique des versions de ce dépôt. Assurez-vous d’être dans le bon dossier avant d’exécuter cette commande !

Ensuite, naviguez vers le bon répertoire et exécutez à nouveau git init.

J’ai fait cette erreur plusieurs fois, alors vérifiez deux fois votre répertoire de travail pour l’éviter.

Gestion des fichiers non suivis

Problème: Après avoir exécuté git init, Git ne suit pas vos fichiers. L’exécution de git status montre :

No commits yet  
Untracked files:
  (use "git add <file>..." to include in what will be committed)

Solution: 

  • Vérifiez si les fichiers ne sont vraiment pas suivis :
git status

Si vos fichiers apparaissent sous Fichiers non suivis, Git les voit mais ne les suit pas encore.

  • Ensuite, mettez en scène les fichiers nécessaires avec :
git add <file-name>
  • Validez les fichiers :
git commit -m "Initial commit"

Des vérifications régulières de l’état garantissent que rien d’important n’est négligé.

Si git status n’affiche aucun fichier, vérifiez si votre projet contient un fichier .gitignore qui pourrait exclure des fichiers importants.

Conclusion

Maîtriser git init est la première étape cruciale pour mettre en place un système de contrôle de version fiable qui favorise la collaboration et la gestion efficace de projet. Suivez ce guide—de l’initialisation et l’organisation de votre dépôt à la résolution des problèmes courants—pour établir un flux de travail fluide et efficace.

Commencez petit—initialisez un projet de test en utilisant git init et expérimentez avec la mise en scène, la validation et l’envoi des changements. Plus tôt vous maîtriserez les fondamentaux de Git, plus efficace sera votre flux de travail ! Et si vous êtes impatient d’approfondir vos compétences en Git, consultez ces cours DataCamp :

  • Git intermédiaire – Améliorez vos compétences avec des techniques avancées de branching, de fusion et de résolution de conflits.
  • Fondations de GitHub – Apprenez à intégrer Git avec GitHub de manière transparente pour des projets collaboratifs.

Bon codage – et voici pour la construction de projets fiables et innovants en utilisant Git !

Source:
https://www.datacamp.com/tutorial/git-init