SchedulerX:Kubernetes jobs

Script jobs (Shell, Python, PHP, Node.js)

For script-based jobs, SchedulerX provides a built-in editor -- write and update scripts directly in the console without building images or editing YAML files.

Replace the default image with a custom one if needed.

Create a script job:

1. In the SchedulerX console, go to Task Management.

2. Create a job with Task type set to K8s.

3. Set resource to the script type you need (for example, Shell-Script).

4. Write or paste your script in the built-in editor.

5. Save the job.

The following screenshots show the configuration page for each script type:

• Shell script configuration:

• Python script configuration:

• PHP script configuration:

• Node.js script configuration:

Run and verify:

1. On the Task Management page, find the job and click Run once in the Actions column.

2. A pod starts in the cluster. For example, a Shell script job creates a pod named schedulerx-shell-{JobId}.

3. To view execution logs, click Historical records in the Actions column.

Job-YAML

Use Job-YAML to run a native Kubernetes Job defined in YAML.

1. Create a job with Task type set to K8s and resource set to Job-YAML.

2. Enter your Job YAML definition.

   

3. Click Run once in the Actions column. A pod and the corresponding Kubernetes Job start in the cluster.

   

4. Click Historical records to view execution logs.

   

Pod-YAML

Use Pod-YAML to run a native Kubernetes pod defined in YAML.

1. Create a job with Task type set to K8s and resource set to Pod-YAML.

2. Enter your pod YAML definition.

   

3. Click Run once in the Actions column. The pod starts in the cluster.

   

4. Click Historical records to view execution logs.

   

Online script editing

Native Kubernetes jobs require packaging scripts into images and configuring commands in YAML. Every script change means rebuilding and redeploying the image:

apiVersion: batch/v1
kind: Job
metadata:
  name: hello
spec:
  template:
    spec:
      containers:
      - name: hello
        image: busybox
        command: ["sh",  "/root/hello.sh"]
      restartPolicy: Never
  backoffLimit: 4

With SchedulerX, edit Shell, Python, PHP, and Node.js scripts directly in the console. Changes take effect on the next scheduled run without an image rebuild. Developers unfamiliar with containers can skip container details entirely.

Visual workflow orchestration

Instead of writing Argo-style YAML to define job dependencies:

# Diamond workflow: A -> B,C -> D
apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  generateName: dag-diamond-
spec:
  entrypoint: diamond
  templates:
  - name: diamond
    dag:
      tasks:
      - name: A
        template: echo
        arguments:
          parameters: [{name: message, value: A}]
      - name: B
        depends: "A"
        template: echo
        arguments:
          parameters: [{name: message, value: B}]
      - name: C
        depends: "A"
        template: echo
        arguments:
          parameters: [{name: message, value: C}]
      - name: D
        depends: "B && C"
        template: echo
        arguments:
          parameters: [{name: message, value: D}]

  - name: echo
    inputs:
      parameters:
      - name: message
    container:
      image: alpine:3.7
      command: [echo, "{{inputs.parameters.message}}"]

SchedulerX provides a drag-and-drop visual interface to build job workflows. Track progress and identify bottlenecks at a glance.

Built-in alerting and monitoring

SchedulerX includes alerting with no additional setup:

• Notification channels: text message, phone call, email, and webhook (DingTalk, WeCom, Lark)

• Alert policies: alert on failure, alert on execution timeout

Automatic log collection

SchedulerX collects pod logs automatically. View and analyze failure details in the console without activating Simple Log Service or other log services.

Built-in monitoring dashboard

View job execution metrics in a built-in dashboard without activating Managed Service for Prometheus.

Mixed deployment of online and offline jobs

SchedulerX supports both Java and Kubernetes jobs, enabling mixed scheduling of online and offline workloads:

• Online jobs that require low latency (for example, order processing): run as method calls within the same Java process.

• Offline jobs that consume significant resources (for example, financial report generation): run as scripts in separate pods.