Snabbstart: Autentisera med Microsoft Entra-ID

2025-06-19

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 telefonnummer.
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:

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:

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.

{
    "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 för Azure-rolltilldelningar att träda i kraft.

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.

Anmärkning

Hitta den färdiga koden för den här snabbstarten på GitHub

Översikt

Den här snabbstarten visar hur du använder hanterade identiteter via Azure Service Principals för att autentisera med Azure Communication Services. Den innehåller exempel för att utfärda en åtkomsttoken för VoIP-samtal (Voice over IP) och skicka SMS.

Förbereda

Skapa ett nytt C#-program

Målet är att skapa ett nytt konsolprogram i C# för att köra snabbstartskoden. Öppna ett terminalfönster (t.ex. kommandotolken, PowerShell eller Bash) och kör följande kommando för att skapa en ny konsolapp med namnet ActiveDirectoryAuthenticationQuickstart:

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Det här kommandot genererar ett enkelt "Hello World" C#-projekt, inklusive en enda källfil: Program.cs.

Skapa programmet

Gå till den nyligen skapade appmappen och kompilera programmet med kommandot dotnet build :

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installera nödvändiga SDK-paket

Om du vill interagera med Azure Communication Services och Azure Identity lägger du till följande NuGet-paket i projektet:

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

Uppdatera Program.cs-filen

Om du vill använda de installerade Azure SDK-paketen inkluderar du följande using direktiv överst Program.cs i filen:

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

Autentisera med DefaultAzureCredential

I den här snabbstarten använder vi StandardAzureCredential, som är lämplig för både utvecklings- och produktionsmiljöer. Deklarera en instans av den här autentiseringsuppgiften på klassnivå i Program.cs:

private DefaultAzureCredential credential = new DefaultAzureCredential();

Utfärda en token med tjänstens huvudnamn

Lägg till följande metod i Program.cs filen. Den här metoden använder Azure Communication Services SDK för att utfärda en VoIP-åtkomsttoken:

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

Om du vill visa hur du skickar ett SMS lägger du till följande metod i Program.cs filen. Den här metoden använder Azure Communication Services SDK för att skicka ett SMS:

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

Skriv Main-metoden

Main I metoden för filen Program.cs lägger du till kod för att anropa de metoder som du skapade för att utfärda en token och skicka ett SMS. Metoden Main bör se ut ungefär så här:

static void Main(string[] args)
{
    // Replace <RESOURCE_NAME> with your Communication Services resource name,
    // for example: "https://<RESOURCE_NAME>.communication.azure.com".
    Uri endpoint = new("https://<RESOURCENAME>.communication.azure.com/");

    // Create an instance of the Program class to invoke instance methods.
    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");

    // Replace with your Azure Communication Services phone number and the target phone number.
    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:

class Program
     {
          private DefaultAzureCredential credential = new DefaultAzureCredential();
          static void Main(string[] args)
          {
               // Replace <RESOURCE_NAME> with your Communication Services resource name,
               // for example: "https://<RESOURCE_NAME>.communication.azure.com".
               Uri endpoint = new("https://acstestingrifox.communication.azure.com/");

               // Create an instance of the Program class to invoke instance methods.
               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");

               // Replace with your Azure Communication Services phone number and the target phone number.
               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

Det är dags att köra programmet och kontrollera att det hämtar en åtkomsttoken och skickar ett SMS. Öppna en terminal, navigera till programkatalogen och kör:

     dotnet run

Konsolens utdata bör visas på följande sätt:

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

Anmärkning

Hitta den färdiga koden för den här snabbstarten på GitHub

Förbereda

Skapa ett nytt Node.js-program

Öppna terminalen eller kommandofönstret skapa en ny katalog för din app och navigera till den.

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.

npm init -y

Installera SDK-paketen

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.

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

Skapa en DefaultAzureCredential

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 .

    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.

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

Skicka ett SMS med tjänstens huvudnamn

Låt oss nu skriva en funktion som använder tjänsteprincipaler för att kunna skicka SMS.

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

När vi har skapat våra funktioner kan vi nu skriva en huvudfunktion för att anropa dem och demonstrera användningen av serviceprincipaler.

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:

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.

    $ node index.js
    Retrieving new Access Token, using Service Principals
    Retrieved Access Token: ey...Q
    Sending SMS using Service Principals
    SMS ID: ...
    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.

Anmärkning

Hitta den färdiga koden för den här snabbstarten på GitHub

Förbereda

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

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

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 DefaultAzureCredential

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.

    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:

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

Skriv Main-metoden

Du App.java bör redan ha en Main-metod, låt oss lägga till viss kod som kommer att anropa vår tidigare skapade kod för att demonstrera användningen av tjänsthuvudmän:

    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 slutliga App.java bör se ut så här:

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.

mvn compile

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

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: ...
Send Result Successful: true

Anmärkning

Hitta den färdiga koden för den här snabbstarten på GitHub

Förbereda

Skapa ett nytt Python-program

Låt oss konfigurera arbetskatalogen för programmet. För det öppnar du terminalen eller kommandofönstret, skapar en ny katalog och navigerar till den:

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

Installera SDK-paketen

Därefter måste vi installera nödvändiga Azure SDK-paket. Kör följande kommandon:

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

Skapa en ny fil

Nu behöver vi en Python-fil för att lagra koden. Öppna och spara en ny fil med namnet authentication.py i din katalog.

Använda SDK-paketen

Vårt nästa mål är att importera nödvändiga Azure SDK-moduler för att arbeta med identitet och SMS. Lägg till följande instruktioner överst i filen:

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

Skapa en DefaultAzureCredential

Vi måste initiera autentiseringsuppgifter för både produktions- och utvecklingsmiljöer.

Placera den här raden med DefaultAzureCredential efter tidigare infogade rader:

     credential = DefaultAzureCredential()

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

Skapa en identitet och begär en VoIP-åtkomsttoken (Voice over Internet Protocol):

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

Du kan också använda dina autentiseringsuppgifter för att skicka en kort meddelandetjänst (SMS) som du ser i exemplet nedan:

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

Nu har vi alla nödvändiga kodblock för att köra funktionerna för att skapa en identitet, hämta en åtkomsttoken och skicka ett SMS.

Inkludera huvudkoden som anropar dina funktioner:

# Retrieve your endpoint and access key from your resource in the Azure portal
# For example: "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");

# Provide a valid phone number from your Azure 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}');

Så här ser det authentication.py ut efter alla ändringar du har gjort:

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

Det är dags att köra Python-skriptet för att verifiera funktioner. Kör filen från projektets katalog med kommandot :

python authentication.py

Om det lyckas visas utdata som liknar följande:

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

Nästa steg

Feedback

Var den här sidan till hjälp?

Dela via

Snabbstart: Autentisera med Microsoft Entra-ID

Förutsättningar

Ytterligare förutsättningar

Inrätta

Autentisera ett registrerat program i utvecklingsmiljön

Skapa ett Microsoft Entra-registrerat program

Ange miljövariabler

Översikt

Förbereda

Skapa ett nytt C#-program

Skapa programmet

Installera nödvändiga SDK-paket

Uppdatera Program.cs-filen

Autentisera med DefaultAzureCredential

Utfärda en token med tjänstens huvudnamn

Skicka ett SMS med tjänstens huvudnamn

Skriv Main-metoden

Köra programmet

Förbereda

Skapa ett nytt Node.js-program

Installera SDK-paketen

Skapa en ny fil

Använda SDK-paketen

Skapa en DefaultAzureCredential

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

Skicka ett SMS med tjänstens huvudnamn

Skriva huvudfunktionen

Köra programmet

Ytterligare förutsättningar för Java

Förbereda

Skapa ett nytt Java-program

Installera paketet

Använda SDK-paketen

Skapa en DefaultAzureCredential

Utfärda en token med tjänstens huvudnamn

Skicka ett SMS med tjänstens huvudnamn

Skriv Main-metoden

Kör koden

Förbereda

Skapa ett nytt Python-program

Installera SDK-paketen

Skapa en ny fil

Använda SDK-paketen

Skapa en DefaultAzureCredential

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

Skicka ett SMS med tjänstens huvudnamn

Skriv vår huvudkod

Köra programmet

Nästa steg

Feedback

Ytterligare resurser