Guia de início rápido: configurar e gerenciar tokens de acesso para usuários do Teams

Configurar pré-requisitos

• A versão mais recente do SDK do .NET para seu sistema operacional.

Código final

Encontre o código finalizado para este início rápido no GitHub.

Configurar

Criar um novo aplicativo C#

Em uma janela de console (como cmd, PowerShell ou Bash), use o dotnet new comando para criar um novo aplicativo de console com o nome CommunicationAccessTokensQuickstart. Este comando cria um projeto C# "Hello World" simples com um único arquivo de origem: Program.cs.

dotnet new console -o CommunicationAccessTokensQuickstart

Altere seu diretório para a pasta do aplicativo recém-criada e use o dotnet build comando para compilar seu aplicativo.

cd CommunicationAccessTokensQuickstart
dotnet build

Instalar o pacote

Enquanto ainda estiver no diretório do aplicativo, instale a biblioteca de Identidade dos Serviços de Comunicação do Azure para o pacote .NET usando o dotnet add package comando.

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

Configurar a estrutura do aplicativo

No diretório do projeto:

1. Abrir Program.cs arquivo em um editor de texto
2. Adicionar uma using diretiva para incluir o Azure.Communication.Identity namespace
3. Atualizar a declaração de método para suportar código assíncrono Main

Use o seguinte código para começar:

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

Etapa 1: Receber o token de usuário e a ID do objeto do Microsoft Entra por meio da biblioteca MSAL

A primeira etapa no fluxo de troca de tokens é obter um token para o usuário do Teams usando Microsoft.Identity.Client. O código abaixo recupera a ID do cliente Microsoft Entra e a ID do locatário das variáveis de ambiente chamadas AAD_CLIENT_ID e AAD_TENANT_ID. É essencial configurar o cliente MSAL com a autoridade correta, com base na AAD_TENANT_ID variável de ambiente, para poder recuperar a declaração de ID de objeto (oid) correspondente a um usuário no locatário da Fabrikam e inicializar a userObjectId variável.

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

Etapa 2: Inicializar o CommunicationIdentityClient

Inicialize um CommunicationIdentityClient com sua cadeia de conexão. O código abaixo recupera a cadeia de conexão para o recurso de uma variável de ambiente chamada COMMUNICATION_SERVICES_CONNECTION_STRING. Saiba como gerir a cadeia de ligação do seu recurso.

Adicione o seguinte código ao método 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);

Etapa 3: Trocar o token de acesso do Microsoft Entra do usuário do Teams por um token de acesso de identidade de comunicação

Use o GetTokenForTeamsUser método para emitir um token de acesso para o usuário do Teams que pode ser usado com os SDKs dos Serviços de Comunicação do Azure.

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

Executar o código

Execute o aplicativo a partir do diretório do aplicativo com o dotnet run comando.

dotnet run

Configurar pré-requisitos

• Node.js versões Ative LTS e Maintenance LTS (8.11.1 e 10.14.1 recomendadas).

Código final

Encontre o código finalizado para este início rápido no GitHub.

Configurar

Criar um novo aplicativo Node.js

Abra o terminal ou a janela de comando, crie um novo diretório para seu aplicativo e navegue até ele.

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

Execute npm init -y para criar um package.json arquivo com as configurações padrão.

npm init -y

Instalar o pacote

Use o npm install comando para instalar o SDK de Identidade dos Serviços de Comunicação do Azure para JavaScript.

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

A --save opção lista a biblioteca como uma dependência em seu arquivo package.json .

Configurar a estrutura do aplicativo

No diretório do projeto:

1. Abrir um novo arquivo de texto no editor de código

2. Adicionar uma require chamada para carregar o CommunicationIdentityClient

3. Criar a estrutura para o programa, incluindo o tratamento básico de exceções

   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. Salve o novo arquivo como issue-communication-access-token.js no access-tokens-quickstart diretório.

Etapa 1: Receber o token de usuário e a ID do objeto do Microsoft Entra por meio da biblioteca MSAL

A primeira etapa no fluxo de troca de tokens é obter um token para o usuário do Teams usando Microsoft.Identity.Client. O código abaixo recupera a ID do cliente Microsoft Entra e a ID do locatário das variáveis de ambiente chamadas AAD_CLIENT_ID e AAD_TENANT_ID. É essencial configurar o cliente MSAL com a autoridade correta, com base na AAD_TENANT_ID variável de ambiente, para poder recuperar a declaração de ID de objeto (oid) correspondente a um usuário no locatário da Fabrikam e inicializar a userObjectId variável.

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

Etapa 2: Inicializar o CommunicationIdentityClient

Instancie a CommunicationIdentityClient com sua cadeia de conexão. O código abaixo recupera a cadeia de conexão para o recurso de uma variável de ambiente chamada COMMUNICATION_SERVICES_CONNECTION_STRING. Saiba como gerir a cadeia de ligação do seu recurso.

Adicione o seguinte código ao método 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);

Etapa 3: Trocar o token de acesso do Microsoft Entra do usuário do Teams por um token de acesso de identidade de comunicação

Use o getTokenForTeamsUser método para emitir um token de acesso para o usuário do Teams que pode ser usado com os SDKs dos Serviços de Comunicação do 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);

