Comment configurer le jeton d'accès personnel Git

GitGitBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce tutoriel, nous vous guiderons tout au long du processus de configuration et de paramétrage des jetons d'accès personnels Git. Vous apprendrez à générer, sécuriser et gérer ces jetons, ainsi qu'à comprendre leur importance dans l'écosystème Git. À la fin de ce guide, vous aurez une bonne compréhension de l'utilisation efficace des jetons d'accès personnels pour des opérations Git sécurisées.

gh auth login

Ce Lab nécessite une connexion Internet pour l'apprentissage. Seuls les utilisateurs LabEx Pro peuvent démarrer la machine virtuelle. Passez à l'offre Pro.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL git(("Git")) -.-> git/SetupandConfigGroup(["Setup and Config"]) git(("Git")) -.-> git/GitHubIntegrationToolsGroup(["GitHub Integration Tools"]) git/SetupandConfigGroup -.-> git/config("Set Configurations") git/SetupandConfigGroup -.-> git/git("Show Version") git/GitHubIntegrationToolsGroup -.-> git/cli_config("Configure CLI") subgraph Lab Skills git/config -.-> lab-393036{{"Comment configurer le jeton d'accès personnel Git"}} git/git -.-> lab-393036{{"Comment configurer le jeton d'accès personnel Git"}} git/cli_config -.-> lab-393036{{"Comment configurer le jeton d'accès personnel Git"}} end

Comprendre les jetons d'accès personnels Git

Git est un système de contrôle de version distribué largement utilisé qui permet aux développeurs de collaborer sur des projets, de suivre les modifications et de gérer les dépôts de code. Un aspect essentiel de l'utilisation efficace de Git est l'authentification sécurisée lors de l'interaction avec les dépôts distants.

Qu'est-ce que les jetons d'accès personnels?

Les jetons d'accès personnels (Personal Access Tokens - PATs) sont des informations d'identification d'authentification qui vous permettent d'accéder en toute sécurité à vos dépôts Git sans utiliser votre nom d'utilisateur et votre mot de passe. Ils fonctionnent de manière similaire aux mots de passe, mais offrent plusieurs avantages :

  1. Sécurité renforcée : Les PATs peuvent être révoqués ou remplacés sans changer votre mot de passe principal de compte.
  2. Autorisations précises : Vous pouvez limiter les actions qu'un jeton peut effectuer en lui assignant des étendues (scopes) spécifiques.
  3. Prise en charge de l'automatisation : Les PATs permettent un accès programmatique pour les scripts, les pipelines CI/CD et d'autres outils.
  4. Compatibilité avec l'authentification multifacteur : Les PATs fonctionnent parfaitement avec les comptes pour lesquels l'authentification multifacteur (MFA) est activée.

Pourquoi utiliser des jetons d'accès personnels?

De nombreuses plateformes d'hébergement de dépôts Git, notamment GitHub, GitLab et Bitbucket, éliminent progressivement l'authentification basée sur le mot de passe pour les opérations Git. Cette transition est principalement motivée par des préoccupations de sécurité. Les jetons d'accès personnels offrent une alternative plus sécurisée qui réduit le risque associé aux informations d'identification à long terme et à accès large.

Lorsque vous utilisez un jeton d'accès personnel au lieu d'un mot de passe :

  • Vous pouvez limiter les capacités du jeton à ce qui est strictement nécessaire.
  • Vous pouvez créer plusieurs jetons pour différents usage.
  • Vous pouvez révoquer des jetons individuels sans affecter les autres.
  • Vous maintenez de meilleures traces d'audit de l'accès et de l'utilisation.

Dans les étapes suivantes, nous allons créer un jeton d'accès personnel et configurer Git pour l'utiliser pour l'authentification.

Générer un jeton d'accès personnel sur GitHub

Dans cette étape, nous allons générer un jeton d'accès personnel sur GitHub. Le processus est similaire sur d'autres plateformes Git telles que GitLab ou Bitbucket, avec de légères différences dans l'interface utilisateur.

Créer un jeton sur GitHub

Suivez ces étapes pour générer votre jeton d'accès personnel :

  1. Ouvrez un terminal et installez l'outil GitHub CLI, qui offre un moyen pratique d'interagir avec GitHub :

    sudo apt-get update
    sudo apt-get install -y gh
  2. Authentifiez-vous auprès de GitHub en exécutant la commande suivante :

    gh auth login
gh auth login

Suivez les invites interactives :

  • Sélectionnez "GitHub.com" lorsque vous êtes invité à choisir le compte.
  • Choisissez "HTTPS" comme protocole préféré.
  • Confirmez que vous souhaitez vous authentifier avec vos informations d'identification GitHub.
  • Choisissez "Se connecter avec un navigateur web" lorsque vous êtes invité à choisir la méthode d'authentification.

Un code à usage unique sera affiché. GitHub s'ouvrira dans votre navigateur, ou vous serez invité à visiter une URL et à entrer ce code.

  1. Après une authentification réussie, générez un nouveau jeton d'accès personnel :

    gh auth token

    Cette commande affichera votre jeton d'authentification actuel. Copiez ce jeton et enregistrez-le dans un endroit sûr, car nous en aurons besoin dans les étapes suivantes.

    Si vous préférez créer un jeton avec des étendues (scopes) spécifiques directement, vous pouvez utiliser :

    gh auth refresh -s repo,read:org
    gh auth token

    Cela crée un jeton avec accès en lecture aux dépôts et aux organisations.

  2. Alternativement, vous pouvez générer un jeton directement depuis le site web GitHub :

gh auth login
  • Accédez à GitHub à l'adresse https://github.com
  • Cliquez sur votre photo de profil en haut à droite
  • Sélectionnez "Paramètres"
  • Faites défiler la page vers le bas et cliquez sur "Paramètres pour les développeurs" dans la barre latérale gauche
  • Cliquez sur "Jetons d'accès personnels" puis sur "Jetons (classiques)"
  • Cliquez sur "Générer un nouveau jeton" et sélectionnez "Générer un nouveau jeton (classique)"
  • Donnez un nom descriptif à votre jeton, comme "Accès Git CLI"
  • Sélectionnez les étendues appropriées (au minimum, sélectionnez "repo" pour l'accès aux dépôts)
  • Cliquez sur "Générer le jeton"
  • Copiez le jeton généré et enregistrez-le en toute sécurité

N'oubliez pas de stocker votre jeton dans un endroit sûr, car GitHub ne l'affichera qu'une seule fois. Si vous le perdez, vous devrez en générer un nouveau.

Configurer Git pour utiliser votre jeton d'accès personnel

Maintenant que vous avez généré un jeton d'accès personnel, vous devez configurer Git pour l'utiliser pour l'authentification lors de l'interaction avec les dépôts distants. Il existe plusieurs méthodes pour y parvenir.

Méthode 1 : Utilisation de l'assistant d'authentification Git

L'assistant d'authentification Git permet à Git de mémoriser vos informations d'identification, de sorte que vous n'avez pas besoin de les saisir à chaque fois.

  1. Ouvrez un terminal et accédez au répertoire de votre projet :

    cd ~/project
  2. Configurez Git pour utiliser l'assistant d'authentification pour stocker vos informations d'identification :

    git config --global credential.helper store

    Note : Cela stockera vos informations d'identification en clair sur votre disque. Pour une option plus sécurisée, vous pouvez utiliser l'assistant de cache à la place, qui stocke temporairement les informations d'identification en mémoire :

    git config --global credential.helper 'cache --timeout=3600'

    Cela stockera vos informations d'identification en mémoire pendant 1 heure (3600 secondes).

  3. Créez un dépôt Git d'exemple pour tester votre configuration :

    mkdir -p ~/project/test-repo
    cd ~/project/test-repo
    git init
  4. Ajoutez un dépôt distant (vous devrez remplacer par votre nom d'utilisateur GitHub réel) :

    git remote add origin https://github.com/yourusername/test-repo.git
  5. La prochaine fois que Git nécessitera une authentification (par exemple, lors d'un push ou d'un pull), vous serez invité à saisir vos informations d'identification. Fournissez votre nom d'utilisateur GitHub et utilisez votre jeton d'accès personnel comme mot de passe.

Méthode 2 : Utilisation de l'authentification basée sur l'URL

Une autre approche consiste à intégrer directement votre jeton dans l'URL du dépôt :

  1. Dans le répertoire de votre projet, configurez l'URL du dépôt distant avec votre jeton :

    git remote set-url origin https://[email protected]/yourusername/test-repo.git

    Remplacez YOUR_TOKEN par votre jeton d'accès personnel réel et yourusername par votre nom d'utilisateur GitHub.

  2. Créez un fichier de test pour vérifier la configuration :

    echo "## Test Repository" > README.md
    git add README.md
    git commit -m "Initial commit"

Méthode 3 : Utilisation du fichier de configuration Git

Vous pouvez également modifier directement le fichier de configuration Git :

  1. Créez ou modifiez le fichier .git/config dans votre dépôt :

    nano ~/project/test-repo/.git/config
  2. Mettez à jour l'URL du dépôt distant origin pour inclure votre jeton :

    [remote "origin"]
        url = https://[email protected]/yourusername/test-repo.git
        fetch = +refs/heads/*:refs/remotes/origin/*

    Remplacez YOUR_TOKEN par votre jeton d'accès personnel réel et yourusername par votre nom d'utilisateur GitHub.

  3. Enregistrez le fichier en appuyant sur Ctrl+O, puis Entrée, et quittez avec Ctrl+X.

Pour des raisons de sécurité, la méthode de l'assistant d'authentification (Méthode 1) est généralement recommandée pour la plupart des utilisateurs, car elle évite de stocker votre jeton directement dans les fichiers de configuration.

Tester votre jeton d'accès personnel

Après avoir configuré Git pour utiliser votre jeton d'accès personnel, il est important de vérifier que l'authentification fonctionne correctement. Dans cette étape, nous allons tester le jeton en effectuant des opérations Git courantes.

Créer un dépôt de test sur GitHub

Tout d'abord, créons un dépôt de test sur GitHub en utilisant l'interface en ligne de commande GitHub (GitHub CLI) :

  1. Créez un nouveau dépôt sur GitHub :

    cd ~/project
    gh repo create test-pat-repo --private --clone
    cd test-pat-repo

    Cette commande crée un nouveau dépôt privé nommé "test-pat-repo" et le clone sur votre machine locale.

Tester les opérations Git de base

Maintenant, effectuons quelques opérations Git de base pour nous assurer que votre jeton d'accès personnel fonctionne correctement :

  1. Créez un fichier README simple :

    echo "## Test PAT Repository" > README.md
    echo "This repository is used to test Personal Access Token configuration." >> README.md
  2. Ajoutez et validez le fichier :

    git add README.md
    git commit -m "Add README file"
  3. Poussez les modifications sur GitHub :

    git push -u origin main

    Si votre jeton d'accès personnel est correctement configuré, la commande push devrait réussir sans vous demander de mot de passe. Si vous utilisez l'assistant d'authentification et que c'est votre première push, vous pourriez être invité à saisir votre nom d'utilisateur et votre jeton, qui seront ensuite stockés pour une utilisation future.

  4. Apportez une autre modification pour vérifier les informations d'identification stockées :

    echo "### Additional Information" >> README.md
    echo "This section contains additional information about the repository." >> README.md
    git add README.md
    git commit -m "Update README with additional information"
    git push

    Cette deuxième push devrait se dérouler sans aucune invite d'authentification, confirmant que votre jeton est utilisé correctement.

Vérifier l'accès au dépôt

Pour confirmer encore plus que votre jeton fonctionne correctement, vous pouvez lister vos dépôts :

gh repo list --limit 5

Cette commande devrait afficher une liste de vos dépôts GitHub, y compris le dépôt de test que nous venons de créer. Si cette commande s'exécute avec succès, cela confirme que votre jeton d'accès personnel a les autorisations correctes pour accéder aux dépôts.

Si vous rencontrez des problèmes lors de ces tests, vérifiez à nouveau la configuration de votre jeton et assurez-vous que le jeton a les étendues (autorisations) nécessaires pour les opérations que vous essayez d'effectuer.

Gérer et renouveler vos jetons d'accès personnels

Les jetons d'accès personnels doivent être traités avec le même soin que les mots de passe. Dans cette étape finale, nous allons discuter des meilleures pratiques pour gérer et renouveler vos jetons afin de maintenir la sécurité.

Lister vos jetons d'accès personnels

Pour afficher vos jetons d'accès personnels existants sur GitHub :

  1. En utilisant l'interface en ligne de commande GitHub (GitHub CLI) :

    gh auth status

    Cette commande affiche des informations sur votre statut d'authentification actuel, y compris le jeton utilisé.

  2. Alternativement, vous pouvez afficher tous vos jetons via l'interface web GitHub :

    • Accédez à GitHub.com et connectez-vous.
    • Cliquez sur votre photo de profil en haut à droite.
    • Sélectionnez "Paramètres".
    • Accédez à "Paramètres pour les développeurs" > "Jetons d'accès personnels" > "Jetons (classiques)".

Meilleures pratiques de sécurité des jetons

Pour maintenir la sécurité de vos jetons d'accès personnels, suivez ces meilleures pratiques :

  1. Limitez les étendues (scopes) des jetons : Accordez uniquement les autorisations minimales nécessaires à l'utilisation prévue du jeton.

  2. Utilisez des noms descriptifs : Donnez à vos jetons des noms significatifs qui indiquent leur but et leur utilisation.

  3. Définissez des dates d'expiration : Pour les jetons non critiques, définissez une date d'expiration pour forcer le renouvellement régulier.

    Pour créer un jeton avec une date d'expiration en utilisant l'interface en ligne de commande GitHub :

    gh auth refresh -s repo,read:org --expiry 30d
    gh auth token

    Cela crée un jeton qui expire dans 30 jours.

  4. Auditez régulièrement les jetons : Vérifiez périodiquement vos jetons et révoquez ceux qui ne sont plus nécessaires.

  5. Stockez les jetons en toute sécurité : Ne stockez jamais les jetons dans des dépôts publics, des fichiers non chiffrés ou partagez-les avec d'autres personnes.

  6. Utilisez des variables d'environnement : Lorsque vous utilisez des jetons dans des scripts ou des applications, stockez-les sous forme de variables d'environnement plutôt que de les coder en dur.

    Par exemple :

    export GITHUB_TOKEN=your_token_here

Révoquer un jeton d'accès personnel

Si vous suspectez qu'un jeton a été compromis ou qu'il n'est plus nécessaire, révoquez-le immédiatement :

  1. En utilisant l'interface en ligne de commande GitHub (remplacez TOKEN par votre jeton) :

    gh auth logout

    Cela vous déconnecte et invalide le jeton actuel.

  2. Via l'interface web GitHub :

    • Accédez à GitHub.com et connectez-vous.
    • Accédez à "Paramètres" > "Paramètres pour les développeurs" > "Jetons d'accès personnels" > "Jetons (classiques)".
    • Trouvez le jeton que vous souhaitez révoquer.
    • Cliquez sur "Supprimer" et confirmez l'action.

Renouveler vos jetons

Le renouvellement régulier des jetons est une bonne pratique de sécurité. Voici comment renouveler vos jetons :

  1. Générez un nouveau jeton avec les mêmes autorisations que l'ancien.
  2. Mettez à jour vos applications et configurations pour utiliser le nouveau jeton.
  3. Testez que tout fonctionne avec le nouveau jeton.
  4. Révoquez l'ancien jeton.

Pour les processus automatisés, envisagez d'utiliser des variables d'environnement ou des coffres-forts sécurisés pour stocker les jetons, ce qui facilitera le renouvellement.

## Generate a new token
gh auth refresh -s repo,read:org
NEW_TOKEN=$(gh auth token)

## Update your Git remote URL with the new token
git remote set-url origin https://${NEW_TOKEN}@github.com/yourusername/your-repo.git

## Verify it works
git fetch

## Revoke the old token through GitHub website
echo "Remember to revoke your old token in GitHub settings"

En suivant ces meilleures pratiques, vous pouvez maintenir un accès sécurisé à vos dépôts Git tout en minimisant le risque d'accès non autorisé.

Résumé

Dans ce tutoriel, vous avez appris à utiliser efficacement les jetons d'accès personnels Git. Voici un récapitulatif de ce que vous avez accompli :

  1. Compris l'importance et les avantages de l'utilisation de jetons d'accès personnels pour l'authentification Git
  2. Généré un jeton d'accès personnel sur GitHub en utilisant à la fois l'interface en ligne de commande (CLI) et l'interface web
  3. Configuré Git pour utiliser votre jeton d'accès personnel pour les opérations de dépôt
  4. Testé la configuration de votre jeton en effectuant des opérations Git de base
  5. Appris les meilleures pratiques pour gérer, sécuriser et renouveler vos jetons

En utilisant des jetons d'accès personnels au lieu de mots de passe, vous avez amélioré la sécurité de votre flux de travail Git. Vous pouvez maintenant créer des jetons avec des autorisations spécifiques, limiter leur durée de vie et les révoquer si nécessaire sans affecter les informations d'identification de votre compte principal.

N'oubliez pas ces points clés :

  • Utilisez toujours les autorisations minimales nécessaires pour vos jetons
  • Stockez les jetons en toute sécurité et ne les partagez jamais
  • Renouvelez régulièrement les jetons, surtout pour les dépôts sensibles
  • Révoquez immédiatement les jetons inutilisés ou compromis

En mettant en œuvre ces pratiques, vous pouvez maintenir un accès sécurisé à vos dépôts Git tout en minimisant les risques de sécurité.