チュートリアル: Visual Studio Code を使用して IoT Edge モジュールを開発する

2025-05-16

適用対象: IoT Edge 1.5

重要

IoT Edge 1.5 LTS は、サポートされているリリースです。 IoT Edge 1.4 LTS は、2024 年 11 月 12 日をもってサポートが終了しています。以前のリリースの場合は、「 IoT Edge の更新」を参照してください。

このチュートリアルでは、コードを開発して IoT Edge デバイスにデプロイする方法について説明します。 Azure IoT Edge モジュールを使用すると、ビジネスロジックを実行するコードを IoT Edge デバイスに直接デプロイできます。「Linux デバイスへのコードのデプロイ」クイックスタートでは、IoT Edge デバイスを設定し、Azure Marketplace からモジュールをデプロイしました。

この記事では、2 つの IoT Edge 開発ツールの手順について説明します。

開発に推奨される Azure IoT Edge Dev Tool コマンドライン (CLI)。
メンテナンスモードの Visual Studio Code 拡張機能用の Azure IoT Edge ツール。

この記事の冒頭にあるツールセレクターボタンを使用して、ツールを選択します。

このチュートリアルでは、以下の内容を学習します。

開発用コンピューターを設定する
IoT Edge ツールを使用して新しいプロジェクトを作成する
Docker コンテナーとしてプロジェクトをビルドし、Azure コンテナーレジストリに格納する
IoT Edge デバイスにコードをデプロイする

このチュートリアルで作成する IoT Edge モジュールは、デバイスが生成する温度データをフィルター処理します。温度が設定されたしきい値を超えている場合にのみ、アップストリームにメッセージを送信します。エッジでこのような分析を行うと、クラウドに送信され、クラウドに格納されるデータの量を減らすことができます。

前提条件

開発マシン:

自分のパソコンまたは仮想マシンを使用できます。
コンテナーエンジンを実行するための入れ子になった仮想化が開発マシンでサポートされていることを確認します。
コンテナーエンジンを実行するほとんどのオペレーティングシステムを使用して、Linux デバイス用の IoT Edge モジュールを開発できます。このチュートリアルでは Windows コンピューターを使用しますが、macOS または Linux での既知の違いについて説明します。
Visual Studio Code をインストールする
Azure CLI をインストールします。

Azure IoT Edge デバイス:

別のデバイスで IoT Edge を実行します。開発用マシンと IoT Edge デバイスを個別に保持すると、実際のデプロイシナリオがシミュレートされ、概念を明確に保つことができます。クイックスタート記事「 Linux デバイスにコードをデプロイして Azure に IoT Edge デバイスを作成する」または Azure リソーステンプレートを使用して、IoT Edge 対応 VM をデプロイします。

クラウドリソース:

無料または Standard レベルの Azure IoT Hub を使用します。

Azure アカウントをお持ちでない場合は、開始する前に無料アカウントを作成してください。

ヒント

Visual Studio Code または Visual Studio 2022 での対話型デバッグに関するガイダンスについて。

このチュートリアルでは、Visual Studio Code の開発手順について説明します。

主要な概念

このチュートリアルでは、IoT Edge モジュールの開発について説明します。 "IoT Edge モジュール" は、実行可能コードのコンテナーです。 1 つ以上のモジュールを IoT Edge デバイスにデプロイします。モジュールは、センサーからのデータの取り込み、データのクリーニングと分析、IoT Hub へのメッセージの送信などの特定のタスクを実行します。詳細については、「 Azure IoT Edge モジュールについて」を参照してください。

IoT Edge モジュールを開発するときは、開発マシンと、モジュールがデプロイされるターゲット IoT Edge デバイスの違いを理解します。モジュールコードを保持するためにビルドするコンテナーは、 ターゲットデバイスのオペレーティングシステム (OS) と一致している必要があります。たとえば、最も一般的なシナリオは、IoT Edge を実行している Linux デバイスを対象とするモジュールを Windows コンピューターで開発することです。その場合、コンテナーオペレーティングシステムは Linux です。このチュートリアルを実行するときは、 開発用マシン OS と コンテナー OS の違いに注意してください。

ヒント

Windows で Linux 用 IoT Edge を使用している場合、シナリオのターゲットデバイスは、Windows ホストではなく Linux 仮想マシンです。

このチュートリアルでは、Linux コンテナーを使用して IoT Edge を実行しているデバイスをターゲットとしています。開発マシンが Linux コンテナーを実行している限り、任意のオペレーティングシステムを使用します。 Linux コンテナーを使用した開発には Visual Studio Code をお勧めします。そのため、このチュートリアルではそれを使用します。 Visual Studio も使用できますが、この 2 つのツールの間にはサポートに違いがあります。

次の表に、Visual Studio Code と Visual Studio の Linux コンテナー でサポートされている開発シナリオを示します。

	Visual Studio Code	Visual Studio 2019/2022
Linux デバイスアーキテクチャ	Linux AMD64 Linux ARM32v7 Linux ARM64	Linux AMD64 Linux ARM32 Linux ARM64
Azure サービス	Azure Functions Azure Stream Analytics Azure Machine Learning
言語	C C# ジャワ Node.js Python（プログラミング言語）	C C#
詳細情報	Azure IoT Edge for Visual Studio Code	Visual Studio 2019 用の Azure IoT Edge ツール Azure IoT Edge Tools for Visual Studio 2022

コンテナーエンジンをインストールする

IoT Edge モジュールはコンテナーとしてパッケージ化されているため、開発マシン上に Docker と互換性のあるコンテナー管理システムを構築して管理する必要があります。 Docker Desktop は強力な機能サポートを備えるため、開発に人気のある選択肢です。 Windows 上の Docker Desktop を使用すると、Linux コンテナーと Windows コンテナーを切り替えることができるため、さまざまな種類の IoT Edge デバイス用のモジュールを開発できます。

Docker のドキュメントを使用して、開発用コンピューターに Docker をインストールします。

Docker Desktop for Windows をインストールする
- Docker Desktop for Windows をインストールするときに、Linux コンテナーを使用するか Windows コンテナーを使用するかを尋ねられます。この設定は、いつでも変更できます。モジュールは Linux デバイスを対象としているため、このチュートリアルでは Linux コンテナーを使用します。詳細については、「 Windows コンテナーと Linux コンテナーの切り替え」を参照してください。
Docker Desktop for Mac をインストールする
いくつかの Linux プラットフォームでのインストール情報については、 Docker CE についてお読みください。
- Windows Subsystem for Linux (WSL) の場合は、Docker Desktop for Windows をインストールします。

ツールを設定する

Python ベースの Azure IoT Edge Dev Tool をインストールして、IoT Edge ソリューションを作成します。次の 2 つのオプションがあります。

推奨される事前構築済みの IoT Edge 開発コンテナーを使用する
iotedgedev 開発セットアップを使用してツールをインストールする

重要

Visual Studio Code 拡張機能用の Azure IoT Edge ツールはメンテナンスモードです。推奨される開発ツールは、コマンドライン (CLI) の "Azure IoT Edge 開発ツール" です。

Visual Studio Code の IoT 拡張機能を使用して、IoT Edge モジュールを開発します。これらの拡張機能は、プロジェクトテンプレートを提供し、配置マニフェストの作成を自動化し、IoT Edge デバイスを監視および管理できるようにします。このセクションでは、Visual Studio Code と IoT 拡張機能をインストールし、次に Visual Studio Code 内から IoT Hub のリソースを管理する Azure アカウントを設定します。

