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,37 @@ 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.
+
+The following code snippet includes a Task state that uses eks:call to list the pods.
+
+```ts
+import * as eks from '@aws-cdk/aws-eks';
+import * as sfn from '@aws-cdk/aws-stepfunctions';
+import * as tasks from '@aws-cdk/aws-stepfunctions-tasks';
+
+const myEksCluster = new eks.Cluster(this, 'my sample cluster', {
+ version: eks.KubernetesVersion.V1_18,
+ clusterName: 'myEksCluster',
+ });
+
+new tasks.EksCall(stack, 'Call a EKS Endpoint', {
+ cluster: myEksCluster,
+ httpMethod: MethodType.GET,
+ httpPath: '/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,118 @@
+import * as eks from '@aws-cdk/aws-eks';
+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
+ * @experimental
+ */
+export interface EksCallProps extends sfn.TaskStateBaseProps {
+
+ /**
+ * The EKS cluster
+ */
+ readonly cluster: eks.ICluster;
+
+ /**
+ * HTTP method ("GET", "POST", "PUT", ...) part of HTTP request
+ */
+ readonly httpMethod: HttpMethods;
+
+ /**
+ * HTTP path of the Kubernetes REST API operation
+ */
+ readonly httpPath: 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
+ * @experimental
+ */
+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.cluster.clusterName,
+ CertificateAuthority: this.props.cluster.clusterCertificateAuthorityData,
+ Endpoint: this.props.cluster.clusterEndpoint,
+ Method: this.props.httpMethod,
+ Path: this.props.httpPath,
+ QueryParameters: this.props.queryParameters,
+ RequestBody: this.props.requestBody,
+ }),
+ };
+ }
+}
+
+/**
+ * Method type of a EKS call
+ */
+export enum HttpMethods {
+ /**
+ * 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

@@ -44,3 +44,4 @@ 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/package.json

@@ -81,6 +81,7 @@
  "@aws-cdk/aws-ecr": "0.0.0",
  "@aws-cdk/aws-ecr-assets": "0.0.0",
  "@aws-cdk/aws-ecs": "0.0.0",
+ "@aws-cdk/aws-eks": "0.0.0",
  "@aws-cdk/aws-glue": "0.0.0",
  "@aws-cdk/aws-iam": "0.0.0",
  "@aws-cdk/aws-kms": "0.0.0",
@@ -103,6 +104,7 @@
  "@aws-cdk/aws-ecr": "0.0.0",
  "@aws-cdk/aws-ecr-assets": "0.0.0",
  "@aws-cdk/aws-ecs": "0.0.0",
+ "@aws-cdk/aws-eks": "0.0.0",
  "@aws-cdk/aws-glue": "0.0.0",
  "@aws-cdk/aws-iam": "0.0.0",
  "@aws-cdk/aws-kms": "0.0.0",

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

@@ -0,0 +1,103 @@
+import * as eks from '@aws-cdk/aws-eks';
+import * as sfn from '@aws-cdk/aws-stepfunctions';
+import { Stack } from '@aws-cdk/core';
+import { EksCall, HttpMethods } from '../../lib/eks/call';
+
+let stack: Stack;
+let cluster: eks.Cluster;
+
+beforeEach(() => {
+ //GIVEN
+ stack = new Stack();
+ cluster = new eks.Cluster(stack, 'Cluster', {
+ version: eks.KubernetesVersion.V1_18,
+ clusterName: 'eksCluster',
+ });
+});
+
+test('Call an EKS endpoint', () => {
+ // WHEN
+ const task = new EksCall(stack, 'Call', {
+ cluster: cluster,
+ httpMethod: HttpMethods.GET,
+ httpPath: '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: {
+ Ref: 'Cluster9EE0221C',
+ },
+ CertificateAuthority: {
+ 'Fn::GetAtt': [
+ 'Cluster9EE0221C',
+ 'CertificateAuthorityData',
+ ],
+ },
+ Endpoint: {
+ 'Fn::GetAtt': [
+ 'Cluster9EE0221C',
+ 'Endpoint',
+ ],
+ },
+ Method: 'GET',
+ Path: 'path',
+ RequestBody: {
+ type: 1,
+ value: {
+ RequestBody: 'requestBody',
+ },
+ },
+ },
+ });
+});
+
+test('Task throws if RUN_JOB is supplied as service integration pattern', () => {
+ expect(() => {
+ new EksCall(stack, 'Call', {
+ cluster: cluster,
+ httpMethod: HttpMethods.GET,
+ httpPath: 'path',
+ requestBody: sfn.TaskInput.fromObject({
+ RequestBody: 'requestBody',
+ }),
+ integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+ });
+ }).toThrow(
+ /Unsupported service integration pattern. Supported Patterns: REQUEST_RESPONSE. Received: RUN_JOB/,
+ );
+});
+
+test('Task throws if WAIT_FOR_TASK_TOKEN is supplied as service integration pattern', () => {
+ expect(() => {
+ new EksCall(stack, 'Call', {
+ cluster: cluster,
+ httpMethod: HttpMethods.GET,
+ httpPath: 'path',
+ requestBody: sfn.TaskInput.fromObject({
+ RequestBody: 'requestBody',
+ }),
+ integrationPattern: sfn.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
+ });
+ }).toThrow(
+ /Unsupported service integration pattern. Supported Patterns: REQUEST_RESPONSE. Received: WAIT_FOR_TASK_TOKEN/,
+ );
+});