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

[アーティクル]
04/11/2024

適用対象: IoT Edge 1.4

重要

IoT Edge 1.4 がサポートされているリリースです。以前のリリースの場合は、「IoT Edge を更新する」を参照してください。

このチュートリアルでは、独自のコードを開発して IoT Edge デバイスにデプロイするまでを順を追って説明します。 Azure IoT Edge モジュールを使用して、ビジネスロジックを実装するコードを IoT Edge デバイスに直接展開できます。 Linux デバイスへのコードのデプロイクイックスタートでは、IoT Edge デバイスを作成し、Azure Marketplace からモジュールをデプロイしました。

この記事には、2 つの IoT Edge 開発ツールの手順が含まれています。

"Azure IoT Edge 開発ツール" コマンドライン (CLI)。このツールは開発に適しています。
"Visual Studio Code 用の Azure IoT Edge ツール" 拡張機能。拡張機能はメンテナンスモードになっています。

この記事の冒頭にあるツールセレクターボタンを使用して、ツールのバージョンを選択してください。

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

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

このチュートリアルで作成する IoT Edge モジュールは、デバイスが生成する温度データをフィルター処理します。これは、指定されたしきい値を温度が上回っているときにのみ、メッセージを上流に送信します。エッジでのこの種の分析は、クラウドに送信および保存されるデータ量を削減するうえで役に立ちます。

前提条件

開発マシン:

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

Azure IoT Edge デバイス:

別のデバイスで IoT Edge を実行する必要があります。開発マシンと IoT Edge デバイスのこの区別によって、実際のデプロイシナリオをシミュレーションして異なる概念を区別できるようになります。 Azure に IoT Edge デバイスを作成するための Linux デバイスへのコードのデプロイに関するクイックスタート記事、または IoT Edge 対応 VM をデプロイするための Azure リソーステンプレートを使用します。

クラウドリソース:

Azure の Free レベルまたは Standard レベルの IoT Hub。

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

ヒント

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

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

主要な概念

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

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

ヒント

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

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

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

	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
Languages	C C# Java Node.js Python	C C#
詳細情報	Visual Studio Code 用の Azure IoT Edge	Visual Studio 2019 用の Azure IoT Edge ツール Visual Studio 2022 用の Azure IoT Edge Tools

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

IoT Edge モジュールはコンテナーとしてパッケージ化されるので、それらをビルドおよび管理するためには、開発用コンピューター上に Docker 互換のコンテナー管理システムが必要です。機能のサポートと人気があるため、開発には Docker Desktop をお勧めします。 Windows で Docker デスクトップを使用すると、Linux コンテナーと Windows コンテナーを切り替えて、さまざまな型の IoT Edge デバイス用のモジュールを開発することができます。

次の Docker のドキュメントを使用して、ご使用の開発マシンにインストールします。

Install Docker Desktop for Windows
- Docker Desktop for Windows をインストールするときに、Linux コンテナーを使用するか Windows コンテナーを使用するかを尋ねられます。この決定はいつでも変更できます。このチュートリアルでは、モジュールが Linux デバイスをターゲットとしているので Linux コンテナーを使用します。詳細については、「Switch between Windows and Linux containers」を参照してください。
Install Docker Desktop for Windows
いくつかの Linux プラットフォームでのインストール情報については、「About Docker CE」をお読みください。
- Linux 用 Windows サブシステム (WSL) の場合は、Docker Desktop for Windows をインストールします。

ツールを設定する

IoT Edge ソリューションを作成するための、Python ベースの Azure IoT Edge 開発ツールをインストールします。 2 つのオプションがあります。

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

重要

