I’ll explain how to build a LINE bot by combining AWS CDK, LINE Messaging API, and the Hono web framework.

Have you ever wanted to automate communication with users through a LINE official account? Or perhaps you’re already using the LINE Messaging API but want to implement it with a more efficient serverless architecture?

In this article, I’ll show you how to build a LINE webhook processing system on AWS Lambda using the Hono framework with AWS CDK, creating an efficient and scalable LINE bot.

Prerequisites and Environment Setup

To understand this article, the following prerequisites will be helpful:

Basic understanding of how LINE bots work

Basic knowledge of AWS CDK

Basic TypeScript syntax

For the environment setup, you need to install the following tools:

# Assuming Node.js is already installed
npm install -g aws-cdk
npm install -g typescript

You’ll also need an AWS account and a LINE Developers account. You can create a LINE Developers account from the LINE Developers Console.

LINE Messaging API Basics

The LINE Messaging API allows you to automate message exchanges between LINE official accounts and users. Its main features are:

Webhook: An endpoint to receive messages from users

Reply API: An API to reply to user messages

Push API: An API to send messages to users

In this article, we’ll implement the Webhook with AWS Lambda and Hono, and use the Reply API to automatically respond to messages from users.

Project Structure

The overall structure of the project we’re building is as follows:

my-line-bot/
├── bin/
│   └── app.ts
├── lib/
│   └── school-app-backend-stack.ts
├── lambda/
│   ├── line-webhook.ts
│   └── utils/
│       └── line-client.ts
├── package.json
└── tsconfig.json

Creating the AWS CDK Stack

First, let’s define the necessary AWS resources using AWS CDK. We’ll primarily create the following resources:

Lambda function for the LINE Webhook

Lambda function URL

Here’s the code for lib/school-app-backend-stack.ts:

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import { aws_lambda_nodejs, aws_iam } from 'aws-cdk-lib';
import { FunctionUrlAuthType, LoggingFormat } from 'aws-cdk-lib/aws-lambda';
import { join } from 'path'

export class SchoolAppBackendStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps & {
    environment: string
  }) {
    super(scope, id, props);

    /**
     * LINE Message API handler
     */
    const lambdaLineMessageApiHandler = new aws_lambda_nodejs.NodejsFunction(this, `LINEWebhook-${props?.environment}`, {
      entry: join(__dirname, '../lambda/line-webhook.ts'),
      handler: 'handler',
      environment: {
        APP_ENV: props?.environment || 'dev',
        SNS_TOPIC_ARN: process.env.SLACK_NOTIFICATION_SNS_ARN as string,
        LINE_CHANNEL_ACCESS_TOKEN: process.env.LINE_CHANNEL_ACCESS_TOKEN as string,
        LINE_CHANNEL_SECRET: process.env.LINE_CHANNEL_SECRET as string,
      },
      loggingFormat: LoggingFormat.TEXT,
    });

    const lambdaLineMessageApiUrl = lambdaLineMessageApiHandler.addFunctionUrl({
      authType: FunctionUrlAuthType.NONE, // No authentication
    });

    new cdk.CfnOutput(this, 'LINEWebhookAPIURL', {
      value: lambdaLineMessageApiUrl.url,
      description: 'URL for the Lambda function',
    });
  }
}

In this code, we use NodejsFunction to define a TypeScript Lambda function and set environment variables for the LINE API channel access token and channel secret. We also create a Lambda Function URL to provide an endpoint accessible from outside.

Implementing the LINE Webhook Handler with Hono

Next, we’ll implement the webhook handler in the Lambda function using Hono. Hono is a lightweight, fast web framework that’s highly compatible with serverless environments.

First, let’s install the necessary packages:

npm install hono @line/bot-sdk

Here’s the code for lambda/line-webhook.ts:

import { Hono } from 'hono';
import { handle } from 'hono/aws-lambda';
import { Client, middleware, WebhookEvent } from '@line/bot-sdk';

// LINE client configuration
const config = {
  channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN || '',
  channelSecret: process.env.LINE_CHANNEL_SECRET || '',
};

// Initialize LINE client
const lineClient = new Client(config);

// Create Hono app
const app = new Hono();

// Set up LINE middleware
app.use('/webhook', async (c, next) => {
  const signature = c.req.header('x-line-signature');
  if (!signature) {
    return c.text('Invalid signature', 401);
  }

  // Get request body
  const body = await c.req.text();
  
  // Verify signature with LINE SDK middleware
  try {
    middleware(config)(
      { headers: { 'x-line-signature': signature }, body },
      {} as any,
      () => {}
    );
  } catch (err) {
    console.error('Invalid signature:', err);
    return c.text('Invalid signature', 401);
  }

  c.set('lineBody', JSON.parse(body));
  await next();
});

// Webhook endpoint
app.post('/webhook', async (c) => {
  const body = c.get('lineBody');
  
  // Process events
  await Promise.all(
    body.events.map(async (event: WebhookEvent) => {
      try {
        await handleEvent(event);
      } catch (err) {
        console.error('Error handling event:', err);
      }
    })
  );
  
  return c.text('OK');
});

// Event handler
async function handleEvent(event: WebhookEvent) {
  // Only process message events
  if (event.type !== 'message' || event.message.type !== 'text') {
    return;
  }

  // Received message text
  const receivedText = event.message.text;
  
  // Create reply message
  let replyText = `I received your message: "${receivedText}"!`;
  
  // Set response based on message (example: simple echo bot)
  if (receivedText.includes('hello')) {
    replyText = 'Hello! How can I help you today?';
  } else if (receivedText.includes('thank you')) {
    replyText = 'You\'re welcome! Feel free to ask if you have any other questions 😊';
  }

  // Send reply
  await lineClient.replyMessage(event.replyToken, {
    type: 'text',
    text: replyText,
  });
}

// Lambda Handler
export const handler = handle(app);

In this code:

We create a Hono application and define a handler for AWS Lambda

We implement middleware to verify LINE Messaging API signatures

We define a webhook endpoint to process events from LINE

We implement functionality to automatically reply when receiving text messages

Implementing the LINE Client Utility

To better separate functionality, we can extract the LINE client processing into a separate file. Here’s an example of lambda/utils/line-client.ts:

import { Client, ClientConfig, MessageAPIResponseBase } from '@line/bot-sdk';

export class LineClientWrapper {
  private client: Client;

  constructor(config: ClientConfig) {
    this.client = new Client(config);
  }

  /**
   * Send a text message
   */
  async sendTextMessage(to: string, text: string): Promise<MessageAPIResponseBase> {
    return this.client.pushMessage(to, {
      type: 'text',
      text,
    });
  }

  /**
   * Send multiple messages
   */
  async sendMessages(to: string, messages: any[]): Promise<MessageAPIResponseBase> {
    return this.client.pushMessage(to, messages);
  }

  /**
   * Reply with token
   */
  async replyWithToken(replyToken: string, messages: any): Promise<MessageAPIResponseBase> {
    return this.client.replyMessage(replyToken, messages);
  }
}

// Create default LINE client instance
export const lineClient = new LineClientWrapper({
  channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN || '',
  channelSecret: process.env.LINE_CHANNEL_SECRET || '',
});

With this utility class, you can more easily use the main features of the LINE Messaging API.

Deployment and Configuration

1. Deploying the CDK Project

To deploy the project, run the following commands:

# Set environment variables
export LINE_CHANNEL_ACCESS_TOKEN=your_access_token
export LINE_CHANNEL_SECRET=your_channel_secret
export SLACK_NOTIFICATION_SNS_ARN=your_sns_arn  # For notifications (optional)

# CDK deploy
cdk deploy

After successful deployment, you’ll see the Lambda Function URL in the output. You’ll set this URL in the LINE Developers Console.

2. Configuration in the LINE Developers Console

Log in to the LINE Developers Console

Select your provider and channel

Open the “Messaging API Settings” tab

In the “Webhook Settings” section, set the “Webhook URL” to the Lambda Function URL obtained from the CDK deployment, and add /webhook to the end (e.g., https://xxxx.lambda-url.ap-northeast-1.on.aws/webhook)

Turn on “Use webhook”

Click the “Verify” button to confirm that the webhook is correctly set up

Testing

Once the setup is complete, you can test the operation by sending a message to the LINE official account.

Add the LINE official account as a friend

Send a text message (e.g., “hello”)

If you receive an automatic reply from the bot, it’s working correctly!

Benefits of Using Hono

The benefits of using Hono in this implementation are:

Lightweight: Small bundle size, excellent for cold starts

Performance: Fast routing and processing

TypeScript Support: Type-safe Web API implementation

Middleware: Flexible middleware functionality for organized code

Multi-platform: The same code works in environments other than AWS Lambda

Troubleshooting

Here are common problems and their solutions:

1. Webhook Verification Fails

Check that the Webhook URL is correctly set in LINE Developers

Check that the channel secret and access token are correctly set as environment variables

Check that the path /webhook is included in the Lambda Function URL

2. No Reply to Messages

Check CloudWatch logs for errors

Add exception handling to the event processing part to get detailed logs

Check LINE Messaging API usage limits (free plans have a daily message sending limit)

3. Lambda Function Deployment Fails

Check that IAM role permissions are appropriate

Check that all dependency packages are installed

Check for TypeScript compilation errors

Advanced Implementation Ideas

Once you have the basic implementation working, you can add the following features for extension:

DynamoDB Integration: Store user information and conversation history

Amazon Lex/Bedrock: Add natural language processing for advanced conversation capabilities

Multiple Message Types: Support messages other than text, such as images and location information

Rich Menu: Add menus to improve bot operability

Authentication: Add user authentication to provide personalized services

Operational Considerations

For operations, be mindful of the following:

Security: Securely manage LINE channel secrets and access tokens

Monitoring: Set up log monitoring and alarms in CloudWatch

Cost Management: Monitor Lambda execution count and memory usage

Scaling: Consider strategies for handling increased traffic

Conclusion

In this article, I’ve shown you how to build a serverless LINE bot by combining AWS CDK, LINE Messaging API, and the Hono framework. This configuration has the following benefits:

Cost Efficiency: Pay-as-you-go with serverless architecture

Maintainability: Easy code organization with the Hono framework

Scalability: Easy integration with various AWS services

By combining the LINE Messaging API and AWS serverless services, you can create a low-cost solution to streamline communication between businesses and users.

As next steps, I recommend incorporating your own business logic into the bot or integrating LINE with web applications to provide a more advanced user experience.

I encourage you all to try developing services using LINE bots! If you have any questions or issues, please let me know in the comments section.

I hope this article was helpful.

Happy Coding!

Hideyoshi Okamoto

Tag: serverless architecture

Building a Message API with AWS CDK, LINE, and Hono