Avvio rapido: Distribuire un hub IoT di Azure e un account di archiviazione usando un modello di Resource Manager

Articolo
01/05/2024

In questa guida introduttiva si usa un modello di Azure Resource Manager 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.

Un modello di Azure Resource Manager è un file JSON (JavaScript Object Notation) che definisce l'infrastruttura e la configurazione del progetto. Il modello utilizza la sintassi dichiarativa. Si descrive la distribuzione prevista senza scrivere la sequenza di comandi di programmazione necessari per creare la distribuzione.

Se l'ambiente soddisfa i prerequisiti e si ha familiarità con l'uso dei modelli di Resource Manager, selezionare il pulsante Distribuisci in Azure. Il modello viene visualizzato nel portale di Azure.

Prerequisiti

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Rivedere il modello

Il modello usato in questo argomento di avvio rapido è denominato 101-iothub-auto-route-messages ed è incluso nei modelli di avvio rapido di Azure.

Nel modello 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.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.26.54.24096",
      "templateHash": "1111741482289134864"
    }
  },
  "parameters": {
    "projectName": {
      "type": "string",
      "defaultValue": "contoso",
      "minLength": 1,
      "maxLength": 11,
      "metadata": {
        "description": "Define the project name or prefix for all objects."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The datacenter to use for the deployment."
      }
    },
    "skuName": {
      "type": "string",
      "defaultValue": "S1",
      "metadata": {
        "description": "The SKU to use for the IoT Hub."
      }
    },
    "skuUnits": {
      "type": "int",
      "defaultValue": 1,
      "metadata": {
        "description": "The number of IoT Hub units."
      }
    },
    "d2cPartitions": {
      "type": "int",
      "defaultValue": 4,
      "metadata": {
        "description": "Partitions used for the event stream."
      }
    }
  },
  "variables": {
    "iotHubName": "[format('{0}Hub{1}', parameters('projectName'), uniqueString(resourceGroup().id))]",
    "storageAccountName": "[format('{0}{1}', toLower(parameters('projectName')), uniqueString(resourceGroup().id))]",
    "storageEndpoint": "[format('{0}StorageEndpont', parameters('projectName'))]",
    "storageContainerName": "[format('{0}results', toLower(parameters('projectName')))]"
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2023-01-01",
      "name": "[variables('storageAccountName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "Storage",
      "properties": {
        "allowBlobPublicAccess": false,
        "minimumTlsVersion": "TLS1_2",
        "supportsHttpsTrafficOnly": true
      }
    },
    {
      "type": "Microsoft.Storage/storageAccounts/blobServices/containers",
      "apiVersion": "2023-01-01",
      "name": "[format('{0}/default/{1}', variables('storageAccountName'), variables('storageContainerName'))]",
      "properties": {
        "publicAccess": "None"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
      ]
    },
    {
      "type": "Microsoft.Devices/IotHubs",
      "apiVersion": "2023-06-30",
      "name": "[variables('iotHubName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "[parameters('skuName')]",
        "capacity": "[parameters('skuUnits')]"
      },
      "properties": {
        "eventHubEndpoints": {
          "events": {
            "retentionTimeInDays": 1,
            "partitionCount": "[parameters('d2cPartitions')]"
          }
        },
        "routing": {
          "endpoints": {
            "storageContainers": [
              {
                "connectionString": "[format('DefaultEndpointsProtocol=https;AccountName={0};EndpointSuffix={1};AccountKey={2}', variables('storageAccountName'), environment().suffixes.storage, listKeys(resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName')), '2023-01-01').keys[0].value)]",
                "containerName": "[variables('storageContainerName')]",
                "fileNameFormat": "{iothub}/{partition}/{YYYY}/{MM}/{DD}/{HH}/{mm}",
                "batchFrequencyInSeconds": 100,
                "maxChunkSizeInBytes": 104857600,
                "encoding": "JSON",
                "name": "[variables('storageEndpoint')]"
              }
            ]
          },
          "routes": [
            {
              "name": "ContosoStorageRoute",
              "source": "DeviceMessages",
              "condition": "level=\"storage\"",
              "endpointNames": [
                "[variables('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
          }
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.Storage/storageAccounts', variables('storageAccountName'))]"
      ]
    }
  ],
  "outputs": {
    "name": {
      "type": "string",
      "value": "[variables('iotHubName')]"
    },
    "resourceId": {
      "type": "string",
      "value": "[resourceId('Microsoft.Devices/IotHubs', variables('iotHubName'))]"
    },
    "resourceGroupName": {
      "type": "string",
      "value": "[resourceGroup().name]"
    },
    "location": {
      "type": "string",
      "value": "[parameters('location')]"
    }
  }
}

Distribuire il modello

Questa sezione illustra i passaggi per distribuire il modello di Resource Manager.

Creare le risorse distribuendo il modello di Resource Manager.

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 modello nell'hub IoT invia messaggi alla risorsa di 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 le risorse distribuite

Accedere al portale di Azure e selezionare il gruppo di risorse e 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 è riferita a un messaggio diverso. Viene crittografato anche il corpo dei singoli messaggi. Questa operazione è necessaria per consentire l'esecuzione di query sul corpo del messaggio.

Nota

Questi messaggi vengono codificati in formato UTF-32 e Base64. Se si legge di nuovo il messaggio, è necessario decodificarlo dal formato Base64 e UTF-32 per leggerlo in formato 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. Ecco il percorso dalla parte superiore della cartella: ./iothub/device/samples/getting started/RoutingTutorial/SimulatedDevice/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 modello di Resource Manager 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

Per rimuovere le risorse aggiunte durante questa guida introduttiva, accedere al portale di Azure. Selezionare Gruppi di risorse e quindi trovare il gruppo di risorse usato per questo argomento di avvio rapido. Selezionare il gruppo di risorse e quindi Elimina. Quando il gruppo viene eliminato, quindi tutte le risorse nel gruppo.

Passaggi successivi

Creare e distribuire il primo modello di Resource Manager

Condividi tramite