Dela via

Kom igång med IoT Hub modulidentitet och modultvilling (Node.js)

  • Artikel

Modulidentiteter och modultvillingar liknar enhetsidentitet och enhetstvilling i Azure IoT Hub, men har en större detaljnivå. Även om Azure IoT Hub enhetsidentitet och enhetstvilling gör det möjligt för serverdelsprogrammet att konfigurera en enhet och ger insyn i enhetens villkor, tillhandahåller en modulidentitet och modultvilling dessa funktioner för enskilda komponenter i en enhet. På kompatibla enheter med flera komponenter, till exempel operativsystemenheter eller enheter med inbyggd programvara, möjliggör det isolerad konfiguration och villkor för varje komponent.

Anteckning

Funktionerna som beskrivs i den här artikeln är endast tillgängliga på standardnivån för IoT Hub. Mer information om nivåerna basic och standard/kostnadsfri IoT Hub finns i Välja rätt IoT Hub nivå för din lösning.

I slutet av den här artikeln har du två Node.js appar:

  • CreateIdentities: skapar en enhetsidentitet, en modulidentitet och tillhörande säkerhetsnycklar för att ansluta dina enhets- och modulklienter.

  • UpdateModuleTwinReportedProperties: skickar uppdaterade modultvillingar, rapporterade egenskaper till din IoT Hub.

Anteckning

Mer information om de SDK-verktyg som är tillgängliga för att skapa både enhets- och serverdelsappar finns i Azure IoT SDK:er.

Förutsättningar

Modulautentisering

Du kan använda symmetriska nycklar eller X.509-certifikat för att autentisera modulidentiteter. För X.509-certifikatautentisering måste modulens certifikat ha sitt eget namn (CN) formaterat som CN=<deviceid>/<moduleid>. Exempel:

openssl req -new -key d1m1.key.pem -out d1m1.csr -subj "/CN=device01\/module01"

Hämta IoT Hub-anslutningssträngen

I den här artikeln skapar du en serverdelstjänst som lägger till en enhet i identitetsregistret och sedan lägger till en modul på enheten. Tjänsten kräver registrets skrivbehörighet . Som standard skapas varje IoT-hubb med en princip för delad åtkomst med namnet registryReadWrite som ger den här behörigheten.

Så här hämtar du IoT Hub-anslutningssträngen för registryReadWrite-principen:

  1. I Azure Portal väljer du Resursgrupper. Välj den resursgrupp där hubben finns och välj sedan hubben i listan över resurser.

  2. I fönstret till vänster i hubben väljer du Principer för delad åtkomst.

  3. I listan över principer väljer du registryReadWrite-principen .

  4. Kopiera den primära anslutningssträngen och spara värdet.

    Skärmbild som visar hur du hämtar anslutningssträngen

Mer information om IoT Hub principer och behörigheter för delad åtkomst finns i Åtkomstkontroll och behörigheter.

Skapa en enhetsidentitet och en modulidentitet i IoT Hub

I det här avsnittet skapar du en Node.js app som skapar en enhetsidentitet och en modulidentitet i identitetsregistret i din IoT-hubb. En enhet eller modul kan inte ansluta till IoT Hub om den inte har en post i identitetsregistret. Mer information finns i Förstå identitetsregistret i din IoT-hubb. När du kör den här konsolappen, genereras ett unikt ID och en unik nyckel för både enheten och modulen. ID och nyckel är skiftlägeskänsliga. Enheten och modulen använder dessa värden för att identifiera sig vid överföring av enhet-till-moln-meddelanden till IoT Hub.

  1. Skapa en katalog för att lagra koden.

  2. I den katalogen kör du först npm init -y för att skapa en tom package.json med standardvärden. Det här är projektfilen för din kod.

  3. Kör npm install -S azure-iothub@modules-preview för att installera tjänst-SDK i underkatalogen node_modules .

    Anteckning

    Underkatalognamnet node_modules använder ordet module för att betyda "ett nodbibliotek". Termen här har inget att göra med IoT Hub moduler.

  4. Skapa följande .js-fil i katalogen. Kalla det add.js. Kopiera och klistra in hubbanslutningssträngen och hubbnamnet.

    var Registry = require('azure-iothub').Registry;
var uuid = require('uuid');
// Copy/paste your connection string and hub name here
var serviceConnectionString = '<hub connection string from portal>';
var hubName = '<hub name>.azure-devices.net';
// Create an instance of the IoTHub registry
var registry = Registry.fromConnectionString(serviceConnectionString);
// Insert your device ID and moduleId here.
var deviceId = 'myFirstDevice';
var moduleId = 'myFirstModule';
// Create your device as a SAS authentication device
var primaryKey = new Buffer(uuid.v4()).toString('base64');
var secondaryKey = new Buffer(uuid.v4()).toString('base64');
var deviceDescription = {
  deviceId: deviceId,
  status: 'enabled',
  authentication: {
    type: 'sas',
    symmetricKey: {
      primaryKey: primaryKey,
      secondaryKey: secondaryKey
    }
  }
};

