Schnellstart: Authentifizieren mithilfe von Microsoft Entra ID

Artikel
03/25/2023

Hier erfahren Sie mehr zu den ersten Schritten bei der Verwendung verwalteter Identitäten mit Microsoft Entra ID. Die Identitäts- und SMS-SDKs von Communication Services Identity unterstützen die Microsoft Entra-Authentifizierung.

In diesem Schnellstart erfahren Sie, wie Sie den Zugriff auf die Identitäts- und SMS-SDKs aus einer Azure-Umgebung autorisieren, die Active Directory unterstützt. Außerdem wird beschrieben, wie Sie Ihren Code in einer Entwicklungsumgebung testen, indem Sie einen Dienstprinzipal für Ihre Arbeit erstellen.

Voraussetzungen

Ein Azure-Konto mit einem aktiven Abonnement. Kostenlos ein Konto erstellen
Eine aktive Azure Communication Services-Ressource. Informationen zum Erstellen einer Communication Services-Ressource finden Sie bei Bedarf hier.
Eine Telefonnummer zum Senden einer SMS.
Einen Einrichtungsdienstprinzipal für eine Entwicklungsumgebung. Weitere Informationen finden Sie unter Schnellstart: Authentifizieren mittels Azure Active Directory (Azure CLI).

Zusätzlich erforderliche Komponenten

Azure-Befehlszeilenschnittstelle. Installationshandbuch

Einrichten

Wenn Sie Active Directory für andere Azure-Ressourcen verwenden, sollten Sie verwaltete Identitäten verwenden. Informationen zum Aktivieren von verwalteten Identitäten für Azure-Ressourcen finden Sie in diesen Artikeln:

Authentifizieren einer registrierten Anwendung in der Entwicklungsumgebung

Wenn Ihre Entwicklungsumgebung kein einmaliges Anmelden bzw. keine Anmeldung über einen Webbrowser unterstützt, können Sie für die Authentifizierung über die Entwicklungsumgebung eine registrierte Anwendung verwenden.

Erstellen einer registrierten Microsoft Entra-Anwendung

Zum Erstellen einer registrierten Anwendung über die Azure CLI müssen Sie bei dem Azure-Konto angemeldet sein, in dem die Vorgänge ausgeführt werden sollen. Dazu können Sie den Befehl az login verwenden und Ihre Anmeldeinformationen im Browser eingeben. Nachdem Sie sich über die CLI bei Ihrem Azure-Konto angemeldet haben, können wir den az ad sp create-for-rbac-Befehl zum Erstellen der registrierten Anwendung und des Dienstprinzipals aufrufen.

In den folgenden Beispielen wird die Azure CLI verwendet, um eine neue registrierte Anwendung zu erstellen:

az ad sp create-for-rbac --name <application-name> --role Contributor --scopes /subscriptions/<subscription-id>

Mit dem Befehl az ad sp create-for-rbac wird eine Liste der Dienstprinzipaleigenschaften im JSON-Format zurückgegeben. Kopieren Sie diese Werte, damit Sie sie zum Erstellen der erforderlichen Umgebungsvariablen im nächsten Schritt verwenden können.

{
    "appId": "generated-app-ID",
    "displayName": "service-principal-name",
    "name": "http://service-principal-uri",
    "password": "generated-password",
    "tenant": "tenant-ID"
}

Wichtig

Die Azure-Rollenzuweisungen können einige Minuten dauern.

Festlegen von Umgebungsvariablen

Über das Azure Identity SDK werden zur Laufzeit Werte aus drei Umgebungsvariablen gelesen, um die Anwendung zu authentifizieren. In der folgenden Tabelle sind die für die einzelnen Umgebungsvariablen festzulegenden Werte beschrieben.

Umgebungsvariable	value
`AZURE_CLIENT_ID`	Wert `appId` aus dem generierten JSON-Code
`AZURE_TENANT_ID`	Wert `tenant` aus dem generierten JSON-Code
`AZURE_CLIENT_SECRET`	Wert `password` aus dem generierten JSON-Code

