Guida introduttiva: Eseguire l'autenticazione con Microsoft Entra ID

Articolo
10/18/2023

Per iniziare a usare Servizi di comunicazione di Azure, usare Microsoft Entra ID. Gli SDK di Identità e SMS di 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 Telefono.
Un'entità servizio di installazione per un ambiente di sviluppo, vedere Autorizzare l'accesso con l'entità servizio

Prerequisiti aggiuntivi

Interfaccia della riga di comando di Azure. Guida all'installazione

Configurazione

Quando si usa Active Directory per altre risorse di Azure, è consigliabile usare identità gestite. Per informazioni su come abilitare 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 az ad sp create-for-rbac comando 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 dei ruoli 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.

Nota

Trovare il codice finalizzato per questa guida introduttiva in GitHub

Configurazione

Creare una nuova applicazione C#

In una finestra di una console, ad esempio cmd, PowerShell o Bash, usare il comando dotnet new per creare una nuova app console con il nome ActiveDirectoryQuickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Passare alla cartella dell'app appena creata e usare il comando dotnet build per compilare l'applicazione.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installare i pacchetti SDK

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

Usare i pacchetti SDK

Aggiungere le direttive seguenti using per Program.cs usare l'identità di Azure e gli SDK Archiviazione di Azure.

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

Creare un'istanza di DefaultAzureCredential

Per questa guida introduttiva si userà DefaultAzureCredential . Questa credenziale è adatta per ambienti di produzione e di sviluppo. Poiché è necessario per ogni operazione, è possibile crearlo all'interno della Program.cs classe . Aggiungere il valore seguente alla parte iniziale del file .

private DefaultAzureCredential credential = new DefaultAzureCredential();

Rilasciare un token con le 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(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

Come altro esempio di uso delle entità servizio, si aggiungerà questo codice che usa le stesse credenziali per inviare un 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 Main

È Program.cs necessario avere già un metodo Main, aggiungere un codice che chiamerà il codice creato in precedenza per illustrare l'uso delle entità servizio:

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

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

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

Eseguire il programma

A questo punto dovrebbe essere possibile eseguire l'applicazione usando dotnet run dalla cartella dell'applicazione. L'output sarà simile al seguente:

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

Nota

Trovare il codice finalizzato per questa guida introduttiva in 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 un'istanza di DefaultAzureCredential

    const credential = new DefaultAzureCredential();

Creare un'identità ed emettere un token con le 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, consente di scrivere una funzione che usa le 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 main

Con le funzioni create è ora possibile scrivere una funzione principale per chiamarle 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 dovrebbe vedere qualcosa di simile al seguente.

    $ 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

Prerequisiti aggiuntivi per Java

Per Java, è anche necessario:

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

Nota

Trovare il codice finalizzato per questa guida introduttiva in 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 un'istanza di DefaultAzureCredential

Per questa guida introduttiva si userà DefaultAzureCredential . Questa credenziale è adatta per ambienti di produzione e di sviluppo. Poiché è necessario per ogni operazione, è possibile crearlo all'interno della App.java classe . Aggiungere quanto segue all'inizio della App.java classe .

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

Rilasciare un token con le 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 uso delle entità servizio, si aggiungerà 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 Main

È App.java necessario avere già un metodo Main, aggiungere un codice che chiamerà il codice creato in precedenza per illustrare 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());
    }

L'ultima App.java dovrebbe essere simile alla seguente:

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

Compilare 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: Outgoing_202104...33f8ae1f_noam
Send Result Successful: true

Nota

Trovare il codice finalizzato per questa guida introduttiva in GitHub

Configurazione

Creare una nuova applicazione Python

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

Installare i pacchetti SDK

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

Creare un nuovo file

Aprire e salvare un nuovo file all'interno della cartella creata denominata authentication.py, il codice verrà inserito all'interno di questo file.

Usare i pacchetti SDK

Aggiungere le istruzioni seguenti import all'inizio del file per usare gli SDK installati.

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

Creare un'istanza di DefaultAzureCredential

Verrà usato DefaultAzureCredential. Questa credenziale è adatta per ambienti di produzione e di sviluppo. Come verrà usato in questa guida introduttiva, verrà creato all'inizio del file.

     credential = DefaultAzureCredential()

Creare un'identità ed emettere un token con le 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:

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

Come altro esempio di uso delle entità servizio, si aggiungerà questo codice che usa le stesse credenziali per inviare un SMS:

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

Con le funzioni create è ora possibile scrivere il codice principale che chiamerà le funzioni scritte in precedenza.

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

Il file finale authentication.py avrà un aspetto simile al seguente:

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

Al termine, è possibile eseguire il file immettendo python authentication.py dalla directory del progetto. Se tutto è andato bene dovrebbe vedere qualcosa di simile al seguente.

    $ 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

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

Configurazione

Creare una nuova applicazione C#

Installare i pacchetti SDK

Usare i pacchetti SDK

Creare un'istanza di DefaultAzureCredential

Rilasciare un token con le entità servizio

Inviare un SMS con entità servizio

Scrivere il metodo Main

Eseguire il programma

Configurazione

Creare una nuova applicazione Node.js

Installare i pacchetti SDK

Creare un nuovo file

Usare i pacchetti SDK

Creare un'istanza di DefaultAzureCredential

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

Inviare un SMS con entità servizio

Scrivere la funzione main

Eseguire il programma

Prerequisiti aggiuntivi per Java

Configurazione

Creare una nuova applicazione Java

Installare il pacchetto

Usare i pacchetti SDK

Creare un'istanza di DefaultAzureCredential

Rilasciare un token con le entità servizio

Inviare un SMS con entità servizio

Scrivere il metodo Main

Eseguire il codice

Configurazione

Creare una nuova applicazione Python

Installare i pacchetti SDK

Creare un nuovo file

Usare i pacchetti SDK

Creare un'istanza di DefaultAzureCredential

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

Inviare un SMS con entità servizio

Scrivere il codice principale

Eseguire il programma

Passaggi successivi

Risorse aggiuntive