Snabbstart: Konfigurera och hantera åtkomsttoken för Teams-användare
I den här snabbstarten skapar du ett .NET-konsolprogram för att autentisera en Microsoft 365-användare med hjälp av Microsoft Authentication Library (MSAL) och hämtar en Microsoft Entra-användartoken. Sedan byter du ut den token mot en åtkomsttoken för Teams-användare med Azure Communication Services Identity SDK. Åtkomsttoken för Teams-användare kan sedan användas av Communication Services Calling SDK för att integrera samtalsfunktionen som Teams-användare.
Kommentar
När du är i en produktionsmiljö rekommenderar vi att du implementerar den här exchange-mekanismen i serverdelstjänster, eftersom begäranden om ett utbyte signeras med en hemlighet.
Förutsättningar
- Ett Azure-konto med en aktiv prenumeration. Skapa ett konto utan kostnad.
- En aktiv Azure Communication Services-resurs och anslutningssträng. Mer information finns i Skapa en Azure Communication Services-resurs.
- En Microsoft Entra-instans med användare som har en Teams-licens. Mer information finns i Licenskrav för Teams.
Introduktion
Teams-identiteter är bundna till klientorganisationer i Microsoft Entra-ID. Ditt program kan användas av användare från samma eller en annan klientorganisation. I den här snabbstarten går du igenom ett användningsfall för flera klientorganisationer med flera aktörer: användare, utvecklare och administratörer från fiktiva företag Contoso och Fabrikam. I det här användningsfallet är Contoso ett företag som skapar programvara som en tjänst (SaaS) för Fabrikam.
Följande avsnitt vägleder dig genom stegen för administratörer, utvecklare och användare. Diagrammen visar användningsfallet för flera klientorganisationer. Om du arbetar med en enda klientorganisation kör du alla steg från Contoso och Fabrikam i en enda klientorganisation.
Administratörsåtgärder
Administratörsrollen har utökade behörigheter i Microsoft Entra-ID. Medlemmar i den här rollen kan konfigurera resurser och kan läsa information från Azure-portalen. I följande diagram kan du se alla åtgärder som måste utföras av administratörer.
- Contoso-administratören skapar eller väljer ett befintligt program i Microsoft Entra-ID. Kontotyper som stöds för egenskapen definierar om användare från olika klienter kan autentisera till programmet. Egenskapen Redirect URI omdirigerar en lyckad autentiseringsbegäran till Contoso-servern.
- Contoso-administratören lägger till API-behörigheter till
Teams.ManageCallsochTeams.ManageChatsfrån Communication Services. - Contoso-administratören tillåter offentligt klientflöde för programmet.
- Contoso-administratören skapar eller väljer befintliga kommunikationstjänster, som ska användas för autentisering av utbytesbegäranden. Microsoft Entra-användartoken byts ut mot en åtkomsttoken för Teams-användare. Mer information finns i Skapa och hantera Communication Services-resurser.
- Fabrikam-administratören beviljar Kommunikationstjänster
Teams.ManageCallsochTeams.ManageChatsbehörigheter till Contoso-programmet. Det här steget krävs om endast Fabrikam-administratören kan bevilja åtkomst till programmet med behörigheternaTeams.ManageCallsochTeams.ManageChats.
Steg 1: Skapa en Microsoft Entra-programregistrering eller välj ett Microsoft Entra-program
Användare måste autentiseras mot Microsoft Entra-program med behörigheterna Azure Communication Service Teams.ManageCalls och Teams.ManageChats. Om du inte har ett befintligt program som du vill använda för den här snabbstarten kan du skapa en ny programregistrering.
Följande programinställningar påverkar upplevelsen:
- Egenskapen Kontotyper som stöds definierar om programmet är en enskild klientorganisation ("Endast konton i den här organisationskatalogen") eller multitenant ("Konton i en organisationskatalog"). I det här scenariot kan du använda multitenant.
- Omdirigerings-URI definierar den URI där autentiseringsbegäran omdirigeras efter autentisering. I det här scenariot kan du använda offentlig klient/intern (mobil och stationär dator) och ange
http://localhostsom URI.
Mer detaljerad information finns i Registrera ett program med Microsofts identitetsplattform.
När programmet har registrerats visas en identifierare i översikten. Den här identifieraren, program-ID (klient)-ID, används i nästa steg.
Steg 2: Tillåt offentliga klientflöden
I fönstret Autentisering i ditt program kan du se en konfigurerad plattform för offentlig klient/intern (mobil och skrivbord) med en omdirigerings-URI som pekar på http://localhost. Längst ned i fönstret visas växlingsknappen Tillåt offentliga klientflöden , som för den här snabbstarten ska vara inställd på Ja.
Steg 3: Lägg till Behörigheter för Kommunikationstjänster i programmet
Programmet måste deklarera Teams.ManageCalls- och Teams.ManageChats-behörigheter för att ha åtkomst till Teams-samtalsfunktioner i klientorganisationen. Teams-användare begär en Microsoft Entra-användartoken med den här behörigheten för tokenutbyte.
- Gå till Din Microsoft Entra-app i Azure-portalen och välj API-behörigheter
- Välj Lägg till behörigheter
- I menyn Lägg till behörigheter väljer du Azure Communication Services
- Välj behörigheterna Teams.ManageCalls och Teams.ManageChats och välj sedan Lägg till behörigheter
Steg 4: Skapa eller välj en Communication Services-resurs
Din Communication Services-resurs används för att autentisera alla begäranden om utbyte av Microsoft Entra-användartoken mot en åtkomsttoken för Teams-användare. Du kan utlösa det här utbytet med hjälp av Communication Services Identity SDK, som du kan autentisera med en åtkomstnyckel, eller med hjälp av rollbaserad åtkomstkontroll i Azure (Azure RBAC). Du kan hämta åtkomstnyckeln antingen i Azure-portalen eller genom att konfigurera Azure RBAC i fönstret Åtkomstkontroll (IAM) efter Communication Services-resurs.
Om du vill skapa en ny Communication Services-resurs kan du läsa Skapa och hantera Communication Services-resurser.
Steg 5: Ge administratörsmedgivande
Microsoft Entra-klientorganisationen kan konfigureras för att kräva Microsoft Entra-administratörsmedgivande för behörigheterna Teams.ManageCalls och Teams.ManageChats för programmet. I sådana fall måste Microsoft Entra-administratören bevilja behörigheter till Contoso-programmet för Communication Services Teams.ManageCalls och Teams.ManageChats. Fabrikam Microsoft Entra-administratören ger medgivande via en unik URL.
Följande roller kan ge medgivande åt ett företag:
- global administratör
- Programadministratör
- Molnprogramadministratör
Om du vill kontrollera roller i Azure-portalen kan du läsa Lista Azure-rolltilldelningar.
Om du vill skapa en URL för administratörsmedgivande utför Fabrikam Microsoft Entra-administratören följande steg:
- I URL:en https://login.microsoftonline.com/{Tenant_ID}/adminconsent?client_id={Application_ID}ersätter administratören {Tenant_ID} med Fabrikam-klient-ID :t och ersätter {Application_ID} med Contosos program-ID.
- Administratören loggar in och beviljar behörigheter för organisationens räkning.
Tjänstens huvudnamn för Contoso-programmet i Fabrikam-klientorganisationen skapas om medgivande beviljas. Fabrikam-administratören kan granska medgivandet i Microsoft Entra-ID genom att göra följande:
- Logga in på Azure-portalen som administratör.
- Gå till Microsoft Entra ID.
- I fönstret Företagsprogram anger du filtret Programtyp till Alla program.
- I fältet för att filtrera programmen anger du namnet på Contoso-programmet.
- Välj Använd.
- Välj tjänstens huvudnamn med det namn som krävs.
- Gå till fönstret Behörigheter .
Du kan se att statusen för behörigheterna Communication Services Teams.ManageCalls och Teams.ManageChats beviljas för {Directory_name}.
Om du stöter på problemet "Appen försöker komma åt en tjänst '1fd5118e-2576-4263-8130-9503064c837a'(Azure Communication Services) som din organisation {GUID} saknar ett huvudnamn för tjänsten för. Kontakta IT-administratören för att granska konfigurationen av dina tjänstprenumerationer eller godkänna programmet för att skapa tjänstens huvudnamn." Din Microsoft Entra-klient saknar tjänstens huvudnamn för Azure Communication Services-programmet. Åtgärda problemet genom att använda PowerShell som Microsoft Entra-administratör för att ansluta till din klientorganisation. Ersätt Tenant_ID med ett ID för din Microsoft Entra-klientorganisation.
Du behöver Application.ReadWrite.All enligt nedan.
Connect-MgGraph -TenantId "Tenant_ID" -Scopes Application.ReadWrite.All
Om kommandot inte hittas startar du PowerShell som administratör och installerar Microsoft Graph-paketet.
Install-Module Microsoft.Graph
Kör sedan följande kommando för att lägga till ett huvudnamn för tjänsten i klientorganisationen. Ändra inte GUID för app-ID:t.
New-MgServicePrincipal -AppId "1fd5118e-2576-4263-8130-9503064c837a"
Utvecklaråtgärder
Contoso-utvecklaren måste konfigurera klientprogrammet för att autentisera användare. Utvecklaren måste sedan skapa en slutpunkt på serverdelsservern för att bearbeta Microsoft Entra-användartoken efter omdirigering. När Microsoft Entra-användartoken tas emot byts den mot åtkomsttoken för Teams-användaren och returneras till klientprogrammet.
Utvecklarens nödvändiga åtgärder visas i följande diagram:
- Contoso-utvecklaren konfigurerar Microsoft Authentication Library (MSAL) för att autentisera användaren för programmet som skapades tidigare av behörigheterna Administrator for Communication Services Teams.ManageCalls och Teams.ManageChats.
- Contoso-utvecklaren initierar Communication Services Identity SDK och utbyter den inkommande Microsoft Entra-användartoken för åtkomsttoken för Teams-användare via identitets-SDK. Åtkomsttoken för Teams-användaren returneras sedan till klientprogrammet.
Med hjälp av MSAL kan utvecklare hämta Microsoft Entra-användartoken från Microsofts identitetsplattform-slutpunkten för att autentisera användare och få åtkomst till säkra webb-API:er. Det kan användas för att ge säker åtkomst till Kommunikationstjänster. MSAL stöder många olika programarkitekturer och plattformar, inklusive .NET, JavaScript, Java, Python, Android och iOS.
Mer information om hur du konfigurerar miljöer i offentlig dokumentation finns i Översikt över Microsoft Authentication Library.
Kommentar
I följande avsnitt beskrivs hur du byter Microsoft Entra-åtkomsttoken mot åtkomsttoken för Teams-användare för konsolprogrammet.
Konfigurera krav
- Den senaste versionen av .NET SDK för operativsystemet.
Den slutliga koden
Hitta den färdiga koden för den här snabbstarten på GitHub.
Konfigurera
Skapa ett nytt C#-program
I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du dotnet new kommandot för att skapa en ny konsolapp med namnet CommunicationAccessTokensQuickstart. Det här kommandot skapar ett enkelt "Hello World"-C#-projekt med en enda källfil: Program.cs.
dotnet new console -o CommunicationAccessTokensQuickstart
Ändra katalogen till den nyligen skapade appmappen dotnet build och använd kommandot för att kompilera programmet.
cd CommunicationAccessTokensQuickstart
dotnet build
Installera -paketet
Installera Azure Communication Services Identity-biblioteket för .NET-paketet med hjälp av kommandot medan du fortfarande är i programkatalogen dotnet add package .
dotnet add package Azure.Communication.Identity
dotnet add package Microsoft.Identity.Client
Konfigurera appramverket
Från projektkatalogen:
- Öppna Program.cs fil i en textredigerare
- Lägg till ett
usingdirektiv för att inkluderaAzure.Communication.Identitynamnområdet - Uppdatera metoddeklarationen
Mainför att stödja asynkron kod
Börja med följande kod:
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
}
}
}
Steg 1: Ta emot Microsoft Entra-användartoken och objekt-ID:t via MSAL-biblioteket
Det första steget i tokenutbytesflödet är att hämta en token för teams-användaren med hjälp av Microsoft.Identity.Client. Koden nedan hämtar Microsoft Entra-klient-ID och klient-ID från miljövariabler med namnet AAD_CLIENT_ID och AAD_TENANT_ID. Det är viktigt att konfigurera MSAL-klienten med rätt utfärdare, baserat på AAD_TENANT_ID miljövariabeln, för att kunna hämta objekt-ID-anspråket (oid) som motsvarar en användare i Fabrikams klientorganisation och initiera variabeln 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;
Steg 2: Initiera CommunicationIdentityClient
Initiera en CommunicationIdentityClient med din anslutningssträng. Koden nedan hämtar anslutningssträng för resursen från en miljövariabel med namnet COMMUNICATION_SERVICES_CONNECTION_STRING. Lär dig hur du hanterar resursens anslutningssträng.
Lägg till följande kod i Main-metoden:
// 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);
Steg 3: Byt åtkomsttoken för Microsoft Entra för Teams-användaren mot en åtkomsttoken för kommunikationsidentitet
GetTokenForTeamsUser Använd metoden för att utfärda en åtkomsttoken för Teams-användaren som kan användas med Azure Communication Services SDK:er.
var options = new GetTokenForTeamsUserOptions(teamsUserAadToken, appId, userObjectId);
var accessToken = await client.GetTokenForTeamsUserAsync(options);
Console.WriteLine($"Token: {accessToken.Value.Token}");
Kör koden
Kör programmet från programkatalogen dotnet run med kommandot .
dotnet run
Konfigurera krav
Den slutliga koden
Hitta den färdiga koden för den här snabbstarten på GitHub.
Konfigurera
Skapa ett nytt Node.js-program
Öppna terminalen eller kommandofönstret skapa en ny katalog för din app och navigera till den.
mkdir communication-access-tokens-quickstart && cd communication-access-tokens-quickstart
Kör npm init -y för att skapa en package.json fil med standardinställningar.
npm init -y
Installera -paketet
npm install Använd kommandot för att installera Azure Communication Services Identity SDK för JavaScript.
npm install @azure/communication-identity@latest --save
npm install @azure/msal-node --save
npm install express --save
npm install dotenv --save
Alternativet --save visar biblioteket som ett beroende i din package.json-fil .
Konfigurera appramverket
Från projektkatalogen:
Öppna en ny textfil i kodredigeraren
Lägg till ett
requireanrop för att läsa inCommunicationIdentityClientSkapa strukturen för programmet, inklusive grundläggande undantagshantering
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}!`))Spara den nya filen som
issue-communication-access-token.jsiaccess-tokens-quickstartkatalogen.
Steg 1: Ta emot Microsoft Entra-användartoken och objekt-ID:t via MSAL-biblioteket
Det första steget i tokenutbytesflödet är att hämta en token för teams-användaren med hjälp av Microsoft.Identity.Client. Koden nedan hämtar Microsoft Entra-klient-ID och klient-ID från miljövariabler med namnet AAD_CLIENT_ID och AAD_TENANT_ID. Det är viktigt att konfigurera MSAL-klienten med rätt utfärdare, baserat på AAD_TENANT_ID miljövariabeln, för att kunna hämta objekt-ID-anspråket (oid) som motsvarar en användare i Fabrikams klientorganisation och initiera variabeln 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);
});
});
Steg 2: Initiera CommunicationIdentityClient
Instansiera en CommunicationIdentityClient med din anslutningssträng. Koden nedan hämtar anslutningssträng för resursen från en miljövariabel med namnet COMMUNICATION_SERVICES_CONNECTION_STRING. Lär dig hur du hanterar resursens anslutningssträng.
Lägg till följande kod i then-metoden:
// 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);
Steg 3: Byt åtkomsttoken för Microsoft Entra för Teams-användaren mot en åtkomsttoken för kommunikationsidentitet
getTokenForTeamsUser Använd metoden för att utfärda en åtkomsttoken för Teams-användaren som kan användas med Azure Communication Services SDK:er.
//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);
Kör koden
Från en konsolprompt går du till katalogen som innehåller issue-communication-access-token.js-filen och kör sedan följande node kommando för att köra appen.
node ./issue-communication-access-token.js
Konfigurera krav
- Python 3.8+.
Den slutliga koden
Hitta den färdiga koden för den här snabbstarten på GitHub.
Konfigurera
Skapa ett nytt Python-program
Öppna terminalen eller kommandofönstret skapa en ny katalog för din app och navigera till den.
mkdir communication-access-tokens-quickstart && cd communication-access-tokens-quickstartAnvänd en textredigerare för att skapa en fil som heter
exchange-communication-access-tokens.pyi projektets rotkatalog och lägga till strukturen för programmet, inklusive grundläggande undantagshantering. Du lägger till all källkod för den här snabbstarten i den här filen i följande avsnitt.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}")
Installera -paketet
Installera Azure Communication Services Identity SDK för Python-paketet med hjälp av kommandot medan du fortfarande är i programkatalogen pip install .
pip install azure-communication-identity
pip install msal
Steg 1: Ta emot Microsoft Entra-användartoken och objekt-ID:t via MSAL-biblioteket
Det första steget i tokenutbytesflödet är att hämta en token för teams-användaren med hjälp av Microsoft.Identity.Client. I Azure-portalen konfigurerar du omdirigerings-URI:n för ditt "mobil- och skrivbordsprogram" som http://localhost. Koden nedan hämtar Microsoft Entra-klient-ID och klient-ID från miljövariabler med namnet AAD_CLIENT_ID och AAD_TENANT_ID. Det är viktigt att konfigurera MSAL-klienten med rätt utfärdare, baserat på AAD_TENANT_ID miljövariabeln, för att kunna hämta objekt-ID-anspråket (oid) som motsvarar en användare i Fabrikams klientorganisation och initiera variabeln 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"]
Steg 2: Initiera CommunicationIdentityClient
Instansiera en CommunicationIdentityClient med din anslutningssträng. Koden nedan hämtar anslutningssträng för resursen från en miljövariabel med namnet COMMUNICATION_SERVICES_CONNECTION_STRING. Lär dig hur du hanterar resursens anslutningssträng.
Lägg till den här koden i try blocket:
# 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)
Steg 3: Byt åtkomsttoken för Microsoft Entra för Teams-användaren mot en åtkomsttoken för kommunikationsidentitet
get_token_for_teams_user Använd metoden för att utfärda en åtkomsttoken för Teams-användaren som kan användas med Azure Communication Services SDK:er.
# 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)
Kör koden
Från en konsolprompt går du till katalogen som innehåller exchange-teams-access-tokens.py-filen och kör sedan följande python kommando för att köra appen.
python ./exchange-communication-access-tokens.py
Konfigurera krav
- Java Development Kit (JDK) version 8 eller senare.
- Apache Maven.
Den slutliga koden
Hitta den färdiga koden för den här snabbstarten på GitHub.
Konfigurera
Skapa ett nytt Java-program
Öppna terminalen eller kommandofönstret. Navigera till katalogen där du vill skapa ditt Java-program. Kör kommandot nedan för att generera Java-projektet från mallen maven-archetype-quickstart .
mvn archetype:generate -DgroupId=com.communication.quickstart -DartifactId=communication-quickstart -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false
Du kommer att märka att aktiviteten "generera" skapade en katalog med samma namn som artifactId. Under den src/main/java här katalogen innehåller katalogen projektets källkod, src/test/java directory innehåller testkällan och pom.xml filen är projektets projektobjektmodell eller POM.
Installera -paketet
pom.xml Öppna filen i textredigeraren. Lägg till följande beroendeelement i gruppen med beroenden.
<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>
Konfigurera appramverket
Från projektkatalogen:
- Gå till katalogen
/src/main/java/com/communication/quickstart App.javaÖppna filen i redigeringsprogrammet- Ersätt -instruktionen
System.out.println("Hello world!"); - Lägga till
importdirektiv
Börja med följande kod:
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
}
}
Steg 1: Ta emot Microsoft Entra-användartoken och objekt-ID:t via MSAL-biblioteket
Det första steget i tokenutbytesflödet är att hämta en token för teams-användaren med hjälp av Microsoft.Identity.Client. Det är viktigt att konfigurera MSAL-klienten med rätt utfärdare, baserat på variabeln tenantId , för att kunna hämta objekt-ID-anspråket (oid) som motsvarar en användare i Fabrikams klientorganisation och initiera variabeln 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);
Steg 2: Initiera CommunicationIdentityClient
Instansiera en CommunicationIdentityClient med resursens åtkomstnyckel och slutpunkt. Lär dig hur du hanterar resursens anslutningssträng. Dessutom kan du initiera klienten med valfri anpassad HTTP-klient som implementerar com.azure.core.http.HttpClient gränssnittet.
Lägg till följande kod i main-metoden:
//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();
Steg 3: Byt åtkomsttoken för Microsoft Entra för Teams-användaren mot en åtkomsttoken för kommunikationsidentitet
getTokenForTeamsUser Använd metoden för att utfärda en åtkomsttoken för Teams-användaren som kan användas med Azure Communication Services SDK:er.
// 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());
Kör koden
Navigera till katalogen som innehåller pom.xml filen och kompilera projektet med hjälp mvn compile av kommandot .
Skapa sedan paketet.
mvn package
Kör följande mvn kommando för att köra appen.
mvn exec:java -Dexec.mainClass="com.communication.quickstart.App" -Dexec.cleanupDaemonThreads=false
Användaråtgärder
Användaren representerar Fabrikam-användarna av Contoso-programmet. Användarupplevelsen visas i följande diagram:
- Fabrikam-användaren använder Contoso-klientprogrammet och uppmanas att autentisera.
- Contoso-klientprogrammet använder MSAL för att autentisera användaren mot Fabrikam Microsoft Entra-klientorganisationen för Contoso-programmet med behörigheterna Communication Services Teams.ManageCalls och Teams.ManageChats.
- Autentisering omdirigeras till servern enligt definitionen i egenskapen Omdirigerings-URI i MSAL- och Contoso-programmet.
- Contoso-servernutbyter Microsoft Entra-användartoken för åtkomsttoken för Teams-användaren med hjälp av Communication Services Identity SDK och returnerar åtkomsttoken för Teams-användaren till klientprogrammet.
Med en giltig åtkomsttoken för Teams-användare i klientprogrammet kan utvecklare integrera Communication Services Calling SDK och hantera samtal som Teams-användare.
Nästa steg
I den här snabbstarten har du lärt dig att:
- Skapa och konfigurera ett program i Microsoft Entra-ID.
- Använd Microsoft Authentication Library (MSAL) för att utfärda en Microsoft Entra-användartoken.
- Använd Communication Services Identity SDK för att byta Ut Microsoft Entra-användartoken mot en åtkomsttoken för Teams-användare.
Skapa en betrodd autentiseringstjänst för Teams-användareGör ett anrop som Teams-användare till en Teams-användare
Lär dig mer om följande begrepp: