% composer require bref/bref bref/laravel-bridge --update-with-dependencies

% npm install @bref.sh/constructs

const vpc = new ec2.Vpc(this, "BrefVpc", {
  maxAzs: 1,
  natGateways: 0,
  restrictDefaultSecurityGroup: true,
  subnetConfiguration: [
    {
      name: "BrefPrivate",
      subnetType: ec2.SubnetType.PRIVATE_ISOLATED,
    },
  ],
});

const fileSystem = new efs.FileSystem(this, "BrefEfs", {
  vpc: vpc,
  removalPolicy: cdk.RemovalPolicy.DESTROY,
  performanceMode: efs.PerformanceMode.GENERAL_PURPOSE,
  throughputMode: efs.ThroughputMode.BURSTING,
  oneZone: true,
});

const accessPoint = this.fileSystem.addAccessPoint("BrefAccessPoint", {
  path: "/bref"
  createAcl: {
    ownerUid: "1001",
    ownerGid: "1001",
    permissions: "750",
  },
  posixUser: {
    uid: "1001",
    gid: "1001",
  },
});

const backendFn = new PhpFpmFunction(this, "BrefApiFunction", {
  functionName: "ApiFunction",
  handler: "public/index.php",
  code: packagePhpCode("../laravel/", {
    exclude: ["tests/**", "var/**"],
  }),
  timeout: cdk.Duration.seconds(28),
  memorySize: 1024,
  vpc: vpc,
  filesystem: lambda.FileSystem.fromEfsAccessPoint(
    accessPoint,
    "/mnt/efs",
  ),
  environment: {
    APP_ENV: "production",
    LOG_CHANNEL: "stderr",
    DB_CONNECTION: "sqlite",
    DB_DATABASE: "/mnt/efs/database.sqlite",
  },
  phpVersion: "8.4",
});

const api = new apigwv2.HttpApi(this, "BrefHttpApi", {
  defaultIntegration: new integrations.HttpLambdaIntegration(
    "Integration",
    backendFn,
  ),
});

new cdk.CfnOutput(this, "ApiUrl", {
  value: api.url!,
});

new ConsoleFunction(this, "BrefConsoleFunction", {
  functionName: "ConsoleFunction",
  handler: "artisan",
  code: packagePhpCode("../laravel/", {
    exclude: ["tests/**", "var/**"],
  }),
  timeout: cdk.Duration.seconds(28),
  memorySize: 512,
  vpc: vpc,
  filesystem: lambda.FileSystem.fromEfsAccessPoint(
    accessPoint,
    "/mnt/efs",
  ),
  environment: {
    APP_ENV: "production",
    LOG_CHANNEL: "stderr",
    DB_CONNECTION: "sqlite",
    DB_DATABASE: "/mnt/efs/database.sqlite",
  },
  phpVersion: "8.4",
});

% cdk deploy

(略)

Outputs:
BrefStack.ApiUrl = https://example.execute-api.ap-northeast-1.amazonaws.com/

% aws lambda invoke \
     --function-name ConsoleFunction \
     --region ap-northeast-1 \
     --cli-binary-format raw-in-base64-out \
     --payload '"migrate --force"' \
     response.json

{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}

$ cdk --version
2.148.0 (build e5740c0)

$ cdk init app --language typescript

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import { Platform } from 'aws-cdk-lib/aws-ecr-assets';
import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
import { HttpLambdaIntegration } from 'aws-cdk-lib/aws-apigatewayv2-integrations';

export class MyLambdaStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);
    const handler = new lambda.DockerImageFunction(this, 'Handler', {
      code: lambda.DockerImageCode.fromImageAsset('./my-remix', { // Remix アプリケーションのディレクトリ名とする
        platform: Platform.LINUX_AMD64,
      }),
      memorySize: 256,
      timeout: cdk.Duration.seconds(30),
    });

    new apigw.HttpApi(this, 'Api', {
      apiName: 'MyLambdaRemix',
      defaultIntegration: new HttpLambdaIntegration('Integration', handler),
    });
  }
}

