Guida introduttiva: Eseguire l'autenticazione con Microsoft Entra ID

2025-06-20

Introduzione a Servizi di comunicazione di Azure con Microsoft Entra ID. Gli SDK di Identità e SMS dei Servizi di Comunicazione supportano l'autenticazione di Microsoft Entra.

Questa guida introduttiva illustra come autorizzare l'accesso agli SDK di identità e SMS da un ambiente di Azure che supporta Active Directory. Descrive anche come testare il codice in un ambiente di sviluppo creando un'entità servizio per il lavoro.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuitamente
Una risorsa di Servizi di comunicazione di Azure attiva, vedere Creare una risorsa di Servizi di comunicazione se non ne è disponibile una.
Per inviare un SMS è necessario un numero di telefono.
Per configurare un'entità servizio per un ambiente di sviluppo, vedere Autorizzare l'accesso con entità servizio

Prerequisiti aggiuntivi

Interfaccia della riga di comando di Azure (CLI) Guida all'installazione

Configurazione

Quando si usa Active Directory per altre risorse di Azure, è consigliabile usare identità gestite. Per informazioni su come abilitare le identità gestite per le risorse di Azure, vedere uno di questi articoli:

Autenticare un'applicazione registrata nell'ambiente di sviluppo

Se l'ambiente di sviluppo non supporta l'accesso Single Sign-On o l'accesso tramite un Web browser, è possibile usare un'applicazione registrata per l'autenticazione dall'ambiente di sviluppo.

Creazione di un'applicazione registrata di Microsoft Entra

Per creare un'applicazione registrata dall'interfaccia della riga di comando di Azure, è necessario accedere all'account Azure in cui si vuole eseguire le operazioni. A tale scopo, è possibile usare il az login comando e immettere le credenziali nel browser. Dopo aver eseguito l'accesso all'account Azure dall'interfaccia della riga di comando, è possibile chiamare il comando az ad sp create-for-rbac per creare l'applicazione registrata e l'entità servizio.

L'esempio seguente usa l'interfaccia della riga di comando di Azure per creare una nuova applicazione registrata:

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

Il az ad sp create-for-rbac comando restituirà un elenco di proprietà dell'entità servizio in formato JSON. Copiare questi valori in modo che sia possibile usarli per creare le variabili di ambiente necessarie nel passaggio successivo.

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

Importante

La propagazione delle assegnazioni di ruolo di Azure può richiedere alcuni minuti.

Impostare le variabili di ambiente

Azure Identity SDK legge i valori da tre variabili di ambiente in fase di esecuzione per autenticare l'applicazione. Nella tabella seguente viene descritto il valore da impostare per ogni variabile di ambiente.

Variabile di ambiente	Valore
`AZURE_CLIENT_ID`	`appId` valore dal codice JSON generato
`AZURE_TENANT_ID`	`tenant` valore dal codice JSON generato
`AZURE_CLIENT_SECRET`	`password` valore dal codice JSON generato

Importante

Dopo aver impostato le variabili di ambiente, chiudere e riaprire la finestra della console. Se si usa Visual Studio o un altro ambiente di sviluppo, potrebbe essere necessario riavviarlo per registrare le nuove variabili di ambiente.

Dopo aver impostato queste variabili, sarà possibile usare l'oggetto DefaultAzureCredential nel codice per eseguire l'autenticazione al client del servizio preferito.

Annotazioni

Trova il codice definitivo per questa guida introduttiva su GitHub

Informazioni generali

Questa guida introduttiva illustra come utilizzare le identità gestite tramite i Principali del Servizio di Azure per l'autenticazione con i Servizi di Comunicazione di Azure. Fornisce esempi per l'emissione di un token di accesso per chiamate VoIP (Voice over IP) e l'invio di messaggi SMS.

Configurazione

Creare una nuova applicazione C#

L'obiettivo è creare una nuova applicazione console in C# per eseguire il codice di avvio rapido. Aprire una finestra del terminale (ad esempio, prompt dei comandi, PowerShell o Bash) ed eseguire il comando seguente per creare una nuova app console denominata ActiveDirectoryAuthenticationQuickstart:

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Questo comando genererà un semplice progetto C# "Hello World", incluso un singolo file di origine: Program.cs.

Compilare l'applicazione

Passare alla cartella dell'app appena creata e compilare l'applicazione usando il dotnet build comando :

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installare i pacchetti SDK necessari

Per interagire con Servizi di comunicazione di Azure e Identità di Azure, aggiungere i pacchetti NuGet seguenti al progetto:

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

Aggiornare il file Program.cs

Per usare i pacchetti di Azure SDK installati, includere le direttive seguenti using all'inizio del Program.cs file:

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

Eseguire l'autenticazione con DefaultAzureCredential

Per questa guida introduttiva si userà DefaultAzureCredential, adatto sia per gli ambienti di sviluppo che per gli ambienti di produzione. Dichiarare un'istanza di queste credenziali a livello di classe in Program.cs:

private DefaultAzureCredential credential = new DefaultAzureCredential();

Emettere un token con entità servizio

Aggiungere il metodo seguente al Program.cs file. Questo metodo usa Azure Communication Services SDK per rilasciare un token di accesso VoIP:

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

Inviare un SMS con entità servizio

Per illustrare l'invio di un SMS, aggiungere il metodo seguente al Program.cs file. Questo metodo usa Azure Communication Services SDK per inviare un messaggio 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;
}

Scrivere il metodo principale

Nel metodo Main del file Program.cs, aggiungere il codice per chiamare i metodi creati per l'emissione di un token e l'invio di un SMS. Il Main metodo dovrebbe essere simile al seguente:

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

Il file finale Program.cs sarà simile al seguente:

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

Eseguire il programma

È il momento di eseguire l'applicazione e verificare che recuperi un token di accesso e invii un SMS. Aprire un terminale, passare alla directory dell'applicazione ed eseguire:

     dotnet run

L'output della console dovrebbe essere visualizzato come segue:

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

Annotazioni

Trova il codice definitivo per questa guida introduttiva su GitHub

Configurazione

Creare una nuova applicazione Node.js

Aprire il terminale o la finestra di comando per creare una nuova directory per l'app e passare a tale directory.

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

Eseguire npm init -y per creare un file package.json con le impostazioni predefinite.

npm init -y

Installare i pacchetti SDK

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

Creare un nuovo file

Aprire un nuovo file con un editor di testo e salvarlo come index.js, il codice verrà inserito all'interno di questo file.

Usare i pacchetti SDK

Aggiungere le direttive seguenti require all'inizio di index.js per usare Azure Identity e Gli SDK di Archiviazione di Azure.

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

Creare DefaultAzureCredential

Per questo avvio rapido verrà usato DefaultAzureCredential. Questa credenziale è adatta per ambienti di produzione e di sviluppo. Poiché è necessario per ogni operazione, è possibile crearlo all'interno della parte superiore del index.js file.

    const credential = new DefaultAzureCredential();

Creare un'identità ed emettere un token con entità servizio

Verrà quindi scritta una funzione che crea una nuova identità e rilascia un token per questa identità, che verrà usata in un secondo momento per testare la configurazione dell'entità servizio.

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

Inviare un SMS con entità servizio

Ora viene scritta una funzione che usa entità servizio per inviare un 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
    );
}

Scrivere la funzione principale

Con le funzioni create, ora è possibile scrivere una funzione principale per richiamarle e dimostrare l'uso delle entità servizio:

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

Il file finale index.js sarà simile al seguente:

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

Eseguire il programma

Al termine, è possibile eseguire il file immettendo node index.js dalla directory del progetto. Se tutto è andato bene, dovresti vedere qualcosa di simile alla schermata seguente.

    $ 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

Prerequisiti aggiuntivi per Java

Per Java, è anche necessario:

Java Development Kit (JDK) versione 8 o successiva.
Apache Maven.

Annotazioni

Trova il codice definitivo per questa guida introduttiva su GitHub

Configurazione

Creare una nuova applicazione Java

Aprire la finestra del terminale o di comando. Passare alla directory in cui creare l'applicazione Java. Eseguire il comando seguente per generare il progetto Java dal modello maven-archetype-quickstart.

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

Si noterà che l'attività 'generate' ha creato una directory con lo stesso nome di artifactId. In questa directory, la directory src/main/java contiene il codice sorgente del progetto, la directory src/test/java directory contiene l'origine di test e il file pom.xml è il modello a oggetti del progetto o POM.

Installare il pacchetto

Aprire il file pom.xml nell'editor di testo. Aggiungere l'elemento di dipendenza seguente al gruppo di dipendenze.

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

Usare i pacchetti SDK

Aggiungere le direttive seguenti import al codice per usare Azure Identity e Azure Communication SDK.

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

Creare DefaultAzureCredential

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

Emettere un token con entità servizio

A questo punto si aggiungerà il codice che usa le credenziali create per rilasciare un token di accesso VoIP. Questo codice verrà chiamato più avanti;

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

Inviare un SMS con entità servizio

Come altro esempio di utilizzo delle entità servizio, verrà aggiunto questo codice che usa le stesse credenziali per inviare un 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);
     }

Scrivere il metodo principale

App.java dovrebbe già avere un metodo principale; ora si aggiunge il codice che chiamerà il codice creato in precedenza per dimostrare l'uso delle entità servizio:

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

Il tuo App.java finale dovrebbe apparire così:

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

Eseguire il codice

Passare alla directory contenente il file pom.xml e compilare il progetto tramite il comando mvn seguente.

mvn compile

Quindi, compila il pacchetto.

mvn package

Eseguire il comando mvn seguente per eseguire l'app.

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

L'output finale dovrebbe essere simile al seguente:

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

Annotazioni

Trova il codice definitivo per questa guida introduttiva su GitHub

Configurazione

Creare una nuova applicazione Python

Ora si configura la directory di lavoro per l'applicazione. Apri il terminale o la finestra di comando, crea una nuova directory e accedici:

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

Installare i pacchetti SDK

Successivamente è necessario installare i pacchetti di Azure SDK necessari. Eseguire questi comandi:

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

Creare un nuovo file

A questo momento è necessario un file Python per contenere il codice. Aprire e salvare un nuovo file denominato authentication.py all'interno della directory.

Usare i pacchetti SDK

L'obiettivo successivo consiste nell'importare i moduli di Azure SDK necessari per lavorare con identità e SMS. Aggiungere le istruzioni seguenti all'inizio del file:

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

Creare DefaultAzureCredential

È necessario inizializzare una credenziale sia per gli ambienti di produzione che per gli ambienti di sviluppo.

Inserire questa riga con DefaultAzureCredential dopo le righe inserite in precedenza:

     credential = DefaultAzureCredential()

Creare un'identità ed emettere un token con entità servizio

Creare un'identità e richiedere un token di accesso VoIP (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

Inviare un SMS con entità servizio

In alternativa, è possibile usare le credenziali per inviare un SMS (Short Message Service), come illustrato nell'esempio seguente:

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
     )

Scrivere il codice principale

Ora sono disponibili tutti i blocchi di codice necessari per eseguire le funzioni per creare un'identità, ottenere un token di accesso e inviare un SMS.

Inserisci il codice principale che chiama le tue funzioni.

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

Ecco come appare il authentication.py dopo tutte le modifiche apportate:

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

Eseguire il programma

È il momento di eseguire lo script Python per verificare la funzionalità. Eseguire il file dalla directory del progetto con il comando :

python authentication.py

In caso di esito positivo, viene visualizzato un output simile al seguente:

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

Condividi tramite

Guida introduttiva: Eseguire l'autenticazione con Microsoft Entra ID

Prerequisiti

Prerequisiti aggiuntivi

Configurazione

Autenticare un'applicazione registrata nell'ambiente di sviluppo

Creazione di un'applicazione registrata di Microsoft Entra

Impostare le variabili di ambiente

Informazioni generali

Configurazione

Creare una nuova applicazione C#

Compilare l'applicazione

Installare i pacchetti SDK necessari

Aggiornare il file Program.cs

Eseguire l'autenticazione con DefaultAzureCredential

Emettere un token con entità servizio

Inviare un SMS con entità servizio

Scrivere il metodo principale

Eseguire il programma

Configurazione

Creare una nuova applicazione Node.js

Installare i pacchetti SDK

Creare un nuovo file

Usare i pacchetti SDK

Creare DefaultAzureCredential

Creare un'identità ed emettere un token con entità servizio

Inviare un SMS con entità servizio

Scrivere la funzione principale

Eseguire il programma

Prerequisiti aggiuntivi per Java

Configurazione

Creare una nuova applicazione Java

Installare il pacchetto

Usare i pacchetti SDK

Creare DefaultAzureCredential

Emettere un token con entità servizio

Inviare un SMS con entità servizio

Scrivere il metodo principale

Eseguire il codice

Configurazione

Creare una nuova applicazione Python

Installare i pacchetti SDK

Creare un nuovo file

Usare i pacchetti SDK

Creare DefaultAzureCredential

Creare un'identità ed emettere un token con entità servizio

Inviare un SMS con entità servizio

Scrivere il codice principale

Eseguire il programma

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive