Using Map state in Inline mode in Step Functions workflows

By default, Map states runs in Inline mode. In Inline mode, the Map state accepts only a JSON array as input. It receives this array from a previous step in the workflow. In this mode, each iteration of the Map state runs in the context of the workflow that contains the Map state. Step Functions adds the execution history of these iterations to the parent workflow's execution history.

In this mode, the Map state supports up to 40 concurrent iterations.

A Map state set to Inline is known as an Inline Map state. Use the Map state in Inline mode if your workflow's execution history won't exceed 25,000 entries, or if you don't require more than 40 concurrent iterations.

For an introduction to using the Inline Map state, see the tutorial Repeat actions with Inline Map.

Key concepts in this topic

Inline Map state fields

To use the Inline Map state in your workflows, specify one or more of these fields. You specify these fields in addition to the common state fields.

Deprecated fields

Inline Map state example (JSONPath)

Consider the following input data for a Map state running in Inline mode.

{
  "ship-date": "2016-03-14T01:59:00Z",
  "detail": {
    "delivery-partner": "UQS",
    "shipped": [
      { "prod": "R31", "dest-code": 9511, "quantity": 1344 },
      { "prod": "S39", "dest-code": 9511, "quantity": 40 },
      { "prod": "R31", "dest-code": 9833, "quantity": 12 },
      { "prod": "R40", "dest-code": 9860, "quantity": 887 },
      { "prod": "R40", "dest-code": 9511, "quantity": 1220 }
    ]
  }
}

Given the previous input, the Map state in the following example invokes an AWS Lambda function named ship-val once for each item of the array in the shipped field.

"Validate All": {
    "Type": "Map",
    "InputPath": "$.detail",
    "ItemProcessor": {
        "ProcessorConfig": {
            "Mode": "INLINE"
        },
        "StartAt": "Validate",
        "States": {
            "Validate": {
                "Type": "Task",
                "Resource": "arn:aws:states:::lambda:invoke",
                "OutputPath": "$.Payload",
                "Parameters": {
                    "FunctionName": "arn:aws:lambda:us-east-2:account-id:function:ship-val:$LATEST"
                },
                "End": true
            }
        }
    },
    "End": true,
    "ResultPath": "$.detail.shipped",
    "ItemsPath": "$.shipped"
}

Each iteration of the Map state sends an item in the array, selected with the ItemsPath field, as input to the ship-val Lambda function. The following values are an example of input the Map state sends to an invocation of the Lambda function:

{
  "prod": "R31",
  "dest-code": 9511,
  "quantity": 1344
}

When complete, the output of the Map state is a JSON array, where each item is the output of an iteration. In this case, this array contains the output of the ship-val Lambda function.

Inline Map state example with ItemSelector

Suppose that the ship-val Lambda function in the previous example also needs information about the shipment's courier. This information is in addition to the items in the array for each iteration. You can include information from the input, along with information specific to the current iteration of the Map state. Note the ItemSelector field in the following example:

"Validate-All": {
  "Type": "Map",
  "InputPath": "$.detail",
  "ItemsPath": "$.shipped",
  "MaxConcurrency": 0,
  "ResultPath": "$.detail.shipped",
  "ItemSelector": {
    "parcel.$": "$$.Map.Item.Value",
    "courier.$": "$.delivery-partner"
  },
  "ItemProcessor": {
    "StartAt": "Validate",
    "States": {
      "Validate": {
        "Type": "Task",
	"Resource": "arn:aws:lambda:region:account-id:function:ship-val",
        "End": true
      }
    }
  },
  "End": true
}

The ItemSelector block replaces the input to the iterations with a JSON node. This node contains both the current item data from the Context object and the courier information from the Map state input's delivery-partner field. The following is an example of input to a single iteration. The Map state passes this input to an invocation of the ship-val Lambda function.

{
  "parcel": {
    "prod": "R31",
    "dest-code": 9511,
    "quantity": 1344
   },
   "courier": "UQS"
}

In the previous Inline Map state example, the ResultPath field produces output in the same format as the input. However, it overwrites the detail.shipped field with an array in which each element is the output of each iteration's ship-val Lambda invocation.

For more information about using the Inline Map state state and its fields, see the following.

Inline Map state input and output processing

For a given Map state, InputPath selects a subset of the state's input.

The input of a Map state must include a JSON array. The Map state runs the ItemProcessor section once for each item in the array. If you specify the ItemsPath field, the Map state selects where in the input to find the array to iterate over. If not specified, the value of ItemsPath is $, and the ItemProcessor section expects that the array is the only input. If you specify the ItemsPath field, its value must be a Reference Path. The Map state applies this path to the effective input after it applies the InputPath. The ItemsPath must identify a field whose value is a JSON array.

The input to each iteration, by default, is a single element of the array field identified by the ItemsPath value. You can override this value with the ItemSelector (Map) field.

When complete, the output of the Map state is a JSON array, where each item is the output of an iteration.

For more information about Inline Map state inputs and outputs, see the following: