Utiliser des jetons d’accès personnels

Azure DevOps Services | Azure DevOps Server 2022 | Azure DevOps Server 2019

Un jeton d’accès personnel (PAT) sert de mot de passe alternatif pour l’authentification dans Azure DevOps. Ce PAT vous identifie et détermine votre accessibilité et votre étendue d’accès. Par conséquent, traitez les TP avec le même niveau de prudence que les mots de passe.

Lorsque vous utilisez des outils Microsoft, votre compte Microsoft (MSA) ou microsoft Entra ID est une méthode reconnue et prise en charge. Si vous utilisez des outils non-Microsoft qui ne prennent pas en charge les comptes Microsoft ou Microsoft Entra, ou si vous préférez ne pas partager vos informations d’identification principales avec ces outils, les PAT sont une alternative appropriée.

Cet article vous guide tout au long de la création, de l’utilisation, de la modification et de la révocation de paTs pour Azure DevOps.

Vous pouvez gérer les PAT à l’aide des méthodes suivantes :

• Interface utilisateur : via les paramètres utilisateur, comme indiqué dans cet article
• API de gestion du cycle de vie PAT

Pour établir des PAT pour les outils non-Microsoft, vous pouvez utiliser des gestionnaires d’informations d’identification Git ou les générer manuellement. Nous vous recommandons de consulter nos conseils d’authentification pour choisir le mécanisme d’authentification approprié. Les PAT offrent une alternative simple pour les projets plus petits qui ne nécessitent pas de solution étendue. Sans gestionnaire d’informations d’identification, les utilisateurs entrent leurs informations d’identification chaque fois.

Prérequis

• Autorisations :
  • Disposez d’une autorisation d’accès et de modification de vos paramètres utilisateur dans lesquels les PAT sont gérés.
    • Vérifier les autorisations : Pour vérifier vos autorisations, effectuez l’un des processus suivants dans Azure DevOps :
      • Accédez à votre profil et sélectionnez Jetons d’accès personnels des paramètres>utilisateur. Si vous pouvez voir et gérer vos PAT ici, vous disposez des autorisations nécessaires.
      • Accédez à votre projet et sélectionnez Autorisations des paramètres>du projet. Recherchez votre compte d’utilisateur dans la liste et vérifiez les autorisations qui vous sont attribuées. Recherchez les autorisations relatives à la gestion des jetons ou des paramètres utilisateur.
  • Si votre organisation a des stratégies en place, un administrateur Azure DevOps peut avoir besoin d’accorder des autorisations spécifiques ou de vous ajouter à une liste d’autorisation pour créer et gérer des PAT.
  • Selon les tâches que vous souhaitez effectuer avec le PAT, vous devrez peut-être disposer d’autorisations supplémentaires. Par exemple :
    • Build : Lecture & exécution
    • Code : lecture, écriture, &gestion
    • Environnement : Lecture et gestion
    • Projet et équipe : Lecture, écriture et gestion
    • Groupes de variables : Lecture et création
• Niveaux d’accès : disposez au moins d’un accès de base.
• Bonnes pratiques en matière de sécurité : Familiarisez-vous avec les meilleures pratiques de sécurité pour la gestion des PAT, telles que l’utilisation de celles-ci uniquement lorsque cela est nécessaire et effectuez régulièrement une rotation.

Créer un PAT

1. Connectez-vous à votre organisation (https://dev.azure.com/{Your_Organization}).

2. À partir de votre page d’accueil, ouvrez les paramètres utilisateur et sélectionnez Jetons d’accès personnels.

   

3. Sélectionnez + Nouveau jeton.

   

4. Nommez votre jeton, sélectionnez l’organisation dans laquelle vous souhaitez utiliser le jeton, puis définissez votre jeton pour expirer automatiquement après un nombre défini de jours.

   

5. Sélectionnez les étendues de ce jeton pour autoriser vos tâches spécifiques.

   Par exemple, pour créer un jeton pour un agent de génération et de mise en production pour s’authentifier auprès d’Azure DevOps, définissez l’étendue du jeton sur les pools d’agents (lecture et gestion). Pour lire les événements du journal d’audit et gérer ou supprimer des flux, sélectionnez Lire le journal d’audit, puis sélectionnez Créer.

   

   Remarque

   Vous pouvez être limité à la création de paTs à étendue complète. Dans ce cas, votre administrateur Azure DevOps dans Microsoft Entra ID a activé une stratégie qui vous limite à un ensemble d’étendues personnalisé spécifique. Pour plus d’informations, consultez Gérer les PAT avec des stratégies/Restreindre la création de paTs à étendue complète. Pour un PAT défini sur mesure, l’étendue requise pour accéder à l’API Gouvernance des composants n’est vso.governancepas sélectionnable dans l’interface utilisateur.

6. Lorsque vous avez terminé, copiez le jeton et stockez-le dans un emplacement sécurisé. Pour votre sécurité, elle ne s’affiche pas à nouveau.

   

Utilisez votre PAT partout où vos informations d’identification utilisateur sont requises pour l’authentification dans Azure DevOps.

Notifications

Pendant la durée de vie d’un PAT, les utilisateurs reçoivent deux notifications : la première au moment de la création et les sept jours avant son expiration.

Après avoir créé un PAT, vous recevez une notification similaire à l’exemple suivant. Cette notification sert de confirmation que votre PAT a été correctement ajouté à votre organisation.

L’image suivante montre un exemple de notification de sept jours avant l’expiration de votre PAT.

Notification inattendue

Si vous recevez une notification PAT inattendue, cela peut signifier qu’un administrateur ou un outil a créé un PAT pour vous. Voici quelques exemples.

• Un jeton nommé « git : https://dev.azure.com/{Your_Organization} sur YourMachine » est créé lorsque vous vous connectez à un dépôt Git Azure DevOps via git.exe.
• Un jeton nommé « Service Hooks : Azure App Service : : Déployer une application web » est créé lorsque vous ou un administrateur configurez un déploiement d’application web Azure App Service.
• Un jeton nommé « WebAppLoadTestCDIntToken » est créé lorsque le test de charge web est configuré dans le cadre d’un pipeline par vous ou un administrateur.
• Un jeton nommé « Intégration Microsoft Teams » est créé lorsqu’une extension de messagerie d’intégration Microsoft Teams est configurée.

Utiliser un pat

Votre PAT sert d’identité numérique, comme un mot de passe.

Git

Les interactions Git nécessitent un nom d’utilisateur, qui peut être tout sauf une chaîne vide. Pour utiliser un protocole PAT avec l’authentification de base HTTP, vous $MyPat devez l’afficher Base64-encode dans le bloc de code suivant.

$MyPat = 'yourPat'
$headerValue = "Authorization: Basic " + [Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes(":" + $MyPat))
$env:GIT_AUTH_HEADER = $headerValue

git --config-env=http.extraheader=GIT_AUTH_HEADER clone https://dev.azure.com/yourOrgName/yourProjectName/_git/yourRepoName

MY_PAT=yourPAT # replace "yourPAT" with "PatStringFromWebUI"
export HEADER_VALUE=$(echo -n "Authorization: Basic "$(printf ":%s" "$MY_PAT" | base64))

git --config-env=http.extraheader=HEADER_VALUE clone https://dev.azure.com/yourOrgName/yourProjectName/_git/yourRepoName

Référentiels existants

• Supprimer l’origine existante : si vous avez précédemment ajouté l’origine à l’aide d’un nom d’utilisateur, supprimez-la en exécutant la commande suivante :

  git remote remove origin

• S’authentifier auprès d’un pater : si vous rencontrez des problèmes d’authentification standard, exécutez la commande suivante pour vous authentifier via la ligne de commande :

  git remote add origin https://dev.azure.com/<PAT>@<company_machineName>:/<project-name>/_git/<repo_name>

  git push -u origin --all

  Il path to git repo = /_git/do fait référence à la structure de chemin d’URL utilisée dans azure DevOps pour les dépôts Git. Le /_git/ segment indique que vous accédez à un référentiel Git et que vous devez remplacer do par le nom réel de votre référentiel. Par exemple, si votre référentiel est nommé my-repo, le chemin d’accès est «/_git/my-repo ».

• Cloner le référentiel : si vous utilisez Git et que vous devez vous authentifier, exécutez la commande suivante :

  git clone https://{organization}@dev.azure.com/{organization}/_git/{repository}

  Remplacez {organization} par le nom de votre organisation Azure DevOps et {repository} par le nom de votre référentiel.

Utiliser un pater dans votre code

Vous pouvez utiliser un PAT dans votre code pour authentifier les demandes d’API et automatiser les flux de travail. Pour ce faire, incluez le PAT dans l’en-tête d’autorisation de vos requêtes HTTP.

Authorization: Basic BASE64_USERNAME_PAT_STRING

public static async void GetBuilds()
{
    try
    {
        var personalaccesstoken = "PATFROMWEB";

        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Accept.Add(
                new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
                Convert.ToBase64String(
                    System.Text.ASCIIEncoding.ASCII.GetBytes(
                        string.Format("{0}:{1}", "", personalaccesstoken))));

            using (HttpResponseMessage response = client.GetAsync(
                        "https://dev.azure.com/{organization}/{project}/_apis/build/builds?api-version=5.0").Result)
            {
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                Console.WriteLine(responseBody);
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }
}

public static async void GetBuilds()
{
   try
  {
      var personalaccesstoken = "PATFROMWEB";

      using (HttpClient client = new HttpClient())
       {
           client.DefaultRequestHeaders.Accept.Add(
              new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));

           client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
               Convert.ToBase64String(
                   System.Text.ASCIIEncoding.ASCII.GetBytes(
                       string.Format("{0}:{1}", "", personalaccesstoken))));

          using (HttpResponseMessage response = client.GetAsync(
                       $"https://dev.azure.com/{organization}/{project}/_apis/build/builds?api-version=5.0").Result)
           {
               response.EnsureSuccessStatusCode();
               string responseBody = await response.Content.ReadAsStringAsync();
               Console.WriteLine(responseBody);
           }
       }
   }
   catch (Exception ex)
   {
       Console.WriteLine(ex.ToString());
   }
}

curl -u :{PAT} https://dev.azure.com/{organization}/_apis/build-release/builds

Lorsque votre code fonctionne, il est judicieux de passer de l’authentification de base à OAuth.

Pour plus d’informations et des exemples d’utilisation des PAT, consultez les articles suivants :

• Configurer des gestionnaires d’informations d’identification Git
• Accéder aux API REST
• Utiliser NuGet sur un Mac
• Authentifier les clients de création de rapports
• Prise en main d’Azure DevOps CLI

Modifications apportées au format

À compter de juillet 2024, nous avons considérablement modifié le format des PAT émis par Azure DevOps. Ces modifications offrent davantage d’avantages en matière de sécurité et améliorent les outils de détection des secrets disponibles via nos offres partenaires, telles que GitHub Advanced Security pour Azure DevOps. Ce nouveau format PAT suit le format recommandé pour tous les produits Microsoft. L’inclusion de bits plus identifiables améliore le taux de détection faux positifs de ces outils de détection secrète et nous permet d’atténuer les fuites détectées plus rapidement.

Modifications clés :

• Longueur accrue du jeton : les nouveaux jetons sont désormais de 84 caractères, avec 52 caractères étant des données aléatoires. Cette longueur accrue améliore l’entropie globale, ce qui rend les jetons plus résistants aux attaques potentielles par force brute.
• Signature fixe : Les jetons émis par notre service incluent une signature fixe AZDO aux positions 76-80.

Action nécessaire :

• Régénérer les PAT existants : nous vous recommandons vivement de régénérer tous les PAT actuellement utilisés pour tirer parti de ces améliorations de sécurité.
• Prise en charge de l’intégrateur : les intégrateurs doivent mettre à jour leurs systèmes pour prendre en charge les longueurs de jeton nouvelles et existantes.

Articles connexes

• En savoir plus sur la sécurité, l’authentification et l’autorisation
• Passer en revue les autorisations et l’accès par défaut pour Azure DevOps
• Révoquer des PAT utilisateur (pour les administrateurs)
• Gérer les principaux de service et les identités managées dans Azure DevOps