Tutorial: Armazenar dados na periferia com bases de dados do SQL Server

Artigo
04/11/2024

Aplica-se a: IoT Edge 1.4

Importante

O IoT Edge 1.4 é a versão suportada. Se tiver uma versão anterior, consulte Atualizar IoT Edge.

Implante um módulo do SQL Server para armazenar dados em um dispositivo que executa o Azure IoT Edge com contêineres Linux.

Utilize o Azure IoT Edge e o SQL Server para armazenar e consultar dados na periferia. O Azure IoT Edge tem recursos básicos de armazenamento para armazenar mensagens em cache se um dispositivo ficar offline e, em seguida, encaminhá-las quando a conexão for restabelecida. No entanto, pode querer capacidades de armazenamento mais avançadas, como a capacidade de consultar dados localmente. Seus dispositivos IoT Edge podem usar bancos de dados locais para executar computação mais complexa sem precisar manter uma conexão com o Hub IoT.

Este artigo fornece instruções para implementar uma base de dados do SQL Server num dispositivo IoT Edge. As Funções do Azure, em execução no dispositivo IoT Edge, estruturam os dados recebidos e, em seguida, envia-os para a base de dados. Os passos neste artigo também podem ser aplicados a outras bases de dados que funcionam em contentores, como o MySQL ou o PostgreSQL.

Neste tutorial, irá aprender a:

Utilize o Visual Studio Code para criar uma função do Azure
Implementar uma base de dados do SQL Server no seu dispositivo IoT Edge
Utilize o Visual Studio Code para criar módulos e implementá-los no seu dispositivo IoT Edge
Ver os dados gerados

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

Pré-requisitos

Antes de começar este tutorial, você deve ter passado pelo tutorial anterior para configurar seu ambiente de desenvolvimento para desenvolvimento de contêineres Linux: Desenvolver módulos do Azure IoT Edge usando o Visual Studio Code. Ao concluir esse tutorial, você deve ter os seguintes pré-requisitos em vigor:

Um Hub IoT no escalão gratuito ou standard no Azure.
Um dispositivo AMD64 executando o Azure IoT Edge com contêineres Linux. Você pode usar os inícios rápidos para configurar um dispositivo Linux ou um dispositivo Windows.
- Dispositivos ARM, como o Raspberry Pis, não podem executar o SQL Server. Se você quiser usar o SQL em um dispositivo ARM, poderá usar o Azure SQL Edge.
Um registro de contêiner, como o Azure Container Registry.
Código do Visual Studio configurado com as extensões Azure IoT Edge e Azure IoT Hub . A extensão de código das ferramentas do Azure IoT Edge para Visual Studio está no modo de manutenção.
Baixe e instale um sistema de gerenciamento de contêineres compatível com Docker em sua máquina de desenvolvimento. Configure-o para executar contêineres Linux.

Este tutorial usa um módulo do Azure Functions para enviar dados para o SQL Server. Para desenvolver um módulo IoT Edge com o Azure Functions, instale os seguintes pré-requisitos adicionais em sua máquina de desenvolvimento:

Extensão C# para o Visual Studio Code (com tecnologia da OmniSharp) para o Visual Studio Code.
SDK do .NET Core.

Criar um projeto de função

Para enviar dados numa base de dados, precisa de um módulo que possa estruturar corretamente os dados e, em seguida, armazená-los numa tabela.

Criar um novo projeto

Os passos seguintes mostram-lhe como criar uma função do IoT Edge com o Visual Studio Code e a extensão Azure IoT Edge.

Abra o Visual Studio Code.
Abra a paleta de comandos Código do Visual Studio selecionando Exibir>paleta de comandos.

Na paleta de comandos, escreva e execute o comando Azure IoT Edge: Nova solução do IoT Edge. Na paleta de comandos, indique as seguintes informações para criar a sua solução:

Campo	Value
Selecionar pasta	Escolha o local em sua máquina de desenvolvimento para Visual Studio Code para criar os arquivos de solução.
Indicar um nome para a solução	Insira um nome descritivo para sua solução, como SqlSolution, ou aceite o padrão.
Selecionar modelo de módulo	Escolha Azure Functions - C#.
Indicar um nome para o módulo	Atribua o nome sqlFunction ao módulo.
Indicar o repositório de imagens do Docker para o módulo	Os repositórios de imagens incluem o nome do seu registo de contentor e o nome da sua imagem de contentor. A imagem de contentor é pré-preenchida no passo anterior. Substitua localhost:5000 pelo valor do servidor de Logon do seu registro de contêiner do Azure. Você pode recuperar o servidor de Logon na página Visão geral do seu registro de contêiner no portal do Azure. A cadeia de caracteres final se parece com <o nome> do Registro.azurecr.io/sqlfunction.

A janela do Visual Studio Code carrega a sua área de trabalho da solução do IoT Edge.

Adicionar as credenciais do registo

O ficheiro de ambiente armazena as credenciais do seu registo de contentor e partilha-as com o runtime do IoT Edge. O runtime precisa destas credenciais para solicitar as imagens privadas para o dispositivo IoT Edge.

A extensão IoT Edge tenta extrair suas credenciais de registro de contêiner do Azure e preenchê-las no arquivo de ambiente. Verifique se as suas credenciais já estão incluídas. Se não, adicione-os agora:

No explorador de código do Visual Studio, abra o arquivo .env.
Atualize os campos com os valores nome de utilizador e palavra-passe que copiou do seu Azure Container Registry.
Guarde este ficheiro.

Nota

Este tutorial usa credenciais de logon de administrador para o Registro de Contêiner do Azure, que são convenientes para cenários de desenvolvimento e teste. Quando estiver pronto para cenários de produção, recomendamos uma opção de autenticação de privilégios mínimos, como entidades de serviço. Para obter mais informações, consulte Gerenciar o acesso ao registro de contêiner.

Selecione sua arquitetura de destino

Você precisa selecionar qual arquitetura você está segmentando com cada solução, porque o contêiner é criado e executado de forma diferente para cada tipo de arquitetura. O padrão é Linux AMD64.

Abra a paleta de comandos e procure Azure IoT Edge: set Default Target Platform for Edge Solution ou selecione o ícone de atalho na barra lateral na parte inferior da janela.
Na paleta de comandos, selecione a arquitetura de destino na lista de opções. Para este tutorial, estamos usando uma máquina virtual Ubuntu como o dispositivo IoT Edge, portanto, manteremos o amd64 padrão.

Atualizar o módulo com o código personalizado

No explorador de código do Visual Studio, abra os módulos>sqlFunction sqlFunction.csproj.>
Localize o grupo de referências de pacote e adicione um novo para incluir SqlClient.
```
<PackageReference Include="System.Data.SqlClient" Version="4.5.1"/>
```
Salve o arquivo sqlFunction.csproj .
Abra o arquivo sqlFunction.cs .

Substitua todo o conteúdo do arquivo pelo seguinte código:

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Azure.Devices.Client;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.EdgeHub;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Sql = System.Data.SqlClient;

namespace Functions.Samples
{
    public static class sqlFunction
    {
        [FunctionName("sqlFunction")]
        public static async Task FilterMessageAndSendMessage(
            [EdgeHubTrigger("input1")] Message messageReceived,
            [EdgeHub(OutputName = "output1")] IAsyncCollector<Message> output,
            ILogger logger)
        {
            const int temperatureThreshold = 20;
            byte[] messageBytes = messageReceived.GetBytes();
            var messageString = System.Text.Encoding.UTF8.GetString(messageBytes);

            if (!string.IsNullOrEmpty(messageString))
            {
                logger.LogInformation("Info: Received one non-empty message");
                // Get the body of the message and deserialize it.
                var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);

                //Store the data in SQL db
                const string str = "<sql connection string>";
                using (Sql.SqlConnection conn = new Sql.SqlConnection(str))
                {
                    conn.Open();
                    var insertMachineTemperature = "INSERT INTO MeasurementsDB.dbo.TemperatureMeasurements VALUES (CONVERT(DATETIME2,'" + messageBody.timeCreated + "', 127), 'machine', " + messageBody.machine.temperature + ");";
                    var insertAmbientTemperature = "INSERT INTO MeasurementsDB.dbo.TemperatureMeasurements VALUES (CONVERT(DATETIME2,'" + messageBody.timeCreated + "', 127), 'ambient', " + messageBody.ambient.temperature + ");";
                    using (Sql.SqlCommand cmd = new Sql.SqlCommand(insertMachineTemperature + "\n" + insertAmbientTemperature, conn))
                    {
                        //Execute the command and log the # rows affected.
                        var rows = await cmd.ExecuteNonQueryAsync();
                        logger.LogInformation($"{rows} rows were updated");
                    }
                }

                if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
                {
                    // Send the message to the output as the temperature value is greater than the threashold.
                    using (var filteredMessage = new Message(messageBytes))
                    {
                         // Copy the properties of the original message into the new Message object.
                         foreach (KeyValuePair<string, string> prop in messageReceived.Properties)
                         {filteredMessage.Properties.Add(prop.Key, prop.Value);}
                         // Add a new property to the message to indicate it is an alert.
                         filteredMessage.Properties.Add("MessageType", "Alert");
                         // Send the message.
                         await output.AddAsync(filteredMessage);
                         logger.LogInformation("Info: Received and transferred a message with temperature above the threshold");
                    }
                }
            }
        }
    }
    //Define the expected schema for the body of incoming messages.
    class MessageBody
    {
        public Machine machine {get; set;}
        public Ambient ambient {get; set;}
        public string timeCreated {get; set;}
    }
    class Machine
    {
        public double temperature {get; set;}
        public double pressure {get; set;}
    }
    class Ambient
    {
        public double temperature {get; set;}
        public int humidity {get; set;}
    }
}

Na linha 35, substitua a cadeia de conexão sql pela cadeia> de <caracteres a seguir. A propriedade Data Source faz referência ao contêiner do SQL Server, que ainda não existe. Você irá criá-lo com o nome SQL na próxima seção.
```
Data Source=tcp:sql,1433;Initial Catalog=MeasurementsDB;User Id=SA;Password=Strong!Passw0rd;TrustServerCertificate=False;Connection Timeout=30;
```
Salve o arquivo sqlFunction.cs .

Adicionar o contêiner do SQL Server

Um Manifesto de implementação declara os módulos que o runtime do IoT Edge irá instalar no seu dispositivo IoT Edge. Você forneceu o código para criar um módulo de Função personalizado na seção anterior, mas o módulo do SQL Server já está criado e disponível no Azure Marketplace. Apenas tem de indicar ao runtime do IoT Edge para o incluir e configurar no seu dispositivo.

No Visual Studio Code, abra a paleta de comandos selecionando Exibir>paleta de comandos.

Na paleta de comandos, digite e execute o comando Azure IoT Edge: Add IoT Edge module. Na paleta de comandos, forneça as seguintes informações para adicionar um novo módulo:

Campo	Value
Selecione o ficheiro de modelo da implementação	A paleta de comandos destaca o arquivo deployment.template.json na pasta da solução atual. Selecione esse arquivo.
Selecionar modelo de módulo	Selecione Módulo no Azure Marketplace.

No mercado do módulo Azure IoT Edge, procure e selecione Módulo SQL Server.
Altere o nome do módulo para sql, tudo em minúsculas. Esse nome corresponde ao nome do contêiner declarado na cadeia de conexão no arquivo sqlFunction.cs.
Selecione Importar para adicionar o módulo à sua solução.
Na pasta da solução, abra o arquivo deployment.template.json .
Encontre a seção de módulos . Você deve ver três módulos. O módulo SimulatedTemperatureSensor está incluído por padrão em novas soluções e fornece dados de teste para usar com seus outros módulos. O módulo sqlFunction é o módulo que você criou inicialmente e atualizou com o novo código. Finalmente, o módulo sql foi importado do Azure Marketplace.

Gorjeta

O módulo SQL Server vem com uma senha padrão definida nas variáveis de ambiente do manifesto de implantação. Sempre que criar um contentor do SQL Server num ambiente de produção, deve alterar a palavra-passe de administrador do sistema predefinida.
Feche o arquivo deployment.template.json .

Criar a sua solução do IoT Edge

Nas secções anteriores, criou uma solução com um módulo e, em seguida, adicionou outra ao modelo de manifesto de implementação. O módulo SQL Server é hospedado publicamente pela Microsoft, mas você precisa conteinerizar o código no módulo Funções. Nesta seção, você cria a solução, cria imagens de contêiner para o módulo sqlFunction e envia a imagem para o registro de contêiner.

No Visual Studio Code, selecione View (Ver) >Terminal para abrir o terminal integrado do VS Code.
Inicie sessão no seu registo de contentor do Visual Studio Code para que possa enviar as imagens para o seu registo. Use as mesmas credenciais do Registro de Contêiner do Azure (ACR) que você adicionou ao arquivo .env. Introduza o seguinte comando no terminal integrado:
```
docker login -u <ACR username> -p <ACR password> <ACR login server>
```
Você pode ver um aviso de segurança recomendando o uso do parâmetro --password-stdin. Enquanto a sua utilização está fora do âmbito deste artigo, recomendamos que siga esta melhor prática. Para obter mais informações, consulte a referência do comando docker login .
No explorador de código do Visual Studio, clique com o botão direito do mouse no arquivo de deployment.template.json e selecione Criar e enviar por push a solução IoT Edge.

O comando build e push inicia três operações. Primeiro, ele cria uma nova pasta na solução chamada config que contém o manifesto de implantação completo, que é criado a partir de informações no modelo de implantação e outros arquivos de solução. Em segundo lugar, ele é executado docker build para criar a imagem do contêiner com base no dockerfile apropriado para sua arquitetura de destino. Em seguida, ele é executado docker push para enviar o repositório de imagens para o registro do contêiner.

Esse processo pode levar vários minutos na primeira vez, mas é mais rápido na próxima vez que você executar os comandos.

Você pode verificar se o módulo sqlFunction foi enviado com êxito para o registro do contêiner. No portal do Azure, navegue até o registro do contêiner. Selecione repositórios e procure sqlFunction. Os outros dois módulos, SimulatedTemperatureSensor e sql, não serão enviados para o registro do contêiner porque seus repositórios já estão nos registros da Microsoft.

Implementar a solução num dispositivo

Pode definir módulos num dispositivo através do Hub IoT, mas também pode aceder o seu Hub IoT e dispositivos através do Visual Studio Code. Nesta seção, você configura o acesso ao seu Hub IoT e, em seguida, usa o Visual Studio Code para implantar sua solução em seu dispositivo IoT Edge.

No explorador de código do Visual Studio, na seção Hub IoT do Azure, expanda Dispositivos para ver sua lista de dispositivos IoT.
Clique com o botão direito do mouse no dispositivo que você deseja direcionar com sua implantação e selecione Criar implantação para um único dispositivo.
Selecione o arquivo deployment.amd64.json na pasta config e clique em Select Edge Deployment Manifest. Não utilize o ficheiro deployment.template.json.
No dispositivo, expanda Módulos para ver uma lista de módulos implantados e em execução. Clique no botão Atualizar. Você deve ver os novos módulos sql e sqlFunction em execução junto com o módulo SimulatedTemperatureSensor e os $edgeAgent e $edgeHub.

Também pode verificar se todos os módulos estão em execução no seu dispositivo. No dispositivo IoT Edge, execute o seguinte comando para ver o estado dos módulos.
```
iotedge list
```
Pode levar alguns minutos para que os módulos iniciem. O tempo de execução do IoT Edge precisa receber seu novo manifesto de implantação, extrair as imagens do módulo do tempo de execução do contêiner e iniciar cada novo módulo.

Criar uma base de dados SQL

Ao aplicar o manifesto de implementação ao seu dispositivo, obtém três módulos em execução. O módulo SimulatedTemperatureSensor gera dados de ambiente simulados. O módulo sqlFunction utiliza os dados e formata-os para uma base de dados. Esta secção orienta-o na configuração da base de dados do SQL Server para armazenar os dados de temperatura.

Execute os seguintes comandos no dispositivo IoT Edge. Esses comandos se conectam ao módulo sql em execução no seu dispositivo e criam um banco de dados e uma tabela para armazenar os dados de temperatura que estão sendo enviados para ele.

Em uma ferramenta de linha de comando em seu dispositivo IoT Edge, conecte-se ao seu banco de dados.
```
sudo docker exec -it sql bash
```

Abra a ferramenta de comandos SQL.

/opt/mssql-tools/bin/sqlcmd -S localhost -U SA -P 'Strong!Passw0rd'

Criar a base de dados:

CREATE DATABASE MeasurementsDB
ON
(NAME = MeasurementsDB, FILENAME = '/var/opt/mssql/measurementsdb.mdf')
GO

Defina a tabela.

CREATE TABLE MeasurementsDB.dbo.TemperatureMeasurements (measurementTime DATETIME2, location NVARCHAR(50), temperature FLOAT)
GO

Pode personalizar o ficheiro de docker do SQL Server para configurar automaticamente o SQL Server para ser implementado em vários dispositivos IoT Edge. Para obter mais informações, veja o Projeto de demonstração de contentor do Microsoft SQL Server.

Ver os dados locais

Assim que a tabela for criada, o módulo sqlFunction começa a armazenar os dados numa base de dados local do SQL Server 2017 no seu dispositivo IoT Edge.

A partir da ferramenta de comandos SQL, execute o seguinte comando para ver os dados de tabela formatados:

SELECT * FROM MeasurementsDB.dbo.TemperatureMeasurements
GO

View contents of local database

Clean up resources (Limpar recursos)

Se planeia avançar para o próximo artigo recomendado, pode manter os recursos e as configurações que criou e reutilizá-los. Também pode continuar a utilizar o mesmo dispositivo IoT Edge como um dispositivo de teste.

Caso contrário, pode eliminar as configurações locais e os recursos do Azure que criou neste artigo para evitar custos.

Eliminar recursos do Azure

A eliminação de recursos e grupos de recursos do Azure é irreversível. Confirme que não elimina acidentalmente o grupo de recursos ou recursos errados. Se você criou o hub IoT dentro de um grupo de recursos existente que tem recursos que deseja manter, exclua apenas o recurso do hub IoT em si, não o grupo de recursos.

Para eliminar os recursos:

Inicie sessão no Portal do Azure e selecione Grupos de recursos.
Selecione o nome do grupo de recursos que contém os recursos de teste do IoT Edge.
Reveja a lista de recursos contidos no seu grupo de recursos. Se quiser eliminá-los todos, pode selecionar Eliminar grupo de recursos. Se quiser eliminar apenas alguns dos recursos, pode clicar em cada um para eliminá-los individualmente.

Neste tutorial, criou um módulo das Funções do Azure que contém código para filtrar dados não processados gerados pelo seu dispositivo IoT Edge. Quando estiver pronto para criar seus próprios módulos, você poderá saber mais sobre como desenvolver módulos do Azure IoT Edge usando o Visual Studio Code.

Próximos passos

Se você quiser tentar outro método de armazenamento na borda, leia sobre como usar o Armazenamento de Blob do Azure no IoT Edge.

Armazenar dados na periferia com o Armazenamento de Blobs do Azure no IoT Edge