Alibaba cloud と Qwen LLM で LINE Chatbot を作成する

SDKError:
   StatusCode: 401
   Code: InvalidAccessKeyId
   Message: Your SLS service has not been opened.

infra/
├── live/dev/bot/
│   └── terragrunt.hcl
├── modules/bot/
│   └── .gitkeep
└── root.hcl
services/
└── ...

remote_state {
  backend = "oss"

  generate = {
    path      = "backend.tf"
    if_exists = "overwrite"
  }

  config = {
    bucket  = "linebot-tf-backend"
    key     = "${path_relative_to_include()}/terraform.tfstate"
    acl     = "private"
    region  = "ap-northeast-1"
    encrypt = true

    access_key = get_env("ALIBABA_CLOUD_ACCESS_KEY_ID")
    secret_key = get_env("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
  }
}

generate "provider" {
  path      = "provider.tf"
  if_exists = "overwrite"
  contents  = 
}

include "root" {
  path = find_in_parent_folders("root.hcl")
}

terraform {
  source = "${get_parent_terragrunt_dir("root")}/modules/bot"
}

inputs = {
  line_channel_secret = get_env("LINE_CHANNEL_SECRET")
  line_access_token   = get_env("LINE_ACCESS_TOKEN")
  dashscope_api_key   = get_env("ALIBABA_DASHSCOPE_API_KEY")
  root_path           = get_repo_root()
}

infra/modules/bot/
├── fc.tf
├── artifacts.tf
├── ram.tf
├── logs.tf
└── variables.tf

resource "alicloud_fcv3_function" "this" {
  function_name = "linebot-fc"
  runtime       = "nodejs20"
  handler       = "index.handler"
  cpu           = 0.25
  memory_size   = 256
  disk_size     = 512

  environment_variables = {
    LINE_CHANNEL_SECRET = var.line_channel_secret
    LINE_ACCESS_TOKEN   = var.line_access_token
    DASHSCOPE_API_KEY   = var.dashscope_api_key
  }

  role = alicloud_ram_role.fc_log_role.arn

  log_config {
    project  = alicloud_log_project.fc_logs.project_name
    logstore = alicloud_log_store.fc_logs.logstore_name
  }

  code {
    oss_bucket_name = alicloud_oss_bucket.artifacts.bucket
    oss_object_name = alicloud_oss_bucket_object.zipfile.key
  }
}

resource "alicloud_fcv3_trigger" "http" {
  trigger_name = "http"
  trigger_type = "http"
  qualifier    = "LATEST"
  trigger_config = jsonencode({
    disableURLInternet = false,
    authType           = "anonymous",
    methods            = ["POST"]
  })
  function_name = alicloud_fcv3_function.this.function_name
}


output "fc_http_public_url" {
  value = alicloud_fcv3_trigger.http.http_trigger[0].url_internet
}

resource "alicloud_oss_bucket" "artifacts" {
  bucket = "linebot-oss-bucket-fc-artifacts"
}

resource "alicloud_oss_bucket_object" "zipfile" {
  bucket = alicloud_oss_bucket.artifacts.bucket
  key    = "linebot-oss-object-fc-artifacts-${substr(data.archive_file.zip.output_sha, 0, 12)}.zip"
  source = data.archive_file.zip.output_path
}

data "archive_file" "zip" {
  type        = "zip"
  source_dir  = "${var.root_path}/services/bot"
  output_path = "${path.module}/code.zip"
}

resource "alicloud_ram_role" "fc_log_role" {
  role_name   = "linebot-role-fc-log-writer"
  description = "Allow FC to write logs to SLS"
  assume_role_policy_document = jsonencode({
    Version = "1",
    Statement = [{
      Effect    = "Allow",
      Action    = "sts:AssumeRole",
      Principal = { Service = ["fc.aliyuncs.com"] }
    }]
  })
}

resource "alicloud_ram_role_policy_attachment" "fc_log_role_attach" {
  role_name   = alicloud_ram_role.fc_log_role.role_name
  policy_type = "System"
  policy_name = "AliyunLogFullAccess"
}

resource "alicloud_log_project" "fc_logs" {
  project_name = "linebot-sls-pj-fc-logs"
  description  = "Function Compute logs"
}

resource "alicloud_log_store" "fc_logs" {
  project_name     = alicloud_log_project.fc_logs.project_name
  logstore_name    = "linebot-sls-ls-fc-logs"
  retention_period = 90
}

resource "alicloud_log_store_index" "fc_logs_index" {
  project  = alicloud_log_project.fc_logs.project_name
  logstore = alicloud_log_store.fc_logs.logstore_name

  full_text {
    case_sensitive = false
  }
}

service/bot/
├── src/
│   ├── llm/
│   │   └── openaiClient.js
│   ├── line/
│   │   ├── client.js
│   │   ├── isMentionToBot.js
│   │   └── verifySignature.js
│   └── bot/
│       └── process.js
├── index.js
└── package.json

async function replyMessage(replyToken, text) {
  const res = await fetch("https://api.line.me/v2/bot/message/reply", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Authorization": `Bearer ${ACCESS_TOKEN}`,
    },
    body: JSON.stringify({
      replyToken,
      messages: [{ type: "text", text }]
    })
  });

  if (!res.ok) {
    const body = await res.text();
    throw new Error(`LINE API ${res.status}: ${body}`);
  }
}

