Workflow

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.glue.Workflow("example", {name: "example"});
const example_start = new aws.glue.Trigger("example-start", {
    name: "trigger-start",
    type: "ON_DEMAND",
    workflowName: example.name,
    actions: [{
        jobName: "example-job",
    }],
});
const example_inner = new aws.glue.Trigger("example-inner", {
    name: "trigger-inner",
    type: "CONDITIONAL",
    workflowName: example.name,
    predicate: {
        conditions: [{
            jobName: "example-job",
            state: "SUCCEEDED",
        }],
    },
    actions: [{
        jobName: "another-example-job",
    }],
});

import pulumi
import pulumi_aws as aws
example = aws.glue.Workflow("example", name="example")
example_start = aws.glue.Trigger("example-start",
    name="trigger-start",
    type="ON_DEMAND",
    workflow_name=example.name,
    actions=[aws.glue.TriggerActionArgs(
        job_name="example-job",
    )])
example_inner = aws.glue.Trigger("example-inner",
    name="trigger-inner",
    type="CONDITIONAL",
    workflow_name=example.name,
    predicate=aws.glue.TriggerPredicateArgs(
        conditions=[aws.glue.TriggerPredicateConditionArgs(
            job_name="example-job",
            state="SUCCEEDED",
        )],
    ),
    actions=[aws.glue.TriggerActionArgs(
        job_name="another-example-job",
    )])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Glue.Workflow("example", new()
    {
        Name = "example",
    });
    var example_start = new Aws.Glue.Trigger("example-start", new()
    {
        Name = "trigger-start",
        Type = "ON_DEMAND",
        WorkflowName = example.Name,
        Actions = new[]
        {
            new Aws.Glue.Inputs.TriggerActionArgs
            {
                JobName = "example-job",
            },
        },
    });
    var example_inner = new Aws.Glue.Trigger("example-inner", new()
    {
        Name = "trigger-inner",
        Type = "CONDITIONAL",
        WorkflowName = example.Name,
        Predicate = new Aws.Glue.Inputs.TriggerPredicateArgs
        {
            Conditions = new[]
            {
                new Aws.Glue.Inputs.TriggerPredicateConditionArgs
                {
                    JobName = "example-job",
                    State = "SUCCEEDED",
                },
            },
        },
        Actions = new[]
        {
            new Aws.Glue.Inputs.TriggerActionArgs
            {
                JobName = "another-example-job",
            },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/glue"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := glue.NewWorkflow(ctx, "example", &glue.WorkflowArgs{
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = glue.NewTrigger(ctx, "example-start", &glue.TriggerArgs{
			Name:         pulumi.String("trigger-start"),
			Type:         pulumi.String("ON_DEMAND"),
			WorkflowName: example.Name,
			Actions: glue.TriggerActionArray{
				&glue.TriggerActionArgs{
					JobName: pulumi.String("example-job"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = glue.NewTrigger(ctx, "example-inner", &glue.TriggerArgs{
			Name:         pulumi.String("trigger-inner"),
			Type:         pulumi.String("CONDITIONAL"),
			WorkflowName: example.Name,
			Predicate: &glue.TriggerPredicateArgs{
				Conditions: glue.TriggerPredicateConditionArray{
					&glue.TriggerPredicateConditionArgs{
						JobName: pulumi.String("example-job"),
						State:   pulumi.String("SUCCEEDED"),
					},
				},
			},
			Actions: glue.TriggerActionArray{
				&glue.TriggerActionArgs{
					JobName: pulumi.String("another-example-job"),
				},
			},
		})
		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.glue.Workflow;
import com.pulumi.aws.glue.WorkflowArgs;
import com.pulumi.aws.glue.Trigger;
import com.pulumi.aws.glue.TriggerArgs;
import com.pulumi.aws.glue.inputs.TriggerActionArgs;
import com.pulumi.aws.glue.inputs.TriggerPredicateArgs;
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 Workflow("example", WorkflowArgs.builder()
            .name("example")
            .build());
        var example_start = new Trigger("example-start", TriggerArgs.builder()
            .name("trigger-start")
            .type("ON_DEMAND")
            .workflowName(example.name())
            .actions(TriggerActionArgs.builder()
                .jobName("example-job")
                .build())
            .build());
        var example_inner = new Trigger("example-inner", TriggerArgs.builder()
            .name("trigger-inner")
            .type("CONDITIONAL")
            .workflowName(example.name())
            .predicate(TriggerPredicateArgs.builder()
                .conditions(TriggerPredicateConditionArgs.builder()
                    .jobName("example-job")
                    .state("SUCCEEDED")
                    .build())
                .build())
            .actions(TriggerActionArgs.builder()
                .jobName("another-example-job")
                .build())
            .build());
    }
}

resources:
  example:
    type: aws:glue:Workflow
    properties:
      name: example
  example-start:
    type: aws:glue:Trigger
    properties:
      name: trigger-start
      type: ON_DEMAND
      workflowName: ${example.name}
      actions:
        - jobName: example-job
  example-inner:
    type: aws:glue:Trigger
    properties:
      name: trigger-inner
      type: CONDITIONAL
      workflowName: ${example.name}
      predicate:
        conditions:
          - jobName: example-job
            state: SUCCEEDED
      actions:
        - jobName: another-example-job

$ pulumi import aws:glue/workflow:Workflow MyWorkflow MyWorkflow