Rövid útmutató: Hitelesítés a Microsoft Entra-azonosítóval

Cikk
10/18/2023

Az Azure Communication Services használatának első lépései a Microsoft Entra ID használatával. A Communication Services Identity és az SMS SDK-k támogatják a Microsoft Entra-hitelesítést.

Ez a rövid útmutató bemutatja, hogyan engedélyezheti az identitás- és SMS SDK-k elérését egy Olyan Azure-környezetből, amely támogatja az Active Directoryt. Azt is ismerteti, hogyan tesztelheti a kódot fejlesztési környezetben egy szolgáltatásnév létrehozásával a munkájához.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Fiók létrehozása ingyenesen
Ha nem rendelkezik egy aktív Azure Communication Services-erőforrással, tekintse meg a Communication Services-erőforrás létrehozását.
SMS küldéséhez szüksége lesz egy Telefon számra.
A telepítési szolgáltatásnév fejlesztési környezethez: Hozzáférés engedélyezése szolgáltatásnévvel

További előfeltételek

Azure parancssori felület (CLI). Telepítési útmutató

Beállítása

Ha az Active Directoryt más Azure-erőforrásokhoz használja, felügyelt identitásokat kell használnia. Ha meg szeretné tudni, hogyan engedélyezheti a felügyelt identitásokat az Azure-erőforrásokhoz, tekintse meg az alábbi cikkek egyikét:

Regisztrált alkalmazás hitelesítése a fejlesztési környezetben

Ha a fejlesztői környezet nem támogatja az egyszeri bejelentkezést vagy a webböngészőn keresztüli bejelentkezést, akkor egy regisztrált alkalmazással hitelesítheti magát a fejlesztői környezetből.

Regisztrált Microsoft Entra-alkalmazás létrehozása

Ha regisztrált alkalmazást szeretne létrehozni az Azure CLI-ből, be kell jelentkeznie arra az Azure-fiókra, ahol a műveleteket el szeretné végezni. Ehhez használhatja a az login parancsot, és megadhatja a hitelesítő adatait a böngészőben. Miután bejelentkezett az Azure-fiókjába a parancssori felületről, meghívhatjuk a az ad sp create-for-rbac parancsot a regisztrált alkalmazás és szolgáltatásnév létrehozásához.

Az alábbi példa az Azure CLI használatával hoz létre egy új regisztrált alkalmazást:

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

A az ad sp create-for-rbac parancs JSON formátumban adja vissza a szolgáltatásnév tulajdonságainak listáját. Másolja ki ezeket az értékeket, hogy a következő lépésben a szükséges környezeti változók létrehozásához használhassa őket.

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

Fontos

Az Azure-szerepkör-hozzárendelések propagálása eltarthat néhány percig.

Környezeti változók beállítása

Az Azure Identity SDK futásidőben három környezeti változó értékeit olvassa be az alkalmazás hitelesítéséhez. Az alábbi táblázat az egyes környezeti változókhoz beállított értéket ismerteti.

Környezeti változó	Érték
`AZURE_CLIENT_ID`	`appId` érték a létrehozott JSON-ból
`AZURE_TENANT_ID`	`tenant` érték a létrehozott JSON-ból
`AZURE_CLIENT_SECRET`	`password` érték a létrehozott JSON-ból

Fontos

A környezeti változók beállítása után zárja be és nyissa meg újra a konzolablakot. Ha Visual Studiót vagy más fejlesztői környezetet használ, előfordulhat, hogy újra kell indítania ahhoz, hogy regisztrálhassa az új környezeti változókat.

Miután beállította ezeket a változókat, a defaultAzureCredential objektumot használhatja a kódban a választott szolgáltatásügyfél hitelesítéséhez.

Feljegyzés

A rövid útmutató véglegesített kódjának megkeresése a GitHubon

Beállítás

Új C#-alkalmazás létrehozása

Egy konzolablakban (például parancsmag, PowerShell vagy Bash) a dotnet new paranccsal hozzon létre egy új konzolalkalmazást a névvel ActiveDirectoryQuickstart. Ez a parancs egy egyszerű ""Helló világ!" alkalmazás" C#-projektet hoz létre egyetlen forrásfájllal: Program.cs.

dotnet new console -o ActiveDirectoryAuthenticationQuickstart

Módosítsa a könyvtárat az újonnan létrehozott alkalmazásmappára, és használja a dotnet build parancsot az alkalmazás fordításához.

cd ActiveDirectoryAuthenticationQuickstart
dotnet build

Az SDK-csomagok telepítése

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

Az SDK-csomagok használata

Adja hozzá az alábbi using irányelveket Program.cs az Azure Identity és az Azure Storage SDK-k használatához.

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

DefaultAzureCredential létrehozása

Ehhez a rövid útmutatóhoz a DefaultAzureCredential értéket fogjuk használni. Ez a hitelesítő adat éles és fejlesztési környezetekhez alkalmas. Mivel minden művelethez szükség van rá, hozzuk létre az osztályon Program.cs belül. Adja hozzá a következő utasítást a fájl elejéhez.

private DefaultAzureCredential credential = new DefaultAzureCredential();

Jogkivonat kiállítása szolgáltatásnévvel

Most hozzáadunk egy kódot, amely a létrehozott hitelesítő adatokat használja egy VoIP hozzáférési jogkivonat kiállításához. Ezt a kódot később hívjuk meg.

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

SMS küldése szolgáltatásnévvel

Egy másik példa a szolgáltatásnevek használatára, ezt a kódot fogjuk hozzáadni, amely ugyanazt a hitelesítő adatot használja az SMS-küldéshez:

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

A Fő metódus írása

Már Program.cs rendelkeznie kell egy Fő metódussal, adjunk hozzá néhány kódot, amely meghívja a korábban létrehozott kódot a szolgáltatásnevek használatának bemutatásához:

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

A végleges Program.cs fájlnak így kell kinéznie:

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

A program futtatása

Most már képesnek kell lennie az alkalmazás futtatására az dotnet run alkalmazásmappából. A kimenetnek a következőhöz kell hasonlítania:

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

Feljegyzés

A rövid útmutató véglegesített kódjának megkeresése a GitHubon

Beállítás

Új Node.js-alkalmazás létrehozása

Nyissa meg a terminált vagy a parancsablakot, és hozzon létre egy új könyvtárat az alkalmazáshoz, és navigáljon hozzá.

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

Futtassa npm init -y az alapértelmezett beállításokkal rendelkező package.json fájl létrehozásához.

npm init -y

Az SDK-csomagok telepítése

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

Új fájl létrehozása

Nyisson meg egy új fájlt egy szövegszerkesztővel, és mentse azt a fájlba index.js, a kódot ebben a fájlban fogjuk elhelyezni.

Az SDK-csomagok használata

Adja hozzá a következő require irányelveket az index.js Azure Identity és az Azure Storage SDK-k használatához.

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

DefaultAzureCredential létrehozása

    const credential = new DefaultAzureCredential();

Identitás létrehozása és jogkivonat kiállítása szolgáltatásnevek használatával

Ezután megírunk egy függvényt, amely létrehoz egy új identitást, és kiad egy jogkivonatot ehhez az identitáshoz. Ezt később használjuk a szolgáltatásnév beállításának teszteléséhez.

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

SMS küldése szolgáltatásnévvel

Most írjon egy függvényt, amely szolgáltatásnevek használatával küld SMS-t:

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

A fő függvény írása

A létrehozott függvényekkel most már megírhatunk egy fő függvényt, amellyel meghívhatjuk őket, és bemutathatjuk a szolgáltatásnevek használatát:

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

A végső index.js fájlnak így kell kinéznie:

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

A program futtatása

Ha minden elkészült, futtathatja a fájlt a projekt könyvtárából való beírással node index.js . Ha minden jól ment, az alábbihoz hasonlót kell látnia.

    $ 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

A Java további előfeltételei

Java esetén a következőkre is szüksége lesz:

A Java Development Kit (JDK) 8- vagy újabb verziója.
Apache Maven.

Feljegyzés

A rövid útmutató véglegesített kódjának megkeresése a GitHubon

Beállítás

Új Java-alkalmazás létrehozása

Nyissa meg a terminált vagy a parancsablakot. Lépjen arra a könyvtárra, ahol létre szeretné hozni a Java-alkalmazást. Futtassa az alábbi parancsot a Java-projekt létrehozásához a maven-archetype-quickstart sablonból.

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

Megfigyelheti, hogy a "létrehozás" feladat létrehozott egy könyvtárat, amelynek a neve megegyezik a artifactId. Ebben a könyvtárban az src/main/java könyvtár tartalmazza a projekt forráskódját, a src/test/java directory tesztforrást, a pom.xml fájl pedig a projekt projektobjektum-modelljét vagy POM-ját.

Telepítse a(z) csomagot

Nyissa meg a pom.xml fájlt a szövegszerkesztőben. Adja hozzá a következő függőségi elemet a függőségek csoportjához.

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

Az SDK-csomagok használata

Adja hozzá a következő import irányelveket a kódhoz az Azure Identity és az Azure Communication SDK-k használatához.

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

DefaultAzureCredential létrehozása

Ehhez a rövid útmutatóhoz a DefaultAzureCredential értéket fogjuk használni. Ez a hitelesítő adat éles és fejlesztési környezetekhez alkalmas. Mivel minden művelethez szükség van rá, hozzuk létre az osztályon App.java belül. Adja hozzá a következőket az App.java osztály elejéhez.

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

Jogkivonat kiállítása szolgáltatásnévvel

Most hozzáadunk egy kódot, amely a létrehozott hitelesítő adatokat használja egy VoIP hozzáférési jogkivonat kiállításához. Ezt a kódot később hívjuk meg;

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

SMS küldése szolgáltatásnévvel

Egy másik példa a szolgáltatásnevek használatára, ezt a kódot fogjuk hozzáadni, amely ugyanazt a hitelesítő adatot használja az SMS-küldéshez:

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

A Fő metódus írása

Már App.java rendelkeznie kell egy Fő metódussal, adjunk hozzá néhány kódot, amely meghívja a korábban létrehozott kódot a szolgáltatásnevek használatának bemutatásához:

    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 véglegesnek App.java így kell kinéznie:

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

A kód futtatása

Lépjen a pom.xml fájlt tartalmazó könyvtárra, és fordítsa le a projektet az alábbi mvn paranccsal.

mvn compile

Ezután hozza létre a csomagot.

mvn package

Futtassa a következő mvn parancsot az alkalmazás végrehajtásához.

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

A végső kimenetnek a következőhöz kell hasonlítania:

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

Feljegyzés

A rövid útmutató véglegesített kódjának megkeresése a GitHubon

Beállítás

Új Python-alkalmazás létrehozása

Nyissa meg a terminált vagy a parancsablakot, és hozzon létre egy új könyvtárat az alkalmazáshoz, és navigáljon hozzá.

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

Az SDK-csomagok telepítése

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

Új fájl létrehozása

Nyisson meg és mentsen egy új fájlt a létrehozott mappába authentication.py, amelyet ebben a fájlban fogunk elhelyezni.

Az SDK-csomagok használata

Adja hozzá a következő import utasításokat a fájl elejéhez a telepített SDK-k használatához.

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

DefaultAzureCredential létrehozása

A DefaultAzureCredential értéket fogjuk használni. Ez a hitelesítő adat éles és fejlesztési környezetekhez alkalmas. Mivel ebben a rövid útmutatóban ezt fogjuk használni, a fájl tetején fogjuk létrehozni.

     credential = DefaultAzureCredential()

Identitás létrehozása és jogkivonat kiállítása szolgáltatásnevek használatával

Most hozzáadunk egy kódot, amely a létrehozott hitelesítő adatokat használja egy VoIP hozzáférési jogkivonat kiállításához. Ezt a kódot később hívjuk meg:

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

SMS küldése szolgáltatásnévvel

Egy másik példa a szolgáltatásnevek használatára, ezt a kódot fogjuk hozzáadni, amely ugyanazt a hitelesítő adatot használja az SMS-küldéshez:

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
     )

A fő kód megírása

A létrehozott függvényekkel most már megírhatjuk a fő kódot, amely meghívja a korábban írt függvényeket.

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

Az utolsó authentication.py fájlnak így kell kinéznie:

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

A program futtatása

Ha minden elkészült, futtathatja a fájlt a projekt könyvtárából való beírással python authentication.py . Ha minden jól ment, az alábbihoz hasonlót kell látnia.

    $ 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

Megosztás a következőn keresztül:

Rövid útmutató: Hitelesítés a Microsoft Entra-azonosítóval

Előfeltételek

További előfeltételek

Beállítása

Regisztrált alkalmazás hitelesítése a fejlesztési környezetben

Regisztrált Microsoft Entra-alkalmazás létrehozása

Környezeti változók beállítása

Beállítás

Új C#-alkalmazás létrehozása

Az SDK-csomagok telepítése

Az SDK-csomagok használata

DefaultAzureCredential létrehozása

Jogkivonat kiállítása szolgáltatásnévvel

SMS küldése szolgáltatásnévvel

A Fő metódus írása

A program futtatása

Beállítás

Új Node.js-alkalmazás létrehozása

Az SDK-csomagok telepítése

Új fájl létrehozása

Az SDK-csomagok használata

DefaultAzureCredential létrehozása

Identitás létrehozása és jogkivonat kiállítása szolgáltatásnevek használatával

SMS küldése szolgáltatásnévvel

A fő függvény írása

A program futtatása

A Java további előfeltételei

Beállítás

Új Java-alkalmazás létrehozása

Telepítse a(z) csomagot

Az SDK-csomagok használata

DefaultAzureCredential létrehozása

Jogkivonat kiállítása szolgáltatásnévvel

SMS küldése szolgáltatásnévvel

A Fő metódus írása

A kód futtatása

Beállítás

Új Python-alkalmazás létrehozása

Az SDK-csomagok telepítése

Új fájl létrehozása

Az SDK-csomagok használata

DefaultAzureCredential létrehozása

Identitás létrehozása és jogkivonat kiállítása szolgáltatásnevek használatával

SMS küldése szolgáltatásnévvel

A fő kód megírása

A program futtatása

Következő lépések

Visszajelzés

További források