Início Rápido: Autenticar usando a ID do Microsoft Entra

2025-06-20

Introdução aos Serviços de Comunicação do Azure usando a ID do Microsoft Entra. Os SDKs de identidade e SMS dos Serviços de Comunicação suportam a autenticação Microsoft Entra.

Este início rápido mostra como autorizar o acesso aos SDKs de Identidade e SMS de um ambiente do Azure que dá suporte ao Active Directory. Ele também descreve como testar seu código em um ambiente de desenvolvimento criando uma entidade de serviço para o seu trabalho.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Crie uma conta gratuitamente
Um recurso ativo dos Serviços de Comunicação do Azure, consulte criar um recurso dos Serviços de Comunicação se você não tiver um.
Para enviar um SMS, você precisará de um Número de Telefone.
Uma entidade de serviço configurada para um ambiente de desenvolvimento. Confira Autorizar o acesso com entidade de serviço

Pré-requisitos adicionais

CLI do Azure. Guia de instalação

Configuração

Ao usar o Active Directory para outros recursos do Azure, você deve estar usando identidades gerenciadas. Para saber como habilitar identidades gerenciadas para recursos do Azure, consulte um destes artigos:

Autenticar um aplicativo registrado no ambiente de desenvolvimento

Se o ambiente de desenvolvimento não oferecer suporte ao logon único ou logon por meio de um navegador da Web, você poderá usar um aplicativo registrado para se autenticar no ambiente de desenvolvimento.

Criando um aplicativo registrado do Microsoft Entra

Para criar um aplicativo registrado da CLI do Azure, você precisa estar conectado à conta do Azure em que deseja que as operações ocorram. Para fazer isso, você pode usar o az login comando e inserir suas credenciais no navegador. Depois que você tiver feito logon em sua conta do Azure via CLI, é possível chamar o comando az ad sp create-for-rbac para criar o aplicativo registrado e a entidade de serviço.

O exemplo a seguir usa a CLI do Azure para criar um novo aplicativo registrado:

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

O comando az ad sp create-for-rbac retornará uma lista de propriedades de entidade de serviço no formato JSON. Copie esses valores para que você possa usá-los para criar as variáveis de ambiente necessárias na próxima etapa.

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

Importante

As atribuições de função do Azure podem levar alguns minutos para serem propagadas.

Definir variáveis de ambiente

O SDK de identidade do Azure lê valores de três variáveis de ambiente no tempo de execução para autenticar o aplicativo. A tabela a seguir descreve o valor a ser definido para cada variável de ambiente.

Variável de ambiente	Valor
`AZURE_CLIENT_ID`	`appId` valor do JSON gerado
`AZURE_TENANT_ID`	`tenant` valor do JSON gerado
`AZURE_CLIENT_SECRET`	`password` valor do JSON gerado

Importante

Depois de definir as variáveis de ambiente, feche e abra novamente a janela do console. Se você estiver usando o Visual Studio ou outro ambiente de desenvolvimento, talvez seja necessário reiniciá-lo para que ele registre as novas variáveis de ambiente.

Depois que essas variáveis tiverem sido definidas, você poderá usar o objeto DefaultAzureCredential em seu código para se autenticar no cliente de serviço de sua escolha.

Observação

Encontre o código finalizado para este guia de início rápido no GitHub

Visão geral

Este início rápido demonstra como usar identidades gerenciadas por meio de Entidades de Serviço do Azure para autenticar com os Serviços de Comunicação do Azure. Ele fornece exemplos para emitir um token de acesso para chamadas VoIP (Voz por IP) e enviar mensagens SMS.

Configurando

Criar um aplicativo em C#

A meta é criar um novo aplicativo de console em C# para executar o código de início rápido. Abra uma janela de terminal (por exemplo, Prompt de Comando, PowerShell ou Bash) e execute o seguinte comando para criar um novo aplicativo de console chamado ActiveDirectoryAuthenticationQuickstart:

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Esse comando gerará um projeto C# "Hello World" simples, incluindo um único arquivo de origem: Program.cs.

Criar o aplicativo

Navegue até a pasta de aplicativo recém-criada e compile seu aplicativo usando o dotnet build comando:

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Instalar os pacotes do SDK necessários

Para interagir com os Serviços de Comunicação do Azure e a Identidade do Azure, adicione os seguintes pacotes NuGet ao seu projeto:

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

Atualizar o arquivo de Program.cs

Para usar os pacotes do SDK do Azure instalados, inclua as seguintes using diretivas na parte superior do Program.cs arquivo:

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

Autenticar com DefaultAzureCredential

Para este início rápido, usaremos o DefaultAzureCredential, que é adequado para ambientes de desenvolvimento e produção. Declare uma instância dessa credencial no nível da classe em Program.cs:

private DefaultAzureCredential credential = new DefaultAzureCredential();

Emitir um token com entidades de serviço

Adicione o método a seguir ao arquivo Program.cs . Esse método usa o SDK dos Serviços de Comunicação do Azure para emitir um Token de Acesso 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;
}

Enviar um SMS com entidades de serviço

Para demonstrar o envio de um SMS, adicione o método a seguir ao arquivo Program.cs . Esse método usa o SDK dos Serviços de Comunicação do Azure para enviar uma mensagem 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;
}

Gravar o método principal

No método Main do seu arquivo Program.cs, adicione código para chamar os métodos que você criou para emitir um token e enviar um SMS. Seu Main método deve ser semelhante a este:

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

Seu arquivo final Program.cs deve ter esta aparência:

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

Executar o programa

É hora de executar seu aplicativo e verificar se ele recupera um token de acesso e envia um SMS. Abra um terminal, navegue até o diretório do aplicativo e execute:

     dotnet run

A saída do console deve aparecer da seguinte maneira:

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

Observação

Encontre o código finalizado para este guia de início rápido no GitHub

Configurando

Criar um novo aplicativo do Node.js

Abra o terminal ou a janela de comando para criar um diretório para seu aplicativo e navegue até ele.

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

Execute npm init -y para criar um arquivo package.json com as configurações padrão.

npm init -y

Instalar os pacotes do SDK

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

Criar um novo arquivo

Abra um novo arquivo com um editor de texto e salve-o como index.js, colocaremos nosso código dentro desse arquivo.

Usar os pacotes do SDK

Adicione as seguintes require diretivas à parte superior de index.js para usar o Azure Identity e os SDKs de Armazenamento do Azure.

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

Criar um credencial padrão do Azure

Usaremos o DefaultAzureCredential para este início rápido. Essa credencial é adequada para ambientes de produção e desenvolvimento. Como é necessário para cada operação, vamos criá-la na parte superior do nosso index.js arquivo.

    const credential = new DefaultAzureCredential();

Criar uma identidade e emitir um token com entidades de serviço

Em seguida, escreveremos uma função que cria uma nova identidade e emite um token para essa identidade, usaremos isso mais tarde para testar a configuração da entidade de serviço.

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

Enviar um SMS com entidades de serviço

Agora, vamos escrever uma função que usa entidades de serviço para enviar um 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
    );
}

Escrever a função principal

Com nossas funções criadas, podemos agora escrever uma função principal para chamá-las e demonstrar o uso de entidades de serviço:

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

O arquivo final index.js deve ter esta aparência:

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

Executar o programa

Com tudo concluído, você pode executar o arquivo inserindo node index.js no diretório do projeto. Se tudo deu certo, você deverá ver algo semelhante ao seguinte.

    $ node index.js
    Retrieving new Access Token, using Service Principals
    Retrieved Access Token: ey...Q
    Sending SMS using Service Principals
    SMS ID: ...
    Send Result Successful: true

Pré-requisitos adicionais para Java

Para Java, você também precisará:

JDK (Java Development Kit) versão 8 ou superior.
Apache Maven.

Observação

Encontre o código finalizado para este guia de início rápido no GitHub

Configurando

Criar um aplicativo Java

Abra o terminal ou a janela Comando. Navegue até o diretório em que você deseja criar o aplicativo Java. Execute o comando abaixo para gerar o projeto Java no modelo maven-archetype-quickstart.

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

Você observará que a tarefa 'gerar' criou um diretório com o mesmo nome que o artifactId. Nesse diretório, o diretório src/main/java contém o código-fonte do projeto, o src/test/java directory contém a fonte de teste e o arquivo pom.xml é o Modelo de Objeto do Projeto, ou POM.

Instalar o pacote

Abra o arquivo pom.xml no seu editor de texto. Adicione o seguinte elemento de dependência ao grupo de dependências.

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

Usar os pacotes do SDK

Adicione as seguintes import diretivas ao código para usar a Identidade do Azure e os SDKs de Comunicação do 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.*;

Criar um credencial padrão do Azure

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

