Snabbstart: Autentisera med Microsoft Entra-ID

Välj ett datorspråk

Azure CLI C# JavaScript Java Python

Kom igång med Azure Communication Services med hjälp av Microsoft Entra-ID. Communication Services-identiteten och SMS-SDK:erna stöder Microsoft Entra-autentisering.

Den här snabbstarten visar hur du auktoriserar åtkomst till identitets- och SMS-SDK:er från en Azure-miljö som stöder Active Directory. Den beskriver också hur du testar koden i en utvecklingsmiljö genom att skapa ett huvudnamn för tjänsten för ditt arbete.

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration. Skapa ett konto kostnadsfritt
• En aktiv Azure Communication Services-resurs finns i Skapa en Communication Services-resurs om du inte har någon.
• Om du vill skicka ett SMS behöver du ett Telefon nummer.
• En konfigurationstjänsthuvudnamn för en utvecklingsmiljö finns i Auktorisera åtkomst med tjänstens huvudnamn

Ytterligare förutsättningar

• Azure CLI. Installationsguide

Inrätta

När du använder Active Directory för andra Azure-resurser bör du använda hanterade identiteter. Mer information om hur du aktiverar hanterade identiteter för Azure-resurser finns i någon av följande artiklar:

• Azure Portal
• Azure PowerShell
• Azure CLI
• Azure Resource Manager-mall
• Azure Resource Manager-SDK:er
• Apptjänster

Autentisera ett registrerat program i utvecklingsmiljön

Om utvecklingsmiljön inte stöder enkel inloggning eller inloggning via en webbläsare kan du använda ett registrerat program för att autentisera från utvecklingsmiljön.

Skapa ett Microsoft Entra-registrerat program

Om du vill skapa ett registrerat program från Azure CLI måste du vara inloggad på det Azure-konto där du vill att åtgärderna ska utföras. För att göra detta kan du använda az login kommandot och ange dina autentiseringsuppgifter i webbläsaren. När du har loggat in på ditt Azure-konto från CLI kan vi anropa az ad sp create-for-rbac kommandot för att skapa det registrerade programmet och tjänstens huvudnamn.

I följande exempel används Azure CLI för att skapa ett nytt registrerat program:

Azure CLI

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

Kommandot az ad sp create-for-rbac returnerar en lista över egenskaper för tjänstens huvudnamn i JSON-format. Kopiera dessa värden så att du kan använda dem för att skapa nödvändiga miljövariabler i nästa steg.

JSON

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

Viktigt

Det kan ta några minuter att sprida Azure-rolltilldelningar.

Ange miljövariabler

Azure Identity SDK läser värden från tre miljövariabler vid körning för att autentisera programmet. I följande tabell beskrivs värdet som ska anges för varje miljövariabel.

Miljövariabel	Värde
AZURE_CLIENT_ID	appId värdet från den genererade JSON
AZURE_TENANT_ID	tenant värdet från den genererade JSON
AZURE_CLIENT_SECRET	password värdet från den genererade JSON

Viktigt

När du har angett miljövariablerna stänger och öppnar du konsolfönstret igen. Om du använder Visual Studio eller en annan utvecklingsmiljö kan du behöva starta om den för att kunna registrera de nya miljövariablerna.

När dessa variabler har angetts bör du kunna använda standardobjektetAzureCredential i koden för att autentisera till valfri tjänstklient.

Anteckning

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 ActiveDirectoryQuickstart. Det här kommandot skapar ett enkelt "Hello World"-C#-projekt med en enda källfil: Program.cs.

Console

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Ändra katalogen till den nyligen skapade appmappen dotnet build och använd kommandot för att kompilera programmet.

Console

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installera SDK-paketen

Console

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

Använda SDK-paketen

Lägg till följande using direktiv för att Program.cs använda SDK:er för Azure Identity och Azure Storage.

C#

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

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential för den här snabbstarten. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. När det behövs för varje åtgärd ska vi skapa den i Program.cs klassen. Lägg till följande överst i -filen.

C#

private DefaultAzureCredential credential = new DefaultAzureCredential();

Utfärda en token med tjänstens huvudnamn

Nu ska vi lägga till kod som använder den skapade autentiseringsuppgiften för att utfärda en VoIP-åtkomsttoken. Vi anropar den här koden senare.

C#

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

Skicka ett SMS med tjänstens huvudnamn

Som ett annat exempel på hur du använder tjänstens huvudnamn lägger vi till den här koden som använder samma autentiseringsuppgifter för att skicka ett SMS:

C#

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

Skriva main-metoden

Du Program.cs bör redan ha en Main-metod, vi lägger till kod som anropar vår tidigare skapade kod för att demonstrera användningen av tjänstens huvudnamn:

C#

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

Den slutliga Program.cs filen bör se ut så här:

C#

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

Köra programmet

Nu bör du kunna köra programmet med hjälp av dotnet run från programmappen. Utdata bör likna följande:

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

Anteckning

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.

Console

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