$ npx create-remix@latest

FROM node:22-bookworm-slim AS base

FROM base AS deps
RUN mkdir /app
WORKDIR /app

COPY package.json package-lock.json ./
RUN npm ci

FROM base AS builder

RUN mkdir /app
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY . .

ENV NODE_ENV production
RUN npm run build

FROM base AS runner

# lambda-web-adapter
COPY --from=public.ecr.aws/awsguru/aws-lambda-adapter:0.5.0 /lambda-adapter /opt/extensions/lambda-adapter

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 remix

RUN mkdir /app
WORKDIR /app

RUN chown remix:nodejs ./
USER remix

COPY --from=builder --chown=remix:nodejs /app/node_modules ./node_modules
COPY --from=builder --chown=remix:nodejs /app/build ./build
COPY --from=builder --chown=remix:nodejs /app/public ./public
COPY --from=builder --chown=remix:nodejs /app/package.json /app/package-lock.json ./

ENV NODE_ENV production
ENV PORT 3000
EXPOSE 3000

CMD ["npm", "run", "start"]

COPY --from=public.ecr.aws/awsguru/aws-lambda-adapter:0.5.0 /lambda-adapter /opt/extensions/lambda-adapter

ENV PORT 3000

$ cdk deploy

cdk --version
2.54.0 (build 9f41881)

import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
import * as lambda from 'aws-cdk-lib/aws-lambda';

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

    const fn =  new lambda.Function(this, 'LambdaFunction', {
      runtime: lambda.Runtime.PYTHON_3_9,
      handler: 'app.lambda_handler',
      code: lambda.Code.fromAsset('./lambda'),
    });

    const fnUrl = fn.addFunctionUrl({
      authType: lambda.FunctionUrlAuthType.NONE,
    });
    new cdk.CfnOutput(this, 'TheUrl', {
      value: fnUrl.url,
    });
  }
}

def lambda_handler(event, context):
    return "Hello  world!!"

Outputs:
LambdaFunctionUrlsStack.TheUrl = https://xxxxxxxxxx.lambda-url.ap-northeast-1.on.aws/

curl https://xxxxxxxxxx.lambda-url.ap-northeast-1.on.aws/
Hello  world!!%

const fnUrl = fn.addFunctionUrl({
  authType: lambda.FunctionUrlAuthType.AWS_IAM,
});

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "lambda:InvokeFunctionUrl",
            "Resource": "*"
        }
    ]
}

cdk --version
2.2.0 (build 4f5c27c)

sam --version
SAM CLI, version 1.40.1

mkdir lambda-local-sam
cd lambda-local-sam
cdk init app --language typescript

import { Stack, StackProps } from 'aws-cdk-lib'
import { Construct } from 'constructs'
import * as path from "path"
import * as lambda from 'aws-cdk-lib/aws-lambda'

export class LambdaLocalSamStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props)

    new lambda.Function(this, 'MyFunction', {
      runtime: lambda.Runtime.PYTHON_3_7,
      handler: 'app.lambda_handler',
      code: lambda.Code.fromAsset('./lambda'),
    })
  }
}

def lambda_handler(event, context):
    return "Hello from SAM and the CDK!"

import { Stack, StackProps } from 'aws-cdk-lib'
import { Construct } from 'constructs'
import * as path from "path";
import * as nodeLambda from 'aws-cdk-lib/aws-lambda-nodejs'

export class LambdaLocalSamStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props)

    new nodeLambda.NodejsFunction(this, 'MyFunction', {
      entry: path.join(__dirname, '../lambda/index.ts'),
      handler: 'handler',
    })
  }
}

import { Handler } from 'aws-cdk-lib/aws-lambda'

export const handler: Handler = async function () {
    return "Hello from SAM and the CDK!";
}

cdk synth --no-staging

sam local invoke MyFunction --no-event -t ./cdk.out/LambdaLocalSamStack.template.json
(略)
"Hello from SAM and the CDK!"