Wichtig

Nachdem Sie die Umgebungsvariablen festgelegt haben, schließen Sie das Konsolenfenster, und öffnen Sie es dann erneut. Wenn Sie Visual Studio oder eine andere Entwicklungsumgebung verwenden, müssen Sie möglicherweise einen Neustart durchführen, damit die neuen Umgebungsvariablen registriert werden.

Nachdem diese Variablen festgelegt wurden, können Sie das Objekt „DefaultAzureCredential“ in Ihrem Code verwenden, um sich beim Dienstclient Ihrer Wahl zu authentifizieren.

Hinweis

Den fertigen Code für diesen Schnellstart finden Sie auf GitHub.

Einrichten

Erstellen einer neuen C#-Anwendung

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen ActiveDirectoryQuickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-C#-Projekt mit einer einzigen Quelldatei: Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Wechseln Sie zum neu erstellten App-Ordner, und verwenden Sie den Befehl dotnet build, um Ihre Anwendung zu kompilieren.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installieren der SDK-Pakete

dotnet add package Azure.Communication.Identity
dotnet add package Azure.Communication.Sms
dotnet add package Azure.Identity

Verwenden der SDK-Pakete

Fügen Sie Program.cs die folgenden using-Anweisungen hinzu, um die Azure Identity und Azure Storage SDKs zu verwenden.

using Azure.Identity;
using Azure.Communication.Identity;
using Azure.Communication.Sms;
using Azure.Core;
using Azure;

Erstellen eines DefaultAzureCredentials

Für diese Schnellstartanleitung verwenden wir DefaultAzureCredential. Diese Anmeldeinformationen eignen sich für Produktions- und Entwicklungsumgebungen. Da sie für jeden Vorgang benötigt werden, erstellen wir sie in der Program.cs-Klasse. Fügen Sie am Anfang der Datei Folgendes hinzu:

private DefaultAzureCredential credential = new DefaultAzureCredential();

Ausgabe eines Tokens mit Dienstprinzipalen

Nun fügen wir Code hinzu, der die erstellten Anmeldeinformationen verwendet, um ein VoIP-Zugriffstoken auszugeben. Wir werden diesen Code später aufrufen.

public AccessToken CreateIdentityAndGetTokenAsync(Uri resourceEndpoint)
{
    var client = new CommunicationIdentityClient(resourceEndpoint, this.credential);
    var result = client.CreateUserAndToken(scopes: new[] { CommunicationTokenScope.VoIP });
    var (user, token) = response.Value;
    return token;
}

Senden einer SMS mit Dienstprinzipalen

Als weiteres Beispiel für die Verwendung von Dienstprinzipalen fügen wir diesen Code hinzu, der dieselben Anmeldeinformationen zum Senden einer SMS verwendet:

public SmsSendResult SendSms(Uri resourceEndpoint, string from, string to, string message)
{
    SmsClient smsClient = new SmsClient(resourceEndpoint, this.credential);
    SmsSendResult sendResult = smsClient.Send(
            from: from,
            to: to,
            message: message,
            new SmsSendOptions(enableDeliveryReport: true) // optional
        );

    return sendResult;
}

Schreiben der Main-Methode

Ihre Program.cs sollte bereits eine Main-Methode enthalten. Fügen Sie nun Code hinzu, der unseren zuvor erstellten Code aufruft, um die Verwendung von Dienstprinzipalen zu veranschaulichen:

static void Main(string[] args)
{
    // You can find your endpoint and access key from your resource in the Azure portal
    // e.g. "https://<RESOURCE_NAME>.communication.azure.com";
    Uri endpoint = new("https://<RESOURCENAME>.communication.azure.com/");

    // We need an instance of the program class to use within this method.
    Program instance = new();

    Console.WriteLine("Retrieving new Access Token, using Service Principals");
    AccessToken response = instance.CreateIdentityAndGetTokenAsync(endpoint);
    Console.WriteLine($"Retrieved Access Token: {response.Token}");

    Console.WriteLine("Sending SMS using Service Principals");

    // You will need a phone number from your resource to send an SMS.
    SmsSendResult result = instance.SendSms(endpoint, "<Your Azure Communication Services Phone Number>", "<The Phone Number you'd like to send the SMS to.>", "Hello from using Service Principals");
    Console.WriteLine($"Sms id: {result.MessageId}");
    Console.WriteLine($"Send Result Successful: {result.Successful}");
}

Die endgültige Program.cs-Datei sollte wie folgt aussehen:

class Program
     {
          private DefaultAzureCredential credential = new DefaultAzureCredential();
          static void Main(string[] args)
          {
               // You can find your endpoint and access key from your resource in the Azure portal
               // e.g. "https://<RESOURCE_NAME>.communication.azure.com";
               Uri endpoint = new("https://acstestingrifox.communication.azure.com/");

               // We need an instance of the program class to use within this method.
               Program instance = new();

               Console.WriteLine("Retrieving new Access Token, using Service Principals");
               AccessToken response = instance.CreateIdentityAndGetTokenAsync(endpoint);
               Console.WriteLine($"Retrieved Access Token: {response.Token}");

               Console.WriteLine("Sending SMS using Service Principals");

               // You will need a phone number from your resource to send an SMS.
               SmsSendResult result = instance.SendSms(endpoint, "<Your Azure Communication Services Phone Number>", "<The Phone Number you'd like to send the SMS to.>", "Hello from Service Principals");
               Console.WriteLine($"Sms id: {result.MessageId}");
               Console.WriteLine($"Send Result Successful: {result.Successful}");
          }
          public AccessToken CreateIdentityAndGetTokenAsync(Uri resourceEndpoint)
          {
               var client = new CommunicationIdentityClient(resourceEndpoint, this.credential);
               var result = client.CreateUserAndToken(scopes: new[] { CommunicationTokenScope.VoIP });
               var (user, token) = response.Value;
               return token;
          }
          public SmsSendResult SendSms(Uri resourceEndpoint, string from, string to, string message)
          {
               SmsClient smsClient = new SmsClient(resourceEndpoint, this.credential);
               SmsSendResult sendResult = smsClient.Send(
                    from: from,
                    to: to,
                    message: message,
                    new SmsSendOptions(enableDeliveryReport: true) // optional
               );

               return sendResult;
          }
    }

Ausführen des Programms

Sie sollten Ihre Anwendung jetzt mithilfe von dotnet run aus Ihrem Anwendungsordner ausführen können. Die Ausgabe sollte wie folgt aussehen:

Retrieving new Access Token, using Service Principals
Retrieved Access Token: ey....
Sending SMS using Service Principals
Sms id: Outgoing_..._noam
Send Result Successful: True

Hinweis

Den fertigen Code für diesen Schnellstart finden Sie auf GitHub.

Einrichten

Erstellen einer neuen Node.js-Anwendung

Öffnen Sie Ihr Terminal- oder Befehlsfenster, erstellen Sie ein neues Verzeichnis für Ihre App, und navigieren Sie zu diesem Verzeichnis.

mkdir active-directory-authentication-quickstart && cd active-directory-authentication-quickstart

Führen Sie npm init -y aus, um die Datei package.json mit den Standardeinstellungen zu erstellen.

npm init -y

Installieren der SDK-Pakete

npm install @azure/communication-identity
npm install @azure/communication-common
npm install @azure/communication-sms
npm install @azure/identity

Erstellen einer neuen Datei

Öffnen Sie eine neue Datei mit einem Text-Editor, und speichern Sie sie als index.js. Wir platzieren den Code in dieser Datei.

Verwenden der SDK-Pakete

Fügen Sie am Anfang von index.js die folgenden require-Anweisungen hinzu, um die Azure Identity- und Azure Storage-SDKs zu verwenden.

const { DefaultAzureCredential } = require("@azure/identity");
const { CommunicationIdentityClient, CommunicationUserToken } = require("@azure/communication-identity");
const { SmsClient, SmsSendRequest } = require("@azure/communication-sms");

Erstellen eines DefaultAzureCredential-Standards

    const credential = new DefaultAzureCredential();

Erstellen einer Identität und Ausstellen eines Tokens mit Dienstprinzipalen

Als Nächstes schreiben Sie eine Funktion, die eine neue Identität erstellt und ein Token für diese Identität ausstellt. Sie verwenden diese Funktion später, um die Einrichtung des Dienstprinzipals zu testen.

async function createIdentityAndIssueToken(resourceEndpoint) {
    const client = new CommunicationIdentityClient(resourceEndpoint, credential);
    return await client.createUserAndToken(["chat"]);
}

Senden einer SMS mit Dienstprinzipalen

Schreiben Sie nun eine Funktion, die Dienstprinzipale zum Senden einer SMS verwendet:

async function sendSms(resourceEndpoint, fromNumber, toNumber, message) {
    const smsClient = new SmsClient(resourceEndpoint, credential);
    const sendRequest = {
        from: fromNumber,
        to: [toNumber],
        message: message
    };
    return await smsClient.send(
        sendRequest,
        {} //Optional SendOptions
    );
}

Schreiben der main-Funktion

Nachdem Sie die Funktionen erstellt haben, können Sie nun eine main-Funktion schreiben, um diese Funktionen aufzurufen und die Verwendung von Dienstprinzipalen zu veranschaulichen:

async function main() {
    // You can find your endpoint and access key from your resource in the Azure portal
    // e.g. "https://<RESOURCE_NAME>.communication.azure.com";
    const endpoint = "https://<RESOURCE_NAME>.communication.azure.com/"

    
    console.log("Retrieving new Access Token, using Service Principals");
    const result = await createIdentityAndIssueToken(endpoint);
    console.log(`Retrieved Access Token: ${result.token}`);

    console.log("Sending SMS using Service Principals");

    // You will need a phone number from your resource to send an SMS.
    const smsResult = await sendSms(endpoint, "<FROM NUMBER>", "<TO NUMBER>", "Hello from Service Principals");
    console.log(`SMS ID: ${smsResult[0].messageId}`);
    console.log(`Send Result Successful: ${smsResult[0].successful}`);
}

main();

Die endgültige index.js-Datei sollte wie folgt aussehen:

const { DefaultAzureCredential } = require("@azure/identity");
const { CommunicationIdentityClient, CommunicationUserToken } = require("@azure/communication-identity");
const { SmsClient, SmsSendRequest } = require("@azure/communication-sms");

const credential = new DefaultAzureCredential();

async function createIdentityAndIssueToken(resourceEndpoint) {
    const client = new CommunicationIdentityClient(resourceEndpoint, credential);
    return await client.createUserAndToken(["chat"]);
}

async function sendSms(resourceEndpoint, fromNumber, toNumber, message) {
    const smsClient = new SmsClient(resourceEndpoint, credential);
    const sendRequest = {
        from: fromNumber,
        to: [toNumber],
        message: message
    };
    return await smsClient.send(
        sendRequest,
        {} //Optional SendOptions
    );
}

async function main() {
    // You can find your endpoint and access key from your resource in the Azure portal
    // e.g. "https://<RESOURCE_NAME>.communication.azure.com";
    const endpoint = "https://<RESOURCE_NAME>.communication.azure.com/"

    
    console.log("Retrieving new Access Token, using Service Principals");
    const result = await createIdentityAndIssueToken(endpoint);
    console.log(`Retrieved Access Token: ${result.token}`);

    console.log("Sending SMS using Service Principals");

    // You will need a phone number from your resource to send an SMS.
    const smsResult = await sendSms(endpoint, "<FROM NUMBER>", "<TO NUMBER>", "Hello from Service Principals");
    console.log(`SMS ID: ${smsResult[0].messageId}`);
    console.log(`Send Result Successful: ${smsResult[0].successful}`);
}

main();

Ausführen des Programms

Wenn alles erledigt ist, können Sie die Datei durch Eingabe von node index.js aus dem Verzeichnis Ihres Projekts ausführen. Ist alles in Ordnung, sollte etwa folgende Ausgabe angezeigt werden:

    $ node index.js
    Retrieving new Access Token, using Service Principals
    Retrieved Access Token: ey...Q
    Sending SMS using Service Principals
    SMS ID: Outgoing_2021040602194...._noam
    Send Result Successful: true

Zusätzliche Voraussetzungen für Java

Für Java benötigen Sie außerdem:

Java Development Kit (JDK), Version 8 oder höher.
Apache Maven.

Hinweis

Den fertigen Code für diesen Schnellstart finden Sie auf GitHub.

Einrichten

Erstellen einer neuen Java-Anwendung

Öffnen Sie Ihr Terminal oder Befehlsfenster. Navigieren Sie zu dem Verzeichnis, in dem Sie Ihre Java-Anwendung erstellen möchten. Führen Sie den unten angegebenen Befehl aus, um das Java-Projekt auf der Grundlage der Vorlage „maven-archetype-quickstart“ zu generieren.

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

Wie Sie sehen, wurde durch die Aufgabe „generate“ ein Verzeichnis erstellt, das den gleichen Namen besitzt wie die Artefakt-ID (artifactId). In diesem Verzeichnis enthält das Verzeichnis „src/main/java“ den Quellcode des Projekts. Das Verzeichnis src/test/java directory enthält die Testquelle, und die Datei pom.xml ist das Projektobjektmodell (POM) des Projekts.

Installieren des Pakets

Öffnen Sie die Datei pom.xml in Ihrem Text-Editor. Fügen Sie der Gruppe „dependencies“ das folgende Abhängigkeitselement hinzu.

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-identity</artifactId>
    <version>[1.4.0,)</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-communication-sms</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-identity</artifactId>
    <version>1.2.3</version>
</dependency>

Verwenden der SDK-Pakete

Fügen Sie dem Code die folgenden import-Anweisungen hinzu, um die Azure Identity und Azure Communication SDKs zu verwenden.

import com.azure.communication.common.*;
import com.azure.communication.identity.*;
import com.azure.communication.identity.models.*;
import com.azure.communication.sms.*;
import com.azure.communication.sms.models.*;
import com.azure.core.credential.*;
import com.azure.identity.*;

import java.util.*;

Erstellen eines DefaultAzureCredential-Standards

Für diese Schnellstartanleitung verwenden wir DefaultAzureCredential. Diese Anmeldeinformationen eignen sich für Produktions- und Entwicklungsumgebungen. Da sie für jeden Vorgang benötigt werden, erstellen wir sie in der App.java-Klasse. Fügen Sie Folgendes am Anfang der App.java-Klasse hinzu:

private TokenCredential credential = new DefaultAzureCredentialBuilder().build();

Ausgabe eines Tokens mit Dienstprinzipalen

Nun fügen wir Code hinzu, der die erstellten Anmeldeinformationen verwendet, um ein VoIP-Zugriffstoken auszugeben. Wir werden diesen Code später aufrufen.

    public AccessToken createIdentityAndGetTokenAsync(String endpoint) {
          CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClientBuilder()
                    .endpoint(endpoint)
                    .credential(this.credential)
                    .buildClient();

          CommunicationUserIdentifierAndToken result =  communicationIdentityClient.createUserAndToken(new ArrayList<>(Arrays.asList(CommunicationTokenScope.CHAT)));
          return result.getUserToken();
    }

Senden einer SMS mit Dienstprinzipalen

