Använda personliga åtkomsttoken

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

En personlig åtkomsttoken (PAT) fungerar som ett alternativt lösenord för autentisering i Azure DevOps. Denna PAT identifierar dig och bestämmer din tillgänglighet och åtkomstomfattning. Behandla därför PAT med samma försiktighetsnivå som lösenord.

När du använder Microsoft-verktyg är ditt Microsoft-konto (MSA) eller Microsoft Entra-ID en identifierad metod som stöds. Om du använder icke-Microsoft-verktyg som inte stöder Microsoft- eller Microsoft Entra-konton, eller om du föredrar att inte dela dina primära autentiseringsuppgifter med dessa verktyg, är PAT ett lämpligt alternativ.

Den här artikeln vägleder dig genom att skapa, använda, ändra och återkalla PAT:er för Azure DevOps.

Du kan hantera PAT:er med hjälp av följande metoder:

• Användargränssnitt (användargränssnitt): Via användarinställningar, enligt beskrivningen i den här artikeln
• API för LIVSCYKELHANTERING FÖR PAT

Om du vill upprätta PAT:er för verktyg som inte kommer från Microsoft kan du använda Git-autentiseringsuppgifter eller generera dem manuellt. Vi rekommenderar att du går igenom vår autentiseringsvägledning för att välja lämplig autentiseringsmekanism. PAT är ett enkelt alternativ för mindre projekt som inte kräver någon omfattande lösning. Utan en autentiseringshanterare anger användarna sina autentiseringsuppgifter varje gång.

Förutsättningar

• Behörigheter:
  • Ha behörighet att komma åt och ändra användarinställningarna där PAT hanteras.
    • Kontrollera behörigheter: Kontrollera dina behörigheter genom att utföra någon av följande processer i Azure DevOps:
      • Gå till din profil och välj Användarinställningar>Personliga åtkomsttoken. Om du kan se och hantera dina PAT:er här har du de behörigheter som krävs.
      • Gå till projektet och välj Projektinställningar>Behörigheter. Leta upp ditt användarkonto i listan och kontrollera de behörigheter som tilldelats dig. Leta efter behörigheter som rör hantering av token eller användarinställningar.
  • Om din organisation har principer på plats kan en Azure DevOps-administratör behöva ge dig specifika behörigheter eller lägga till dig i en lista över tillåtna för att skapa och hantera PATs.
  • Beroende på vilka uppgifter du vill utföra med PAT kan du behöva ytterligare behörigheter. Till exempel:
    • Build: Läs &kör
    • Kod: Läsa, skriva och hantera
    • Miljö: Läsa och hantera
    • Projekt och team: Läsa, skriva, &hantera
    • Variabelgrupper: Läsa och skapa
• Åtkomstnivåer: Ha minst grundläggande åtkomst.
• Metodtips för säkerhet: Bekanta dig med metodtips för säkerhet för att hantera PAT:er, till exempel att endast använda dem när det behövs och rotera dem regelbundet.

Skapa en PAT

1. Logga in på organisationen (https://dev.azure.com/{Your_Organization}).

2. På startsidan öppnar du användarinställningar och väljer Personliga åtkomsttoken.

   

3. Välj + Ny token.

   

4. Namnge din token, välj den organisation där du vill använda token och ställ sedan in din token så att den upphör att gälla automatiskt efter ett angivet antal dagar.

   

5. Välj omfången för den här token för att auktorisera för dina specifika uppgifter.

   Om du till exempel vill skapa en token för en versions- och versionsagent för att autentisera till Azure DevOps anger du tokens omfång till Agentpooler (Läs och hantera). Om du vill läsa granskningslogghändelser och hantera eller ta bort strömmar väljer du Läs granskningslogg och sedan Skapa.

   

   Kommentar

   Du kan vara begränsad från att skapa fullständiga begränsade PAT:er. I så fall har Azure DevOps-administratören i Microsoft Entra-ID aktiverat en princip som begränsar dig till en specifik anpassad uppsättning omfång. Mer information finns i Hantera PAT med principer/Begränsa skapandet av fullständiga begränsade PAT:er. För en egendefinierad PAT kan det nödvändiga omfånget för åtkomst till API vso.governance:et för komponentstyrning inte väljas i användargränssnittet.

6. När du är klar kopierar du token och lagrar den på en säker plats. För din säkerhet visas den inte igen.

   

Använd din PAT var som helst där dina autentiseringsuppgifter krävs för autentisering i Azure DevOps.

Meddelanden

Under livslängden för en PAT får användarna två meddelanden: den första vid tidpunkten för skapandet och den andra sju dagarna innan den upphör att gälla.

När du har skapat en PAT får du ett meddelande som liknar följande exempel. Det här meddelandet fungerar som en bekräftelse på att din PAT har lagts till i din organisation.

Följande bild visar ett exempel på sjudagarsmeddelandet innan din PAT upphör att gälla.

Oväntat meddelande

Om du får ett oväntat PAT-meddelande kan det innebära att en administratör eller ett verktyg har skapat en PAT åt dig. Här följer några exempel.

• En token med namnet "git: https://dev.azure.com/{Your_Organization} on YourMachine" skapas när du ansluter till en Azure DevOps Git-lagringsplats via git.exe.
• En token med namnet "Service Hooks: : Azure App Service: : Deploy web app" skapas när du eller en administratör konfigurerar en azure App Service-webbappdistribution.
• En token med namnet "WebAppLoadTestCDIntToken" skapas när webbbelastningstestning konfigureras som en del av en pipeline av dig eller en administratör.
• En token med namnet "Microsoft Teams-integrering" skapas när ett Microsoft Teams Integration Messaging-tillägg har konfigurerats.

Använda en PAT

Din PAT fungerar som din digitala identitet, ungefär som ett lösenord.

Git

Git-interaktioner kräver ett användarnamn, vilket kan vara allt annat än en tom sträng. Om du vill använda en PAT med grundläggande HTTP-autentisering, Base64-encode $MyPat så som visas i följande kodblock.

$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

Befintliga lagringsplatser

• Ta bort befintligt ursprung: Om du tidigare har lagt till ursprunget med ett användarnamn tar du bort det genom att köra följande kommando:

  git remote remove origin

• Autentisera med en PAT: Om du stöter på problem med standardautentisering kör du följande kommando för att autentisera via kommandoraden:

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

  git push -u origin --all

  Refererar path to git repo = /_git/do till url-sökvägsstrukturen som används i Azure DevOps för Git-lagringsplatser. Segmentet /_git/ anger att du har åtkomst till en Git-lagringsplats och att du bör ersätta do med det faktiska namnet på lagringsplatsen. Om lagringsplatsen till exempel heter my-repoär sökvägen "/_git/my-repo".

• Klona lagringsplats: Om du använder Git och behöver autentisera kör du följande kommando:

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

  Ersätt {organization} med ditt Azure DevOps-organisationsnamn och {repository} med namnet på din lagringsplats.

Använda en PAT i koden

Du kan använda en PAT i koden för att autentisera API-begäranden och automatisera arbetsflöden. Det gör du genom att inkludera PAT i auktoriseringshuvudet för dina HTTP-begäranden.

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

När koden fungerar är det dags att växla från grundläggande autentisering till OAuth.

Mer information och exempel på hur du använder PAT finns i följande artiklar:

• Konfigurera Git-autentiseringshanterare
• Åtkomst till REST-API:er
• Använda NuGet på en Mac
• Autentisera rapportklienter
• Kom igång med Azure DevOps CLI

Ändringar i format

Från och med juli 2024 ändrade vi avsevärt formatet för PAT:er som utfärdats av Azure DevOps. Dessa ändringar ger fler säkerhetsfördelar och förbättrar verktygen för identifiering av hemligheter som är tillgängliga via våra partnererbjudanden, till exempel GitHub Advanced Security för Azure DevOps. Det här nya PAT-formatet följer det rekommenderade formatet för alla Microsoft-produkter. Införandet av mer identifierbara bitar förbättrar den falska positiva identifieringshastigheten för dessa verktyg för identifiering av hemligheter och gör det möjligt för oss att minska identifierade läckor snabbare.

Viktiga ändringar:

• Ökad tokenlängd: De nya token är nu 84 tecken långa, med 52 tecken som randomiserade data. Den här ökade längden förbättrar den övergripande entropi, vilket gör token mer resistenta mot potentiella brute force-attacker.
• Fast signatur: Token som utfärdats av vår tjänst innehåller en fast AZDO signatur på positioner 76-80.

Åtgärd krävs:

• Återskapa befintliga PAT:er: Vi rekommenderar starkt att du återskapar alla PAT:er som för närvarande används för att dra nytta av dessa säkerhetsförbättringar.
• Integratorstöd: Integratorer bör uppdatera sina system så att de passar både nya och befintliga tokenlängder.

Relaterade artiklar

• Lär dig mer om säkerhet, autentisering och auktorisering
• Granska standardbehörigheter och åtkomst för Azure DevOps
• Återkalla användar-PAT (för administratörer)
• Hantera tjänstens huvudnamn och hanterade identiteter i Azure DevOps