feat(stepfunctions-tasks): add EKS call to SFN-tasks

packages/@aws-cdk/aws-stepfunctions-tasks/README.md

@@ -54,6 +54,8 @@ This module is part of the [AWS Cloud Development Kit](https://github.com/aws/aw
   - [Cancel Step](#cancel-step)
   - [Modify Instance Fleet](#modify-instance-fleet)
   - [Modify Instance Group](#modify-instance-group)
+- [EKS](#eks)
+  - [Call](#call)
 - [Glue](#glue)
 - [Glue DataBrew](#glue-databrew)
 - [Lambda](#lambda)
@@ -664,6 +666,28 @@ new tasks.EmrModifyInstanceGroupByName(stack, 'Task', {
 });
 ```
 
+## EKS
+
+Step Functions supports Amazon EKS through the service integration pattern.
+The service integration APIs correspond to Amazon EKS APIs.
+
+[Read more](https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html) about the differences when using these service integrations.
+
+### Call
+
+Read and write Kubernetes resource objects via a Kubernetes API endpoint.
+Corresponds to the [`call`](https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html) API in Step Functions Connector.
+
+```ts
+new tasks.EksCall(stack, 'Call a EKS Endpoint', {
+  clusterName: 'clusterName',
+  certificateAuthority: 'certificateAuthority',
+  endpoint: 'https://apiid.gr7.us-east-1.eks.amazonaws.com',
+  httpMethod: MethodType.GET,
+  path: '/api/v1/namespaces/default/pods',
+});
+```
+
 ## Glue
 
 Step Functions supports [AWS Glue](https://docs.aws.amazon.com/step-functions/latest/dg/connect-glue.html) through the service integration pattern.

packages/@aws-cdk/aws-stepfunctions-tasks/lib/eks/call.ts

@@ -0,0 +1,125 @@
+import * as iam from '@aws-cdk/aws-iam';
+import * as sfn from '@aws-cdk/aws-stepfunctions';
+import { Construct } from 'constructs';
+import { integrationResourceArn, validatePatternSupported } from '../private/task-utils';
+
+/**
+ * Properties for calling a EKS endpoint with EksCall
+ */
+export interface EksCallProps extends sfn.TaskStateBaseProps {
+
+  /**
+   * Name of the cluster
+   */
+  readonly clusterName: string;
+
+  /**
+   * Base 64 encoded certificate data required to communicate with your cluster
+   */
+  readonly certificateAuthority: string;
+
+  /**
+   * API endpoint to communicate with your cluster
+   */
+  readonly endpoint: string;
+
+  /**
+   * HTTP method ("GET", "POST", "PUT", ...) part of HTTP request
+   */
+  readonly httpMethod: MethodType;
+
+  /**
+   * Path of cluster
+   */
+  readonly path: string;
+
+  /**
+   * Query Parameters part of HTTP request
+   * @default - no query parameters
+   */
+  readonly queryParameters?: { [key: string]: string[] };
+
+  /**
+   * Request body part of HTTP request
+   * @default - No request body
+   */
+  readonly requestBody?: { [key: string]: any };
+}
+
+/**
+ * Call a EKS endpoint as a Task
+ *
+ * @see https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html
+ */
+export class EksCall extends sfn.TaskStateBase {
+
+  private static readonly SUPPORTED_INTEGRATION_PATTERNS: sfn.IntegrationPattern[] = [
+    sfn.IntegrationPattern.REQUEST_RESPONSE,
+  ];
+
+  protected readonly taskMetrics?: sfn.TaskMetricsConfig;
+  protected readonly taskPolicies?: iam.PolicyStatement[];
+
+  private readonly integrationPattern: sfn.IntegrationPattern;
+
+  constructor(scope: Construct, id: string, private readonly props: EksCallProps) {
+    super(scope, id, props);
+    this.integrationPattern = props.integrationPattern ?? sfn.IntegrationPattern.REQUEST_RESPONSE;
+
+    validatePatternSupported(this.integrationPattern, EksCall.SUPPORTED_INTEGRATION_PATTERNS);
+  }
+
+  /**
+   * Provides the EKS Call service integration task configuration
+   * @internal
+   */
+  protected _renderTask(): any {
+    return {
+      Resource: integrationResourceArn('eks', 'call', this.integrationPattern),
+      Parameters: sfn.FieldUtils.renderObject({
+        ClusterName: this.props.clusterName,
+        CertificateAuthority: this.props.certificateAuthority,
+        Endpoint: this.props.endpoint,
+        Method: this.props.httpMethod,
+        Path: this.props.path,
+        QueryParameters: this.props.queryParameters,
+        RequestBody: this.props.requestBody,
+      }),
+    };
+  }
+}
+
+/**
+ * Method type of a EKS call
+ */
+export enum MethodType {
+  /**
+   * Retrieve data from a server at the specified resource
+   */
+  GET = 'GET',
+
+  /**
+   * Send data to the API endpoint to create or update a resource
+   */
+  POST = 'POST',
+
+  /**
+   * Send data to the API endpoint to update or create a resource
+   */
+  PUT = 'PUT',
+
+  /**
+   * Delete the resource at the specified endpoint
+   */
+  DELETE = 'DELETE',
+
+  /**
+   * Apply partial modifications to the resource
+   */
+  PATCH = 'PATCH',
+
+  /**
+   * Retrieve data from a server at the specified resource without the response body
+   */
+  HEAD = 'HEAD'
+}

packages/@aws-cdk/aws-stepfunctions-tasks/lib/index.ts

@@ -39,8 +39,10 @@ export * from './dynamodb/update-item';
 export * from './dynamodb/delete-item';
 export * from './dynamodb/shared-types';
 export * from './codebuild/start-build';
+export * from './eks/call';
 export * from './athena/start-query-execution';
 export * from './athena/stop-query-execution';
 export * from './athena/get-query-execution';
 export * from './athena/get-query-results';
 export * from './databrew/start-job-run';
+export * from './eks/call';

packages/@aws-cdk/aws-stepfunctions-tasks/test/eks/call.test.ts

@@ -0,0 +1,54 @@
+import * as sfn from '@aws-cdk/aws-stepfunctions';
+import * as cdk from '@aws-cdk/core';
+import { EksCall, MethodType } from '../../lib/eks/call';
+
+describe('Call an EKS endpoint', () => {
+
+  test('default settings', () => {
+    // GIVEN
+    const stack = new cdk.Stack();
+
+    // WHEN
+    const task = new EksCall(stack, 'Call', {
+      clusterName: 'clusterName',
+      certificateAuthority: 'certificateAuthority',
+      endpoint: 'endpoint',
+      httpMethod: MethodType.GET,
+      path: 'path',
+      requestBody: sfn.TaskInput.fromObject({
+        RequestBody: 'requestBody',
+      }),
+    });
+
+    // THEN
+    expect(stack.resolve(task.toStateJson())).toEqual({
+      Type: 'Task',
+      Resource: {
+        'Fn::Join': [
+          '',
+          [
+            'arn:',
+            {
+              Ref: 'AWS::Partition',
+            },
+            ':states:::eks:call',
+          ],
+        ],
+      },
+      End: true,
+      Parameters: {
+        ClusterName: 'clusterName',
+        CertificateAuthority: 'certificateAuthority',
+        Endpoint: 'endpoint',
+        Method: 'GET',
+        Path: 'path',
+        RequestBody: {
+          type: 1,
+          value: {
+            RequestBody: 'requestBody',
+          },
+        },
+      },
+    });
+  });
+});

packages/@aws-cdk/aws-stepfunctions-tasks/test/eks/integ.call.expected.json

@@ -0,0 +1,65 @@
+{
+  "Resources": {
+    "StateMachineRoleB840431D": {
+      "Type": "AWS::IAM::Role",
+      "Properties": {
+        "AssumeRolePolicyDocument": {
+          "Statement": [
+            {
+              "Action": "sts:AssumeRole",
+              "Effect": "Allow",
+              "Principal": {
+                "Service": {
+                  "Fn::Join": [
+                    "",
+                    [
+                      "states.",
+                      {
+                        "Ref": "AWS::Region"
+                      },
+                      ".amazonaws.com"
+                    ]
+                  ]
+                }
+              }
+            }
+          ],
+          "Version": "2012-10-17"
+        }
+      }
+    },
+    "StateMachine2E01A3A5": {
+      "Type": "AWS::StepFunctions::StateMachine",
+      "Properties": {
+        "RoleArn": {
+          "Fn::GetAtt": [
+            "StateMachineRoleB840431D",
+            "Arn"
+          ]
+        },
+        "DefinitionString": {
+          "Fn::Join": [
+            "",
+            [
+              "{\"StartAt\":\"Call a EKS Endpoint\",\"States\":{\"Call a EKS Endpoint\":{\"End\":true,\"Type\":\"Task\",\"Resource\":\"arn:",
+              {
+                "Ref": "AWS::Partition"
+              },
+              ":states:::eks:call\",\"Parameters\":{\"ClusterName\":\"clusterName\",\"CertificateAuthority\":\"certificateAuthority\",\"Endpoint\":\"https://apiid.gr7.us-east-1.eks.amazonaws.com\",\"Method\":\"GET\",\"Path\":\"/api/v1/namespaces/default/pods\"}}},\"TimeoutSeconds\":30}"
+            ]
+          ]
+        }
+      },
+      "DependsOn": [
+        "StateMachineRoleB840431D"
+      ]
+    }
+  },
+  "Outputs": {
+    "stateMachineArn": {
+      "Value": {
+        "Ref": "StateMachine2E01A3A5"
+      }
+    }
+  }
+}

packages/@aws-cdk/aws-stepfunctions-tasks/test/eks/integ.call.ts

@@ -0,0 +1,28 @@
+import * as sfn from '@aws-cdk/aws-stepfunctions';
+import * as cdk from '@aws-cdk/core';
+import { EksCall, MethodType } from '../../lib';
+
+const app = new cdk.App();
+const stack = new cdk.Stack(app, 'aws-stepfunctions-tasks-eks-call-integ');
+
+const callJob = new EksCall(stack, 'Call a EKS Endpoint', {
+  clusterName: 'clusterName',
+  certificateAuthority: 'certificateAuthority',
+  endpoint: 'https://apiid.gr7.us-east-1.eks.amazonaws.com',
+  httpMethod: MethodType.GET,
+  path: '/api/v1/namespaces/default/pods',
+});
+
+const chain = sfn.Chain.start(callJob);
+
+const sm = new sfn.StateMachine(stack, 'StateMachine', {
+  definition: chain,
+  timeout: cdk.Duration.seconds(30),
+});
+
+new cdk.CfnOutput(stack, 'stateMachineArn', {
+  value: sm.stateMachineArn,
+});
+
+
+app.synth();