Als weiteres Beispiel für die Verwendung von Dienstprinzipalen fügen wir diesen Code hinzu, der dieselben Anmeldeinformationen zum Senden einer SMS verwendet:

     public SmsSendResult sendSms(String endpoint, String from, String to, String message) {
          SmsClient smsClient = new SmsClientBuilder()
                    .endpoint(endpoint)
                    .credential(this.credential)
                    .buildClient();

          // Send the message and check the response for a message id
          return smsClient.send(from, to, message);
     }

Schreiben der Main-Methode

Ihre App.java sollte bereits eine Main-Methode enthalten. Fügen Sie nun Code hinzu, der unseren zuvor erstellten Code aufruft, um die Verwendung von Dienstprinzipalen zu veranschaulichen:

    public static void main(String[] args) {
          App instance = new App();
          // You can find your endpoint and access key from your resource in the Azure portal
          // e.g. "https://<RESOURCE_NAME>.communication.azure.com";
          String endpoint = "https://<RESOURCE_NAME>.communication.azure.com/";

          System.out.println("Retrieving new Access Token, using Service Principals");
          AccessToken token = instance.createIdentityAndGetTokenAsync(endpoint);
          System.out.println("Retrieved Access Token: "+ token.getToken());

          System.out.println("Sending SMS using Service Principals");
          // You will need a phone number from your resource to send an SMS.
          SmsSendResult result = instance.sendSms(endpoint, "<FROM NUMBER>", "<TO NUMBER>", "Hello from Service Principals");
          System.out.println("Sms id: "+ result.getMessageId());
          System.out.println("Send Result Successful: "+ result.isSuccessful());
    }

Der resultierende App.java-Code sollte wie folgt aussehen:

package com.communication.quickstart;

import com.azure.communication.common.*;
import com.azure.communication.identity.*;
import com.azure.communication.identity.models.*;
import com.azure.communication.sms.*;
import com.azure.communication.sms.models.*;
import com.azure.core.credential.*;
import com.azure.identity.*;

import java.util.*;

public class App 
{

    private TokenCredential credential = new DefaultAzureCredentialBuilder().build();

    public SmsSendResult sendSms(String endpoint, String from, String to, String message) {
          SmsClient smsClient = new SmsClientBuilder()
               .endpoint(endpoint)
               .credential(this.credential)
               .buildClient();

          // Send the message and check the response for a message id
          return smsClient.send(from, to, message);
    }
    
    public AccessToken createIdentityAndGetTokenAsync(String endpoint) {
          CommunicationIdentityClient communicationIdentityClient = new CommunicationIdentityClientBuilder()
                    .endpoint(endpoint)
                    .credential(this.credential)
                    .buildClient();

          CommunicationUserIdentifierAndToken result =  communicationIdentityClient.createUserAndToken(new ArrayList<>(Arrays.asList(CommunicationTokenScope.CHAT)));
          return result.getUserToken();
    }

    public static void main(String[] args) {
          App instance = new App();
          // You can find your endpoint and access key from your resource in the Azure portal
          // e.g. "https://<RESOURCE_NAME>.communication.azure.com";
          String endpoint = "https://<RESOURCE_NAME>.communication.azure.com/";

          System.out.println("Retrieving new Access Token, using Service Principals");
          AccessToken token = instance.createIdentityAndGetTokenAsync(endpoint);
          System.out.println("Retrieved Access Token: "+ token.getToken());

          System.out.println("Sending SMS using Service Principals");
          // You will need a phone number from your resource to send an SMS.
          SmsSendResult result = instance.sendSms(endpoint, "<FROM NUMBER>", "<TO NUMBER>", "Hello from Service Principals");
          System.out.println("Sms id: "+ result.getMessageId());
          System.out.println("Send Result Successful: "+ result.isSuccessful());
    }
}

Ausführen des Codes

Navigieren Sie zum Verzeichnis, das die Datei pom.xml enthält, und kompilieren Sie das Projekt mit dem folgenden mvn-Befehl.