async function isMentionToBot(ev) {
  const mentionees = ev?.message?.mention?.mentionees;
  if (!Array.isArray(mentionees) || mentionees.length === 0) return false;

  
  if (mentionees.some(m => m?.isSelf === true)) return true;

  
  if (mentionees.some(m => m?.type === 'all')) return false;

  return false;
}

import crypto from 'node:crypto';

const CHANNEL_SECRET = process.env.LINE_CHANNEL_SECRET;


function verifyLineSignature(bodyStr, headers) {
  const signature = headers['X-Line-Signature'];

  const hmac = crypto.createHmac('sha256', CHANNEL_SECRET);
  hmac.update(bodyStr);
  const expected = hmac.digest('base64');

  return signature === expected;
}

import OpenAI from 'openai';

const API_KEY = process.env.DASHSCOPE_API_KEY;

const openai = new OpenAI({
  apiKey: API_KEY,
  baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
});

async function chatQwenTurbo(userText) {
  const completion = await openai.chat.completions.create({
    model: "qwen-turbo",
    messages: [
      {
        role: "system",
        content: "あなたはチャット相手です。名前は\"わんわんお\"です。必ず日本語で返答してください。返答はとても短く（1〜2文）、会話内容とあまり関係ない単語をときどき混ぜ込みます。"
      },
      { role: "user", content: userText || "こんにちは" }
    ],
    stream: false,
    enable_thinking: false
  });

  return completion.choices?.[0]?.message?.content ?? "（応答なし）";
}

import { replyMessage } from '../line/client.js';
import { chatQwenTurbo } from '../llm/openaiClient.js';
import { isMentionToBot } from '../line/isMentionToBot.js';

async function process(ev) {
  const replyToken = ev?.replyToken;
  const message    = ev?.message?.text;

  
  const shouldReply = await isMentionToBot(ev);
  if (!shouldReply) return;

  let reply;
  try {
    reply = await chatQwenTurbo(message);
  } catch (e) {
    console.error("Qwen API error:", e);
    reply = "LLM呼び出し中にエラーが発生しました";
  }

  await replyMessage(replyToken, reply);
}

import { verifyLineSignature } from './src/line/verifySignature.js';
import { process } from './src/bot/process.js';


function res(statusCode, body, headers = { "Content-Type": "text/plain" }) {
  return { statusCode, headers, body };
}

const ok        = (body = "ok")                => res(200, body);
const badReq    = (body = "bad request")       => res(400, body);
const forbidden = (body = "invalid signature") => res(403, body);
const error     = (body = "error")             => res(500, body);


export async function handler(event, context, callback) {
  let outer;
  try {
    const str = event.toString('utf8');
    outer = JSON.parse(str);
  } catch {
    return callback(null, badReq());
  }

  try {
    
    const bodyStr = typeof outer.body === "string" ? outer.body : JSON.stringify(outer.body || {});
    if (!verifyLineSignature(bodyStr, outer.headers)) {
      console.warn("Signature mismatch");
      return callback(null, forbidden());
    }

    
    const body = JSON.parse(bodyStr);
    const ev = body?.events?.[0] ?? null;

    if (ev?.type === "message" && ev.message?.type === "text") {
      await process(ev);
    }

    return callback(null, ok());
  } catch (e) {
    console.error(e);
    return callback(null, error());
  }
};