Lambda レイヤーで Bedrock Mantle を使う — Docker 不要で 47 モデルを呼び出してみた

AWSTemplateFormatVersion: '2010-09-09'
Description: >-
  Bedrock Mantle SDK Lambda Layer (ARM64) - CodeBuild でビルドし S3 経由でレイヤー公開

Parameters:
  ProjectName:
    Type: String
    Default: bedrock-mantle-sdk-layer
  LayerZipKey:
    Type: String
    Default: layers/bedrock-mantle-sdk/layer-arm64.zip
  DeployLayer:
    Type: String
    Default: "false"
    AllowedValues: ["true", "false"]

Conditions:
  CreateLayer: !Equals [!Ref DeployLayer, "true"]

Resources:
  ArtifactBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub "${ProjectName}-${AWS::AccountId}-${AWS::Region}"
      LifecycleConfiguration:
        Rules:
          - Id: CleanupOldArtifacts
            Status: Enabled
            ExpirationInDays: 90

  CodeBuildRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${ProjectName}-codebuild-role"
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: codebuild.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: CodeBuildPolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - s3:PutObject
                  - s3:GetObject
                  - s3:GetBucketLocation
                Resource:
                  - !GetAtt ArtifactBucket.Arn
                  - !Sub "${ArtifactBucket.Arn}/*"
              - Effect: Allow
                Action:
                  - logs:CreateLogGroup
                  - logs:CreateLogStream
                  - logs:PutLogEvents
                Resource:
                  - !Sub "arn:aws:logs:${AWS::Region}:${AWS::AccountId}:log-group:/aws/codebuild/${ProjectName}-arm64:*"

  CodeBuildProjectArm64:
    Type: AWS::CodeBuild::Project
    Properties:
      Name: !Sub "${ProjectName}-arm64"
      Description: Build Lambda Layer zip (ARM64 native)
      ServiceRole: !GetAtt CodeBuildRole.Arn
      TimeoutInMinutes: 15
      Environment:
        Type: ARM_CONTAINER
        ComputeType: BUILD_GENERAL1_SMALL
        Image: aws/codebuild/amazonlinux2-aarch64-standard:3.0
        EnvironmentVariables:
          - Name: S3_BUCKET
            Value: !Ref ArtifactBucket
          - Name: S3_KEY
            Value: !Ref LayerZipKey
      Source:
        Type: S3
        Location: !Sub "${ArtifactBucket}/${ProjectName}/source.zip"
        BuildSpec: buildspec.yml
      Artifacts:
        Type: NO_ARTIFACTS

  LambdaLayerArm64:
    Type: AWS::Lambda::LayerVersion
    Condition: CreateLayer
    Properties:
      LayerName: !Sub "${ProjectName}-arm64"
      Description: "Bedrock Mantle SDK Layer (arm64) - aws-bedrock-token-generator, openai, anthropic"
      Content:
        S3Bucket: !Ref ArtifactBucket
        S3Key: !Ref LayerZipKey
      CompatibleRuntimes:
        - python3.13
        - python3.12
      CompatibleArchitectures:
        - arm64

Outputs:
  ArtifactBucketName:
    Value: !Ref ArtifactBucket
  CodeBuildProjectArm64Name:
    Value: !Ref CodeBuildProjectArm64
  LayerArn:
    Condition: CreateLayer
    Value: !Ref LambdaLayerArm64
  SourceUploadPath:
    Value: !Sub "s3://${ArtifactBucket}/${ProjectName}/source.zip"

AWSTemplateFormatVersion: '2010-09-09'
Description: >-
  Bedrock Mantle Lambda (Layer版) — Docker/ECR不要、標準Pythonランタイム + レイヤーのみ

Parameters:
  FunctionName:
    Type: String
    Default: bedrock-mantle-layer-test
  LayerArn:
    Type: String
    Default: arn:aws:lambda:us-east-1:123456789012:layer:bedrock-mantle-sdk-layer-arm64:1

