Erste Schritte mit IoT Hub-Modulidentitäten und Modulidentitätszwillingen

• Erfordert Visual Studio

Übersicht

Dieser Artikel beschreibt, wie Sie Azure IoT-SDK für .NET verwenden, um Geräte- und Back-End-Dienstanwendungscode für Modulidentitätszwillinge zu erstellen.

Erstellen einer Geräteanwendung

In diesem Abschnitt wird beschrieben, wie Sie Geräteanwendungscode verwenden, um:

• Abrufen eines Modulidentitätszwillings und Untersuchen gemeldeter Eigenschaften
• Gemeldete Eigenschaften des Modulidentitätszwilling aktualisieren
• Erstellen eines Rückrufhandlers zum Aktualisieren gewünschter Moduleigenschaften

Erforderliches NuGet-Gerätepaket

Geräteclientanwendungen, die in C# geschrieben wurden, erfordern das NuGet-Paket Microsoft.Azure.Devices.Client.

Fügen Sie diese using-Anweisungen hinzu, um die Gerätebibliothek zu verwenden.

using Microsoft.Azure.Devices.Client;
using Microsoft.Azure.Devices.Shared;

Mit einem Gerät verbinden

Die ModuleClient-Klasse macht alle Methoden verfügbar, die für die Interaktion mit Modulidentitätszwillingen vom Gerät erforderlich sind.

Stellen Sie mithilfe der CreateFromConnectionString-Methode mit der Modulidentitätsverbindungszeichenfolge eine Verbindung mit dem Gerät her.

Durch Aufrufen von CreateFromConnectionString ohne Transportparameter wird eine Verbindung mit dem standardmäßigen AMQP-Transport hergestellt.

In diesem Beispiel wird eine Verbindung mit dem Gerät mithilfe des standardmäßigen AMQP-Transports hergestellt.

static string ModuleConnectionString = "{Device module identity connection string}";
private static ModuleClient _moduleClient = null;

_moduleClient = ModuleClient.CreateFromConnectionString(ModuleConnectionString, null);

Abrufen eines Modulidentitätszwillings und Untersuchen von Eigenschaften

Rufen Sie GetTwinAsync auf, um die aktuellen Eigenschaften des Modulidentitätszwillings in ein Twin-Objekt abzurufen.

In diesem Beispiel werden die Eigenschaften des Modulidentitätszwillings im JSON-Format abgerufen und angezeigt.

Console.WriteLine("Retrieving twin...");
Twin twin = await _moduleClient.GetTwinAsync();
Console.WriteLine("\tModule identity twin value received:");
Console.WriteLine(JsonConvert.SerializeObject(twin.Properties));

Aktualisieren der gemeldeten Eigenschaften des Modulidentitätszwillings

So aktualisieren Sie eine gemeldete Eigenschaften eines Gerätezwillings:

1. Erstellen Sie ein TwinCollection-Objekt für die Aktualisierung der gemeldeten Eigenschaft
2. Aktualisieren Sie eine oder mehrere gemeldete Eigenschaften innerhalb des TwinCollection-Objekts
3. Verwenden Sie UpdateReportedPropertiesAsync, um Änderungen an der gemeldeten Eigenschaft an den IoT Hub-Dienst zu übertragen

Zum Beispiel:

try
{
  Console.WriteLine("Sending sample start time as reported property");
  TwinCollection reportedProperties = new TwinCollection();
  reportedProperties["DateTimeLastAppLaunch"] = DateTime.UtcNow;
  await _moduleClient.UpdateReportedPropertiesAsync(reportedProperties);
}
catch (Exception ex)
{
   Console.WriteLine();
   Console.WriteLine("Error in sample: {0}", ex.Message);
}

Erstellen eines Rückrufhandlers zum Aktualisieren gewünschter Eigenschaften

Übergeben Sie den Namen der Rückrufhandlermethode an SetDesiredPropertyUpdateCallbackAsync, um einen gewünschten Rückrufhandler zur Eigenschaftenaktualisierung zu erstellen, der ausgeführt wird, wenn eine gewünschte Eigenschaft im Modulidentitätszwilling geändert wird.

Mit diesem Aufruf wird das System beispielsweise so eingerichtet, dass eine Methode mit dem NamenOnDesiredPropertyChangedAsync benachrichtigt wird, wenn eine gewünschte Moduleigenschaft geändert wird.

await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertyChangedAsync, null);

Die Eigenschaften des Modulidentitätszwillings werden als TwinCollection an die Rückrufmethode übergeben und können als KeyValuePair-Strukturen untersucht werden.

In diesem Beispiel wird die Aktualisierung der gewünschten Eigenschaften als TwinCollection empfangen. Anschließend werden die Aktualisierungen durchlaufen und die KeyValuePair-Auflistung gedruckt. Nach dem Durchlaufen der KeyValuePair-Auflistung ruft der Code UpdateReportedPropertiesAsync auf, um die DateTimeLastDesiredPropertyChangeReceived gemeldete Eigenschaft zu aktualisieren, um den letzten Aktualisierungszeitpunkt auf dem neuesten Stand zu halten.

private async Task OnDesiredPropertyChangedAsync(TwinCollection desiredProperties, object userContext)
{
   var reportedProperties = new TwinCollection();

   Console.WriteLine("\tDesired properties requested:");
   Console.WriteLine($"\t{desiredProperties.ToJson()}");

   // For the purpose of this sample, we'll blindly accept all twin property write requests.
   foreach (KeyValuePair<string, object> desiredProperty in desiredProperties)
   {
         Console.WriteLine($"Setting {desiredProperty.Key} to {desiredProperty.Value}.");
         reportedProperties[desiredProperty.Key] = desiredProperty.Value;
   }

   Console.WriteLine("\tAlso setting current time as reported property");
   reportedProperties["DateTimeLastDesiredPropertyChangeReceived"] = DateTime.UtcNow;

   await _moduleClient.UpdateReportedPropertiesAsync(reportedProperties);
}

SDK-Modulbeispiel

Das Azure IoT SDK für .NET bietet Arbeitsbeispiele von Geräte-Apps, die Aufgaben des Modulidentitätszwillings verarbeiten. Weitere Informationen finden Sie unter:

• TwinSample
• Geräteclienttests

Erstellen einer Back-End-Anwendung

In diesem Abschnitt wird beschrieben, wie Modulidentitätsfelder gelesen und aktualisiert werden.

Die Klasse RegistryManager macht alle Methoden verfügbar, die für die Erstellung einer Back-End-Anwendung zur Interaktion mit Modulidentitätszwillingen des Diensts erforderlich sind.

Erforderliches NuGet-Dienstpaket

Back-End-Dienstanwendungen erfordern das NuGet-Paket Microsoft.Azure.Devices.

Fügen Sie diese using-Anweisungen hinzu, um die Dienstbibliothek zu verwenden.

using Microsoft.Azure.Devices;
using Microsoft.Azure.Devices.Shared;

Herstellen einer Verbindung mit IoT Hub

Sie können einen Back-End-Dienst mit IoT Hub mithilfe der folgenden Methoden verbinden:

• SAS-Richtlinie
• Microsoft Entra

Herstellen einer Verbindung mithilfe der SAS-Richtlinie

Verbinden Sie eine Back-End-Anwendung mit IoT Hub mithilfe von CreateFromConnectionString.

Die in diesem Abschnitt verwendete UpdateModuleAsync-Methode erfordert die Berechtigung der SAS-Richtlinie Service Connect, um einem Modul gewünschte Eigenschaften hinzuzufügen. Geben Sie als Parameter für CreateFromConnectionString eine Verbindungszeichenfolge als SAS-Richtlinien an, welche die Berechtigung Service Connect enthält. Weitere Informationen zu SAS-Richtlinien finden Sie unter Steuer des Zugriffs auf IoT Hub mithilfe von Shared Access Signatures.

Zum Beispiel:

static RegistryManager registryManager;
static string connectionString = "{IoT hub shared access policy connection string}";
registryManager = RegistryManager.CreateFromConnectionString(connectionString);

Verbinden mit Microsoft Entra

Eine Back-End-App, die Microsoft Entra verwendet, muss erfolgreich authentifiziert werden und Anmeldeinformationen für Sicherheitstoken erhalten, bevor Sie eine Verbindung mit IoT Hub herstellen. Dieses Token wird an eine IoT Hub-Verbindungsmethode übergeben. Allgemeine Informationen zum Einrichten und Verwenden von Microsoft Entra für IoT Hub finden Sie unter Steuern des Zugriffs auf IoT Hub mithilfe von Microsoft Entra ID.

Konfigurieren der Microsoft Entra-App

Sie müssen eine Microsoft Entra-App einrichten, die für Ihre bevorzugten Authentifizierungsanmeldeinformationen konfiguriert ist. Die App enthält Parameter wie den geheimen Clientschlüssel, der von der Back-End-Anwendung zur Authentifizierung verwendet wird. Die verfügbaren Konfigurationen für die App-Authentifizierung sind:

• Geheimer Clientschlüssel
• Zertifikat
• Anmeldeinformationen für Verbundidentität

Microsoft Entra-Apps erfordern je nach ausgeführten Vorgängen möglicherweise bestimmte Rollenberechtigungen. Beispielsweise ist IoT Hub Twin Contributor erforderlich, um Lese- und Schreibzugriff auf ein IoT Hub-Gerät und Modulzwilling zu ermöglichen. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf IoT Hub mithilfe der Azure RBAC-Rollenzuweisung.

Weitere Informationen zum Einrichten einer Microsoft Entra-App finden Sie in der Schnellstartanleitung: Registrieren einer Anwendung bei der Microsoft Identitäts-Plattform.

Authentifizieren mithilfe von DefaultAzureCredential

Die einfachste Möglichkeit, Microsoft Entra zum Authentifizieren einer Back-End-Anwendung zu verwenden, besteht darin, DefaultAzureCredential zu verwenden. Es wird jedoch empfohlen, eine andere Methode in einer Produktionsumgebung zu verwenden, einschließlich einer bestimmten TokenCredential oder analysierten ChainedTokenCredential. Der Einfachheit halber beschreibt dieser Abschnitt die Authentifizierung mit DefaultAzureCredential und den geheimen Clientschlüssel. Weitere Informationen zu den Vor- und Nachteilen der Verwendung von DefaultAzureCredential finden Sie unter Verwendungsleitfaden für DefaultAzureCredential.

DefaultAzureCredential unterstützt verschiedene Authentifizierungsmechanismen und bestimmt den entsprechenden Anmeldeinformationstyp basierend auf der Umgebung, in der er ausgeführt wird. Es versucht, mehrere Anmeldeinformationstypen in einer Reihenfolge zu verwenden, bis sie eine funktionierende Anmeldeinformation findet.

Microsoft Entra erfordert diese NuGet-Pakete und entsprechende using Anweisungen:

• Azure.Core
• Azure.Identity

using Azure.Core;
using Azure.Identity;

In diesem Beispiel werden Clientschlüssel, Client-ID und Mandanten-ID der Microsoft Entra-App zu Umgebungsvariablen hinzugefügt. Diese Umgebungsvariablen werden von DefaultAzureCredential verwendet, um die Anwendung zu authentifizieren. Das Ergebnis einer erfolgreichen Microsoft Entra-Authentifizierung ist eine Sicherheitstoken-Anmeldeinformation, die an eine IoT Hub-Verbindungsmethode übergeben wird.

string clientSecretValue = "xxxxxxxxxxxxxxx";
string clientID = "xxxxxxxxxxxxxx";
string tenantID = "xxxxxxxxxxxxx";

Environment.SetEnvironmentVariable("AZURE_CLIENT_SECRET", clientSecretValue);
Environment.SetEnvironmentVariable("AZURE_CLIENT_ID", clientID);
Environment.SetEnvironmentVariable("AZURE_TENANT_ID", tenantID);

TokenCredential tokenCredential = new DefaultAzureCredential();

Das resultierende TokenCredential kann dann an eine Verbindung mit der IoT Hub-Methode für jeden SDK-Client übergeben werden, der Microsoft Entra-Anmeldeinformationen akzeptiert:

• JobClient
• RegistryManager
• DigitalTwinClient
• ServiceClient

In diesem Beispiel wird TokenCredential an ServiceClient.Create übergeben, um ein ServiceClient-Verbindungsobjekt zu erstellen.

string hostname = "xxxxxxxxxx.azure-devices.net";
using var serviceClient = ServiceClient.Create(hostname, tokenCredential, TransportType.Amqp);

In diesem Beispiel wird TokenCredential an RegistryManager.Create übergeben, um ein RegistryManager-Objekt zu erstellen.

string hostname = "xxxxxxxxxx.azure-devices.net";
registryManager = RegistryManager.Create(hostname, tokenCredential);

Codebeispiel

Ein funktionierendes Beispiel für die Microsoft Entra-Dienstauthentifizierung finden Sie im Beispiel für die rollenbasierte Authentifizierung.

Lesen und Aktualisieren von Modulidentitätsfeldern

Rufen Sie GetModuleAsync auf, um die aktuelle Modulidentitätszwillingsfelder in ein Module-Objekt abzurufen.

Die Module-Klasse enthält properties-Abschnitte eines Modulidentitätszwillings. Verwenden Sie die Eigenschaften der Module-Klasse zum Anzeigen und Aktualisieren der Modulidentitätszwillingsfelder. Sie können die Module-Objekteigenschaften verwenden, um mehrere Felder zu aktualisieren, bevor Sie die Aktualisierungen mithilfe von UpdateModuleAsync auf das Gerät schreiben.

Rufen Sie nach der Aktualisierung von Modulidentitätszwillingsfeldern UpdateModuleAsync auf, um Module-Objektfeldaktualisierungen zurück auf ein Gerät zu schreiben. Verwenden Sie die try- und catch-Logik, die mit einem Fehlerhandler gekoppelt ist, um falsch formatierte Patchfehler aus UpdateModuleAsync abzufangen.

In diesem Beispiel wird ein Modul in ein Module-Objekt abgerufen, die module LastActivityTime-Eigenschaft aktualisiert und anschließend das Modul im IoT Hub mithilfe von UpdateModuleAsync aktualisiert.

// Retrieve the module
var module = await registryManager.GetModuleAsync("myDeviceId","myModuleId");

// Update the module object
module.LastActivityTime = DateTime.Now;

// Apply the patch to update the device twin tags section
try
{
   await registryManager.UpdateModuleAsync(module);
}
catch (Exception e)
{
   console.WriteLine("Module update failed.", e.Message);
}

Andere Modul-API

• GetModulesOnDeviceAsync: Ruft die Modulidentitäten auf einem Gerät ab
• RemoveModuleAsync: Löscht ein zuvor registriertes Modul von einem Gerät

Beispiel des SDK-Diensts

Das Azure IoT SDK für .NET bietet ein praktisches Beispiel für eine Dienst-App, die Aufgaben von Modulidentitätszwillingen verarbeitet. Weitere Informationen finden Sie unter Registry Manager E2E Tests.

• Empfohlen wird Python, Version 3.7 oder höher. Stellen Sie je nach Einrichtung sicher, dass die 32-Bit- bzw. die 64-Bit-Installation verwendet wird. Fügen Sie Python Ihrer plattformspezifischen Umgebungsvariablen hinzu, wenn Sie während der Installation dazu aufgefordert werden.

Übersicht

Dieser Artikel beschreibt, wie Sie Azure IoT-SDK für Python verwenden, um Geräte- und Back-End-Dienstanwendungscode für Modulidentitätszwillinge zu erstellen.

Installieren von Paketen

Die Azure-iot-Device-Bibliothek muss installiert werden, um Geräteanwendungen zu erstellen.

pip install azure-iot-device

Die Azure-iot-hub-Bibliothek muss installiert werden, um Back-End-Dienstanwendungen zu erstellen.

pip install azure-iot-hub

Die Msrest-Bibliothek wird verwendet, um HTTPOperationError-Ausnahmen abzufangen.

pip install msrest

Erstellen einer Geräteanwendung

In diesem Abschnitt wird beschrieben, wie Sie Geräteanwendungscode verwenden, um:

• Abrufen eines Modulidentitätszwillings und Untersuchen gemeldeter Eigenschaften
• Aktualisieren der gemeldeten Eigenschaften des Modulidentitätszwillings
• Erstellen eines Rückrufhandlers zum Aktualisieren gewünschter Eigenschaften des Modulidentitätszwillings

Importanweisungen

Fügen Sie diese import-Anweisung hinzu, um die Gerätebibliothek zu verwenden.

# import the device client library
import asyncio
from azure.iot.device.aio import IoTHubDeviceClient

Mit einem Gerät verbinden

Die IoTHubModuleClient-Klasse enthält Methoden, die zum Arbeiten mit Modulidentitätszwillingen verwendet werden können.

So stellen Sie eine Verbindung zwischen einer Anwendung und einem Gerät her:

1. Rufen Sie create_from_connection_string auf, um die Verbindungszeichenfolge der Modulidentität hinzuzufügen
2. Rufen Sie connect auf, um den Geräteclient mit Azure IoT Hub zu verbinden

# import the device client library
import asyncio
from azure.iot.device.aio import IoTHubDeviceClient

# substitute the device connection string in conn_str
# and add it to the IoTHubDeviceClient object
conn_str = "{Device module identity connection string}"
device_client = IoTHubDeviceClient.create_from_connection_string(conn_str)

# connect the application to the device
await device_client.connect()

Abrufen eines Modulidentitätszwillings und Untersuchen von Eigenschaften

Rufen Sie get_twin auf, um den Modulidentitätszwilling aus dem Azure IoT Hub-Dienst abzurufen. Die Zwillingsinformationen werden in eine Variable eingefügt, die untersucht werden kann.

In diesem Beispiel wird der Gerätezwilling abgerufen und der Befehl print verwendet, um den Gerätezwilling im JSON-Format anzuzeigen.

# get the twin
twin = await device_client.get_twin()
print("Twin document:")
print("{}".format(twin))

Aktualisieren der gemeldeten Eigenschaften des Modulidentitätszwillings

Sie können einen Patch anwenden, um die gemeldeten Eigenschaften des Modulidentitätszwilling im JSON-Format zu aktualisieren.

So wenden Sie ein Patch zum Aktualisieren gemeldeter Eigenschaften an:

1. Weisen Sie ein JSON-Patch einer gemeldeten Eigenschaft einer Variablen zu.
2. Rufen Sie patch_twin_reported_properties auf, um den JSON-Patch auf die gemeldeten Eigenschaften anzuwenden.

Zum Beispiel:

# create the reported properties patch
reported_properties = {"temperature": random.randint(320, 800) / 10}
print("Setting reported temperature to {}".format(reported_properties["temperature"]))
# update the reported properties and wait for the result
await device_client.patch_twin_reported_properties(reported_properties)

Erstellen eines Rückrufhandlers zum Aktualisieren gewünschter Eigenschaften des Modulidentitätszwillings

Rufen Sie on_twin_desired_properties_patch_received auf, um eine Handlerfunktion oder Coroutine zu erstellen, die aufgerufen werden, wenn ein Patch für die gewünschten Eigenschaften eines Modulidentitätszwillings empfangen wird. Der Handler verwendet ein Argument, bei dem es sich um den Zwillingspatch in Form eines JSON-Wörterbuchobjekts handelt.

In diesem Beispiel wird ein Patchhandler für die gewünschten Eigenschaften mit dem Namen twin_patch_handler eingerichtet.

Zum Beispiel:

try:
    # Set handlers on the client
    device_client.on_twin_desired_properties_patch_received = twin_patch_handler
except:
    # Clean up in the event of failure
    client.shutdown()

Der twin_patch_handler empfängt und druckt die JSON-Aktualisierungen der gewünschten Eigenschaften.

    # Define behavior for receiving twin desired property patches
    def twin_patch_handler(twin_patch):
        print("Twin patch received:")
        print(twin_patch)

Beispiele für SDK-Geräte

