Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Docs
  2. Pulumi Cloud
  3. Deployments
  4. Schedules

Schedules

    Scheduled Deployments in Pulumi Cloud introduce a robust capability to automate cloud operations, enabling more control over when and how infrastructure updates are applied. This feature is ideal for teams looking to enhance operational efficiency by automating routine tasks and ensuring that changes are made during optimal times, such as off-peak hours or predetermined maintenance windows.

    Users can easily define schedules for any stack with Pulumi Deployments configured, using cron expressions to specify exact times for operations. This granular level of control allows for precise management of infrastructure tasks, accommodating complex scheduling needs. Scheduled Deployments build upon the existing infrastructure provided by Pulumi Deployments, enhancing it with the flexibility to manage deployment timing extensively. This means Pulumi Deployments concurrency limits apply to scheduled deployments and pausing deployments on a stack will queue scheduled deployments as well.

    Pulumi Cloud UI

    In order to set up a deployment schedule in the Pulumi Cloud console, follow these steps:

    1. Ensure Deployments Settings are configured on the stack see the docs
    2. Navigate to the Stack > Settings > Schedules

    Schedule

    1. Select “Raw operation”
    2. Select from the drop-down the type of operation you would like to schedule
    3. Set the schedule using a cron expression
    4. Save the Schedule

    Populated Schedule in the UI

    Setting it up in the API

    For those who prefer to automate and script their infrastructure tasks, Time-to-Live schedules can be configured programmatically using simple HTTP requests.

    • Create a schedule
    • Get a schedule for a stack
    • Update or delete a schedule
    • Pause or resume a schedule
    • List all schedules in the organization (includes Drift and Time-to-Live schedules)

    Below is an example of creating a Schedule on a stack programmatically:

    curl \
  -H "Accept: application/vnd.pulumi+8" \
  -H "Content-Type: application/json" \
  -H "Authorization: token $PULUMI_ACCESS_TOKEN" \
  --request POST \
  --data '{ "scheduleCron":"0 0 * * *", "request": { "operation": "update" } }' \
  https://api.pulumi.com/api/stacks/{organization}/{project}/{stack}/deployments/schedules

    Refer to the Pulumi Deployments REST API documentation for more details on how to use the REST API to manage Scheduled Deployments.

    Pulumi Cloud Service provider

    import * as pulumi from "@pulumi/pulumi";
import * as pulumiservice from "@pulumi/pulumiservice";

const organizationName = "my-org";
const projectName = "my-project";
const stackName = "prod-stack";

const rawSchedule = new pulumiservice.DeploymentSchedule("rawSchedule", {
    organization: organizationName,
    project: projectName,
    stack: stackName,
    scheduleCron: "0 0 * * *", // Run an update daily at midnight
    pulumiOperation: pulumiservice.PulumiOperation.update
});

export const scheduleId = rawSchedule.scheduleId;

    import pulumi
import pulumi_pulumiservice as pulumiservice

organization_name = "my-org"
project_name = "my-project"
stack_name = "prod-stack"

# Create a raw deployment schedule
raw_schedule = pulumiservice.DeploymentSchedule("rawSchedule",
    organization=organization_name,
    project=project_name,
    stack=stack_name,
    schedule_cron="0 0 * * *",  # Run an update daily at midnight
    pulumi_operation=pulumiservice.PulumiOperation.update)

pulumi.export('scheduleId', raw_schedule.schedule_id)

    package main

import (
    "github.com/pulumi/pulumi-pulumiservice/sdk/go/pulumiservice"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        rawSchedule, err := pulumiservice.NewDeploymentSchedule(ctx, "rawSchedule", &pulumiservice.DeploymentScheduleArgs{
            Organization: pulumi.String("my-org"),
            Project: pulumi.String("my-project"),
            Stack: pulumi.String("prod-stack"),
            ScheduleCron: pulumi.String("0 0 * * *"),  // Run an update daily at midnight
            PulumiOperation: pulumiservice.PulumiOperationUpdate,
        })
        if err != nil {
            return err
        }

        ctx.Export("scheduleId", rawSchedule.ScheduleID)
        return nil
    })
}

    using Pulumi;
using PulumiService = Pulumi.PulumiService;

class Program
{
    static Task<int> Main() => Deployment.RunAsync(() => {
        var rawSchedule = new PulumiService.DeploymentSchedule("rawSchedule", new PulumiService.DeploymentScheduleArgs
        {
            Organization = "my-org",
            Project = "my-project",
            Stack = "prod-stack",
            ScheduleCron = "0 0 * * *",  // Run an update daily at midnight
            PulumiOperation = PulumiService.PulumiOperation.Update,
        });

        return new Dictionary<string, object?>
        {
            { "scheduleId", rawSchedule.ScheduleId }
        };
    });
}

    import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.pulumiservice.DeploymentSchedule;
import com.pulumi.pulumiservice.DeploymentScheduleArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    private static to stack(Context ctx) {
        var rawSchedule = new DeploymentSchedule("rawSchedule", DeploymentScheduleArgs.builder()
            .organization("my-org")
            .project("my-project")
            .stack("prod-stack")
            .scheduleCron("0 0 * * *") // Run an update daily at midnight
            .pulumiOperation(com.pulumi.pulumiservice.PulumiOperation.update())
            .build());

        ctx.export("scheduleId", rawSchedule.name());
    }
}

    name: raw-schedule-setup
runtime: yaml
description: Setup of a raw schedule for automatic operations with Pulumi

resources:
  rawSchedule:
    type: pulumiservice:index:DeploymentSchedule
    properties:
      organization: my-org
      project: my-project
      stack: prod-stack
      scheduleCron: "0 0 * * *" # Run an update daily at midnight
      pulumiOperation: update

outputs:
  scheduleId: ${rawSchedule.scheduleId}

    See the Pulumi Service Provider documentation for more details on how to manage Scheduled Deployments in source control.

      PulumiUP 2024. Watch On Demand.