Avvio rapido: Distribuire un hub IoT di Azure e un account di archiviazione con Bicep

Articolo
01/05/2024

In questa guida introduttiva si usa Bicep per creare un hub IoT, un account Archiviazione di Azure e una route per inviare messaggi dall'hub IoT all'archiviazione. L'hub è configurato in modo che i messaggi inviati all'hub vengano indirizzati automaticamente all'account di archiviazione se soddisfano la condizione di routing. Al termine di questo argomento di avvio rapido, è possibile aprire l'account di archiviazione e visualizzare i messaggi inviati.

Bicep è un linguaggio specifico di dominio (DSL) che usa la sintassi dichiarativa per distribuire le risorse di Azure. Offre sintassi concisa, indipendenza dai tipi affidabile e supporto per il riutilizzo del codice. Bicep offre la migliore esperienza di creazione per le soluzioni di infrastruttura come codice in Azure.

Prerequisiti

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.
Installazione dell'interfaccia della riga di comando di Azure

Esaminare il file Bicep

Il file Bicep usato in questa guida introduttiva viene chiamato 101-iothub-auto-route-messages da Modelli di avvio rapido di Azure.

Nel file Bicep sono definite due risorse di Azure:

Microsoft.Storage/storageAccounts: un account di archiviazione con un contenitore.
Microsoft.Devices/IotHubs: un hub IoT con un endpoint che punta al contenitore di archiviazione e una route per inviare messaggi filtrati a tale endpoint.

@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

Distribuire il file Bicep

Questa sezione illustra i passaggi per distribuire il file Bicep.

Scaricare il file main.bicep dal repository Modelli di avvio rapido di Azure.
Creare le risorse distribuendo il file Bicep usando l'interfaccia della riga di comando di Azure.
```
az group create --name ContosoResourceGrp --location eastus
az deployment group create --resource-group exampleRG --template-file main.bicep
```
La distribuzione richiede alcuni minuti. Al termine della distribuzione, verrà visualizzato l'output che descrive in dettaglio le risorse distribuite.

Inviare messaggi da dispositivo a cloud

In questa sezione si registra un dispositivo nel nuovo hub IoT e quindi si inviano messaggi da tale dispositivo a hub IoT. La route configurata dal file Bicep nell'hub IoT invia messaggi all'archiviazione solo se contengono la proprietà level=storagedel messaggio . Per verificare che questa condizione di routing funzioni come previsto, verranno inviati alcuni messaggi con tale proprietà e alcuni senza.

Suggerimento

Questa guida introduttiva usa il dispositivo simulato dell'interfaccia della riga di comando di Azure per praticità. Per un esempio di codice per l'invio di messaggi da dispositivo a cloud con proprietà dei messaggi per il routing, vedere HubRoutingSample in Azure IoT SDK per .NET.

Recuperare il nome dell'hub IoT creato automaticamente dal modello.

Se sono stati usati i comandi predefiniti nella sezione precedente, le risorse sono state create nel gruppo di risorse ContosoResourceGrp . Se è stato usato un gruppo di risorse diverso, aggiornare il comando seguente in modo che corrisponda.
```
az iot hub list --resource-group ContosoResourceGrp --output table
```
Copiare il nome dell'hub IoT dall'output. Deve essere formattato come contosoHub{randomidentifier}

Aggiungere un dispositivo all'hub.

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

Simulare il dispositivo e inviare messaggi da dispositivo a cloud.

Il --data parametro consente di impostare il corpo del messaggio.
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --data "This message won't be routed."
```
Il simulatore invia 100 messaggi e quindi si disconnette. Non è necessario attendere tutti i 100 ai fini di questa guida introduttiva.

Suggerimento

L'interfaccia della riga di comando di Azure non stampa i messaggi quando li invia. Se si vogliono controllare i messaggi quando arrivano all'hub, è possibile installare l'estensione hub IoT di Azure per Visual Studio Code e usarla per monitorare l'endpoint predefinito.
Inviare messaggi da dispositivo a cloud da instradare all'archiviazione.

Il --properties parametro consente di aggiungere proprietà di messaggio, applicazione o sistema al messaggio predefinito. Per questa guida introduttiva, la route nell'hub IoT cerca i messaggi che contengono la proprietà level=storagedel messaggio .
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --properties level=storage \
  --data "This message will be routed to storage."
```

Esaminare i messaggi indirizzati

Accedere al portale di Azure e selezionare il gruppo di risorse, quindi selezionare l'account di archiviazione.
Eseguire il drill-down nell'account di archiviazione fino a trovare i file.
Selezionare uno dei file, scegliere Scarica e scaricare il file in un percorso accessibile in un secondo momento. Ha un nome numerico, ad esempio 47. Aggiungere . txt alla fine del nome e quindi fare doppio clic sul file per aprirlo.
Quando si apre il file, ogni riga è per un messaggio diverso. Anche il corpo di ogni messaggio viene crittografato. Questa operazione è necessaria per consentire l'esecuzione di query sul corpo del messaggio.

Nota

Questi messaggi sono codificati in UTF-8 e base64. Se si legge nuovamente il messaggio, è necessario decodificarlo da base64 e utf-8 per leggerlo come ASCII. Se si è interessati, è possibile usare il metodo ReadOneRowFromFile descritto nell'esercitazione sul routing per leggere uno alla volta questi file di messaggio e decodificarli in formato ASCII. ReadOneRowFromFile si trova nel repository IoT C# SDK decompresso per questa guida introduttiva. Di seguito è riportato il percorso dall'inizio della cartella: ./iothub/device/samples/how to guides/HubRoutingSample/Program.cs Impostare il valore booleano readTheFile su true e impostare come hardcoded il percorso del file su disco e verrà aperta e convertita la prima riga nel file.

In questa guida introduttiva è stato distribuito un file Bicep per creare un hub IoT e un account di archiviazione, quindi eseguire un programma per inviare messaggi all'hub. I messaggi vengono instradati in base alle proprietà del messaggio e archiviati nell'account di archiviazione in cui possono essere visualizzati.

Pulire le risorse

Quando le risorse create non sono più necessarie, eliminare il gruppo di risorse.

az group delete --name exampleRG

Passaggi successivi

Guida introduttiva: Creare file Bicep con Visual Studio Code

Condividi tramite