能否用Node.js 8.10版AWS Lambda函数向SNS主题发布多条消息？

Absolutely! Sending multiple messages to an SNS topic from an async Node.js 8.10 Lambda function is straightforward—here’s how to do it right, including best practices for error handling and performance.

Prerequisite: IAM Permissions #

First, make sure your Lambda execution role has the sns:Publish permission for your target SNS topic. You can attach a policy like this to your role:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "sns:Publish",
      "Resource": "arn:aws:sns:your-region:your-account-id:your-topic-name"
    }
  ]
}

Replace the placeholder values with your actual AWS region, account ID, and topic ARN.

Core Implementation: Async/Await with Promise.all #

Since your handler is async, the most efficient way to send multiple messages is to use Promise.all to publish them in parallel. This avoids unnecessary waiting between messages while keeping the code clean.

Here’s a complete example:

const AWS = require('aws-sdk');
// Initialize the SNS client with your target region
const sns = new AWS.SNS({ region: 'us-east-1' });

exports.handler = async (event) => {
  // Define your array of messages (can also come from the event payload)
  const messagesToPublish = [
    {
      Message: 'Daily inventory update: Stock levels are at 75%',
      TopicArn: 'arn:aws:sns:us-east-1:123456789012:Inventory-Alerts'
    },
    {
      Message: 'System maintenance scheduled for 2AM UTC tomorrow',
      TopicArn: 'arn:aws:sns:us-east-1:123456789012:System-Notifications',
      // Optional: Add message attributes for filtering
      MessageAttributes: {
        'Severity': {
          DataType: 'String',
          StringValue: 'Medium'
        }
      }
    },
    {
      Message: 'New user signed up: john.doe@example.com',
      TopicArn: 'arn:aws:sns:us-east-1:123456789012:User-Activity'
    }
  ];

  try {
    // Publish all messages in parallel
    const publishResults = await Promise.all(
      messagesToPublish.map(message => sns.publish(message).promise())
    );

    console.log('All messages published successfully:', publishResults);
    return {
      statusCode: 200,
      body: JSON.stringify({
        message: 'All messages sent successfully',
        messageIds: publishResults.map(res => res.MessageId)
      })
    };
  } catch (error) {
    console.error('Failed to publish messages:', error);
    // Re-throw the error to let Lambda handle it (returns a 500 status)
    throw error;
  }
};

Handling Edge Cases #

1. Sequential Publishing (If Needed) #

If you need to publish messages one after another (e.g., for rate limiting or dependent messages), use a for...of loop instead of Promise.all:

const publishResults = [];
for (const message of messagesToPublish) {
  try {
    const result = await sns.publish(message).promise();
    publishResults.push(result);
    console.log(`Published message: ${message.Message}`);
  } catch (err) {
    console.error(`Failed to publish message: ${message.Message}`, err);
    // Decide whether to continue or break here
  }
}

2. Partial Failure Handling #

By default, Promise.all will fail immediately if any single message fails to publish. If you want to continue publishing other messages even if some fail, add error handling inside the map function:

const publishResults = await Promise.all(
  messagesToPublish.map(async (message) => {
    try {
      const result = await sns.publish(message).promise();
      return { success: true, messageId: result.MessageId, message: message.Message };
    } catch (err) {
      console.error(`Failed to send message: ${message.Message}`, err);
      return { success: false, error: err.message, message: message.Message };
    }
  })
);

// Filter out failed messages if needed
const failedMessages = publishResults.filter(res => !res.success);
if (failedMessages.length > 0) {
  console.warn(`Failed to send ${failedMessages.length} messages`, failedMessages);
}

Key Notes for Node.js 8.10 #

• Node.js 8.10 supports async/await natively, so you don’t need extra libraries like bluebird.
• The AWS SDK for Node.js automatically promisifies methods when you call .promise() on them—perfect for async/await.

内容的提问来源于stack exchange，提问作者Alex Schwartz