Emitir um token com entidades de serviço

Agora, adicionaremos um código que usa a credencial criada para emitir um Token de Acesso VoIP. Vamos chamar esse código mais tarde;

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

Enviar um SMS com entidades de serviço

Como outro exemplo de uso de princípios de serviço, adicionaremos este código que usa a mesma credencial para enviar um 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);
     }

Gravar o método principal

Seu App.java já deve ter um método principal. Vamos adicionar um código que chamará o código criado anteriormente para demonstrar o uso de entidades de serviço:

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

Sua final App.java deve ter esta aparência:

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

Executar o código

Navegue até o diretório que contém o arquivo pom.xml e compile o projeto usando o comando mvn a seguir.

mvn compile

Em seguida, compile o pacote.

mvn package

Execute o comando mvn a seguir para executar o aplicativo.

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

A saída final deve ser semelhante ao seguinte:

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

Observação

Encontre o código finalizado para este guia de início rápido no GitHub

Configurando

Criar um novo aplicativo Python

Vamos configurar seu diretório de trabalho para o aplicativo. Para isso, abra o terminal ou a janela de comando, crie um novo diretório e navegue até ele:

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

Instalar os pacotes do SDK

Em seguida, precisamos instalar os pacotes necessários do SDK do Azure. Execute estes comandos:

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

Criar um novo arquivo

Agora, precisamos de um arquivo Python para manter seu código. Abra e salve um novo arquivo chamado authentication.py em seu diretório.

Usar os pacotes do SDK

Nossa próxima meta é importar os módulos necessários do SDK do Azure para trabalhar com identidade e SMS. Adicione as seguintes declarações na parte superior do seu arquivo:

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

Criar um credencial padrão do Azure

Precisamos inicializar uma credencial para ambientes de produção e desenvolvimento.

Coloque essa linha com DefaultAzureCredential após linhas inseridas anteriormente:

     credential = DefaultAzureCredential()

Criar uma identidade e emitir um token com entidades de serviço

Crie uma identidade e solicite um token de acesso voIP (Voice over Internet Protocol):

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

Enviar um SMS com entidades de serviço

Como alternativa, você pode utilizar sua credencial para enviar um SMS (Serviço de Mensagem Curta), conforme mostrado no exemplo abaixo:

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
     )

Escrever nosso código principal

Agora temos todos os blocos de código necessários para executar as funções para criar uma identidade, obter um token de acesso e enviar um SMS.

Inclua o código principal que chama as suas funções:

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

É assim que o authentication.py fica depois de todas as alterações que você fez:

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

Executar o programa

É hora de executar o script Python para verificar a funcionalidade. Execute o arquivo do diretório do projeto com o comando:

python authentication.py

Se tiver êxito, você verá uma saída semelhante a esta:

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

Compartilhar via

Início Rápido: Autenticar usando a ID do Microsoft Entra

Pré-requisitos

Pré-requisitos adicionais

Configuração

Autenticar um aplicativo registrado no ambiente de desenvolvimento

Criando um aplicativo registrado do Microsoft Entra

Definir variáveis de ambiente

Visão geral

Configurando

Criar um aplicativo em C#

Criar o aplicativo

Instalar os pacotes do SDK necessários

Atualizar o arquivo de Program.cs

Autenticar com DefaultAzureCredential

Emitir um token com entidades de serviço

Enviar um SMS com entidades de serviço

Gravar o método principal

Executar o programa

Configurando

Criar um novo aplicativo do Node.js

Instalar os pacotes do SDK

Criar um novo arquivo

Usar os pacotes do SDK

Criar um credencial padrão do Azure

Criar uma identidade e emitir um token com entidades de serviço

Enviar um SMS com entidades de serviço

Escrever a função principal

Executar o programa

Pré-requisitos adicionais para Java

Configurando

Criar um aplicativo Java

Instalar o pacote

Usar os pacotes do SDK

Criar um credencial padrão do Azure

Emitir um token com entidades de serviço

Enviar um SMS com entidades de serviço

Gravar o método principal

Executar o código

Configurando

Criar um novo aplicativo Python

Instalar os pacotes do SDK

Criar um novo arquivo

Usar os pacotes do SDK

Criar um credencial padrão do Azure

Criar uma identidade e emitir um token com entidades de serviço

Enviar um SMS com entidades de serviço

Escrever nosso código principal

Executar o programa

Próximas etapas

Comentários

Recursos adicionais