Créer des applications Python avec Microsoft Graph

Article
Developer (Débutant)
29 minutes avant achèvement

Ce tutoriel vous apprend à créer une application console Python qui utilise l’API Microsoft Graph pour accéder aux données au nom 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 :

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, python et pip doivent être installés 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 Python version 3.10.4 et pip version 20.0.2. 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

28 minutes restantes

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.

Centre d'administration Microsoft Entra
PowerShell

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 Tutorial

Dé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.

Pour utiliser PowerShell, vous avez besoin du Kit de développement logiciel (SDK) Microsoft Graph PowerShell. Si vous ne l’avez pas, consultez Installer le Kit de développement logiciel (SDK) Microsoft Graph PowerShell pour obtenir des instructions d’installation.

Importante

Le script PowerShell nécessite un compte professionnel/scolaire avec le rôle Administrateur d’application, Administrateur d’application cloud ou Administrateur général. Si votre compte a le rôle Développeur d’applications, vous pouvez vous inscrire dans le Centre d’administration Microsoft Entra.

Créez un fichier nommé RegisterAppForUserAuth.ps1 et ajoutez le code suivant.

param(
  [Parameter(Mandatory=$true,
  HelpMessage="The friendly name of the app registration")]
  [String]
  $AppName,

  [Parameter(Mandatory=$false,
  HelpMessage="The sign in audience for the app")]
  [ValidateSet("AzureADMyOrg", "AzureADMultipleOrgs", `
  "AzureADandPersonalMicrosoftAccount", "PersonalMicrosoftAccount")]
  [String]
  $SignInAudience = "AzureADandPersonalMicrosoftAccount",

  [Parameter(Mandatory=$false)]
  [Switch]
  $StayConnected = $false
)

# Tenant to use in authentication.
# See https://learn.microsoft.com/azure/active-directory/develop/v2-oauth2-device-code#device-authorization-request
$authTenant = switch ($SignInAudience)
{
  "AzureADMyOrg" { "tenantId" }
  "AzureADMultipleOrgs" { "organizations" }
  "AzureADandPersonalMicrosoftAccount" { "common" }
  "PersonalMicrosoftAccount" { "consumers" }
  default { "invalid" }
}

if ($authTenant -eq "invalid")
{
  Write-Host -ForegroundColor Red "Invalid sign in audience:" $SignInAudience
  Exit
}

# Requires an admin
Connect-MgGraph -Scopes "Application.ReadWrite.All User.Read" -UseDeviceAuthentication -ErrorAction Stop

# Get context for access to tenant ID
$context = Get-MgContext -ErrorAction Stop

if ($authTenant -eq "tenantId")
{
  $authTenant = $context.TenantId
}

# Create app registration
$appRegistration = New-MgApplication -DisplayName $AppName -SignInAudience $SignInAudience `
 -IsFallbackPublicClient -ErrorAction Stop
Write-Host -ForegroundColor Cyan "App registration created with app ID" $appRegistration.AppId

# Create corresponding service principal
if ($SignInAudience -ne "PersonalMicrosoftAccount")
{
  New-MgServicePrincipal -AppId $appRegistration.AppId -ErrorAction SilentlyContinue `
   -ErrorVariable SPError | Out-Null
  if ($SPError)
  {
    Write-Host -ForegroundColor Red "A service principal for the app could not be created."
    Write-Host -ForegroundColor Red $SPError
    Exit
  }

  Write-Host -ForegroundColor Cyan "Service principal created"
}

Write-Host
Write-Host -ForegroundColor Green "SUCCESS"
Write-Host -ForegroundColor Cyan -NoNewline "Client ID: "
Write-Host -ForegroundColor Yellow $appRegistration.AppId
Write-Host -ForegroundColor Cyan -NoNewline "Auth tenant: "
Write-Host -ForegroundColor Yellow $authTenant

if ($StayConnected -eq $false)
{
  Disconnect-MgGraph | Out-Null
  Write-Host "Disconnected from Microsoft Graph"
}
else
{
  Write-Host
  Write-Host -ForegroundColor Yellow `
   "The connection to Microsoft Graph is still active. To disconnect, use Disconnect-MgGraph"
}

Enregistrez le fichier.
Ouvrez PowerShell et remplacez le répertoire actif par l’emplacement de RegisterAppForUserAuth.ps1.

Exécutez la commande suivante, en <remplaçant audience-value> par la valeur souhaitée (voir le tableau ci-dessous).

.\RegisterAppForUserAuth.ps1 -AppName "Graph User Auth Tutorial" -SignInAudience <audience-value>

Valeur SignInAudience	Qui peut se connecter ?
`AzureADMyOrg`	Seuls les utilisateurs de votre organisation Microsoft 365
`AzureADMultipleOrgs`	Utilisateurs d’une organisation Microsoft 365 (comptes professionnels ou scolaires)
`AzureADandPersonalMicrosoftAccount`	Utilisateurs de toute organisation Microsoft 365 (comptes professionnels ou scolaires) et comptes Microsoft personnels
`PersonalMicrosoftAccount`	Seuls les comptes Microsoft personnels

Suivez l’invite pour ouvrir https://microsoft.com/devicelogin dans un navigateur, entrez le code fourni et terminez le processus d’authentification.
Copiez les valeurs d’ID client et de locataire d’authentification à partir de la sortie du script. Vous aurez besoin de ces valeurs à l’étape suivante.
```
SUCCESS
Client ID: 2fb1652f-a9a0-4db9-b220-b224b8d9d38b
Auth tenant: common
```

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 Python

25 minutes restantes

Commencez par créer un fichier Python.

Créez un fichier nommé main.py et ajoutez le code suivant.
```
print ('Hello world!')
```
Enregistrez le fichier et utilisez la commande suivante pour exécuter le fichier.
```
python3 main.py
```
Si cela fonctionne, l’application doit générer Hello world!.

Installer les dépendances

Avant de continuer, ajoutez des dépendances supplémentaires que vous utiliserez ultérieurement.

Bibliothèque de client Azure Identity pour Python afin d’authentifier l’utilisateur et d’acquérir des jetons d’accès.
Kit de développement logiciel (SDK) Microsoft Graph pour Python (préversion) pour effectuer des appels à Microsoft Graph.

Exécutez les commandes suivantes dans votre interface CLI pour installer les dépendances.

python3 -m pip install azure-identity
python3 -m pip install msgraph-sdk

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 main.py nommé config.cfg et ajoutez le code suivant.

[azure]
clientId = YOUR_CLIENT_ID_HERE
tenantId = common
graphUserScopes = User.Read Mail.Read Mail.Send

Mettez à jour les valeurs en fonction du tableau suivant.

Paramètre	Valeur
`clientId`	ID client de l’inscription de votre application
`tenantId`	Si 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é config.dev.cfg.

Concevoir l’application

Dans cette section, vous allez créer un menu simple basé sur la console.

Créez un fichier nommé graph.py et ajoutez le code suivant à ce fichier.
```
# Temporary placeholder
class Graph:
    def __init__(self, config):
        self.settings = config
```
Ce code est un espace réservé. Vous allez implémenter la Graph classe dans la section suivante.

Ouvrez main.py et remplacez tout son contenu par le code suivant.

import asyncio
import configparser
from msgraph.generated.models.o_data_errors.o_data_error import ODataError
from graph import Graph

async def main():
    print('Python Graph Tutorial\n')

    # Load settings
    config = configparser.ConfigParser()
    config.read(['config.cfg', 'config.dev.cfg'])
    azure_settings = config['azure']

    graph: Graph = Graph(azure_settings)

    await greet_user(graph)

    choice = -1

    while choice != 0:
        print('Please choose one of the following options:')
        print('0. Exit')
        print('1. Display access token')
        print('2. List my inbox')
        print('3. Send mail')
        print('4. Make a Graph call')

        try:
            choice = int(input())
        except ValueError:
            choice = -1

        try:
            if choice == 0:
                print('Goodbye...')
            elif choice == 1:
                await display_access_token(graph)
            elif choice == 2:
                await list_inbox(graph)
            elif choice == 3:
                await send_mail(graph)
            elif choice == 4:
                await make_graph_call(graph)
            else:
                print('Invalid choice!\n')
        except ODataError as odata_error:
            print('Error:')
            if odata_error.error:
                print(odata_error.error.code, odata_error.error.message)

Ajoutez les méthodes d’espace réservé suivantes à la fin du fichier. Vous les implémenterez dans les étapes ultérieures.

async def greet_user(graph: Graph):
    # TODO
    return

async def display_access_token(graph: Graph):
    # TODO
    return

async def list_inbox(graph: Graph):
    # TODO
    return

async def send_mail(graph: Graph):
    # TODO
    return

async def make_graph_call(graph: Graph):
    # TODO
    return

Ajoutez la ligne suivante à appeler main à la fin du fichier.
```
# Run main
asyncio.run(main())
```

Cela implémente un menu de base et lit le choix de l’utilisateur à partir de la ligne de commande.

Ajouter l’authentification utilisateur

20 minutes restantes

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 la bibliothèque de client Azure Identity pour Python dans l’application et configurer l’authentification pour le Kit de développement logiciel (SDK) Microsoft Graph pour Python (préversion) .

La bibliothèque Azure Identity fournit un certain nombre de TokenCredential classes qui implémentent des flux de jetons OAuth2. Le Kit de développement logiciel (SDK) 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.

Ouvrez graph.py et remplacez tout son contenu par le code suivant.

from configparser import SectionProxy
from azure.identity import DeviceCodeCredential
from msgraph import GraphServiceClient
from msgraph.generated.users.item.user_item_request_builder import UserItemRequestBuilder
from msgraph.generated.users.item.mail_folders.item.messages.messages_request_builder import (
    MessagesRequestBuilder)
from msgraph.generated.users.item.send_mail.send_mail_post_request_body import (
    SendMailPostRequestBody)
from msgraph.generated.models.message import Message
from msgraph.generated.models.item_body import ItemBody
from msgraph.generated.models.body_type import BodyType
from msgraph.generated.models.recipient import Recipient
from msgraph.generated.models.email_address import EmailAddress

class Graph:
    settings: SectionProxy
    device_code_credential: DeviceCodeCredential
    user_client: GraphServiceClient

    def __init__(self, config: SectionProxy):
        self.settings = config
        client_id = self.settings['clientId']
        tenant_id = self.settings['tenantId']
        graph_scopes = self.settings['graphUserScopes'].split(' ')

        self.device_code_credential = DeviceCodeCredential(client_id, tenant_id = tenant_id)
        self.user_client = GraphServiceClient(self.device_code_credential, graph_scopes)

Ce code déclare deux propriétés privées, un DeviceCodeCredential objet et un GraphServiceClient objet . La __init__ 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 , user_clientil utilise les informations d’identification fournies pour obtenir un jeton d’accès.

Ajoutez la fonction suivante à graph.py.

async def get_user_token(self):
    graph_scopes = self.settings['graphUserScopes']
    access_token = self.device_code_credential.get_token(graph_scopes)
    return access_token.token

Remplacez la fonction vide display_access_token dans main.py par ce qui suit.

async def display_access_token(graph: Graph):
    token = await graph.get_user_token()
    print('User token:', token, '\n')

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

Python 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 scp jeton contient les étendues d’autorisation Microsoft Graph attendues.

Obtenir un utilisateur

15 minutes restantes

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 Python (préversion) pour effectuer des appels à Microsoft Graph.

Ajoutez la fonction suivante à graph.py.

async def get_user(self):
    # Only request specific properties using $select
    query_params = UserItemRequestBuilder.UserItemRequestBuilderGetQueryParameters(
        select=['displayName', 'mail', 'userPrincipalName']
    )

    request_config = UserItemRequestBuilder.UserItemRequestBuilderGetRequestConfiguration(
        query_parameters=query_params
    )

    user = await self.user_client.me.get(request_configuration=request_config)
    return user

Remplacez la fonction vide greet_user dans main.py par ce qui suit.

async def greet_user(graph: Graph):
    user = await graph.get_user()
    if user:
        print('Hello,', user.display_name)
        # For Work/school accounts, email is in mail property
        # Personal accounts, email is in userPrincipalName
        print('Email:', user.mail or user.user_principal_name, '\n')

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 get_user fonction . Il ne s’agit que de quelques lignes, mais il y a quelques détails clés à noter.

Accès à « moi »

La fonction génère une requête à l’API Obtenir l’utilisateur . 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 le paramètre de requête $select pour spécifier le jeu de propriétés dont elle a besoin. Microsoft Graph retourne uniquement les propriétés demandées dans la réponse. Dans get_user, cette opération s’effectue avec le select paramètre dans l’objet MeRequestBuilderGetQueryParameters .

Boîte de réception de liste

12 minutes restantes

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 à graph.py.

async def get_inbox(self):
    query_params = MessagesRequestBuilder.MessagesRequestBuilderGetQueryParameters(
        # Only request specific properties
        select=['from', 'isRead', 'receivedDateTime', 'subject'],
        # Get at most 25 results
        top=25,
        # Sort by received time, newest first
        orderby=['receivedDateTime DESC']
    )
    request_config = MessagesRequestBuilder.MessagesRequestBuilderGetRequestConfiguration(
        query_parameters= query_params
    )

    messages = await self.user_client.me.mail_folders.by_mail_folder_id('inbox').messages.get(
            request_configuration=request_config)
    return messages

Remplacez la fonction vide list_inbox dans main.py par ce qui suit.

async def list_inbox(graph: Graph):
    message_page = await graph.get_inbox()
    if message_page and message_page.value:
        # Output each message's details
        for message in message_page.value:
            print('Message:', message.subject)
            if (
                message.from_ and
                message.from_.email_address
            ):
                print('  From:', message.from_.email_address.name or 'NONE')
            else:
                print('  From: NONE')
            print('  Status:', 'Read' if message.is_read else 'Unread')
            print('  Received:', message.received_date_time)

        # If @odata.nextLink is present
        more_available = message_page.odata_next_link is not None
        print('\nMore messages available?', more_available, '\n')

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: 2022-04-26T19:19:05Z
Message: Employee Initiative Thoughts
  From: Patti Fernandez
  Status: Read
  Received: 2022-04-25T19:43:57Z
Message: Voice Mail (11 seconds)
  From: Alex Wilber
  Status: Unread
  Received: 2022-04-22T19:43:23Z
Message: Our Spring Blog Update
  From: Alex Wilber
  Status: Unread
  Received: 2022-04-19T22:19:02Z
Message: Atlanta Flight Reservation
  From: Alex Wilber
  Status: Unread
  Received: 2022-04-19T15:15:56Z
Message: Atlanta Trip Itinerary - down time
  From: Alex Wilber
  Status: Unread
  Received: 2022-04-18T14:24:16Z

...

More messages available? True

Explication du code

Considérez le code dans la get_inbox fonction .

Accès aux dossiers de courrier connus

La fonction génère une requête à l’API Répertorier les messages . Étant donné qu’elle inclut le mail_folders.by_mail_folder_id('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 get_user 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 get_inbox, cette opération s’effectue avec le top paramètre dans l’objet MessagesRequestBuilderGetQueryParameters .

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) Python l’expose en tant que propriété sur les odata_next_link objets de page de collection. Si cette propriété est présente, d’autres résultats sont disponibles.

Tri des collections

La fonction utilise le paramètre de requête $orderby 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. Dans get_inbox, cette opération s’effectue avec le orderby paramètre dans l’objet MessagesRequestBuilderGetQueryParameters .

Envoyer un message

8 minutes restantes

Dans cette section, vous allez ajouter la possibilité d’envoyer un e-mail en tant qu’utilisateur authentifié.

Ajoutez la fonction suivante à graph.py.

async def send_mail(self, subject: str, body: str, recipient: str):
    message = Message()
    message.subject = subject

    message.body = ItemBody()
    message.body.content_type = BodyType.Text
    message.body.content = body

    to_recipient = Recipient()
    to_recipient.email_address = EmailAddress()
    to_recipient.email_address.address = recipient
    message.to_recipients = []
    message.to_recipients.append(to_recipient)

    request_body = SendMailPostRequestBody()
    request_body.message = message

    await self.user_client.me.send_mail.post(body=request_body)

Remplacez la fonction vide send_mail dans main.py par ce qui suit.

async def send_mail(graph: Graph):
    # Send mail to the signed-in user
    # Get the user for their email address
    user = await graph.get_user()
    if user:
        user_email = user.mail or user.user_principal_name

        await graph.send_mail('Testing Microsoft Graph', 'Hello world!', user_email or '')
        print('Mail sent.\n')

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 send_mail fonction .

Envoi de messages

La fonction utilise le générateur de user_client.me.send_mail requêtes, qui génère une requête à l’API Envoyer un courrier .

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 un dictionnaire représentant la charge utile de la requête, définissez les propriétés souhaitées, puis envoyez-le 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

5 minutes restantes

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 à graph.py.

async def make_graph_call(self):
    # INSERT YOUR CODE HERE
    return

Remplacez la fonction vide make_graph_call dans main.py par ce qui suit.

async def make_graph_call(graph: Graph):
    await graph.make_graph_call()

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 créer votre propre demande d’API.

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 config.cfg.
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 make_graph_call fonction dans graph.py. Si vous copiez un extrait de code à partir de la documentation ou de l’Explorateur Graph, veillez à renommer en GraphServiceClientself.user_client.

Partager via

Créer des applications Python avec Microsoft Graph

Configuration requise

Inscrire l’application sur le portail

Inscrire l’application pour l’authentification utilisateur

Créer une application console Python

Installer les dépendances

Charger les paramètres de l’application

Concevoir l’application

Ajouter l’authentification utilisateur

Configurer le client Graph pour l’authentification utilisateur

Obtenir un utilisateur

Explication du code

Accès à « moi »

Demande de propriétés spécifiques

Boîte de réception de liste

Explication du code

Accès aux dossiers de courrier connus

Accès à une collection

Tailles de page par défaut

Obtention des pages suivantes

Tri des collections

Envoyer un message

Explication du code

Envoi de messages

Création d’objets

Facultatif : ajouter votre propre code

Mettre à jour l’application

Choisir une API

Configuration des autorisations

Ajouter votre code

Félicitations !

Exemples Python