Overview

Temporal Schedules are a replacement for traditional cron jobs for task scheduling because this Schedules provide a more durable way to execute tasks, allow insight into their progress, enable observability of schedules and workflow runs, and let you start, stop, and pause them.

Now that Temporal Schedules are GA, it’s time to convert those cron jobs into Schedules. In this article we will step through the process and show some examples.

By converting to Schedules, you can immediately take advantage of the benefits which include:

• Enhanced workflow control and visibility
• Flexible and extensible scheduling
• Elimination of external dependencies

For more information about Schedules, check out this blog post.

Converting to Schedules

Thankfully the process of converting to Schedules is very simple. The Temporal SDKs provide new primitives for Schedule CRUD operations. In addition to the SDKs, the CLI and UI are also able to perform Schedule CRUD operations. First, setup and test your new Temporal Schedule using the interface of your choice. Then once your Schedule is working and you are comfortable, turn off your old cron job. That is it!

For more information, you can refer to the Temporal documentation.

Typescript Example

See also the Schedules sample application.

Go Example

Dev guide ▶️ Go ▶️ Features ▶️ Schedules

package main

import (
	"context"
	"log"

	"example.com/myworkflows"
	"go.temporal.io/sdk/client"
)

func main() {
	ctx := context.Background()
	// The client is a heavyweight object that should be created once per process.
	c, err := client.Dial(client.Options{
		HostPort: client.DefaultHostPort,
	})
	if err != nil {
		log.Fatalln("Unable to create client", err)
	}
	defer c.Close()

	_, err := c.ScheduleClient().Create(ctx, client.ScheduleOptions{
		ID: "top-stories-every-mon-at-noon",
		Spec: client.ScheduleSpec{
			CronExpressions: []string{"0 12 * * MON"},
		},
		Action: &client.ScheduleWorkflowAction{
			ID:        "temporal-community-workflow",
			TaskQueue: "schedules-task-queue",
			Workflow:  myworkflows.SampleScheduleWorkflow,
		},
	})
	if err != nil {
		log.Fatalln("Unable to create schedule", err)
	}
}

Java Example

Dev guide ▶️ Java ▶️ Features ▶️ Schedules

package io.temporal.samples.hello;

import io.temporal.client.WorkflowOptions;
import io.temporal.client.schedules.*;
import io.temporal.serviceclient.WorkflowServiceStubs;
import io.temporal.serviceclient.WorkflowServiceStubsOptions;
import java.util.Collections;

public class HelloSchedules {
  public static void main(String[] args) {
    // Get a Workflow service stub.
    WorkflowServiceStubs service = WorkflowServiceStubs.newServiceStubs(WorkflowServiceStubsOptions.newBuilder().setTarget("localhost:7233").build());

    /*
     * Get a Schedule client which can be used to interact with schedule.
     */
    ScheduleClient scheduleClient = ScheduleClient.newInstance(service);

    /*
     * Create the workflow options for our schedule.
     * Note: Not all workflow options are supported for schedules.
     */
    WorkflowOptions workflowOptions =
        WorkflowOptions.newBuilder().setWorkflowId("temporal-community-workflow").setTaskQueue("schedules-task-queue").build();

    /*
     * Create the action that will be run when the schedule is triggered.
     */
    ScheduleActionStartWorkflow action =
        ScheduleActionStartWorkflow.newBuilder()
            .setWorkflowType(HelloActivity.GreetingWorkflow.class)
            .setOptions(workflowOptions)
            .build();

    // Define the schedule spec
    ScheduleSpec spec = ScheduleSpec.newBuilder().setCronExpressions(Collections.singletonList("0 12 * * MON")).build();

    // Define the schedule we want to create
    Schedule schedule =
        Schedule.newBuilder().setAction(action).setSpec(spec).build();

    // Create a schedule on the server
     scheduleClient.createSchedule("top-stories-every-mon-at-noon", schedule, ScheduleOptions.newBuilder().build());  }
}

.NET Example

import asyncio  
from datetime import timedelta  

from temporalio.client import (  
    Client,  
    Schedule,  
    ScheduleActionStartWorkflow,  
    ScheduleIntervalSpec,  
    ScheduleSpec,  
    ScheduleState,  
)  

from activities import TASK_QUEUE_NAME  
from your_workflow import TemporalCommunityWorkflow

async def main():  
    client = await Client.connect("localhost:7233")

async def main():
    client = await Client.connect("localhost:7233")

    await client.create_schedule(
        "top-stories-every-mon-at-noon",
        Schedule(
            action=ScheduleActionStartWorkflow(
                TemporalCommunityWorkflow.run,
                id="temporal-community-workflow",
                task_queue="schedules-task-queue",
            ),
	    	cron_expression=["0 12 * * MON"],
    )