Démarrage rapide : s’authentifier avec Microsoft Entra ID
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 :
- Azure portal
- Azure PowerShell
- Azure CLI
- Modèle Azure Resource Manager
- Kits SDK Azure Resource Manager
- App Services
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
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 au début 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 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