Quickstart: Een Azure IoT-hub en een opslagaccount implementeren met Bicep

Artikel
01/05/2024

In deze quickstart gebruikt u Bicep om een IoT-hub, een Azure Storage-account en een route te maken om berichten van de IoT-hub naar de opslag te verzenden. De hub is zo geconfigureerd dat de berichten die naar de hub worden verzonden, automatisch worden doorgestuurd naar het opslagaccount als ze voldoen aan de routeringsvoorwaarde. Aan het einde van deze quickstart kunt u het opslagaccount openen en de verzonden berichten bekijken.

Bicep is een domeinspecifieke taal (DSL) die declaratieve syntaxis gebruikt om Azure-resources te implementeren. Deze taal voorziet in een beknopte syntaxis, betrouwbare typeveiligheid en ondersteuning voor hergebruik van code. Bicep biedt de beste ontwerpervaring voor uw infrastructuur als code-oplossingen in Azure.

Vereisten

Als u nog geen abonnement op Azure hebt, maakt u een gratis Azure-account voordat u begint.
Azure-CLI installeren

Het Bicep-bestand controleren

Het Bicep-bestand dat in deze quickstart wordt gebruikt, wordt aangeroepen 101-iothub-auto-route-messages vanuit Azure Quickstart-sjablonen.

Er worden twee Azure-resources gedefinieerd in het Bicep-bestand:

Microsoft.Storage/storageAccounts: een opslagaccount met een container.
Microsoft.Devices/IotHubs: een IoT-hub met een eindpunt dat verwijst naar de opslagcontainer en een route om gefilterde berichten naar dat eindpunt te verzenden.

@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

Het Bicep-bestand implementeren

Deze sectie bevat de stappen voor het implementeren van het Bicep-bestand.

Download het bestand main.bicep uit de Azure Quickstart Templates-opslagplaats.
Maak de resources door het Bicep-bestand te implementeren met behulp van Azure CLI.
```
az group create --name ContosoResourceGrp --location eastus
az deployment group create --resource-group exampleRG --template-file main.bicep
```
Het duurt enkele minuten om de implementatie te voltooien. Wanneer de implementatie is voltooid, ziet u uitvoer met informatie over de geïmplementeerde resources.

Apparaat-naar-cloud-berichten verzenden

In deze sectie registreert u een apparaat in uw nieuwe IoT-hub en verzendt u vervolgens berichten van dat apparaat naar IoT Hub. De route die het Bicep-bestand dat is geconfigureerd in de IoT-hub verzendt alleen berichten naar de opslag als deze de berichteigenschap level=storagebevatten. Om te testen of deze routeringsvoorwaarde werkt zoals verwacht, verzenden we enkele berichten met die eigenschap en sommige zonder.

Tip

In deze quickstart wordt het gesimuleerde Azure CLI-apparaat gebruikt voor het gemak. Zie HubRoutingSample in de Azure IoT SDK voor .NET voor een codevoorbeeld voor het verzenden van apparaat-naar-cloud-berichten met berichteigenschappen voor routering.

Haal de naam op van de IoT-hub die door de sjabloon voor u is gemaakt.

Als u de standaardopdrachten in de vorige sectie hebt gebruikt, zijn uw resources gemaakt in de resourcegroep ContosoResourceGrp . Als u een andere resourcegroep hebt gebruikt, werkt u de volgende opdracht bij zodat deze overeenkomt.
```
az iot hub list --resource-group ContosoResourceGrp --output table
```
Kopieer de naam van uw IoT-hub uit de uitvoer. Deze moet worden opgemaakt als contosoHub{randomidentifier}

Voeg een apparaat toe aan de hub.

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

Simuleer het apparaat en verzend apparaat-naar-cloud-berichten.

Met --data de parameter kunnen we de berichttekst instellen.
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --data "This message won't be routed."
```
De simulator verzendt 100 berichten en verbreekt vervolgens de verbinding. U hoeft niet te wachten op alle 100 voor deze quickstart.

Tip

De Azure CLI drukt de berichten niet af terwijl ze worden verzonden. Als u de berichten wilt bekijken wanneer u bij uw hub aankomt, kunt u de Azure IoT Hub-extensie voor Visual Studio Code installeren en deze gebruiken om het ingebouwde eindpunt te bewaken.
Verzend apparaat-naar-cloud-berichten om naar de opslag te worden gerouteerd.

Met --properties de parameter kunnen we bericht-, toepassings- of systeemeigenschappen toevoegen aan het standaardbericht. Voor deze quickstart is de route in uw IoT-hub op zoek naar berichten die de berichteigenschap level=storagebevatten.
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --properties level=storage \
  --data "This message will be routed to storage."
```

Gerouteerde berichten controleren

Meld u aan bij Azure Portal en selecteer de resourcegroep en selecteer vervolgens het opslagaccount.
Zoom in op het opslagaccount totdat u bestanden vindt.
Selecteer een van de bestanden en selecteer Downloaden. Download het bestand naar een locatie die u later kunt vinden. Het heeft een naam die numeriek is, zoals 47. Voeg .txt toe aan het einde en dubbelklik op het bestand om het te openen.
Wanneer u het bestand opent, is elke rij voor een ander bericht. De hoofdtekst van elk bericht wordt ook versleuteld. Dit is nodig om query's uit te voeren op basis van de hoofdtekst van het bericht.

Notitie

Deze berichten worden gecodeerd in UTF-8 en base64. Als u het bericht terug leest, moet u het decoderen van base64 en utf-8 om het als ASCII te kunnen lezen. Als u geïnteresseerd bent, kunt u de methode ReadOneRowFromFile in de zelfstudie voor routering gebruiken om een van deze berichtbestanden te lezen en te decoderen naar ASCII. ReadOneRowFromFile bevindt zich in de IoT C#SDK-opslagplaats die u voor deze quickstart hebt uitgepakt. Hier volgt het pad boven aan die map: ./iothub/device/samples/how to guides/HubRoutingSample/Program.cs Stel de booleaanse readTheFile waarde in op true, en hardcodeer het pad naar het bestand op schijf, waarna de eerste rij in het bestand wordt geopend en vertaald.

In deze quickstart hebt u een Bicep-bestand geïmplementeerd om een IoT-hub en een opslagaccount te maken en vervolgens een programma uit te voeren om berichten naar de hub te verzenden. De berichten worden gerouteerd op basis van hun berichteigenschappen en opgeslagen in het opslagaccount waar ze kunnen worden bekeken.

Resources opschonen

Wanneer u de resources die u hebt gemaakt niet meer nodig hebt, verwijdert u de resourcegroep.

az group delete --name exampleRG

Volgende stappen

Quickstart: Bicep-bestanden maken met Visual Studio Code

Delen via