Início Rápido: Implantar um hub IoT do Azure e uma conta de armazenamento usando um modelo do ARM

Artigo
03/06/2024

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

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

Se seu ambiente atender aos pré-requisitos e você estiver familiarizado com o uso de modelos ARM, selecione o botão Implantar no Azure. O modelo é aberto no portal do Azure.

Pré-requisitos

Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar.

Examinar o modelo

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

Há dois recursos do Azure 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')]"
    }
  }
}

Implantar o modelo

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

Crie os recursos implantando o modelo do ARM.

Enviar mensagens do dispositivo para a nuvem

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

Dica

Este início rápido usa o dispositivo simulado da CLI do Azure para facilitar. 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 da Internet das Coisas do Azure para .NET.

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

Se você usou os comandos padrões 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 hub IoT da saída. Ele 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 nuvem.

O parâmetro --data 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 se desconecta. Para os fins deste início rápido não é necessário esperar por todas as 100 mensagens.

Dica

A CLI do Azure não imprimirá as mensagens conforme as envia. Se desejar observar as mensagens ao chegar no hub, é possível instalar a extensão do Hub IoT do Azure para o Visual Studio Code e usá-la para monitorar o ponto de extremidade interno.
Enviar mensagens do dispositivo para a nuvem para serem roteadas para o armazenamento.

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

Examinar os recursos implantados

Entre no portal do Azure e selecione o Grupo de Recursos e, em seguida, selecione a conta de armazenamento.
Faça uma busca detalhada na conta de armazenamento até encontrar arquivos.
Selecione um dos arquivos e selecione Baixar e baixe o arquivo para uma localização que você possa encontrar posteriormente. Ela tem um nome numérico, como 47. Adicione .txt ao final e clique duas vezes no arquivo para abri-lo.
Quando você abre o arquivo, cada linha se destina a uma mensagem diferente; o corpo de cada mensagem também é criptografado. Ele deve estar em ordem que você possa executar consultas no corpo da mensagem.

Observação

Essas mensagens são codificadas em UTF-32 e base64. Se você ler a mensagem de volta, precisará decodificá-la de base64 e UTF-32 para lê-la como ASCII. Se você tiver interesse, poderá usar o método ReadOneRowFromFile no Tutorial de Roteamento para ler um para um desses arquivos de mensagem e decodificá-lo em ASCII. ReadOneRowFromFile está no repositório do SDK de IoT para C# que você descompactou para este guia de início rápido. Este é o caminho partindo do início da pasta: ./iothub/device/samples/getting started/RoutingTutorial/SimulatedDevice/Program.cs. Defina o booliano readTheFile como verdadeiro e codifique o caminho no arquivo em disco e ele será aberto e converterá a primeira linha no arquivo.

Neste início rápido você implantou um modelo do 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 em que podem ser exibidas.

Limpar os recursos

Para remover os recursos adicionados durante este guia de início rápido, entre no portal do Azure. Selecione Grupos de Recursos e localize o grupo de recursos usado para este guia de início rápido. Selecione o grupo de recursos e escolha Excluir. Quando o grupo é excluído, todos os recursos dele também são excluídos.

Próximas etapas

Tutorial: Criar e implantar seu primeiro modelo do Resource Manager

Compartilhar via