AWS Lambda

mkdir my-app
cd my-app
cdk init app -l typescript
npm install hono
npm install -D esbuild
mkdir lambda
touch lambda/index.ts

mkdir my-app
cd my-app
cdk init app -l typescript
yarn add hono
yarn add -D esbuild
mkdir lambda
touch lambda/index.ts

mkdir my-app
cd my-app
cdk init app -l typescript
pnpm add hono
pnpm add -D esbuild
mkdir lambda
touch lambda/index.ts

mkdir my-app
cd my-app
cdk init app -l typescript
bun add hono
bun add -D esbuild
mkdir lambda
touch lambda/index.ts

import { Hono } from 'hono'
import { handle } from 'hono/aws-lambda'
 
const app = new Hono()
 
app.get('/', (c) => {
  return c.text('Hello AWS Lambda!')
})
 
app.get('/api/hello', (c) => {
  return c.json({
    message: 'Hello from Lambda',
    region: process.env.AWS_REGION,
  })
})
 
export const handler = handle(app)

import * as cdk from 'aws-cdk-lib'
import { Construct } from 'constructs'
import * as lambda from 'aws-cdk-lib/aws-lambda'
import { NodejsFunction } from 'aws-cdk-lib/aws-lambda-nodejs'
 
export class MyAppStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props)
 
    // Create Lambda function
    const fn = new NodejsFunction(this, 'HonoLambda', {
      entry: 'lambda/index.ts',
      handler: 'handler',
      runtime: lambda.Runtime.NODEJS_22_X,
      timeout: cdk.Duration.seconds(30),
      memorySize: 512,
    })
 
    // Create Function URL
    const fnUrl = fn.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    })
 
    // Output the URL
    new cdk.CfnOutput(this, 'FunctionUrl', {
      value: fnUrl.url,
    })
  }
}

cdk deploy

const fn = new NodejsFunction(this, 'HonoLambda', {
  entry: 'lambda/index.ts',
  handler: 'handler',
  runtime: lambda.Runtime.NODEJS_22_X,
  environment: {
    API_KEY: 'your-api-key',
    DATABASE_URL: 'postgresql://...',
  },
})

app.get('/config', (c) => {
  return c.json({
    apiKey: process.env.API_KEY,
    region: process.env.AWS_REGION,
  })
})

import { Hono } from 'hono'
import { handle } from 'hono/aws-lambda'
import type { LambdaEvent, LambdaContext } from 'hono/aws-lambda'
 
type Bindings = {
  event: LambdaEvent
  lambdaContext: LambdaContext
}
 
const app = new Hono<{ Bindings: Bindings }>()
 
app.get('/lambda-info', (c) => {
  return c.json({
    requestId: c.env.lambdaContext.awsRequestId,
    functionName: c.env.lambdaContext.functionName,
    remainingTime: c.env.lambdaContext.getRemainingTimeInMillis(),
    isBase64Encoded: c.env.event.isBase64Encoded,
  })
})
 
export const handler = handle(app)

import type { LambdaEvent } from 'hono/aws-lambda'
 
type Bindings = {
  event: LambdaEvent
}
 
const app = new Hono<{ Bindings: Bindings }>()
 
app.get('/request-info', (c) => {
  const requestContext = c.env.event.requestContext
  
  return c.json({
    requestId: requestContext.requestId,
    apiId: requestContext.apiId,
    stage: requestContext.stage,
    sourceIp: requestContext.identity?.sourceIp,
  })
})

app.get('/image', async (c) => {
  const imageBuffer = await fetchImage()
  
  c.header('Content-Type', 'image/png') // Binary content type
  return c.body(imageBuffer) // Automatically base64 encoded
})
 
app.get('/pdf', async (c) => {
  const pdfBuffer = await generatePDF()
  
  c.header('Content-Type', 'application/pdf')
  return c.body(pdfBuffer)
})

const fn = new NodejsFunction(this, 'HonoLambda', {
  entry: 'lambda/index.ts',
  handler: 'handler',
  runtime: lambda.Runtime.NODEJS_22_X,
})
 
const fnUrl = fn.addFunctionUrl({
  authType: lambda.FunctionUrlAuthType.NONE,
  invokeMode: lambda.InvokeMode.RESPONSE_STREAM, // Enable streaming
})

import { Hono } from 'hono'
import { streamHandle } from 'hono/aws-lambda'
import { streamText } from 'hono/streaming'
 
const app = new Hono()
 
app.get('/stream', (c) => {
  return streamText(c, async (stream) => {
    for (let i = 0; i < 100; i++) {
      await stream.writeln(`Line ${i}`)
      await stream.sleep(100)
    }
  })
})
 
// Use streamHandle instead of handle
export const handler = streamHandle(app)

import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
import { DynamoDBDocumentClient, GetCommand } from '@aws-sdk/lib-dynamodb'
 
const client = new DynamoDBClient({})
const docClient = DynamoDBDocumentClient.from(client)
 
app.get('/users/:id', async (c) => {
  const id = c.req.param('id')
  
  const result = await docClient.send(
    new GetCommand({
      TableName: 'Users',
      Key: { id },
    })
  )
  
  return c.json(result.Item)
})

import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3'
 
const s3 = new S3Client({})
 
app.post('/upload', async (c) => {
  const body = await c.req.arrayBuffer()
  
  await s3.send(
    new PutObjectCommand({
      Bucket: 'my-bucket',
      Key: 'file.txt',
      Body: Buffer.from(body),
    })
  )
  
  return c.json({ message: 'Uploaded successfully' })
})

import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs'
 
const sqs = new SQSClient({})
 
app.post('/queue', async (c) => {
  const data = await c.req.json()
  
  await sqs.send(
    new SendMessageCommand({
      QueueUrl: process.env.QUEUE_URL,
      MessageBody: JSON.stringify(data),
    })
  )
  
  return c.json({ message: 'Queued' })
})

import * as apigateway from 'aws-cdk-lib/aws-apigateway'
 
const api = new apigateway.LambdaRestApi(this, 'HonoApi', {
  handler: fn,
  proxy: true,
})

import * as apigatewayv2 from 'aws-cdk-lib/aws-apigatewayv2'
import * as integrations from 'aws-cdk-lib/aws-apigatewayv2-integrations'
 
const httpApi = new apigatewayv2.HttpApi(this, 'HonoHttpApi')
 
httpApi.addRoutes({
  path: '/{proxy+}',
  methods: [apigatewayv2.HttpMethod.ANY],
  integration: new integrations.HttpLambdaIntegration(
    'HonoIntegration',
    fn
  ),
})

import * as ec2 from 'aws-cdk-lib/aws-ec2'
 
const vpc = ec2.Vpc.fromLookup(this, 'VPC', {
  vpcId: 'vpc-xxxxx',
})
 
const fn = new NodejsFunction(this, 'HonoLambda', {
  entry: 'lambda/index.ts',
  handler: 'handler',
  runtime: lambda.Runtime.NODEJS_22_X,
  vpc,
  vpcSubnets: {
    subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
  },
})

// ✅ Import only what you need
import { Hono } from 'hono'
import { handle } from 'hono/aws-lambda'
 
// ❌ Avoid heavy imports at top level
// import * as AWS from 'aws-sdk' // Large package
 
// ✅ Lazy load when needed
app.get('/heavy', async (c) => {
  const AWS = await import('aws-sdk')
  // Use AWS SDK
})

// ❌ Don't hardcode
const dbUrl = 'postgresql://user:pass@host/db'
 
// ✅ Use environment variables
const dbUrl = process.env.DATABASE_URL

app.onError((err, c) => {
  console.error('Lambda error:', err)
  return c.json(
    { error: 'Internal Server Error' },
    500
  )
})

const fn = new NodejsFunction(this, 'HonoLambda', {
  // ...
  timeout: cdk.Duration.seconds(30), // Max 900s
  memorySize: 1024, // More memory = more CPU
})