Executar o código

Em um prompt do console, navegue até o diretório que contém o arquivo issue-communication-access-token.js e execute o seguinte node comando para executar o aplicativo.

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

Configurar pré-requisitos

• Python 3.8+.

Código final

Encontre o código finalizado para este início rápido no GitHub.

Configurar

Criar uma aplicação Python nova

1. Abra o terminal ou a janela de comando, crie um novo diretório para seu aplicativo e navegue até ele.

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

2. Use um editor de texto para criar um arquivo chamado exchange-communication-access-tokens.py no diretório raiz do projeto e adicionar a estrutura para o programa, incluindo o tratamento básico de exceções. Você adicionará todo o código-fonte deste início rápido a este arquivo nas seções a seguir.

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

Instalar o pacote

Enquanto ainda estiver no diretório do aplicativo, instale o pacote SDK de Identidade dos Serviços de Comunicação do Azure para Python usando o pip install comando.

pip install azure-communication-identity
pip install msal

Etapa 1: Receber o token de usuário e a ID do objeto do Microsoft Entra por meio da biblioteca MSAL

A primeira etapa no fluxo de troca de tokens é obter um token para o usuário do Teams usando Microsoft.Identity.Client. No portal do Azure, configure o URI de Redirecionamento do seu "Aplicativo móvel e de área de trabalho" como http://localhost. O código abaixo recupera a ID do cliente Microsoft Entra e a ID do locatário das variáveis de ambiente chamadas AAD_CLIENT_ID e AAD_TENANT_ID. É essencial configurar o cliente MSAL com a autoridade correta, com base na AAD_TENANT_ID variável de ambiente, para poder recuperar a declaração de ID de objeto (oid) correspondente a um usuário no locatário da Fabrikam e inicializar a user_object_id variável.

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

Etapa 2: Inicializar o CommunicationIdentityClient

Instancie a CommunicationIdentityClient com sua cadeia de conexão. O código abaixo recupera a cadeia de conexão para o recurso de uma variável de ambiente chamada COMMUNICATION_SERVICES_CONNECTION_STRING. Saiba como gerir a cadeia de ligação do seu recurso.

Adicione este código dentro do try bloco:

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

Etapa 3: Trocar o token de acesso do Microsoft Entra do usuário do Teams por um token de acesso de identidade de comunicação

Use o get_token_for_teams_user método para emitir um token de acesso para o usuário do Teams que pode ser usado com os SDKs dos Serviços de Comunicação do 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)

Executar o código

Em um prompt do console, navegue até o diretório que contém o arquivo exchange-teams-access-tokens.py e execute o seguinte python comando para executar o aplicativo.

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

Configurar pré-requisitos

• Java Development Kit (JDK) versão 8 ou superior.
• Apache Maven.

Código final

Encontre o código finalizado para este início rápido no GitHub.

Configurar

Criar uma nova aplicação Java

Abra o terminal ou a janela de comando. Navegue até o diretório onde você gostaria de criar seu aplicativo Java. Execute o comando abaixo para gerar o projeto Java a partir do maven-archetype-quickstart modelo.

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

Você notará que a tarefa 'gerar' criou um diretório com o mesmo nome do artifactId. Neste diretório, o src/main/java diretório contém o código-fonte do projeto, o src/test/java directory contém a fonte de teste e o pom.xml arquivo é o Project Object Model ou POM do projeto.

Instalar o pacote

Abra o arquivo no editor de pom.xml texto. Adicione os seguintes elementos de dependência ao grupo de dependências.

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

Configurar a estrutura do aplicativo

No diretório do projeto:

1. Navegue para o diretório /src/main/java/com/communication/quickstart
2. Abra o App.java arquivo no editor
3. Substitua a System.out.println("Hello world!"); instrução
4. Adicionar import diretivas

Use o seguinte código para começar:

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

Etapa 1: Receber o token de usuário e a ID do objeto do Microsoft Entra por meio da biblioteca MSAL

A primeira etapa no fluxo de troca de tokens é obter um token para o usuário do Teams usando Microsoft.Identity.Client. É essencial configurar o cliente MSAL com a autoridade correta, com base na tenantId variável, para poder recuperar a declaração de ID de objeto (oid) correspondente a um usuário no locatário da Fabrikam e inicializar a userObjectId variável.

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

Etapa 2: Inicializar o CommunicationIdentityClient

Instancie um CommunicationIdentityClient com a chave de acesso e o ponto de extremidade do seu recurso. Saiba como gerir a cadeia de ligação do seu recurso. Além disso, você pode inicializar o cliente com qualquer cliente HTTP personalizado que implementa a com.azure.core.http.HttpClient interface.

Adicione o seguinte código ao método 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();

Etapa 3: Trocar o token de acesso do Microsoft Entra do usuário do Teams por um token de acesso de identidade de comunicação

Use o getTokenForTeamsUser método para emitir um token de acesso para o usuário do Teams que pode ser usado com os SDKs dos Serviços de Comunicação do 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());

Executar o código

Navegue até o diretório que contém o pom.xml arquivo e compile o projeto usando o mvn compile comando.

Em seguida, compile o pacote.

mvn package

Execute o seguinte mvn comando para executar o aplicativo.

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