Snabbstart: Autentisera med Microsoft Entra-ID

Artikel
10/18/2023

Kom igång med Azure Communication Services med hjälp av Microsoft Entra-ID. Communication Services-identiteten och SMS-SDK:erna stöder Microsoft Entra-autentisering.

Den här snabbstarten visar hur du auktoriserar åtkomst till identitets- och SMS-SDK:er från en Azure-miljö som stöder Active Directory. Den beskriver också hur du testar koden i en utvecklingsmiljö genom att skapa ett huvudnamn för tjänsten för ditt arbete.

Förutsättningar

Ett Azure-konto med en aktiv prenumeration. Skapa ett konto kostnadsfritt
En aktiv Azure Communication Services-resurs finns i Skapa en Communication Services-resurs om du inte har någon.
Om du vill skicka ett SMS behöver du ett Telefon nummer.
En konfigurationstjänsthuvudnamn för en utvecklingsmiljö finns i Auktorisera åtkomst med tjänstens huvudnamn

Ytterligare förutsättningar

Azure CLI. Installationsguide

Inrätta

När du använder Active Directory för andra Azure-resurser bör du använda hanterade identiteter. Mer information om hur du aktiverar hanterade identiteter för Azure-resurser finns i någon av följande artiklar:

Autentisera ett registrerat program i utvecklingsmiljön

Om utvecklingsmiljön inte stöder enkel inloggning eller inloggning via en webbläsare kan du använda ett registrerat program för att autentisera från utvecklingsmiljön.

Skapa ett Microsoft Entra-registrerat program

Om du vill skapa ett registrerat program från Azure CLI måste du vara inloggad på det Azure-konto där du vill att åtgärderna ska utföras. För att göra detta kan du använda az login kommandot och ange dina autentiseringsuppgifter i webbläsaren. När du har loggat in på ditt Azure-konto från CLI kan vi anropa az ad sp create-for-rbac kommandot för att skapa det registrerade programmet och tjänstens huvudnamn.

I följande exempel används Azure CLI för att skapa ett nytt registrerat program:

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

Kommandot az ad sp create-for-rbac returnerar en lista över egenskaper för tjänstens huvudnamn i JSON-format. Kopiera dessa värden så att du kan använda dem för att skapa nödvändiga miljövariabler i nästa steg.

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

Viktigt!

Det kan ta några minuter att sprida Azure-rolltilldelningar.

Ange miljövariabler

Azure Identity SDK läser värden från tre miljövariabler vid körning för att autentisera programmet. I följande tabell beskrivs värdet som ska anges för varje miljövariabel.

Miljövariabel	Värde
`AZURE_CLIENT_ID`	`appId` värdet från den genererade JSON
`AZURE_TENANT_ID`	`tenant` värdet från den genererade JSON
`AZURE_CLIENT_SECRET`	`password` värdet från den genererade JSON

Viktigt!

När du har angett miljövariablerna stänger och öppnar du konsolfönstret igen. Om du använder Visual Studio eller en annan utvecklingsmiljö kan du behöva starta om den för att kunna registrera de nya miljövariablerna.

När dessa variabler har angetts bör du kunna använda standardobjektetAzureCredential i koden för att autentisera till valfri tjänstklient.

Kommentar

Hitta den färdiga koden för den här snabbstarten på GitHub

Konfigurera

Skapa ett nytt C#-program

I ett konsolfönster (till exempel cmd, PowerShell eller Bash) använder du dotnet new kommandot för att skapa en ny konsolapp med namnet ActiveDirectoryQuickstart. Det här kommandot skapar ett enkelt "Hello World"-C#-projekt med en enda källfil: Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Ändra katalogen till den nyligen skapade appmappen dotnet build och använd kommandot för att kompilera programmet.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Installera SDK-paketen

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

Använda SDK-paketen

Lägg till följande using direktiv för att Program.cs använda SDK:er för Azure Identity och Azure Storage.

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

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential för den här snabbstarten. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. När det behövs för varje åtgärd ska vi skapa den i Program.cs klassen. Lägg till följande överst i -filen.

