pulumi-aws-kotlin/com.pulumi.aws.scheduler.kotlin/Schedule

Schedule

class Schedule : KotlinCustomResource

Provides an EventBridge Scheduler Schedule resource. You can find out more about EventBridge Scheduler in the User Guide.

Note: EventBridge was formerly known as CloudWatch Events. The functionality is identical.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.scheduler.Schedule("example", {
    name: "my-schedule",
    groupName: "default",
    flexibleTimeWindow: {
        mode: "OFF",
    },
    scheduleExpression: "rate(1 hours)",
    target: {
        arn: exampleAwsSqsQueue.arn,
        roleArn: exampleAwsIamRole.arn,
    },
});

import pulumi
import pulumi_aws as aws
example = aws.scheduler.Schedule("example",
    name="my-schedule",
    group_name="default",
    flexible_time_window=aws.scheduler.ScheduleFlexibleTimeWindowArgs(
        mode="OFF",
    ),
    schedule_expression="rate(1 hours)",
    target=aws.scheduler.ScheduleTargetArgs(
        arn=example_aws_sqs_queue["arn"],
        role_arn=example_aws_iam_role["arn"],
    ))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Scheduler.Schedule("example", new()
    {
        Name = "my-schedule",
        GroupName = "default",
        FlexibleTimeWindow = new Aws.Scheduler.Inputs.ScheduleFlexibleTimeWindowArgs
        {
            Mode = "OFF",
        },
        ScheduleExpression = "rate(1 hours)",
        Target = new Aws.Scheduler.Inputs.ScheduleTargetArgs
        {
            Arn = exampleAwsSqsQueue.Arn,
            RoleArn = exampleAwsIamRole.Arn,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/scheduler"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := scheduler.NewSchedule(ctx, "example", &scheduler.ScheduleArgs{
			Name:      pulumi.String("my-schedule"),
			GroupName: pulumi.String("default"),
			FlexibleTimeWindow: &scheduler.ScheduleFlexibleTimeWindowArgs{
				Mode: pulumi.String("OFF"),
			},
			ScheduleExpression: pulumi.String("rate(1 hours)"),
			Target: &scheduler.ScheduleTargetArgs{
				Arn:     pulumi.Any(exampleAwsSqsQueue.Arn),
				RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.scheduler.Schedule;
import com.pulumi.aws.scheduler.ScheduleArgs;
import com.pulumi.aws.scheduler.inputs.ScheduleFlexibleTimeWindowArgs;
import com.pulumi.aws.scheduler.inputs.ScheduleTargetArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Schedule("example", ScheduleArgs.builder()
            .name("my-schedule")
            .groupName("default")
            .flexibleTimeWindow(ScheduleFlexibleTimeWindowArgs.builder()
                .mode("OFF")
                .build())
            .scheduleExpression("rate(1 hours)")
            .target(ScheduleTargetArgs.builder()
                .arn(exampleAwsSqsQueue.arn())
                .roleArn(exampleAwsIamRole.arn())
                .build())
            .build());
    }
}

resources:
  example:
    type: aws:scheduler:Schedule
    properties:
      name: my-schedule
      groupName: default
      flexibleTimeWindow:
        mode: OFF
      scheduleExpression: rate(1 hours)
      target:
        arn: ${exampleAwsSqsQueue.arn}
        roleArn: ${exampleAwsIamRole.arn}

Universal Target

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.sqs.Queue("example", {});
const exampleSchedule = new aws.scheduler.Schedule("example", {
    name: "my-schedule",
    flexibleTimeWindow: {
        mode: "OFF",
    },
    scheduleExpression: "rate(1 hours)",
    target: {
        arn: "arn:aws:scheduler:::aws-sdk:sqs:sendMessage",
        roleArn: exampleAwsIamRole.arn,
        input: pulumi.jsonStringify({
            MessageBody: "Greetings, programs!",
            QueueUrl: example.url,
        }),
    },
});

import pulumi
import json
import pulumi_aws as aws
example = aws.sqs.Queue("example")
example_schedule = aws.scheduler.Schedule("example",
    name="my-schedule",
    flexible_time_window=aws.scheduler.ScheduleFlexibleTimeWindowArgs(
        mode="OFF",
    ),
    schedule_expression="rate(1 hours)",
    target=aws.scheduler.ScheduleTargetArgs(
        arn="arn:aws:scheduler:::aws-sdk:sqs:sendMessage",
        role_arn=example_aws_iam_role["arn"],
        input=pulumi.Output.json_dumps({
            "MessageBody": "Greetings, programs!",
            "QueueUrl": example.url,
        }),
    ))

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Sqs.Queue("example");
    var exampleSchedule = new Aws.Scheduler.Schedule("example", new()
    {
        Name = "my-schedule",
        FlexibleTimeWindow = new Aws.Scheduler.Inputs.ScheduleFlexibleTimeWindowArgs
        {
            Mode = "OFF",
        },
        ScheduleExpression = "rate(1 hours)",
        Target = new Aws.Scheduler.Inputs.ScheduleTargetArgs
        {
            Arn = "arn:aws:scheduler:::aws-sdk:sqs:sendMessage",
            RoleArn = exampleAwsIamRole.Arn,
            Input = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
            {
                ["MessageBody"] = "Greetings, programs!",
                ["QueueUrl"] = example.Url,
            })),
        },
    });
});