Das Azure IoT SDK für Python bietet ein funktionierendes Beispiel für Geräte-Apps, die Modulidentitätszwillingsaufgaben verarbeiten:

• get_twin: Stellen Sie eine Verbindung mit einem Gerät her und rufen Sie die Informationen zum Zwilling ab.
• update_twin_reported_properties: Aktualisieren Sie die gemeldeten Eigenschaften des Zwillings.
• receive_twin_desired_properties: Empfangen und aktualisieren Sie die gewünschten Eigenschaften.

Erstellen einer Back-End-Anwendung

In diesem Abschnitt wird beschrieben, wie Sie eine Back-End-Anwendung zum Abrufen und Aktualisieren von Eigenschaften des Modulidentitätszwillings erstellen.

Die Klasse IoTHubRegistryManager macht alle Methoden verfügbar, die für die Erstellung einer Back-End-Anwendung zur Interaktion mit Modulidentitätszwillingen des Diensts erforderlich sind.

Dienst-Importanweisungen

Fügen Sie diese import-Anweisung hinzu, um die Dienstbibliothek zu verwenden.

import sys
from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import Twin, TwinProperties, QuerySpecification, QueryResult

Herstellen einer Verbindung mit dem IoT-Hub

Sie können einen Back-End-Dienst mit IoT Hub mithilfe der folgenden Methoden verbinden:

• SAS-Richtlinie
• Microsoft Entra

Herstellen einer Verbindung mithilfe einer SAS-Richtlinie

Stellen Sie mithilfe von from_connection_string eine Verbindung mit dem IoT-Hub her.

Die in diesem Abschnitt verwendete update_module_twin-Methode erfordert die Berechtigung der SAS-Richtlinie Service Connect, um einem Modul gewünschte Eigenschaften hinzuzufügen. Geben Sie als Parameter für from_connection_string eine Verbindungszeichenfolge als SAS-Richtlinien an, welche die Berechtigung Service Connect enthält. Weitere Informationen zu SAS-Richtlinien finden Sie unter Steuer des Zugriffs auf IoT Hub mithilfe von Shared Access Signatures.

Zum Beispiel:

# Connect to IoT hub
IOTHUB_CONNECTION_STRING = "{IoT hub shared access policy connection string}"
iothub_registry_manager = IoTHubRegistryManager.from_connection_string(IOTHUB_CONNECTION_STRING)

Verbinden mit Microsoft Entra

Eine Back-End-App, die Microsoft Entra verwendet, muss erfolgreich authentifiziert werden und Anmeldeinformationen für Sicherheitstoken erhalten, bevor Sie eine Verbindung mit IoT Hub herstellen. Dieses Token wird an eine IoT Hub-Verbindungsmethode übergeben. Allgemeine Informationen zum Einrichten und Verwenden von Microsoft Entra für IoT Hub finden Sie unter Steuern des Zugriffs auf IoT Hub mithilfe von Microsoft Entra ID.

Eine Übersicht über die Python SDK-Authentifizierung finden Sie unter Authentifizieren von Python-Apps für Azure-Dienste mithilfe des Azure SDK für Python

Konfigurieren der Microsoft Entra-App

Sie müssen eine Microsoft Entra-App einrichten, die für Ihre bevorzugten Authentifizierungsanmeldeinformationen konfiguriert ist. Die App enthält Parameter wie den geheimen Clientschlüssel, der von der Back-End-Anwendung zur Authentifizierung verwendet wird. Die verfügbaren Konfigurationen für die App-Authentifizierung sind:

• Geheimer Clientschlüssel
• Zertifikat
• Anmeldeinformationen für Verbundidentität

Microsoft Entra-Apps erfordern je nach ausgeführten Vorgängen möglicherweise bestimmte Rollenberechtigungen. Beispielsweise ist IoT Hub Twin Contributor erforderlich, um Lese- und Schreibzugriff auf ein IoT Hub-Gerät und Modulzwilling zu ermöglichen. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf IoT Hub mithilfe der Azure RBAC-Rollenzuweisung.

Weitere Informationen zum Einrichten einer Microsoft Entra-App finden Sie in der Schnellstartanleitung: Registrieren einer Anwendung bei der Microsoft Identitäts-Plattform.

Authentifizieren mithilfe von DefaultAzureCredential

Die einfachste Möglichkeit, Microsoft Entra zum Authentifizieren einer Back-End-Anwendung zu verwenden, besteht darin, DefaultAzureCredential zu verwenden. Es wird jedoch empfohlen, eine andere Methode in einer Produktionsumgebung zu verwenden, einschließlich einer bestimmten TokenCredential oder analysierten ChainedTokenCredential. Der Einfachheit halber beschreibt dieser Abschnitt die Authentifizierung mit DefaultAzureCredential und den geheimen Clientschlüssel. Weitere Informationen zu den Vor- und Nachteilen der Verwendung von DefaultAzureCredential finden Sie unter Anmeldeinformationsketten in der Azure Identity-Clientbibliothek für Python.

DefaultAzureCredential unterstützt verschiedene Authentifizierungsmechanismen und bestimmt den entsprechenden Anmeldeinformationstyp basierend auf der Umgebung, in der er ausgeführt wird. Er versucht, mehrere Anmeldeinformationstypen in einer Reihenfolge zu verwenden, bis er eine funktionierende Anmeldeinformation findet.

Microsoft Entra erfordert dieses Importpaket und die entsprechende import-Anweisung:

pip install azure-identity

from azure.identity import DefaultAzureCredential

In diesem Beispiel wurden Clientschlüssel, Client-ID und Mandanten-ID der Microsoft Entra-App zu Umgebungsvariablen hinzugefügt. Diese Umgebungsvariablen werden von DefaultAzureCredential verwendet, um die Anwendung zu authentifizieren. Das Ergebnis einer erfolgreichen Microsoft Entra-Authentifizierung ist eine Sicherheitstoken-Anmeldeinformation, die an eine IoT Hub-Verbindungsmethode übergeben wird.

from azure.identity import DefaultAzureCredential
credential = DefaultAzureCredential()

Das resultierende AccessToken kann dann an from_token_credential zur Verbindung mit IoT Hub für jeden SDK-Client übergeben werden, der Microsoft Entra-Anmeldeinformationen akzeptiert:

• IoTHubRegistryManager zum Erstellen einer Dienstverbindung mit IoT Hub mithilfe einer Entra-Token-Anmeldeinformationen.
• IoTHubJobManager
• DigitalTwinClient
• IoTHubHttpRuntimeManager
• IoTHubConfigurationManager

from_token_credential erfordert zwei Parameter:

• Die Azure-Dienst-URL – Die Azure-Dienst-URL sollte im Format {Your Entra domain URL}.azure-devices.net ohne ein https://-Präfix vorliegen. Beispiel: MyAzureDomain.azure-devices.net.
• Das Azure-Anmeldeinformationstoken

