state-machine - GitLite

KO | EN

gitlite — search

#nlp #cloud-native #machine-learning #python #containers #self-hosted #csharp #chatbot #android #ai

state-machine

(★ 42)

a CDK construct for Step Functions State Machines that allows for easy integration with Workflow Studio

파일 탐색기

ZIP 다운로드

- - build.yml
  - pull-request-lint.yml
  - release.yml
- FUNDING.yml
- pull_request_template.md
- - codeStyleConfig.xml
  - Project.xml
- - Project_Default.xml
- .gitignore
- modules.xml
- state-machine.iml
- vcs.xml
- deps.json
- files.json
- tasks.json
- BuildStateType.ts
- index.ts
- StateMachine.ts
- StepFunctionsAutoDiscover.ts
- - StateMachine.test.ts.snap
  - StateMachineAutoDiscover.test.ts.snap
- - test.json.asl
  - test.workflow.json
  - test.yaml.asl
  - test2.workflow.json
- sample.json
- StateMachine.test.ts
- StateMachineAutoDiscover.test.ts
.eslintrc.json
.gitattributes
.gitignore
.mergify.yml
.npmignore
.projenrc.ts
API.md
LICENSE
package.json
README.md
tsconfig.dev.json
yarn.lock

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

명령어 용어집

이 문서에서 사용된 명령어를 모아봤습니다. 낯선 명령어가 있다면 펼쳐서 확인해보세요.

🔍

`Redshift`

설명 보기 ▼

주변 환경에 따라 화면의 색온도를 조정.
더 많은 정보: <https://manned.org/redshift>.

redshift -t 5700:3600

낮 동안 특정 [t]온도(예: 5700K)와 밤 동안 특정 온도(예: 3600K)로 Redshift 켜기:

redshift -l {{latitude}}:{{longitude}}

수동으로 지정한 맞춤 [l]위치로 Redshift 켜기:

redshift -b 0.7:0.4

낮 동안 특정 화면 [b]밝기(예: 70%)와 밤 동안 특정 밝기(예: 40%)로 Redshift 켜기:

# 프로젝트 배지

View on Construct Hub 바로가기

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

This is a Workflow Studio compatible AWS Step Function state machine construct.

The goal of this construct is to make it easy to build and maintain your state machines using the Workflow Studio but still
leverage the AWS CDK as the source of truth for the state machine.

Read more about it [here](https://matthewbonig.com/2022/02/19/step-functions-and-the-cdk/).

## How to Use This Construct

Start by designing your initial state machine using the Workflow Studio.
When done with your first draft, copy and paste the ASL definition to a local file.

Create a new instance of this construct, handing it a fully parsed version of the ASL. 
Then add overridden values. 
The fields in the `overrides` field should match the `States` field of the ASL.

## Version Usage

The AWS CDK `StateMachine` construct introduced a change in version [**2.85.0**](https://github.com/aws/aws-cdk/pull/25932) that deprecated an earlier usage of 'definition'
by this construct. This construct has been updated to use the new 'definitionBody' field.

If you are using a version of the CDK before version **2.85.0**, you should use version **0.0.28** of this construct.

If you are using a version fo the CDK great or equal to **2.85.0**, you should use version **0.0.29+** of this construct.

### Projen component

There is a projen component included in this library which will help you in using the construct. It works similar
to the [auto-discovery feature](https://projen.io/docs/integrations/aws/#aws-lambda-functions). To use it, first add the component
to your projen project:

```js
// ...
const { StepFunctionsAutoDiscover } = require('@matthewbonig/state-machine');

const project = new awscdk.AwsCdkTypeScriptApp({
  // ...,
  deps: [
    // ...,
    '@matthewbonig/state-machine',
  ]
});

new StepFunctionsAutoDiscover(project);
```

Now projen will look for any files with a suffix `.workflow.json` and generate new files beside the .json:
* A typed `overrides` interface which is based on your workflow.
* A construct derived from `StateMachine` that uses this override.

Instead of using the `StateMachine` construct directly you can now use the generated one:

```text
.
├── MyFancyThing.workflow.json
└── MyFancyThing-statemachine.ts
```

```ts
export class SomeStack extends Stack {
  constructor(scope: Construct, id: string, props: StackProps) {
    super(scope, id, props);
    const handler = new NodejsFunction(this, 'MyHandler');
    new SomeFancyThingStateMachine(this, 'MyFancyWorkflow', {
      overrides: {
        'My First State': {
          Parameters: {
            FunctionName: handler.functionName
          }
        }
      }
    })
  }
}
```

> :warning: **The interfaces and constructs generated here are NOT jsii compliant (they use Partials and Omits) and cannot be 
compiled by jsii into other languages. If you plan to distribute any libraries you cannot use this.**

### Alternative Extensions

There is an optional parameter, `extension` that you can pass to have it search for alternative extensions.
AWS recommends that ASL definition files have a `.asl.json` extension, which will be picked up by some IDE
tools. This extension was recommended after initial development of this component. Therefore, the default is
to use the original extension. But, you can override this by passing a different extension to the
AutoDiscover's constructor options. There are two constants defined, `JSON_STEPFUNCTION_EXT` and `AWS_RECOMMENDED_JSON_EXT` that you can use.

```js
// ...
const { StepFunctionsAutoDiscover, AWS_RECOMMENDED_JSON_EXT } = require('@matthewbonig/state-machine');

const project = new awscdk.AwsCdkTypeScriptApp({
  // ...,
  deps: [
    // ...,
    '@matthewbonig/state-machine',
  ]
});

new StepFunctionsAutoDiscover(project, { extension: AWS_RECOMMENDED_JSON_EXT });
```

### Yaml files

Yaml files are supported as well. You can provide an extension to the AutoDiscover component to have it search for yaml files. If the file has 'yaml' or 'yml' anywhere in the name it will be parsed as yaml. If not, it will be parsed as json.

```js
// ...
const { StepFunctionsAutoDiscover } = require('@matthewbonig/state-machine');

const project = new awscdk.AwsCdkTypeScriptApp({
  // ...,
  deps: [
    // ...,
    '@matthewbonig/state-machine',
  ]
});

new StepFunctionsAutoDiscover(project, { extension: '.yaml.asl' });
```

### Examples

```ts
const secret = new Secret(stack, 'Secret', {});
new StateMachine(stack, 'Test', {
  stateMachineName: 'A nice state machine',
  definition: JSON.parse(fs.readFileSync(path.join(__dirname, 'sample.json'), 'utf8').toString()),
  overrides: {
    'Read database credentials secret': {
      Parameters: {
        SecretId: secret.secretArn,
      },
    },
  },
});
```

You can also override nested states in arrays, for example:

```ts
new StateMachine(stack, 'Test', {
    stateMachineName: 'A-nice-state-machine',
    overrides: {
      Branches: [{
        // pass an empty object too offset overrides
      }, {
        StartAt: 'StartInstances',
        States: {
          StartInstances: {
            Parameters: {
              InstanceIds: ['INSTANCE_ID'],
            },
          },
        },
      }],
    },
    stateMachineType: StateMachineType.STANDARD,
    definition: {
      States: {
        Branches: [
          {
            StartAt: 'ResumeCluster',
            States: {
              'Redshift Pass': {
                Type: 'Pass',
                End: true,
              },
            },
          },
          {
            StartAt: 'StartInstances',
            States: {
              'StartInstances': {
                Type: 'Task',
                Parameters: {
                  InstanceIds: [
                    'MyData',
                  ],
                },
                Resource: 'arn:aws:states:::aws-sdk:ec2:startInstances',
                Next: 'DescribeInstanceStatus',
              },
              'DescribeInstanceStatus': {
                Type: 'Task',
                Next: 'EC2 Pass',
                Parameters: {
                  InstanceIds: [
                    'MyData',
                  ],
                },
                Resource: 'arn:aws:states:::aws-sdk:ec2:describeInstanceStatus',
              },
              'EC2 Pass': {
                Type: 'Pass',
                End: true,
              },
            },
          },
        ],
      },
    },
  });
```

For Python, be sure to use a context manager when opening your JSON file.  
- You do not need to `str()` the dictionary object you supply as your `definition` prop.  
- Elements of your override path **do** need to be strings.

```python
secret = Secret(stack, 'Secret')

with open('sample.json', 'r+', encoding='utf-8') as sample:
    sample_dict = json.load(sample)

state_machine = StateMachine(
    self,
    'Test',
    definition = sample_dict,
    overrides = {
    "Read database credentials secret": {
      "Parameters": {
        "SecretId": secret.secret_arn,
      },
    },
  })
```

In this example, the ASL has a state called 'Read database credentials secret' and the SecretId parameter is overridden with a 
CDK generated value.
Future changes can be done by editing, debugging, and testing the state machine directly in the Workflow Studio.
Once everything is working properly, copy and paste the ASL back to your local file.

## Issues

Please open any issues you have on [Github](https://github.com/mbonig/state-machine/issues).

## Contributing

Please submit PRs from forked repositories if you'd like to contribute.