Guia de início rápido: implantar um hub IoT do Azure e uma conta de armazenamento usando um modelo ARM

Artigo
01/05/2024

Neste início rápido, você usa um modelo do Azure Resource Manager (modelo ARM) para criar um hub IoT, uma conta de Armazenamento do Azure e uma rota para enviar mensagens do hub IoT para o armazenamento. O hub é configurado para que as mensagens enviadas para o hub sejam automaticamente roteadas para a conta de armazenamento se atenderem à condição de roteamento. No final deste início rápido, você pode abrir a conta de armazenamento e ver as mensagens enviadas.

Um modelo do Azure Resource Manager é um arquivo JSON (JavaScript Object Notation) que define a infraestrutura e a configuração do seu projeto. O modelo utiliza sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.

Se o seu ambiente cumpre os pré-requisitos e se está familiarizado com a utilização de modelos ARM, selecione o botão Implementar no Azure. O modelo é aberto no portal do Azure.

Pré-requisitos

Se não tiver uma subscrição do Azure, crie uma conta do Azure gratuita antes de começar.

Rever o modelo

O modelo usado neste início rápido é chamado 101-iothub-auto-route-messages de Modelos de Início Rápido do Azure.

Dois recursos do Azure são definidos no modelo:

Microsoft.Storage/storageAccounts: Uma conta de armazenamento com um contêiner.
Microsoft.Devices/IotHubs: um hub IoT com um ponto de extremidade que aponta para o contêiner de armazenamento e uma rota para enviar mensagens filtradas para esse ponto de extremidade.

{
  "$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')]"
    }
  }
}

Implementar o modelo

Esta seção fornece as etapas para implantar o modelo ARM.

Crie os recursos implantando o modelo ARM.

Enviar mensagens do dispositivo para a nuvem

Nesta seção, você registra um dispositivo em seu novo hub IoT e, em seguida, envia mensagens desse dispositivo para o Hub IoT. A rota que o modelo configurado no hub IoT só envia mensagens para o armazenamento se elas contiverem a propriedade level=storagemessage . Para testar se essa condição de roteamento funciona conforme o esperado, enviaremos algumas mensagens com essa propriedade e outras sem.

Gorjeta

Este guia de início rápido usa o dispositivo simulado da CLI do Azure para conveniência. Para obter um exemplo de código de envio de mensagens de dispositivo para nuvem com propriedades de mensagem para roteamento, consulte HubRoutingSample no SDK do Azure IoT para .NET.

Recupere o nome do hub IoT que o modelo criou para você.

Se você usou os comandos padrão na seção anterior, seus recursos foram criados no grupo de recursos ContosoResourceGrp . Se você usou um grupo de recursos diferente, atualize o comando a seguir para corresponder.
```
az iot hub list --resource-group ContosoResourceGrp --output table
```
Copie o nome do seu hub IoT da saída. Deve ser formatado como contosoHub{randomidentifier}

Adicione um dispositivo ao hub.

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

Simule o dispositivo e envie mensagens do dispositivo para a nuvem.

O --data parâmetro nos permite definir o corpo da mensagem.
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --data "This message won't be routed."
```
O simulador envia 100 mensagens e, em seguida, desconecta. Você não precisa esperar por todos os 100 para os fins deste início rápido.

Gorjeta

A CLI do Azure não imprimirá as mensagens à medida que as envia. Se quiser observar as mensagens à medida que chegam ao seu hub, você pode instalar a extensão do Hub IoT do Azure para Visual Studio Code e usá-la para monitorar o ponto de extremidade interno.
Envie mensagens do dispositivo para a nuvem para serem encaminhadas para o armazenamento.

O --properties parâmetro nos permite adicionar propriedades de mensagem, aplicativo ou sistema à mensagem padrão. Para este início rápido, a rota em seu hub IoT está procurando mensagens que contenham a propriedade level=storagemessage .
```
az iot device simulate \
  --device-id contosoDevice \
  --hub-name {YourIoTHubName} \
  --properties level=storage \
  --data "This message will be routed to storage."
```

Rever os recursos implementados

Entre no portal do Azure e selecione o Grupo de Recursos e, em seguida, selecione a conta de armazenamento.
Analise detalhadamente a conta de armazenamento até encontrar os arquivos.
Selecione um dos arquivos e selecione Baixar e baixar o arquivo para um local que você pode encontrar mais tarde. Tem um nome numérico, como 47. Adicione .txt ao final e, em seguida, clique duas vezes no arquivo para abri-lo.
Quando você abre o arquivo, cada linha é para uma mensagem diferente; O corpo de cada mensagem também é criptografado. Ele deve ser para que você execute consultas no corpo da mensagem.

Nota

Essas mensagens são codificadas em UTF-32 e base64. Se você ler a mensagem de volta, você tem que decodificá-lo a partir de base64 e utf-32, a fim de lê-lo como ASCII. Se você estiver interessado, você pode usar o método ReadOneRowFromFile no Tutorial de Roteamento para ler um para de um desses arquivos de mensagem e decodificá-lo em ASCII. ReadOneRowFromFile está no repositório IoT C# SDK que você descompactou para este início rápido. Aqui está o caminho da parte superior dessa pasta: ./iothub/device/samples/getting started/RoutingTutorial/SimulatedDevice/Program.cs. Defina o booleano readTheFile como true e codifice o caminho para o arquivo no disco e ele abrirá e traduzirá a primeira linha do arquivo.

Neste início rápido, você implantou um modelo ARM para criar um hub IoT e uma conta de armazenamento e, em seguida, executar um programa para enviar mensagens para o hub. As mensagens são roteadas com base em suas propriedades de mensagem e armazenadas na conta de armazenamento onde podem ser visualizadas.

Clean up resources (Limpar recursos)

Para remover os recursos adicionados durante este início rápido, entre no portal do Azure. Selecione Grupos de Recursos e, em seguida, localize o grupo de recursos que utilizou para este início rápido. Selecione o grupo de recursos e, em seguida, selecione Excluir. Quando o grupo é excluído, todos os recursos do grupo também são.

Próximos passos

Tutorial: Criar e implantar seu primeiro modelo ARM

Share via