Inicio rápido: Autenticación mediante el identificador de Microsoft Entra

2025-06-20

Introducción a Azure Communication Services mediante el identificador de Entra de Microsoft. Los SDK de identidad y SMS de Communication Services admiten la autenticación de Microsoft Entra.

En este inicio rápido se muestra cómo autorizar el acceso a los SDK de identidad y SMS desde un entorno de Azure que admite Active Directory. También explica cómo probar tu código en un entorno de desarrollo creando una entidad de servicio para tu proyecto.

Prerrequisitos

Una cuenta de Azure con una suscripción activa. Cree su cuenta de forma gratuita.
Un recurso activo de Azure Communication Services, consulte Creación de un recurso de Communication Services si no tiene uno.
Para enviar un SMS, necesitará un número de teléfono.
Una entidad de servicio de configuración para un entorno de desarrollo, consulte Autorización del acceso con la entidad de servicio

Requisitos previos adicionales

CLI de Azure. Guía de instalación

Instalación

Al usar Active Directory para otros recursos de Azure, debe usar identidades administradas. Para obtener información sobre cómo habilitar identidades administradas para recursos de Azure, consulte uno de estos artículos:

Autenticación de una aplicación registrada en el entorno de desarrollo

Si el entorno de desarrollo no admite el inicio de sesión único ni el inicio de sesión a través de un explorador web, puede usar una aplicación registrada para autenticarse desde el entorno de desarrollo.

Creación de una aplicación registrada de Microsoft Entra

Para crear una aplicación registrada desde la CLI de Azure, debe iniciar sesión en la cuenta de Azure donde quiere que se realicen las operaciones. Para ello, puede usar el az login comando y escribir sus credenciales en el explorador. Una vez que haya iniciado sesión en la cuenta de Azure desde la CLI, podemos llamar al comando az ad sp create-for-rbac para crear la aplicación registrada y la entidad de servicio.

En el ejemplo siguiente se usa la CLI de Azure para crear una aplicación registrada:

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

El az ad sp create-for-rbac comando devolverá una lista de propiedades de entidad de servicio en formato JSON. Copie estos valores para poder usarlos para crear las variables de entorno necesarias en el paso siguiente.

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

Importante

Las asignaciones de roles de Azure pueden tardar unos minutos en propagarse.

Establecimiento de variables de entorno

El SDK de Azure Identity lee valores de tres variables de entorno en tiempo de ejecución para autenticar la aplicación. En la tabla siguiente se describe el valor que se va a establecer para cada variable de entorno.

Variable del entorno	Importancia
`AZURE_CLIENT_ID`	`appId` valor del JSON generado
`AZURE_TENANT_ID`	`tenant` valor del JSON generado
`AZURE_CLIENT_SECRET`	`password` valor del JSON generado

Importante

Después de establecer las variables de entorno, cierre y vuelva a abrir la ventana de la consola. Si usa Visual Studio u otro entorno de desarrollo, es posible que tenga que reiniciarlo para que registre las nuevas variables de entorno.

Una vez establecidas estas variables, debería poder usar el objeto DefaultAzureCredential en el código para autenticarse en el cliente de servicio que prefiera.

Nota:

Busque el código finalizado de este inicio rápido en GitHub

Información general

En este inicio rápido se muestra cómo usar identidades administradas a través de entidades de servicio de Azure para autenticarse con Azure Communication Services. Proporciona ejemplos para emitir un token de acceso para llamadas de voz a través de IP (VoIP) y enviar mensajes SMS.

Instalación

Creación de una aplicación de C#

El objetivo es crear una nueva aplicación de consola en C# para ejecutar el código de inicio rápido. Abra una ventana de terminal (por ejemplo, símbolo del sistema, PowerShell o Bash) y ejecute el siguiente comando para crear una nueva aplicación de consola denominada ActiveDirectoryAuthenticationQuickstart:

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Este comando generará un proyecto sencillo de C# "Hola mundo", incluido un único archivo de código fuente: Program.cs.

Compilación de la aplicación

Vaya a la carpeta de la aplicación recién creada y compile la aplicación con el dotnet build comando :

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Instalación de los paquetes de SDK necesarios

Para interactuar con Azure Communication Services e Identidad de Azure, agregue los siguientes paquetes NuGet al proyecto:

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

Actualización del archivo Program.cs

Para usar los paquetes de Azure SDK instalados, incluya las siguientes using directivas en la parte superior del Program.cs archivo:

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

Autenticación con DefaultAzureCredential

En este inicio rápido, usaremos DefaultAzureCredential, que es adecuado para entornos de desarrollo y producción. Declare una instancia de esta credencial en el nivel de clase en Program.cs:

private DefaultAzureCredential credential = new DefaultAzureCredential();

Emisión de un token con entidades de servicio

Agregue el siguiente método al Program.cs archivo. Este método usa el SDK de Azure Communication Services para emitir un token de acceso 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;
}

Envío de un SMS con entidades de servicio

Para demostrar el envío de un SMS, agregue el siguiente método al Program.cs archivo. Este método usa el SDK de Azure Communication Services para enviar un mensaje 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;
}

Escribe el método Main

En el método Main de su archivo Program.cs, añada código para llamar a los métodos que creó para emitir un token y enviar un SMS. El Main método debe tener un aspecto similar al siguiente:

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

El archivo final Program.cs debe tener este aspecto:

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

Ejecución del programa

Es el momento de ejecutar la aplicación y comprobar que recupera un token de acceso y envía un SMS. Abra un terminal, vaya al directorio de la aplicación y ejecute:

     dotnet run

La salida de la consola debe aparecer de la siguiente manera:

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

Nota:

Busque el código finalizado de este inicio rápido en GitHub

Instalación

Creación de una aplicación Node.js

Abra la ventana de comandos o de terminal, cree un nuevo directorio para la aplicación y navegue hasta este.

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

Ejecute npm init -y para crear un archivo package.json con la configuración predeterminada.

npm init -y

Instalación de los paquetes del SDK

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

Crear un nuevo archivo

Abra un nuevo archivo con un editor de texto y guárdelo como index.js, colocaremos nuestro código dentro de este archivo.

Uso de los paquetes del SDK

Agregue las siguientes require directivas a la parte superior de index.js para usar los SDK de Azure Identity y Azure Storage.

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

Creación de una credencial DefaultAzureCredential

Usaremos DefaultAzureCredential para este inicio rápido. Esta credencial es adecuada para entornos de producción y desarrollo. Como es necesario para cada operación, vamos a crearla dentro de la parte superior de nuestro index.js archivo.

    const credential = new DefaultAzureCredential();

Creación de una identidad y emisión de un token con entidades de servicio

A continuación, escribiremos una función que crea una nueva identidad y emite un token para esta identidad, lo usaremos más adelante para probar la configuración de la entidad de servicio.

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

Envío de un SMS con entidades de servicio

Ahora, vamos a escribir una función que usa entidades de servicio para enviar 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
    );
}

Escribir la función principal

Con las funciones creadas, podemos escribir una función principal para llamarlas y mostrar el uso de entidades de servicio:

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

El archivo final index.js debe tener este aspecto:

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

Ejecución del programa

Con todo completo, puede ejecutar el archivo escribiendo node index.js desde el directorio del proyecto. Si todo salió bien, debería ver algo similar al siguiente.

    $ 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

Requisitos previos adicionales para Java

Para Java, también necesitará lo siguiente:

Kit de desarrollo de Java (JDK), versión 8 o posterior.
Apache Maven.

Nota:

Busque el código finalizado de este inicio rápido en GitHub

Instalación

Creación de una aplicación Java

Abra el terminal o la ventana de comandos. Vaya al directorio en el que quiere crear la aplicación Java. Ejecute el siguiente comando para generar el proyecto de Java a partir de la plantilla maven-archetype-quickstart.

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

Observará que la tarea "generar" creó un directorio con el mismo nombre que el objeto artifactId. En este directorio, el directorio src/main/java contiene el código fuente del proyecto, el directorio src/test/java directory contiene el origen de la prueba y el archivo pom.xml es el modelo de objetos del proyecto o POM.

Instalación del paquete

Abra el archivo pom.xml en el editor de texto. Agregue el siguiente elemento de dependencia al grupo de dependencias.

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

Uso de los paquetes del SDK

Agregue las siguientes import directivas al código para usar los SDK de Identidad de Azure y Comunicación de Azure.

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

Creación de una credencial DefaultAzureCredential

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

Emisión de un token con entidades de servicio

Ahora agregaremos código que usa la credencial creada para emitir un token de acceso voIP. Llamaremos a este código más adelante;

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

