Démarrage rapide : configurer et gérer des jetons d’accès pour les utilisateurs Teams
Dans ce guide de démarrage rapide, vous allez créer une application de console .NET pour authentifier un utilisateur Microsoft 365 en employant la bibliothèque d’authentification Microsoft (MSAL) et en récupérant un jeton utilisateur Microsoft Entra. Vous échangerez ensuite ce jeton contre un jeton d’accès d’utilisateur Teams avec le kit SDK Azure Communication Services Identity. Le jeton d’accès d’utilisateur Teams peut ensuite être utilisé par le kit SDK Communication Services Calling pour intégrer la fonctionnalité d’appels en tant qu’utilisateur Teams.
Notes
Quand vous êtes dans un environnement de production, nous vous recommandons d’implémenter ce mécanisme d’échange dans les services back-end, car les demandes d’échange sont signées avec un secret.
Prérequis
- Compte Azure avec un abonnement actif. Créez un compte gratuitement.
- Une ressource Azure Communication Services active et la chaîne de connexion. Pour plus d’informations, consultez Créer une ressource Azure Communication Services.
- Une Instance Microsoft Entra avec des utilisateurs disposant d’une licence Teams. Pour plus d’informations, consultez Conditions de licence Teams.
Présentation
Les identités Teams sont associées aux locataires dans Microsoft Entra ID. Votre application peut être utilisée par les utilisateurs du même locataire ou d’un autre. Dans ce guide de démarrage rapide, vous allez utiliser un cas d’usage multilocataire avec plusieurs acteurs : utilisateurs, développeurs et administrateurs des entreprises fictives Contoso et Fabrikam. Dans ce cas d’usage, Contoso est une société qui crée une solution SaaS (software as a service) pour Fabrikam.
Les sections suivantes vous guident tout au long des étapes destinées aux administrateurs, développeurs et utilisateurs. Les diagrammes illustrent le cas d’usage mutualisé. Si vous utilisez un seul locataire, exécutez toutes les étapes de Contoso et de Fabrikam dans un seul locataire.
Actions de l’administrateur
Le rôle Administrateur dispose d’autorisations étendues dans Microsoft Entra ID. Les membres de ce rôle peuvent configurer des ressources et lire des informations à partir du portail Azure. Dans le diagramme suivant, vous pouvez voir toutes les actions qui doivent être exécutées par les administrateurs.
- L’administrateur Contoso crée ou sélectionne une application existante dans Microsoft Entra ID. La propriété Types de comptes pris en charge définit si les utilisateurs de différents locataires peuvent s’authentifier auprès de l’application. La propriété URI de redirection redirige une demande d’authentification réussie vers le serveur Contoso.
- L’administrateur Contoso ajoute des autorisations d’API à
Teams.ManageCallsetTeams.ManageChatsà partir de Communication Services. - L’administrateur Contoso autorise le flux client public pour l’application.
- L’administrateur Contoso crée ou sélectionne des services de communication existants, destinés à être utilisés pour l’authentification des demandes d’échange. Les jetons utilisateur Microsoft Entra sont échangés contre des jetons d’accès d’utilisateurs Teams. Pour plus d’informations, consultez Créer et gérer des ressources Communication Services.
- L’administrateur Fabrikam accorde les autorisations
Teams.ManageCallsetTeams.ManageChatsde Communication Services à l’application Contoso. Cette étape est requise si seul l’administrateur Fabrikam peut accorder l’accès à l’application avec les autorisationsTeams.ManageCallsetTeams.ManageChats.
Étape 1 : créer une inscription d’application Microsoft Entra ou sélectionner une application Microsoft Entra
Les utilisateurs doivent être authentifiés auprès des applications Microsoft Entra avec les autorisations Teams.ManageCalls et Teams.ManageChats d’Azure Communication Services. Si vous ne disposez pas d’une application que vous souhaitez utiliser pour ce guide de démarrage rapide, vous pouvez créer une inscription d’application.
Les paramètres d’application suivants influent sur l’expérience :
- La propriété Types de comptes pris en charge définit si l’application est monolocataire (« comptes au sein de cet annuaire organisationnel uniquement ») ou multilocataire (« comptes au sein de n’importe quel annuaire organisationnel »). Pour ce scénario, vous pouvez utiliser une configuration multilocataire.
- URI de redirection définit l’URI où la demande d’authentification est redirigée après authentification. Pour ce scénario, vous pouvez utiliser Client public/natif (mobile et bureau) et entrer
http://localhostcomme URI.
Pour des informations plus détaillées, consultez Inscrire une application auprès de la plateforme d’identités Microsoft.
Quand l’application est inscrite, un identificateur s’affiche dans la vue d’ensemble. Cet identificateur, ID d’application (client), est utilisé dans les étapes suivantes.
Étape 2 : Autoriser les flux clients publics
Dans le volet Authentification de votre application, vous pouvez voir une plateforme configurée pour le Client public/natif (mobile et bureau) avec l’URI de redirection pointant vers http://localhost. En bas du volet se trouve un bouton bascule Autoriser les flux clients publics, qui, pour ce guide démarrage rapide, doit être défini sur Oui.
Étape 3 : Ajouter les autorisations Communication Services dans l’application
L’application doit déclarer les autorisations Teams.ManageCalls et Teams.ManageChats pour avoir accès aux fonctionnalités d’appel Teams dans le locataire. L’utilisateur Teams demande un jeton d’utilisateur Microsoft Entra avec cette autorisation pour l’échange de jetons.
- Accéder à votre application Microsoft Entra dans le Portail Azure et sélectionnez Autorisations d’API
- Sélectionnez Ajouter des autorisations.
- Dans le menu Ajouter des autorisations, sélectionnez Azure Communication Services
- Sélectionnez les autorisations Teams.ManageCalls et Teams.ManageChats, puis Ajouter des autorisations
Étape 4 : Créer ou sélectionner une ressource Communication Services
Votre ressource Communication Services est utilisée pour authentifier toutes les demandes d’échange de jetons utilisateur Microsoft Entra contre des jetons d’accès d’utilisateurs Teams. Vous pouvez déclencher cet échange avec le SDK Communication Services Identity, que vous pouvez authentifier avec une clé d’accès ou en utilisant le contrôle d’accès en fonction du rôle (RBAC) Azure. Vous pouvez récupérer la clé d’accès dans le portail Azure ou en configurant Azure RBAC dans le volet Contrôle d’accès (IAM) par la ressource Communication Services.
Si vous souhaitez créer une ressource Communication Services, consultez Créer et gérer des ressources Communication Services.
Étape 5 : Fournir le consentement de l’administrateur
Le locataire Microsoft Entra peut être configuré pour exiger le consentement de l’administrateur Microsoft Entra pour les autorisations Teams.ManageCalls et Teams.ManageChats de l’application. Dans ce cas, l’administrateur Microsoft Entra doit accorder à l’application Contoso les autorisations Teams.ManageCalls et Teams.ManageChats de Communication Services. L’administrateur Fabrikam Microsoft Entra fournit le consentement via une URL unique.
Les rôles suivants peuvent donner un consentement au nom d’une entreprise :
- Administrateur général
- Administrateur d’application
- Administrateur d’application cloud
Si vous souhaitez vérifier les rôles dans portail Azure, consultez Répertorier les attributions de rôles Azure.
Pour construire une URL de consentement d’administrateur, l’administrateur Microsoft Entra Fabrikam effectue les étapes suivantes :
- Dans l’URL https://login.microsoftonline.com/{Tenant_ID}/adminconsent?client_id={Application_ID} l’administrateur remplace {Tenant_ID} par l’ID du locataire Fabrikam et remplace {Application_ID} par l’ID de l’application Contoso.
- L’administrateur se connecte et accorde des autorisations pour le compte de l’organisation.
Dans le locataire Fabrikam, le principal de service de l’application Contoso est créé si le consentement est accordé. L’administrateur Fabrikam peut examiner le consentement dans Microsoft Entra en procédant comme suit :
- Connectez-vous au portail Azure en tant qu’administrateur.
- Rendez-vous sur Microsoft Entra ID.
- Dans le volet Applications d’entreprise, définissez le filtre Type d’application sur Toutes les applications.
- Dans le champ de filtrage des applications, entrez le nom de l’application Contoso.
- Sélectionnez Appliquer.
- Sélectionnez le principal de service en utilisant le nom requis.
- Accédez au volet Autorisations.
Vous pouvez voir que l’état des autorisations Teams.ManageCalls et Teams.ManageChats de Communication Services est Accordé pour {Nom_annuaire}.
Si vous rencontrez le problème « L’application tente d’accéder à un service « 1fd5118e-2576-4263-8130-9503064c837a » (Azure Communication Services) pour lequel votre organisation « {GUID} » n’a pas de principal de service. Contactez votre administrateur informatique pour passer en revue la configuration de vos abonnements au service ou donner votre consentement à l’application pour créer le principal de service requis. Votre locataire Microsoft Entra ne dispose pas d’un principal de service pour l’application Azure Communication Services. Pour résoudre ce problème, utilisez PowerShell en tant qu’administrateur Microsoft Entra pour vous connecter à votre locataire. Remplacez Tenant_ID par un ID de votre location Microsoft Entra.
Vous aurez besoin de l’autorisation Application.ReadWrite.All, comme indiqué ci-dessous.
Connect-MgGraph -TenantId "Tenant_ID" -Scopes Application.ReadWrite.All
Si la commande est introuvable, démarrez PowerShell en tant qu’administrateur et installez le package Microsoft Graph.
Install-Module Microsoft.Graph
Exécutez ensuite la commande suivante pour ajouter un principal de service à votre locataire. Ne modifiez pas le GUID de l’ID d’application.
New-MgServicePrincipal -AppId "1fd5118e-2576-4263-8130-9503064c837a"
Actions du développeur
Le développeur Contoso doit configurer l’application cliente pour authentifier les utilisateurs. Le développeur doit ensuite créer un point de terminaison sur le serveur backend afin de traiter le jeton utilisateur Microsoft Entra après la redirection. Une fois reçu, le jeton utilisateur Microsoft Entra est échangé contre le jeton d’accès d’utilisateur Teams et retourné à l’application cliente.
Les actions requises du développeur sont présentées dans le diagramme suivant :
- Le développeur Contoso configure la Bibliothèque d’authentification Microsoft (MSAL) pour authentifier l’utilisateur de l’application créée précédemment par l’administrateur pour les autorisations Teams.ManageCalls et Teams.ManageChats de Communication Services.
- Le développeur Contoso initialise le kit SDK d’identité Communication Services et échange le jeton utilisateur Microsoft Entra entrant contre le jeton d’accès d’utilisateur Teams par le biais du kit SDK d’identité. Le jeton d’accès d’utilisateur Teams est ensuite retourné à l’application cliente.
Avec la bibliothèque d’authentification Microsoft (MSAL), les développeurs peuvent acquérir des jetons utilisateur Microsoft Entra à partir du point de terminaison de la plateforme d’identités Microsoft afin d’authentifier les utilisateurs et d’accéder aux API web sécurisées. Elle peut être utilisée pour fournir un accès sécurisé à Communication Services. La bibliothèque MSAL prend en charge de nombreuses architectures et plateformes d’application différentes, notamment .NET, JavaScript, Java, Python, Android et iOS.
Pour plus d’informations sur la configuration des environnements dans la documentation publique, consultez Vue d’ensemble de la bibliothèque d’authentification Microsoft.
Remarque
Les sections suivantes décrivent comment échanger le jeton d’accès Microsoft Entra contre le jeton d’accès d’utilisateur Teams pour l’application de console.
Configurer les prérequis
- Dernière version du SDK .NET pour votre système d’exploitation.
Code final
Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.
Configurer
Créer une application C#
Dans une fenêtre de console (par exemple cmd, PowerShell ou Bash), utilisez la commande dotnet new pour créer une application console avec le nom CommunicationAccessTokensQuickstart. Cette commande crée un projet C# « Hello World » simple avec un seul fichier source : Program.cs.
dotnet new console -o CommunicationAccessTokensQuickstart
Remplacez votre répertoire par le dossier d’application que vous venez de créer, puis utilisez la commande dotnet build pour compiler votre application.
cd CommunicationAccessTokensQuickstart
dotnet build
Installer le package
Alors que vous êtes toujours dans le répertoire de l’application, installez le package de la bibliothèque Azure Communication Services Identity pour .NET à l’aide de la commande dotnet add package.
dotnet add package Azure.Communication.Identity
dotnet add package Microsoft.Identity.Client
Configurer le framework d’application
À partir du répertoire de projet :
- Ouvrez le fichier Program.cs dans un éditeur de texte
- Ajoutez une directive
usingpour inclure l’espace de nomsAzure.Communication.Identity - Mettez à jour la déclaration de méthode
Mainpour prendre en charge le code asynchrone
Utilisez le code suivant pour commencer :
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.Communication.Identity;
using Microsoft.Identity.Client;
namespace CommunicationAccessTokensQuickstart
{
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("Azure Communication Services - Teams Access Tokens Quickstart");
// Quickstart code goes here
}
}
}
Étape 1 : obtenir le jeton utilisateur Microsoft Entra et l’ID d’objet via la bibliothèque MSAL
La première étape du flux d’échange de jetons consiste à obtenir un jeton pour votre utilisateur Teams à l’aide de Microsoft.Identity.Client. Le code ci-dessous récupère l’ID client Microsoft Entra et l’ID de locataire à partir de variables d’environnement nommées AAD_CLIENT_ID et AAD_TENANT_ID. Il est essentiel de configurer le client MSAL avec l’autorité appropriée, à partir de la variable d’environnement AAD_TENANT_ID, pour pouvoir récupérer la revendication de l’ID d’objet (oid) correspondant à un utilisateur dans le locataire de Fabrikam, et initialiser la variable userObjectId.
// This code demonstrates how to fetch an AAD client ID and tenant ID
// from an environment variable.
string appId = Environment.GetEnvironmentVariable("AAD_CLIENT_ID");
string tenantId = Environment.GetEnvironmentVariable("AAD_TENANT_ID");
string authority = $"https://login.microsoftonline.com/{tenantId}";
string redirectUri = "http://localhost";
// Create an instance of PublicClientApplication
var aadClient = PublicClientApplicationBuilder
.Create(appId)
.WithAuthority(authority)
.WithRedirectUri(redirectUri)
.Build();
List<string> scopes = new() {
"https://auth.msft.communication.azure.com/Teams.ManageCalls",
"https://auth.msft.communication.azure.com/Teams.ManageChats"
};
// Retrieve the AAD token and object ID of a Teams user
var result = await aadClient
.AcquireTokenInteractive(scopes)
.ExecuteAsync();
string teamsUserAadToken = result.AccessToken;
string userObjectId = result.UniqueId;
Étape 2 : Initialiser CommunicationIdentityClient
Initialisez un CommunicationIdentityClient avec votre chaîne de connexion. Le code ci-dessous récupère la chaîne de connexion de la ressource à partir d’une variable d’environnement nommée COMMUNICATION_SERVICES_CONNECTION_STRING. Découvrez comment gérer la chaîne de connexion de la ressource.
Ajoutez le code suivant à la méthode Main :
// This code demonstrates how to fetch your connection string
// from an environment variable.
string connectionString = Environment.GetEnvironmentVariable("COMMUNICATION_SERVICES_CONNECTION_STRING");
var client = new CommunicationIdentityClient(connectionString);
Étape 3 : échanger le jeton d’accès Microsoft Entra de l’utilisateur Teams contre un jeton d’accès d’identité Communication
Utilisez la méthode GetTokenForTeamsUser afin d’émettre, pour l’utilisateur Teams, un jeton d’accès qui peut être utilisé avec les SDK Azure Communication Services.
var options = new GetTokenForTeamsUserOptions(teamsUserAadToken, appId, userObjectId);
var accessToken = await client.GetTokenForTeamsUserAsync(options);
Console.WriteLine($"Token: {accessToken.Value.Token}");
Exécuter le code
Exécutez l’application à partir de votre répertoire d’application avec la commande dotnet run.
dotnet run
Configurer les prérequis
- Node.js versions Active LTS et Maintenance LTS (8.11.1 et 10.14.1 recommandées).
Code final
Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.
Configurer
Créer une application Node.js
Ouvrez votre fenêtre de terminal ou de commande, créez un répertoire pour votre application, puis accédez-y.
mkdir communication-access-tokens-quickstart && cd communication-access-tokens-quickstart
Exécutez npm init -y pour créer un fichier package.json avec les paramètres par défaut.
npm init -y
Installer le package
Utilisez la commande npm install pour installer le kit de développement logiciel (SDK) Azure Communication Services Identity pour JavaScript.
npm install @azure/communication-identity@latest --save
npm install @azure/msal-node --save
npm install express --save
npm install dotenv --save
L’option --save liste la bibliothèque comme dépendance dans votre fichier package.json.
Configurer le framework d’application
À partir du répertoire de projet :
Ouvrez un nouveau fichier texte dans votre éditeur de code
Ajoutez un appel
requirepour chargerCommunicationIdentityClientCréer la structure du programme, y compris la gestion des exceptions de base
const { CommunicationIdentityClient } = require('@azure/communication-identity'); const { PublicClientApplication, CryptoProvider } = require('@azure/msal-node'); const express = require("express"); // You will need to set environment variables in .env const SERVER_PORT = process.env.PORT || 80; const REDIRECT_URI = `http://localhost:${SERVER_PORT}/redirect`; const clientId = process.env['AAD_CLIENT_ID']; const tenantId = process.env['AAD_TENANT_ID']; // Quickstart code goes here app.listen(SERVER_PORT, () => console.log(`Communication access token application started on ${SERVER_PORT}!`))Enregistrez le nouveau fichier sous
issue-communication-access-token.jsdans le répertoireaccess-tokens-quickstart.
Étape 1 : obtenir le jeton utilisateur Microsoft Entra et l’ID d’objet via la bibliothèque MSAL
La première étape du flux d’échange de jetons consiste à obtenir un jeton pour votre utilisateur Teams à l’aide de Microsoft.Identity.Client. Le code ci-dessous récupère l’ID client Microsoft Entra et l’ID de locataire à partir de variables d’environnement nommées AAD_CLIENT_ID et AAD_TENANT_ID. Il est essentiel de configurer le client MSAL avec l’autorité appropriée, à partir de la variable d’environnement AAD_TENANT_ID, pour pouvoir récupérer la revendication de l’ID d’objet (oid) correspondant à un utilisateur dans le locataire de Fabrikam, et initialiser la variable userObjectId.
// Create configuration object that will be passed to MSAL instance on creation.
const msalConfig = {
auth: {
clientId: clientId,
authority: `https://login.microsoftonline.com/${tenantId}`,
}
};
// Create an instance of PublicClientApplication
const pca = new PublicClientApplication(msalConfig);
const provider = new CryptoProvider();
const app = express();
let pkceVerifier = "";
const scopes = [
"https://auth.msft.communication.azure.com/Teams.ManageCalls",
"https://auth.msft.communication.azure.com/Teams.ManageChats"
];
app.get('/', async (req, res) => {
// Generate PKCE Codes before starting the authorization flow
const {verifier, challenge} = await provider.generatePkceCodes();
pkceVerifier = verifier;
const authCodeUrlParameters = {
scopes: scopes,
redirectUri: REDIRECT_URI,
codeChallenge: challenge,
codeChallengeMethod: "S256"
};
// Get url to sign user in and consent to scopes needed for application
pca.getAuthCodeUrl(authCodeUrlParameters).then((response) => {
res.redirect(response);
}).catch((error) => console.log(JSON.stringify(error)));
});
app.get('/redirect', async (req, res) => {
// Create request parameters object for acquiring the AAD token and object ID of a Teams user
const tokenRequest = {
code: req.query.code,
scopes: scopes,
redirectUri: REDIRECT_URI,
codeVerifier: pkceVerifier,
};
// Retrieve the AAD token and object ID of a Teams user
pca.acquireTokenByCode(tokenRequest).then(async(response) => {
console.log("Response:", response);
let teamsUserAadToken = response.accessToken;
let userObjectId = response.uniqueId;
//TODO: the following code snippets go here
res.sendStatus(200);
}).catch((error) => {
console.log(error);
res.status(500).send(error);
});
});
Étape 2 : Initialiser CommunicationIdentityClient
Instanciez un CommunicationIdentityClient avec votre chaîne de connexion. Le code ci-dessous récupère la chaîne de connexion de la ressource à partir d’une variable d’environnement nommée COMMUNICATION_SERVICES_CONNECTION_STRING. Découvrez comment gérer la chaîne de connexion de la ressource.
Ajoutez le code suivant à la méthode then :
// This code demonstrates how to fetch your connection string
// from an environment variable.
const connectionString = process.env['COMMUNICATION_SERVICES_CONNECTION_STRING'];
// Instantiate the identity client
const identityClient = new CommunicationIdentityClient(connectionString);
Étape 3 : échanger le jeton d’accès Microsoft Entra de l’utilisateur Teams contre un jeton d’accès d’identité Communication
Utilisez la méthode getTokenForTeamsUser afin d’émettre, pour l’utilisateur Teams, un jeton d’accès qui peut être utilisé avec les SDK Azure Communication Services.
//Exchange the Azure AD access token of the Teams User for a Communication Identity access token
let accessToken = await identityClient.getTokenForTeamsUser({
teamsUserAadToken: teamsUserAadToken,
clientId: clientId,
userObjectId: userObjectId,
});
console.log("Token:", accessToken);
Exécuter le code
À partir d’une invite de console, accédez au répertoire contenant le fichier issue-communication-access-token.js, puis exécutez la commande node suivante pour exécuter l’application.
node ./issue-communication-access-token.js
Configurer les prérequis
- Python 3.8+.
Code final
Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.
Configurer
Créer une application Python
Ouvrez votre fenêtre de terminal ou de commande, créez un répertoire pour votre application, puis accédez-y.
mkdir communication-access-tokens-quickstart && cd communication-access-tokens-quickstartUtilisez un éditeur de texte pour créer un fichier appelé
exchange-communication-access-tokens.pydans le répertoire racine du projet, puis ajoutez la structure du programme, notamment la gestion des exceptions de base. Dans les sections suivantes, vous ajouterez l’ensemble du code source de ce guide de démarrage rapide dans ce fichier.import os from azure.communication.identity import CommunicationIdentityClient, CommunicationUserIdentifier from msal.application import PublicClientApplication try: print("Azure Communication Services - Access Tokens Quickstart") # Quickstart code goes here except Exception as ex: print(f"Exception: {ex}")
Installer le package
Toujours dans le répertoire de l’application, installez le package du kit de développement logiciel (SDK) Azure Communication Services Identity pour Python à l’aide de la commande pip install.
pip install azure-communication-identity
pip install msal
Étape 1 : obtenir le jeton utilisateur Microsoft Entra et l’ID d’objet via la bibliothèque MSAL
La première étape du flux d’échange de jetons consiste à obtenir un jeton pour votre utilisateur Teams à l’aide de Microsoft.Identity.Client. Dans le portail Azure, configurez l’URI de redirection de votre « Application mobile et de bureau » en tant que http://localhost. Le code ci-dessous récupère l’ID client Microsoft Entra et l’ID de locataire à partir de variables d’environnement nommées AAD_CLIENT_ID et AAD_TENANT_ID. Il est essentiel de configurer le client MSAL avec l’autorité appropriée, à partir de la variable d’environnement AAD_TENANT_ID, pour pouvoir récupérer la revendication de l’ID d’objet (oid) correspondant à un utilisateur dans le locataire de Fabrikam, et initialiser la variable user_object_id.
# This code demonstrates how to fetch your Azure AD client ID and tenant ID
# from an environment variable.
client_id = os.environ["AAD_CLIENT_ID"]
tenant_id = os.environ["AAD_TENANT_ID"]
authority = "https://login.microsoftonline.com/%s" % tenant_id
# Create an instance of PublicClientApplication
app = PublicClientApplication(client_id, authority=authority)
scopes = [
"https://auth.msft.communication.azure.com/Teams.ManageCalls",
"https://auth.msft.communication.azure.com/Teams.ManageChats"
]
# Retrieve the AAD token and object ID of a Teams user
result = app.acquire_token_interactive(scopes)
aad_token = result["access_token"]
user_object_id = result["id_token_claims"]["oid"]
Étape 2 : Initialiser CommunicationIdentityClient
Instanciez un CommunicationIdentityClient avec votre chaîne de connexion. Le code ci-dessous récupère la chaîne de connexion de la ressource à partir d’une variable d’environnement nommée COMMUNICATION_SERVICES_CONNECTION_STRING. Découvrez comment gérer la chaîne de connexion de la ressource.
Ajoutez ce code dans le bloc try :
# This code demonstrates how to fetch your connection string
# from an environment variable.
connection_string = os.environ["COMMUNICATION_SERVICES_CONNECTION_STRING"]
# Instantiate the identity client
client = CommunicationIdentityClient.from_connection_string(connection_string)
Étape 3 : échanger le jeton d’accès Microsoft Entra de l’utilisateur Teams contre un jeton d’accès d’identité Communication
Utilisez la méthode get_token_for_teams_user afin d’émettre, pour l’utilisateur Teams, un jeton d’accès qui peut être utilisé avec les SDK Azure Communication Services.
# Exchange the Azure AD access token of the Teams User for a Communication Identity access token
token_result = client.get_token_for_teams_user(aad_token, client_id, user_object_id)
print("Token: " + token_result.token)
Exécuter le code
À partir d’une invite de console, accédez au répertoire contenant le fichier exchange-teams-access-tokens.py, puis exécutez la commande python suivante pour exécuter l’application.
python ./exchange-communication-access-tokens.py
Configurer les prérequis
- Java Development Kit (JDK) version 8 ou ultérieure.
- Apache Maven.
Code final
Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.
Configurer
Créer une application Java
Ouvrez votre fenêtre de terminal ou de commande. Accédez au répertoire dans lequel vous souhaitez créer votre application Java. Exécutez la commande ci-dessous pour générer le projet Java à partir du modèle maven-archetype-quickstart.
mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
Vous remarquerez que la tâche « generate » a créé un répertoire portant le même nom que l’artifactId. Sous ce répertoire, le répertoire src/main/java contient le code source du projet, le src/test/java directory contient la source de test et le fichier pom.xml est le modèle objet du projet (POM).
Installer le package
Ouvrez le fichier pom.xml dans votre éditeur de texte. Ajoutez les éléments de dépendance suivants au groupe de dépendances.
<dependencies>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-communication-identity</artifactId>
<version>[1.2.0,)</version>
</dependency>
<dependency>
<groupId>com.microsoft.azure</groupId>
<artifactId>msal4j</artifactId>
<version>1.11.0</version>
</dependency>
</dependencies>
Configurer le framework d’application
À partir du répertoire de projet :
- Accédez au répertoire
/src/main/java/com/communication/quickstart. - Ouvrez le fichier
App.javadans votre éditeur. - Remplacez l’instruction
System.out.println("Hello world!"); - Ajoutez des directives
import.
Utilisez le code suivant pour commencer :
package com.communication.quickstart;
import com.azure.communication.identity.CommunicationIdentityClient;
import com.azure.communication.identity.CommunicationIdentityClientBuilder;
import com.azure.communication.identity.models.GetTokenForTeamsUserOptions;
import com.azure.core.credential.AccessToken;
import com.microsoft.aad.msal4j.IAuthenticationResult;
import com.microsoft.aad.msal4j.InteractiveRequestParameters;
import com.microsoft.aad.msal4j.PublicClientApplication;
import java.net.URI;
import java.util.HashSet;
import java.util.Set;
public class App
{
public static void main( String[] args ) throws Exception
{
System.out.println("Azure Communication Services - Communication access token Quickstart");
// Quickstart code goes here
}
}
Étape 1 : obtenir le jeton utilisateur Microsoft Entra et l’ID d’objet via la bibliothèque MSAL
La première étape du flux d’échange de jetons consiste à obtenir un jeton pour votre utilisateur Teams à l’aide de Microsoft.Identity.Client. Il est essentiel de configurer le client MSAL avec l’autorité appropriée, à partir de la variable tenantId, pour pouvoir récupérer la revendication de l’ID d’objet (oid) correspondant à un utilisateur dans le locataire de Fabrikam, et initialiser la variable userObjectId.
// You need to provide your Azure AD client ID and tenant ID
String appId = "<contoso_application_id>";
String tenantId = "<contoso_tenant_id>";
String authority = "https://login.microsoftonline.com/" + tenantId;
// Create an instance of PublicClientApplication
PublicClientApplication pca = PublicClientApplication.builder(appId)
.authority(authority)
.build();
String redirectUri = "http://localhost";
Set<String> scope = new HashSet<String>();
scope.add("https://auth.msft.communication.azure.com/Teams.ManageCalls");
scope.add("https://auth.msft.communication.azure.com/Teams.ManageChats");
// Create an instance of InteractiveRequestParameters for acquiring the AAD token and object ID of a Teams user
InteractiveRequestParameters parameters = InteractiveRequestParameters
.builder(new URI(redirectUri))
.scopes(scope)
.build();
// Retrieve the AAD token and object ID of a Teams user
IAuthenticationResult result = pca.acquireToken(parameters).get();
String teamsUserAadToken = result.accessToken();
String[] accountIds = result.account().homeAccountId().split("\\.");
String userObjectId = accountIds[0];
System.out.println("Teams token: " + teamsUserAadToken);
Étape 2 : Initialiser CommunicationIdentityClient
Instanciez un CommunicationIdentityClient avec la clé d’accès et le point de terminaison de votre ressource. Découvrez comment gérer la chaîne de connexion de la ressource. En outre, vous pouvez initialiser le client avec n’importe quel client HTTP personnalisé qui implémente l’interface com.azure.core.http.HttpClient.
Ajoutez le code suivant à la méthode main :
//You can find your connection string from your resource in the Azure portal
String connectionString = "<connection_string>";
// Instantiate the identity client
CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClientBuilder()
.connectionString(connectionString)
.buildClient();
Étape 3 : échanger le jeton d’accès Microsoft Entra de l’utilisateur Teams contre un jeton d’accès d’identité Communication
Utilisez la méthode getTokenForTeamsUser afin d’émettre, pour l’utilisateur Teams, un jeton d’accès qui peut être utilisé avec les SDK Azure Communication Services.
// Exchange the Azure AD access token of the Teams User for a Communication Identity access token
GetTokenForTeamsUserOptions options = new GetTokenForTeamsUserOptions(teamsUserAadToken, appId, userObjectId);
var accessToken = communicationIdentityClient.getTokenForTeamsUser(options);
System.out.println("Token: " + accessToken.getToken());
Exécuter le code
Accédez au répertoire contenant le fichier pom.xml, puis compilez le projet à l’aide de la commande mvn compile.
Ensuite, générez le package.
mvn package
Exécutez la commande mvn suivante pour exécuter l’application.
mvn exec:java -Dexec.mainClass="com.communication.quickstart.App" -Dexec.cleanupDaemonThreads=false
Actions utilisateur
L’utilisateur représente les utilisateurs Fabrikam de l’application Contoso. L’expérience utilisateur est présentée dans le diagramme suivant :
- L’utilisateur Fabrikam utilise l’application cliente Contoso et est invité à s’authentifier.
- L’application cliente Contoso utilise MSAL pour authentifier l’utilisateur auprès du locataire Microsoft Entra Fabrikam pour l’application Contoso avec les autorisations Teams.ManageCalls et Teams.ManageChats de Communication Services.
- L’authentification est redirigée vers le serveur comme défini dans la propriété URI de redirection dans MSAL et l’application Contoso.
- Le serveur Contoso échange le jeton utilisateur Microsoft Entra contre le jeton d’accès d’utilisateur Teams en utilisant le kit SDK d’identité Communication Services et renvoie le jeton d’accès d’utilisateur Teams à l’application cliente.
Avec un jeton d’accès d’utilisateur Teams valide dans l’application cliente, les développeurs peuvent intégrer le SDK Communication Services Calling et gérer les appels en tant qu’utilisateur Teams.
Étapes suivantes
Dans ce démarrage rapide, vous avez appris comment :
- Créez et configurez une application dans Microsoft Entra ID.
- Utilisez la bibliothèque d’authentification Microsoft (MSAL) pour émettre un jeton utilisateur Microsoft Entra.
- Utiliser le kit SDK d’identité Communication Services pour échanger le jeton utilisateur Microsoft Entra contre un jeton d’accès d’utilisateur Teams.
Créer un service d’authentification approuvé pour les utilisateurs TeamsPasser un appel en tant qu’utilisateur Teams à un utilisateur Teams
Découvrez les concepts suivants :
- Cas d’usage pour la communication en tant qu’utilisateur Teams
- Azure Communication Services prend en charge les identités Teams
- Interopérabilité de Teams
- Authentification monolocataire et multilocataire pour les utilisateurs de Teams
- Créer et gérer des jetons d’accès de communication pour les utilisateurs Teams dans une application monopage (SPA)