Tutorial: Automatizar o Serviço de Provisionamento de Dispositivo do Azure com ações do GitHub

Use ferramentas de automação como o GitHub Actions para gerenciar o ciclo de vida do seu dispositivo IoT. Este tutorial demonstra um fluxo de trabalho de Ações do GitHub que conecta um dispositivo a um hub IoT usando o DPS (Serviço de Provisionamento de Dispositivos) do Azure.

Neste tutorial, aprenderás como:

Salve as credenciais de autenticação como segredos do repositório.
Crie um fluxo de trabalho para provisionar recursos do Hub IoT e do Serviço de Provisionamento de Dispositivos.
Execute o fluxo de trabalho e monitore um dispositivo simulado à medida que ele se conecta ao Hub IoT.

Pré-requisitos

Uma assinatura do Azure

Se não tiver uma subscrição do Azure, crie uma conta gratuita antes de começar.
A Azure CLI
- Utilize o ambiente Bash no Azure Cloud Shell.
- Ou, se preferires executar comandos de referência de CLI localmente, instala a CLI do Azure. Se você estiver executando no Windows ou macOS, considere executar a CLI do Azure em um contêiner do Docker.
  - Se você estiver usando uma instalação local, entre na CLI do Azure usando o comando az login .
  - Execute az version para descobrir a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.
Uma conta do GitHub com um repositório que você possui ou um repositório onde você tem acesso de administrador. Para obter mais informações, consulte Introdução ao GitHub.

1 - Criar segredos do repositório

O fluxo de trabalho que defines na secção seguinte requer acesso à tua subscrição do Azure para criar e gerir recursos. Não quer colocar essa informação num ficheiro não protegido onde possa ser descoberta, por isso usamos segredos do repositório para armazenar essa informação, mas ainda assim torná-la acessível como variável de ambiente no fluxo de trabalho. Para mais informações, veja Usar segredos nas Ações do GitHub.

Somente proprietários e administradores de repositórios podem gerenciar segredos de repositório.

Criar um "service principal"

Em vez de fornecer as suas credenciais de acesso pessoais, criamos um principal de serviço e depois adicionamos essas credenciais como segredos do repositório. Utilize o Azure CLI para criar um novo principal de serviço. Para mais informações, consulte Criar uma entidade de serviço do Azure com o Azure CLI.

Use o comando az ad sp create-for-rbac para criar um principal de serviço com acesso de colaborador a um grupo de recursos específico. Substitua <SUBSCRIPTION_ID> e <RESOURCE_GROUP_NAME> com as suas próprias informações.

Este comando requer funções de proprietário ou administrador de acesso de usuário na assinatura.
```
az ad sp create-for-rbac --name github-actions-sp --role contributor --scopes /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP_NAME>
```
Copie os seguintes itens da saída do comando de criação do principal de serviço para usar na próxima seção:
- O clientId.
- O clientSecret. Este valor é uma palavra-passe gerada para o principal do serviço à qual não consegues aceder novamente.
- O tenantId.

Use o comando az role assignment create para atribuir mais duas funções de acesso ao principal de serviço: Device Provisioning Service Data Contributor e IoT Hub Data Contributor. Substitua <SP_CLIENT_ID> pelo valor clientId copiado da saída do comando anterior.

az role assignment create --assignee "<SP_CLIENT_ID>" --role "Device Provisioning Service Data Contributor" --resource-group "<RESOURCE_GROUP_NAME>"

az role assignment create --assignee "<SP_CLIENT_ID>" --role "IoT Hub Data Contributor" --resource-group "<RESOURCE_GROUP_NAME>"

Guardar as credenciais da entidade de serviço como secretos

No GitHub.com, navegue até as Configurações do repositório.
Selecione Segredos no menu de navegação e, em seguida, selecione Ações.
Selecione Novo segredo do repositório.
Crie um segredo para o identificador da entidade de serviço.
- Nome: APP_ID
- Secret: Cole o clientId que você copiou da saída do comando de criação da entidade de serviço.
Selecione Adicionar segredo e, em seguida, selecione Novo segredo do repositório para adicionar um segundo segredo.
Crie um segredo para a senha do serviço principal.
- Nome: SECRET
- Secret: Cole o clientSecret que foi copiado da saída do comando de criação do principal de serviço.
Selecione Adicionar segredo e, em seguida, selecione Novo segredo do repositório para adicionar o segredo final.
Crie um segredo para o seu locatário do Azure.
- Nome: TENANT
- Secret: Cole o tenantId que copiaste da saída do comando de criação do principal de serviço.
Selecione Add secret (Adicionar segredo).

2 - Criar um fluxo de trabalho

Um fluxo de trabalho de Ações no GitHub define as tarefas que se executam assim que um evento desencadeia o fluxo de trabalho. Um fluxo de trabalho contém um ou mais trabalhos que podem ser executados em paralelo ou sequencialmente. Para obter mais informações, consulte Noções básicas sobre ações do GitHub.

Para este tutorial, criamos um fluxo de trabalho que contém trabalhos para cada uma das seguintes tarefas:

Provisione uma instância do Hub IoT e uma instância do DPS.
Vincule as instâncias do Hub IoT e do DPS entre si.
Crie um registro individual na instância do DPS e registre um dispositivo no hub IoT usando a autenticação de chave simétrica por meio do registro do DPS.
Simule o dispositivo por cinco minutos e monitore os eventos do hub IoT.

Fluxos de trabalho são arquivos YAML localizados no .github/workflows/ diretório de um repositório.

No repositório do GitHub, navegue até a guia Ações .
No painel Ações , selecione Novo fluxo de trabalho.
Na página Escolha um fluxo de trabalho, você pode escolher modelos pré-criados para usar. Vamos criar o próprio fluxo de trabalho para este tutorial, portanto, selecione Configurar um fluxo de trabalho você mesmo.
O GitHub cria um novo arquivo de fluxo de trabalho para você. Observe que ele está no .github/workflows/ diretório. Dê ao novo arquivo um nome significativo, como dps-tutorial.yml.
Adicione o parâmetro name para dar um nome ao seu fluxo de trabalho.
```
name: DPS Tutorial
```
Adicione o parâmetro on.workflow_dispatch . O on parâmetro define quando um fluxo de trabalho é executado. O workflow_dispatch parâmetro indica que queremos acionar manualmente o fluxo de trabalho. Com este parâmetro, poderíamos definir inputs que seria passado ao fluxo de trabalho em cada execução, mas não o usamos inputs para este tutorial.
```
on: workflow_dispatch
```
Defina as variáveis de ambiente para os recursos que você está criando no fluxo de trabalho. Estas variáveis estão disponíveis para todos os trabalhos no fluxo de trabalho. Você também pode definir variáveis de ambiente para trabalhos individuais ou para etapas individuais dentro de trabalhos.

Substitua os valores padrão pelos seus próprios valores. Certifique-se de especificar o mesmo grupo de recursos ao qual a entidade de serviço tem acesso.
```
env:
  HUB_NAME: <Globally unique IoT hub name>
  DPS_NAME: <Desired Device Provisioning Service name>
  DEVICE_NAME: <Desired device name>
  RESOURCE_GROUP: <Solution resource group where resources will be created>
```

Defina variáveis de ambiente para os segredos que você criou na seção anterior.

  SP_USER: ${{ secrets.APP_ID }}
  SP_SECRET: ${{ secrets.SECRET }}
  SP_TENANT: ${{ secrets.TENANT }}

Adicione o parâmetro jobs ao arquivo de fluxo de trabalho.
```
jobs:
```

Defina a primeira tarefa para o nosso fluxo de trabalho, que chamamos de provision. Esta tarefa provisiona as instâncias do Hub IoT e DPS:

  provision:
    runs-on: ubuntu-latest
    steps:
      - name: Provision Infra
        run: |
          az --version
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az iot hub create -n "$HUB_NAME" -g "$RESOURCE_GROUP"
          az iot dps create -n "$DPS_NAME" -g "$RESOURCE_GROUP"

Para obter mais informações sobre os comandos executados neste trabalho, consulte:

Defina um trabalho para configure as instâncias do DPS e do Hub IoT. Note que este trabalho utiliza o parâmetro necessidades , o que significa que o configure trabalho não é executado até que o trabalho listado complete a sua própria execução com sucesso.
```
  configure:
    runs-on: ubuntu-latest
    needs: provision
    steps:
      - name: Configure Infra
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az iot dps linked-hub create --dps-name "$DPS_NAME" --hub-name "$HUB_NAME"   
```
Para obter mais informações sobre os comandos executados neste trabalho, consulte:
- az iot dps hub ligado criar
Defina um trabalho chamado register que crie uma inscrição individual e depois use essa inscrição para registar um dispositivo no IoT Hub.
```
  register:
    runs-on: ubuntu-latest
    needs: configure
    steps:
      - name: Create enrollment
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az extension add --name azure-iot
          az iot dps enrollment create -n "$DPS_NAME" --eid "$DEVICE_NAME" --attestation-type symmetrickey --auth-type login
      - name: Register device
        run: |
          az iot device registration create -n "$DPS_NAME" --rid "$DEVICE_NAME" --auth-type login   
```
Observação

Esta tarefa e outras usam o parâmetro --auth-type login em alguns comandos para indicar que a operação deve usar o principal do serviço da sessão atual do Microsoft Entra. A alternativa --auth-type key não requer a configuração do principal de serviço, mas é menos segura.

Para obter mais informações sobre os comandos executados neste trabalho, consulte:
- az iot dps inscrição criar
- az iot registro de dispositivo criar

Defina uma tarefa para simulate um dispositivo IoT que se conecta ao hub IoT e envia mensagens de telemetria de amostra.

  simulate:
    runs-on: ubuntu-latest
    needs: register
    steps:
      - name: Simulate device
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az extension add --name azure-iot
          az iot device simulate -n "$HUB_NAME" -d "$DEVICE_NAME"

Para obter mais informações sobre os comandos executados neste trabalho, consulte:

Simular dispositivo AZ IoT

Defina um trabalho para monitor o ponto de extremidade do hub IoT para eventos e observe as mensagens recebidas do dispositivo simulado. Observe que os trabalhos de simulação e monitoramento definem o trabalho de registro em seu needs parâmetro. Esta configuração significa que, uma vez concluído com sucesso o trabalho de registos , ambos os trabalhos correm em paralelo.
```
  monitor:
    runs-on: ubuntu-latest
    needs: register
    steps:
      - name: Monitor d2c telemetry
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az extension add --name azure-iot
          az iot hub monitor-events -n "$HUB_NAME" -y   
```
Para obter mais informações sobre os comandos executados neste trabalho, consulte:
- AZ IoT Hub-Eventos-Monitor

O ficheiro de fluxo de trabalho completo deve parecer com este exemplo, com as suas informações a substituir os valores de placeholder nas variáveis de ambiente.

name: DPS Tutorial

on: workflow_dispatch

env:
  HUB_NAME: <Globally unique IoT hub name>
  DPS_NAME: <Desired Device Provisioning Service name>
  DEVICE_NAME: <Desired device name>
  RESOURCE_GROUP: <Solution resource group where resources will be created>
  SP_USER: ${{ secrets.APP_ID }}
  SP_SECRET: ${{ secrets.SECRET }}
  SP_TENANT: ${{ secrets.TENANT }}

jobs:
  provision:
    runs-on: ubuntu-latest
    steps:
      - name: Provision Infra
        run: |
          az --version
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az iot hub create -n "$HUB_NAME" -g "$RESOURCE_GROUP"
          az iot dps create -n "$DPS_NAME" -g "$RESOURCE_GROUP"
  configure:
    runs-on: ubuntu-latest
    needs: provision
    steps:
      - name: Configure Infra
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az iot dps linked-hub create --dps-name "$DPS_NAME" --hub-name "$HUB_NAME"
  register:
    runs-on: ubuntu-latest
    needs: configure
    steps:
      - name: Create enrollment
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az extension add --name azure-iot
          az iot dps enrollment create -n "$DPS_NAME" --eid "$DEVICE_NAME" --attestation-type symmetrickey --auth-type login
      - name: Register device
        run: |
          az iot device registration create -n "$DPS_NAME" --rid "$DEVICE_NAME" --auth-type login
  simulate:
    runs-on: ubuntu-latest
    needs: register
    steps:
      - name: Simulate device
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az extension add --name azure-iot
          az iot device simulate -n "$HUB_NAME" -d "$DEVICE_NAME"
  monitor:
    runs-on: ubuntu-latest
    needs: register
    steps:
      - name: Monitor d2c telemetry
        run: |
          az login --service-principal -u "$SP_USER" -p "$SP_SECRET" --tenant "$SP_TENANT"
          az extension add --name azure-iot
          az iot hub monitor-events -n "$HUB_NAME" -y

Salve, confirme e envie esse novo arquivo para o repositório do GitHub.

3 - Executar o fluxo de trabalho

Navegue até a guia Ações do repositório GitHub.
No painel Ações , selecione Tutorial do DPS, que é o nome que definimos no arquivo de fluxo de trabalho, e selecione a caixa suspensa Executar fluxo de trabalho .
Altere a ramificação se você criou seu fluxo de trabalho em uma ramificação diferente da principal e, em seguida, selecione Executar fluxo de trabalho.
Uma nova execução de fluxo de trabalho aparece em andamento. Selecione o nome para visualizar os detalhes da execução.
No resumo do fluxo de trabalho, você pode observar como cada trabalho começa e é concluído. Selecione qualquer nome de trabalho para visualizar seus detalhes. O trabalho de dispositivo simulado é executado por cinco minutos e envia telemetria para o Hub IoT. Durante esse tempo, selecione o trabalho de simulação para assistir às mensagens que estão sendo enviadas do dispositivo e o trabalho de monitor para observar essas mensagens sendo recebidas pelo Hub IoT.
Quando todos os trabalhos forem concluídos com sucesso, deverá ver marcas de verificação verdes em cada um.

Limpeza de recursos

Se você não vai continuar a usar esses recursos criados neste tutorial, exclua-os com as etapas a seguir.

Utilize a linha de comandos do Azure:

Liste os recursos no seu grupo de recursos.

az resource list --resource-group <RESOURCE_GROUP_NAME>

Para excluir recursos individuais, use a ID do recurso.

az resource delete --resource-group <RESOURCE_GROUP_NAME> --ids <RESOURCE_ID>

Se você quiser excluir todo o grupo de recursos e todos os recursos dentro dele, execute o seguinte comando:
```
az group delete --resource-group <RESOURCE_GROUP_NAME>
```

Use o portal do Azure:

No portal do Azure, navegue até o grupo de recursos onde você criou os novos recursos.
Pode eliminar todo o grupo de recursos ou selecionar os recursos individuais que pretende remover e, em seguida, selecionar Eliminar.

Próximos passos

Saiba como provisionar instâncias do DPS com outras ferramentas de automação.

Tutorial: Usar políticas de alocação personalizadas com o Serviço de Provisionamento de Dispositivo (DPS)

Feedback

Esta página foi útil?

Last updated on 2025-11-22