AWS ল্যাম্বডা, CDK, API Gateway, Congnito এবং অন্যান্য

export const handler = async (event) => {
  // TODO implement
  const response = {
    statusCode: 200,
    body: JSON.stringify('Hello from Lambda!'),
  };
  return response;
};

npm install -g aws-cdk

aws configure --profile mypersonal

cdk init app --language javascript

bin/
lib/
test/
cdk.json
package.json

exports.handler = async () => {
    return {
      statusCode: 200,
      body: JSON.stringify("Hello from Lambda!"),
    };
  };

const { Stack, Duration, CfnOutput } = require('aws-cdk-lib');
const { Function, Runtime, Code, FunctionUrlAuthType } = require('aws-cdk-lib/aws-lambda');
const { LambdaRestApi } = require('aws-cdk-lib/aws-apigateway');
const path = require('path');

class LamdaStack extends Stack {
  /**
   *
   * @param {Construct} scope
   * @param {string} id
   * @param {StackProps=} props
   */
  constructor(scope, id, props) {
    super(scope, id, props);

    // Lambda function
    const helloLambda = new Function(this, 'HelloLambda', {
      runtime: Runtime.NODEJS_22_X,
      handler: 'hello.handler',
      code: Code.fromAsset(path.join(__dirname, '../lambda')),
    });


    //  Function URL  
    const functionUrl = helloLambda.addFunctionUrl({
      authType: FunctionUrlAuthType.NONE,
    });

    // Output the API URL
    new CfnOutput(this, 'ApiUrl', {
      value: functionUrl.url,
      description: 'URL of the Function URL',
    });

  }
}

module.exports = { LamdaStack }

cdk bootstrap aws://YOUR_ACCOUNT_ID/us-east-1 --profile mypersonal

cdk deploy --profile mypersonal

Outputs:
LamdaStack.ApiUrl = https://l7varnr4asdfpyvdi0pjknj.lambda-url.ap-south-1.on.aws/

const { Stack, Duration, CfnOutput } = require('aws-cdk-lib');
const { Function, Runtime, Code, FunctionUrlAuthType } = require('aws-cdk-lib/aws-lambda');
const { LambdaRestApi } = require('aws-cdk-lib/aws-apigateway');
const path = require('path');

class LamdaStack extends Stack {
  /**
   *
   * @param {Construct} scope
   * @param {string} id
   * @param {StackProps=} props
   */
  constructor(scope, id, props) {
    super(scope, id, props);

    // Lambda function
    const helloLambda = new Function(this, 'HelloLambda', {
      runtime: Runtime.NODEJS_22_X,
      handler: 'hello.handler',
      code: Code.fromAsset(path.join(__dirname, '../lambda')),
    });

    //  API Gateway (REST API)
    const api = new LambdaRestApi(this, 'HelloApi', {
      handler: helloLambda,
      proxy: true, // Forward all requests to Lambda
    });

 
    // Output the API URL
    new CfnOutput(this, 'ApiUrl', {
      value: api.url,
      description: 'URL of the API Gateway',
    });
  }
}

module.exports = { LamdaStack }

const { Stack, CfnOutput } = require('aws-cdk-lib');
const { Table, AttributeType, BillingMode } = require('aws-cdk-lib/aws-dynamodb');
const { Function, Runtime, Code } = require('aws-cdk-lib/aws-lambda');
const { LambdaRestApi } = require('aws-cdk-lib/aws-apigateway');
const path = require('path');

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

    // DynamoDB
    const table = new Table(this, "ItemsTable", {
      partitionKey: { name: "id", type: AttributeType.STRING },
      billingMode: BillingMode.PAY_PER_REQUEST,
      tableName: "Items",
    });

    // Lambda Function
    const apiLambda = new Function(this, "ApiLambda", {
      runtime: Runtime.NODEJS_22_X,
      handler: "handler.main",
      code: Code.fromAsset(path.join(__dirname, "../lambda")),
      environment: {
        TABLE_NAME: table.tableName,
      },
    });

    table.grantReadWriteData(apiLambda);

    // API Gateway
    const api = new LambdaRestApi(this, "ItemsApi", {
      handler: apiLambda,
      proxy: false,
    });

    const items = api.root.addResource("item");
    items.addMethod("POST");

    const itemId = items.addResource("{id}");
    itemId.addMethod("GET");

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

module.exports = { LamdaStack };

const {
    DynamoDBClient,
    PutItemCommand,
    GetItemCommand,
  } = require("@aws-sdk/client-dynamodb");
  
  const client = new DynamoDBClient({});
  
  exports.main = async (event) => {
    const tableName = process.env.TABLE_NAME;
  
    try {
      // Handle POST /item
      if (event.httpMethod === "POST") {
        const body = JSON.parse(event.body);
  
        await client.send(
          new PutItemCommand({
            TableName: tableName,
            Item: {
              id: { S: body.id },
              value: { S: body.value },
            },
          })
        );
  
        return {
          statusCode: 200,
          body: JSON.stringify({ message: "Item stored" }),
        };
      }
  
      // Handle GET /item/{id}
      if (event.httpMethod === "GET") {
        const id = event.pathParameters.id;
  
        const result = await client.send(
          new GetItemCommand({
            TableName: tableName,
            Key: { id: { S: id } },
          })
        );
  
        return {
          statusCode: 200,
          body: JSON.stringify({ item: result.Item }),
        };
      }
  
      return {
        statusCode: 400,
        body: "Invalid request",
      };
    } catch (err) {
      console.error(err);
      return { statusCode: 500, body: "Server error" };
    }
  };
  

https://xxxx.execute-api.ap-south-1.amazonaws.com/prod/

POST https://xxxx.execute-api.ap-south-1.amazonaws.com/prod/item
{
  "id": "1",
  "value": "Hello"
}

https://xxxx.execute-api.ap-south-1.amazonaws.com/prod/item/1

const { Stack, CfnOutput } = require('aws-cdk-lib');
const { Table, AttributeType, BillingMode } = require('aws-cdk-lib/aws-dynamodb');
const { Function, Runtime, Code } = require('aws-cdk-lib/aws-lambda');
const { RestApi, LambdaIntegration, AuthorizationType } = require('aws-cdk-lib/aws-apigateway');
const { UserPool, UserPoolClient } = require('aws-cdk-lib/aws-cognito');
const { CognitoUserPoolsAuthorizer } = require('aws-cdk-lib/aws-apigateway');
const path = require('path');

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

    // DynamoDB
    const table = new Table(this, "ItemsTable", {
      partitionKey: { name: "id", type: AttributeType.STRING },
      billingMode: BillingMode.PAY_PER_REQUEST,
      tableName: "Items",
    });

    // Create a user pool
    const userPool = new UserPool(this, 'MyUserPool', {
      userPoolName: 'MyUserPool',
      selfSignUpEnabled: true,
      signInAliases: { email: true }
    });

    // App client - Enable USER_PASSWORD_AUTH flow
    const appClient = new UserPoolClient(this, 'AppClient', {
      userPool,
      generateSecret: false,
      authFlows: {
        userPassword: true, 
        userSrp: true,       
      },
    });

    // Lambda Function
    const apiLambda = new Function(this, "ApiLambda", {
      runtime: Runtime.NODEJS_22_X,
      handler: "handler.main",
      code: Code.fromAsset(path.join(__dirname, "../lambda")),
      environment: {
        TABLE_NAME: table.tableName,
        USER_POOL_ID: userPool.userPoolId,
        APP_CLIENT_ID: appClient.userPoolClientId,
      },
    });



    table.grantReadWriteData(apiLambda);


    // API Gateway
    const api = new RestApi(this, "ItemsApi", {
      restApiName: "Items API",
    });

    // Create authorizer ( 
    const authorizer = new CognitoUserPoolsAuthorizer(this, 'CognitoAuthorizer', {
      cognitoUserPools: [userPool],
      authorizerName: 'MyCognitoAuthorizer',
    });

    // Create Lambda integration
    const lambdaIntegration = new LambdaIntegration(apiLambda);

    const items = api.root.addResource("item");
    items.addMethod("POST", lambdaIntegration, {
      authorizer: authorizer,  // add authorizer to the method
      authorizationType: AuthorizationType.COGNITO,
    });

    const itemId = items.addResource("{id}");
    itemId.addMethod("GET", lambdaIntegration, {
      authorizer: authorizer, // add authorizer to the method
      authorizationType: AuthorizationType.COGNITO,
    });

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

module.exports = { LamdaStack };

const {
    DynamoDBClient,
    PutItemCommand,
    GetItemCommand,
  } = require("@aws-sdk/client-dynamodb");
  
  const client = new DynamoDBClient({});
  
  exports.main = async (event) => {
    const tableName = process.env.TABLE_NAME;
  
    try {
      // Handle POST /item
      if (event.httpMethod === "POST") {
        const body = JSON.parse(event.body);
  
        await client.send(
          new PutItemCommand({
            TableName: tableName,
            Item: {
              id: { S: body.id },
              value: { S: body.value },
            },
          })
        );
  
        return {
          statusCode: 200,
          body: JSON.stringify({ message: "Item stored" }),
        };
      }
  
      // Handle GET /item/{id}
      if (event.httpMethod === "GET") {
        const id = event.pathParameters.id;
  
        const result = await client.send(
          new GetItemCommand({
            TableName: tableName,
            Key: { id: { S: id } },
          })
        );
  
        return {
          statusCode: 200,
          body: JSON.stringify({ item: result.Item }),
        };
      }
  
      return {
        statusCode: 400,
        body: "Invalid request",
      };
    } catch (err) {
      console.error(err);
      return { statusCode: 500, body: "Server error" };
    }
  };
 

cdk deploy

aws cognito-idp admin-create-user \
  --region ap-south-1 \
  --user-pool-id USER_POOL_ID \
  --username YOUR_EMAIL \
  --user-attributes Name=email,Value=YOUR_EMAIL Name=email_verified,Value=true \
  --temporary-password 'TempPassword123!' \
  --message-action SUPPRESS

aws cognito-idp admin-set-user-password \
  --region ap-south-1 \
  --user-pool-id USER_POOL_ID \
  --username YOUR_EMAIL \
  --password 'YourPermanentPassword123!' \
  --permanent

aws cognito-idp initiate-auth \
  --region ap-south-1 \
  --auth-flow USER_PASSWORD_AUTH \
  --client-id USER_POOL_CLIENT_ID \
  --auth-parameters USERNAME="YOUR_EMAIL",PASSWORD=‘YOUR_PASSWORD’

cdk destroy