serverless 3.40.0 access logging still use nodejs 18 which will be deprecated

[300LiterPropofol]

Issue description

I am using serverless 3.40.0. I am enabling access logging in my serverless file.

provider:
  logs:
    restApi:
      accessLogging: true

This config automatically creates a lambda function named custom-resource-apigw-cw-role and it is using NodeJS 18.
NodeJS 18 will be deprecated by AWS soon, as a user I see no option to update the lambda runtime myself. I think it is hardcoded in your framework.
What is your plan for this access logging lambda function that uses nodejs 18, when are you going to update it?
Thank you!

Context

No response

[narley]

Same here, but on version 3.39.0.

[abhijeet-toptal]

Same here!

[bradwood]

Related to #12133

[nthornton2010]

Node 18 will be officially deprecated by AWS on September 1. New functions will not be allowed October 1 and all deployments will be prevented November 1. Clock's ticking not just for Serverless Framework v3 but all of those depending on it and now waiting for a solution.

https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html

[300LiterPropofol]

Any progress on it?

[dave-continuum-media]

We've hit the same problem, decided to disable access logging on the API G/W which removed the Lambda. Might look at #12133 (comment) which is a viable workaround but a little hacky. But this is pushing us to migrate away.

[300LiterPropofol]

Since the clock is ticking, and we do need access logging and api gateway creation etc.
We decided to migrate to native AWS CDK.
After some testing, we managed to replicate all the existing functionalities that our current serverless framework does.
For anyone who struggles with this, we share the AWS CDK solution below in case it is useful for you. We use NodeJS version of aws CDK.

Starts from the original code base and code structure where your serverless.yml is located. Add a folder in this path with structure

cdk/
- bin/app.js
- lib/app-stack.js
- cdk.json
- package.json

This cdk/ folder is for replacing the serverless.yml file in this path, all other handlers stay unchanged in the same path.
The package.json file looks something like this

{
    "name": "app",
    "version": "1.0.0",
    "description": "",
    "scripts": {
        "deploy": "cdk deploy --require-approval never",
        "synth": "cdk synth"
    },
    "repository": {
        "type": "git",
        "url": "git@..."
    },
    "license": "ISC",
    "author": "",
    "dependencies": {
        "aws-cdk-lib": "2.208.0",
        "constructs": "10.4.2",
        "dotenv": "17.2.1"
    }
}

And then use your local terminal to go under cdk/, run npm i to install the dependencies, then a package-lock.json will automatically pop out under the same cdk/ path.

The cdk.json file looks something like this

{
    "app": "node bin/app.js"
}

The bin/app.js looks something like this

const cdk = require('aws-cdk-lib');
const { PatsStationStack } = require('../lib/app-stack');

const stage = process.env.STAGE; // environment variable that is input during deployment as opt, same as the env that you use when `serverless deploy --stage STAGE
const service = process.env.SERVICE; // environment variable that is input during deployment as opt, same as the first line like `service: SERVICE` in your serverless.yml file 
const app = new cdk.App();
new AppStack(app, `${service}-${stage}`, {
    env: {
        account: process.env.CDK_DEFAULT_ACCOUNT, // account needs to be specified when vpc is used in the stack, otherwise CDK can recognize the account automatically and we don't need to note here
        region: 'your region'
    }
});

The longest and most complicated is the lib/app-stack.js which essentially replaces serverless and sets up all the infrastructure. In our case we need API gateway creation, custom domian, step functions, vpc, multiple lambdas, cloudwatch log group management, access logging, tracing and other stuff handled in this same stack. All our actual lambda handlers is in Python, and they can keep unchanged in its original path. If your usecase is similar, the file looks something like this.

const cdk = require('aws-cdk-lib');
const { Stack } = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const kms = require('aws-cdk-lib/aws-kms');
const ec2 = require('aws-cdk-lib/aws-ec2');
const logs = require('aws-cdk-lib/aws-logs');
const iam = require('aws-cdk-lib/aws-iam');
const apigateway = require('aws-cdk-lib/aws-apigateway');
const stepfunctions = require('aws-cdk-lib/aws-stepfunctions');
const stepfunctionTasks = require('aws-cdk-lib/aws-stepfunctions-tasks');
const acm = require('aws-cdk-lib/aws-certificatemanager');
const route53 = require('aws-cdk-lib/aws-route53');
const route53Targets = require('aws-cdk-lib/aws-route53-targets');
const path = require('path');
const dotenv = require('dotenv');
const fs = require('fs');

class AppStack extends Stack {
    constructor(scope, id, props) {
        super(scope, id, props);

        const stage = process.env.STAGE; // environment variable that is input during deployment as opt
        const service = process.env.SERVICE; // environment variable that is input during deployment as opt
        // load environment variables from .env.xx file
        dotenv.config({ path: path.resolve(__dirname, `../.env.${stage}`) }); // CI job has copied env files under /cdk

        const rootPath = path.join(__dirname, '../../');

        const genericLambdaRole = new iam.Role(this, 'genericLambdaRole', {
            roleName: `${service}-${stage}-lambdaRole`,
            assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
            inlinePolicies: {
                genericLambdaPolicy: new iam.PolicyDocument({
                    statements: [
                        new iam.PolicyStatement({
                            actions: [
                                'logs:CreateLogGroup',
                                'logs:CreateLogStream',
                                'logs:PutLogEvents'
                            ],
                            resources: [
                                process.env.log_group_arn,
                                process.env.log_stream_arn
                            ]
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'secretsmanager:GetSecretValue',
                                'secretsmanager:DescribeSecret'
                            ],
                            resources: [
                                process.env.mongodb_arn_secret
                            ]
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'ec2:CreateNetworkInterface',
                                'ec2:DescribeNetworkInterfaces',
                                'ec2:DeleteNetworkInterface'
                            ],
                            resources: ['*'] // action does not support resource-level permissions Ref: https://docs.aws.amazon.com/IAM/latest/UserGuide/troubleshoot_policies.html#unsupported-services-actions
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'ec2:AssignPrivateIpAddresses',
                                'ec2:UnassignPrivateIpAddresses'
                            ],
                            resources: [
                                `arn:aws:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:network-interface/*`, // does not know eni id before deployment
                                `arn:aws:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:subnet/${process.env.subnet_IDs_1}`,
                                `arn:aws:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:subnet/${process.env.subnet_IDs_2}`,
                                `arn:aws:ec2:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:subnet/${process.env.subnet_IDs_3}`
                            ]
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'sqs:SendMessage',
                                'sqs:GetQueueAttributes',
                                'sqs:GetQueueUrl',
                                'sqs:ListDeadLetterSourceQueues'
                            ],
                            resources: [
                                process.env.sqs_arn,
                                process.env.sqs_arn_deadletter,
                            ]
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'sqs:ListQueues'
                            ],
                            resources: ['*'] // action does not support resource-level permissions
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'kms:Encrypt',
                                'kms:Decrypt',
                                'kms:DescribeKey',
                                'kms:GenerateDataKey*'
                            ],
                            resources: [
                                process.env.kms_key_arn
                            ]
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'states:DescribeExecution',
                                'states:StartExecution',
                                'states:GetExecutionHistory'
                            ],
                            resources: [
                                `arn:aws:states:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:stateMachine:AppStateMachine${process.env.stage_short}`,
                                `arn:aws:states:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:execution:AppStateMachine${process.env.stage_short}:*`,
                                `arn:aws:states:${cdk.Stack.of(this).region}:${cdk.Stack.of(this).account}:express:AppStateMachine${process.env.stage_short}:*`
                            ]
                        }),
                        new iam.PolicyStatement({
                            actions: [
                                'sns:Publish'
                            ],
                            resources: [
                                process.env.sns_topic_arn
                            ]
                        })
                    ]
                })
            }
        });

        // because all our lambda handlers are in Python, we need to build code bundle in code as here
        const genericCodeAsset = lambda.Code.fromAsset(rootPath, {
            bundling: {
                local: {
                    tryBundle(outputDir) {
                        const { execSync } = require('child_process');
                        try {
                            // install python dependencies abd copy files
                            execSync(`pip install -r ${rootPath}/requirements.txt -t ${outputDir}`, { stdio: 'inherit' });
                            execSync( `rsync -a --exclude='cdk/' --exclude='cdk.out/' ${rootPath}/ ${outputDir}`, { stdio: 'inherit' }); // Since App is a complex structure, there are many files related to each function, for simplicity, we copy everything under root, meanwhile we cannot copy the cdk/ deployment folder itself, otherwise error
                            return true; 
                        } catch (error) {
                            console.error('Local bundling failed:', error);
                            return false; 
                        }
                    }
                },
                // fallback to Docker if local fails (won't be used in CI)
                image: lambda.Runtime.PYTHON_3_13.bundlingImage,
                command: [
                    'bash', '-c',
                    [
                        'pip install -r requirements.txt -t /asset-output',
                        'cp -au . /asset-output'
                    ].join(' && ')
                ]
            }
        });

        // Explicitly find the vpc that already exists, this is done automcatically in serverless but needs to be done explicitly in CDK
        const vpc = ec2.Vpc.fromLookup(this, 'ImportedVpc', {
            tags: {
                // your own vpc tag
            }
        });

        const securityGroups = [
            ec2.SecurityGroup.fromSecurityGroupId(this, 'ImportedSecurityGroup', process.env.security_group_ID)
        ];
        const vpcSubnets = [
            ec2.Subnet.fromSubnetId(this, 'ImportedMongoSubnet1', process.env.subnet_IDs_1),
            ec2.Subnet.fromSubnetId(this, 'ImportedMongoSubnet2', process.env.subnet_IDs_2),
            ec2.Subnet.fromSubnetId(this, 'ImportedMongoSubnet3', process.env.subnet_IDs_3)
        ];

        const api = new apigateway.RestApi(this, 'AppApi', {
            restApiName: `${service}-${stage}`, // this is for replicating serverless behavior when they create the api gateway
            endpointTypes: [apigateway.EndpointType.REGIONAL],
            deployOptions: {
                stageName: stage,
                tracingEnabled: true,
                metricsEnabled: true,
                accessLogDestination: new apigateway.LogGroupLogDestination(
                    new logs.LogGroup(this, 'AppAccessLogging', {
                        logGroupName: `/aws/api-gateway/execution-logs/${service}-${stage}`,
                        retention: logs.RetentionDays.TWO_WEEKS
                    })
                ),
                accessLogFormat: apigateway.AccessLogFormat.jsonWithStandardFields(), // all fields are turned on by default
                loggingLevel: apigateway.MethodLoggingLevel.INFO, // INFO is the default logging level, we can also set it to ERROR or OFF
                dataTraceEnabled: true, // enable data tracing for API Gateway, this will allow us to see the detailed request and response data in CloudWatch logs, the most detailed execution log is on this option
            },
            defaultCorsPreflightOptions: {
                allowOrigins: apigateway.Cors.ALL_ORIGINS,
                allowMethods: apigateway.Cors.ALL_METHODS
            },
            disableExecuteApiEndpoint: true // must use the custom domain
        });
        // the api access logging enabling will automatically create another /aws/api-gateway/.. log group as AWS internal provision, we set the retention for it¨
        new logs.LogRetention(this, 'ApiGatewaySideLogRetention', {
            logGroupName: `/aws/api-gateway/${api.restApiName}`, // the name prefix is the pattern of AWS
            retention: logs.RetentionDays.TWO_WEEKS
        });
        new logs.LogRetention(this, 'ApiGatewayTracingLogRetention', {
            logGroupName: `API-Gateway-Execution-Logs_${api.restApiId}/${stage}`, // the name prefix is the pattern of AWS
            retention: logs.RetentionDays.TWO_MONTHS // keep longer on purpose since this is the most detailed record for debug
        });

        // Gather environment variables that are needed for different lambda functions
        const environmentVariablesInAuthorizer = {
            account_id: cdk.Stack.of(this).account,
            aws_region: cdk.Stack.of(this).region,
            apigateway_id: api.restApiId,
            public_url: process.env.public_token_url,
            audience: process.env.audience_auth0, // if you use auth0 for authentication and put audience as env var
            auth_audience_file: process.env.auth0_audience_filename // if you use auth0 for authentication and put audience as a separate file
        };
        const environmentVariablesInHandler = {
            // all environment variables go here, the same env vars as you put under provider.environment in serverless.yml
        };

        // BasePath for all endpoints, i.e., the same as the customDomain.basePath: app if you use serverless-domain-manager plugin
        // And this /app is handled in apigateway.BasePathMapping so we don't need to addSource here otherwise we got two /app in the endpoints
        const basePath = api.root;

        // we have health check endpoint that does not need auth
        const healthCheckFunctionName = `${service}-${stage}-health_check`;
        const healthCheckFunction = new lambda.Function(this, 'HealthCheckFunction', {
            functionName: healthCheckFunctionName,
            description: 'Lambda function that listens to GET request without authentication to check if the service is up and running',
            runtime: lambda.Runtime.PYTHON_3_13,
            handler: 'handler.health_check',
            role: genericLambdaRole,
            code: genericCodeAsset,
            memorySize: ,
            timeout: cdk.Duration.seconds(30), // api gateway has maximum 30 timeout, so more than that does not function anyway
            reservedConcurrentExecutions: ,
            vpc,
            securityGroups,
            vpcSubnets,
            environment: environmentVariablesInHandler
        });
        new logs.LogRetention(this, 'HealthCheckLogRetention', {
            logGroupName: `/aws/lambda/${healthCheckFunctionName}`, // prefix is defined and auto-generated by AWS
            retention: logs.RetentionDays.TWO_WEEKS
        });

        const healthCheckPath= basePath.addResource('health');
        healthCheckPath.addMethod('GET', new apigateway.LambdaIntegration(healthCheckFunction), {
            authorizer: undefined // no authorizer for health check
        });

        // authorizers, we have multiple endpoints defined in this stack and different endpoints have different authorizers
        // Each authorizer is set up and attached independently
        // By default authorizerResultTtlInSeconds is 300 seconds, we will just use the default value and skip this assignment
        const appAuthorizerFunctionName = `${service}-${stage}-app_authorizer`;
        const appAuthorizerFunction = new lambda.Function(this, 'AppAuthorizerFunction', {
            functionName: appAuthorizerFunctionName,
            description: 'Lambda function that works as the authorizing layer to verify app POST request sender permission',
            runtime: lambda.Runtime.PYTHON_3_13,
            handler: 'authorizer.app_authorizer',
            role: genericLambdaRole,
            code: genericCodeAsset,
            memorySize: ,
            timeout: cdk.Duration.seconds(30),
            reservedConcurrentExecutions: ,
            vpc,
            securityGroups,
            vpcSubnets,
            environment: environmentVariablesInAuthorizer
        });
        new logs.LogRetention(this, 'AppAuthorizerLogRetention', {
            logGroupName: `/aws/lambda/${appAuthorizerFunctionName}`,
            retention: logs.RetentionDays.TWO_WEEKS
        });
        const appAuthorizer = new apigateway.RequestAuthorizer(this, 'AppRequestAuthorizer', {
            handler: appAuthorizerFunction,
            identitySources: [apigateway.IdentitySource.header('your-token-name')]
        }); // RequestAuthorizer looks at the whole request body, if you need custiomized header, you have to use this instead of TokenAuthorizer, this is for replacing events.http.authorizer.identitySource:method.request.header.your-token-name in serverless
        // ......repeat this authorizer setting up depending on how many authorizer you have, this set up needs to be done the same times as the number of authorizer handlers

        //set up all lambda functions that actually do the app logic for each endpoints
		// In our case we need a step function,i.e., state machine so we will also show an example how to set that up
        // Example: Two sub-functions that will compose the main state machine of this Stack, i.e., the main endpoint
        const appFunctionName = `${service}-${stage}-app_handler`;
        const appFunction = new lambda.Function(this, 'AppFunction', {
            functionName: appFunctionName,
            description: '',
            runtime: lambda.Runtime.PYTHON_3_13,
            handler: 'handler.app_handler',
            role: genericLambdaRole,
            code: genericCodeAsset,
            memorySize: ,
            timeout: cdk.Duration.seconds(30),
            reservedConcurrentExecutions: 25,
            vpc,
            securityGroups,
            vpcSubnets,
            environment: environmentVariablesInHandler
        });
        new logs.LogRetention(this, 'AppLogRetention', {
            logGroupName: `/aws/lambda/${appFunctionName}`,
            retention: logs.RetentionDays.TWO_WEEKS
        });

        const app2FunctionName = `${service}-${stage}-app2_handler`;
        const app2Function = new lambda.Function(this, 'App2Function', {
            functionName: app2FunctionName,
            description: '',
            runtime: lambda.Runtime.PYTHON_3_13,
            handler: 'handler.app2_handler',
            role: genericLambdaRole,
            code: genericCodeAsset,
            memorySize: ,
            timeout: cdk.Duration.seconds(30),
            reservedConcurrentExecutions: ,
            vpc,
            securityGroups,
            vpcSubnets,
            environment: environmentVariablesInHandler
        });
        new logs.LogRetention(this, 'App2LogRetention', {
            logGroupName: `/aws/lambda/${app2FunctionName}`,
            retention: logs.RetentionDays.TWO_WEEKS
        });

        // Start compose the state machine that has two parallel bnanches
        const appTask = new stepfunctionTasks.LambdaInvoke(this, 'AppTask', {
            lambdaFunction: appFunction,
            outputPath: '$.Payload'
        });
        const app2Task = new stepfunctionTasks.LambdaInvoke(this, 'App2Task', {
            lambdaFunction: app2Function,
            outputPath: '$.Payload'
        });
        const parallelState = new stepfunctions.Parallel(this, 'ParallelState')
            .branch(appTask)
            .branch(app2Task);
        const parallelStateMachine = new stepfunctions.StateMachine(this, 'AppStateMachine', {
            stateMachineName: `AppStateMachine${process.env.stage_short}`,
            definitionBody: stepfunctions.DefinitionBody.fromChainable(parallelState)
        });

        const appStateMachineFunctionName = `${service}-${stage}-startExecution`;
        const appStateMachineFunction = new lambda.Function(this, 'AppStateMachineFunction', {
            functionName: appStateMachineFunctionName,
            description: 'Wrapper Lambda function outside of the parallel step function',
            runtime: lambda.Runtime.PYTHON_3_13,
            handler: 'wrapper.start',
            role: genericLambdaRole,
            code: genericCodeAsset,
            memorySize: ,
            timeout: cdk.Duration.seconds(30),
            reservedConcurrentExecutions: ,
            vpc,
            securityGroups,
            vpcSubnets,
            environment: {
                statemachine_arn: parallelStateMachine.stateMachineArn, // this will be used inside the wrapper.start handler to trigger the state machine
                aws_region: cdk.Stack.of(this).region
            }
        });
        new logs.LogRetention(this, 'AppStateMachineLogRetention', {
            logGroupName: `/aws/lambda/${appStateMachineFunctionName}`,
            retention: logs.RetentionDays.TWO_WEEKS
        });
        
		// ......other lambda functions setting up, repeat
        const app3FunctionName = `${service}-${stage}-app3_handler`;
        const app3Function = new lambda.Function(this, 'App3Function', {
            functionName: app3FunctionName,
            description: '',
            runtime: lambda.Runtime.PYTHON_3_13,
            handler: 'handler.app3_handler',
            role: genericLambdaRole,
            code: genericCodeAsset,
            memorySize: ,
            timeout: cdk.Duration.seconds(30),
            reservedConcurrentExecutions: ,
            vpc,
            securityGroups,
            vpcSubnets,
            environment: environmentVariablesInHandler
        });
        new logs.LogRetention(this, 'App3LogRetention', {
            logGroupName: `/aws/lambda/${app3FunctionName}`,
            retention: logs.RetentionDays.TWO_WEEKS
        });

        // set up all the endpoints paths, the HTTP address that your request will call
        const appPath = basePath.addResource('app');
        const app3BasePath = basePath.addResource('app3');
        const app3Path = app3BasePath.addResource('app3'); // the addSource syntax does not accept slash inside the input parameter, so if you are setting up an endpoint with slash, you do it by adding one each time
        // .... repeat

        // read in the schema file and set up schema validation for each endpoint, this is for replacing events.http.request.schemas.application/json.schema in serverless.yml
        // .... repeat this depending on how many schema you have
		const appSchema = JSON.parse(
            fs.readFileSync(path.join(rootPath, process.env.schema_filename), 'utf8')
        );
        const app3Schema = JSON.parse(
            fs.readFileSync(path.join(rootPath, process.env.peripheral_schema_filename), 'utf8')
        );
        
        const appSchemaModel = new apigateway.Model(this, 'AppReportSchemaModel', {
            modelName: 'AppReportSchema',
            restApi: api,
            contentType: 'application/json',
            schema: appSchema,
            description: ''
        });
        const app3SchemaModel = new apigateway.Model(this, 'App3SchemaModel', {
            modelName: 'App3Schema',
            restApi: api,
            contentType: 'application/json',
            schema: app3Schema,
            description: ''
        });

        const AppRequestValidator = new apigateway.RequestValidator(this, 'AppRequestValidator', {
            restApi: api,
            requestValidatorName: 'AppRequestValidator',
            validateRequestBody: true,
            validateRequestParameters: false
        });
        const app3RequestValidator = new apigateway.RequestValidator(this, 'App3RequestValidator', {
            restApi: api,
            requestValidatorName: 'App3RequestValidator',
            validateRequestBody: true,
            validateRequestParameters: false
        });

		// compose the schema, authorizer, and handler etc. together, this needs to be done explicitly in CDK.
        appPath.addMethod('POST', new apigateway.LambdaIntegration(appStateMachineFunction), {
            authorizer: appAuthorizer,
            authorizationType: apigateway.AuthorizationType.CUSTOM,
            requestModels: {
                'application/json': appSchemaModel
            },
            requestValidator: AppRequestValidator
        });
        app3Path.addMethod('POST', new apigateway.LambdaIntegration(app3Function), {
            authorizer: app3Authorizer,
            authorizationType: apigateway.AuthorizationType.CUSTOM,
            requestModels: {
                'application/json': app3SchemaModel
            },
            requestValidator: app3RequestValidator
        });

        // Finally we set up the custom domain and add corresponding connection to the api gateway
        // note that certificate is an external resource that is read in, not created here, neither by serverless or cdk
		// this is for replacing customDomain.certificateName in serverless if you use serverless-domain-manager plugin. Different than the plugin, you must provide the certificate arn here instead of just the name. The reason is that the plugin read in all certifiacates and do wildcard mapping with the name to choose the closest one. Essentially there is no way to explicitly query a certificate just by name
        const certificate = acm.Certificate.fromCertificateArn(this, 'ImportedCertificate', process.env.certificate_arn);
        const hostedZone = route53.HostedZone.fromLookup(this, 'ImportedHostedZone', {
            domainName: process.env.host// This is also an external resource which is not created here. you need to read it from your AWS resources and put it here
        });
        const customDomain = new apigateway.DomainName(this, 'CustomDomain', {
            domainName: process.env.domain_name,
            certificate,
            endpointType: apigateway.EndpointType.REGIONAL,
            securityPolicy: apigateway.SecurityPolicy.TLS_1_2
        }); // As the previous serverless, the cdk is responsible for creating and connecting the custom domain
        new apigateway.BasePathMapping(this, 'BasePathMapping', {
            domainName: customDomain,
            restApi: api,
            basePath: 'app', // this is the basePath that is mentioned previously, for replacing customDomain.basePath in serverless
            stage: api.deploymentStage
        });
        new route53.ARecord(this, 'CustomDomainAliasRecord', {
            zone: hostedZone,
            recordName: process.env.domain_name,
            target: route53.RecordTarget.fromAlias(new route53Targets.ApiGatewayDomain(customDomain))
        }); // this is for replacing customDomain.createRoute53record: true in serverless
        new route53.AaaaRecord(this, 'CustomDomainAliasRecordAAAA', {
            zone: hostedZone,
            recordName: process.env.domain_name,
            target: route53.RecordTarget.fromAlias(new route53Targets.ApiGatewayDomain(customDomain))
        }); // this is also for replacing customDomain.createRoute53record: true in serverless, A record and AAAA record are different types depending on your needs 
    }
}

module.exports = { AppStack };

After having cdk/ set up you can delete the serverless.yml because everything is replaced.

For deployment, how to replace the serverless deploy --stage STAGE command. You replace this command, regardless of you are deploying through CI/CD or from local, to something like

  - npm install -g aws-cdk@2.1023.0
  - cd cdk && npm install
  - export CDK_DEFAULT_ACCOUNT=$(aws sts get-caller-identity --query Account --output text)
  - export SERVICE=app
  - export STAGE=STAGE
  - cp ../.env.$STAGE .env.$STAGE
  - npm run synth
  - npm run deploy

And final of final. You need to run serverless remove --stage STAGE to remove the original CloudFormation stack before deploying the CDK version. Your original resources will be removed thus after redeployment the resource id will change, but the names otherwise remain the same.
Hope this helps!

[swathivelivala]

Can we have the runtime set to nodejs 20 in V3 rather than upgrading it to v4 ?

[pieterocp]

Serverless is a business trying to make money. They will not release any more upgrades for V3. There are forks in place that can be used instead.

[lukemcgregor]

This issue has made us switch to osls (an open source fork of v3 which supports new aws runtimes), serverless has been a great tool but I have no desire to push all my deploys through third party infrastructure.