Schnellstart: Bereitstellen einer Azure IoT Hub-Instanz und eines Speicherkontos mithilfe von Bicep

Artikel
01/05/2024

In dieser Schnellstartanleitung verwenden Sie Bicep zum Erstellen eines IoT-Hubs, eines Azure Storage-Kontos und einer Route zum Senden von Nachrichten vom IoT-Hub an den Speicher. Der Hub ist so konfiguriert, dass die an den Hub gesendeten Nachrichten automatisch an das Speicherkonto weitergeleitet werden, wenn sie die Routingbedingung erfüllen. Am Ende dieser Schnellstartanleitung können Sie das Speicherkonto öffnen und die gesendeten Nachrichten anzeigen.

Bicep ist eine domänenspezifische Sprache (Domain-Specific Language, DSL), die eine deklarative Syntax zur Bereitstellung von Azure-Ressourcen verwendet. Sie bietet eine präzise Syntax, zuverlässige Typsicherheit und Unterstützung für die Wiederverwendung von Code. Bicep bietet die beste Form der Erstellung für Ihre Infrastructure-as-Code-Lösungen in Azure.

Voraussetzungen

Wenn Sie über kein Azure-Abonnement verfügen, können Sie ein kostenloses Azure-Konto erstellen, bevor Sie beginnen.
Installieren der Azure-Befehlszeilenschnittstelle

Überprüfen der Bicep-Datei

Die in diesem Schnellstart verwendete Bicep-Datei lautet 101-iothub-auto-route-messages und stammt aus den Azure-Schnellstartvorlagen.

In der Bicep-Datei sind zwei Azure-Ressourcen definiert:

Microsoft.Storage/storageAccounts: Ein Speicherkonto mit einem Container.
Microsoft.Devices/IotHubs: Ein IoT-Hub mit einem Endpunkt, der auf den Speichercontainer verweist, und eine Route zum Senden gefilterter Nachrichten an diesen Endpunkt.

@description('Define the project name or prefix for all objects.')
@minLength(1)
@maxLength(11)
param projectName string = 'contoso'

@description('The datacenter to use for the deployment.')
param location string = resourceGroup().location

@description('The SKU to use for the IoT Hub.')
param skuName string = 'S1'

@description('The number of IoT Hub units.')
param skuUnits int = 1

@description('Partitions used for the event stream.')
param d2cPartitions int = 4

var iotHubName = '${projectName}Hub${uniqueString(resourceGroup().id)}'
var storageAccountName = '${toLower(projectName)}${uniqueString(resourceGroup().id)}'
var storageEndpoint = '${projectName}StorageEndpont'
var storageContainerName = '${toLower(projectName)}results'

resource storageAccount 'Microsoft.Storage/storageAccounts@2023-01-01' = {
  name: storageAccountName
  location: location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'Storage'
  properties: {
    allowBlobPublicAccess: false
    minimumTlsVersion: 'TLS1_2'
    supportsHttpsTrafficOnly: true
  }
}

resource container 'Microsoft.Storage/storageAccounts/blobServices/containers@2023-01-01' = {
  name: '${storageAccountName}/default/${storageContainerName}'
  properties: {
    publicAccess: 'None'
  }
  dependsOn: [
    storageAccount
  ]
}

resource IoTHub 'Microsoft.Devices/IotHubs@2023-06-30' = {
  name: iotHubName
  location: location
  sku: {
    name: skuName
    capacity: skuUnits
  }
  properties: {
    eventHubEndpoints: {
      events: {
        retentionTimeInDays: 1
        partitionCount: d2cPartitions
      }
    }
    routing: {
      endpoints: {
        storageContainers: [
          {
            connectionString: 'DefaultEndpointsProtocol=https;AccountName=${storageAccountName};EndpointSuffix=${environment().suffixes.storage};AccountKey=${storageAccount.listKeys().keys[0].value}'
            containerName: storageContainerName
            fileNameFormat: '{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}'
            batchFrequencyInSeconds: 100
            maxChunkSizeInBytes: 104857600
            encoding: 'JSON'
            name: storageEndpoint
          }
        ]
      }
      routes: [
        {
          name: 'ContosoStorageRoute'
          source: 'DeviceMessages'
          condition: 'level="storage"'
          endpointNames: [
            storageEndpoint
          ]
          isEnabled: true
        }
      ]
      fallbackRoute: {
        name: '$fallback'
        source: 'DeviceMessages'
        condition: 'true'
        endpointNames: [
          'events'
        ]
        isEnabled: true
      }
    }
    messagingEndpoints: {
      fileNotifications: {
        lockDurationAsIso8601: 'PT1M'
        ttlAsIso8601: 'PT1H'
        maxDeliveryCount: 10
      }
    }
    enableFileUploadNotifications: false
    cloudToDevice: {
      maxDeliveryCount: 10
      defaultTtlAsIso8601: 'PT1H'
      feedback: {
        lockDurationAsIso8601: 'PT1M'
        ttlAsIso8601: 'PT1H'
        maxDeliveryCount: 10
      }
    }
  }
}

output name string = IoTHub.name
output resourceId string = IoTHub.id
output resourceGroupName string = resourceGroup().name
output location string = location

Bereitstellen der Bicep-Datei

Dieser Abschnitt enthält die Schritte zum Bereitstellen der Bicep-Datei.

Laden Sie die Datei "Standard.bicep" aus dem Azure-Schnellstartvorlagen-Repository herunter.
Erstellen Sie die Ressourcen, indem Sie die Bicep-Datei mit Azure CLI bereitstellen.
```
az group create --name ContosoResourceGrp --location eastus
az deployment group create --resource-group exampleRG --template-file main.bicep
```
Die Bereitstellung kann einige Minuten in Anspruch nehmen. Nach Abschluss der Bereitstellung sollte die Ausgabe mit den bereitgestellten Ressourcen angezeigt werden.

Senden von Gerät-zu-Cloud (D2C)-Nachrichten

In diesem Abschnitt registrieren Sie ein Gerät in Ihrem neuen IoT-Hub und senden dann Nachrichten von diesem Gerät an IoT Hub. Die Route, die die im IoT-Hub konfigurierte Bicep-Datei sendet nur Nachrichten an den Speicher, wenn sie die Nachrichteneigenschaft level=storageenthalten. Um zu testen, dass diese Routingbedingung wie erwartet funktioniert, senden wir einige Nachrichten mit dieser Eigenschaft und einige ohne.

Tipp

Diese Schnellstartanleitung verwendet das simulierte Azure CLI-Gerät zur Vereinfachung. Ein Codebeispiel zum Senden von Geräte-zu-Cloud-Nachrichten mit Nachrichteneigenschaften für das Routing finden Sie unter HubRoutingSample im Azure IoT SDK für .NET.

Rufen Sie den Namen des IoT-Hubs ab, den die Vorlage für Sie erstellt hat.

Wenn Sie die Standardbefehle im vorherigen Abschnitt verwendet haben, wurden Ihre Ressourcen in der Ressourcengruppe "ContosoResourceGrp " erstellt. Wenn Sie eine andere Ressourcengruppe verwendet haben, aktualisieren Sie den folgenden Befehl entsprechend.
```
az iot hub list --resource-group ContosoResourceGrp --output table
```
Kopieren Sie den Namen Ihres IoT-Hubs aus der Ausgabe. Sie sollte wie folgt formatiert werden: contosoHub{randomidentifier}

Fügen Sie dem Hub ein Gerät hinzu.

az iot hub device-identity create --device-id contosoDevice --hub-name {YourIoTHubName}

Simulieren Sie das Gerät, und senden Sie Geräte-an-Cloud-Nachrichten.

Mit --data dem Parameter können wir den Nachrichtentext festlegen.
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --data "This message won't be routed."
```
Der Simulator sendet 100 Nachrichten und trennt dann die Verbindung. Sie müssen nicht auf alle 100 für die Zwecke dieser Schnellstartanleitung warten.

Tipp

Die Azure CLI druckt die Nachrichten nicht, wenn sie gesendet werden. Wenn Sie die Nachrichten beim Eintreffen auf Ihrem Hub ansehen möchten, können Sie die Azure IoT Hub-Erweiterung für Visual Studio Code installieren und ihn verwenden, um den integrierten Endpunkt zu überwachen.
Senden von Geräte-zu-Cloud-Nachrichten, die an den Speicher weitergeleitet werden sollen.

Mit dem --properties Parameter können wir der Standardnachricht Nachrichten-, Anwendungs- oder Systemeigenschaften hinzufügen. Für diese Schnellstartanleitung sucht die Route in Ihrem IoT-Hub nach Nachrichten, die die Nachrichteneigenschaft level=storageenthalten.
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --properties level=storage \
  --data "This message will be routed to storage."
```

Überprüfen von weitergeleiteten Nachrichten

Melden Sie sich beim Azure-Portal an, und wählen Sie die Ressourcengruppe aus, und wählen Sie dann das Speicherkonto aus.
Führen Sie einen Drilldown für das Speicherkonto aus, bis Sie zu Dateien gelangen.
Wählen Sie eine der Dateien und anschließend Herunterladen aus, um die Datei an einen Speicherort herunterzuladen, den Sie später leicht finden. Er hat einen numerischen Namen, z. B. 47. Fügen Sie am Ende .txt hinzu, und doppelklicken Sie auf die Datei, um sie zu öffnen.
Wenn Sie die Datei öffnen, steht jede Zeile für eine andere Nachricht. Der Textkörper jeder Nachricht wird zudem verschlüsselt. Das muss so sein, damit Sie Abfragen für den Nachrichtentext durchführen können.

Hinweis

Diese Nachrichten werden in UTF-8 und Base64 codiert. Wenn Sie die Nachricht wieder lesen, müssen Sie sie von base64 und utf-8 decodieren, um sie als ASCII zu lesen. Bei Interesse können Sie die Methode „ReadOneRowFromFile“ aus dem Routingtutorial verwenden, um eine einzelne Zeile aus einer dieser Nachrichtendateien zu lesen und in ASCII zu decodieren. „ReadOneRowFromFile“ befindet sich in dem IoT C#-SDK-Repository, das Sie für diesen Schnellstart entzippt haben. Hier ist der Pfad vom Anfang dieses Ordners: ./iothub/device/samples/how to guides/HubRoutingSample/Program.cs Legen Sie den booleschen readTheFile Wert auf "true" fest, und hartcodieren Sie den Pfad zur Datei auf dem Datenträger, und sie öffnet und übersetzt die erste Zeile in der Datei.

In dieser Schnellstartanleitung haben Sie eine Bicep-Datei zum Erstellen eines IoT-Hubs und eines Speicherkontos bereitgestellt und dann ein Programm zum Senden von Nachrichten an den Hub ausgeführt. Die Nachrichten werden basierend auf ihren Nachrichteneigenschaften weitergeleitet und im Speicherkonto gespeichert, in dem sie angezeigt werden können.

Bereinigen von Ressourcen

Wenn Sie die von Ihnen erstellten Ressourcen nicht mehr benötigen, löschen Sie die Ressourcengruppe.

az group delete --name exampleRG

Nächste Schritte

Schnellstart: Erstellen von Bicep-Dateien mit Visual Studio Code

Share via