Démarrage rapide : S’authentifier à l’aide de l’ID Microsoft Entra

Commencez avec Azure Communication Services en utilisant Microsoft Entra ID. Les kits SDK Communication Services Identity et SMS prennent en charge l’authentification Microsoft Entra.

Ce guide de démarrage rapide vous montre comment autoriser l’accès aux kits SDK Identity et SMS à partir d’un environnement Azure qui prend en charge Active Directory. Il décrit également comment tester votre code dans un environnement de développement en créant un principal de service pour votre travail.

Conditions préalables

Un compte Azure avec un abonnement actif. Créez un compte gratuitement.
Une ressource Azure Communication Services active, consultez créer une ressource Communication Services si vous n’en avez pas.
Pour envoyer un SMS, vous aurez besoin d’un numéro de téléphone.
Configuration d'un principal de service pour un environnement de développement ; consultez Autoriser l’accès avec un principal de service

Prérequis supplémentaires

Azure CLI. Guide d’installation

Configuration

Lorsque vous utilisez Active Directory pour d’autres ressources Azure, vous devez utiliser des identités managées. Pour savoir comment activer des identités managées pour les ressources Azure, consultez l’un des articles suivants :

Authentifier une application inscrite dans l’environnement de développement

Si votre environnement de développement ne prend pas en charge l’authentification unique ou la connexion via un navigateur web, vous pouvez utiliser une application inscrite pour vous authentifier à partir de l’environnement de développement.

Création d’une application enregistrée Microsoft Entra

Pour créer une application inscrite à partir d’Azure CLI, vous devez être connecté au compte Azure dans lequel vous souhaitez que les opérations soient effectuées. Pour ce faire, vous pouvez utiliser la az login commande et entrer vos informations d’identification dans le navigateur. Une fois que vous êtes connecté à votre compte Azure à partir de Azure CLI, vous pouvez appeler la commande az ad sp create-for-rbac pour créer l’application inscrite et le principal de service.

L’exemple suivant utilise Azure CLI pour créer une application inscrite :

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

La commande az ad sp create-for-rbac retournera une liste de propriétés du principal de service au format JSON. Copiez ces valeurs pour pouvoir les utiliser pour créer les variables d’environnement nécessaires à l’étape suivante.

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

Important

La propagation des attributions de rôles Azure peut prendre plusieurs minutes.

Définir des variables d’environnement

Le kit SDK Azure Identity lit les valeurs de trois variables d’environnement au moment de l’exécution pour authentifier l’application. Le tableau suivant décrit la valeur à définir pour chaque variable d’environnement.

Variable d’environnement	Valeur
`AZURE_CLIENT_ID`	`appId` valeur à partir du JSON généré
`AZURE_TENANT_ID`	`tenant` valeur à partir du JSON généré
`AZURE_CLIENT_SECRET`	`password` valeur à partir du JSON généré

Important

Après avoir défini les variables d’environnement, fermez et rouvrez votre fenêtre de console. Si vous utilisez Visual Studio ou un autre environnement de développement, vous devrez peut-être le redémarrer pour qu’il inscrive les nouvelles variables d’environnement.

Une fois ces variables définies, vous devez être en mesure d’utiliser l’objet DefaultAzureCredential dans votre code pour vous authentifier auprès du client de service de votre choix.

Remarque

Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.

Aperçu

Ce guide de démarrage rapide montre comment utiliser des identités managées via des principaux de service Azure pour s’authentifier auprès d’Azure Communication Services. Il fournit des exemples d’émission d’un jeton d’accès pour les appels Voice over IP (VoIP) et l’envoi de sms.

Configuration

Créer une application C#

L’objectif est de créer une application console en C# pour exécuter le code de démarrage rapide. Ouvrez une fenêtre de terminal (par exemple, invite de commandes, PowerShell ou Bash) et exécutez la commande suivante pour créer une application console nommée ActiveDirectoryAuthenticationQuickstart:

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Cette commande génère un projet C# simple « Hello World », y compris un fichier source unique : Program.cs.

Générer l’application

Accédez au dossier d’application nouvellement créé et compilez votre application à l’aide de la dotnet build commande :

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installer les packages du Kit de développement logiciel (SDK) requis

Pour interagir avec Azure Communication Services et l’identité Azure, ajoutez les packages NuGet suivants à votre projet :

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

Mettre à jour le fichier Program.cs

Pour utiliser les packages du Kit de développement logiciel (SDK) Azure installés, incluez les directives suivantes using en haut de votre Program.cs fichier :

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

S’authentifier auprès de DefaultAzureCredential

Pour ce guide de démarrage rapide, nous allons utiliser DefaultAzureCredential, qui convient aux environnements de développement et de production. Déclarez une instance de ces informations d’identification au niveau de la classe dans Program.cs :

private DefaultAzureCredential credential = new DefaultAzureCredential();

Émettre un jeton avec des principaux de service

Ajoutez la méthode suivante à votre Program.cs fichier. Cette méthode utilise le Kit de développement logiciel (SDK) Azure Communication Services pour émettre un jeton d’accès 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;
}

Envoyer un SMS avec des principaux de service

Pour illustrer l’envoi d’un SMS, ajoutez la méthode suivante à votre Program.cs fichier. Cette méthode utilise le Kit de développement logiciel (SDK) Azure Communication Services pour envoyer 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;
}

Écrire la méthode Main

Dans la méthode Main de votre fichier Program.cs, ajoutez le code pour appeler les méthodes que vous avez créées pour émettre un jeton et envoyer un SMS. Votre Main méthode doit ressembler à ceci :

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

Votre fichier final Program.cs doit ressembler à ceci :

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

Exécuter le programme

Il est temps d’exécuter votre application et de vérifier qu’elle récupère un jeton d’accès et envoie un SMS. Ouvrez un terminal, accédez à votre répertoire d’application et exécutez :

     dotnet run

La sortie de la console doit apparaître comme suit :

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

Remarque

Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.

Configuration

Création d’une application Node.js

Ouvrez votre fenêtre de terminal ou de commande, créez un répertoire pour votre application, puis accédez-y.

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

Exécutez npm init -y pour créer un fichier package.json avec les paramètres par défaut.

npm init -y

Installer les packages du Kit de développement logiciel (SDK)

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

Créer un nouveau fichier

Ouvrez un nouveau fichier avec un éditeur de texte et enregistrez-le sous index.js, nous placerons notre code dans ce fichier.

Utiliser les packages du Kit de développement logiciel (SDK)

Ajoutez les directives suivantes require en haut de index.js pour utiliser les SDK Azure Identity et Stockage Azure.

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

Créer un DefaultAzureCredential

Nous allons utiliser DefaultAzureCredential pour ce démarrage rapide. Ces informations d’identification sont appropriées pour les environnements de production et de développement. Comme cela est nécessaire pour chaque opération, nous allons la créer au sommet de notre fichier index.js.

    const credential = new DefaultAzureCredential();

Créer une identité et émettre un jeton avec des principaux de service

Ensuite, nous allons écrire une fonction qui crée une nouvelle identité et émet un jeton pour cette identité, nous allons l’utiliser ultérieurement pour tester notre configuration du principal de service.

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

Envoyer un SMS avec des principaux de service

À présent, nous allons écrire une fonction qui utilise des principaux de service pour envoyer 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
    );
}

Écrire la fonction principale

Après avoir créé nos fonctions, nous pouvons maintenant écrire une fonction principale pour les appeler et démontrer l’utilisation des principaux de service :

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

Le fichier final index.js doit ressembler à ceci :

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

Exécuter le programme

Une fois tout terminé, vous pouvez exécuter le fichier en entrant node index.js depuis le répertoire de votre projet. Si tout s’est bien passé, vous devriez voir quelque chose de similaire à ce qui suit.

    $ 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

Prérequis supplémentaires pour Java

Pour Java, vous aurez également besoin des éléments suivants :

Java Development Kit (JDK) version 8 ou ultérieure.
Apache Maven.

Remarque

Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.

Configuration

Créer une application Java

Ouvrez votre fenêtre de terminal ou de commande. Accédez au répertoire dans lequel vous souhaitez créer votre application Java. Exécutez la commande ci-dessous pour générer le projet Java à partir du modèle maven-archetype-quickstart.

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

Vous remarquerez que la tâche « generate » a créé un répertoire portant le même nom que l’artifactId. Sous ce répertoire, le répertoire src/main/java contient le code source du projet, src/test/java directory contient la source de test, et le fichier pom.xml est le modèle objet du projet (le POM).

Installer le package

Ouvrez le fichier pom.xml dans votre éditeur de texte. Ajoutez l’élément dépendance suivant au groupe de dépendances.

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

Utiliser les packages du Kit de développement logiciel (SDK)

Ajoutez les directives suivantes import à votre code pour utiliser les kits SDK Azure Identity et 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.*;

Créer un DefaultAzureCredential

Nous allons utiliser DefaultAzureCredential pour ce démarrage rapide. Ces informations d’identification sont appropriées pour les environnements de production et de développement. Comme il est nécessaire pour chaque opération, nous allons le créer dans la App.java classe. Ajoutez ce qui suit en haut de la App.java classe.

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

Émettre un jeton avec des principaux de service

Nous allons maintenant ajouter du code qui utilise les informations d’identification créées pour émettre un jeton d’accès VoIP. Nous appellerons ce code plus tard :

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

Envoyer un SMS avec des principaux de service

Comme autre exemple d’utilisation des principaux de service, nous allons ajouter ce code qui utilise les mêmes informations d’identification pour envoyer 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);
     }

Écrire la méthode Main

Votre App.java doit déjà disposer d’une méthode main. Ajoutons du code qui appellera notre code précédemment créé pour démontrer l’utilisation des principaux de service :

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

Votre résultat final App.java doit ressembler à ceci :

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

Exécuter le code

Accédez au répertoire contenant le fichier pom.xml, puis compilez le projet à l’aide de la commande mvn suivante.

mvn compile

Ensuite, générez le package.

mvn package

Exécutez la commande mvn suivante pour exécuter l’application.

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

La sortie finale doit ressembler à ce qui suit :

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

Remarque

Vous trouverez le code finalisé pour ce guide de démarrage rapide sur GitHub.

Configuration

Créer une application Python

Nous allons configurer votre répertoire de travail pour l’application. Pour cela, ouvrez votre terminal ou fenêtre de commande, créez un répertoire et accédez-y :

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

Installer les packages du Kit de développement logiciel (SDK)

Ensuite, nous devons installer les packages du Kit de développement logiciel (SDK) Azure requis. Exécutez les commandes suivantes :

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

Créer un nouveau fichier

Nous avons maintenant besoin d’un fichier Python pour contenir votre code. Ouvrez et enregistrez un nouveau fichier appelé authentication.py dans votre répertoire.

Utiliser les packages du Kit de développement logiciel (SDK)

Notre prochain objectif est d’importer les modules du Kit de développement logiciel (SDK) Azure nécessaires pour travailler avec l’identité et le SMS. Ajoutez les instructions suivantes en haut de votre fichier :

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

Créer un DefaultAzureCredential

Nous devons initialiser une authentification pour les environnements de production et de développement.

Placez cette ligne avec DefaultAzureCredential après les lignes précédemment insérées :

     credential = DefaultAzureCredential()

Créer une identité et émettre un jeton avec des principaux de service

Créez une identité et demandez un jeton d’accès Voice over Internet Protocol (VoIP) :

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

Envoyer un SMS avec des principaux de service

Vous pouvez également utiliser vos informations d’identification pour envoyer un service sms (Short Message Service), comme illustré dans l’exemple ci-dessous :

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
     )

Écrire notre code principal

Maintenant, nous avons tous les blocs de code nécessaires pour exécuter les fonctions pour créer une identité, obtenir un jeton d’accès et envoyer un SMS.

Incluez le code principal qui appelle vos fonctions :

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

Voici à quoi authentication.py ressemble après toutes les modifications que vous avez apportées :

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

Exécuter le programme

Il est temps d’exécuter votre script Python pour vérifier les fonctionnalités. Exécutez le fichier à partir du répertoire de votre projet avec la commande :

python authentication.py

Si elle réussit, vous voyez une sortie similaire à celle-ci :

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

Étapes suivantes

Commentaires

Est-ce que cette page vous a été utile?

Last updated on 2025-06-20

Partage via

Démarrage rapide : S’authentifier à l’aide de l’ID Microsoft Entra

Conditions préalables

Prérequis supplémentaires

Configuration

Authentifier une application inscrite dans l’environnement de développement

Création d’une application enregistrée Microsoft Entra

Définir des variables d’environnement

Aperçu

Configuration

Créer une application C#

Générer l’application

Installer les packages du Kit de développement logiciel (SDK) requis

Mettre à jour le fichier Program.cs

S’authentifier auprès de DefaultAzureCredential

Émettre un jeton avec des principaux de service

Envoyer un SMS avec des principaux de service

Écrire la méthode Main

Exécuter le programme

Configuration

Création d’une application Node.js

Installer les packages du Kit de développement logiciel (SDK)

Créer un nouveau fichier

Utiliser les packages du Kit de développement logiciel (SDK)

Créer un DefaultAzureCredential

Créer une identité et émettre un jeton avec des principaux de service

Envoyer un SMS avec des principaux de service

Écrire la fonction principale

Exécuter le programme

Prérequis supplémentaires pour Java

Configuration

Créer une application Java

Installer le package

Utiliser les packages du Kit de développement logiciel (SDK)

Créer un DefaultAzureCredential

Émettre un jeton avec des principaux de service

Envoyer un SMS avec des principaux de service

Écrire la méthode Main

Exécuter le code

Configuration

Créer une application Python

Installer les packages du Kit de développement logiciel (SDK)

Créer un nouveau fichier

Utiliser les packages du Kit de développement logiciel (SDK)

Créer un DefaultAzureCredential

Créer une identité et émettre un jeton avec des principaux de service

Envoyer un SMS avec des principaux de service

Écrire notre code principal

Exécuter le programme

Étapes suivantes

Commentaires

Ressources supplémentaires