Guida introduttiva: Configurare e gestire i token di accesso per gli utenti di Teams

Configurare i prerequisiti

• Versione più recente di .NET SDK per il sistema operativo.

Codice finale

Trovare il codice finalizzato per questa guida introduttiva in GitHub.

Impostazione

Creare una nuova applicazione C#

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome CommunicationAccessTokensQuickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.

dotnet new console -o CommunicationAccessTokensQuickstart

Passare alla cartella dell'app appena creata e usare il comando dotnet build per compilare l'applicazione.

cd CommunicationAccessTokensQuickstart
dotnet build

Installare il pacchetto

Rimanendo nella directory dell'applicazione, installare il pacchetto della libreria di identità di Servizi di comunicazione di Azure per .NET usando il comando dotnet add package.

dotnet add package Azure.Communication.Identity
dotnet add package Microsoft.Identity.Client

Configurare il framework dell'app

Dalla directory del progetto:

1. Aprire il file Program.cs in un editor di testo
2. Aggiungere una direttiva using per includere lo spazio dei nomi Azure.Communication.Identity
3. Aggiornare la dichiarazione del metodo Main per supportare codice asincrono

Per iniziare, usare il codice seguente:

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
        }
    }
}

Passaggio 1: Ricevere il token utente e l'ID oggetto di Microsoft Entra tramite la libreria MSAL

Il primo passaggio del flusso di scambio di token consiste nel ottenere un token per l'utente di Teams usando Microsoft.Identity.Client. Il codice seguente recupera l'ID client e l'ID tenant di Microsoft Entra dalle variabili di ambiente denominate AAD_CLIENT_ID e AAD_TENANT_ID. È essenziale configurare il client MSAL con l'autorità corretta, in base alla AAD_TENANT_ID variabile di ambiente, per poter recuperare l'attestazione ID oggetto (oid) corrispondente a un utente nel tenant di Fabrikam e inizializzare la userObjectId variabile.

// 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;

Passaggio 2: Inizializzare CommunicationIdentityClient

Inizializzare CommunicationIdentityClient con la stringa di connessione. Il codice seguente recupera la stringa di connessione per la risorsa da una variabile di ambiente denominata COMMUNICATION_SERVICES_CONNECTION_STRING. Informazioni su come gestire la stringa di connessione della risorsa .

Aggiungere al metodo Main il codice seguente:

// 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);

Passaggio 3: Scambiare il token di accesso Microsoft Entra dell'utente di Teams per un token di accesso di identità di comunicazione

Usare il GetTokenForTeamsUser metodo per rilasciare un token di accesso per l'utente di Teams che può essere usato con gli SDK Servizi di comunicazione di Azure.

var options = new GetTokenForTeamsUserOptions(teamsUserAadToken, appId, userObjectId);
var accessToken = await client.GetTokenForTeamsUserAsync(options);
Console.WriteLine($"Token: {accessToken.Value.Token}");

Eseguire il codice

Eseguire l'applicazione dalla directory dell'applicazione con il comando dotnet run.

dotnet run

Configurare i prerequisiti

• Versioni di Active LTS e Maintenance LTS Node.js(versioni consigliate 8.11.1 e 10.14.1).

Codice finale

Trovare il codice finalizzato per questa guida introduttiva in GitHub.

Impostazione

Creare una nuova applicazione Node.js

Aprire il terminale o la finestra di comando per creare una nuova directory per l'app e passare a tale directory.

mkdir communication-access-tokens-quickstart && cd communication-access-tokens-quickstart

Eseguire npm init -y per creare un package.json file con le impostazioni predefinite.

npm init -y

Installare il pacchetto

Usare il npm install comando per installare Servizi di comunicazione di Azure Identity SDK per JavaScript.

npm install @azure/communication-identity@latest --save
npm install @azure/msal-node --save
npm install express --save
npm install dotenv --save

L'opzione --save elenca la libreria come dipendenza nel file package.json.

Configurare il framework dell'app

Dalla directory del progetto:

1. Aprire un nuovo file di testo nell'editor del codice

2. Aggiungere una chiamata di require per caricare CommunicationIdentityClient

