GitHub repository

https://github.com/laidani/ChatGPT-OpenAPI-Swagger

Follow along as we walk through creating an AWS Lambda function using Java. By the end of this tutorial, you will have a fully-functioning Java-based AWS Lambda that integrates with the ChatGPT library.

ChatGPT Token

To use the ChatGPT API, you need to create a token:

• Login to https://openai.com/api/

• And create a token

AWS Lambda function code

This article will explore how to integrate ChatGPT into your application using the openai-java library. This library, developed by TheoKanning and available on GitHub at https://github.com/TheoKanning/openai-java, provides a convenient way to access the ChatGPT API and take advantage of its natural language processing capabilities in your own projects.

• Create a new maven project

• In pom.xml add

<dependency>
    <groupId>com.theokanning.openai-gpt3-java</groupId>
    <artifactId>client</artifactId>
    <version>1.18.24</version>
</dependency>

• Create a class TalkToChatGPT.java

import com.theokanning.openai.OpenAiService;
import com.theokanning.openai.completion.CompletionChoice;
import com.theokanning.openai.completion.CompletionRequest;
import com.theokanning.openai.completion.CompletionResult;
import lombok.extern.slf4j.Slf4j;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

@Slf4j
public class TalkToChatGPT {
    private static final String MODEL = "text-davinci-003";
    private static final String TOKEN = "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
    private static final OpenAiService OPEN_AI_SERVICE = new OpenAiService(TOKEN);

    public String handleRequest(Event event) {
        final String question = event.getBody();
        return getChatGPTResponse(question);
    }

    private String getChatGPTResponse(String question) {
        CompletionRequest completionRequest = getCompletionRequest(question);
        return Optional.ofNullable(OPEN_AI_SERVICE.createCompletion(completionRequest))
                .map(CompletionResult::getChoices)
                .stream()
                .flatMap(List::stream)
                .map(CompletionChoice::getText)
                .map(this::removeSpaces)
                .collect(Collectors.joining());
    }

    private static CompletionRequest getCompletionRequest(String question) {
        return CompletionRequest.builder()
                .model(MODEL)
                .prompt(question)
                .maxTokens(1000)
                .build();
    }

    private String removeSpaces(String text) {
        return text.replace("\n", "").trim();
    }
}

• You can find the complete project at this link https://github.com/laidani/AWS-Lambda-ChatGPT

• Before we can upload and run our code on AWS Lambda, we need to create a .jar file containing all of the necessary code and dependencies. To do this, we can use the mvn clean package command.

AWS Lambda function

Create a new Lambda function

To proceed, log in to your AWS account and create a new Lambda function as follows:

To test the function, we can enable the function URL:

This will allow us to send requests to the function and receive responses from it, allowing us to verify that it is working as intended.

To ensure that ChatGPT has enough time to generate a response, it is advisable to set the timeout for the function to a value greater than 15 seconds(default timeout of lambda function).

Upload the .jar file to the Lambda function

Ensure that the Handler field in your Lambda function points to the correct Java function by specifying the fully qualified class name followed by :: and the function name, for example: packaged.name.ClassName::functionName.

Test Lambda function

To test the functionality of our AWS Lambda function, we can use the following curl command:

$ curl --location --request POST 'https://luqp5lgsrvcdxu5dxf3aa67iee0spbbm.lambda-url.eu-west-1.on.aws/' \
--header 'Content-Type: text/plain' \
--data-raw 'How many planets are in the Solar System?'

$ There are 8 planets in the Solar System: Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, and Neptune.

Or by using postman:

Enjoy ;)

API Gateway endpoints

As the transcription service can take a couple of seconds to extract the speech from the audio, we need two endpoints:

1. The first one is a POST endpoint that triggers a lambda which will upload the audio file to an S3 bucket and trigger a transcript job, it looks like this https://xxxxxxx.execute-api.eu-west-1.amazonaws.com/dev/upload

2. The second one is a GET endpoint to get the result of transcription, it looks like this https://xxxxxxx.execute-api.eu-west-1.amazonaws.com/dev/transcription?code=f55c863e-60b2-4f64-9ed2-bd4b0afe0168.mp3

The terraform code of these two endpoints:

resource "aws_apigatewayv2_api" "http_api" {
  name          = "transcribe_api"
  protocol_type = "HTTP"
  description   = "HTTP API to send audio files to Lambda"

  cors_configuration {
    allow_credentials = false
    allow_headers     = []
    allow_methods     = ["GET", "POST"]
    allow_origins     = ["*"]
    expose_headers    = []
    max_age           = 0
  }
}

# Upload audio endpoint
resource "aws_apigatewayv2_integration" "api_upload" {
  api_id = aws_apigatewayv2_api.http_api.id

  integration_uri  = aws_lambda_function.upload_audit_lambda.invoke_arn
  integration_type = "AWS_PROXY"
}

resource "aws_apigatewayv2_route" "api_upload" {
  api_id    = aws_apigatewayv2_api.http_api.id
  route_key = "POST /upload"
  target    = "integrations/${aws_apigatewayv2_integration.api_upload.id}"
}

# Get transcription endpoint
resource "aws_apigatewayv2_integration" "api_transcription" {
  api_id = aws_apigatewayv2_api.http_api.id

  integration_uri  = aws_lambda_function.get_transcription_lambda.invoke_arn
  integration_type = "AWS_PROXY"
}

resource "aws_apigatewayv2_route" "api_transcription" {
  api_id    = aws_apigatewayv2_api.http_api.id
  route_key = "GET /transcription"
  target    = "integrations/${aws_apigatewayv2_integration.api_transcription.id}"
}

# Stage
resource "aws_apigatewayv2_stage" "api_stage_dev" {
  api_id      = aws_apigatewayv2_api.http_api.id
  name        = "dev"
  auto_deploy = true

  depends_on = [aws_apigatewayv2_integration.api_upload]
}

S3 bucket

resource "aws_s3_bucket" "transcript_bucket" {
  bucket_prefix = "transcript-bucket-"
  force_destroy = true
}

Lambda to upload Audio

Python code

import base64
import boto3
import json
import os
import uuid

s3_client = boto3.client('s3')
transcribe = boto3.client('transcribe')
bucket_name = os.environ['S3_BUCKET_NAME']

def lambda_handler(event, context):
    body = event['body']
    body_bytes = bytes(body, 'utf-8')

    body_base64 = base64.b64decode(body_bytes)

    name = str(uuid.uuid4()) + '.mp3'
    s3_client.put_object(Bucket=bucket_name, Body=body_base64, Key=name)
    start_transcript_job(name)

    return {
        "statusCode": 200,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": json.dumps({
            "code ": name
        })
    }


def start_transcript_job(key):
    job_name = key
    job_uri = f"s3://{bucket_name}/{key}"
    transcribe.start_transcription_job(
        TranscriptionJobName=job_name,
        Media={'MediaFileUri': job_uri},
        MediaFormat='mp3',
        LanguageCode='en-US'
    )

This lambda will be triggered by the first POST endpoint mentioned before, it will then:

1. Extract the audio file from the body of the request event['body'].

2. Upload the file to S3 with a UUID, for example 0fc6f6de-0634-4a97-9734-b005f5cb1595.mp3

3. Start a new transcript job

4. and finally, return the name of the user so that it can be used to get the transcription with another endpoint.

Terraform

# Lambda
resource "aws_lambda_permission" "upload_audit_lambda_permission" {
  statement_id  = "AllowExecutionFromAPIGateway"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.upload_audit_lambda.function_name
  principal     = "apigateway.amazonaws.com"

  source_arn = "${aws_apigatewayv2_api.http_api.execution_arn}/*"
}

resource "aws_lambda_function" "upload_audit_lambda" {
  filename         = local.upload_audio_lambda_file_name
  function_name    = local.upload_audio_function_name
  role             = aws_iam_role.upload_audio_role.arn
  handler          = "lambda_upload_audio.lambda_handler"
  runtime          = "python3.8"
  timeout          = 25
  source_code_hash = filebase64sha256(local.upload_audio_lambda_file_name)

  environment {
    variables = {
      S3_BUCKET_NAME = aws_s3_bucket.transcript_bucket.bucket
    }
  }
}

resource "aws_iam_role" "upload_audio_role" {
  name = "${local.upload_audio_function_name}_role"

  assume_role_policy = <<POLICY
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Effect": "Allow",
      "Sid": ""
    }
  ]
}
POLICY
}

resource "aws_iam_policy" "upload_audit_lambda_policy" {
  name        = "${local.upload_audio_function_name}-policy"
  description = "Policy for ${local.upload_audio_function_name}"

  policy = jsonencode({
    "Version" : "2012-10-17",
    "Statement" : [
      {
        "Effect" : "Allow",
        "Action" : [
          "logs:CreateLogStream",
          "logs:PutLogEvents",
          "logs:CreateLogGroup"
        ],
        "Resource" : "arn:aws:logs:*:*:*"
      },
      {
        "Effect" : "Allow",
        "Action" : ["s3:*"],
        "Resource" : "${aws_s3_bucket.transcript_bucket.arn}/*"
      },
      {
        "Action" : ["transcribe:*"],
        "Resource" : "*",
        "Effect" : "Allow"
      }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "upload_audio_role_policy_attachment" {
  role       = aws_iam_role.upload_audio_role.name
  policy_arn = aws_iam_policy.upload_audit_lambda_policy.arn
}

locals {
  upload_audio_function_name    = "Upload_Audio_Lambda"
  upload_audio_lambda_file_name = "lambda_upload_audio.zip"
}

Lambda to get the transcription

Python code

import boto3
import json
import urllib.request

transcribe = boto3.client('transcribe')

def lambda_handler(event, context):
    job_name = event['queryStringParameters']['code']
    transcript = get_transcription(job_name)

    return {
        "statusCode": 200,
        "headers": {
            "Content-Type": "application/html"
        },
        "body": transcript
    }

def get_transcription(job_name):
    status = transcribe.get_transcription_job(TranscriptionJobName=job_name)
    if status['TranscriptionJob']['TranscriptionJobStatus'] in ['COMPLETED', 'FAILED']:
        s3_url = status['TranscriptionJob']['Transcript']['TranscriptFileUri']
        with urllib.request.urlopen(s3_url) as url:
            response = url.read()
            json_response = json.loads(response.decode('utf-8'))
            return json_response['results']['transcripts'][0]['transcript']
    else:
        return 'Code not exist, or transcription result not ready.'

This lambda will be triggered by the second GET endpoint mentioned before, it will then:

1. Extract the job code, for example f55c863e-60b2-4f64-9ed2-bd4b0afe0168.mp3

2. Make a get_transcription_job, if the status is COMPLETE it simply returns the transcription result in the body.

Terraform

# Lambda
resource "aws_lambda_permission" "get_transcription_lambda_permission" {
  statement_id  = "AllowExecutionFromAPIGateway"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.get_transcription_lambda.function_name
  principal     = "apigateway.amazonaws.com"

  source_arn = "${aws_apigatewayv2_api.http_api.execution_arn}/*"
}

resource "aws_lambda_function" "get_transcription_lambda" {
  filename         = local.transcription_lambda_file_name
  function_name    = local.transcription_function_name
  role             = aws_iam_role.upload_audio_role.arn
  handler          = "lambda_get_transcription.lambda_handler"
  runtime          = "python3.8"
  timeout          = 25
  source_code_hash = filebase64sha256(local.transcription_lambda_file_name)
}

resource "aws_iam_role" "transcription_role" {
  name = "${local.transcription_function_name}_role"

  assume_role_policy = <<POLICY
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Action": "sts:AssumeRole",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Effect": "Allow",
      "Sid": ""
    }
  ]
}
POLICY
}

resource "aws_iam_policy" "transcription_lambda_policy" {
  name        = "${local.transcription_function_name}-policy"
  description = "Policy for ${local.upload_audio_function_name}"

  policy = jsonencode({
    "Version" : "2012-10-17",
    "Statement" : [
      {
        "Effect" : "Allow",
        "Action" : [
          "logs:CreateLogStream",
          "logs:PutLogEvents",
          "logs:CreateLogGroup"
        ],
        "Resource" : "arn:aws:logs:*:*:*"
      },
      {
        "Action" : ["transcribe:*"],
        "Resource" : "*",
        "Effect" : "Allow"
      }
    ]
  })
}

resource "aws_iam_role_policy_attachment" "transcription_role_policy_attachment" {
  role       = aws_iam_role.transcription_role.name
  policy_arn = aws_iam_policy.transcription_lambda_policy.arn
}

locals {
  transcription_function_name    = "Get_Transcription_Lambda"
  transcription_lambda_file_name = "lambda_get_transcription.zip"
}

Give it a try

To run all this, just follow these steps:

$ git clone https://github.com/laidani/Create-an-Audio-Transcript-with-Amazon-Transcribe-API-Gateway-Lambda-and-Terraform
$ cd Create-an-Audio-Transcript-with-Amazon-Transcribe-API-Gateway-Lambda-and-Terraform

$ terraform init
$ terraform apply --auto-approve

In the end, you will get the API URL

Now you can use postman for example to upload an audio file:

And in a few seconds, you can call the GET transcription endpoint

To destroy everything you just execute this command:

terraform apply --destroy --auto-approve

GitHub repository

You can find all the code written in this tutorial at https://github.com/laidani/Create-an-Audio-Transcript-with-Amazon-Transcribe-API-Gateway-Lambda-and-Terraform

Enjoy :)

In this article, we will create a process to get a notification if the price of silver or gold is below x price. This example can be used with any service, for example, to check airline prices or dates, amazon product prices, appointments, etc...

Architecture

The idea here is to start a Lambda using EventBridge, this Lambda will make an HTTP query, in this example, we use an endpoint from goldprice.org. If the price of gold is below 1500 EUR, the lambda will publish a notification in an SNS topic, and the topic will send an email, SMS, or both.

Lambda

The lambda is made using NodeJS, to create this you need to install NodeJS, then create a project using:

npm init

and follow the instructions.

Lambda code

After the project is created, create a file index.js then copy and paste the following code:

const request = require('request-promise');
const aws = require("aws-sdk");
const sns = new aws.SNS();

const priceAlert = 1500;

const options = {
    'method': 'GET',
    'url': 'https://data-asg.goldprice.org/dbXRates/EUR',
    resolveWithFullResponse: true
};

function check_gold_price() {
    return request(options);
}

function send_message(price) {
    const snsParams = {
        TopicArn: "arn:aws:sns:<Region>:<AccountId>:<TopicName>",
        Subject: "Gold price",
        Message: `Hey, the price of gold is ${price}`
    };
    let response = sns.publish(snsParams).promise();

    response.then(function () {
        console.log('Message has been sent');
    }).catch(function (err) {
        console.error(err, err.stack);
    });
}

exports.handler = () => {
    check_gold_price().then(response => {
        if (response.statusCode === 200 && response.body) {
            let json = JSON.parse(response.body);
            let price = json.items[0]?.xauPrice;
            if (price < priceAlert) {
                send_message(price);
            }
        }
    });
};

To install the missing modules, execute this command.

npm install

Lambda package

there are many ways to deploy your code to Lambda, in this article we will use the simple one, we will zip our code and upload it to the lambda.

As you have seen in the code of our Lambda, we use aws-sdk, this module is really big(>80MB), and we don't need it to be packaged with the other modules, because the Lambda runtime has already this module. to remove this module we can just execute:

npm uninstall aws-sdk

We need to zip the code like this:

Create AWS Lambda and upload the zip file

I assume you already have an AWS account, if not you can create one here https://aws.amazon.com/

In this article, we will create a Lambda from the AWS console, to do this:

• Login to your AWS Account

• Search Lambda

• Select Functions, and then click Create function button

• Then fill in the information, and in the end click Create function button

• Upload the zip file

The Lambda will look like this:

Create SNS Topic

To create an SNS Topic:

• Search SNS in the AWS console

• Select Simple Notification Service

• Select Topics and then click Create Topic button

• Choose a Standard topic and give a name to the topic like this

• Click at the end Create topic button

SNS Subscriptions

In this step, we will add an email to test the process, to do this:

• Amazon SNS > Subscriptions > Create subscription

In this example, we add only an email, you can add a phone number, and many other services to receive notifications.

Select the ARN of the topic and put it in TopicArn like this:

    const snsParams = {
        TopicArn: "arn:aws:sns:eu-west-1:1222331122:MyTopic",
        Subject: "Gold price",
        Message: `Hey, the price of gold is ${price}`
    };

Note: this is not the recommended way, and it is really bad in some cases, to do things better, you must use Environment variables, by Secret Manager, or KMS, it depends on your variables.

When you test the Lambda you will get this error:

To fix this error, you have to give your Lambda the right to publish SNS notifications, to do this:

• Select the Lambda's role from Lambda > Configuration > Permissions

• Create a new Policy that allows only sns:Publish and link it to this role

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": "sns:Publish",
            "Resource": "arn:aws:sns:eu-west-1:1222331122:MyTopic"
        }
    ]
}

Test again, and everything will work correctly, and you will receive an email and SMS that looks like this

Note: you need also to give the Lambda enough timeout, you can configure this on Lambda > Configuration > General configuration > Edit > and change the Timeout to 30sec for example.

EventBridge

Until now everything is good, we will just configure the EventBridge to launch the Lambda each period of time, to configure this:

• Search EventBrdidge in the AWS console

• Select Amazon EventBridge

• Select Rules then click Create rule button

• Give a name to this rule and choose the Schedule rule type and click the next button

• Choose "A schedule that runs at a regular rate, such as every 10 minutes" as the schedule pattern

• For the "Rate expression" for test purposes we use 5min and click the next button

• For "Target" select Lambda, and then choose the name of Lambda that we have created

• Click next > next > Create rule in the end

In this stage, the Lambda will be executed each 5min, if the price is below 1500 EUR, a notification will be sent via SNS.

That's it.

Terraform

You found the terraform for this sample here: https://github.com/laidani/Notification-system-using-AWS-lambda-SNS-EventBridge-and-Terraform