Resources:
  LambdaRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub "${FunctionName}-role"
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: BedrockMantle
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - bedrock-mantle:CreateInference
                  - bedrock-mantle:CallWithBearerToken
                Resource: "*"

  MantleFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: !Ref FunctionName
      Runtime: python3.13
      Handler: index.handler
      Architectures:
        - arm64
      MemorySize: 512
      Timeout: 120
      Role: !GetAtt LambdaRole.Arn
      Layers:
        - !Ref LayerArn
      Environment:
        Variables:
          BEDROCK_REGION: us-east-1
      Code:
        ZipFile: |
          import json
          import os
          import time

          import anthropic
          from aws_bedrock_token_generator import provide_token
          from openai import OpenAI

          REGION = os.environ.get("BEDROCK_REGION", "us-east-1")
          BASE_URL = f"https://bedrock-mantle.{REGION}.api.aws"

          OPENAI_V1_PREFIXES = ("google.gemma-4", "xai.")
          RESPONSES_PREFIXES = ("openai.gpt-5.",)
          ANTHROPIC_PREFIXES = ("anthropic.",)

          def _get_route(model_id: str) -> str:
              if any(model_id.startswith(p) for p in ANTHROPIC_PREFIXES):
                  return "anthropic"
              if any(model_id.startswith(p) for p in RESPONSES_PREFIXES):
                  return "responses"
              if any(model_id.startswith(p) for p in OPENAI_V1_PREFIXES):
                  return "openai_v1"
              return "v1"

          def _openai_client(base_path: str) -> OpenAI:
              token = provide_token(region=REGION)
              return OpenAI(base_url=f"{BASE_URL}{base_path}", api_key=token)

          def _anthropic_client() -> anthropic.Anthropic:
              token = provide_token(region=REGION)
              return anthropic.Anthropic(
                  base_url=f"{BASE_URL}/anthropic", api_key=token
              )

          def invoke_anthropic(model_id, system, user_message):
              client = _anthropic_client()
              response = client.messages.create(
                  model=model_id,
                  max_tokens=4096,
                  system=system,
                  messages=[{"role": "user", "content": user_message}],
              )
              text = "".join(b.text for b in response.content if b.type == "text")
              return {
                  "text": text,
                  "usage": {
                      "inputTokens": response.usage.input_tokens,
                      "outputTokens": response.usage.output_tokens,
                      "totalTokens": response.usage.input_tokens + response.usage.output_tokens,
                  },
              }

          def invoke_responses(model_id, system, user_message):
              client = _openai_client("/openai/v1")
              response = client.responses.create(
                  model=model_id,
                  input=[
                      {"role": "developer", "content": system},
                      {"role": "user", "content": user_message},
                  ],
                  max_output_tokens=4096,
              )
              text = response.output_text or ""
              return {
                  "text": text,
                  "usage": {
                      "inputTokens": response.usage.input_tokens,
                      "outputTokens": response.usage.output_tokens,
                      "totalTokens": response.usage.total_tokens,
                  },
              }

          def invoke_chat(model_id, system, user_message, base_path):
              client = _openai_client(base_path)
              response = client.chat.completions.create(
                  model=model_id,
                  messages=[
                      {"role": "system", "content": system},
                      {"role": "user", "content": user_message},
                  ],
                  max_tokens=4096,
              )
              text = response.choices[0].message.content or ""
              usage = None
              if response.usage:
                  usage = {
                      "inputTokens": response.usage.prompt_tokens,
                      "outputTokens": response.usage.completion_tokens,
                      "totalTokens": response.usage.total_tokens,
                  }
              return {"text": text, "usage": usage}

          def handler(event, context):
              body = event if isinstance(event, dict) else json.loads(event.get("body", "{}"))

              model_id = body["modelId"]
              system = body.get("system", "You are a helpful assistant.")
              user_message = body.get("message", "Hello!")

              route = _get_route(model_id)
              start = time.time()

              try:
                  if route == "anthropic":
                      result = invoke_anthropic(model_id, system, user_message)
                      path = "/anthropic/v1/messages"
                  elif route == "responses":
                      result = invoke_responses(model_id, system, user_message)
                      path = "/openai/v1/responses"
                  elif route == "openai_v1":
                      result = invoke_chat(model_id, system, user_message, "/openai/v1")
                      path = "/openai/v1/chat/completions"
                  else:
                      result = invoke_chat(model_id, system, user_message, "/v1")
                      path = "/v1/chat/completions"

                  elapsed_ms = int((time.time() - start) * 1000)

                  return {
                      "modelId": model_id,
                      "route": path,
                      "text": result["text"],
                      "elapsedMs": elapsed_ms,
                      "usage": result.get("usage"),
                  }

              except Exception as e:
                  elapsed_ms = int((time.time() - start) * 1000)
                  return {
                      "modelId": model_id,
                      "route": route,
                      "error": str(e),
                      "elapsedMs": elapsed_ms,
                  }

Outputs:
  FunctionArn:
    Value: !GetAtt MantleFunction.Arn
  FunctionName:
    Value: !Ref MantleFunction