Azure IoT Edge 拡張機能をインストールします。
Azure IoT Hub 拡張機能をインストールします。
拡張機能をインストールしたら、表示を選択して>を開きます。
コマンドパレットで、 Azure IoT Hub: [IoT Hub の選択] を検索して選択します。プロンプトに従って、Azure サブスクリプションと IoT Hub を選択します。
アクティビティバーでアイコンを選択するか、 ビュー>Explorer を選択して、Visual Studio Code のエクスプローラーセクションを開きます。
エクスプローラーセクションの下部で、折りたたまれている Azure IoT Hub /[デバイス] メニューを 展開します。コマンドパレットで選択した IoT Hub に関連付けられているデバイスと IoT Edge デバイスが表示されます。

言語固有のツールをインストールする

開発に使用する言語に固有のツールをインストールします:

Java SE Development Kit 11 と Maven。 JDK のインストールを指すJAVA_HOME環境変数を設定する必要があります。
Maven
Visual Studio Code 用 Java 拡張機能パック

ヒント

Java および Maven のインストールプロセスによって、環境変数がシステムに追加されます。インストールが完了したら、開いている Visual Studio Code ターミナル、PowerShell、またはコマンドプロンプトインスタンスを再起動します。この手順により、これらのユーティリティで Java コマンドと Maven コマンドが認識されます。

Python で IoT Edge モジュールを開発するには、開発用コンピューターに次の追加の前提条件をインストールします。

注意

bin フォルダーがプラットフォームのパスにあることを確認します。通常は、UNIX と macOS の場合は ~/.local/、Windows の場合は %APPDATA%\Pythonです。

コンテナーレジストリの作成

このチュートリアルでは、 Azure IoT Edge と Azure IoT Hub 拡張機能を使用してモジュールをビルドし、ファイルから コンテナーイメージ を作成します。その後、イメージを格納および管理する レジストリ にこのイメージをプッシュします。最後に、レジストリからイメージを展開し、IoT Edge デバイスで実行します。

重要

Azure IoT Edge Visual Studio Code 拡張機能はメンテナンスモードです。

コンテナーイメージは、Docker と互換性のある任意のレジストリを使用して格納できます。一般的な 2 つの Docker レジストリサービスは、Azure Container Registry と Docker Hub です。このチュートリアルでは、Azure Container Registry を使用します。

コンテナーレジストリがまだない場合は、次の手順に従って、Azure に新しいコンテナーレジストリを作成します。

Azure portal で、リソースの作成>Containers>Container Registry を選択します。

コンテナーレジストリを作成するために、以下の必須値を指定します。

フィールド	値
サブスクリプション	ドロップダウンリストで、サブスクリプションを選択します。
リソースグループ	IoT Edge のクイックスタートおよびチュートリアルで作成したすべてのテストリソースに対して同じリソースグループを使用します。たとえば、 IoTEdgeResources です。
レジストリ名	一意の名前を指定します。
ロケーション	近くの場所を選択します。
SKU（在庫管理単位）	[ 基本] を選択します。

[ 確認と作成]、[ 作成] の順に選択します。
Azure portal のホームページの [リソース ] セクションから新しいコンテナーレジストリを選択して開きます。
コンテナーレジストリの左側のウィンドウで、[設定] の下にあるメニューから [アクセスキー] を選択します。
トグルボタンを使用して 管理者ユーザー を有効にし、コンテナーレジストリの ユーザー名 と パスワード を表示します。
ログインサーバー、ユーザー名、パスワードの値をコピーし、便利な場所に保存します。このチュートリアルではこれらの値を使用して、コンテナーレジストリへのアクセスを提供します。

新しいモジュールプロジェクトを作成する

この Azure IoT Edge 拡張機能には、Visual Studio Code でサポートされているすべての IoT Edge モジュール言語のプロジェクトテンプレートが用意されています。これらのテンプレートには、IoT Edge をテストするために作業モジュールをデプロイするために必要なすべてのファイルとコードが含まれています。また、独自のビジネスロジックを使用してテンプレートをカスタマイズするための出発点を提供します。

プロジェクトテンプレートを作成する

IoT Edge Dev Tool は、環境変数によって駆動されるコマンドを使用して Azure IoT Edge 開発を簡略化します。これは、既定のモジュールと必要なすべての構成ファイルを含む IoT Edge 開発コンテナーと IoT Edge ソリューションスキャフォールディングを使用して IoT Edge 開発を開始するのに役立ちます。

目的のパスにソリューションのディレクトリを作成します。 iotedgesolution ディレクトリに移動します。
```
mkdir c:\dev\iotedgesolution
cd c:\dev\iotedgesolution
```

iotedgedev solution init コマンドを使用してソリューションを作成し、任意の開発言語で Azure IoT Hub を設定します。

iotedgedev solution init --template csharp

iotedgedev solution init --template c

iotedgedev solution init --template java

iotedgedev solution init --template nodejs

iotedgedev solution init --template python

iotedgedev ソリューション init スクリプトでは、次のようないくつかの手順を完了するように求められます。

Azure に対して認証します
Azure サブスクリプションを選択する
リソースグループを選択または作成する
Azure IoT Hub を選択または作成する
Azure IoT Edge デバイスを選択または作成する

Visual Studio Code と Azure IoT Edge 拡張機能を使用します。まず、ソリューションを作成し、そのソリューションで最初のモジュールを生成します。各ソリューションには、複数のモジュールを含めることができます。

[ 表示>コマンドパレット] を選択します。
コマンドパレットで、「 Azure IoT Edge: New IoT Edge Solution」コマンドを入力して実行します。
新しいソリューションを作成するフォルダーを参照し、[フォルダーの選択] を 選択します。
ソリューションの名前を入力します。
ソリューション内の最初のモジュールになるように、好きな開発言語用のモジュールテンプレートを選択します。
モジュールの名前を入力します。コンテナーレジストリ内に一意の名前を選択します。
モジュールのイメージリポジトリの名前を入力します。 Visual Studio Code では、モジュール名に localhost:5000/< モジュール名>が自動的に入力されます。独自のレジストリ情報に置き換えます。テストにローカル Docker レジストリを使用する場合は、 localhost を使用します。 Azure Container Registry を使用する場合は、レジストリの設定から ログインサーバー を使用します。サインインサーバーは、<registry name>.azurecr.io のようになります。 localhost:5000部分のみを置き換えて、最終結果が<registry name>.azurecr.io/<あなたのモジュール名>のように見えるようにします。

Visual Studio Code は、指定された情報を取得し、IoT Edge ソリューションを作成して、それを新しいウィンドウに読み込みます。

ソリューションを作成すると、次のメインファイルがソリューションに含まれます。

.vscode フォルダーには、構成ファイルlaunch.jsonが含まれています。
modules フォルダーには、各モジュールのサブフォルダーがあります。各サブフォルダーでは、module.json ファイルによってモジュールのビルドとデプロイ方法が制御されます。
.env ファイルには、環境変数が一覧表示されます。コンテナーレジストリの環境変数は、既定では localhost:5000 です。
deployment.template.json と deployment.debug.template.jsonの 2 つのモジュール展開ファイルに、デバイスにデプロイするモジュールが一覧表示されます。既定では、一覧には IoT Edge システムモジュール (edgeAgent と edgeHub) と次のようなサンプルモジュールが含まれます。
- filtermodule は、単純なフィルター関数を実装するサンプルモジュールです。
- SimulatedTemperatureSensor モジュールは、テストに使用できるデータをシミュレートします。配置マニフェストのしくみの詳細については、「配置マニフェストを使用してモジュールを配置し、ルートを確立する方法」を参照してください。シミュレートされた温度モジュールのしくみの詳細については、 SimulatedTemperatureSensor.csproj ソースコードを参照してください。
注意

インストールされる正確なモジュールは、選択した言語によって異なります。

IoT Edge ランタイムバージョンを設定する