mvn compile

Erstellen Sie dann das Paket.

mvn package

Führen Sie die App mit dem folgenden mvn-Befehl aus.

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

Die endgültige Ausgabe sollte wie folgt aussehen:

Retrieving new Access Token, using Service Principals
Retrieved Access Token: ey..A
Sending SMS using using Service Principals
Sms id: Outgoing_202104...33f8ae1f_noam
Send Result Successful: true

Hinweis

Den fertigen Code für diesen Schnellstart finden Sie auf GitHub.

Einrichten

Erstellen einer neuen Python-Anwendung

Öffnen Sie Ihr Terminal- oder Befehlsfenster, erstellen Sie ein neues Verzeichnis für Ihre App, und navigieren Sie zu diesem Verzeichnis.

mkdir active-directory-authentication-quickstart && cd active-directory-authentication-quickstart

Installieren der SDK-Pakete

pip install azure-identity
pip install azure-communication-identity
pip install azure-communication-sms

Erstellen einer neuen Datei

Öffnen und speichern Sie eine neue Datei in Ihrem erstellten Ordner mit dem Namen authentication.py. Wir werden unseren Code in dieser Datei platzieren.

Verwenden der SDK-Pakete

Fügen Sie die folgenden import-Anweisungen am Anfang Ihrer Datei hinzu, um die von uns installierten SDKs zu verwenden.

from azure.identity import DefaultAzureCredential
from azure.communication.identity import CommunicationIdentityClient
from azure.communication.sms import SmsClient

Erstellen eines DefaultAzureCredential-Standards

Wir verwenden DefaultAzureCredential. Diese Anmeldeinformationen eignen sich für Produktions- und Entwicklungsumgebungen. Da sie in dieser Schnellstartanleitung verwendet werden, erstellen wir sie am Anfang der Datei.

     credential = DefaultAzureCredential()

Erstellen einer Identität und Ausstellen eines Tokens mit Dienstprinzipalen

Nun fügen wir Code hinzu, der die erstellten Anmeldeinformationen verwendet, um ein VoIP-Zugriffstoken auszugeben. Wir werden diesen Code später aufrufen:

def create_identity_and_get_token(resource_endpoint):
     client = CommunicationIdentityClient(resource_endpoint, credential)
     user, token_response = client.create_user_and_token(scopes=["voip"])

     return token_response

Senden einer SMS mit Dienstprinzipalen

Als weiteres Beispiel für die Verwendung von Dienstprinzipalen wird dieser Code hinzugefügt, der dieselben Anmeldeinformationen zum Senden einer SMS verwendet:

def send_sms(resource_endpoint, from_phone_number, to_phone_number, message_content):
     sms_client = SmsClient(resource_endpoint, credential)

     sms_client.send(
          from_=from_phone_number,
          to_=[to_phone_number],
          message=message_content,
          enable_delivery_report=True  # optional property
     )

Schreiben des Hauptcodes

Mit unseren erstellten Funktionen können wir jetzt den Hauptcode schreiben, der die Funktionen aufruft, die wir zuvor geschrieben haben.

# You can find your endpoint and access key from your resource in the Azure portal
# e.g. "https://<RESOURCE_NAME>.communication.azure.com";
endpoint = "https://<RESOURCE_NAME>.communication.azure.com/"

print("Retrieving new Access Token, using Service Principals");
result = create_identity_and_get_token(endpoint);
print(f'Retrieved Access Token: {result.token}');

print("Sending SMS using Service Principals");

# You will need a phone number from your resource to send an SMS.
sms_result = send_sms(endpoint, "<FROM_NUMBER>", "<TO_NUMBER>", "Hello from Service Principals");
print(f'SMS ID: {sms_result[0].message_id}');
print(f'Send Result Successful: {sms_result[0].successful}');

Ihre endgültige authentication.py-Datei sollte in etwa wie folgt aussehen:

from azure.identity import DefaultAzureCredential
from azure.communication.identity import CommunicationIdentityClient
from azure.communication.sms import SmsClient

credential = DefaultAzureCredential()

def create_identity_and_get_token(resource_endpoint):
     client = CommunicationIdentityClient(resource_endpoint, credential)
     user, token_response = client.create_user_and_token(scopes=["voip"])

     return token_response

def send_sms(resource_endpoint, from_phone_number, to_phone_number, message_content):
     sms_client = SmsClient(resource_endpoint, credential)

     response = sms_client.send(
          from_=from_phone_number,
          to=[to_phone_number],
          message=message_content,
          enable_delivery_report=True  # optional property
     )
     return response

# You can find your endpoint and access key from your resource in the Azure portal
# e.g. "https://<RESOURCE_NAME>.communication.azure.com";
endpoint = "https://<RESOURCE_NAME>.communication.azure.com/"

print("Retrieving new Access Token, using Service Principals");
result = create_identity_and_get_token(endpoint);
print(f'Retrieved Access Token: {result.token}');

print("Sending SMS using Service Principals");

# You will need a phone number from your resource to send an SMS.
sms_result = send_sms(endpoint, "<FROM_NUMBER>", "<TO_NUMBER>", "Hello from Service Principals");
print(f'SMS ID: {sms_result[0].message_id}');
print(f'Send Result Successful: {sms_result[0].successful}');

Ausführen des Programms

Wenn alles erledigt ist, können Sie die Datei durch Eingabe von python authentication.py aus dem Verzeichnis Ihres Projekts ausführen. Ist alles in Ordnung, sollte etwa folgende Ausgabe angezeigt werden:

    $ python authentication.py
    Retrieving new Access Token, using Service Principals
    Retrieved Access Token: ey...Q
    Sending SMS using using Service Principals
    SMS ID: Outgoing_2021040602194...._noam
    Send Result Successful: true

Schnellstart: Authentifizieren mithilfe von Microsoft Entra ID

Voraussetzungen

Zusätzlich erforderliche Komponenten

Einrichten

Authentifizieren einer registrierten Anwendung in der Entwicklungsumgebung

Erstellen einer registrierten Microsoft Entra-Anwendung

Festlegen von Umgebungsvariablen

Einrichten

Erstellen einer neuen C#-Anwendung

Installieren der SDK-Pakete

Verwenden der SDK-Pakete

Erstellen eines DefaultAzureCredentials

Ausgabe eines Tokens mit Dienstprinzipalen

Senden einer SMS mit Dienstprinzipalen

Schreiben der Main-Methode

Ausführen des Programms

Einrichten

Erstellen einer neuen Node.js-Anwendung

Installieren der SDK-Pakete

Erstellen einer neuen Datei

Verwenden der SDK-Pakete

Erstellen eines DefaultAzureCredential-Standards

Erstellen einer Identität und Ausstellen eines Tokens mit Dienstprinzipalen

Senden einer SMS mit Dienstprinzipalen

Schreiben der main-Funktion

Ausführen des Programms

Zusätzliche Voraussetzungen für Java

Einrichten

Erstellen einer neuen Java-Anwendung

Installieren des Pakets

Verwenden der SDK-Pakete

Erstellen eines DefaultAzureCredential-Standards

Ausgabe eines Tokens mit Dienstprinzipalen

Senden einer SMS mit Dienstprinzipalen

Schreiben der Main-Methode

Ausführen des Codes

Einrichten

Erstellen einer neuen Python-Anwendung

Installieren der SDK-Pakete

Erstellen einer neuen Datei

Verwenden der SDK-Pakete

Erstellen eines DefaultAzureCredential-Standards

Erstellen einer Identität und Ausstellen eines Tokens mit Dienstprinzipalen

Senden einer SMS mit Dienstprinzipalen

Schreiben des Hauptcodes

Ausführen des Programms

Nächste Schritte

Zusätzliche Ressourcen