Självstudie: Distribuera Azure Functions som IoT Edge-moduler

  • Artikel

Gäller för:Bockmarkering för IoT Edge 1.5 IoT Edge 1.5 Bockmarkering för IoT Edge 1.4 IoT Edge 1.4

Viktigt!

IoT Edge 1.5 LTS och IoT Edge 1.4 LTS stöds. IoT Edge 1.4 LTS upphör den 12 november 2024. Om du har en tidigare version läser du Uppdatera IoT Edge.

Du kan använda Azure Functions till att distribuera kod som implementerar din affärslogik direkt till dina Azure IoT Edge-enheter. Den här självstudien beskriver hur du skapar och distribuerar en Azure-funktion som filtrerar sensordata på den simulerade IoT Edge-enheten. Du använder den simulerade IoT Edge-enhet som du skapade i snabbstarterna. I den här självstudien lär du dig att:

  • Använd Visual Studio Code för att skapa en Azure-funktion.
  • Använd Visual Studio Code och Docker för att skapa en Docker-avbildning och publicera den i ett containerregister.
  • distribuera modulen från containerregistret till din IoT Edge-enhet
  • visa filtrerade data.

Diagram över funktionsarkitektur, som visar hur du mellanlagrar och distribuerar en funktionsmodul.

Den Azure-funktion som du skapar i den här självstudien filtrerar temperaturdata som genereras av enheten. Funktionen skickar bara meddelanden uppströms till Azure IoT Hub när temperaturen ligger över ett angivet tröskelvärde.

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar.

Förutsättningar

Innan du påbörjar den här självstudien gör du självstudien för att konfigurera utvecklingsmiljön för Linux-containerutveckling: Utveckla Azure IoT Edge-moduler med Hjälp av Visual Studio Code. När du har slutfört självstudien bör du ha följande förutsättningar på plats:

Om du vill utveckla en IoT Edge-modul med Azure Functions installerar du ytterligare krav på utvecklingsdatorn:

Skapa ett funktionsprojekt

Azure IoT Edge för Visual Studio Code som du har installerat i förhandskraven ger både hanteringsfunktioner och vissa kodmallar. I det här avsnittet använder du Visual Studio Code för att skapa en IoT Edge-lösning som innehåller en Azure-funktion.

Skapa ett nytt projekt

Följ de här stegen för att skapa en C#-funktionslösningsmall som är anpassningsbar.

  1. Öppna Visual Studio Code på utvecklingsdatorn.

  2. Öppna Visual Studio Code-kommandopaletten genom att välja Visa>kommandopalett.

  3. I kommandopaletten lägger du till och kör kommandot Azure IoT Edge: Ny IoT Edge-lösning. Följ de här anvisningarna i kommandopaletten för att skapa din lösning:

    • Välj en mapp: Välj platsen på utvecklingsdatorn för Visual Studio Code för att skapa lösningsfilerna.
    • Ange ett lösningsnamn: lägg till ett beskrivande namn för din lösning, till exempel FunctionSolution, eller acceptera standardinställningen.|
    • Välj en modulmall: välj Azure Functions – C#.
    • Ange ett modulnamn | Ge modulen namnet CSharpFunction.
    • Ange en Docker-avbildningslagringsplats för modulen. En bildlagringsplats innehåller namnet på containerregistret och namnet på containeravbildningen. Containeravbildningen fylls i i förväg från det sista steget. Ersätt localhost:5000 med värdet för inloggningsservern från azure-containerregistret. Du kan hämta inloggningsservern från sidan Översikt i containerregistret i Azure-portalen. Den slutliga strängen ser ut så här: <registernamn>.azurecr.io/csharpfunction.

    Skärmbild som visar var du lägger till namnet på Docker-avbildningslagringsplatsen i Visual Studio Code.

Lägg till autentiseringsuppgifter för registret

Miljöfilen för din lösning lagrar autentiseringsuppgifterna för containerregistret och delar dem med IoT Edge-körningen. Körningen behöver dessa autentiseringsuppgifter för att hämta dina privata avbildningar till din IoT Edge-enhet.

IoT Edge-tillägget i Visual Studio Code försöker hämta dina autentiseringsuppgifter för containerregistret från Azure och fylla i dem i miljöfilen. Kontrollera om dina autentiseringsuppgifter redan finns i filen. Om inte lägger du till dem nu:

  1. Öppna filen i Visual Studio Code-utforskaren .env .
  2. Uppdatera fälten med det användarnamn och lösenord som du kopierade från Azure Container-registret. Du kan hitta dem igen genom att gå till containerregistret i Azure och titta på sidan Inställningar> Åtkomstnycklar.
  3. Spara filen.

Kommentar

I den här självstudien används autentiseringsuppgifter för administratörsinloggning för Azure Container Registry, vilket är praktiskt för utvecklings- och testscenarier. När du är redo för produktionsscenarier rekommenderar vi ett alternativ för autentisering med minst privilegier som tjänstens huvudnamn. Mer information finns i Hantera åtkomst till containerregistret.

Ange målarkitektur till AMD64

Att köra Azure Functions-moduler på IoT Edge stöds endast på Linux AMD64-baserade containrar. Standardmålarkitekturen för Visual Studio Code är Linux AMD64, men vi anger den uttryckligen till Linux AMD64 här.

  1. Öppna kommandopaletten och sök efter Azure IoT Edge: Ange standardmålplattform för Edge-lösning.

  2. I kommandopaletten väljer du AMD64-målarkitekturen i listan med alternativ.

Uppdatera modulen med anpassad kod

Nu ska vi lägga till ytterligare kod så att CSharpFunction-modulen bearbetar meddelandena vid gränsen innan de vidarebefordras till IoT Hub.

  1. Öppna modulerna>CSharpFunction>CSharpFunction.cs i Visual Studio Code-utforskaren.

  2. Ersätt innehållet i filen CSharpFunction.cs med följande kod. Den här koden tar emot telemetri om omgivande temperatur och datortemperatur och vidarebefordrar enbart meddelandet till IoT Hub om datortemperaturen överstiger ett angivet tröskelvärde.

    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;

namespace Functions.Samples
{
    public static class CSharpFunction
    {
        [FunctionName("CSharpFunction")]
        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);

                if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
                {
                    // Send the message to the output as the temperature value is greater than the threshold.
                    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;}
    }
}

  3. Spara filen.

Skapa och push-överföra din IoT Edge-lösning

I föregående avsnitt skapade du en IoT Edge-lösning och ändrade CSharpFunction för att filtrera bort meddelanden med rapporterade datortemperaturer under det acceptabla tröskelvärdet. Nu behöver du bygga lösningen som en containeravbildning och push-överföra den till ditt containerregister.

  1. Öppna den integrerade Terminalen i Visual Studio Code genom att välja Visa>terminal.

  2. Logga in på Docker genom att ange följande kommando i terminalen. Logga in med användarnamnet, lösenordet och inloggningsservern från azure-containerregistret. Du kan hämta dessa värden från avsnittet Åtkomstnycklar i registret i Azure-portalen.

    docker login -u <ACR username> -p <ACR password> <ACR login server>

    Du kan få en säkerhetsvarning som rekommenderar användning av --password-stdin. Även om den bästa metoden rekommenderas för produktionsscenarier ligger den utanför omfånget för den här självstudien. Mer information finns i docker-inloggningsreferensen.

  3. I Visual Studio Code-utforskaren högerklickar du på filen deployment.template.json och väljer Build and Push IoT Edge Solution (Skapa och push-lösning för IoT Edge).

    Kommandot build och push startar tre åtgärder. Först skapar den en ny mapp i lösningen med namnet config som innehåller det fullständiga distributionsmanifestet, som är inbyggt med information i distributionsmallen och andra lösningsfiler. För det andra körs docker build den för att skapa containeravbildningen baserat på lämplig dockerfile för målarkitekturen. Sedan körs docker push den för att skicka avbildningslagringsplatsen till containerregistret.

    Den här processen kan ta flera minuter första gången, men det går snabbare nästa gång du kör kommandona.

Visa din containeravbildning

Visual Studio Code matar ut ett meddelande om lyckad överföring när containeravbildningen har push-överförts till containerregistret. Om du själv vill kontrollera att åtgärden lyckades kan du visa avbildningen i registret.

  1. Bläddra till ditt Azure containerregister i Azure Portal.
  2. Välj Tjänstlagringsplatser>.
  3. Du bör se lagringsplatsen csharpfunction i listan. Välj den här lagringsplatsen för att se mer information.
  4. I avsnittet Taggar bör du se taggen 0.0.1-amd64. Den här taggen anger version och plattform för avbildningen du skapade. Dessa värden anges i filen module.json i mappen CSharpFunction.

Distribuera och kör lösningen

Du kan använda Azure-portalen för att distribuera funktionsmodulen till en IoT Edge-enhet som du gjorde i snabbstarten. Du kan också distribuera och övervaka moduler från Visual Studio Code. I följande avsnitt används Azure IoT Edge och IoT Hub för Visual Studio Code som angavs i förhandskraven. Installera tilläggen nu, om du inte redan har gjort det.

  1. I Visual Studio Code-utforskaren under avsnittet Azure IoT Hub expanderar du Enheter för att se din lista över IoT-enheter.

  2. Högerklicka på namnet på din IoT Edge-enhet och välj sedan Skapa distribution för enskild enhet.

  3. Bläddra till lösningsmappen som innehåller CSharpFunction. Öppna mappen config, välj filen deployment.amd64.json och välj sedan Välj Edge-distributionsmanifest.

  4. Under enheten expanderar du Moduler för att se en lista över distribuerade och körande moduler. Klicka på uppdateringsknappen. Du bör se att den nya CSharpFunction körs tillsammans med modulen SimulatedTemperatureSensor och $edgeAgent och $edgeHub.

    Det kan ta en stund för de nya modulerna att visas. IoT Edge-enheten måste hämta sin nya distributionsinformation från IoT Hub, starta de nya containrarna och rapportera statusen tillbaka till IoT Hub.

    Skärmbild som visar hur du visar distribuerade moduler i Visual Studio Code.

Visa genererade data

Du kan se alla meddelanden som kommer till din IoT-hubb från alla dina enheter genom att köra Azure IoT Hub: Börja övervaka inbyggd händelseslutpunkt i kommandopaletten. Om du vill sluta övervaka meddelanden kör du kommandot Azure IoT Hub: Stop Monitoring Built-in Event Endpoint in the command palette (Stoppa övervakning av inbyggd händelseslutpunkt i kommandopaletten).

Du kan också filtrera vyn för att visa alla meddelanden som kommer till IoT-hubben från en viss enhet. Högerklicka på enheten i avsnittet Azure IoT Hub-enheter> i Visual Studio Code-utforskaren och välj Starta övervakning inbyggd händelseslutpunkt.

Rensa resurser

Om du tänker fortsätta till nästa rekommenderade artikel kan du behålla de resurser och konfigurationer du har skapat och använda dem igen. Du kan även fortsätta att använda samma IoT Edge-enhet som en testenhet.

Annars kan du ta bort de lokala konfigurationerna och de Azure-resurser som du har skapat i den här artikeln för att därigenom undvika kostnader.

Ta bort Azure-resurser

Det går inte att ångra borttagningen av Azure-resurser och resursgrupper. Var noga så att du inte tar bort fel resursgrupp eller resurser av misstag. Om du har skapat IoT-hubben i en befintlig resursgrupp som har resurser som du vill behålla tar du bara bort själva IoT Hub-resursen, inte resursgruppen.

Ta bort resurser:

  1. Logga in på Azure-portalen och välj Resursgrupper.

  2. Välj namnet på resursgruppen som innehåller dina IoT Edge-testresurser.

  3. Granska listan över resurser som finns i resursgruppen. Om du vill ta bort alla kan du välja Ta bort resursgrupp. Om du bara vill ta bort några av dem kan du klicka i varje resurs och ta bort dem individuellt.

Nästa steg

I den här självstudien skapade du en Azure-funktionsmodul med kod för att filtrera rådata som genereras av din IoT Edge-enhet.

Fortsätt med någon av följande självstudier om du vill lära dig mer om hur Azure IoT Edge kan hjälpa dig att omvandla dina data till affärsinsikter.

Hitta medelvärden med hjälp av ett flytande fönster i Azure Stream Analytics