最新の安定した IoT Edge システムモジュールのバージョンは 1.5 です。システムモジュールをバージョン 1.5 に設定します。

Visual Studio Code で、配置マニフェストファイル deployment.template.json 開きます。配置マニフェストは、ターゲット IoT Edge デバイスで構成するモジュールについて説明する JSON ドキュメントです。
システムランタイムモジュールイメージ edgeAgent と edgeHub のランタイムバージョンを変更します。たとえば、IoT Edge ランタイムバージョン 1.5 を使用する場合は、配置マニフェストファイルで次の行を変更します。
```
"systemModules": {
    "edgeAgent": {

        "image": "mcr.microsoft.com/azureiotedge-agent:1.5",

    "edgeHub": {

        "image": "mcr.microsoft.com/azureiotedge-hub:1.5",
```

レジストリの資格情報を IoT Edge エージェントに提供する

コンテナーレジストリの資格情報は、環境ファイルに格納され、IoT Edge ランタイムと共有されます。コンテナーイメージを IoT Edge デバイスにプルするには、ランタイムにこれらの資格情報が必要です。

IoT Edge 拡張機能は、Azure からコンテナーレジストリの資格情報をプルし、それらを環境ファイルに取り込もうとします。

注意

環境ファイルは、モジュールのイメージリポジトリを指定した場合にのみ作成されます。 localhost の既定値を受け入れてローカルでテストおよびデバッグする場合は、環境変数を宣言する必要はありません。

資格情報が存在するかどうかを確認します。含まれていない場合は、次のようにして追加します。

レジストリが Azure Container Registry の場合、Azure Container Registry のユーザー名とパスワードを設定します。これらの値は、Azure portal のコンテナーレジストリの >] メニューから取得します。
モジュールソリューションで .env ファイルを開きます。
Azure コンテナーレジストリからコピーした ユーザー名 と パスワード の値を追加します。次に例を示します。
```
CONTAINER_REGISTRY_SERVER="myacr.azurecr.io"
CONTAINER_REGISTRY_USERNAME="myacr"
CONTAINER_REGISTRY_PASSWORD="<registry_password>"
```
変更を .env ファイルに保存します。

注意

このチュートリアルでは、開発とテストのシナリオに便利な Azure Container Registry の管理者資格情報を使用します。運用環境のシナリオに向けて準備ができたら、サービスプリンシパルやリポジトリスコープトークンのような最小特権の認証オプションを使用することをお勧めします。詳細については、「コンテナーレジストリへのアクセスの管理」を参照してください。

ターゲットアーキテクチャ

コンテナーのビルドと実行方法に影響するため、各ソリューションを対象とするアーキテクチャを選択します。既定値は Linux AMD64 です。このチュートリアルでは、IoT Edge デバイスとして Ubuntu 仮想マシンを使用し、既定の amd64 をそのまま使用します。

ソリューションのターゲットアーキテクチャを変更する必要がある場合は、次の手順に従います。

コマンドパレットを開き、「 Azure IoT Edge: Edge ソリューションの既定のターゲットプラットフォームを設定する」を検索するか、ウィンドウの下部にあるサイドバーにあるショートカットアイコンを選択します。
コマンドパレットで、オプションの一覧からターゲットアーキテクチャを選択します。

C#
C、Java、Node.js、Python

ターゲットアーキテクチャは、後の手順でコンテナーイメージを作成するときに設定されます。

ソリューションの .vscode ディレクトリで settings.json を開くか作成します。
プラットフォームの値をamd64、arm32v7、arm64v8、またはwindows-amd64に変更します。次に例を示します。
```
{
    "azure-iot-edge.defaultPlatform": {
        "platform": "amd64",
        "alias": null
    }
}
```

カスタムコードでモジュールを更新する

各テンプレートには、 SimulatedTemperatureSensor モジュールからシミュレートされたセンサーデータを取得し、それを IoT Hub にルーティングするサンプルコードが含まれています。サンプルモジュールは、メッセージを受信して渡します。パイプライン機能は、IoT Edge における重要な概念である、モジュールが相互に通信する方法を示しています。

各モジュールは、コード内で複数の入力キューと出力キューを宣言できます。デバイスで実行されている IoT Edge ハブは、1 つのモジュールの出力から 1 つ以上のモジュールの入力にメッセージをルーティングします。入力と出力を宣言するための特定のコードは言語によって異なりますが、概念はすべてのモジュールで同じです。モジュール間のルーティングの詳細については、「ルートの宣言」を参照してください。

プロジェクトテンプレートに付属するサンプル C# コードでは、IoT Hub SDK for .NET の ModuleClient クラスを使用します。

Visual Studio Code エクスプローラーで、 モジュール>filtermodule>ModuleBackgroundService.csを開きます。

filtermodule 名前空間の前に、後で使用する型に対して 3 つの using ステートメントを追加します。

using System.Collections.Generic;     // For KeyValuePair<>
using Microsoft.Azure.Devices.Shared; // For TwinCollection
using Newtonsoft.Json;                // For JsonConvert

temperatureThreshold 変数を ModuleBackgroundService クラスに追加します。この変数は、IoT Hub にデータを送信するために測定温度が超える必要がある値を設定します。
```
static int temperatureThreshold { get; set; } = 25;
```

MessageBody、Machine、Ambient クラスを追加します。これらのクラスは、受信メッセージの本文に対して予期されるスキーマを定義します。

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;}
}

ExecuteAsync 関数を見つけます。この関数は、モジュールがローカルの Azure IoT Edge ランタイムに接続してメッセージを送受信できるようにする ModuleClient オブジェクトを作成して構成します。 ModuleClient を作成した後、コードはモジュールツインの必要なプロパティから temperatureThreshold 値を読み取ります。このコードは、 input1 というエンドポイントを介して IoT Edge ハブからメッセージを受信するコールバックを登録します。

ProcessMessageAsync メソッドの呼び出しを、エンドポイントの名前と入力が到着したときに呼び出されるメソッドを更新する新しいメソッドに置き換えます。また、必要なプロパティを更新するための SetDesiredPropertyUpdateCallbackAsync メソッドを追加します。この変更を行うには、ExecuteAsync メソッドの最後の行を次のコードに置き換えます。
```
// Register a callback for messages that are received by the module.
// await _moduleClient.SetInputMessageHandlerAsync("input1", PipeMessage, cancellationToken);

// Read the TemperatureThreshold value from the module twin's desired properties
var moduleTwin = await _moduleClient.GetTwinAsync();
await OnDesiredPropertiesUpdate(moduleTwin.Properties.Desired, _moduleClient);

// Attach a callback for updates to the module twin's desired properties.
await _moduleClient.SetDesiredPropertyUpdateCallbackAsync(OnDesiredPropertiesUpdate, null);

// Register a callback for messages that are received by the module. Messages received on the inputFromSensor endpoint are sent to the FilterMessages method.
await _moduleClient.SetInputMessageHandlerAsync("inputFromSensor", FilterMessages, _moduleClient);
```

OnDesiredPropertiesUpdate メソッドを ModuleBackgroundService クラスに追加します。このメソッドは、モジュールツインから必要なプロパティの更新を受け取り、 temperatureThreshold 変数を一致するように更新します。すべてのモジュールに独自のモジュールツインがあり、これにより、モジュール内で実行されているコードをクラウドから直接構成できます。

static Task OnDesiredPropertiesUpdate(TwinCollection desiredProperties, object userContext)
{
    try
    {
        Console.WriteLine("Desired property change:");
        Console.WriteLine(JsonConvert.SerializeObject(desiredProperties));

        if (desiredProperties["TemperatureThreshold"]!=null)
            temperatureThreshold = desiredProperties["TemperatureThreshold"];

    }
    catch (AggregateException ex)
    {
        foreach (Exception exception in ex.InnerExceptions)
        {
            Console.WriteLine();
            Console.WriteLine("Error when receiving desired property: {0}", exception);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine();
        Console.WriteLine("Error when receiving desired property: {0}", ex.Message);
    }
    return Task.CompletedTask;
}

FilterMessages メソッドを追加します。このメソッドは、モジュールが IoT Edge ハブからメッセージを受け取るたびに呼び出されます。これにより、モジュールツインで設定されているしきい値を下回る温度を報告するメッセージは除外されます。また、値が Alert に設定された MessageType プロパティをメッセージに追加 します。

async Task<MessageResponse> FilterMessages(Message message, object userContext)
{
    var counterValue = Interlocked.Increment(ref _counter);
    try
    {
        ModuleClient moduleClient = (ModuleClient)userContext;
        var messageBytes = message.GetBytes();
        var messageString = Encoding.UTF8.GetString(messageBytes);
        Console.WriteLine($"Received message {counterValue}: [{messageString}]");

        // Get the message body.
        var messageBody = JsonConvert.DeserializeObject<MessageBody>(messageString);

        if (messageBody != null && messageBody.machine.temperature > temperatureThreshold)
        {
            Console.WriteLine($"Machine temperature {messageBody.machine.temperature} " +
                $"exceeds threshold {temperatureThreshold}");
            using (var filteredMessage = new Message(messageBytes))
            {
                foreach (KeyValuePair<string, string> prop in message.Properties)
                {
                    filteredMessage.Properties.Add(prop.Key, prop.Value);
                }

                filteredMessage.Properties.Add("MessageType", "Alert");
                await moduleClient.SendEventAsync("output1", filteredMessage);
            }
        }

        // Indicate that the message treatment is completed.
        return MessageResponse.Completed;
    }
    catch (AggregateException ex)
    {
        foreach (Exception exception in ex.InnerExceptions)
        {
            Console.WriteLine();
            Console.WriteLine("Error in sample: {0}", exception);
        }
        // Indicate that the message treatment is not completed.
        var moduleClient = (ModuleClient)userContext;
        return MessageResponse.Abandoned;
    }
    catch (Exception ex)
    {
        Console.WriteLine();
        Console.WriteLine("Error in sample: {0}", ex.Message);
        // Indicate that the message treatment is not completed.
        ModuleClient moduleClient = (ModuleClient)userContext;
        return MessageResponse.Abandoned;
    }
}

ModuleBackgroundService.cs ファイルを保存します。
Visual Studio Code エクスプローラーで、IoT Edge ソリューションワークスペースの deployment.template.json ファイルを開きます。
モジュールがリッスンするエンドポイントの名前を変更したので、配置マニフェスト内のルートも、"edgeHub" が新しいエンドポイントにメッセージを送信するように更新する必要があります。

$edgeHub モジュールツインでルート セクションを見つけます。 sensorTofiltermodule ルートを更新して、input1をinputFromSensorに置き換えます。
```
"sensorTofiltermodule": "FROM /messages/modules/tempSensor/outputs/temperatureOutput INTO BrokeredEndpoint(\"/modules/filtermodule/inputs/inputFromSensor\")"
```
配置マニフェストに filtermodule モジュールツインを追加します。 modulesContent セクションの下部に、$edgeHub モジュールツインの後に次の JSON コンテンツを挿入します。
```
   "filtermodule": {
       "properties.desired":{
           "TemperatureThreshold":25
       }
   }
```
deployment.template.json ファイルを保存します。

このシナリオでは、センサーからのデータは JSON 形式で提供されます。 JSON 形式のメッセージをフィルター処理するには、C 用の JSON ライブラリをインポートします。このチュートリアルでは、Parson を使用します。
1. Parson GitHub リポジトリをダウンロードします。 parson.c ファイルと parson.h ファイルを filtermodule フォルダーにコピーします。
2. > >を開きます。ファイルの上部で、Parson ファイルを my_parson というライブラリとしてインポートします。
```
add_library(my_parson
    parson.c
    parson.h
)
```
3. CMakeLists.txtのtarget_link_libraries関数のライブラリの一覧にmy_parsonを追加します。
4. CMakeLists.txt ファイルを保存します。
5. モジュール>filtermodule>main.c を開きます。 include ステートメントの一覧の一番下に、JSON サポート用の parson.h をインクルードするための新しいステートメントを追加します。
```
#include "parson.h"
```
main.c ファイルで、include セクションの後に temperatureThreshold というグローバル変数を追加します。この変数により、データが IoT Hub に送信される基準値が設定されます。データは、測定温度がこの値を超えると送信されます。
```
static double temperatureThreshold = 25;
```
main.c で CreateMessageInstance 関数を探します。内部の if-else ステートメントを、数行の機能を追加する次のコードに置き換えます。
```
    if ((messageInstance->messageHandle = IoTHubMessage_Clone(message)) == NULL)
    {
        free(messageInstance);
        messageInstance = NULL;
    }
    else
    {
        messageInstance->messageTrackingId = messagesReceivedByInput1Queue;
        MAP_HANDLE propMap = IoTHubMessage_Properties(messageInstance->messageHandle);
        if (Map_AddOrUpdate(propMap, "MessageType", "Alert") != MAP_OK)
        {
           printf("ERROR: Map_AddOrUpdate Failed!\r\n");
        }
    }
```
else ステートメント内の新しいコード行は、メッセージに新しいプロパティを追加し、これによりメッセージにアラートのラベルが付けられます。高温を報告する場合に IoT Hub に単にメッセージを送信する機能を追加するため、このコードはすべてのメッセージにアラートのラベルを付けます。

InputQueue1Callback 関数全体を次のコードに置き換えます。この関数は、実際のメッセージングフィルターを実装します。メッセージを受信すると、報告された温度がしきい値を超えているかどうかが確認されます。そうである場合は、出力キューを介してメッセージが転送されます。そうでない場合、メッセージは無視されます。

static unsigned char *bytearray_to_str(const unsigned char *buffer, size_t len)
{
    unsigned char *ret = (unsigned char *)malloc(len + 1);
    memcpy(ret, buffer, len);
    ret[len] = '\0';
    return ret;
}

static IOTHUBMESSAGE_DISPOSITION_RESULT InputQueue1Callback(IOTHUB_MESSAGE_HANDLE message, void* userContextCallback)
{
    IOTHUBMESSAGE_DISPOSITION_RESULT result;
    IOTHUB_CLIENT_RESULT clientResult;
    IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle = (IOTHUB_MODULE_CLIENT_LL_HANDLE)userContextCallback;

    unsigned const char* messageBody;
    size_t contentSize;

    if (IoTHubMessage_GetByteArray(message, &messageBody, &contentSize) == IOTHUB_MESSAGE_OK)
    {
        messageBody = bytearray_to_str(messageBody, contentSize);
    } else
    {
        messageBody = "<null>";
    }

    printf("Received Message [%zu]\r\n Data: [%s]\r\n",
            messagesReceivedByInput1Queue, messageBody);

    // Check if the message reports temperatures higher than the threshold
    JSON_Value *root_value = json_parse_string(messageBody);
    JSON_Object *root_object = json_value_get_object(root_value);
    double temperature;
    if (json_object_dotget_value(root_object, "machine.temperature") != NULL && (temperature = json_object_dotget_number(root_object, "machine.temperature")) > temperatureThreshold)
    {
        printf("Machine temperature %f exceeds threshold %f\r\n", temperature, temperatureThreshold);
        // This message should be sent to next stop in the pipeline, namely "output1".  What happens at "output1" is determined
        // by the configuration of the Edge routing table setup.
        MESSAGE_INSTANCE *messageInstance = CreateMessageInstance(message);
        if (NULL == messageInstance)
        {
            result = IOTHUBMESSAGE_ABANDONED;
        }
        else
        {
            printf("Sending message (%zu) to the next stage in pipeline\n", messagesReceivedByInput1Queue);

            clientResult = IoTHubModuleClient_LL_SendEventToOutputAsync(iotHubModuleClientHandle, messageInstance->messageHandle, "output1", SendConfirmationCallback, (void *)messageInstance);
            if (clientResult != IOTHUB_CLIENT_OK)
            {
                IoTHubMessage_Destroy(messageInstance->messageHandle);
                free(messageInstance);
                printf("IoTHubModuleClient_LL_SendEventToOutputAsync failed on sending msg#=%zu, err=%d\n", messagesReceivedByInput1Queue, clientResult);
                result = IOTHUBMESSAGE_ABANDONED;
            }
            else
            {
                result = IOTHUBMESSAGE_ACCEPTED;
            }
        }
    }
    else
    {
        printf("Not sending message (%zu) to the next stage in pipeline.\r\n", messagesReceivedByInput1Queue);
        result = IOTHUBMESSAGE_ACCEPTED;
    }

    messagesReceivedByInput1Queue++;
    return result;
}

moduleTwinCallback 関数を追加します。このメソッドは、モジュールツインから必要なプロパティの更新を受け取り、 temperatureThreshold 変数を一致するように更新します。すべてのモジュールに独自のモジュールツインがあり、これにより、モジュール内で実行されているコードをクラウドから直接構成できます。

static void moduleTwinCallback(DEVICE_TWIN_UPDATE_STATE update_state, const unsigned char* payLoad, size_t size, void* userContextCallback)
{
    printf("\r\nTwin callback called with (state=%s, size=%zu):\r\n%s\r\n",
        MU_ENUM_TO_STRING(DEVICE_TWIN_UPDATE_STATE, update_state), size, payLoad);
    JSON_Value *root_value = json_parse_string(payLoad);
    JSON_Object *root_object = json_value_get_object(root_value);
    if (json_object_dotget_value(root_object, "desired.TemperatureThreshold") != NULL) {
        temperatureThreshold = json_object_dotget_number(root_object, "desired.TemperatureThreshold");
    }
    if (json_object_get_value(root_object, "TemperatureThreshold") != NULL) {
        temperatureThreshold = json_object_get_number(root_object, "TemperatureThreshold");
    }
}

SetupCallbacksForModule 関数を検索します。関数を、モジュールツインが更新されているかどうかを確認する else if ステートメントを追加する次のコードに置き換えます。

static int SetupCallbacksForModule(IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle)
{
    int ret;

    if (IoTHubModuleClient_LL_SetInputMessageCallback(iotHubModuleClientHandle, "input1", InputQueue1Callback, (void*)iotHubModuleClientHandle) != IOTHUB_CLIENT_OK)
    {
        printf("ERROR: IoTHubModuleClient_LL_SetInputMessageCallback(\"input1\")..........FAILED!\r\n");
        ret = MU_FAILURE;
    }
    else if (IoTHubModuleClient_LL_SetModuleTwinCallback(iotHubModuleClientHandle, moduleTwinCallback, (void*)iotHubModuleClientHandle) != IOTHUB_CLIENT_OK)
    {
        printf("ERROR: IoTHubModuleClient_LL_SetModuleTwinCallback(default)..........FAILED!\r\n");
        ret = MU_FAILURE;
    }
    else
    {
        ret = 0;
    }

    return ret;
}

main.c ファイルを保存します。
Visual Studio Code エクスプローラーで、IoT Edge ソリューションワークスペースの deployment.template.json ファイルを開きます。
filtermodule モジュールツインを配置マニフェストに追加します。次の JSON コンテンツを moduleContent セクションの下部、$edgeHub モジュールツインの後に挿入します。
```
"filtermodule": {
    "properties.desired":{
        "TemperatureThreshold":25
    }
}
```
deployment.template.json ファイルを保存します。

Visual Studio Code エクスプローラーで、 モジュール>filtermodule>src>main>java>com>edgemodule>App.java を開きます。

新しい参照先クラスをインポートするための次のコードをファイルの先頭に追加します。

import java.io.StringReader;
import java.util.concurrent.atomic.AtomicLong;
import java.util.HashMap;
import java.util.Map;

import javax.json.Json;
import javax.json.JsonObject;
import javax.json.JsonReader;

import com.microsoft.azure.sdk.iot.device.DeviceTwin.Pair;
import com.microsoft.azure.sdk.iot.device.DeviceTwin.Property;
import com.microsoft.azure.sdk.iot.device.DeviceTwin.TwinPropertyCallBack;

次の定義を App クラスに追加します。この変数は、温度のしきい値を設定します。測定されたマシンの温度は、この値を超えるまで IoT Hub に報告されません。
```
private static final String TEMP_THRESHOLD = "TemperatureThreshold";
private static AtomicLong tempThreshold = new AtomicLong(25);
```

MessageCallbackMqtt の execute メソッドを次のコードに置き換えます。このメソッドは、モジュールが IoT Edge ハブから MQTT メッセージを受け取るたびに呼び出されます。これにより、モジュールツインで設定されているしきい値を下回る温度を報告するメッセージは除外されます。

protected static class MessageCallbackMqtt implements MessageCallback {
    private int counter = 0;
    @Override
    public IotHubMessageResult execute(Message msg, Object context) {
        this.counter += 1;

        String msgString = new String(msg.getBytes(), Message.DEFAULT_IOTHUB_MESSAGE_CHARSET);
        System.out.println(
               String.format("Received message %d: %s",
                        this.counter, msgString));
        if (context instanceof ModuleClient) {
            try (JsonReader jsonReader = Json.createReader(new StringReader(msgString))) {
                final JsonObject msgObject = jsonReader.readObject();
                double temperature = msgObject.getJsonObject("machine").getJsonNumber("temperature").doubleValue();
                long threshold = App.tempThreshold.get();
                if (temperature >= threshold) {
                    ModuleClient client = (ModuleClient) context;
                    System.out.println(
                        String.format("Temperature above threshold %d. Sending message: %s",
                        threshold, msgString));
                    client.sendEventAsync(msg, eventCallback, msg, App.OUTPUT_NAME);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return IotHubMessageResult.COMPLETE;
    }
}

次の 2 つの静的内部クラス を App クラスに追加します。モジュールツインの desired プロパティが変化すると、これらのクラスによって tempThreshold 変数が更新されます。すべてのモジュールに独自のモジュールツインがあり、これにより、モジュール内で実行されているコードをクラウドから直接構成できます。

protected static class DeviceTwinStatusCallBack implements IotHubEventCallback {
    @Override
    public void execute(IotHubStatusCode status, Object context) {
        System.out.println("IoT Hub responded to device twin operation with status " + status.name());
    }
}

protected static class OnProperty implements TwinPropertyCallBack {
    @Override
    public void TwinPropertyCallBack(Property property, Object context) {
        if (!property.getIsReported()) {
            if (property.getKey().equals(App.TEMP_THRESHOLD)) {
                try {
                    long threshold = Math.round((double) property.getValue());
                    App.tempThreshold.set(threshold);
                } catch (Exception e) {
                    System.out.println("Failed to set TemperatureThread with exception");
                    e.printStackTrace();
                }
            }
        }
    }
}

client.open() の後に main メソッドに次の行を追加して、モジュールツインの更新をサブスクライブします。

client.startTwin(new DeviceTwinStatusCallBack(), null, new OnProperty(), null);
Map<Property, Pair<TwinPropertyCallBack, Object>> onDesiredPropertyChange = new HashMap<Property, Pair<TwinPropertyCallBack, Object>>() {
    {
        put(new Property(App.TEMP_THRESHOLD, null), new Pair<TwinPropertyCallBack, Object>(new OnProperty(), null));
    }
};
client.subscribeToTwinDesiredProperties(onDesiredPropertyChange);
client.getTwin();

App.java ファイルを保存します。
Visual Studio Code エクスプローラーで、IoT Edge ソリューションワークスペースの deployment.template.json ファイルを開きます。
配置マニフェストに filtermodule モジュールツインを追加します。 $edgeHub モジュールツインの後の moduleContent セクションの下部に、次の JSON コンテンツを挿入します。
```
  "filtermodule": {
      "properties.desired":{
          "TemperatureThreshold":25
      }
  }
```
deployment.template.json ファイルを保存します。

Visual Studio Code エクスプローラーで、 モジュール>filtermodule>app.jsを開きます。
温度しきい値変数を "app.js" の先頭に追加します。温度のしきい値により、データが IoT Hub に送信される基準値が設定されます。データは、測定温度がこの値を超えると送信されます。
```
var temperatureThreshold = 25;
```

PipeMessage 関数全体を FilterMessage 関数に置き換えます。

// This function filters out messages that report temperatures below the temperature threshold.
// It also adds the MessageType property to the message with the value set to Alert.
function filterMessage(client, inputName, msg) {
    client.complete(msg, printResultFor('Receiving message'));
    if (inputName === 'input1') {
        var message = msg.getBytes().toString('utf8');
        var messageBody = JSON.parse(message);
        if (messageBody && messageBody.machine && messageBody.machine.temperature && messageBody.machine.temperature > temperatureThreshold) {
            console.log(`Machine temperature ${messageBody.machine.temperature} exceeds threshold ${temperatureThreshold}`);
            var outputMsg = new Message(message);
            outputMsg.properties.add('MessageType', 'Alert');
            client.sendOutputEvent('output1', outputMsg, printResultFor('Sending received message'));
        }
    }
}

pipeMessage 呼び出しで関数名 filterMessage を client.on() に置き換えます。

client.on('inputMessage', function (inputName, msg) {
    filterMessage(client, inputName, msg);
    });

次のコードスニペットを、client.open() の後、client.on() ステートメント内にある else 関数コールバックにコピーします。この関数は、必要なプロパティが更新されたときに呼び出されます。

client.getTwin(function (err, twin) {
    if (err) {
        console.error('Error getting twin: ' + err.message);
    } else {
        twin.on('properties.desired', function(delta) {
            if (delta.TemperatureThreshold) {
                temperatureThreshold = delta.TemperatureThreshold;
            }
        });
    }
});

app.js ファイルを保存します。
Visual Studio Code エクスプローラーで、IoT Edge ソリューションワークスペースの deployment.template.json ファイルを開きます。
filtermodule モジュールツインを配置マニフェストに追加します。次の JSON コンテンツを moduleContent セクションの下部、$edgeHub モジュールツインの後に挿入します。
```
  "filtermodule": {
      "properties.desired":{
          "TemperatureThreshold":25
      }
  }
```
deployment.template.json ファイルを保存します。

このセクションでは、メッセージを送信する前にメッセージを分析するために filtermodule を展開するコードを追加します。報告されたマシン温度が許容範囲内にあるメッセージをフィルター処理するコードを追加します。

Visual Studio Code エクスプローラーで、 モジュール>filtermodule>main.py を開きます。
main.py ファイルの先頭に json ライブラリをインポートします。
```
import json
```
TEMPERATURE_THRESHOLD、RECEIVED_MESSAGES、およびTWIN_CALLBACKS変数のグローバル定義を追加します。温度のしきい値は、IoT Hub にデータを送信するために測定されたマシンの温度が超える必要がある値を設定します。
```
# global counters
TEMPERATURE_THRESHOLD = 25
TWIN_CALLBACKS = 0
RECEIVED_MESSAGES = 0
```

create_client関数を次のコードに置き換えます。

def create_client():
    client = IoTHubModuleClient.create_from_edge_environment()

    # Define function for handling received messages
    async def receive_message_handler(message):
        global RECEIVED_MESSAGES
        print("Message received")
        size = len(message.data)
        message_text = message.data.decode('utf-8')
        print("    Data: <<<{data}>>> & Size={size}".format(data=message.data, size=size))
        print("    Properties: {}".format(message.custom_properties))
        RECEIVED_MESSAGES += 1
        print("Total messages received: {}".format(RECEIVED_MESSAGES))

        if message.input_name == "input1":
            message_json = json.loads(message_text)
            if "machine" in message_json and "temperature" in message_json["machine"] and message_json["machine"]["temperature"] > TEMPERATURE_THRESHOLD:
                message.custom_properties["MessageType"] = "Alert"
                print("ALERT: Machine temperature {temp} exceeds threshold {threshold}".format(
                    temp=message_json["machine"]["temperature"], threshold=TEMPERATURE_THRESHOLD
                ))
                await client.send_message_to_output(message, "output1")

    # Define function for handling received twin patches
    async def receive_twin_patch_handler(twin_patch):
        global TEMPERATURE_THRESHOLD
        global TWIN_CALLBACKS
        print("Twin Patch received")
        print("     {}".format(twin_patch))
        if "TemperatureThreshold" in twin_patch:
            TEMPERATURE_THRESHOLD = twin_patch["TemperatureThreshold"]
        TWIN_CALLBACKS += 1
        print("Total calls confirmed: {}".format(TWIN_CALLBACKS))

    try:
        # Set handler on the client
        client.on_message_received = receive_message_handler
        client.on_twin_desired_properties_patch_received = receive_twin_patch_handler
    except:
        # Cleanup if failure occurs
        client.shutdown()
        raise

    return client

main.py ファイルを保存します。
Visual Studio Code エクスプローラーで、IoT Edge ソリューションワークスペースの deployment.template.json ファイルを開きます。
配置マニフェストに filtermodule モジュールツインを追加します。 modulesContent セクションの下部に、$edgeHub モジュールツインの後に次の JSON コンテンツを挿入します。
```
    "filtermodule": {
        "properties.desired":{
            "TemperatureThreshold":25
        }
    }
```
deployment.template.json ファイルを保存します。

ソリューションをビルドしてプッシュする

いくつかの主要なデプロイ概念を理解できるように、モジュールコードと展開テンプレートを更新しました。次に、モジュールコンテナーイメージをビルドして、コンテナーレジストリにプッシュします。

Visual Studio Code で、 deployment.template.json 配置マニフェストファイルを開きます。配置マニフェストでは、対象の IoT Edge デバイスで構成するモジュールについて説明します。デプロイの前に、Azure Container Registry 資格情報とモジュールイメージを適切な createOptions の値で更新する必要があります。 createOption 値の詳細については、「 IoT Edge モジュールのコンテナー作成オプションを構成する方法」を参照してください。

Azure Container Registry を使用してモジュールイメージを格納する場合は、deployment.template.jsonの modulesContent>edgeAgent>settings>registryCredentials セクションに資格情報 を追加します。 myacr を独自のレジストリ名に置き換え、パスワードとログインサーバー アドレスを指定します。次に例を示します。

"registryCredentials": {
    "myacr": {
        "username": "myacr",
        "password": "<your_acr_password>",
        "address": "myacr.azurecr.io"
    }
}

一覧表示されているシステム (edgeHub と edgeAgent) とカスタムモジュール (filtermodule と tempSensor) ごとに、次の文字列化されたコンテンツを "createOptions" の値に追加するか置き換えます。必要に応じて、値を変更します。

"createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"

たとえば、 filtermodule の構成は次のようになります。

"filtermodule": {
"version": "1.0",
"type": "docker",
"status": "running",
"restartPolicy": "always",
"settings": {
   "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
   "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
}

モジュールの Docker イメージをビルドする

ターミナル>新しいターミナルを選択して、Visual Studio Code 統合ターミナルを開きます。

C#
C、Java、Node.js、Python

dotnet publish コマンドを使って、Linux および amd64 アーキテクチャ用のコンテナーイメージをビルドします。プロジェクトの filtermodule ディレクトリにディレクトリを変更し、 dotnet publish コマンドを実行します。

dotnet publish --os linux --arch x64 /t:PublishContainer

現在、 iotedgedev ツールテンプレートは .NET 7.0 を対象としています。別のバージョンの .NET をターゲットにする場合は、 filtermodule.csproj ファイルを編集し、 TargetFramework と PackageReference の値を変更できます。たとえば、.NET 8.0 をターゲットにするには、 filtermodule.csproj ファイルは次のようになります。

<Project Sdk="Microsoft.NET.Sdk.Worker">
    <PropertyGroup>
        <TargetFramework>net8.0</TargetFramework>
        <Nullable>enable</Nullable>
        <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Microsoft.Azure.Devices.Client" Version="1.42.0" />
        <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
    </ItemGroup>
</Project>

コンテナーレジストリ情報、バージョン、アーキテクチャで Docker イメージにタグを付けます。 myacr を独自のレジストリ名に置き換えます。

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.1-amd64

モジュールの Dockerfile を使用して、モジュールの Docker イメージをビルドしてタグ付けします。

docker build --rm -f "<DockerFilePath>" -t <ImageNameAndTag> "<ContextPath>"

たとえば、ローカルレジストリまたは Azure コンテナーレジストリのイメージをビルドするには、次のコマンドを使用します。

# Build and tag the image for the local registry

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t localhost:5000/filtermodule:0.0.1-amd64 "./modules/filtermodule"

# Or build and tag the image for an Azure Container Registry. Replace myacr with your own registry name.

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t myacr.azurecr.io/filtermodule:0.0.1-amd64 "./modules/filtermodule"

モジュールの Docker イメージをプッシュする

コンテナーイメージをレジストリ内のストレージにプッシュできるように、Docker にコンテナーレジステリの資格情報を提供します。

Azure Container Registry (ACR) 資格情報を使って Docker にサインインします。
```
docker login -u <ACR username> -p <ACR password> <ACR login server>
```
--password-stdin の使用を推奨するセキュリティ警告が表示される場合があります。これは運用環境のシナリオでの推奨されているベストプラクティスですが、このチュートリアルの範囲外になります。詳細については、 Docker ログインリファレンスを参照してください。
Azure Container Registry にサインインします。コマンドを使用するには、azする必要があります。このコマンドは 、設定>Access キーのコンテナーレジストリで見つかったユーザー名とパスワードを要求します。
```
az acr login -n <ACR registry name>
```
ヒント

このチュートリアルの任意の時点でログアウトした場合、Docker および Azure Container Registry のサインインステップを繰り返して続行します。

モジュールイメージをローカルレジストリまたはコンテナーレジストリにプッシュします。

docker push <ImageName>

次に例を示します。

# Push the Docker image to the local registry

docker push localhost:5000/filtermodule:0.0.1-amd64

# Or push the Docker image to an Azure Container Registry. Replace myacr with your Azure Container Registry name.

az acr login --name myacr
docker push myacr.azurecr.io/filtermodule:0.0.1-amd64

デプロイテンプレートを更新する

デプロイテンプレート "deployment.template.json" をコンテナーレジストリイメージの場所で更新します。たとえば、Azure Container Registry "myacr.azurecr.io" を使用していて、イメージが "filtermodule:0.0.1-amd64" の場合は、"filtermodule" 構成を次のように更新します。

"filtermodule": {
    "version": "1.0",
    "type": "docker",
    "status": "running",
    "restartPolicy": "always",
    "settings": {
        "image": "myacr.azurecr.io/filtermodule:0.0.1-amd64",
        "createOptions": "{\"HostConfig\":{\"PortBindings\":{\"5671/tcp\":[{\"HostPort\":\"5671\"}],\"8883/tcp\":[{\"HostPort\":\"8883\"}],\"443/tcp\":[{\"HostPort\":\"443\"}]}}}"
    }
}

Visual Studio Code エクスプローラーで、 deployment.template.json ファイルを右クリックし、[ IoT Edge ソリューションのビルドとプッシュ] を選択します。

ビルドおよびプッシュコマンドでは、3 つの操作を開始します。最初に、ソリューションに config という名前の新しいフォルダーを作成します。このフォルダーには、配置テンプレートやその他のソリューションファイルの情報から構築された完全な配置マニフェストが保持されます。次に、docker build を実行して、お使いのターゲットアーキテクチャ用の適切な Dockerfile に基づいてコンテナーイメージをビルドします。そして、docker push を実行して、イメージリポジトリをコンテナーレジストリにプッシュします。

このプロセスは、初回は数分間かかる可能性がありますが、次回これらのコマンドを実行するときは、それより速くなります。

省略可能: モジュールとイメージを更新する

モジュールコードを変更する場合は、モジュールイメージをリビルドしてコンテナーレジストリにプッシュする必要があります。このセクションの手順を使って、ビルドとコンテナーイメージを更新します。モジュールコードを変更しなかった場合は、このセクションをスキップできます。

新しく作成した config フォルダーで deployment.amd64.json ファイルを開きます。このファイル名はターゲットアーキテクチャを反映しているため、別のアーキテクチャを選択した場合は別の名前になります。

プレースホルダーがある 2 つのパラメーターに、適切な値が入れられていることに注意してください。 registryCredentials セクションには、レジストリユーザー名とパスワードが .env ファイルからプルされています。 filtermodule には、module.json ファイルの名前、バージョン、およびアーキテクチャタグを含む完全なイメージリポジトリがあります。

filtermodule フォルダー内の module.json ファイルを開きます。
モジュールイメージのバージョン番号を変更します。たとえば、モジュールコードで軽微な修正を行ったかのように、パッチのバージョン番号を "version": "0.0.2" に増分します。

ヒント

モジュールバージョンではバージョン管理が有効であり、実稼働環境に更新プログラムをデプロイする前に、少数のデバイスで変更をテストすることができます。ビルドとプッシュの前にモジュールバージョンを増分しないと、コンテナーレジストリ内のリポジトリが上書きされます。
変更をmodule.json ファイルに保存します。

0.0.2 バージョンタグを使用して、更新されたイメージをビルドしてプッシュします。たとえば、ローカルレジストリまたは Azure コンテナーレジストリのイメージをビルドしてプッシュするには、次のコマンドを使用します:

C#
C、Java、Node.js、Python


# Build the container image for Linux and amd64 architecture.

dotnet publish --os linux --arch x64

# For local registry:
# Tag the image with version 0.0.2, x64 architecture, and the local registry.

docker tag filtermodule localhost:5000/filtermodule:0.0.2-amd64

# For Azure Container Registry:
# Tag the image with version 0.0.2, x64 architecture, and your container registry information. Replace **myacr** with your own registry name.

docker tag filtermodule myacr.azurecr.io/filtermodule:0.0.2-amd64

# Build and push the 0.0.2 image for the local registry

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t localhost:5000/filtermodule:0.0.2-amd64 "./modules/filtermodule"

docker push localhost:5000/filtermodule:0.0.2-amd64

# Or build and push the 0.0.2 image for an Azure Container Registry. Replace myacr with your own registry name.

docker build --rm -f "./modules/filtermodule/Dockerfile.amd64.debug" -t myacr.azurecr.io/filtermodule:0.0.2-amd64 "./modules/filtermodule"

docker push myacr.azurecr.io/filtermodule:0.0.2-amd64

deployment.template.json ファイルをもう一度右クリックし、もう一度 [IoT Edge ソリューションのビルドとプッシュ] を選択します。

deployment.amd64.json ファイルをもう一度開きます。ビルドコマンドとプッシュコマンドをもう一度実行しても、ビルドシステムで新しいファイルが作成されないことに注意してください。代わりに、同じファイルが変更を反映するように更新されます。 "filtermodule" イメージは現在、コンテナーの 0.0.2 バージョンを指しています。

ビルドおよびプッシュコマンドの実行内容をさらに確認するには、 Azure portal に移動し、コンテナーレジストリに移動します。

コンテナーレジストリで、[ リポジトリ ] を選択し、 フィルターモジュールを選択します。イメージの両方のバージョンがレジストリにプッシュされることを確認します。

トラブルシューティング

モジュールイメージをビルドおよびプッシュしているときにエラーが発生する場合は、開発マシン上の Docker 構成に関連していることがよくあります。次のチェックを使用して構成を確認してください。

コンテナーレジストリからコピーした資格情報を使用して docker login コマンドを実行したか。これらの資格情報は、Azure にサインインする際に使用するものとは異なります。
コンテナーリポジトリは正しいか。正しいコンテナーレジストリ名と正しいモジュール名が含まれているか。確認するには、filtermodule フォルダー内の module.json ファイルを開きます。リポジトリの値は、<registry name>.azurecr.io/filtermodule のようになります。
モジュールに filtermodule とは異なる名前を使用した場合、その名前はソリューション全体で一貫していますか?
対象のマシンは、ビルドしているのと同じ種類のコンテナーを実行しているか。このチュートリアルは Linux IoT Edge デバイスを対象としているため、Visual Studio Code ではサイドバーに amd64 または arm32v7 が表示され、Docker Desktop は Linux コンテナーを実行している必要があります。

モジュールをデバイスにデプロイする

ビルドしたコンテナーイメージがコンテナーレジストリに保存されているのを確認したので、次にそれらをデバイスにデプロイします。お使いの IoT Edge デバイスが稼働していることを確認します。

IoT Edge Azure CLI set-modules コマンドを使用して、モジュールを Azure IoT Hub にデプロイします。たとえば、"deployment.template.json" ファイルで定義されているモジュールを、IoT Edge デバイス "my-device" の IoT Hub "my-iot-hub" にデプロイするには、次のコマンドを使用します。 ハブ名、デバイス ID、ログイン IoT Hub 接続文字列の値を独自の値に置き換えます。

az iot edge set-modules --hub-name my-iot-hub --device-id my-device --content ./deployment.template.json --login "HostName=my-iot-hub.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=<SharedAccessKey>"

ヒント

Azure portal で、共有アクセスキーを含む IoT Hub 接続文字列を見つけます。 IoT Hub >セキュリティ設定>共有アクセスポリシー>iothubowner に移動します。

Visual Studio Code エクスプローラーの Azure IoT Hub セクションで、[ デバイス ] を展開して、IoT デバイスの一覧を表示します。
デプロイする IoT Edge デバイスを右クリックし、[ 単一デバイスのデプロイの作成] を選択します。
エクスプローラーで config フォルダーに移動し、 deployment.amd64.json ファイルを選択します。

deployment.template.json ファイルは使用しないでください。これには、コンテナーレジストリ資格情報もモジュールイメージの値も含まれていません。 Linux ARM32 デバイスをターゲットとする場合、配置マニフェストの名前は deployment.arm32v7.json。
デバイスの下で、[ モジュール ] を展開して、デプロイおよび実行中のモジュールの一覧を表示します。 [更新] ボタンを選択します。新しい "tempSensor" と "filtermodule" モジュールがデバイスで実行されていることがわかります。

モジュールが起動するまでに数分かかる場合があります。 IoT Edge ランタイムは、新しい配置マニフェストを受け取り、コンテナーランタイムからモジュールイメージをプルダウンしてから、新しい各モジュールを開始します。

デバイスからのメッセージを表示する

サンプルモジュールコードは、入力キューを介してメッセージを取得し、出力キューを介して送信します。配置マニフェストは、tempSensor から filtermodule にメッセージを送信し、フィルターモジュールから IoT Hub にメッセージを転送するルートを設定します。 Azure IoT Edge と Azure IoT Hub 拡張機能を使用すると、デバイスから IoT Hub に到着したメッセージを確認できます。

Visual Studio Code エクスプローラーで、監視する IoT Edge デバイスを選択し、[ 組み込みイベントエンドポイントの監視の開始] を選択します。
Visual Studio Code の出力ウィンドウを見て、メッセージが IoT Hub に到着することを確認します。

デバイスでの変更を表示する

デバイスで何が起こっているかを確認するには、このセクションのコマンドを使用して、デバイスで実行されている IoT Edge ランタイムとモジュールを調べます。

これらのコマンドは、開発用コンピューターではなく、IoT Edge デバイス用です。 IoT Edge デバイスに仮想マシンを使用している場合は、すぐに接続してください。 Azure で、仮想マシンの概要ページに移動し、[ 接続 ] を選択してセキュリティで保護されたシェル接続にアクセスします。

お使いのデバイスにデプロイされているすべてのモジュールを表示し、それらの状態をチェックします。
```
iotedge list
```
4 つのモジュール (2 つの IoT Edge ランタイムモジュール、 tempSensor、 filtermodule) が表示されます。 4つすべてが「実行中」としてリストされます。
次のように、特定のモジュールのログを検査します。
```
iotedge logs <module name>
```
モジュール名の大文字と小文字は区別されます。

tempSensor ログと filtermodule ログには、処理しているメッセージが表示されます。 edgeAgent モジュールは他のモジュールを起動するため、そのログには配置マニフェストに関する情報が含まれます。モジュールが一覧に表示されていないか、実行されていない場合は、edgeAgent ログでエラーがないか確認します。 edgeHub モジュールは、モジュールと IoT Hub 間の通信を管理します。モジュールが実行されていても、メッセージが IoT Hub に到着しない場合は、edgeHub ログでエラーがないか確認します。

リソースをクリーンアップする

次の推奨記事に進む場合は、作成したリソースと構成を保持し、再利用します。また、同じ IoT Edge デバイスをテストデバイスとして使用し続けることもできます。

それ以外の場合は、課金されないように、この記事で使用したローカル構成と Azure リソースを削除します。

Azure リソースを削除する

Azure のリソースとリソースグループは、削除すると元に戻すことができません。間違ったリソースグループやリソースをうっかり削除しないようにしてください。保持するリソースを含む既存のリソースグループ内に IoT Hub を作成した場合は、リソースグループではなく、IoT Hub リソース自体のみを削除します。

リソースを削除するには、次の手順に従います。

Azure portal にサインインし、[リソースグループ] を選択します。
IoT Edge のテストリソースを含んだリソースグループの名前を選択します。
リソースグループに含まれているリソースの一覧を確認します。それらすべてを削除する場合は、[ リソースグループの削除] を選択できます。一部だけを削除する場合は、削除する各リソースを選択して個別に削除してください。

次のステップ

このチュートリアルでは、開発用コンピューターに Visual Studio Code を設定し、IoT Edge デバイスによって生成された生データをフィルター処理するコードを使用して、最初の IoT Edge モジュールをデプロイします。

次のチュートリアルに進み、Azure IoT Edge を使用して Azure クラウドサービスをデプロイし、エッジでデータを処理および分析する方法について説明します。

Azure IoT Edge モジュール Functions Stream Analytics Custom Vision Service をデバッグする