Kör npm init -y för att skapa en package.json fil med standardinställningar.

Console

npm init -y

Installera SDK-paketen

Console

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

Skapa en ny fil

Öppna en ny fil med en textredigerare och spara den som index.js, vi placerar koden i den här filen.

Använda SDK-paketen

Lägg till följande require direktiv överst index.js för att använda Azure Identity och Azure Storage SDK:er.

JavaScript

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

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential för den här snabbstarten. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. När det behövs för varje åtgärd ska vi skapa den överst i filen index.js .

JavaScript

    const credential = new DefaultAzureCredential();

Skapa en identitet och utfärda en token med tjänstens huvudnamn

Nu ska vi skriva en funktion som skapar en ny identitet och utfärdar en token för den här identiteten. Vi använder den senare för att testa konfigurationen av tjänstens huvudnamn.

JavaScript

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

Skicka ett SMS med tjänstens huvudnamn

Nu kan skriva en funktion som använder tjänstens huvudnamn för att skicka ett SMS:

JavaScript

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

Skriva huvudfunktionen

Med våra funktioner skapade kan vi nu skriva en huvudfunktion för att anropa dem och demonstrera användningen av tjänstens huvudnamn:

JavaScript

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

Den slutliga index.js filen bör se ut så här:

JavaScript

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

Köra programmet

När allt är klart kan du köra filen genom att ange node index.js från projektets katalog. Om allt gick bra bör du se något som liknar följande.

Bash

    $ 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

Ytterligare förutsättningar för Java

För Java behöver du också:

• Java Development Kit (JDK) version 8 eller senare.
• Apache Maven.

Anteckning

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.

Console

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 här katalogen innehåller katalogen src/main/java projektkällkoden, src/test/java directory innehåller testkällan och pom.xml filen är projektets projektobjektmodell eller POM.

Installera -paketet

Öppna filen pom.xml i textredigeraren. Lägg till följande beroendeelement i gruppen med beroenden.

XML

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

Använda SDK-paketen

Lägg till följande import direktiv i koden för att använda SDK:er för Azure Identity och Azure Communication.

Java

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.*;

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential för den här snabbstarten. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. När det behövs för varje åtgärd ska vi skapa den i App.java klassen. Lägg till följande längst upp i App.java klassen.

Java

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

Utfärda en token med tjänstens huvudnamn

Nu ska vi lägga till kod som använder den skapade autentiseringsuppgiften för att utfärda en VoIP-åtkomsttoken. Vi anropar den här koden senare.

Java

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

Skicka ett SMS med tjänstens huvudnamn

Som ett annat exempel på hur du använder tjänstens huvudnamn lägger vi till den här koden som använder samma autentiseringsuppgifter för att skicka ett SMS:

Java

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

Skriva main-metoden

Du App.java bör redan ha en Main-metod, vi lägger till kod som anropar vår tidigare skapade kod för att demonstrera användningen av tjänstens huvudnamn:

Java

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

Din final App.java bör se ut så här:

Java

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

Kör koden

Navigera till katalogen som innehåller pom.xml-filen och kompilera projektet med hjälp av följande mvn kommando.

Console

mvn compile

Skapa sedan paketet.

Console

mvn package

Kör följande mvn kommando för att köra appen.

Console

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

De slutliga utdata bör likna följande:

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

Anteckning

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.

Console

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

Installera SDK-paketen

Console

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

Skapa en ny fil

Öppna och spara en ny fil i den skapade mappen med namnet authentication.py. Vi placerar koden i den här filen.

Använda SDK-paketen

Lägg till följande import instruktioner överst i filen för att använda de SDK:er som vi har installerat.

Python

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

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. Eftersom vi kommer att använda den i den här snabbstarten skapar vi den överst i filen.

Python

     credential = DefaultAzureCredential()

Skapa en identitet och utfärda en token med tjänstens huvudnamn

Nu ska vi lägga till kod som använder den skapade autentiseringsuppgiften för att utfärda en VoIP-åtkomsttoken. Vi anropar den här koden senare:

Python

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

Skicka ett SMS med tjänstens huvudnamn

Som ett annat exempel på hur du använder tjänstens huvudnamn lägger vi till den här koden som använder samma autentiseringsuppgifter för att skicka ett SMS:

Python

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
     )

Skriv vår huvudkod

Med våra funktioner skapade kan vi nu skriva huvudkoden som anropar de funktioner som vi tidigare har skrivit.

Python

# 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}');

Den slutliga authentication.py filen bör se ut ungefär så här:

Python

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

Köra programmet

När allt är klart kan du köra filen genom att ange python authentication.py från projektets katalog. Om allt gick bra bör du se något som liknar följande.

Bash

    $ 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

Nästa steg

• Läs mer om rollbaserad åtkomstkontroll i Azure
• Läs mer om Azure Identity Library för .NET
• Skapa användaråtkomsttoken
• Skicka ett SMS
• Läs mer om SMS
• Skapa snabbt en identitet för testning.