Guia de início rápido: autenticar usando a ID do Microsoft Entra

Artigo
10/18/2023

Introdução aos Serviços de Comunicação do Azure usando a ID do Microsoft Entra. A identidade dos serviços de comunicação e os SDKs do SMS oferecem suporte à autenticação do Microsoft Entra.

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

Pré-requisitos

Uma conta do Azure com uma subscrição 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 não tiver um.
Para enviar um SMS você vai precisar de um número de telefone.
Uma entidade de serviço de configuração para um ambiente de desenvolvimento, consulte Autorizar acesso com entidade de serviço

Pré-requisitos adicionais

CLI do Azure. Guia de instalação

Configuração

Ao usar o Ative Directory para outros Recursos do Azure, você deve usar 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 seu ambiente de desenvolvimento não suportar logon único ou login por meio de um navegador da Web, você poderá usar um aplicativo registrado para autenticar a partir do ambiente de desenvolvimento.

Criando um aplicativo registrado no Microsoft Entra

Para criar um aplicativo registrado a partir da CLI do Azure, você precisa estar conectado à conta do Azure onde deseja que as operações ocorram. Para fazer isso, você pode usar o az login comando e inserir suas credenciais no navegador. Depois de iniciar sessão na sua conta do Azure a partir da CLI, podemos chamar o az ad sp create-for-rbac comando para criar a entidade de segurança registada da aplicação e do 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 az ad sp create-for-rbac comando retornará uma lista de propriedades da 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 se propagar.

Definir variáveis de ambiente

