Autentisera Go-appar som är värdade på Azure med Azure-resurser med hjälp av en systemtilldelad hanterad identitet

Den rekommenderade metoden för att autentisera en Azure-värdbaserad app till andra Azure-resurser är att använda en hanterad identitet. Den här metoden stöds för de flesta Azure-tjänster, inklusive appar som finns i Azure App Service, Azure Container Apps och Azure Virtual Machines. Upptäck mer om olika autentiseringstekniker och autentiseringsmetoder på översiktssidan för autentisering . I de kommande avsnitten får du lära dig:

• Grundläggande begrepp för hanterad identitet
• Så här skapar du en systemtilldelad hanterad identitet för din app
• Tilldela roller till den systemtilldelade hanterade identiteten
• Autentisera med hjälp av den systemtilldelade hanterade identiteten från din appkod

Grundläggande begrepp för hanterad identitet

Med en hanterad identitet kan din app på ett säkert sätt ansluta till andra Azure-resurser utan att använda hemliga nycklar eller andra programhemligheter. Internt spårar Azure identiteten och vilka resurser den tillåts ansluta till. Azure använder den här informationen för att automatiskt hämta Microsoft Entra-token för appen så att den kan ansluta till andra Azure-resurser.

Det finns två typer av hanterade identiteter att tänka på när du konfigurerar din värdbaserade app:

• Systemtilldelade hanterade identiteter aktiveras direkt på en Azure-resurs och är knutna till dess livscykel. När resursen tas bort tar Azure automatiskt bort identiteten åt dig. Systemtilldelade identiteter ger en minimalistisk metod för att använda hanterade identiteter.
• Användartilldelade hanterade identiteter skapas som fristående Azure-resurser och ger större flexibilitet och funktioner. De är idealiska för lösningar som omfattar flera Azure-resurser som behöver dela samma identitet och behörigheter. Om till exempel flera virtuella datorer behöver komma åt samma uppsättning Azure-resurser, ger en användartilldelad hanterad identitet återanvändning och optimerad hantering.

I följande avsnitt beskrivs stegen för att aktivera och använda en systemtilldelad hanterad identitet för en Azure-värdbaserad app. Om du behöver använda en användartilldelad hanterad identitet går du till artikeln användartilldelade hanterade identiteter för mer information.

Aktivera en systemtilldelad hanterad identitet på Azure-värdresursen

För att komma igång med en systemtilldelad hanterad identitet med din app aktiverar du identiteten på den Azure-resurs som är värd för din app, till exempel en Azure App Service, Azure Container App eller Azure Virtual Machine.

Du kan aktivera en systemtilldelad hanterad identitet för en Azure-resurs med hjälp av antingen Azure-portalen eller Azure CLI.

az webapp identity assign \
    --resource-group <resource-group-name> \
    --name <web-app-name>

az vm identity assign \
    --resource-group <resource-group-name> \
    --name <virtual-machine-name>

{
  "principalId": "aaaaaaaa-bbbb-cccc-1111-222222222222",
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "SystemAssigned",
  "userAssignedIdentities": null
}

Tilldela roller till den hanterade identiteten

Bestäm sedan vilka roller din app behöver och tilldela dessa roller till den hanterade identiteten. Du kan tilldela roller till en hanterad identitet i följande omfång:

• Resurs: De tilldelade rollerna gäller endast för den specifika resursen.
• Resursgrupp: De tilldelade rollerna gäller för alla resurser i resursgruppen.
• Prenumeration: De tilldelade rollerna gäller för alla resurser som ingår i prenumerationen.

I följande exempel visas hur du tilldelar roller i resursgruppens omfång, eftersom många appar hanterar alla sina relaterade Azure-resurser med hjälp av en enda resursgrupp.

az role assignment create \
    --assignee "{managedIdentityId}" \
    --role "{roleName}" \
    --scope "{scope}"

az role definition list \
    --query "sort_by([].{roleName:roleName, description:description}, &roleName)" \
    --output table

az role assignment create \
    --assignee aaaaaaaa-bbbb-cccc-1111-222222222222 \
    --role "Storage Blob Data Contributor" \
    --scope "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/msdocs-sdk-auth-example"

Autentisera till Azure-tjänster från din app

Azidentity-modulen innehåller olika autentiseringsuppgifter – implementeringar av TokenCredential anpassade för att stödja olika scenarier och Microsoft Entra-autentiseringsflöden. Eftersom den hanterade identiteten inte är tillgänglig när den körs lokalt visar stegen framåt vilka autentiseringsuppgifter som ska användas i vilket scenario:

• Lokal utvecklingsmiljö: Använd endast StandardAzureCredential för en åsiktsbaserad, förkonfigurerad kedja med autentiseringsuppgifter under den lokala utvecklingen. DefaultAzureCredential identifierar användarautentiseringsuppgifter från dina lokala utvecklingsverktyg, till exempel Azure CLI. Det ger också flexibilitet och bekvämlighet för återförsök, väntetider för svar och stöd för flera autentiseringsalternativ. Mer information finns i artikeln Autentisera till Azure-tjänster under lokal utveckling .
• Azure-värdbaserade appar: När din app körs i Azure använder du ManagedIdentityCredential för att på ett säkert sätt identifiera den hanterade identitet som konfigurerats för din app. Om du anger den här exakta typen av autentiseringsuppgifter förhindrar du att andra tillgängliga autentiseringsuppgifter oväntat hämtas.

Implementera koden

Lägg till azidentity-modulen .

I valfri terminal går du till programprojektkatalogen och kör följande kommandon:

go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

Azure-tjänster används med hjälp av specialiserade klienter från de olika Azure SDK-klientbiblioteken. För alla Go-kod som instansierar en Azure SDK-klient i din app måste du:

1. Importera azidentity-paketet.
2. Skapa en instans av DefaultAzureCredential typen.
3. Skicka instansen av DefaultAzureCredential typen till Azure SDK-klientkonstruktorn.

Ett exempel på dessa steg visas i följande kodsegment med en Azure Storage Blob-klient.

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

const (
	account       = "https://<replace_with_your_storage_account_name>.blob.core.windows.net/"
	containerName = "sample-container"
	blobName      = "sample-blob"
	sampleFile    = "path/to/sample/file"
)

func main() {
	// create a credential
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
	  // TODO: handle error
	}

	// create a client for the specified storage account
	client, err := azblob.NewClient(account, cred, nil)
	if err != nil {
	  // TODO: handle error
	}

	// TODO: perform some action with the azblob Client
	// _, err = client.DownloadFile(context.TODO(), <containerName>, <blobName>, <target_file>, <DownloadFileOptions>)
}

Som beskrivs i översiktsartikeln för Azure SDK för Go-autentisering stöder DefaultAzureCredential flera autentiseringsmetoder och avgör vilken metod som används vid körning. Fördelen med den här metoden är att din app kan använda olika autentiseringsmetoder i olika miljöer utan att implementera miljöspecifik kod. När föregående kod körs på din arbetsstation under lokal utveckling DefaultAzureCredential använder antingen ett huvudnamn för programtjänsten, baserat på miljöinställningar, eller autentiseringsuppgifter för utvecklarverktyget för att autentisera med andra Azure-resurser. Därför kan samma kod användas för att autentisera din app till Azure-resurser både under lokal utveckling och när den distribueras till Azure.

Ett alternativ till DefaultAzureCredential är att använda ManagedIdentityCredential. Stegen för att använda ManagedIdentityCredential är desamma som för att använda typen DefaultAzureCredential .

Ett exempel på dessa steg visas i följande kodsegment med en Azure Storage Blob-klient.

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob"
)

const (
                    // Replace placeholder text with your storage account name
	account       = "https://<replace_with_your_storage_account_name>.blob.core.windows.net/"
	containerName = "sample-container"
	blobName      = "sample-blob"
	sampleFile    = "path/to/sample/file"
)

func main() {
	// create a credential
	cred, err := azidentity.NewManagedIdentityCredential(nil)
	
	// When using User Assigned Managed Identity use this instead and pass your client id in the options
	// clientID := azidentity.ClientID("abcd1234-...")
	// opts := azidentity.ManagedIdentityCredentialOptions{ID: clientID}
	// cred, err := azidentity.NewManagedIdentityCredential(&opts)
	
	if err != nil {
	  // TODO: handle error
	}
	
	// create a client for the specified storage account
	client, err := azblob.NewClient(account, cred, nil)
	if err != nil {
	  // TODO: handle error
	}
	
	// TODO: perform some action with the azblob Client
	// _, err = client.DownloadFile(context.TODO(), <containerName>, <blobName>, <target_file>, <DownloadFileOptions>)
}

Föregående kod fungerar annorlunda beroende på vilken miljö den körs i:

• På din lokala utvecklingsarbetsstation DefaultAzureCredential letar du i miljövariablerna efter ett huvudnamn för programtjänsten eller lokalt installerade utvecklarverktyg, till exempel Azure CLI, för en uppsättning autentiseringsuppgifter för utvecklare.
• När du distribuerar till Azure ManagedIdentityCredential identifierar du dina hanterade identitetskonfigurationer för att autentisera till andra tjänster automatiskt.