3. Creare la struttura per il programma, inclusa la gestione delle eccezioni di 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}!`))
   
   

4. Salvare il nuovo file come issue-communication-access-token.js nella access-tokens-quickstart directory .

Passaggio 1: Ricevere il token utente e l'ID oggetto di Microsoft Entra tramite la libreria MSAL

Il primo passaggio del flusso di scambio di token consiste nel ottenere un token per l'utente di Teams usando Microsoft.Identity.Client. Il codice seguente recupera l'ID client e l'ID tenant di Microsoft Entra dalle variabili di ambiente denominate AAD_CLIENT_ID e AAD_TENANT_ID. È essenziale configurare il client MSAL con l'autorità corretta, in base alla AAD_TENANT_ID variabile di ambiente, per poter recuperare l'attestazione ID oggetto (oid) corrispondente a un utente nel tenant di Fabrikam e inizializzare la userObjectId variabile.

// 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);
    });
});

Passaggio 2: Inizializzare CommunicationIdentityClient

Creare un'istanza di CommunicationIdentityClient con la stringa di connessione. Il codice seguente recupera la stringa di connessione per la risorsa da una variabile di ambiente denominata COMMUNICATION_SERVICES_CONNECTION_STRING. Informazioni su come gestire la stringa di connessione della risorsa .

Aggiungere al metodo then il codice seguente:

// 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);

Passaggio 3: Scambiare il token di accesso Microsoft Entra dell'utente di Teams per un token di accesso di identità di comunicazione

Usare il getTokenForTeamsUser metodo per rilasciare un token di accesso per l'utente di Teams che può essere usato con gli SDK Servizi di comunicazione di Azure.

//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);

Eseguire il codice

Da un prompt della console passare alla directory contenente il file issue-communication-access-token.js , quindi eseguire il comando seguente node per eseguire l'app.

node ./issue-communication-access-token.js

Configurare i prerequisiti

• Python 3.8+.

Codice finale

Trovare il codice finalizzato per questa guida introduttiva in GitHub.

Impostazione

Creare una nuova applicazione Python

1. Aprire il terminale o la finestra di comando per creare una nuova directory per l'app e passare a tale directory.

   mkdir communication-access-tokens-quickstart && cd communication-access-tokens-quickstart
   

2. Usare un editor di testo per creare un file denominato exchange-communication-access-tokens.py nella directory radice del progetto e aggiungere la struttura per il programma, inclusa la gestione delle eccezioni di base. Tutto il codice sorgente per questa guida di avvio rapido verrà aggiunto a questo file nelle sezioni riportate di seguito.

   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}")
   

Installare il pacchetto

Nella directory dell'applicazione installare il pacchetto Servizi di comunicazione di Azure Identity SDK per Python usando il pip install comando .

pip install azure-communication-identity
pip install msal

Passaggio 1: Ricevere il token utente e l'ID oggetto di Microsoft Entra tramite la libreria MSAL

Il primo passaggio del flusso di scambio di token consiste nel ottenere un token per l'utente di Teams usando Microsoft.Identity.Client. In portale di Azure configurare l'URI di reindirizzamento dell'applicazione "Mobile and Desktop" come http://localhost. Il codice seguente recupera l'ID client e l'ID tenant di Microsoft Entra dalle variabili di ambiente denominate AAD_CLIENT_ID e AAD_TENANT_ID. È essenziale configurare il client MSAL con l'autorità corretta, in base alla AAD_TENANT_ID variabile di ambiente, per poter recuperare l'attestazione ID oggetto (oid) corrispondente a un utente nel tenant di Fabrikam e inizializzare la user_object_id variabile.

# 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"] 

Passaggio 2: Inizializzare CommunicationIdentityClient

Creare un'istanza di CommunicationIdentityClient con la stringa di connessione. Il codice seguente recupera la stringa di connessione per la risorsa da una variabile di ambiente denominata COMMUNICATION_SERVICES_CONNECTION_STRING. Informazioni su come gestire la stringa di connessione della risorsa .

Aggiungere questo codice all'interno del blocco 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)

Passaggio 3: Scambiare il token di accesso Microsoft Entra dell'utente di Teams per un token di accesso di identità di comunicazione

Usare il get_token_for_teams_user metodo per rilasciare un token di accesso per l'utente di Teams che può essere usato con gli SDK Servizi di comunicazione di Azure.

# 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)

Eseguire il codice

Da un prompt della console passare alla directory contenente il file exchange-teams-access-tokens.py , quindi eseguire il comando seguente python per eseguire l'app.

python ./exchange-communication-access-tokens.py

Configurare i prerequisiti

• Java Development Kit (JDK) versione 8 o successiva.
• Apache Maven.

Codice finale

Trovare il codice finalizzato per questa guida introduttiva in GitHub.

Impostazione

Creare una nuova applicazione Java

Aprire la finestra del terminale o di comando. Passare alla directory in cui creare l'applicazione Java. Eseguire il comando seguente per generare il progetto Java dal maven-archetype-quickstart modello.

mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

Si noterà che l'attività 'generate' ha creato una directory con lo stesso nome di artifactId. In questa directory la src/main/java directory contiene il codice sorgente del progetto, src/test/java directory contiene l'origine di test e il pom.xml file è il modello a oggetti del progetto o POM.

Installare il pacchetto

Aprire il file pom.xml nell'editor di testo. Aggiungere gli elementi di dipendenza seguenti al gruppo di dipendenze.

<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>

Configurare il framework dell'app

Dalla directory del progetto:

1. Passare alla directory /src/main/java/com/communication/quickstart
2. Aprire il file App.java nell'editor
3. Sostituire l'istruzione System.out.println("Hello world!");
4. Aggiungere le direttive import

Per iniziare, usare il codice seguente:

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
    }
}

Passaggio 1: Ricevere il token utente e l'ID oggetto di Microsoft Entra tramite la libreria MSAL

Il primo passaggio del flusso di scambio di token consiste nel ottenere un token per l'utente di Teams usando Microsoft.Identity.Client. È essenziale configurare il client MSAL con l'autorità corretta, in base alla tenantId variabile, per poter recuperare l'attestazione OBJECT ID (oid) corrispondente a un utente nel tenant di Fabrikam e inizializzare la userObjectId variabile.

// 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);

Passaggio 2: Inizializzare CommunicationIdentityClient

Creare un'istanza di CommunicationIdentityClient con l'endpoint e la chiave di accesso della risorsa. Informazioni su come gestire la stringa di connessione della risorsa . Inoltre, è possibile inizializzare il client con qualsiasi client HTTP personalizzato che implementa l'interfaccia com.azure.core.http.HttpClient .

Aggiungere al metodo main il codice seguente:

//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();

Passaggio 3: Scambiare il token di accesso Microsoft Entra dell'utente di Teams per un token di accesso di identità di comunicazione

Usare il getTokenForTeamsUser metodo per rilasciare un token di accesso per l'utente di Teams che può essere usato con gli SDK Servizi di comunicazione di Azure.

// 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());

Eseguire il codice

Passare alla directory contenente il pom.xml file e compilare il progetto usando il mvn compile comando .

Compilare il pacchetto.

mvn package

Eseguire il comando mvn seguente per eseguire l'app.

mvn exec:java -Dexec.mainClass="com.communication.quickstart.App" -Dexec.cleanupDaemonThreads=false