aws-cdk-lib.aws_stepfunctions.IntegrationPattern

IntegrationPattern Enum

AWS Step Functions integrates with services directly in the Amazon States Language.

You can control these AWS services using service integration patterns:

Source

aws-stepfunctions/lib/states/task-base.ts

Example

import * as codebuild from 'aws-cdk-lib/aws-codebuild';

const codebuildProject = new codebuild.Project(this, 'Project', {
  projectName: 'MyTestProject',
  buildSpec: codebuild.BuildSpec.fromObject({
    version: '0.2',
    phases: {
      build: {
        commands: [
          'echo "Hello, CodeBuild!"',
        ],
      },
    },
  }),
});

const task = new tasks.CodeBuildStartBuild(this, 'Task', {
  project: codebuildProject,
  integrationPattern: sfn.IntegrationPattern.RUN_JOB,
  environmentVariablesOverride: {
    ZONE: {
      type: codebuild.BuildEnvironmentVariableType.PLAINTEXT,
      value: sfn.JsonPath.stringAt('$.envVariables.zone'),
    },
  },
});

import aws_cdk.aws_codebuild as codebuild


codebuild_project = codebuild.Project(self, "Project",
    project_name="MyTestProject",
    build_spec=codebuild.BuildSpec.from_object({
        "version": "0.2",
        "phases": {
            "build": {
                "commands": ["echo \"Hello, CodeBuild!\""
                ]
            }
        }
    })
)

task = tasks.CodeBuildStartBuild(self, "Task",
    project=codebuild_project,
    integration_pattern=sfn.IntegrationPattern.RUN_JOB,
    environment_variables_override={
        "ZONE": codebuild.BuildEnvironmentVariable(
            type=codebuild.BuildEnvironmentVariableType.PLAINTEXT,
            value=sfn.JsonPath.string_at("$.envVariables.zone")
        )
    }
)

import software.amazon.awscdk.services.codebuild.*;


Project codebuildProject = Project.Builder.create(this, "Project")
        .projectName("MyTestProject")
        .buildSpec(BuildSpec.fromObject(Map.of(
                "version", "0.2",
                "phases", Map.of(
                        "build", Map.of(
                                "commands", List.of("echo \"Hello, CodeBuild!\""))))))
        .build();

CodeBuildStartBuild task = CodeBuildStartBuild.Builder.create(this, "Task")
        .project(codebuildProject)
        .integrationPattern(IntegrationPattern.RUN_JOB)
        .environmentVariablesOverride(Map.of(
                "ZONE", BuildEnvironmentVariable.builder()
                        .type(BuildEnvironmentVariableType.PLAINTEXT)
                        .value(JsonPath.stringAt("$.envVariables.zone"))
                        .build()))
        .build();

// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.CodeBuild;


var codebuildProject = new Project(this, "Project", new ProjectProps {
    ProjectName = "MyTestProject",
    BuildSpec = BuildSpec.FromObject(new Dictionary<string, object> {
        { "version", "0.2" },
        { "phases", new Dictionary<string, IDictionary<string, string[]>> {
            { "build", new Struct {
                Commands = new [] { "echo \"Hello, CodeBuild!\"" }
            } }
        } }
    })
});

var task = new CodeBuildStartBuild(this, "Task", new CodeBuildStartBuildProps {
    Project = codebuildProject,
    IntegrationPattern = IntegrationPattern.RUN_JOB,
    EnvironmentVariablesOverride = new Dictionary<string, BuildEnvironmentVariable> {
        { "ZONE", new BuildEnvironmentVariable {
            Type = BuildEnvironmentVariableType.PLAINTEXT,
            Value = JsonPath.StringAt("$.envVariables.zone")
        } }
    }
});

// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import "github.com/aws/aws-cdk-go/awscdk"


codebuildProject := codebuild.NewProject(this, jsii.String("Project"), &ProjectProps{
	ProjectName: jsii.String("MyTestProject"),
	BuildSpec: codebuild.BuildSpec_FromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("echo \"Hello, CodeBuild!\""),
				},
			},
		},
	}),
})

task := tasks.NewCodeBuildStartBuild(this, jsii.String("Task"), &CodeBuildStartBuildProps{
	Project: codebuildProject,
	IntegrationPattern: sfn.IntegrationPattern_RUN_JOB,
	EnvironmentVariablesOverride: map[string]BuildEnvironmentVariable{
		"ZONE": &BuildEnvironmentVariable{
			"type": codebuild.BuildEnvironmentVariableType_PLAINTEXT,
			"value": sfn.JsonPath_stringAt(jsii.String("$.envVariables.zone")),
		},
	},
})

Members

Member	Description
REQUEST_RESPONSE	Step Functions will wait for an HTTP response and then progress to the next state.
RUN_JOB	Step Functions can wait for a request to complete before progressing to the next state.
WAIT_FOR_TASK_TOKEN	Callback tasks provide a way to pause a workflow until a task token is returned.

Referenced by

• TaskStateBaseOptions.integrationPatternintegration_patternintegrationPatternIntegrationPatternIntegrationPattern