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

Artikel
06/16/2024

In dieser Schnellstartanleitung verwenden Sie Bicep, um einen IoT-Hub, ein Azure Storage-Speicherkonto und eine Route zu erstellen, um Nachrichten vom IoT-Hub an den Speicher zu senden. Der Hub ist so konfiguriert, dass die an den Hub gesendeten Nachrichten automatisch an das Speicherkonto weitergeleitet werden, sofern sie die Weiterleitungsbedingung 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

In diesem Abschnitt werden die Schritte zum Bereitstellen der Bicep-Datei beschrieben.

Laden Sie die main.bicep-Datei aus dem Repository Azure-Schnellstartvorlagen herunter.
Erstellen Sie die Ressourcen, indem Sie die Bicep-Datei mithilfe der 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 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 den IoT-Hub. Die Route, die die Bicep-Datei im IoT-Hub konfiguriert hat, sendet nur Nachrichten an den Speicher, wenn sie die Nachrichteneigenschaft level=storage enthalten. Um zu testen, dass diese Weiterleitungsbedingung wie erwartet funktioniert, senden wir einige Nachrichten mit dieser Eigenschaft und einige ohne diese Eigenschaft.

Tipp

Der Einfachheit halber wird in dieser Schnellstartanleitung das simulierte Azure CLI-Gerät verwendet. Ein Codebeispiel zum Senden von Gerät-zu-Cloud-Nachrichten mit Nachrichteneigenschaften für die Weiterleitung 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, ändern Sie den folgenden Befehl entsprechend.
```
az iot hub list --resource-group ContosoResourceGrp --output table
```
Kopieren Sie den Namen Ihres IoT-Hubs aus der Ausgabe. Er sollte folgendermaßen formatiert sein: 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ät-zu-Cloud-Nachrichten.

Mit dem Parameter --data kann der Nachrichtentext festgelegt werden.
```
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. Bei dieser Schnellstartanleitung müssen Sie nicht auf alle 100 warten.

Tipp

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

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

Überprüfung weitergeleiteter Nachrichten

Melden Sie sich beim Azure-Portal an und wählen Sie die Ressourcengruppe und 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. Sie hat einen numerischen Namen, wie „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 sind in UTF-8 und Base64 codiert. Wenn Sie die Nachricht auslesen, müssen Sie sie aus Base64 und UTF-8 decodieren, um sie im ASCII-Format lesen zu können. 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 Wert readTheFile auf „true“ (wahr) fest, und codieren Sie den Pfad zur Datei auf dem Datenträger hart. Dadurch wird die erste Zeile in der Datei geöffnet und übersetzt.

In dieser Schnellstartanleitung haben Sie eine Bicep-Datei bereitgestellt, um einen IoT-Hub und ein Speicherkonto zu erstellen. Dann haben Sie ein Programm ausgeführt, um Nachrichten an den Hub zu senden. 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

Freigeben über