O SDK do Azure Identity lê valores de três variáveis de ambiente em 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	Value
`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 reabra 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 autenticar no cliente de serviço de sua escolha.

Nota

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

Configuração

Criar um novo aplicativo C#

Em uma janela de console (como cmd, PowerShell ou Bash), use o dotnet new comando para criar um novo aplicativo de console com o nome ActiveDirectoryQuickstart. Este comando cria um projeto C# "Hello World" simples com um único arquivo de origem: Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Altere seu diretório para a pasta do aplicativo recém-criada e use o dotnet build comando para compilar seu aplicativo.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Instalar os pacotes SDK

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

Usar os pacotes SDK

Adicione as seguintes using diretivas para Program.cs usar a Identidade do Azure e os SDKs de Armazenamento do Azure.

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

Criar um DefaultAzureCredential

Usaremos o DefaultAzureCredential para este início rápido. Esta credencial é adequada para ambientes de produção e desenvolvimento. Como é necessário para cada operação, vamos criá-lo dentro da Program.cs classe. Adicione o seguinte à parte superior do ficheiro .

private DefaultAzureCredential credential = new DefaultAzureCredential();

Emitir um token com entidades de serviço

Agora vamos adicionar o código que usa a credencial criada, para emitir um token de acesso VoIP. Chamaremos esse código mais tarde.

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

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

Escreva o método Main

Você Program.cs já deve ter um método Main, vamos adicionar algum código que chamará nosso código criado anteriormente para demonstrar o uso de entidades de serviço:

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

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

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

Execute o programa

Agora você deve ser capaz de executar seu aplicativo, usando dotnet run a partir de sua pasta de aplicativo. A saída deve ser semelhante à seguinte:

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

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

Configuração

Criar uma nova aplicação Node.js

Abra o terminal ou a janela de comando, crie um novo 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 SDK

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

Criar um novo ficheiro

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 SDK

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

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

Criar um DefaultAzureCredential

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

Escreva a função principal

Com nossas funções criadas, agora podemos 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 ficheiro final index.js deve ter o seguinte aspeto:

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

Execute o programa

Com tudo concluído, você pode executar o arquivo entrando no node index.js diretório do seu projeto. Se tudo correu bem, 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: Outgoing_2021040602194...._noam
    Send Result Successful: true

Pré-requisitos adicionais para Java

Para Java, você também precisará:

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

Nota

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

Configuração

Criar uma nova aplicação Java

Abra o terminal ou a janela de comando. Navegue até o diretório onde você gostaria de criar seu aplicativo Java. Execute o comando abaixo para gerar o projeto Java a partir do modelo maven-archetype-quickstart.

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

Você notará que a tarefa 'gerar' criou um diretório com o mesmo nome do artifactId. Neste 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 pom.xml arquivo é o Project Object Model ou POM do projeto.

Instalar o pacote

Abra o arquivo pom.xml no 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 SDK

Adicione as seguintes import diretivas ao seu 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 DefaultAzureCredential

Usaremos o DefaultAzureCredential para este início rápido. Esta credencial é adequada para ambientes de produção e desenvolvimento. Como é necessário para cada operação, vamos criá-lo dentro da App.java classe. Adicione o seguinte ao topo da App.java classe.

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

Emitir um token com entidades de serviço

Agora vamos adicionar o código que usa a credencial criada, para emitir um token de acesso VoIP. Chamaremos 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 entidades 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);
     }

Escreva o método Main

Você App.java já deve ter um método Main, vamos adicionar algum código que chamará nosso 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());
    }

A sua final App.java deve ter o seguinte aspeto:

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 seguinte mvn comando.

mvn compile

Em seguida, compile o pacote.

mvn package

Execute o seguinte mvn comando para executar o aplicativo.

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

A saída final deve ser semelhante à seguinte:

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

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

Configuração

Criar uma aplicação Python nova

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

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

Instalar os pacotes SDK

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

Criar um novo ficheiro

Abra e salve um novo arquivo dentro de sua pasta criada chamado authentication.py, vamos colocar nosso código dentro deste arquivo.

Usar os pacotes SDK

Adicione as instruções a seguir import à parte superior do arquivo para usar os SDKs que instalamos.

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

Criar um DefaultAzureCredential

Usaremos o DefaultAzureCredential. Esta credencial é adequada para ambientes de produção e desenvolvimento. Como vamos usá-lo ao longo deste início rápido, vamos criá-lo na parte superior do arquivo.

     credential = DefaultAzureCredential()

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

Agora vamos adicionar o código que usa a credencial criada, para emitir um token de acesso VoIP. Chamaremos esse código mais tarde:

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

Escreva o nosso código principal

Com nossas funções criadas, agora podemos escrever o código principal que chamará as funções que escrevemos 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}');

O arquivo final authentication.py deve ter esta aparência:

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

Execute o programa

Com tudo concluído, você pode executar o arquivo entrando no python authentication.py diretório do seu projeto. Se tudo correu bem, deverá ver algo semelhante ao seguinte.

    $ 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

Partilhar via

Guia de 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 no Microsoft Entra

Definir variáveis de ambiente

Configuração

Criar um novo aplicativo C#

Instalar os pacotes SDK

Usar os pacotes SDK

Criar um DefaultAzureCredential

Emitir um token com entidades de serviço

Enviar um SMS com entidades de serviço

Escreva o método Main

Execute o programa

Configuração

Criar uma nova aplicação Node.js

Instalar os pacotes SDK

Criar um novo ficheiro

Usar os pacotes SDK

Criar um DefaultAzureCredential

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

Enviar um SMS com entidades de serviço

Escreva a função principal

Execute o programa

Pré-requisitos adicionais para Java

Configuração

Criar uma nova aplicação Java

Instalar o pacote

Usar os pacotes SDK

Criar um DefaultAzureCredential

Emitir um token com entidades de serviço

Enviar um SMS com entidades de serviço

Escreva o método Main

Executar o código

Configuração

Criar uma aplicação Python nova

Instalar os pacotes SDK

Criar um novo ficheiro

Usar os pacotes SDK

Criar um DefaultAzureCredential

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

Enviar um SMS com entidades de serviço

Escreva o nosso código principal

Execute o programa

Próximos passos

Comentários

Recursos adicionais