In diesem Beispiel werden die Azure-Anmeldeinformationen mithilfe von DefaultAzureCredential erlangt. Die Azure-Dienst-URL und die Anmeldeinformationen werden dann an IoTHubRegistryManager.from_token_credential bereitgestellt, um die Verbindung mit IoT Hub zu erstellen.

import sys
import os

from azure.identity import DefaultAzureCredential
from azure.iot.hub import IoTHubRegistryManager

# Define the client secret values
clientSecretValue = 'xxxxxxxxxxxxxxx'
clientID = 'xxxxxxxxxxxxxx'
tenantID = 'xxxxxxxxxxxxx'

# Set environment variables
os.environ['AZURE_CLIENT_SECRET'] = clientSecretValue
os.environ['AZURE_CLIENT_ID'] = clientID
os.environ['AZURE_TENANT_ID'] = tenantID

# Acquire a credential object
credential = DefaultAzureCredential()

# Use Entra to authorize IoT Hub service
print("Connecting to IoTHubRegistryManager...")
iothub_registry_manager = IoTHubRegistryManager.from_token_credential(
url="MyAzureDomain.azure-devices.net",
token_credential=credential)

Codebeispiele

Arbeitsbeispiele für die Microsoft Entra-Dienstauthentifizierung finden Sie unter Microsoft Authentication Library (MSAL) für Python.

Abrufen und Aktualisieren von Eigenschaften des Modulidentitätszwillings

Sie können die gewünschten Eigenschaften aus einer Back-End-Anwendung mithilfe von update_module_twin aktualisieren.

So rufen Sie die gewünschten Eigenschaften des Modulidentitätszwillings ab und aktualisieren sie:

1. Rufen Sie get_module_twin auf, um die aktuelle Version des Modulidentitätszwillings abzurufen.
2. Verwenden Sie die Twin-Klasse, um gewünschte Eigenschaften im JSON-Format hinzuzufügen.
3. Rufen Sie update_module_twin auf, um den Patch auf den Gerätezwilling anzuwenden. Sie können auch replace_module_twin verwenden, um die gewünschten Eigenschaften und Tags für einen Modulidentitätszwilling zu ersetzen.

In diesem Beispiel wird die telemetryInterval gewünschte Eigenschaft auf 122 aktualisiert.

try:
    module_twin = iothub_registry_manager.get_module_twin(DEVICE_ID, MODULE_ID)
    print ( "" )
    print ( "Module identity twin properties before update:" )
    print ( "{0}".format(module_twin.properties) )

    # Update twin
    twin_patch = Twin()
    twin_patch.properties = TwinProperties(desired={"telemetryInterval": 122})
    updated_module_twin = iothub_registry_manager.update_module_twin(
        DEVICE_ID, MODULE_ID, twin_patch, module_twin.etag
    )
    print ( "" )
    print ( "Module identity twin properties after update     :" )
    print ( "{0}".format(updated_module_twin.properties) )

except Exception as ex:
    print ( "Unexpected error {0}".format(ex) )
except KeyboardInterrupt:
    print ( "IoTHubRegistryManager sample stopped" )

Beispiel des SDK-Diensts

Das Azure IoT SDK für Python bietet ein praktisches Beispiel für eine Dienst-App, die Aufgaben von Modulidentitätszwillingen verarbeitet. Weitere Informationen finden Sie unter Test IoTHub Registry Manager.

• Erfordert die Node.js-Version 10.0.x oder höher

Übersicht

Dieser Artikel beschreibt, wie Sie Azure IoT-SDK für Node.js verwenden, um Geräte- und Back-End-Dienstanwendungscode für Modulidentitätszwillinge zu erstellen.

Erstellen einer Geräteanwendung

In diesem Abschnitt wird beschrieben, wie Sie das Paket azure-iot-device im Azure IoT SDK für Node.js verwenden, um eine Geräteanwendung zu erstellen, um:

• Abrufen eines Modulidentitätszwillings und Untersuchen gemeldeter Eigenschaften
• Aktualisieren der Modulidentität gemeldeten Zwillingseigenschaften
• Erhalten Sie eine Benachrichtigung über Änderungen der gewünschten Eigenschaft des Modulidentitätszwilling

Das Paket azure-iot-device enthält Objekte, die über eine Schnittstelle mit IoT-Geräten verfügen. Die Twin-Klasse enthält für Zwillinge spezifische Objekte. In diesem Abschnitt wird der Client-Klassencode beschrieben, der zum Lesen und Schreiben von Daten zu Modulidentitätszwillingen verwendet wird.

Installieren des SDK-Pakets

Führen Sie diesen Befehl aus, um das Geräte-SDK azure-iot-device auf Ihrem Computer zu installieren:

npm install azure-iot-device --save

Verbinden eines Geräts mit IoT Hub

Eine Geräte-App kann sich mit den folgenden Methoden bei IoT Hub authentifizieren:

• Schlüssel für den gemeinsamen Zugriff
• X.509-Zertifikat

Authentifizieren mithilfe eines Schlüssels für den gemeinsamen Zugriff

Auswählen eines Transportprotokolls

Das Client-Objekt unterstützt die folgenden Protokolle:

• Amqp
• Http: Bei Verwendung von Http führt die Client-Instanz selten eine Überprüfung auf Nachrichten von IoT Hub durch (mindestens alle 25 Minuten).
• Mqtt
• MqttWs
• AmqpWs

Installieren Sie die erforderlichen Transportprotokolle auf Ihrem Computer.

Mit diesem Befehl wird beispielsweise das Amqp-Protokoll installiert:

npm install azure-iot-device-amqp --save

Weitere Informationen zu den Unterschieden zwischen der Unterstützung für MQTT, AMQP und HTTPS finden Sie unter Leitfaden zur C2D-Kommunikation und Auswählen eines Gerätekommunikationsprotokolls.

Erstellen eines Clientobjekts

Erstellen Sie ein Client-Objekt mithilfe des installierten Pakets.

Zum Beispiel:

const Client = require('azure-iot-device').Client;

Erstellen eines Protokollobjekts

Erstellen Sie ein Protocol-Objekt mithilfe eines installierten Transportpakets.

In diesem Beispiel wird das AMQP-Protokoll zugewiesen:

const Protocol = require('azure-iot-device-amqp').Amqp;

Fügen Sie die Verbindungszeichenfolge des Geräts und das Transportprotokoll hinzu

Rufen Sie fromConnectionString auf, um Verbindungsparameter für das Gerät zu liefern:

• connStr: Verbindungszeichenfolge des IoT-Hub-Identitätsmoduls.
• transportCtor: Das Transportprotokoll

In diesem Beispiel wird das Amqp-Transportprotokoll verwendet:

const deviceConnectionString = "{IoT hub identity module connection string}"
const Protocol = require('azure-iot-device-mqtt').Amqp;
let client = Client.fromConnectionString(deviceConnectionString, Protocol);

Öffnen der Verbindung mit IoT Hub

Verwenden Sie die open-Methode, um eine Verbindung zwischen einem IoT-Gerät und IoT Hub zu öffnen.

Zum Beispiel:

client.open(function(err) {
  if (err) {
    console.error('error connecting to hub: ' + err);
    process.exit(1);
  }
})

Authentifizierung mit einem X.509-Zertifikat

Das X.509-Zertifikat wird an die Übertragung über die Verbindung zwischen Gerät und IoT Hub angefügt.

So konfigurieren Sie eine Verbindung zwischen einem Gerät und IoT Hub mit einem X.509-Zertifikat

1. Rufen Sie fromConnectionString auf, um die Verbindungszeichenfolge des Gerätes oder Identitätsmoduls und den Transporttyp zum Client-Objekt hinzuzufügen. Fügen Sie der Verbindungszeichenfolge x509=true hinzu, um anzugeben, dass ein Zertifikat zu DeviceClientOptions hinzugefügt wird. Zum Beispiel:

   • Eine Geräte-Verbindungszeichenfolge:

     HostName=xxxxx.azure-devices.net;DeviceId=Device-1;SharedAccessKey=xxxxxxxxxxxxx;x509=true

   • Ein Identitätsmodul-Verbindungszeichenfolge:

     HostName=xxxxx.azure-devices.net;DeviceId=Device-1;ModuleId=Module-1;SharedAccessKey=xxxxxxxxxxxxx;x509=true

2. Konfigurieren Sie eine JSON-Variable mit Zertifikatdetails, und übergeben Sie sie an DeviceClientOptions.

3. Rufen Sie setOptions auf, um dem Clienttransport ein X.509-Zertifikat und einen Schlüssel (und optional eine Passphrase) hinzuzufügen.

4. Rufen Sie open auf, um die Verbindung vom Gerät zu IoT Hub zu öffnen.

Das folgende Beispiel zeigt Zertifikatkonfigurationsinformationen in einer JSON-Variable. Die Zertifizierungskonfiguration clientOptions wird an setOptions übergeben und die Verbindung wird mit open geöffnet.

const Client = require('azure-iot-device').Client;
const Protocol = require('azure-iot-device-mqtt').Mqtt;
// Connection string illustrated for demonstration only. Never hard-code the connection string in production. Instead use an environmental variable or other secure storage.
const connectionString = `HostName=xxxxx.azure-devices.net;DeviceId=Device-1;SharedAccessKey=xxxxxxxxxxxxx;x509=true`
const client = Client.fromConnectionString(connectionString, Protocol);

var clientOptions = {
   cert: myX509Certificate,
   key: myX509Key,
   passphrase: passphrase,
   http: {
     receivePolicy: {
       interval: 10
     }
   }
 }

 client.setOptions(clientOptions);
 client.open(connectCallback);

Weitere Informationen zur Zertifikatauthentifizierung finden Sie unter:

• Authentifizieren von Identitäten mit X.509-Zertifikaten
• Erstellen und Hochladen von Zertifikaten für Tests

Codebeispiel

Ein funktionierendes Beispiel für die Authentifizierung mit X.509-Zertifikaten finden Sie unter Einfaches Gerätebeispiel (X.509).

Abrufen eines Modulidentitätszwillings und Untersuchen gemeldeter Eigenschaften

Rufen Sie getTwin auf, um aktuelle Informationen zu Modulidentitätszwillingen in einem Twin-Objekt abzurufen.

Der Gerätecode kann dann auf die Eigenschaften des Modulidentitätszwillings zugreifen.

Zum Beispiel:

// Retrieve the current module identity twin
client.getTwin(function(err, twin))
if (err)
    console.error('could not get twin');

// Display the current properties
console.log('twin contents:');
console.log(twin.properties);

Aktualisieren der gemeldeten Eigenschaften des Modulidentitätszwillings

Verwenden Sie update, um die gemeldeten Eigenschaften des Gerätezwillings zu aktualisieren. Fügen Sie einen JSON-formatierten Patch als ersten Parameter und eine Rückrufmethode für den Status der Funktionsausführung als zweiten Parameter zur Methode hinzu.

In diesem Beispiel wird ein JSON-formatierter Patch für den Modulidentitätszwilling in der Variablen patch gespeichert. Der Patch enthält einen connectivity-Updatewert für den Modulidentitätszwilling von cellular. Der Patch- und Fehlerhandler werden an die update-Methode übergeben. Wenn ein Fehler auftritt, wird eine Fehlermeldung in der Konsole angezeigt.

// Create a patch to send to IoT Hub
var patch = {
  updateTime: new Date().toString(),
  firmwareVersion:'1.2.1',
  weather:{
    temperature: 72,
    humidity: 17
  }
};

// Apply the patch
twin.properties.reported.update(patch, function(err)
  {
    if (err)
      {
        console.error('could not update twin');
      } 
    else
      {
        console.log('twin state reported');
        process.exit();
      }
  });

Erhalten Sie eine Benachrichtigung über Änderungen der gewünschten Eigenschaft des Modulidentitätszwilling

Erstellen Sie einen Ereignislistener zur Aktualisierung gewünschter Eigenschaften des Modulidentitätszwillings, der ausgeführt wird, wenn eine gewünschte Eigenschaft geändert wird, indem der Name der Rückrufhandlermethode an twin.on übergeben wird.

Der gewünschte Ereignislistener für die Eigenschaft kann die folgenden Formen annehmen:

• Empfangen aller Patches mit einem einzelnen Ereignishandler
• Empfangen eines Ereignisses, wenn sich etwas bei einer Eigenschaftengruppierung ändert
• Empfangen eines Ereignisses für eine einzelne Änderung einer Eigenschaft

Empfangen aller Patches mit einem einzelnen Ereignishandler

Sie können einen Listener erstellen, um jede Änderung einer gewünschten Eigenschaft zu erhalten.

In diesem Beispielcode werden alle Eigenschaften ausgegeben, die vom Dienst empfangen werden.

twin.on('properties.desired', function (delta) {
    console.log('new desired properties received:');
    console.log(JSON.stringify(delta));
});

Empfangen eines Ereignisses, wenn sich etwas bei einer Eigenschaftengruppierung ändert

Sie können einen Listener erstellen, um ein Ereignis zu empfangen, wenn sich etwas bei einer Eigenschaftsgruppierung ändert.

Zum Beispiel:

1. Die Eigenschaften minTemperature und maxTemperature befinden sich unter einer Eigenschaftsgruppierung mit dem Namen properties.desired.climate changes.

2. Eine Back-End-Dienstanwendung wendet diesen Patch an, um die gewünschten Eigenschaften minTemperature und maxTemperature zu aktualisieren:

   const twinPatch1 = {
   properties: {
      desired: {
       climate: { minTemperature: 68, maxTemperature: 76, },
       },
     },
    };
   

3. Dieser Code richtet einen Ereignislistener für Änderungen der gewünschten Eigenschaft ein, der für Änderungen innerhalb der properties.desired.climate-Eigenschaftengruppierung ausgelöst wird. Wenn innerhalb dieser Gruppe eine Änderung der gewünschten Eigenschaft vorliegt, werden Meldungen zur minimalen und maximalen Temperaturänderung in der Konsole angezeigt:

   twin.on('properties.desired.climate', function (delta) {
       if (delta.minTemperature || delta.maxTemperature) {
           console.log('updating desired temp:');
           console.log('min temp = ' + twin.properties.desired.climate.minTemperature);
           console.log('max temp = ' + twin.properties.desired.climate.maxTemperature);
       }
   });
   

Empfangen eines Ereignisses für eine einzelne Änderung einer Eigenschaft

Sie können einen Listener für eine einzelne Änderung einer Eigenschaft einrichten. In diesem Beispiel wird der Code für dieses Ereignis nur ausgeführt, wenn der boolesche Wert fanOn Teil des Patches ist. Der Code gibt den neuen gewünschten Zustand fanOn aus, wenn der Dienst ihn aktualisiert.

1. Eine Back-End-Anwendung wendet den Patch für die gewünschten Eigenschaften an:

    const twinPatch2 = {
     properties: {
       desired: {
         climate: {
           hvac: {
             systemControl: { fanOn: true, },
           },
         },
       },
     },
   };
   

2. Der Listener wird nur ausgelöst, wenn sich die fanOn-Eigenschaft ändert:

    twin.on('properties.desired.climate.hvac.systemControl', function (fanOn) {
        console.log('setting fan state to ' + fanOn);
     });
   

Vollständiges Beispiel

In diesem Beispiel werden die Prinzipien dieses Abschnitts gekapselt, einschließlich der Schachtelung der Rückruffunktion mit mehreren Ebenen.

var Client = require('azure-iot-device').Client;
var Protocol = require('azure-iot-device-amqp').Amqp;
// Copy/paste your module connection string here.
var connectionString = 'HostName=xxx.azure-devices.net;DeviceId=myFirstDevice2;ModuleId=myFirstModule2;SharedAccessKey=xxxxxxxxxxxxxxxxxx';
// Create a client using the Amqp protocol.
var client = Client.fromConnectionString(connectionString, Protocol);
client.on('error', function (err) {
  console.error(err.message);
});
// connect to the hub
client.open(function(err) {
  if (err) {
    console.error('error connecting to hub: ' + err);
    process.exit(1);
  }
  console.log('client opened');
// Create device Twin
  client.getTwin(function(err, twin) {
    if (err) {
      console.error('error getting twin: ' + err);
      process.exit(1);
    }
    // Output the current properties
    console.log('twin contents:');
    console.log(twin.properties);
    // Add a handler for desired property changes
    twin.on('properties.desired', function(delta) {
        console.log('new desired properties received:');
        console.log(JSON.stringify(delta));
    });
    // create a patch to send to the hub
    var patch = {
      updateTime: new Date().toString(),
      firmwareVersion:'1.2.1',
      weather:{
        temperature: 75,
        humidity: 20
      }
    };
    // send the patch
    twin.properties.reported.update(patch, function(err) {
      if (err) throw err;
      console.log('twin state reported');
    });

  });
});

Beispiele für Geräte-SDK

Das Azure IoT SDK für Node.js bietet Arbeitsbeispiele von Geräte-Apps, die Modulidentitätszwillingsaufgaben verarbeiten. Weitere Informationen finden Sie unter:

• Modulidentitätszwilling
• Module Test Helper
• Twin e2e Tests

Erstellen einer Back-End-Anwendung

In diesem Abschnitt wird beschrieben, wie Sie eine Back-End-Anwendung erstellen, die einen Modulidentitätszwilling abruft und die gewünschten Eigenschaften aktualisiert.

Dienst-SDK-Paket installieren

Führen Sie diesen Befehl aus, um azure-iothub auf Ihrem Computer zu installieren:

npm install azure-iothub --save

Erstellen eines Registrierungsobjekts

Die Registry-Klasse macht alle Methoden verfügbar, die für die Interaktion mit Modulidentitätszwillingen einer Back-End-Anwendung erforderlich sind.

let Registry = require('azure-iothub').Registry;

Herstellen einer Verbindung mit dem IoT-Hub

Sie können einen Back-End-Dienst mit IoT Hub mithilfe der folgenden Methoden verbinden:

• SAS-Richtlinie
• Microsoft Entra

Herstellen einer Verbindung mithilfe einer SAS-Richtlinie

Verwenden Sie fromConnectionString, um eine Verbindung mit dem IoT-Hub herzustellen.

Die in diesem Abschnitt verwendete update-Methode erfordert die Berechtigung der SAS-Richtlinie Service Connect, um einem Modul gewünschte Eigenschaften hinzuzufügen. Geben Sie als Parameter für fromConnectionString eine Verbindungszeichenfolge als SAS-Richtlinien an, welche die Berechtigung Service Connect enthält. Weitere Informationen zu SAS-Richtlinien finden Sie unter Steuer des Zugriffs auf IoT Hub mithilfe von Shared Access Signatures.

let connectionString = '{IoT hub shared access policy connection string}';
let registry = Registry.fromConnectionString(serviceConnectionString);

Verbinden mit Microsoft Entra

Eine Back-End-App, die Microsoft Entra verwendet, muss erfolgreich authentifiziert werden und Anmeldeinformationen für Sicherheitstoken erhalten, bevor Sie eine Verbindung mit IoT Hub herstellen. Dieses Token wird an eine IoT Hub-Verbindungsmethode übergeben. Allgemeine Informationen zum Einrichten und Verwenden von Microsoft Entra für IoT Hub finden Sie unter Steuern des Zugriffs auf IoT Hub mithilfe von Microsoft Entra ID.

Eine Übersicht über Node.js SDK-Authentifizierung finden Sie unter:

• Erste Schritte mit der Benutzerauthentifizierung in Azure
• Azure Identity-Clientbibliothek für JavaScript

Konfigurieren der Microsoft Entra-App

Sie müssen eine Microsoft Entra-App einrichten, die für Ihre bevorzugten Authentifizierungsanmeldeinformationen konfiguriert ist. Die App enthält Parameter wie den geheimen Clientschlüssel, der von der Back-End-Anwendung zur Authentifizierung verwendet wird. Die verfügbaren Konfigurationen für die App-Authentifizierung sind:

