Ajouter l’authentification utilisateur aux applications Go pour Microsoft Graph

2025-06-12

Dans cet article, vous allez ajouter l’authentification utilisateur à l’application que vous avez créée dans Générer des applications Go avec Microsoft Graph. Vous utilisez ensuite l’API utilisateur Microsoft Graph pour obtenir l’utilisateur authentifié.

Ajouter l’authentification utilisateur

Le module client Azure Identity pour Go fournit de nombreuses TokenCredential classes qui implémentent des flux de jetonS OAuth2. Le Kit de développement logiciel (SDK) Microsoft Graph pour Go utilise ces classes pour authentifier les appels à Microsoft Graph.

Configurer le client Graph pour l’authentification utilisateur

Commencez par utiliser la DeviceCodeCredential classe pour demander un jeton d’accès à l’aide du flux de code de l’appareil.

Ajoutez la fonction suivante à ./graphhelper/graphhelper.go.

func (g *GraphHelper) InitializeGraphForUserAuth() error {
    clientId := os.Getenv("CLIENT_ID")
    tenantId := os.Getenv("TENANT_ID")
    scopes := os.Getenv("GRAPH_USER_SCOPES")
    g.graphUserScopes = strings.Split(scopes, ",")

    // Create the device code credential
    credential, err := azidentity.NewDeviceCodeCredential(&azidentity.DeviceCodeCredentialOptions{
        ClientID: clientId,
        TenantID: tenantId,
        UserPrompt: func(ctx context.Context, message azidentity.DeviceCodeMessage) error {
            fmt.Println(message.Message)
            return nil
        },
    })
    if err != nil {
        return err
    }

    g.deviceCodeCredential = credential

    // Create an auth provider using the credential
    authProvider, err := auth.NewAzureIdentityAuthenticationProviderWithScopes(credential, g.graphUserScopes)
    if err != nil {
        return err
    }

    // Create a request adapter using the auth provider
    adapter, err := msgraphsdk.NewGraphRequestAdapter(authProvider)
    if err != nil {
        return err
    }

    // Create a Graph client using request adapter
    client := msgraphsdk.NewGraphServiceClient(adapter)
    g.userClient = client

    return nil
}

Conseil

Si vous utilisez goimports, certains modules peuvent être supprimés de votre import instruction dans graphhelper.go lors de l’enregistrement. Vous devrez peut-être rajouter les modules pour générer.

Remplacez la fonction vide initializeGraph dans graphtutorial.go par ce qui suit.

func initializeGraph(graphHelper *graphhelper.GraphHelper) {
    err := graphHelper.InitializeGraphForUserAuth()
    if err != nil {
        log.Panicf("Error initializing Graph for user auth: %v\n", err)
    }
}

Ce code initialise deux propriétés, un DeviceCodeCredential objet et un GraphServiceClient objet . La InitializeGraphForUserAuth fonction crée un instance de DeviceCodeCredential, puis utilise cette instance pour créer un instance de GraphServiceClient. Chaque fois qu’un appel d’API est effectué à Microsoft Graph via , userClientil utilise les informations d’identification fournies pour obtenir un jeton d’accès.

Tester deviceCodeCredential

Ensuite, ajoutez du code pour obtenir un jeton d’accès à partir de .DeviceCodeCredential

Ajoutez la fonction suivante à ./graphhelper/graphhelper.go.

func (g *GraphHelper) GetUserToken() (*string, error) {
    token, err := g.deviceCodeCredential.GetToken(context.Background(), policy.TokenRequestOptions{
        Scopes: g.graphUserScopes,
    })
    if err != nil {
        return nil, err
    }

    return &token.Token, nil
}

Remplacez la fonction vide displayAccessToken dans graphtutorial.go par ce qui suit.

func displayAccessToken(graphHelper *graphhelper.GraphHelper) {
    token, err := graphHelper.GetUserToken()
    if err != nil {
        log.Panicf("Error getting user token: %v\n", err)
    }

    fmt.Printf("User token: %s", *token)
    fmt.Println()
}

Générez et exécutez l’application en exécutant go run graphtutorial. Entrez 1 lorsque vous êtes invité à entrer une option. L’application affiche une URL et un code d’appareil.

Go Graph Tutorial

Please choose one of the following options:
0. Exit
1. Display access token
2. List my inbox
3. Send mail
4. Make a Graph call
1
To sign in, use a web browser to open the page https://microsoft.com/devicelogin and
enter the code RB2RUD56D to authenticate.

Ouvrez un navigateur et accédez à l’URL affichée. Entrez le code fourni et connectez-vous.

Importante

Gardez à l’esprit tous les comptes Microsoft 365 existants qui sont connectés à votre navigateur lorsque vous accédez à https://microsoft.com/devicelogin. Utilisez les fonctionnalités du navigateur telles que les profils, le mode invité ou le mode privé pour vous assurer que vous vous authentifiez en tant que compte que vous envisagez d’utiliser pour les tests.
Une fois terminé, revenez à l’application pour voir le jeton d’accès.

Conseil

À des fins de validation et de débogage uniquement, vous pouvez décoder les jetons d’accès utilisateur (pour les comptes professionnels ou scolaires uniquement) à l’aide de l’analyseur de jetons en ligne de Microsoft à l’adresse https://jwt.ms. L’analyse de votre jeton peut être utile si vous rencontrez des erreurs de jeton lors de l’appel de Microsoft Graph. Par exemple, vérifier que la revendication dans le scp jeton contient les étendues d’autorisation Microsoft Graph attendues.

Obtenir un utilisateur

Maintenant que l’authentification est configurée, vous pouvez effectuer votre premier appel microsoft API Graph. Ajoutez du code pour obtenir le nom et l’adresse e-mail de l’utilisateur authentifié.

Ajoutez la fonction suivante à ./graphhelper/graphhelper.go.

func (g *GraphHelper) GetUser() (models.Userable, error) {
    query := users.UserItemRequestBuilderGetQueryParameters{
        // Only request specific properties
        Select: []string{"displayName", "mail", "userPrincipalName"},
    }

    return g.userClient.Me().Get(context.Background(),
        &users.UserItemRequestBuilderGetRequestConfiguration{
            QueryParameters: &query,
        })
}

Remplacez la fonction vide greetUser dans graphtutorial.go par ce qui suit.

func greetUser(graphHelper *graphhelper.GraphHelper) {
    user, err := graphHelper.GetUser()
    if err != nil {
        log.Panicf("Error getting user: %v\n", err)
    }

    fmt.Printf("Hello, %s!\n", *user.GetDisplayName())

    // For Work/school accounts, email is in Mail property
    // Personal accounts, email is in UserPrincipalName
    email := user.GetMail()
    if email == nil {
        email = user.GetUserPrincipalName()
    }

    fmt.Printf("Email: %s\n", *email)
    fmt.Println()
}

Si vous exécutez l’application maintenant, une fois que vous vous êtes connecté, l’application vous accueille par son nom.

Hello, Megan Bowen!
Email: MeganB@contoso.com

Explication du code

Considérez le code dans la getUser fonction . Il ne s’agit que de quelques lignes, mais il y a quelques détails clés à noter.

Accès à « moi »

La fonction utilise le générateur de userClient.Me requêtes, qui génère une requête à l’API Get user . Cette API est accessible de deux façons :

GET /me
GET /users/{user-id}

Dans ce cas, le code appelle le point de terminaison d’API GET /me . Ce point de terminaison est une méthode de raccourci permettant d’obtenir l’utilisateur authentifié sans connaître son ID d’utilisateur.

Remarque

Étant donné que le GET /me point de terminaison d’API obtient l’utilisateur authentifié, il est disponible uniquement pour les applications qui utilisent l’authentification utilisateur. Les applications d’authentification d’application uniquement ne peuvent pas accéder à ce point de terminaison.

Demande de propriétés spécifiques

La fonction utilise la Select propriété dans les paramètres de requête de la requête pour spécifier le jeu de propriétés dont elle a besoin. Cette propriété ajoute le paramètre de requête $select à l’appel d’API.

Type de retour fortement typé

La fonction retourne un Userable objet désérialisé à partir de la réponse JSON de l’API. Étant donné que le code utilise Select, seules les propriétés demandées ont des valeurs dans l’objet retourné Userable . Toutes les autres propriétés ont des valeurs par défaut.

Étape suivante

Lire et envoyer des e-mails

Partager via

Ajouter l’authentification utilisateur aux applications Go pour Microsoft Graph