Authentifier les applications Go aux services Azure lors du développement local à l'aide des principaux de service

Pendant le développement local, les applications doivent s’authentifier auprès d’Azure pour accéder à différents services Azure. Les deux approches les plus courantes pour l'authentification locale sont l'utilisation d'un compte de développeur ou d'un principal de service. Cet article explique comment utiliser un principal de service d'application. Dans les sections suivantes, vous allez apprendre :

• Comment inscrire une application auprès de Microsoft Entra pour créer un principal de service
• Comment utiliser des groupes Microsoft Entra pour gérer efficacement les autorisations
• Comment attribuer des rôles aux permissions d'étendue ?
• Comment s’authentifier à l’aide d’un principal de service à partir de votre code d’application

En utilisant des principaux de service d’application dédiés, vous pouvez respecter le principe de privilège minimum lors de l’accès aux ressources Azure. Limitez les autorisations aux exigences spécifiques de l’application pendant le développement, ce qui empêche l’accès accidentel aux ressources Azure destinées à d’autres applications ou services. Cette approche permet également d’éviter les problèmes lorsque l’application est déplacée en production en s’assurant qu’elle n’est pas sur-privilégiée dans l’environnement de développement.

Lorsque vous inscrivez l’application dans Azure, vous créez un principal de service d’application. Pour le développement local :

• Créez une inscription d’application distincte pour chaque développeur travaillant sur l’application afin que chaque développeur dispose de son propre principal de service d’application et n’ait pas besoin de partager les informations d’identification.
• Créez une inscription d’application distincte pour chaque application afin de limiter les autorisations de l’application uniquement à ce qui est nécessaire.

Pendant le développement local, définissez des variables d’environnement avec l’identité du principal du service d’application. La bibliothèque Azure Identity lit ces variables d’environnement pour authentifier l’application auprès des ressources Azure requises.

Inscrire l’application dans Azure

Les objets principaux du service d’application sont créés via une inscription d’application dans Azure à l’aide du portail Azure ou d’Azure CLI.

Créer un groupe Microsoft Entra pour le développement local

Créez un groupe Microsoft Entra pour encapsuler les rôles (autorisations) dont l’application a besoin dans le développement local plutôt que d’affecter les rôles à des objets de principal de service individuels. Cette approche offre les avantages suivants :

• Chaque développeur a les mêmes rôles attribués au niveau du groupe.
• Si un nouveau rôle est nécessaire pour l’application, il doit uniquement être ajouté au groupe de l’application.
• Si un nouveau développeur rejoint l’équipe, un nouveau principal du service d’application est créé pour le développeur et ajouté au groupe, ce qui garantit que le développeur dispose des autorisations appropriées pour travailler sur l’application.

Attribuer des rôles au groupe

Ensuite, déterminez les rôles (autorisations) dont votre application a besoin sur les ressources et attribuez ces rôles au groupe Microsoft Entra que vous avez créé. Les groupes peuvent être affectés à un rôle au niveau de la ressource, du groupe de ressources ou de l’étendue de l’abonnement. Cet exemple montre comment attribuer des rôles à l’étendue du groupe de ressources, car la plupart des applications regroupent toutes leurs ressources Azure dans un seul groupe de ressources.

Définir les variables d’environnement d’application

Au moment de l’exécution, certaines informations d’identification de la bibliothèque Azure Identity, telles que DefaultAzureCredential, EnvironmentCredentialet ClientSecretCredential, recherchent des informations de principal de service par convention dans les variables d’environnement. Vous pouvez configurer des variables d’environnement de plusieurs façons en fonction de vos outils et de votre environnement. Vous pouvez créer un fichier ou utiliser des variables d’environnement .env système pour stocker ces informations d’identification localement pendant le développement. Étant donné que la plupart des développeurs travaillent sur plusieurs applications, utilisez un package comme godotenv pour accéder aux variables d’environnement à partir d’un .env fichier stocké dans le répertoire de l’application pendant le développement. Cette approche étend les variables d’environnement utilisées pour authentifier l’application auprès d’Azure afin que seule cette application puisse les utiliser. Ne validez jamais le fichier .env dans le contrôle de version, car il contient la clé secrète de l'application pour Azure. Le fichier .gitignore standard pour Go exclut automatiquement le fichier .env de l’archivage.

Pour utiliser le package godotenv, installez d’abord le package dans votre application.

go get github.com/joho/godotenv

Ensuite, créez un .env fichier dans le répertoire racine de votre application. Définissez les valeurs de variable d’environnement avec les valeurs obtenues à partir du processus d’inscription d’application pour un principal de service :

• AZURE_CLIENT_ID: utilisé pour identifier l’application inscrite dans Azure.
• AZURE_TENANT_ID: Identifiant du client Microsoft Entra.
• AZURE_CLIENT_SECRET: informations d’identification secrètes générées pour l’application.

AZURE_CLIENT_ID=<your-client-id>
AZURE_TENANT_ID=<your-tenant-id>
AZURE_CLIENT_SECRET=<your-client-secret>

Enfin, dans le code de démarrage de votre application, utilisez la godotenv bibliothèque pour lire les variables d’environnement à partir du .env fichier au démarrage.

// Imports of fmt, log, and os omitted for brevity 
import "github.com/joho/godotenv"

environment := os.Getenv("ENVIRONMENT")

if environment == "development" {
	fmt.Println("Loading environment variables from .env file")

	// Load the .env file
	err := godotenv.Load(".env")
	if err != nil {
	    log.Fatalf("Error loading .env file: %v", err)
	}
}

Si vous préférez définir les variables d’environnement dans votre environnement système au lieu d’utiliser un .env fichier, vous pouvez le faire de plusieurs façons en fonction de votre système d’exploitation et de votre interpréteur de commandes. Les exemples suivants montrent comment définir les variables d’environnement dans différents interpréteurs de commandes :

export AZURE_CLIENT_ID=<your-client-id>
export AZURE_TENANT_ID=<your-tenant-id>
export AZURE_CLIENT_SECRET=<your-client-secret>

set AZURE_CLIENT_ID=<your-client-id>
set AZURE_TENANT_ID=<your-tenant-id>
set AZURE_CLIENT_SECRET=<your-client-secret>

$env:AZURE_CLIENT_ID="<your-client-id>"
$env:AZURE_TENANT_ID="<your-tenant-id>"
$env:AZURE_CLIENT_SECRET="<your-client-secret>"

S’authentifier auprès des services Azure à partir de votre application

La bibliothèque d’identités Azure fournit différentes TokenCredential implémentations pour différents scénarios et flux d’authentification Microsoft Entra. Utilisez EnvironmentCredential lors de l’utilisation des principaux de service localement et en production. Dans ce scénario, EnvironmentCredential lit les variables d'environnement AZURE_CLIENT_ID, AZURE_TENANT_ID et AZURE_CLIENT_SECRET pour obtenir les informations du principal de service de l'application afin de se connecter à Azure.

1. Ajoutez le azidentity package à votre application.

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

2. Pour tout code Go qui crée un objet client azure SDK dans votre application, vous souhaitez :

   1. Importez le azidentity package.
   2. Créez une EnvironmentCredential instance.
   3. Transmettez l’instance au constructeur client du Kit de développement logiciel (SDK) Azure.

   Le segment de code suivant montre un exemple :

   import (
   	"context"
   	"os"
   
   	"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.NewEnvironmentCredential(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>)
   }