Démarrage rapide : s’authentifier avec Microsoft Entra ID

Article
03/25/2023

Commencez à utiliser Azure Communication Services avec Microsoft Entra ID. Les kits de développement logiciel (SDK) Identité Communication Services et SMS prennent en charge l’authentification Microsoft Entra.

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

Prérequis

Compte Azure avec un abonnement actif. Créez un compte gratuitement.
Une ressource Azure Communication Services active ou 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.
Un principal de service configuré pour un environnement de développement. Voir Autoriser l’accès avec un principal de service.

Autres prérequis

Azure CLI. Guide d'installation

Configuration

Quand 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 ressources Azure, consultez un de ces articles :

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 dans l’environnement de développement.

Création d’une application inscrite auprès de 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 commande az login 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 retourne une liste de propriétés de principal du service au format JSON. Copiez ces valeurs pour pouvoir les utiliser afin de 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 indique la valeur à définir pour chaque variable d’environnement.

Variable d’environnement	Valeur
`AZURE_CLIENT_ID`	Valeur `appId` du JSON généré
`AZURE_TENANT_ID`	Valeur `tenant` du JSON généré
`AZURE_CLIENT_SECRET`	Valeur `password` 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 afin qu’il enregistre les nouvelles variables d’environnement.

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

Notes

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

Configuration

Créer une application C#

Dans une fenêtre de console (par exemple cmd, PowerShell ou Bash), utilisez la commande dotnet new pour créer une application console avec le nom ActiveDirectoryQuickstart. Cette commande crée un projet C# « Hello World » simple avec un seul fichier source : Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Remplacez votre répertoire par le dossier d’application que vous venez de créer, puis utilisez la commande dotnet build pour compiler votre application.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installer les packages du kit SDK

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

Utiliser les packages du kit SDK

Ajoutez les directives using suivantes à Program.cs pour utiliser les Kits de développement logiciel (SDK) Azure Identity et Stockage Azure.

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

Créer un DefaultAzureCredential

Nous utiliserons le DefaultAzureCredential pour ce démarrage rapide. Ces informations d’identification sont appropriées pour les environnements de production et de développement. Comme elles sont nécessaires pour chaque opération, créons-les dans la classe Program.cs. Ajoutez ce qui suit au début du fichier.

private DefaultAzureCredential credential = new DefaultAzureCredential();

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

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

Votre Program.cs 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 :

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

Le fichier Program.cs final doit ressembler à ce qui suit :

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

Exécuter le programme

Vous devez maintenant être en mesure d’exécuter votre application en utilisant dotnet run à partir de votre dossier d’application. La sortie doit ressembler à ce qui suit :

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

Notes

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 SDK

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

Créer un 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 SDK

Ajoutez les directives require suivantes au début de index.js pour utiliser les Kits de développement logiciel (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

    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 l’utiliserons ultérieurement pour tester la configuration de notre 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 main

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 index.js final doit ressembler à ce qui suit :

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

Lorsque tout est terminé, vous pouvez exécuter le fichier en entrant node index.js dans le répertoire de votre projet. Si tout s’est bien passé, vous devez obtenir un résultat 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: Outgoing_2021040602194...._noam
    Send Result Successful: true

Autres composants requis pour Java

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

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

Notes

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 SDK

Ajoutez les directives import suivantes à 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 utiliserons le DefaultAzureCredential pour ce démarrage rapide. Ces informations d’identification sont appropriées pour les environnements de production et de développement. Comme elles sont nécessaires pour chaque opération, créons-les dans la classe App.java. Ajoutez le code suivant au début de la classe App.java.

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

Notes

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

Configuration

Créer une application Python

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

Installer les packages du kit SDK

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

Créer un fichier

Ouvrez et enregistrez un nouveau fichier dans le dossier que vous avez créé, appelé authentication.py. Nous placerons notre code dans ce fichier.

Utiliser les packages du kit SDK

Ajoutez les instructions import suivantes au début de votre fichier pour utiliser les Kits de développement logiciel (SDK) que vous avez installés.

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

Créer un DefaultAzureCredential

Nous allons utiliser le DefaultAzureCredential. Ces informations d’identification sont appropriées pour les environnements de production et de développement. Comme nous allons les utiliser tout au long de ce démarrage rapide, nous allons les créer au début du fichier.

     credential = DefaultAzureCredential()

Créer une identité et é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 :

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

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 :

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 le code principal

Après avoir créé nos fonctions, nous pouvons maintenant écrire le code principal qui appellera les fonctions que nous avons écrites précédemment.

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

Le fichier authentication.py final doit ressembler à ce qui suit :

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

Lorsque tout est terminé, vous pouvez exécuter le fichier en entrant python authentication.py dans le répertoire de votre projet. Si tout s’est bien passé, vous devez obtenir un résultat similaire à ce qui suit.

    $ 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

Démarrage rapide : s’authentifier avec Microsoft Entra ID

Prérequis

Autres prérequis

Configuration

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

Création d’une application inscrite auprès de Microsoft Entra

Définir des variables d’environnement

Configuration

Créer une application C#

Installer les packages du kit SDK

Utiliser les packages du kit 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 programme

Configuration

Création d’une application Node.js

Installer les packages du kit SDK

Créer un fichier

Utiliser les packages du kit 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 main

Exécuter le programme

Autres composants requis pour Java

Configuration

Créer une application Java

Installer le package

Utiliser les packages du kit 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 SDK

Créer un fichier

Utiliser les packages du kit 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 le code principal

Exécuter le programme

Étapes suivantes

Ressources supplémentaires