private DefaultAzureCredential credential = new DefaultAzureCredential();

Utfärda en token med tjänstens huvudnamn

Nu ska vi lägga till kod som använder den skapade autentiseringsuppgiften för att utfärda en VoIP-åtkomsttoken. Vi anropar den här koden senare.

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

Skicka ett SMS med tjänstens huvudnamn

Som ett annat exempel på hur du använder tjänstens huvudnamn lägger vi till den här koden som använder samma autentiseringsuppgifter för att skicka ett 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;
}

Skriva main-metoden

Du Program.cs bör redan ha en Main-metod, vi lägger till kod som anropar vår tidigare skapade kod för att demonstrera användningen av tjänstens huvudnamn:

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

Den slutliga Program.cs filen bör se ut så här:

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

Köra programmet

Nu bör du kunna köra programmet med hjälp av dotnet run från programmappen. Utdata bör likna följande:

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

Kommentar

Hitta den färdiga koden för den här snabbstarten på GitHub

Konfigurera

Skapa ett nytt Node.js-program

Öppna terminalen eller kommandofönstret skapa en ny katalog för din app och navigera till den.

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

Kör npm init -y för att skapa en package.json fil med standardinställningar.

npm init -y

Installera SDK-paketen

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

Skapa en ny fil

Öppna en ny fil med en textredigerare och spara den som index.js, vi placerar koden i den här filen.

Använda SDK-paketen

Lägg till följande require direktiv överst index.js för att använda Azure Identity och Azure Storage SDK:er.

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

Skapa en StandardAzureCredential

    const credential = new DefaultAzureCredential();

Skapa en identitet och utfärda en token med tjänstens huvudnamn

Nu ska vi skriva en funktion som skapar en ny identitet och utfärdar en token för den här identiteten. Vi använder den senare för att testa konfigurationen av tjänstens huvudnamn.

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

Skicka ett SMS med tjänstens huvudnamn

Nu kan skriva en funktion som använder tjänstens huvudnamn för att skicka ett 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
    );
}

Skriva huvudfunktionen

Med våra funktioner skapade kan vi nu skriva en huvudfunktion för att anropa dem och demonstrera användningen av tjänstens huvudnamn:

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

Den slutliga index.js filen bör se ut så här:

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

Köra programmet

När allt är klart kan du köra filen genom att ange node index.js från projektets katalog. Om allt gick bra bör du se något som liknar följande.

    $ 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

Ytterligare förutsättningar för Java

För Java behöver du också:

Java Development Kit (JDK) version 8 eller senare.
Apache Maven.

Kommentar

Hitta den färdiga koden för den här snabbstarten på GitHub

Konfigurera

Skapa ett nytt Java-program

Öppna terminalen eller kommandofönstret. Navigera till katalogen där du vill skapa ditt Java-program. Kör kommandot nedan för att generera Java-projektet från mallen maven-archetype-quickstart.

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

Du kommer att märka att aktiviteten "generera" skapade en katalog med samma namn som artifactId. Under den här katalogen innehåller katalogen src/main/java projektkällkoden, src/test/java directory innehåller testkällan och pom.xml filen är projektets projektobjektmodell eller POM.

Installera -paketet

Öppna filen pom.xml i textredigeraren. Lägg till följande beroendeelement i gruppen med beroenden.

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

Använda SDK-paketen

Lägg till följande import direktiv i koden för att använda SDK:er för Azure Identity och Azure Communication.

import com.azure.communication.common.*;
import com.azure.communication.identity.*;
import com.azure.communication.identity.models.*;
import com.azure.communication.sms.*;
import com.azure.communication.sms.models.*;
import com.azure.core.credential.*;
import com.azure.identity.*;

import java.util.*;

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential för den här snabbstarten. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. När det behövs för varje åtgärd ska vi skapa den i App.java klassen. Lägg till följande längst upp i App.java klassen.

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

Utfärda en token med tjänstens huvudnamn

Nu ska vi lägga till kod som använder den skapade autentiseringsuppgiften för att utfärda en VoIP-åtkomsttoken. Vi anropar den här koden senare.

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

Skicka ett SMS med tjänstens huvudnamn

Som ett annat exempel på hur du använder tjänstens huvudnamn lägger vi till den här koden som använder samma autentiseringsuppgifter för att skicka ett 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);
     }

Skriva main-metoden

Du App.java bör redan ha en Main-metod, vi lägger till kod som anropar vår tidigare skapade kod för att demonstrera användningen av tjänstens huvudnamn:

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

Din final App.java bör se ut så här:

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

Kör koden

Navigera till katalogen som innehåller pom.xml-filen och kompilera projektet med hjälp av följande mvn kommando.

mvn compile

Skapa sedan paketet.

mvn package

Kör följande mvn kommando för att köra appen.

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

De slutliga utdata bör likna följande:

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

Kommentar

Hitta den färdiga koden för den här snabbstarten på GitHub

Konfigurera

Skapa ett nytt Python-program

Öppna terminalen eller kommandofönstret skapa en ny katalog för din app och navigera till den.

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

Installera SDK-paketen

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

Skapa en ny fil

Öppna och spara en ny fil i den skapade mappen med namnet authentication.py. Vi placerar koden i den här filen.

Använda SDK-paketen

Lägg till följande import instruktioner överst i filen för att använda de SDK:er som vi har installerat.

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

Skapa en StandardAzureCredential

Vi använder StandardAzureCredential. Den här autentiseringsuppgiften är lämplig för produktions- och utvecklingsmiljöer. Eftersom vi kommer att använda den i den här snabbstarten skapar vi den överst i filen.

     credential = DefaultAzureCredential()

Skapa en identitet och utfärda en token med tjänstens huvudnamn

Nu ska vi lägga till kod som använder den skapade autentiseringsuppgiften för att utfärda en VoIP-åtkomsttoken. Vi anropar den här koden senare:

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

Skicka ett SMS med tjänstens huvudnamn

Som ett annat exempel på hur du använder tjänstens huvudnamn lägger vi till den här koden som använder samma autentiseringsuppgifter för att skicka ett 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
     )

Skriv vår huvudkod

Med våra funktioner skapade kan vi nu skriva huvudkoden som anropar de funktioner som vi tidigare har skrivit.

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

Den slutliga authentication.py filen bör se ut ungefär så här:

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

Köra programmet

När allt är klart kan du köra filen genom att ange python authentication.py från projektets katalog. Om allt gick bra bör du se något som liknar följande.

    $ 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

Dela via

Snabbstart: Autentisera med Microsoft Entra-ID

Förutsättningar

Ytterligare förutsättningar

Inrätta

Autentisera ett registrerat program i utvecklingsmiljön

Skapa ett Microsoft Entra-registrerat program

Ange miljövariabler

Konfigurera

Skapa ett nytt C#-program

Installera SDK-paketen

Använda SDK-paketen

Skapa en StandardAzureCredential

Utfärda en token med tjänstens huvudnamn

Skicka ett SMS med tjänstens huvudnamn

Skriva main-metoden

Köra programmet

Konfigurera

Skapa ett nytt Node.js-program

Installera SDK-paketen

Skapa en ny fil

Använda SDK-paketen

Skapa en StandardAzureCredential

Skapa en identitet och utfärda en token med tjänstens huvudnamn

Skicka ett SMS med tjänstens huvudnamn

Skriva huvudfunktionen

Köra programmet

Ytterligare förutsättningar för Java

Konfigurera

Skapa ett nytt Java-program

Installera -paketet

Använda SDK-paketen

Skapa en StandardAzureCredential

Utfärda en token med tjänstens huvudnamn

Skicka ett SMS med tjänstens huvudnamn

Skriva main-metoden

Kör koden

Konfigurera

Skapa ett nytt Python-program

Installera SDK-paketen

Skapa en ny fil

Använda SDK-paketen

Skapa en StandardAzureCredential

Skapa en identitet och utfärda en token med tjänstens huvudnamn

Skicka ett SMS med tjänstens huvudnamn

Skriv vår huvudkod

Köra programmet

Nästa steg

Feedback

Ytterligare resurser