• Geheimer Clientschlüssel
• Zertifikat
• Anmeldeinformationen für Verbundidentität

Microsoft Entra-Apps erfordern je nach ausgeführten Vorgängen möglicherweise bestimmte Rollenberechtigungen. Beispielsweise ist IoT Hub Twin Contributor erforderlich, um Lese- und Schreibzugriff auf ein IoT Hub-Gerät und Modulzwilling zu ermöglichen. Weitere Informationen finden Sie unter Verwalten des Zugriffs auf IoT Hub mithilfe der Azure RBAC-Rollenzuweisung.

Weitere Informationen zum Einrichten einer Microsoft Entra-App finden Sie in der Schnellstartanleitung: Registrieren einer Anwendung bei der Microsoft Identitäts-Plattform.

Authentifizieren mithilfe von DefaultAzureCredential

Die einfachste Möglichkeit, Microsoft Entra zum Authentifizieren einer Back-End-Anwendung zu verwenden, besteht darin, DefaultAzureCredential zu verwenden. Es wird jedoch empfohlen, eine andere Methode in einer Produktionsumgebung zu verwenden, einschließlich einer bestimmten TokenCredential oder analysierten ChainedTokenCredential. Der Einfachheit halber beschreibt dieser Abschnitt die Authentifizierung mit DefaultAzureCredential und den geheimen Clientschlüssel. Weitere Informationen zu den Vor- und Nachteilen der Verwendung von DefaultAzureCredential finden Sie unter Anmeldeinformationsketten in der Azure Identity-Clientbibliothek für JavaScript

DefaultAzureCredential unterstützt verschiedene Authentifizierungsmechanismen und bestimmt den entsprechenden Anmeldeinformationstyp basierend auf der Umgebung, in der er ausgeführt wird. Er versucht, mehrere Anmeldeinformationstypen in einer Reihenfolge zu verwenden, bis er eine funktionierende Anmeldeinformation findet.

Microsoft Entra erfordert dieses Paket:

npm install --save @azure/identity

In diesem Beispiel wurden Clientschlüssel, Client-ID und Mandanten-ID der Microsoft Entra-App zu Umgebungsvariablen hinzugefügt. Diese Umgebungsvariablen werden von DefaultAzureCredential verwendet, um die Anwendung zu authentifizieren. Das Ergebnis einer erfolgreichen Microsoft Entra-Authentifizierung ist eine Sicherheitstoken-Anmeldeinformation, die an eine IoT Hub-Verbindungsmethode übergeben wird.

import { DefaultAzureCredential } from "@azure/identity";

// Azure SDK clients accept the credential as a parameter
const credential = new DefaultAzureCredential();

Das resultierende Anmeldeinformationstoken kann dann an fromTokenCredential übergeben werden, um eine Verbindung mit IoT Hub für jeden SDK-Client herzustellen, der Microsoft Entra-Anmeldeinformationen akzeptiert:

• Registrierung
• Client
• JobClient

fromTokenCredential erfordert zwei Parameter:

• Die Azure-Dienst-URL – Die Azure-Dienst-URL sollte im Format {Your Entra domain URL}.azure-devices.net ohne ein https://-Präfix vorliegen. Beispiel: MyAzureDomain.azure-devices.net.
• Das Azure-Anmeldeinformationstoken

In diesem Beispiel werden die Azure-Anmeldeinformationen mithilfe von DefaultAzureCredential erlangt. Die Azure-Domänen-URL und Anmeldeinformationen werden dann an Registry.fromTokenCredential bereitgestellt, um die Verbindung mit IoT Hub zu erstellen.

const { DefaultAzureCredential } = require("@azure/identity");

let Registry = require('azure-iothub').Registry;

// Define the client secret values
clientSecretValue = 'xxxxxxxxxxxxxxx'
clientID = 'xxxxxxxxxxxxxx'
tenantID = 'xxxxxxxxxxxxx'

// Set environment variables
process.env['AZURE_CLIENT_SECRET'] = clientSecretValue;
process.env['AZURE_CLIENT_ID'] = clientID;
process.env['AZURE_TENANT_ID'] = tenantID;

// Acquire a credential object
const credential = new DefaultAzureCredential()

// Create an instance of the IoTHub registry
hostName = 'MyAzureDomain.azure-devices.net';
let registry = Registry.fromTokenCredential(hostName,credential);

Codebeispiele

Arbeitsbeispiele für die Microsoft Entra-Dienstauthentifizierung finden Sie in Azure-Identitätsbeispielen.

Abrufen eines Modulidentitätszwillings und Aktualisieren der gewünschten Eigenschaften

Sie können einen Patch erstellen, der die gewünschten Eigenschaftenupdates für einen Modulidentitätszwillings enthält.

So aktualisieren Sie einen Modulidentitätszwilling:

1. Rufen Sie getModuleTwin auf, um das Gerät Twin-Objekt abzurufen.

2. Formatieren Sie einen Patch, der das Modulidentitätszwillingsupdate enthält. Der Patch ist in JSON formatiert, wie in der Twin-Klassebeschrieben. Ein Back-End-Dienstpatch enthält die gewünschten Eigenschaftenupdates. Weitere Informationen zum Patchformat finden Sie unter Format von Tags und Eigenschaften.

3. Rufen Sie die Aktualisierung auf, um den Modulidentitätszwilling mit dem Patch zu aktualisieren.

In diesem Beispiel wird der Modulidentitätszwilling für myDeviceId und myModuleId abgerufen. Anschließend wird ein Patch auf die Zwillinge angewendet, der climate-Informationen enthält.

// Insert your device ID and moduleId here.
var deviceId = 'myFirstDevice2';
var moduleId = 'myFirstModule2';

// Retrieve the current module identity twin
registry.getModuleTwin(deviceId, moduleId, function (err, twin) {
  console.log('getModuleTwin returned ' + (err ? err : 'success'));
  if (err) {
    console.log(err);
  } else {
    console.log('success');
    console.log('Current twin:' + JSON.stringify(twin))

    // Format a desired property patch
    const twinPatch1 = {
      properties: {
        desired: {
          climate: { minTemperature: 69, maxTemperature: 77, },
        },
      },
    };

    // Send the desired property patch to IoT Hub
    twin.update(twinPatch1, function(err) {
    if (err) throw err;
    console.log('twin state reported');
    });
  }
});

Dienst-SDK-Beispiele

Das Azure IoT SDK für Node.js bietet Arbeitsbeispiele von Dienst-Apps, die Modulidentitätszwillingsaufgaben verarbeiten. Weitere Informationen finden Sie unter:

• Modulidentitätszwilling
• Module Test Helper
• Twin e2e Tests