Envío de un SMS con entidades de servicio

Como otro ejemplo de uso de entidades de servicio, agregaremos este código que usa la misma credencial para enviar 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);
     }

Escribe el método Main

Su App.java ya debe tener un método principal, vamos a agregar código que llamará al código creado anteriormente para mostrar el uso de entidades de servicio:

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

El resultado final App.java debería tener este aspecto:

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

Ejecución del código

Navegue hasta el directorio que contiene el archivo pom.xml y compile el proyecto mediante el siguiente comando mvn.

mvn compile

A continuación, compile el paquete.

mvn package

Ejecute el siguiente comando mvn para ejecutar la aplicación.

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

La salida final debe ser similar a la siguiente:

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

Nota:

Busque el código finalizado de este inicio rápido en GitHub

Instalación

Creación de una nueva aplicación de Python

Vamos a configurar el directorio de trabajo para la aplicación. Para ello, abra la ventana de terminal o comando, cree un directorio y vaya a él:

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

Instalación de los paquetes del SDK

A continuación, es necesario instalar los paquetes necesarios del SDK de Azure. Ejecute estos comandos:

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

Crear un nuevo archivo

Ahora necesitamos un archivo de Python para almacenar el código. Abra y guarde un nuevo archivo llamado authentication.py dentro del directorio.

Uso de los paquetes del SDK

Nuestro siguiente objetivo es importar los módulos necesarios del SDK de Azure para trabajar con identidad y SMS. Agregue las siguientes declaraciones en la parte superior de tu archivo:

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

Creación de una credencial DefaultAzureCredential

Es necesario inicializar las credenciales tanto para los entornos de producción como de desarrollo.

Coloque esta línea con DefaultAzureCredential después de las líneas insertadas anteriormente:

     credential = DefaultAzureCredential()

Creación de una identidad y emisión de un token con entidades de servicio

Cree una identidad y solicite un token de acceso de 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

Envío de un SMS con entidades de servicio

Como alternativa, puede usar la credencial para enviar un servicio de mensajes cortos (SMS), como se muestra en el ejemplo siguiente:

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
     )

Escribir nuestro código principal

Ahora tenemos todos los bloques de código necesarios para ejecutar las funciones para crear una identidad, obtener un token de acceso y enviar un SMS.

Incluya el código principal que llama a las funciones:

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

Así es como se ve authentication.py después de todos los cambios realizados:

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

Ejecución del programa

Es el momento de ejecutar el script de Python para comprobar la funcionalidad. Ejecute el archivo desde el directorio del proyecto con el comando :

python authentication.py

Si se ejecuta correctamente, verá un resultado similar al siguiente:

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

Compartir a través de

Inicio rápido: Autenticación mediante el identificador de Microsoft Entra

Prerrequisitos

Requisitos previos adicionales

Instalación

Autenticación de una aplicación registrada en el entorno de desarrollo

Creación de una aplicación registrada de Microsoft Entra

Establecimiento de variables de entorno

Información general

Instalación

Creación de una aplicación de C#

Compilación de la aplicación

Instalación de los paquetes de SDK necesarios

Actualización del archivo Program.cs

Autenticación con DefaultAzureCredential

Emisión de un token con entidades de servicio

Envío de un SMS con entidades de servicio

Escribe el método Main

Ejecución del programa

Instalación

Creación de una aplicación Node.js

Instalación de los paquetes del SDK

Crear un nuevo archivo

Uso de los paquetes del SDK

Creación de una credencial DefaultAzureCredential

Creación de una identidad y emisión de un token con entidades de servicio

Envío de un SMS con entidades de servicio

Escribir la función principal

Ejecución del programa

Requisitos previos adicionales para Java

Instalación

Creación de una aplicación Java

Instalación del paquete

Uso de los paquetes del SDK

Creación de una credencial DefaultAzureCredential

Emisión de un token con entidades de servicio

Envío de un SMS con entidades de servicio

Escribe el método Main

Ejecución del código

Instalación

Creación de una nueva aplicación de Python

Instalación de los paquetes del SDK

Crear un nuevo archivo

Uso de los paquetes del SDK

Creación de una credencial DefaultAzureCredential

Creación de una identidad y emisión de un token con entidades de servicio

Envío de un SMS con entidades de servicio

Escribir nuestro código principal

Ejecución del programa

Pasos siguientes

Comentarios

Recursos adicionales