Question

问题：

我有一个node.js（8.10）AWS Lambda函数，该函数接受一个json对象并将其发布到IOT主题。该函数已成功发布到该主题，但是，一旦触发该函数，它将被连续调用，直到我将并发限制为零，才能停止对该函数的任何进一步调用。

我正在尝试弄清楚我实现不正确的原因，从而导致调用该函数的多个实例。

功能：

这是我的功能：

var AWS = require('aws-sdk');

exports.handler = function (event, context) {
    var iotdata = new AWS.IotData({endpoint: 'xxxxxxxxxx.iot.us-east-1.amazonaws.com'});
    var params = {
        topic: '/PiDevTest/SyncDevice',
        payload: JSON.stringify(event),
        qos: 0
    };

    iotdata.publish(params, function(err, data) {
        if (err) {
          console.log(err, err.stack);
        } else {
            console.log("Message sent.");
            context.succeed();
        }     
    });
};

我的测试json是：

{
  "success": 1,
  "TccvID": "TestID01"
}

测试控制台的响应为“ null”，但IOT主题显示来自测试json的数据，该数据大约每秒发布一次。

我尝试过的事情

-我试图在它自己的，称为处理程序的非匿名函数中定义处理程序，然后使用exports.handler = handler;这没有产生任何错误，但是也没有成功发布到物联网主题。

-我认为问题可能出在node.js回调上。我已经尝试实现它并把它省略了（上面的当前迭代），但是这两种方法似乎都没有什么不同。我曾在某处阅读过该函数会在出错时重试的信息，但我相信它只会发生3次，因此不会解释该函数的不确定调用。

-我也尝试过从另一个lambda调用该函数，以确保问题不是aws测试工具。但这产生了相同的行为。

摘要：

我做错了什么导致该函数将json数据无限期地发布到物联网主题？

提前感谢您的时间和专业知识。

Answer 1

使用aws-iot-device-sdk创建一个MQTT客户端，并使用它的messageHandler和publish方法将您的消息发布到IOT主题。下面是示例MQTT客户端代码，

import * as DeviceSdk from 'aws-iot-device-sdk';
import * as AWS from 'aws-sdk';

let instance: any = null;

export default class IoTClient {

  client: any;
  /**
   * Constructor
   *
   * @params {boolean} createNewClient - Whether or not to use existing client instance
   */
  constructor(createNewClient = false, options = {}) {

  }

  async init(createNewClient, options) {
    if (createNewClient && instance) {
      instance.disconnect();
      instance = null;
    }

    if (instance) {
      return instance;
    }
    instance = this;
    this.initClient(options);
    this.attachDebugHandlers();
  }

  /**
   * Instantiate AWS IoT device object
   * Note that the credentials must be initialized with empty strings;
   * When we successfully authenticate to the Cognito Identity Pool,
   * the credentials will be dynamically updated.
   *
   * @params {Object} options - Options to pass to DeviceSdk
   */
  initClient(options) {
    const clientId = getUniqueId();

    this.client = DeviceSdk.device({
      region: options.region || getConfig('iotRegion'),

      // AWS IoT Host endpoint
      host: options.host || getConfig('iotHost'),

      // clientId created earlier
      clientId: options.clientId || clientId,

      // Connect via secure WebSocket
      protocol: options.protocol || getConfig('iotProtocol'),

      // Set the maximum reconnect time to 500ms; this is a browser application
      // so we don't want to leave the user waiting too long for reconnection after
      // re-connecting to the network/re-opening their laptop/etc...
      baseReconnectTimeMs: options.baseReconnectTimeMs || 500,
      maximumReconnectTimeMs: options.maximumReconnectTimeMs || 1000,

      // Enable console debugging information
      debug: (typeof options.debug === 'undefined') ? true : options.debug,

      // AWS access key ID, secret key and session token must be
      // initialized with empty strings
      accessKeyId: options.accessKeyId,
      secretKey: options.secretKey,
      sessionToken: options.sessionToken,
      // Let redux handle subscriptions
      autoResubscribe: (typeof options.debug === 'undefined') ? false : options.autoResubscribe,
    });
  }

  disconnect() {
    this.client.end();
  }

  attachDebugHandlers() {
    this.client.on('reconnect', () => {
      logger.info('reconnect');
    });

    this.client.on('offline', () => {
      logger.info('offline');
    });

    this.client.on('error', (err) => {
      logger.info('iot client error', err);
    });

    this.client.on('message', (topic, message) => {
      logger.info('new message', topic, JSON.parse(message.toString()));
    });
  }

  updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken) {
    this.client.updateWebSocketCredentials(accessKeyId, secretAccessKey, sessionToken);
  }

  attachMessageHandler(onNewMessageHandler) {
    this.client.on('message', onNewMessageHandler);
  }

  attachConnectHandler(onConnectHandler) {
    this.client.on('connect', (connack) => {
      logger.info('connected', connack);
      onConnectHandler(connack);
    });
  }

  attachCloseHandler(onCloseHandler) {
    this.client.on('close', (err) => {
      logger.info('close', err);
      onCloseHandler(err);
    });
  }

  publish(topic, message) {
    this.client.publish(topic, message);
  }

  subscribe(topic) {
    this.client.subscribe(topic);
  }

  unsubscribe(topic) {
    this.client.unsubscribe(topic);
    logger.info('unsubscribed from topic', topic);
  }
}

*** getConfig（）用于从yml文件获取环境变量，否则您可以在此处直接指定它。

Answer 2

虽然他只是将其发布为评论，但MarkB向我指出了正确的方向。

问题是解决方案与另一个lambda有关，后者正在听同一个主题并调用我正在处理的lambda。这导致循环逻辑，因为从未满足退出条件。修复该代码即可解决此问题。

无限期触发将AWS Lambda发布到IOT Topic

2 个答案: