Compartir a través de

Inicio rápido: Autenticación mediante Microsoft Entra ID

  • Artículo

Comience a trabajar con Azure Communication Services mediante Microsoft Entra ID. Los SDK de SMS y de identidad 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 admita Active Directory. También se describe cómo probar el código en un entorno de desarrollo mediante la creación de una entidad de servicio para el trabajo.

Requisitos previos

Otros requisitos previos

Instalación

Al usar Active Directory para otros recursos de Azure, debe usar identidades administradas. Para aprender a habilitar las identidades administradas para los 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 mediante 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 mediante la CLI de Azure, debe haber iniciado sesión en la cuenta de Azure en la que desea que se realicen las operaciones. Para ello, puede usar el comando az login 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 los ejemplos siguientes se usa la CLI de Azure para crear una nueva aplicación registrada:

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

El comando az ad sp create-for-rbac devuelve una lista de propiedades de entidad de servicio en formato JSON. Copie estos valores para poder usarlos con el fin de 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

La propagación de las asignaciones de roles de Azure puede tardar unos minutos.

Establecimiento de variables de entorno

El SDK de Azure Identity lee valores de tres variables del entorno de ejecución para autenticar la entidad de servicio. En la tabla siguiente se describe el valor que se debe establecer para cada variable de entorno.

Variable de entorno Value
AZURE_CLIENT_ID Valor appId del JSON generado
AZURE_TENANT_ID Valor tenant del JSON generado
AZURE_CLIENT_SECRET Valor password 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 que se hayan establecido estas variables, debería poder usar el objeto DefaultAzureCredential en el código para autenticarse en el cliente de servicio de su elección.

Nota

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

Instalación

Creación de una aplicación de C#

En una ventana de consola (por ejemplo, cmd, PowerShell o Bash), use el comando dotnet new para crear una nueva aplicación de consola con el nombre ActiveDirectoryQuickstart. Este comando crea un sencillo proyecto "Hola mundo" de C# con un solo archivo de origen: Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Cambie el directorio a la carpeta de la aplicación recién creada y use el comando dotnet build para compilar la aplicación.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Instalación de los paquetes del SDK

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

Uso de los paquetes del SDK

Agregue las siguientes directivas using a Program.cs para usar los SDK de Azure Storage y Azure Identity.

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

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 necesaria para cada operación, vamos a crearla dentro de la clase Program.cs. Agregue lo siguiente en la parte superior del archivo.

private DefaultAzureCredential credential = new DefaultAzureCredential();

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

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

Escritura del método principal

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

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

El archivo Program.cs final debería tener este aspecto:

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

Ejecución del programa

Ahora debería poder ejecutar la aplicación mediante dotnet run desde la carpeta de la aplicación. La salida debe ser similar a la siguiente:

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

Nota

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

Creación de un archivo nuevo

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

Uso de los paquetes del SDK

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

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 necesaria para cada operación, vamos a crearla en la parte superior del archivo index.js.

    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. La 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
    );
}

Escritura de la función main

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 index.js final debería 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

Una vez completado todo, puede ejecutar el archivo si especifica node index.js desde el directorio del proyecto. Si todo es correcto, debe ver algo parecido a lo siguiente.

    $ 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

Requisitos previos adicionales para Java

Para Java, también necesitará:

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.

Instalar el 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 directivas import al código para usar los SDK de Azure Identity y de Azure Communication Services.

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

Usaremos DefaultAzureCredential para este inicio rápido. Esta credencial es adecuada para entornos de producción y desarrollo. Como es necesaria para cada operación, vamos a crearla dentro de la clase App.java. Agregue lo siguiente en la parte superior de la clase App.java.

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

Escritura del método principal

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 código final App.java debe tener el aspecto siguiente:

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: Outgoing_202104...33f8ae1f_noam
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

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

Instalación de los paquetes del SDK

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

Creación de un archivo nuevo

Abra y guarde un nuevo archivo en la carpeta creada denominada authentication.py, colocaremos nuestro código dentro de este archivo.

Uso de los paquetes del SDK

Agregue las siguientes instrucciones import en la parte superior del archivo para usar los SDK que hemos instalado.

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

Creación de una credencial DefaultAzureCredential

Usaremos DefaultAzureCredential. Esta credencial es adecuada para entornos de producción y desarrollo. Como la usaremos en todo este inicio rápido, la crearemos en la parte superior del archivo.

     credential = DefaultAzureCredential()

Creación de una identidad y 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:

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

Escritura del código principal

Con las funciones creadas, podemos escribir el código principal que llamará a las funciones que hemos escrito anteriormente.

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

El archivo authentication.py final debe tener un aspecto similar al siguiente:

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

Una vez completado todo, puede ejecutar el archivo si especifica python authentication.py desde el directorio del proyecto. Si todo es correcto, debe ver algo parecido a lo siguiente.

    $ 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

Pasos siguientes