Using aws scheduler with parameter

Question

Pulumi · Accepted Answer

To use an AWS Scheduler with a parameter in Pulumi with TypeScript, you need to set up a scheduled task. AWS Scheduler is not a direct service provided by AWS, but you can create scheduled tasks using AWS services like CloudWatch Events (EventBridge) and AWS Lambda or ECS tasks. For simplicity, I'll show you how to set up a Lambda function that is triggered on a schedule using CloudWatch Events.

A typical use case for this might be running a nightly job to process data, send notifications, or other routine tasks. Here's how to create a scheduled Lambda function using Pulumi:

1. **Define the Lambda Function**: Create a new AWS Lambda function that will execute your desired task.
2. **Set up IAM Role**: Define an IAM role that grants your Lambda function permissions to run.
3. **Create a CloudWatch Event Rule**: Define a schedule with a CloudWatch Event Rule. This rule will specify when your task should run.
4. **Create a CloudWatch Event Target**: Connect your Lambda function to the Event Rule as a target.

Here is a detailed Pulumi program written in TypeScript that sets up a scheduled Lambda function triggered once a day:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';

// Create an AWS resource (IAM role) that allows Lambda to call AWS services
const lambdaRole = new aws.iam.Role("lambdaRole", {
    assumeRolePolicy: aws.iam.assumeRolePolicyForPrincipal({
        Service: "lambda.amazonaws.com",
    }),
});

// Attach a policy to the role to allow logging to CloudWatch
new aws.iam.RolePolicyAttachment("lambdaLogs", {
    role: lambdaRole,
    policyArn: aws.iam.ManagedPolicy.AWSLambdaBasicExecutionRole,
});

// Define the Lambda function using the Pulumi AWS SDK
const lambdaFunction = new aws.lambda.Function("scheduledLambda", {
    code: new pulumi.asset.AssetArchive({
        ".": new pulumi.asset.FileArchive("./path-to-your-code"), // Specify the path to your Lambda code
    }),
    role: lambdaRole.arn,
    handler: "index.handler", // Replace 'index.handler' with the entry point to your Lambda function
    runtime: aws.lambda.Runtime.NodeJS12dX, // Specify the runtime, you can change this based on your requirements
});

// Define the CloudWatch Event Rule that triggers on a schedule
const scheduleRule = new aws.cloudwatch.EventRule("scheduleRule", {
    scheduleExpression: "rate(1 day)", // Replace with your desired schedule expression
});

// Set Lambda as a target for the CloudWatch Event Rule
new aws.cloudwatch.EventTarget("eventTarget", {
    rule: scheduleRule.name,
    arn: lambdaFunction.arn,
});

// Export the name of the bucket
export const lambdaFunctionName = lambdaFunction.name;
```

Here's what each part of the program does:

- The `lambdaRole` creates a new IAM role which the Lambda function assumes when running. The IAM policy attached to this role allows the function to log to CloudWatch.
- The `lambdaFunction` defines the AWS Lambda function itself. It specifies the location of the code and other settings like the handler and the runtime environment for the code.
- The `scheduleRule` sets up the AWS CloudWatch Event Rule to trigger the function on the desired schedule. `rate(1 day)` means it will run once every day. You can customise this using cron expressions for more complex schedules.
- The `EventTarget` connects the Lambda function to the Event Rule, effectively setting it up so that the function is triggered by the schedule we've defined.

To use this code, replace "./path-to-your-code" with the actual path to your Lambda function's code, and adjust other settings like the `handler` and `runtime` to match your application. If you're using Lambda to interact with other AWS services, you'll need to attach additional policies to the `lambdaRole`.

After deploying this Pulumi program, the AWS Lambda function you have defined will run automatically according to the specified schedule.