Créer des applications Go avec Microsoft Graph
Ce tutoriel vous apprend à créer une application console Go qui utilise l’API Microsoft Graph pour accéder aux données pour le compte d’un utilisateur.
Remarque
Pour savoir comment utiliser Microsoft Graph pour accéder aux données à l’aide de l’authentification d’application uniquement, consultez ce tutoriel sur l’authentification d’application uniquement.
Dans ce didacticiel, vous allez :
- Obtenir l’utilisateur connecté
- Répertorier les messages de la boîte de réception de l’utilisateur
- Envoyer un courrier électronique
Conseil
Au lieu de suivre ce tutoriel, vous pouvez télécharger le code terminé via l’outil de démarrage rapide , qui automatise l’inscription et la configuration des applications. Le code téléchargé fonctionne sans aucune modification requise.
Vous pouvez également télécharger ou cloner le dépôt GitHub et suivre les instructions du fichier LISEZ-MOI pour inscrire une application et configurer le projet.
Configuration requise
Avant de commencer ce didacticiel, Go doit être installé sur votre ordinateur de développement.
Vous devez également disposer d’un compte professionnel ou scolaire Microsoft avec une boîte aux lettres Exchange Online. Si vous n’avez pas de locataire Microsoft 365, vous pouvez être éligible pour un client via le Programme pour les développeurs Microsoft 365 ; Pour plus d’informations, consultez la FAQ. Vous pouvez également vous inscrire à un essai gratuit de 1 mois ou acheter un plan Microsoft 365.
Remarque
Ce tutoriel a été écrit avec Go version 1.19.3. Les étapes décrites dans ce guide peuvent fonctionner avec d’autres versions, mais elles n’ont pas été testées.
Inscrire l’application sur le portail
Dans cet exercice, vous allez inscrire une nouvelle application dans Azure Active Directory pour activer l’authentification utilisateur. Vous pouvez inscrire une application à l’aide du Centre d’administration Microsoft Entra ou à l’aide du Kit de développement logiciel (SDK) Microsoft Graph PowerShell.
Inscrire l’application pour l’authentification utilisateur
Dans cette section, vous allez inscrire une application qui prend en charge l’authentification utilisateur à l’aide du flux de code d’appareil.
Ouvrez un navigateur et accédez au Centre d’administration Microsoft Entra et connectez-vous à l’aide d’un compte d’administrateur général.
Sélectionnez Id Microsoft Entra dans le volet de navigation de gauche, développez Identité, Applications, puis inscriptions d’applications.
Sélectionnez Nouvelle inscription. Entrez un nom pour votre application, par exemple .
Graph User Auth TutorialDéfinissez types de comptes pris en charge comme vous le souhaitez. Les options disponibles sont les suivantes :
Option Qui peut se connecter ? Comptes dans cet annuaire organisationnel uniquement Seuls les utilisateurs de votre organisation Microsoft 365 Comptes dans un annuaire organisationnel Utilisateurs d’une organisation Microsoft 365 (comptes professionnels ou scolaires) Comptes dans n’importe quel annuaire organisationnel ... et comptes Microsoft personnels Utilisateurs de toute organisation Microsoft 365 (comptes professionnels ou scolaires) et comptes Microsoft personnels Laissez Redirect URI vide.
Sélectionner Inscription. Dans la page Vue d’ensemble de l’application, copiez la valeur de l’ID d’application (client) et enregistrez-la. Vous en aurez besoin à l’étape suivante. Si vous avez choisi Comptes dans cet annuaire organisationnel uniquement pour Types de comptes pris en charge, copiez également l’ID d’annuaire (locataire) et enregistrez-le.
Sous Gérer, sélectionnez Authentification. Recherchez la section Paramètres avancés et modifiez le bouton bascule Autoriser les flux clients publics sur Oui, puis choisissez Enregistrer.
Remarque
Notez que vous n’avez configuré aucune autorisation Microsoft Graph sur l’inscription de l’application. Cela est dû au fait que l’exemple utilise le consentement dynamique pour demander des autorisations spécifiques pour l’authentification utilisateur.
Créer une application console Go
Commencez par initialiser un nouveau module Go à l’aide de l’interface CLI Go. Ouvrez votre interface de ligne de commande (CLI) dans un répertoire dans lequel vous souhaitez créer le projet. Exécutez la commande suivante :
go mod init graphtutorial
Installer les dépendances
Avant de continuer, ajoutez des dépendances supplémentaires que vous utiliserez ultérieurement.
- Module client Azure Identity pour Go pour authentifier l’utilisateur et acquérir des jetons d’accès.
- Kit de développement logiciel (SDK) Microsoft Graph pour Go afin d’effectuer des appels à Microsoft Graph.
- GoDotEnv pour la lecture des variables d’environnement à partir de fichiers .env.
Exécutez les commandes suivantes dans votre interface CLI pour installer les dépendances.
go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
go get github.com/microsoftgraph/msgraph-sdk-go
go get github.com/joho/godotenv
Charger les paramètres de l’application
Dans cette section, vous allez ajouter les détails de l’inscription de votre application au projet.
Créez un fichier dans le même répertoire que go.mod nommé .env et ajoutez le code suivant.
CLIENT_ID=YOUR_CLIENT_ID_HERE TENANT_ID=common GRAPH_USER_SCOPES=user.read,mail.read,mail.sendMettez à jour les valeurs en fonction du tableau suivant.
Paramètre Valeur CLIENT_IDID client de l’inscription de votre application TENANT_IDSi vous avez choisi l’option pour autoriser uniquement les utilisateurs de votre organisation à se connecter, remplacez cette valeur par votre ID de locataire. Sinon, laissez comme common.Conseil
Si vous le souhaitez, vous pouvez définir ces valeurs dans un fichier distinct nommé .env.local.
Concevoir l’application
Dans cette section, vous allez créer un menu simple basé sur la console.
Créez un répertoire dans le même répertoire que go.mod nommé graphhelper.
Ajoutez un nouveau fichier dans le répertoire graphhelper nommé graphhelper.go et ajoutez le code suivant.
package graphhelper import ( "context" "fmt" "os" "strings" "github.com/Azure/azure-sdk-for-go/sdk/azcore/policy" "github.com/Azure/azure-sdk-for-go/sdk/azidentity" auth "github.com/microsoft/kiota-authentication-azure-go" msgraphsdk "github.com/microsoftgraph/msgraph-sdk-go" "github.com/microsoftgraph/msgraph-sdk-go/models" "github.com/microsoftgraph/msgraph-sdk-go/users" ) type GraphHelper struct { deviceCodeCredential *azidentity.DeviceCodeCredential userClient *msgraphsdk.GraphServiceClient graphUserScopes []string } func NewGraphHelper() *GraphHelper { g := &GraphHelper{} return g }Cela crée un type GraphHelper de base que vous allez étendre dans les sections ultérieures pour utiliser Microsoft Graph.
Créez un fichier dans le même répertoire que go.mod nommé graphtutorial.go. Ajoutez le code suivant.
package main import ( "fmt" "graphtutorial/graphhelper" "log" "time" "github.com/joho/godotenv" ) func main() { fmt.Println("Go Graph Tutorial") fmt.Println() // Load .env files // .env.local takes precedence (if present) godotenv.Load(".env.local") err := godotenv.Load() if err != nil { log.Fatal("Error loading .env") } graphHelper := graphhelper.NewGraphHelper() initializeGraph(graphHelper) greetUser(graphHelper) var choice int64 = -1 for { fmt.Println("Please choose one of the following options:") fmt.Println("0. Exit") fmt.Println("1. Display access token") fmt.Println("2. List my inbox") fmt.Println("3. Send mail") fmt.Println("4. Make a Graph call") _, err = fmt.Scanf("%d", &choice) if err != nil { choice = -1 } switch choice { case 0: // Exit the program fmt.Println("Goodbye...") case 1: // Display access token displayAccessToken(graphHelper) case 2: // List emails from user's inbox listInbox(graphHelper) case 3: // Send an email message sendMail(graphHelper) case 4: // Run any Graph code makeGraphCall(graphHelper) default: fmt.Println("Invalid choice! Please try again.") } if choice == 0 { break } } }Ajoutez les méthodes d’espace réservé suivantes à la fin du fichier. Vous les implémenterez dans les étapes ultérieures.
func initializeGraph(graphHelper *graphhelper.GraphHelper) { // TODO } func greetUser(graphHelper *graphhelper.GraphHelper) { // TODO } func displayAccessToken(graphHelper *graphhelper.GraphHelper) { // TODO } func listInbox(graphHelper *graphhelper.GraphHelper) { // TODO } func sendMail(graphHelper *graphhelper.GraphHelper) { // TODO } func makeGraphCall(graphHelper *graphhelper.GraphHelper) { // TODO }
Cela implémente un menu de base et lit le choix de l’utilisateur à partir de la ligne de commande.
Ajouter l’authentification utilisateur
Dans cette section, vous allez étendre l’application de l’exercice précédent pour prendre en charge l’authentification avec Azure AD. Cela est nécessaire pour obtenir le jeton d’accès OAuth nécessaire pour appeler Microsoft Graph. Dans cette étape, vous allez intégrer le module client Azure Identity pour Go dans l’application et configurer l’authentification pour le Kit de développement logiciel (SDK) Microsoft Graph pour Go.
La bibliothèque Azure Identity fournit un certain nombre de TokenCredential classes qui implémentent des flux de jetons OAuth2. La bibliothèque de client Microsoft Graph utilise ces classes pour authentifier les appels à Microsoft Graph.
Configurer le client Graph pour l’authentification utilisateur
Dans cette section, vous allez 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 ont peut-être été automatiquement supprimés de votre
importinstruction dans graphhelper.go lors de l’enregistrement. Vous devrez peut-être rajouter les modules à générer.Remplacez la fonction vide
initializeGraphdans 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 une instance de DeviceCodeCredential, puis utilise cette instance pour créer une nouvelle 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
displayAccessTokendans 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. Entrez1lorsque 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. Cela 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
scpjeton contient les étendues d’autorisation Microsoft Graph attendues.
Obtenir un utilisateur
Dans cette section, vous allez incorporer Microsoft Graph dans l’application. Pour cette application, vous allez utiliser le Kit de développement logiciel (SDK) Microsoft Graph pour Go pour passer des appels à Microsoft Graph.
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
greetUserdans 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 . Il s’agit d’une méthode de raccourci permettant d’obtenir l’utilisateur authentifié sans connaître son ID d’utilisateur.
Remarque
Étant donné que le point de GET /me 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. Cela 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 auront des valeurs dans l’objet retourné Userable . Toutes les autres propriétés ont des valeurs par défaut.
Boîte de réception de liste
Dans cette section, vous allez ajouter la possibilité de répertorier les messages dans la boîte de réception de messagerie de l’utilisateur.
Ajoutez la fonction suivante à ./graphhelper/graphhelper.go.
func (g *GraphHelper) GetInbox() (models.MessageCollectionResponseable, error) { var topValue int32 = 25 query := users.ItemMailFoldersItemMessagesRequestBuilderGetQueryParameters{ // Only request specific properties Select: []string{"from", "isRead", "receivedDateTime", "subject"}, // Get at most 25 results Top: &topValue, // Sort by received time, newest first Orderby: []string{"receivedDateTime DESC"}, } return g.userClient.Me().MailFolders(). ByMailFolderId("inbox"). Messages(). Get(context.Background(), &users.ItemMailFoldersItemMessagesRequestBuilderGetRequestConfiguration{ QueryParameters: &query, }) }Remplacez la fonction vide
listInboxdans graphtutorial.go par ce qui suit.func listInbox(graphHelper *graphhelper.GraphHelper) { messages, err := graphHelper.GetInbox() if err != nil { log.Panicf("Error getting user's inbox: %v", err) } // Load local time zone // Dates returned by Graph are in UTC, use this // to convert to local location, err := time.LoadLocation("Local") if err != nil { log.Panicf("Error getting local timezone: %v", err) } // Output each message's details for _, message := range messages.GetValue() { fmt.Printf("Message: %s\n", *message.GetSubject()) fmt.Printf(" From: %s\n", *message.GetFrom().GetEmailAddress().GetName()) status := "Unknown" if *message.GetIsRead() { status = "Read" } else { status = "Unread" } fmt.Printf(" Status: %s\n", status) fmt.Printf(" Received: %s\n", (*message.GetReceivedDateTime()).In(location)) } // If GetOdataNextLink does not return nil, // there are more messages available on the server nextLink := messages.GetOdataNextLink() fmt.Println() fmt.Printf("More messages available? %t\n", nextLink != nil) fmt.Println() }Exécutez l’application, connectez-vous et choisissez l’option 2 pour répertorier votre boîte de réception.
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 2 Message: Updates from Ask HR and other communities From: Contoso Demo on Yammer Status: Read Received: 2021-12-30 04:54:54 -0500 EST Message: Employee Initiative Thoughts From: Patti Fernandez Status: Read Received: 2021-12-28 17:01:10 -0500 EST Message: Voice Mail (11 seconds) From: Alex Wilber Status: Unread Received: 2021-12-28 17:00:46 -0500 EST Message: Our Spring Blog Update From: Alex Wilber Status: Unread Received: 2021-12-28 16:49:46 -0500 EST Message: Atlanta Flight Reservation From: Alex Wilber Status: Unread Received: 2021-12-28 16:35:42 -0500 EST Message: Atlanta Trip Itinerary - down time From: Alex Wilber Status: Unread Received: 2021-12-28 16:22:04 -0500 EST ... More messages available? True
Explication du code
Considérez le code dans la GetInbox fonction .
Accès aux dossiers de courrier connus
La fonction utilise le générateur de userClient.Me().MailFolders.ByMailFolderId("inbox").Messages() requêtes, qui génère une requête à l’API Répertorier les messages . Étant donné qu’elle inclut le ByMailFolderId("inbox") générateur de requêtes, l’API retourne uniquement les messages dans le dossier de messagerie demandé. Dans ce cas, étant donné que la boîte de réception est un dossier par défaut connu dans la boîte aux lettres d’un utilisateur, elle est accessible via son nom connu. Les dossiers autres que les dossiers par défaut sont accessibles de la même façon, en remplaçant le nom connu par la propriété ID du dossier de messagerie. Pour plus d’informations sur les noms de dossiers connus disponibles, consultez Type de ressource mailFolder.
Accès à une collection
Contrairement à la GetUser fonction de la section précédente, qui retourne un seul objet, cette méthode retourne une collection de messages. La plupart des API de Microsoft Graph qui retournent une collection ne retournent pas tous les résultats disponibles dans une seule réponse. Au lieu de cela, ils utilisent la pagination pour retourner une partie des résultats tout en fournissant une méthode permettant aux clients de demander la « page » suivante.
Tailles de page par défaut
Les API qui utilisent la pagination implémentent une taille de page par défaut. Pour les messages, la valeur par défaut est 10. Les clients peuvent demander plus (ou moins) à l’aide du paramètre de requête $top . Dans GetInbox, cela s’effectue avec la Top propriété dans les paramètres de requête.
Remarque
La valeur passée Top est une limite supérieure, et non un nombre explicite. L’API retourne un certain nombre de messages jusqu’à la valeur spécifiée.
Obtention des pages suivantes
Si d’autres résultats sont disponibles sur le serveur, les réponses de regroupement incluent une @odata.nextLink propriété avec une URL d’API pour accéder à la page suivante. Le Kit de développement logiciel (SDK) Go expose cela en tant que méthode sur les GetOdataNextLink objets de page de collection. Si cette méthode retourne une valeur non nulle, d’autres résultats sont disponibles.
Tri des collections
La fonction utilise la OrderBy propriété dans les paramètres de requête pour demander des résultats triés en fonction de la réception du message (receivedDateTime propriété ). Il inclut le mot clé afin que les DESC messages reçus plus récemment soient répertoriés en premier. Cela ajoute le paramètre de requête $orderby à l’appel d’API.
Envoyer un message
Dans cette section, vous allez ajouter la possibilité d’envoyer un e-mail en tant qu’utilisateur authentifié.
Ajoutez la fonction suivante à ./graphhelper/graphhelper.go.
func (g *GraphHelper) SendMail(subject *string, body *string, recipient *string) error { // Create a new message message := models.NewMessage() message.SetSubject(subject) messageBody := models.NewItemBody() messageBody.SetContent(body) contentType := models.TEXT_BODYTYPE messageBody.SetContentType(&contentType) message.SetBody(messageBody) toRecipient := models.NewRecipient() emailAddress := models.NewEmailAddress() emailAddress.SetAddress(recipient) toRecipient.SetEmailAddress(emailAddress) message.SetToRecipients([]models.Recipientable{ toRecipient, }) sendMailBody := users.NewItemSendMailPostRequestBody() sendMailBody.SetMessage(message) // Send the message return g.userClient.Me().SendMail().Post(context.Background(), sendMailBody, nil) }Remplacez la fonction vide
sendMaildans graphtutorial.go par ce qui suit.func sendMail(graphHelper *graphhelper.GraphHelper) { // Send mail to the signed-in user // Get the user for their email address user, err := graphHelper.GetUser() if err != nil { log.Panicf("Error getting user: %v", err) } // For Work/school accounts, email is in Mail property // Personal accounts, email is in UserPrincipalName email := user.GetMail() if email == nil { email = user.GetUserPrincipalName() } subject := "Testing Microsoft Graph" body := "Hello world!" err = graphHelper.SendMail(&subject, &body, email) if err != nil { log.Panicf("Error sending mail: %v", err) } fmt.Println("Mail sent.") fmt.Println() }Exécutez l’application, connectez-vous et choisissez l’option 3 pour vous envoyer un e-mail.
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 3 Mail sent.Remarque
Si vous effectuez des tests auprès d’un locataire développeur à partir du Programme pour développeurs Microsoft 365, l’e-mail que vous envoyez risque de ne pas être remis et vous pouvez recevoir un rapport de non-remise. Si cela vous arrive, contactez le support via le Centre d’administration Microsoft 365.
Pour vérifier que le message a été reçu, choisissez l’option 2 pour répertorier votre boîte de réception.
Explication du code
Considérez le code dans la SendMail fonction .
Envoi de messages
La fonction utilise le générateur de userClient.Me().SendMail() requêtes, qui génère une requête à l’API Envoyer un courrier . Le générateur de requêtes prend un Message objet représentant le message à envoyer.
Création d’objets
Contrairement aux appels précédents à Microsoft Graph qui ne lisent que les données, cet appel crée des données. Pour ce faire avec la bibliothèque cliente, vous créez une instance de la classe représentant les données (dans ce cas, models.Message), définissez les propriétés souhaitées, puis envoyez-la dans l’appel d’API. Étant donné que l’appel envoie des données, la Post méthode est utilisée à la place de Get.
Facultatif : ajouter votre propre code
Dans cette section, vous allez ajouter vos propres fonctionnalités Microsoft Graph à l’application. Il peut s’agir d’un extrait de code de la documentation Microsoft Graph ou de l’Explorateur Graph, ou du code que vous avez créé. Cette section est facultative.
Mettre à jour l’application
Ajoutez la fonction suivante à ./graphhelper/graphhelper.go.
func (g *GraphHelper) MakeGraphCall() error { // INSERT YOUR CODE HERE return nil }Remplacez la fonction vide
makeGraphCalldans graphtutorial.go par ce qui suit.func makeGraphCall(graphHelper *graphhelper.GraphHelper) { err := graphHelper.MakeGraphCall() if err != nil { log.Panicf("Error making Graph call: %v", err) } }
Choisir une API
Recherchez une API dans Microsoft Graph que vous souhaitez essayer. Par exemple, l’API Créer un événement . Vous pouvez utiliser l’un des exemples de la documentation de l’API, ou vous pouvez personnaliser une demande d’API dans l’Explorateur Graph et utiliser l’extrait de code généré.
Configuration des autorisations
Consultez la section Autorisations de la documentation de référence de l’API choisie pour voir quelles méthodes d’authentification sont prises en charge. Certaines API ne prennent pas en charge les comptes Microsoft personnels ou d’application uniquement, par exemple.
- Pour appeler une API avec l’authentification utilisateur (si l’API prend en charge l’authentification utilisateur (déléguée), ajoutez l’étendue d’autorisation requise dans .env (ou .env.local).
- Pour appeler une API avec une authentification d’application uniquement, consultez le tutoriel sur l’authentification d’application uniquement .
Ajouter votre code
Copiez votre code dans la MakeGraphCall fonction dans graphhelper.go. Si vous copiez un extrait de code à partir de la documentation ou de l’Explorateur Graph, veillez à renommer en GraphServiceClientuserClient.
Félicitations !
Vous avez terminé le tutoriel Go Microsoft Graph. Maintenant que vous disposez d’une application opérationnelle qui appelle Microsoft Graph, vous pouvez expérimenter et ajouter de nouvelles fonctionnalités.
- Découvrez comment utiliser l’authentification d’application uniquement avec le Kit de développement logiciel (SDK) Microsoft Graph pour Go.
- Consultez la vue d’ensemble de Microsoft Graph pour voir toutes les données accessibles avec Microsoft Graph.
Vous avez un défi avec cette section ? Si c'est le cas, faites-nous part de vos commentaires pour que nous puissions l'améliorer.