Internationalization is the process of designing a product, application, or document content that is suitable for a global audience. It is a set of practices that allows a product to be adapted to different languages, cultures, and regions without engineering changes. The Intl object is a standard way to format data in the locale-specific format.

Why It's Needed

For decades, to make an application accessible natively in each region with the support of local elements like currency, timezone, and language-specific content developers had to use third-party libraries. The new Intl API trying to address the issue with the support of a few new features.

JavaScript being, a global language, and it's used by people all over the world. The Intl object is a standard way to format data in the locale-specific format. Previously, it was achieved by third-party libraries to format data in the locale-specific format, and the different operations required many different third-party libraries resulting in a bloated web and higher bundle sizes.

Date formatting was a major pain in the neck for developers. Because of this developers had to use third-party libraries like moment.js, date-fns, luxon, etc to format dates in the locale-specific format.

For formatting strings in the locale-specific format, developers had to use third-party client-side libraries like i18next, react-intl etc.

For formatting strings and numbers in the locale-specific format, developers had to use third-party libraries like numeral.js, accounting.js, cldr-compact-number, etc.

But now with the new Intl object, developers can format strings, numbers, and dates in the locale-specific format without using third-party libraries and standardizing the process of these.

The Intl API has excellent support for all major browsers except IE11. For IE11, you can use the Format.js Polyfil.

Each browser has a different implementation of the Intl object. So Output of the Intl object in different browsers might vary depending on the browser.

Intl API

Intl Object in Node v19.0.0

Intl object in Chrome 107.0

The Intl API provides many constructor properties for various tasks. We'll explore a few of them in this article. Later I, probably will add other remaining constructors.

Intl.Collator

Refrence: Intl.Collator

Constructor for collators, which are objects that enable language-sensitive string comparison.

Syntax

new Intl.Collator(locales, options);

locales: A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see

options: An object with some or all of the following properties:

const initialOptions = {
  localeMatcher: 'best fit',
  usage: 'sort',
  sensitivity: 'variant',
  ignorePunctuation: true,
  numeric: true,
  caseFirst: 'upper',
};

const collator = (
  strOne,
  strTwo,
  language = 'en',
  options = initialOptions
) => {
  const collatorObject = new Intl.Collator(language, initialOptions);

  return collatorObject.compare(strOne, strTwo);
};

const log = console.log;

log(collator('a', 'a', 'en')); // 0

log(collator('a', 'A', 'en')); // 0

log(collator('a', 'b', 'en')); // -1

log(collator('b', 'a', 'en')); // 1

log(collator('100', '10', 'en')); // 1

log(collator('100', '1000', 'en')); // -1

['Z', 'a', 'z', 'ä'].sort((acc, cur) => collator(acc, cur, 'de', {})); // ['a', 'ä', 'Z', 'z']

Intl.DateTimeFormat

Refrence: Intl.DateTimeFormat

Constructor for objects that enable the language-sensitive date and time formatting.

Syntax

new Intl.DateTimeFormat(locales, options);

locales: A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see

options: An object with some or all of the following properties:

const initialOptions = {
  localeMatcher: 'best fit',
  weekday: 'long',
  era: 'long',
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: 'numeric',
  minute: 'numeric',
  second: 'numeric',
  timeZoneName: 'long',
};

const dateTimeFormat = (
  date = new Date(),
  language = 'en',
  options = initialOptions
) => {
  const dateTimeFormatObject = new Intl.DateTimeFormat(language, options);

  return dateTimeFormatObject.format(date);
};

const log = console.log;

log(dateTimeFormat(new Date(), 'en')); // Wednesday, October 26, 2022 Anno Domini at 2:23:13 AM India Standard Time

log(dateTimeFormat(new Date(), 'de')); // Mittwoch, 26. Oktober 2022 n. Chr. um 2:23:13 Indische Normalzeit

log(dateTimeFormat(new Date(), 'fr')); // mercredi 26 octobre 2022 après Jésus-Christ à 2:23:14 heure de l’Inde

log(dateTimeFormat(new Date(), 'ja')); // 西暦2022年10月26日水曜日 2時23分26秒 インド標準時

log(dateTimeFormat(new Date(), 'zh')); // '公元2022年10月26日星期三 印度时间 2:23:35'

log(dateTimeFormat(new Date(), 'en', { weekday: 'short' })); // Wed

Intl.RelativeTimeFormat

Refrence: Intl.RelativeTimeFormat

Constructor for objects that enable language-sensitive relative time formatting.

Syntax

new Intl.RelativeTimeFormat(locales, options);

locales : A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see

options: An object with some or all of the following properties:

const initialOptions = {
  localeMatcher: 'best fit',
  numeric: 'auto',
  style: 'long',
};

const relativeTimeFormat = (
  value = 0,
  unit = 'second',
  language = 'en',
  options = initialOptions
) => {
  const relativeTimeFormatObject = new Intl.RelativeTimeFormat(language, {
    ...options,
    value,
    unit,
  });

  return relativeTimeFormatObject.format(value, unit);
};

const log = console.log;

log(relativeTimeFormat(1));

log(relativeTimeFormat(0, 'month'));

log(relativeTimeFormat(-1, 'year'));

log(relativeTimeFormat(10, 'hour'));

log(relativeTimeFormat(5, 'day'));

log(relativeTimeFormat(1, 'week'));

log(relativeTimeFormat(1, 'month'));

log(relativeTimeFormat(1, 'day'));

log(relativeTimeFormat(-1, 'day'));

Intl.NumberFormat

Refrence: Intl.NumberFormat

Constructor for objects that enable language-sensitive number formatting.

Syntax

new Intl.NumberFormat(locales, options);

locales: A string with a BCP 47 language tag, or an array of such strings. For the general form and interpretation of the locales argument, see

options: An object with some or all of the following properties:

Note: The style property can be either decimal or currency. If style is currency, then the currency property must be provided as well.

Note: The currencyDisplay property can be either symbol or code. If currencyDisplay is symbol, then the currency property must be provided as well.

Note : The notion property can be either standard or scientific. If notation is scientific, then the minimumSignificantDigits and maximumSignificantDigits properties must be provided as well. after which we can achieve the following:

const initialOptions = {
  localeMatcher: 'best fit',
  style: 'decimal',
  currency: 'USD',
  currencyDisplay: 'symbol',
  compactDisplay: 'short',
  useGrouping: true,
  minimumIntegerDigits: 1,
  minimumFractionDigits: 0,
  maximumFractionDigits: 3,
  minimumSignificantDigits: 1,
  maximumSignificantDigits: 21,
  notion: 'compact',
};

const numberFormat = (
  number = 0,
  language = 'en',
  options = initialOptions
) => {
  const numberFormatObject = new Intl.NumberFormat(language, options);

  return numberFormatObject.format(number);
};

const log = console.log;

const numberFormatOptions = {
  notation: 'compact',
  compactDisplay: 'short',
};

log(numberFormat(12343232356.789, 'en', numberFormatOptions)); // 12B

log(numberFormat(1000, 'en')); // 1,000

log(numberFormat(1000, 'de')); // 1.000

log(numberFormat(1000, 'in')); // 1.000

log(numberFormat(1000, 'fr')); // 1 000

log(numberFormat(1000, 'ja')); // 1,000

log(numberFormat(1000, 'zh')); // 1,000

log(numberFormat(1000, 'en', { style: 'currency', currency: 'EUR' })); // €1,000.00

log(numberFormat(1000, 'de', { style: 'currency', currency: 'EUR' })); // 1.000,00 €

log(numberFormat(1000, 'de', { style: 'currency', currency: 'INR' })); // 1.000,00 ₹

log(numberFormat(1000, 'fr', { style: 'currency', currency: 'EUR' })); // 1 000,00 €

log(numberFormat(1000, 'ja', { style: 'currency', currency: 'EUR' })); // €1,000.00

log(numberFormat(1000, 'zh', { style: 'currency', currency: 'EUR' })); // €1,000.00

log(numberFormat(1000, 'en', { style: 'percent' })); // 100,000%

log(numberFormat(1000, 'de', { style: 'percent' })); // 100.000%

log(numberFormat(1000, 'in', { style: 'percent' })); // 100.000%

log(numberFormat(1000, 'fr', { style: 'percent' })); // 100 000 %

log(numberFormat(1000, 'ja', { style: 'percent' })); // 100,000%

log(numberFormat(1000, 'zh', { style: 'percent' })); // 100,000%

References

• MDN Intl

• MDN Intl.Collator

• MDN Intl.DateTimeFormat

• MDN Intl.NumberFormat

• MDN Intl.RelativeTimeFormat

• MDN Intl.PluralRules

• MDN Intl.ListFormat

• MDN Intl.Locale

• MDN Intl.DisplayNames

• MDN Intl.Segmenter

When you create an AWS account, you begin with one sign-in identity that has complete access to all AWS services and resources in the account. This identity is called the AWS account root user and is accessed by signing in with the email address and password that you used to create the account. It is strongly recommended that you do not use the root user for your everyday tasks. Safeguard your root user credentials and use them to perform the tasks that only the root user can perform and use an account with the right permission for day-to-day tasks.

In this article, we will see how to enable AWS Cost, Usage, and Billing information to an IAM user.

You Might think you can just attach the Billing policy to your user and you are good to go. But there is one other step if you're doing it for the first time. You need to enable Activate IAM Access to Billing Console to access the billing information. You can do this by following the steps below.

Create IAM Group

1. Log in to your AWS Console with your root user.
2. Go to the IAM service page.
3. On the left side panel, click on User groups and then click on Create Group.

1. Give a name to your group scroll down and click on Create group.

Note: You can attach policies while creating a group. But for the demo purpose, I'll create the group and attach it later.

Attaching IAM Policy to Group

1. On the IAM service page and in there the User groups section you can see the created group.
2. Click on the group name.

Which will take you to the group details page where you can see the group name and other details.

1. Click on the Permission button and click on Add Permission.

2. From the drop-down select Attach Policies.

1. You can Search billing on the filter policy search bar and attach it.

Based on the group you might want to add permission for ViewOnlyAccess or FullAccess. For this, you'll have to create a custom policy.

More details you can find in here.

1. After attaching the policy click on the Add Permission button.

Add User to Group

1. Go to the IAM service page.
2. On the left side panel, click on User groups and then click on Add users.

1. Select the user you want to add the group to and click on Add User.

Activate IAM Access to Billing Console

1. Go to the IAM service page.
2. From the navigation bar, choose your account name and then choose Account.

1. Scroll down to the IAM User and Role Access to Billing Information section and click on the Edit button.

1. Enable Activate IAM Access to Billing Console and click on the Save Changes button.

Now you should be able to access the billing information from your IAM user.

Conclusion

In this article, we saw

• to enable AWS Cost, Usage, and Billing information to an IAM user.
• We also saw how to create a group and attach a policy to it.
• How to add a user to a group.
• How to activate IAM Access to Billing Console.

References

• AWS IAM User
• AWS IAM Policy

• AWS IAM Group

• AWS IAM Access to Billing Console

• Activating access to the AWS Billing console

How SNS works?

Amazon SNS sends notifications two ways, A2A and A2P. A2A provides high-throughput, push-based, many-to-many messaging between distributed systems, microservices, and event-driven serverless applications. These applications include Amazon Simple Queue Service (SQS), Amazon Kinesis Data Firehose, AWS Lambda, and other HTTP/S endpoints or to any other endpoint that supports the Simple Notification Service (SNS) protocol. A2P functionality lets you send messages to your customers with SMS texts, push notifications, and email. SNS also provides a simple, cost-effective, push-based mechanism to distribute notifications to large numbers of subscribers.

1. SNS is a highly available, durable, secure, and scalable pub/sub messaging system with very low latency.

2. SNS is a fully managed service, which means that AWS takes care of the infrastructure and maintenance of the service. You don't need to worry about the underlying infrastructure, such as the servers, operating systems, and network.

3. SNS is a pub/sub messaging system, which means that the publisher does not need to know the subscribers. The publisher sends a message to the topic, and the message is delivered to all the subscribers of the topic.

4. SNS is a highly available service, which means that it is designed to have a high degree of fault tolerance and to be able to recover from failures quickly, AWS guarantees 99.9% accuracy on SNS service.

5. SNS is a durable service, which means that it can store messages for a long time. SNS is a secure service, which means that it uses encryption and authentication to protect your data.

6. It is a scalable service, which means that it can handle a large number of requests and messages, and it provides high throughput.

SNS Topics

A topic is a logical access point and communication channel for a publisher to post a message that is immediately available for subscribers to consume. A topic is a container for messages that are published to the topic. Subscribers can be applications or end users. When a publisher sends a message to a topic, Amazon SNS delivers the message to each subscriber. A topic can have multiple subscribers, and each subscriber can have multiple protocols.

SNS Subscriptions

Subscriptions are the mechanism that delivers messages to subscribing endpoints or clients. A subscription is a communication channel to deliver notifications from a topic to subscribers. A subscription is an association between a topic and an endpoint. Subscriptions are uni-directional. A subscription can deliver notifications to one or more endpoints and to one or more protocols.

while creating a subscription, you can choose the protocol and endpoint. The protocol is the mechanism by which SNS delivers notifications to the endpoint. The endpoint is the location where the notification is sent.

Upon adding a subscription, SNS sends a confirmation message to the endpoint. The endpoint must confirm the subscription by sending a message back to SNS. The confirmation message is sent to the endpoint using the protocol that you specified when you created the subscription. For example, if you created a subscription with the HTTP protocol, the confirmation message is sent to the endpoint using the HTTP protocol to the endpoint with POST request. If you created a subscription with the email protocol, the confirmation message is sent to the endpoint using the email protocol. If you create a subscription with SQS as the protocol, the correct policy must be attached to the SQS queue.

SNS Message Delivery

SNS provides two types of message delivery, point-to-point, and publish-subscribe. Point-to-point delivery is a one-to-one communication between a sender and a receiver. Publish-subscribe delivery is a one-to-many communication between a sender and multiple receivers. SNS uses publish-subscribe delivery to send messages to multiple subscribers

SNS Message Delivery Guarantees

SNS provides two types of message delivery guarantees, at-least-once and exactly-once. At-least-once delivery is a message delivery guarantee that ensures that a message is delivered at least once. Exactly-once delivery is a message delivery guarantee that ensures that a message is delivered exactly once. SNS uses at-least-once delivery by default. SNS provides exactly-once delivery by using the SNS FIFO (first-in-first-out) topics.

SNS Message Delivery Order

SNS provides two types of message delivery orders, unordered and ordered. Unordered delivery is a message delivery order that ensures that a message is delivered in any order. Ordered delivery is a message delivery order that ensures that a message is delivered in the same order as it was sent. SNS uses unordered delivery by default. SNS provides ordered delivery by using the SNS FIFO (first-in-first-out) topics.

SNS Message Delivery Delay

SNS provides two types of message delivery delay, immediate and delayed. Immediate delivery is a message delivery delay that ensures that a message is delivered immediately. Delayed delivery is a message delivery delay that ensures that a message is delivered after a specified delay. SNS uses immediate delivery by default. SNS provides delayed delivery by using the SNS FIFO (first-in-first-out) topics.

SNS Message Delivery Retries

SNS provides two types of message delivery retries, automatic and manual. Automatic retries are the retries that are performed by SNS automatically. Manual retries are the retries that are performed by the subscriber. SNS uses automatic retries by default. SNS provides manual retries by using the SNS FIFO (first-in-first-out) topics.

SNS Message Delivery Failures

SNS provides two types of message delivery failures, permanent and transient. Permanent failures are the failures that are not recoverable. Transient failures are the failures that are recoverable. SNS uses permanent failures by default. SNS provides transient failures by using the SNS FIFO (first-in-first-out) topics.

SNS Dead Letter Queue

SNS provides two types of dead letter queues, standard, and FIFO. Standard dead letter queues are the dead letter queues that are used to store messages that failed to be delivered to the subscribers. FIFO dead letter queues are the dead letter queues that are used to store messages that failed to be delivered to the subscribers in the same order as they were sent. SNS uses standard dead letter queues by default. SNS provides FIFO dead letter queues by using the SNS FIFO (first-in-first-out) topics.

SNS Message Delivery Status

SNS provides two types of message delivery status, success (200 status code) and failure (400 status code). Success status is the status that is returned when a message is delivered successfully. Failure status is the status that is returned when a message is not delivered successfully. SNS uses success status by default. SNS provides failure status by using the SNS FIFO (first-in-first-out) topics.

Use Cases

1. Integrate your applications with FIFO messaging
   • Deliver messages in a strictly ordered, first in, first out (FIFO) manner to maintain accuracy and consistency across independent applications.

2. Securely encrypt notification message delivery

   • Encrypt messages with AWS Key Management Service (KMS), ensure traffic privacy with AWS PrivateLink, and control access with resource policies and tags.

3. Capture and fan out events from over 60 AWS services

   • Fan out events across AWS categories, such as analytics, compute, containers, databases, IoT, machine learning (ML), security, and storage.

4. Send SMS texts to customers across over 240 countries

   • Send SMS messages to customers in over 240 countries and territories, including the United States, Canada, Australia, and the United Kingdom.

   • Use worldwide SMS, with redundancy across providers. Set SMS origination identity with a sender ID, long code, short code, TFN, or 10DLC. Use Amazon Pinpoint to send SMS messages to customers in the United States, Canada, Australia, and the United Kingdom.

Pricing

Amazon SNS is a pay-as-you-go service. You pay only for the resources you use. There are no upfront costs or long-term commitments. You pay for the number of requests you make to Amazon SNS, the number of messages you publish to Amazon SNS topics, and the number of messages you receive from Amazon SNS subscriptions. You can also choose to pay for the number of messages that are delivered to your endpoints. For more information, see Amazon SNS Pricing.

SNS has also a free tier. It includes 1 million free requests, 100,000 free HTTP/S deliveries, and 1000 Email deliveries as of 24th Oct 2022. For more information, see Amazon SNS Free Tier.

Furthermore, AI voices make the process of editing voiceovers, quick and easy. Users can simply make the necessary changes to their script and modify the AI voice automatically. Synthetic voice is now accessible more than ever in this growing AI and ML world. the possibility of synthetic automated voice is only limited by your imagination. That being said the process of converting Text / SSML to natural-sounding voices isn't as difficult as used to be.

In this article, we'll see how AWS Polly which is an AI-based text-to-speech service can be used to convert text to speech in your desired language. We'll also see how to use AWS Lambda to convert text to speech and save it to AWS S3 and DynamoDB.

Services

What is Amazon Polly?

Amazon Polly is a service that turns text into lifelike speech. It's a text-to-speech (TTS) service that uses advanced deep learning technologies to synthesize speech that sounds like a human voice. It provides dozens of lifelike voices in multiple languages. You can create applications that talk and build entirely new categories of speech-enabled products. Polly is a fully managed service that makes it easy for developers to add speech to their applications.

Polly is a paid service. You can use the free tiers. After that, you'll have to pay for the service. The free tier includes 5 million characters per month for 12 months. You can find the pricing details here.

1. With AWS Polly developers can customize and control speech output that supports lexicons and Speech Synthesis Markup Language (SSML) tags.

2. Store and redistribute speech in standard formats like MP3 and OGG.

3. Quickly deliver lifelike voices and conversational user experiences in consistently fast response times.

How Polly Works This is an Image demonstrating how Polly works straight out of the AWS documentation.

How to use AWS Polly?

For a Quick Simple Demo of AWS Polly, you can use the AWS Polly Service Page.

1. Go to the AWS Polly console and click on the Get Started Now button.
2. Click on Text to Speech.
3. Select the language and voice you want to use.
4. Enter the text you want to convert to speech.
5. Click on Play to listen to the speech.
6. Click on Download to download the speech.

Without further ado, let's get started and build a simple application that converts text to speech and saves the MP3 file it to AWS S3 and the Metadata to DynamoDB.

What is AWS Lambda?

AWS Lambda is a compute service that lets you run code without provisioning or managing servers. AWS Lambda executes your code only when needed and scales automatically, from a few requests per day to thousands per second. You pay only for the compute time you consume - there is no charge when your code is not running. With Lambda, you can run code for virtually any type of application or backend service - all with zero administration. Just upload your code and Lambda takes care of everything required to run and scale your code with high availability. You can set up your code to automatically trigger from other AWS services or call it directly from any web or mobile app.

What is AWS S3?

AWS S3 is a simple storage service that offers an extremely durable, highly available, and infinitely scalable object storage infrastructure at very low costs. It is designed to make web-scale computing easier for developers. Amazon S3 provides developers and IT teams with secure, durable, highly-scalable object storage. Amazon S3 is easy to use, with a simple web services interface to store and retrieve any amount of data from anywhere on the web.

What is DynamoDB?

AWS DynamoDB is a fully managed NoSQL database service that provides fast and predictable performance with seamless scalability. DynamoDB lets you offload the administrative burdens of operating and scaling a distributed database, so that you don't have to worry about hardware provisioning, setup, and configuration, replication, software patching, or cluster scaling.

Prerequisites

1. You need to have an AWS account. If you don't have one, you can create one here.
2. You need to have Node.js installed on your machine. You can download it from here.
3. You need to have the AWS CLI installed on your machine. You can download it from here.
4. You need to have AWS CLI configured. you can configure it by running aws configure.
5. You need to have the Serverless Framework installed on your machine. You can download it from here.

Steps

Note: You can find the complete code for this article in my GitHub Repository.

Initializing the app.

With the serverless framework, we can generate a boilerplate code for our application. We'll use the serverless create command to generate the boilerplate code.

sls create --template aws-nodejs --path speak-polly-app --name speak-polly-app

Here the --template signifies the template we want to use. We're using the aws-nodejs template. The --path signifies the path where we want to create the project. We're creating the project in the speak-polly-app folder. The --name signifies the name of the project. We're naming the project as speak-polly-app.

After running the above command, you'll see a folder named speak-polly-app in your current directory. This folder contains the boilerplate code for our application.

cd speak-polly-app

Now, let's install the dependencies for our application. We'll be using aws-sdk and uuid packages. The aws-sdk package will help us to interact with AWS services and APIs. The uuid package will help us to generate a unique ID for our speech.

npm install aws-sdk uuid

Code

Now, let's open the handler.js file in our project. This file contains the code for our application.

'use strict';

const AWS = require('aws-sdk');
const { v4: uuidV4 } = require('uuid');
const Polly = new AWS.Polly({ apiVersion: '2016-06-10' });
const S3 = new AWS.S3({ apiVersion: 'latest' });
const dynamodb = new AWS.DynamoDB({ apiVersion: '2012-08-10' });

module.exports.speakPolly = async (event) => {
  try {
    const records = event['Records'];

    for (const record of records) {
      const bucketName = record['s3']['bucket']['name'];
      const objectKey = record['s3']['object']['key'];
      // const objectSize = record['s3']['object']['size'];

      const objectDetails = await getObjectFromS3(bucketName, objectKey);
      const text = objectDetails.Body.toString('utf-8');
      const voiceId = process.env.VOICE_AGENT || 'Carla';

      const params = {
        Engine: 'standard',
        OutputFormat: 'mp3',
        SampleRate: '22050',
        Text: text,
        TextType: 'text',
        VoiceId: voiceId,
      };

      const data = await Polly.synthesizeSpeech(params).promise();

      const destinationBucketName = process.env.AUDIO_BUCKET;
      const mp3FileKey = uuidV4();
      const destinationObjectKey = `${mp3FileKey}.mp3`;

      const s3Params = {
        Bucket: destinationBucketName,
        Key: destinationObjectKey,
        data: data.AudioStream,
        ContentType: 'audio/mpeg',
      };

      const dynamoTableName = process.env.DYNAMODB_TABLE;

      await Promise.all([
        putObjectToS3(s3Params),
        putItemToDynamoDB(dynamoTableName, {
          id: { S: mp3FileKey },
          text: { S: text },
          voiceId: { S: voiceId },
          bucket: { S: destinationBucketName },
          createdAt: { S: new Date().toISOString() },
          updatedAt: { S: new Date().toISOString() },
        }),
      ]);
    }

    return {
      statusCode: 200,
      body: JSON.stringify(
        { message: 'Successfully executed', data: event },
        null,
        2
      ),
    };
  } catch (err) {

    return {
      statusCode: 500,
      body: JSON.stringify({ message: 'Error', data: err }, null, 2),
    };
  }
};

async function getObjectFromS3(bucket_name, object_key) {
  const params = {
    Bucket: bucket_name,
    Key: unquotePlus(object_key),
  };

  return await S3.getObject(params).promise();
}

async function putObjectToS3({ Bucket, Key, data, ContentType }) {
  const params = {
    Bucket: Bucket,
    Key: Key,
    Body: data,
    ContentType: ContentType,
  };

  return await S3.putObject(params).promise();
}

async function putItemToDynamoDB(TableName, Item) {
  const params = {
    TableName: TableName,
    Item: Item,
  };

  return await dynamodb.putItem(params).promise();
}

function unquotePlus(s) {
  return decodeURIComponent(s.replace(/\+/g, ' '));
}

Let's understand the Lambda Function.

The default handler function is speakPolly. This function will be called when we invoke our Lambda function. The event object contains the details of the event that triggered the Lambda function. In our case, the event object will contain the details of the S3 object that was created.

With the event object we'll get the details of the S3 object that was uploaded. We'll get the bucket name, object key from the event object, and many other details like object size. We'll use the getObjectFromS3 function to get the object from the S3 bucket. With toString method we'll get the raw text from the object and text to generate the speech.

We'll use the Polly.synthesizeSpeech function to generate the speech. The Polly.synthesizeSpeech function will return the speech in the form of an audio stream. We'll use the putObjectToS3 function to put the audio stream to the S3 bucket. The putObjectToS3 function will return the object that was created in the S3 bucket.

The putItemToDynamoDB function will save the details to a DynamoDB table.

Now, let's deploy our application. We'll be using the serverless package to deploy our application. for this we need to write the YAML file containing all the details of resources and configuration of our application.

service: speak-polly-app
frameworkVersion: '3'

custom:
  text_bucket: text-${self:service}-${self:provider.stage}
  audio_bucket: audio-${self:service}-${self:provider.stage}
  dynamodb_table: mp3-${self:service}-${self:provider.stage}

provider:
  name: aws
  runtime: nodejs14.x
  stage: dev
  region: ap-south-1
  memorySize: 128
  timeout: 100
  profile: serverless-admin
  environment:
    TEXT_BUCKET: ${self:custom.text_bucket}
    AUDIO_BUCKET: ${self:custom.audio_bucket}
    DYNAMODB_TABLE: ${self:custom.dynamodb_table}

  iam:
    role:
      statements:
        - Effect: Allow
          Action: 's3:*'
          Resource:
            - 'arn:aws:s3:::${self:custom.text_bucket}/*'
            - 'arn:aws:s3:::${self:custom.text_bucket}*'
            - 'arn:aws:s3:::${self:custom.audio_bucket}/*'
            - 'arn:aws:s3:::${self:custom.audio_bucket}*'
        - Effect: Allow
          Action: 'polly:*'
          Resource: '*'
        - Effect: Allow
          Action:
            - 'dynamodb:PutItem'
            - 'dynamodb:GetItem'
            - 'dynamodb:DeleteItem'
          Resource:
            - 'arn:aws:dynamodb:${self:provider.region}:*:table/${self:custom.dynamodb_table}'
            - 'arn:aws:dynamodb:${self:provider.region}:*:table/${self:custom.dynamodb_table}/*'

functions:
  speakPolly:
    handler: handler.speakPolly
    environment:
      VOICE_AGENT: Joanna

    events:
      - s3:
          bucket: ${self:custom.text_bucket}
          event: s3:ObjectCreated:*
          rules:
            - prefix: transcripts/
            - suffix: .txt

# you can add CloudFormation resource templates here
resources:
  Resources:
    S3AudioBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: ${self:custom.audio_bucket}
        AccessControl: PublicRead
        VersioningConfiguration:
          Status: Suspended

    DynamoDBTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: ${self:custom.dynamodb_table}
        AttributeDefinitions:
          - AttributeName: id
            AttributeType: S
        KeySchema:
          - AttributeName: id
            KeyType: HASH
        ProvisionedThroughput:
          ReadCapacityUnits: 1
          WriteCapacityUnits: 1

Let's understand the YAML file.

The service property is the name of our application. The frameworkVersion property is the version of the serverless package we are using.

The custom property is used to define the custom properties. We'll be using the text_bucket and audio_bucket and dynamodb_table properties to define the name of the S3 buckets and DynamoDB table we are going to create.

The provider property is used to define the provider of our application. We'll be using the aws provider. The runtime property is the runtime environment of our application. We'll be using the nodejs14.x runtime environment. The stage property is the stage of our application. We'll be using the dev stage. The region property is in which region our application and resources are going to reside. We'll be using the ap-south-1 (Mumbai) region. The memorySize property is the memory size that the lambda function gets. We'll be using the 128 MB. The timeout property is the maximum number of seconds that our function can run at a single invocation. We'll be using the 100 timeout. The profile property is the aws profile that I'm going to use. If you're using default or have a single account configured you can remove it. Here I'm using the serverless-admin profile. The environment property is the environment variables of our lambda function.

The iam property is used to define the IAM roles that our application going to need. The role property is used to define the IAM role of our application. The statements is used to define the IAM statements. The Effect property is used to define the effect of the IAM statement. The action property is used to define the action of the IAM statement. The Resource property is used to define the resources of the IAM statement.

The functions block defines the functions of our application. speakPolly is the function of our application, you can declare one or more functions as well. The handler property is used to define the handler function of the lambda function. The environment property is used to define the environment variables specific to the function. The events property is used to define the events that can trigger the function. The S3 event that is declared can trigger the speakPolly function.

The resources property is used to define the resources of our application. The S3AudioBucket is to define the S3 destination bucket. The Type property is used to define the type of resource. The Properties statement is used to define the different properties of the resource. Similarly, with the DynamoDBTable property a DynamoDB table and its different attributes are mentioned.

Now, let's deploy our application. We'll use the serverless package to deploy our application.

serverless deploy --verbose

Note: Instead of serverless you can also use sls.

The serverless deploy command will deploy our application. The --verbose flag will display the verbose output of the command.

The command with the serverless.yml file will create a cloudformation stack. The cloudformation stack intern will create all the necessary IAM roles, S3 buckets, Lambda functions, database tables, and other required resources.

After the deployment is completed, we'll get the details of the resources that were created.

Now you can upload the text file to the S3 TextBucket. The speakPolly function will be triggered. The speakPolly function will generate the speech from the text and put the audio stream into the S3 bucket. the metadata like audio filename, VoiceId, creation date, etc will be stored in dynamodb.

For every execution, a log stream will be created in the CloudWatch logs.

The output of the speakPolly function can be seen in the target S3 Bucket with the MP3 file.

Cleanup

After you test the application, you can remove the application by serverless to make sure you don't get charged for the resources that were created.

serverless remove --verbose

References

• AWS SDK for JavaScript
• AWS SDK for JavaScript - Polly
• AWS SDK for JavaScript - S3
• Serverless Framework
• Serverless Framework - AWS Lambda
• Serverless Framework - AWS Lambda - Functions

• AWS Polly

  https://github.com/ashutosh4336/speak-polly-serverless

What is Cloudwatch and why do we need it?

CloudWatch is a monitoring and management service built for AWS cloud resources and the applications you run on AWS. CloudWatch provides you with data and actionable insights to monitor your applications, respond to system-wide performance changes, optimize resource utilization, and get a unified view of operational health. There are many more advantages of using CloudWatch. You can find them here.

So without further ado, let's see how to send the application logs to CloudWatch.

Steps

Create IAM Role.

Create IAM Role with relevant permission and attach it to the Linux instance.

Below are the steps to create IAM Role.

Login to the AWS console, and go to the IAM service. Click on Roles in the sidebar and then click on Create Role.

Select EC2 and click on Next to Permissions.

Add the permission. Here we are adding permission to send logs to CloudWatch. You can add more permissions as per your requirement.

Click on Next: In the next screen you'll be presented with a screen to enter a name and tags and then click on Next: Review.

Click on Create Role.

It'll take you to the Roles page. You can see the role you just created. Click on the role name to see the details of the role.

Lunch EC2 Instance

Launch an EC2 instance with default options which should be fine for this demo. please make sure you add a key pair to the instance through which you can ssh into the instance.

After the EC2 instance is up and running, we need to attach it to the EC2 Instance, go to EC2 service and select the instance. Click on Actions. Select the Linux instance and click on Actions. Select security and click on Modify IAM role.

Select the IAM Role you just created from the dropdown and click on Apply.

Configure the Instance to send logs.

After attaching IAM Role to the Linux instance, install the CloudWatch agent on the Linux instance.

Login to the Linux instance and run the below command to install the CloudWatch agent.

sudo yum install -y awslogs

• Edit file /etc/awslogs/awscli.conf and change your AWS Region to the region in which instance is launched.

sudo vi /etc/awslogs/awscli.conf

[plugins]
cwlogs = cwlogs
[default]
region = ap-south-1

• For creating a custom Log Group and other customization Edit file /etc/awslogs/awslogs.conf.

sudo vi /etc/awslogs/awslogs.conf

• At the end of the file, add the following lines to configure the agent to send the logs to CloudWatch Logs.

  [/var/log/messages]
  datetime_format = %b %d %H:%M:%S
  file = /var/log/messages
  buffer_duration = 5000
  log_stream_name = {instance_id}
  initial_position = start_of_file
  log_group_name = EC2Logs

• Start and enable awslogsd service by typing the command.

  sudo systemctl start awslogsd

  sudo systemctl enable awslogsd

• To verify that the agent is running, type the following command. (optional)

  sudo systemctl status awslogsd

You should see the newly created log group and log stream in the CloudWatch console after the agent has been running for a few moments.

The Log Group name is EC2Logs and the Log Stream name is the instance ID of the EC2 instance.

If you're not sure and want to install the AWS SSM Agent while lunching

Add these lines to your user data

#!/bin/bash
sudo yum update -y
sudo yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm

References

• AWS Docs