package main
import (
	"encoding/json"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/scheduler"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sqs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sqs.NewQueue(ctx, "example", nil)
		if err != nil {
			return err
		}
		_, err = scheduler.NewSchedule(ctx, "example", &scheduler.ScheduleArgs{
			Name: pulumi.String("my-schedule"),
			FlexibleTimeWindow: &scheduler.ScheduleFlexibleTimeWindowArgs{
				Mode: pulumi.String("OFF"),
			},
			ScheduleExpression: pulumi.String("rate(1 hours)"),
			Target: &scheduler.ScheduleTargetArgs{
				Arn:     pulumi.String("arn:aws:scheduler:::aws-sdk:sqs:sendMessage"),
				RoleArn: pulumi.Any(exampleAwsIamRole.Arn),
				Input: example.Url.ApplyT(func(url string) (pulumi.String, error) {
					var _zero pulumi.String
					tmpJSON0, err := json.Marshal(map[string]interface{}{
						"MessageBody": "Greetings, programs!",
						"QueueUrl":    url,
					})
					if err != nil {
						return _zero, err
					}
					json0 := string(tmpJSON0)
					return pulumi.String(json0), nil
				}).(pulumi.StringOutput),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.sqs.Queue;
import com.pulumi.aws.scheduler.Schedule;
import com.pulumi.aws.scheduler.ScheduleArgs;
import com.pulumi.aws.scheduler.inputs.ScheduleFlexibleTimeWindowArgs;
import com.pulumi.aws.scheduler.inputs.ScheduleTargetArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Queue("example");
        var exampleSchedule = new Schedule("exampleSchedule", ScheduleArgs.builder()
            .name("my-schedule")
            .flexibleTimeWindow(ScheduleFlexibleTimeWindowArgs.builder()
                .mode("OFF")
                .build())
            .scheduleExpression("rate(1 hours)")
            .target(ScheduleTargetArgs.builder()
                .arn("arn:aws:scheduler:::aws-sdk:sqs:sendMessage")
                .roleArn(exampleAwsIamRole.arn())
                .input(example.url().applyValue(url -> serializeJson(
                    jsonObject(
                        jsonProperty("MessageBody", "Greetings, programs!"),
                        jsonProperty("QueueUrl", url)
                    ))))
                .build())
            .build());
    }
}

resources:
  example:
    type: aws:sqs:Queue
  exampleSchedule:
    type: aws:scheduler:Schedule
    name: example
    properties:
      name: my-schedule
      flexibleTimeWindow:
        mode: OFF
      scheduleExpression: rate(1 hours)
      target:
        arn: arn:aws:scheduler:::aws-sdk:sqs:sendMessage
        roleArn: ${exampleAwsIamRole.arn}
        input:
          fn::toJSON:
            MessageBody: Greetings, programs!
            QueueUrl: ${example.url}

Import

Using pulumi import, import schedules using the combination group_name/name. For example:

$ pulumi import aws:scheduler/schedule:Schedule example my-schedule-group/my-schedule

Properties

arn

val arn: Output<String>

ARN of the schedule.

description

val description: Output<String>?

Brief description of the schedule.

endDate

val endDate: Output<String>?

The date, in UTC, before which the schedule can invoke its target. Depending on the schedule's recurrence expression, invocations might stop on, or before, the end date you specify. EventBridge Scheduler ignores the end date for one-time schedules. Example: 2030-01-01T01:00:00Z.

flexibleTimeWindow

val flexibleTimeWindow: Output<ScheduleFlexibleTimeWindow>

Configures a time window during which EventBridge Scheduler invokes the schedule. Detailed below.

groupName

val groupName: Output<String>

Name of the schedule group to associate with this schedule. When omitted, the default schedule group is used.

val id: Output<String>

kmsKeyArn

val kmsKeyArn: Output<String>?

ARN for the customer managed KMS key that EventBridge Scheduler will use to encrypt and decrypt your data.

name

val name: Output<String>

Name of the schedule. If omitted, the provider will assign a random, unique name. Conflicts with name_prefix.

namePrefix

val namePrefix: Output<String>

Creates a unique name beginning with the specified prefix. Conflicts with name.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

scheduleExpression

val scheduleExpression: Output<String>

Defines when the schedule runs. Read more in Schedule types on EventBridge Scheduler.

scheduleExpressionTimezone

val scheduleExpressionTimezone: Output<String>?

Timezone in which the scheduling expression is evaluated. Defaults to UTC. Example: Australia/Sydney.

startDate

val startDate: Output<String>?

The date, in UTC, after which the schedule can begin invoking its target. Depending on the schedule's recurrence expression, invocations might occur on, or after, the start date you specify. EventBridge Scheduler ignores the start date for one-time schedules. Example: 2030-01-01T01:00:00Z.

state

val state: Output<String>?

Specifies whether the schedule is enabled or disabled. One of: ENABLED (default), DISABLED.

target

val target: Output<ScheduleTarget>

Configures the target of the schedule. Detailed below. The following arguments are optional:

urn

val urn: Output<String>