Início Rápido: Implantar um Internet das Coisas do Azure e uma conta de armazenamento usando o Bicep

Artigo
06/14/2024

Neste início rápido, você usará o Bicep para criar um hub IoT, uma conta de Armazenamento do Microsoft Azure e uma rota para enviar mensagens 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.

O Bicep é um DSL (linguagem específica de domínio) que usa sintaxe declarativa para implantar recursos do Azure. Ele fornece sintaxe concisa, segurança de tipos confiável e suporte para reutilização de código. O Bicep oferece a melhor experiência de criação para suas soluções de infraestrutura como código no Azure.

Pré-requisitos

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

Examinar o arquivo Bicep

O arquivo Bicep usado neste guia de início rápido é chamado de 101-iothub-auto-route-messages dos Modelos de início rápido do Azure.

Há dois recursos do Azure definidos no arquivo Bicep:

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.

@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

Implante o arquivo Bicep

Esta seção fornece as etapas para implantar o arquivo Bicep.

Baixe o arquivo main.bicep do repositório de Modelos do Início Rápido do Azure.
Crie os recursos implantando o arquivo Bicep usando a CLI do Azure.
```
az group create --name ContosoResourceGrp --location eastus
az deployment group create --resource-group exampleRG --template-file main.bicep
```
A implantação leva vários minutos para ser concluída. Quando a implantação for concluída, você deverá ver uma saída detalhando os recursos implantados.

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 arquivo Bicep configurou no hub IoT só envia mensagens para o armazenamento se elas contiverem a propriedade de mensagem level=storage. 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 mensagens roteadas

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 é para 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-8 e base64. Se você ler a mensagem de volta, precisará decodificá-la de base64 e utf-8 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/how to guides/HubRoutingSample/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 arquivo Bicep para criar um hub IoT e uma conta de armazenamento e, em seguida, executou 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

Quando não precisar mais dos recursos que criou, exclua o grupo de recursos.

az group delete --name exampleRG

Próximas etapas

Início Rápido: criar arquivos Bicep com o Visual Studio Code

Compartilhar via