pulumi-aws-kotlin/com.pulumi.aws.appautoscaling.kotlin/ScheduledAction

ScheduledAction

class ScheduledAction : KotlinCustomResource

Provides an Application AutoScaling ScheduledAction resource.

Example Usage

DynamoDB Table Autoscaling

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const dynamodb = new aws.appautoscaling.Target("dynamodb", {
    maxCapacity: 100,
    minCapacity: 5,
    resourceId: "table/tableName",
    scalableDimension: "dynamodb:table:ReadCapacityUnits",
    serviceNamespace: "dynamodb",
});
const dynamodbScheduledAction = new aws.appautoscaling.ScheduledAction("dynamodb", {
    name: "dynamodb",
    serviceNamespace: dynamodb.serviceNamespace,
    resourceId: dynamodb.resourceId,
    scalableDimension: dynamodb.scalableDimension,
    schedule: "at(2006-01-02T15:04:05)",
    scalableTargetAction: {
        minCapacity: 1,
        maxCapacity: 200,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
dynamodb = aws.appautoscaling.Target("dynamodb",
    max_capacity=100,
    min_capacity=5,
    resource_id="table/tableName",
    scalable_dimension="dynamodb:table:ReadCapacityUnits",
    service_namespace="dynamodb")
dynamodb_scheduled_action = aws.appautoscaling.ScheduledAction("dynamodb",
    name="dynamodb",
    service_namespace=dynamodb.service_namespace,
    resource_id=dynamodb.resource_id,
    scalable_dimension=dynamodb.scalable_dimension,
    schedule="at(2006-01-02T15:04:05)",
    scalable_target_action={
        "min_capacity": 1,
        "max_capacity": 200,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var dynamodb = new Aws.AppAutoScaling.Target("dynamodb", new()
    {
        MaxCapacity = 100,
        MinCapacity = 5,
        ResourceId = "table/tableName",
        ScalableDimension = "dynamodb:table:ReadCapacityUnits",
        ServiceNamespace = "dynamodb",
    });
    var dynamodbScheduledAction = new Aws.AppAutoScaling.ScheduledAction("dynamodb", new()
    {
        Name = "dynamodb",
        ServiceNamespace = dynamodb.ServiceNamespace,
        ResourceId = dynamodb.ResourceId,
        ScalableDimension = dynamodb.ScalableDimension,
        Schedule = "at(2006-01-02T15:04:05)",
        ScalableTargetAction = new Aws.AppAutoScaling.Inputs.ScheduledActionScalableTargetActionArgs
        {
            MinCapacity = 1,
            MaxCapacity = 200,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/appautoscaling"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		dynamodb, err := appautoscaling.NewTarget(ctx, "dynamodb", &appautoscaling.TargetArgs{
			MaxCapacity:       pulumi.Int(100),
			MinCapacity:       pulumi.Int(5),
			ResourceId:        pulumi.String("table/tableName"),
			ScalableDimension: pulumi.String("dynamodb:table:ReadCapacityUnits"),
			ServiceNamespace:  pulumi.String("dynamodb"),
		})
		if err != nil {
			return err
		}
		_, err = appautoscaling.NewScheduledAction(ctx, "dynamodb", &appautoscaling.ScheduledActionArgs{
			Name:              pulumi.String("dynamodb"),
			ServiceNamespace:  dynamodb.ServiceNamespace,
			ResourceId:        dynamodb.ResourceId,
			ScalableDimension: dynamodb.ScalableDimension,
			Schedule:          pulumi.String("at(2006-01-02T15:04:05)"),
			ScalableTargetAction: &appautoscaling.ScheduledActionScalableTargetActionArgs{
				MinCapacity: pulumi.Int(1),
				MaxCapacity: pulumi.Int(200),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appautoscaling.Target;
import com.pulumi.aws.appautoscaling.TargetArgs;
import com.pulumi.aws.appautoscaling.ScheduledAction;
import com.pulumi.aws.appautoscaling.ScheduledActionArgs;
import com.pulumi.aws.appautoscaling.inputs.ScheduledActionScalableTargetActionArgs;
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 dynamodb = new Target("dynamodb", TargetArgs.builder()
            .maxCapacity(100)
            .minCapacity(5)
            .resourceId("table/tableName")
            .scalableDimension("dynamodb:table:ReadCapacityUnits")
            .serviceNamespace("dynamodb")
            .build());
        var dynamodbScheduledAction = new ScheduledAction("dynamodbScheduledAction", ScheduledActionArgs.builder()
            .name("dynamodb")
            .serviceNamespace(dynamodb.serviceNamespace())
            .resourceId(dynamodb.resourceId())
            .scalableDimension(dynamodb.scalableDimension())
            .schedule("at(2006-01-02T15:04:05)")
            .scalableTargetAction(ScheduledActionScalableTargetActionArgs.builder()
                .minCapacity(1)
                .maxCapacity(200)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  dynamodb:
    type: aws:appautoscaling:Target
    properties:
      maxCapacity: 100
      minCapacity: 5
      resourceId: table/tableName
      scalableDimension: dynamodb:table:ReadCapacityUnits
      serviceNamespace: dynamodb
  dynamodbScheduledAction:
    type: aws:appautoscaling:ScheduledAction
    name: dynamodb
    properties:
      name: dynamodb
      serviceNamespace: ${dynamodb.serviceNamespace}
      resourceId: ${dynamodb.resourceId}
      scalableDimension: ${dynamodb.scalableDimension}
      schedule: at(2006-01-02T15:04:05)
      scalableTargetAction:
        minCapacity: 1
        maxCapacity: 200
Content copied to clipboard

ECS Service Autoscaling

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const ecs = new aws.appautoscaling.Target("ecs", {
    maxCapacity: 4,
    minCapacity: 1,
    resourceId: "service/clusterName/serviceName",
    scalableDimension: "ecs:service:DesiredCount",
    serviceNamespace: "ecs",
});
const ecsScheduledAction = new aws.appautoscaling.ScheduledAction("ecs", {
    name: "ecs",
    serviceNamespace: ecs.serviceNamespace,
    resourceId: ecs.resourceId,
    scalableDimension: ecs.scalableDimension,
    schedule: "at(2006-01-02T15:04:05)",
    scalableTargetAction: {
        minCapacity: 1,
        maxCapacity: 10,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
ecs = aws.appautoscaling.Target("ecs",
    max_capacity=4,
    min_capacity=1,
    resource_id="service/clusterName/serviceName",
    scalable_dimension="ecs:service:DesiredCount",
    service_namespace="ecs")
ecs_scheduled_action = aws.appautoscaling.ScheduledAction("ecs",
    name="ecs",
    service_namespace=ecs.service_namespace,
    resource_id=ecs.resource_id,
    scalable_dimension=ecs.scalable_dimension,
    schedule="at(2006-01-02T15:04:05)",
    scalable_target_action={
        "min_capacity": 1,
        "max_capacity": 10,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var ecs = new Aws.AppAutoScaling.Target("ecs", new()
    {
        MaxCapacity = 4,
        MinCapacity = 1,
        ResourceId = "service/clusterName/serviceName",
        ScalableDimension = "ecs:service:DesiredCount",
        ServiceNamespace = "ecs",
    });
    var ecsScheduledAction = new Aws.AppAutoScaling.ScheduledAction("ecs", new()
    {
        Name = "ecs",
        ServiceNamespace = ecs.ServiceNamespace,
        ResourceId = ecs.ResourceId,
        ScalableDimension = ecs.ScalableDimension,
        Schedule = "at(2006-01-02T15:04:05)",
        ScalableTargetAction = new Aws.AppAutoScaling.Inputs.ScheduledActionScalableTargetActionArgs
        {
            MinCapacity = 1,
            MaxCapacity = 10,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/appautoscaling"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ecs, err := appautoscaling.NewTarget(ctx, "ecs", &appautoscaling.TargetArgs{
			MaxCapacity:       pulumi.Int(4),
			MinCapacity:       pulumi.Int(1),
			ResourceId:        pulumi.String("service/clusterName/serviceName"),
			ScalableDimension: pulumi.String("ecs:service:DesiredCount"),
			ServiceNamespace:  pulumi.String("ecs"),
		})
		if err != nil {
			return err
		}
		_, err = appautoscaling.NewScheduledAction(ctx, "ecs", &appautoscaling.ScheduledActionArgs{
			Name:              pulumi.String("ecs"),
			ServiceNamespace:  ecs.ServiceNamespace,
			ResourceId:        ecs.ResourceId,
			ScalableDimension: ecs.ScalableDimension,
			Schedule:          pulumi.String("at(2006-01-02T15:04:05)"),
			ScalableTargetAction: &appautoscaling.ScheduledActionScalableTargetActionArgs{
				MinCapacity: pulumi.Int(1),
				MaxCapacity: pulumi.Int(10),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.appautoscaling.Target;
import com.pulumi.aws.appautoscaling.TargetArgs;
import com.pulumi.aws.appautoscaling.ScheduledAction;
import com.pulumi.aws.appautoscaling.ScheduledActionArgs;
import com.pulumi.aws.appautoscaling.inputs.ScheduledActionScalableTargetActionArgs;
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 ecs = new Target("ecs", TargetArgs.builder()
            .maxCapacity(4)
            .minCapacity(1)
            .resourceId("service/clusterName/serviceName")
            .scalableDimension("ecs:service:DesiredCount")
            .serviceNamespace("ecs")
            .build());
        var ecsScheduledAction = new ScheduledAction("ecsScheduledAction", ScheduledActionArgs.builder()
            .name("ecs")
            .serviceNamespace(ecs.serviceNamespace())
            .resourceId(ecs.resourceId())
            .scalableDimension(ecs.scalableDimension())
            .schedule("at(2006-01-02T15:04:05)")
            .scalableTargetAction(ScheduledActionScalableTargetActionArgs.builder()
                .minCapacity(1)
                .maxCapacity(10)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  ecs:
    type: aws:appautoscaling:Target
    properties:
      maxCapacity: 4
      minCapacity: 1
      resourceId: service/clusterName/serviceName
      scalableDimension: ecs:service:DesiredCount
      serviceNamespace: ecs
  ecsScheduledAction:
    type: aws:appautoscaling:ScheduledAction
    name: ecs
    properties:
      name: ecs
      serviceNamespace: ${ecs.serviceNamespace}
      resourceId: ${ecs.resourceId}
      scalableDimension: ${ecs.scalableDimension}
      schedule: at(2006-01-02T15:04:05)
      scalableTargetAction:
        minCapacity: 1
        maxCapacity: 10
Content copied to clipboard

Properties

Link copied to clipboard
val arn: Output<String>

ARN of the scheduled action.

Link copied to clipboard
val endTime: Output<String>?

Date and time for the scheduled action to end in RFC 3339 format. The timezone is not affected by the setting of timezone.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val name: Output<String>

Name of the scheduled action.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val resourceId: Output<String>

Identifier of the resource associated with the scheduled action. Documentation can be found in the ResourceId parameter at: AWS Application Auto Scaling API Reference

Link copied to clipboard
val scalableDimension: Output<String>

Scalable dimension. Documentation can be found in the ScalableDimension parameter at: AWS Application Auto Scaling API Reference Example: ecs:service:DesiredCount

Link copied to clipboard
val scalableTargetAction: Output<ScheduledActionScalableTargetAction>

New minimum and maximum capacity. You can set both values or just one. See below

Link copied to clipboard
val schedule: Output<String>

Schedule for this action. The following formats are supported: At expressions - at(yyyy-mm-ddThh:mm:ss), Rate expressions - rate(valueunit), Cron expressions - cron(fields). Times for at expressions and cron expressions are evaluated using the time zone configured in timezone. Documentation can be found in the Timezone parameter at: AWS Application Auto Scaling API Reference

Link copied to clipboard
val serviceNamespace: Output<String>

Namespace of the AWS service. Documentation can be found in the ServiceNamespace parameter at: AWS Application Auto Scaling API Reference Example: ecs

Link copied to clipboard
val startTime: Output<String>?

Date and time for the scheduled action to start in RFC 3339 format. The timezone is not affected by the setting of timezone.

Link copied to clipboard
val timezone: Output<String>?

Time zone used when setting a scheduled action by using an at or cron expression. Does not affect timezone for start_time and end_time. Valid values are the canonical names of the IANA time zones supported by Joda-Time, such as Etc/GMT+9 or Pacific/Tahiti. Default is UTC.

Link copied to clipboard
val urn: Output<String>