"Visual Studio Code 用の Azure IoT Edge Tools" 拡張機能は、メンテナンスモードになっています。推奨される開発ツールは、コマンドライン (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 を選択します。
左側のアクティビティバーでアイコンを選択するか、 [表示]>[エクスプローラー] を選択して、Visual Studio Code のエクスプローラーセクションを開きます。
エクスプローラーセクションの下部で、折りたたまれている [Azure IoT Hub Devices](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 で、 [リソースの作成]>[コンテナー]>[コンテナーレジストリ] の順に選択します。

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

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

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

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

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

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

IoT Edge 開発ツールを使用すると、環境変数によって駆動されるコマンドに 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 solution 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 を使用する場合、お使いのレジストリの設定のログインサーバーを使用します。サインインサーバーは <レジストリ名>.azurecr.io のようになります。この文字列の localhost:5000 部分だけを置き換えて、最終的な結果が <レジストリ名>.azurecr.io/<対象のモジュール名> になるようにします。

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

ソリューションの作成後、次のメインファイルがソリューションに含まれます:

.vscode フォルダーには、構成ファイル launch.json が含まれています。
モジュール フォルダーにはモジュールごとのサブフォルダーが含まれています。各モジュールのフォルダー内には 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.4 です。システムモジュールをバージョン 1.4 に設定します。

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

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

    "edgeHub": {

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

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

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

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

Note

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

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

レジストリが Azure Container Registry の場合、Azure Container Registry のユーザー名とパスワードを設定します。 Azure portal のコンテナーレジストリの [設定]> [アクセスキー] メニューからこれらの値を取得します。
モジュールソリューション内の .env ファイルを開きます。

Azure コンテナーレジストリからコピーした username と password の値を追加します。次に例を示します。

CONTAINER_REGISTRY_SERVER="myacr.azurecr.io"
CONTAINER_REGISTRY_USERNAME="myacr"
CONTAINER_REGISTRY_PASSWORD="<registry_password>"

変更内容を .env ファイルに保存します。

注意

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

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

アーキテクチャはコンテナーのビルド方法と実行方法に影響を与えるため、ターゲットにしているアーキテクチャをソリューションごとに選択する必要があります。既定値は Linux AMD64 です。このチュートリアルでは、Ubuntu 仮想マシンを IoT Edge デバイスとして使用するため、既定値の amd64 のままにします。

ソリューションのターゲットアーキテクチャを変更する必要がある場合は、次のステップを使用します。

コマンドパレットを開き、次を検索します: 「Azure IoT Edge: Set Default Target Platform for Edge Solution (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# コードには、.NET 用 IoT Hub SDK の 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 関数を見つけます。この関数では、ModuleClient オブジェクトを作成して構成します。これにより、モジュールはローカルの Azure IoT Edge ランタイムに接続して、メッセージを送受信できるようになります。 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 ハブからメッセージを受け取るたびに呼び出されます。これにより、モジュールツインで設定されているしきい値を下回る温度を報告するメッセージは除外されます。また、MessageType プロパティを、値が Alert に設定されたメッセージに追加します。

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

このシナリオでは、センサーからのデータは JSON 形式で提供されます。 JSON 形式のメッセージをフィルター処理するには、C 用の JSON ライブラリをインポートします。このチュートリアルでは、Parson を使用します。
1. Parson GitHub リポジトリをダウンロードします。 parson.c と parson.h ファイルを filtermodule フォルダーにコピーします。
2. モジュール >filtermodule>CMakeLists.txt を開きます。ファイルの先頭で、my_parson という名前のライブラリとして 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 "outpu1" 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 エクスプローラーで、[modules]>[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 の実行メソッドを次のコードに置き換えます。このメソッドは、モジュールが 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;
    }
}

App クラスに次の 2 つの静的内部クラスを追加します。モジュールツインの 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("Faile 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 モジュールツインを配置マニフェストに追加します。次の JSON コンテンツを moduleContent セクションの下部、 $edgeHub モジュールツインの後に挿入します。
```
  "filtermodule": {
      "properties.desired":{
          "TemperatureThreshold":25
      }
  }
```
deployment.template.json ファイルを保存します。

Visual Studio Code エクスプローラーで、[modules]>[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'));
        }
    }
}

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

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

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

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 エクスプローラーで、[modules]>[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 モジュールツインを配置マニフェストに追加します。次の JSON コンテンツを modulesContent セクションの下部、 $edgeHub モジュールツインの後に挿入します。
```
    "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 login のリファレンスをご覧ください。
Azure Container Registry にサインインします。 az コマンドを使うには、Azure CLI をインストールする必要があります。このコマンドでは、[設定]>[アクセスキー] でのコンテナーレジストリで見つかったユーザー名とパスワードが求められます。
```
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 ファイルを右クリックし、 [Build and Push IoT Edge solution](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 ファイルをもう一度右クリックし、 [Build and Push IoT Edge Solution](IoT Edge ソリューションのビルドとプッシュ) を再度選択します。

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

ビルドおよびプッシュコマンドで何が行われたかをさらに確認するには、Azure portal にアクセスして、コンテナーレジストリに移動します。

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

トラブルシューティング

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

コンテナーレジストリからコピーした資格情報を使用して docker login コマンドを実行したか。これらの資格情報は、Azure にサインインする際に使用するものとは異なります。
コンテナーリポジトリは正しいか。正しいコンテナーレジストリ名と正しいモジュール名が含まれているか。 "filtermodule" フォルダー内の module.json ファイルを確認のために開きます。リポジトリ値は、<レジストリ名>.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" にデプロイするには、次のコマンドを使用します。 hub-name、device-id、login という 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>"

ヒント

IoT Hub 接続文字列は共有アクセスキーを含め、Azure portal にあります。 [IoT Hub]>[セキュリティの設定]>[共有アクセスポリシー]>[iothubowner] に移動します。

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

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

モジュールが開始されるまでに数分かかる場合があります。 IoT Edge ランタイムは、新しい配置マニフェストを受け取り、コンテナーランタイムからモジュールイメージを取得して、それぞれの新しいモジュールを開始する必要があります。

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

サンプルのモジュールコードは、入力キュー経由でメッセージを受け取り、出力キュー経由でそれらを渡します。配置マニフェストは、メッセージを "tempSensor" から "filtermodule" に渡し、次に "filtermodule" から IoT Hub にメッセージを転送したルートを宣言しました。 Azure IoT Edge と Azure IoT Hub の拡張機能を使うと、個々のデバイスから IoT Hub に到着したメッセージを表示できます。

Visual Studio Code のエクスプローラーで、監視する IoT Edge デバイスを右クリックして、 [Start Monitoring Built-in Event Endpoint](組み込みイベントエンドポイントの監視を開始する) を選択します。
Visual Studio Code の出力ウィンドウを監視して、IoT ハブに到着するメッセージを確認してください。

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

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

このセクションのコマンドは、開発マシンではなく、IoT Edge デバイスを対象としています。 IoT Edge デバイスに仮想マシンを使用している場合は、すぐに接続してください。 Azure で、仮想マシンの概要ページに移動し、 [接続] を選択して Secure Shell 接続にアクセスします。

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

"tempSensor" と "filtermodule" のログには、処理しているメッセージが表示されるはずです。 edgeAgent モジュールには、他のモジュールを開始する責任があります。そのため、そのログには、配置マニフェストの実装に関する情報が含まれます。モジュールが一覧に含まれていないか、実行されていない場合は、おそらく edgeAgent ログにエラーが記録されています。 edgeHub モジュールは、モジュールと IoT Hub 間の通信を担当します。モジュールは稼働しているものの、メッセージが IoT ハブに到着していない場合は、おそらく edgeHub のログにエラーが記録されています。

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

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

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

Azure リソースを削除する

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

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

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

次のステップ

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

次のチュートリアルに進むと、Azure のクラウドサービスをデプロイしてエッジでデータの処理と分析を行ううえで、Azure IoT Edge がどのように役立つかを確認できます。

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