Building GPT 4 Serverless AWS Lambda Application

import OpenAI from "openai";
import {Request, Response} from "express";
 
const generatePrompt = () => {
   return (
      `You are developer GPT, expert in software engineering and programming.`
   )
}
 
export async function handler(req: Request, res: Response) {
   try {
      const {messages} = req.body;
      const systemPrompt = generatePrompt();
 
      const client = new OpenAI({
         apiKey: process.env.OPENAI_API_KEY
      });
      const completion = await client.chat.completions.create({
         model: "gpt-4",
         messages: [
            {
               role: "system",
               content: systemPrompt,
            },
            ...messages,
         ],
         stream: false,
      });
 
      const result = completion.choices[0].message;
      if (!result || !result?.content) {
         throw Error("No result");
      } else {
         console.log(result);
 
         res.status(200).send(result);
      }
 
   } catch (err) {
      console.error(err);
      res.sendStatus(500);
   }
}

import serverlessExpress from '@vendia/serverless-express';
import {app} from './app';
import AWS from 'aws-sdk';
 
let serverlessExpressInstance: any;
 
async function retrieveSecret(secretName: string): Promise<string | undefined> {
  const secretsManager = new AWS.SecretsManager({
    region: process.env.AWS_REGION ?? 'us-west-2'
  });
 
  try {
    const data = await secretsManager.getSecretValue({ SecretId: secretName }).promise();
 
    if (data && data.SecretString) {
      return data.SecretString;
    }
 
    // If the secret is binary, you can access it using `data.SecretBinary`.
 
    return undefined;
  } catch (err) {
    console.error('Error retrieving the secret:', err);
    throw err;
  }
}
 
async function asyncTask () {
  const openAiSecret = await retrieveSecret('prod/Openai');
  return {openAiSecret}
}
 
async function setup (event: any, context: any) {
  const {openAiSecret}  = await asyncTask();
  process.env.OPENAI_API_KEY = openAiSecret;
 
  serverlessExpressInstance = serverlessExpress({ app })
  return serverlessExpressInstance(event, context)
}
 
export function handler (event: any, context: any) {
  if (serverlessExpressInstance) return serverlessExpressInstance(event, context)
 
  return setup(event, context)
}

import {BackendServiceStage} from "./stage";
import {ComputeType} from "aws-cdk-lib/aws-codebuild";
import {CodeBuildStep, CodePipeline, CodePipelineSource, ManualApprovalStep} from "aws-cdk-lib/pipelines";
import {PolicyStatement} from "aws-cdk-lib/aws-iam";
import {Stack, StackProps} from "aws-cdk-lib";
import {Construct} from "constructs";
 
interface PipelineStackProps extends StackProps {
  repoName: string,
  repoOwner: string,
  branch: string,
  connectionArn: string,
  account: string,
  region: string;
  openAiSecretName: string,
}
 
export class BackendPipelineStack extends Stack {
 
  constructor(scope: Construct, id: string, props: PipelineStackProps) {
    super(scope, id, props);
 
    let source = CodePipelineSource.connection(`${props.repoOwner}/${props.repoName}`, props.branch, {
      connectionArn: props.connectionArn
    });
 
    const synth = new CodeBuildStep('Synth', {
      input: source,
      commands: [
        'cd deployment/',
        'export npm_config_cache=/tmp/.npm', // simplifies local development to avoid root owned .npm cache
        'npm ci',
        'npm run build',
        'npx cdk synth'
      ],
      primaryOutputDirectory: 'deployment/cdk.out',
    });
 
 
    const pipeline = new CodePipeline(this, 'pipeline', {
      crossAccountKeys: false,
      synth: synth,
      selfMutation: true,
      codeBuildDefaults: {
        buildEnvironment: {
          privileged: true,
          computeType: ComputeType.MEDIUM
        },
        rolePolicy: [new PolicyStatement({
          resources: ["*"],
          actions: ["secretsmanager:GetSecretValue"]
        })]
      }
    });
 
    const prod = new BackendServiceStage(this, 'ProdBackend', {
      openAiSecretName: props.openAiSecretName,
    });
 
    pipeline.addStage(prod, {
      pre: [
        new ManualApprovalStep("Promote to Prod")
      ]
    });
  }
}

import {Stack, StackProps} from "aws-cdk-lib";
import {Construct} from "constructs";
import {ApprovedNodeLambda} from "./constructs/approvedNodeLambdaConstruct";
import {Cors, LambdaIntegration, RestApi} from "aws-cdk-lib/aws-apigateway";
import {Secret} from "aws-cdk-lib/aws-secretsmanager";
 
export interface DeploymentStackProps extends StackProps {
  openAiSecretName: string;
  envVars?: Record<string, string>,
}
 
export class DeploymentStack extends Stack {
  constructor(scope: Construct, id: string, props: DeploymentStackProps) {
    super(scope, id, props);
 
    const openAiSecret = Secret.fromSecretNameV2(this, 'openAiSecret', props.openAiSecretName);
 
    const serverFunction = new ApprovedNodeLambda(this, 'backend-server', {
      codeDir: '../source/',
      description: 'backend server lambda function',
      handler: 'src/lambdaServer.handler',
      runtimeEnvironment: props.envVars ?? {}
    });
 
    openAiSecret.grantRead(serverFunction.lambda);
 
    const api = new RestApi(this, 'api', {
      restApiName: 'BackendApi',
      description: 'Api gateway for backend api',
      binaryMediaTypes: ['*/*']
    });
 
    api.root.addProxy({
      defaultCorsPreflightOptions: {
        allowOrigins: Cors.ALL_ORIGINS,
        allowMethods: Cors.ALL_METHODS,
      },
      defaultIntegration: new LambdaIntegration(serverFunction.lambda, {
        proxy: true
      }),
 
    });
  }
}