// First, create a device identity
registry.create(deviceDescription, function(err) {
  if (err) {
    console.log('Error creating device identity: ' + err);
    process.exit(1);
  }
  console.log('device connection string = "HostName=' + hubName + ';DeviceId=' + deviceId + ';SharedAccessKey=' + primaryKey + '"');

  // Then add a module to that device
  registry.addModule({ deviceId: deviceId, moduleId: moduleId }, function(err) {
    if (err) {
      console.log('Error creating module identity: ' + err);
      process.exit(1);
    }

    // Finally, retrieve the module details from the hub so we can construct the connection string
    registry.getModule(deviceId, moduleId, function(err, foundModule) {
      if (err) {
        console.log('Error getting module back from hub: ' + err);
        process.exit(1);
      }
      console.log('module connection string = "HostName=' + hubName + ';DeviceId=' + foundModule.deviceId + ';ModuleId='+foundModule.moduleId+';SharedAccessKey=' + foundModule.authentication.symmetricKey.primaryKey + '"');
      process.exit(0);
    });
  });
});

Den här appen skapar en enhetsidentitet med ID myFirstDevice och en modulidentitet med ID myFirstModule under enheten myFirstDevice. (Om modul-ID:t redan finns i identitetsregistret hämtar koden bara den befintliga modulinformationen.) Appen visar sedan den primära nyckeln för den identiteten. Du använder den här nyckeln i den simulerade modulappen för att ansluta till din IoT Hub.

Kör detta med hjälp av node add.js. Det ger dig en anslutningssträng för din enhetsidentitet och en annan för din modulidentitet.

Anteckning

IoT Hub-identitetsregistret lagrar enhets- och modulidentiteter endast för att skydda åtkomsten till IoT Hub. Enhets-ID:n och nycklar lagras i identitetsregistret och används som autentiseringsuppgifter. I identitetsregistret lagras också en aktiverad/inaktiverad-flagga för varje enhet som du kan använda till att inaktivera enhetens åtkomst. Om ditt program behöver lagra andra enhetsspecifika metadata bör det använda ett programspecifikt datalager. Det finns ingen aktiverad/inaktiverad flagga för modulidentiteter. Mer information finns i Förstå identitetsregistret i din IoT Hub i utvecklarguiden för IoT Hub.

Uppdatera modultvillingen med Node.js enhets-SDK

I det här avsnittet skapar du en Node.js-app på den simulerade enheten som uppdaterar modultvillingens rapporterade egenskaper.

  1. Hämta modulanslutningssträngen. Logga in på Azure-portalen. Gå till IoT Hub och välj IoT-enheter. Leta upp myFirstDevice, öppna den så ser du att myFirstModule har skapats. Kopiera modulens anslutningssträng. Den behövs i nästa steg.

    Information om Azure-portalmodulen

  2. På samma sätt som du gjorde i föregående avsnitt skapar du en katalog för enhetskoden och använder NPM för att initiera den och installera enhetens SDK (npm install -S azure-iot-device-amqp@modules-preview).

    Anteckning

    Installationskommandot för npm kan kännas långsamt. Ha tålamod; Den hämtar massor av kod från paketlagringsplatsen.

    Anteckning

    Om du ser ett fel som säger npm ERR! registerfel vid parsning av json. Det här är säkert att ignorera. Om du ser ett fel som säger npm ERR! registerfel vid parsning av json. Det här är säkert att ignorera.

  3. Skapa en fil med namnet twin.js. Kopiera och klistra in modulidentitetssträngen.

    var Client = require('azure-iot-device').Client;
var Protocol = require('azure-iot-device-amqp').Amqp;
// Copy/paste your module connection string here.
var connectionString = '<insert module connection string here>';
// Create a client using the Amqp protocol.
var client = Client.fromConnectionString(connectionString, Protocol);
client.on('error', function (err) {
  console.error(err.message);
});
// connect to the hub
client.open(function(err) {
  if (err) {
    console.error('error connecting to hub: ' + err);
    process.exit(1);
  }
  console.log('client opened');
// Create device Twin
  client.getTwin(function(err, twin) {
    if (err) {
      console.error('error getting twin: ' + err);
      process.exit(1);
    }
    // Output the current properties
    console.log('twin contents:');
    console.log(twin.properties);
    // Add a handler for desired property changes
    twin.on('properties.desired', function(delta) {
        console.log('new desired properties received:');
        console.log(JSON.stringify(delta));
    });
    // create a patch to send to the hub
    var patch = {
      updateTime: new Date().toString(),
      firmwareVersion:'1.2.1',
      weather:{
        temperature: 72,
        humidity: 17
      }
    };
    // send the patch
    twin.properties.reported.update(patch, function(err) {
      if (err) throw err;
      console.log('twin state reported');
    });
  });
});

  4. Kör nu detta med kommandonoden twin.js.

    F:\temp\module_twin>node twin.js

    Sedan visas:

    client opened
twin contents:
{ reported: { update: [Function: update], '$version': 1 },
  desired: { '$version': 1 } }
new desired properties received:
{"$version":1}
twin state reported

Nästa steg

För att fortsätta komma igång med IoT-hubb och utforska andra IoT-scenarier, se: