Trucos de función de paso de AWS

Muy buenas, me llamo Miguel y hoy les traigo otro nuevo tutorial.

4 trucos para ayudar a construir flujos de trabajo

Después de haber trabajado con las funciones de pasos de AWS durante un tiempo, tuve que superar algunos obstáculos para obtener lo que quería, y pensé que otras personas podrían beneficiarse de las horas de tirones de cabello. Compartir es cuidar, o eso dicen …

1. Elevación de un solo valor en una matriz

Ocasionalmente, querrá convertir un valor en una matriz de ese valor. A menudo, este puede ser el caso si desea mapear un valor único o utilizar un parámetro dinámico con una invocación de tarea ECS como el argumento Command (porque solo acepta matrices, no una cadena 🤷‍♂).

Curiosamente, el Passtipo le permite realizar algunos movimientos de parámetros interesantes. Ambos InputPathy ResultPathson válidos (y la Parametersopción furtiva también está disponible si desea crear objetos más grandes).

{
  "StartAt": "Lift to Array",
  "States": {
     "Lift to Array": {
        "Type": "Pass",
        "InputPath": "$.param",
        "ResultPath": "$.paramList[0]",
        "Next": "Replace"
     },
     "Replace": {
        "Type": "Pass",
        "InputPath": "$.paramList",
        "ResultPath": "$.param",
        "End": true
      }
   }
}

Como se puede ver de lo anterior, la elevamos $.parama $.paramList[0] decir la posición 0 de una matriz, entonces basta con sustituir la $.paramen la etapa siguiente – $.param ahora es una matriz.

2. Concatenación de elementos en una única matriz

Como en el ejemplo anterior, pero un paso más. Cuando necesita una matriz de valores múltiples (nuevamente, argumentos Command de tarea ECS o Mapcon ItemsPath), y desea construirla a partir de varias claves en su estado, por ejemplo, convirtiéndose {k1:1, k2:2, k3:3}en{concat: [1,2,3]}

{
  "StartAt": "Concat",
  "States": {
     "Concat": {
       "Type": "Parallel",
       "InputPath": "$",
       "ResultPath": "$.concat",
       "Branches": [
           {
              "StartAt": "Concat Key1",
              "States": {
                 "Concat Key1": {
                    "InputPath": "$.k1",
                    "Type": "Pass",
                    "End": true
                   }
               }
           },
       {
          "StartAt": "Concat Key2",
          "States": {
              "Concat Key2": {
                 "Result": "two",
                 "Type": "Pass",
                 "End": true
              }
          }
      },
      {
         "StartAt": "Concat Key3",
         "States": {
              "Concat Key3": {
                 "InputPath": "$.k3",
                 "Type": "Pass",
                 "End": true
               }
             }
          } 
        ],
     "End": true
    }
  }
}

Observe que en el ejemplo anterior sustituí el segundo valor por un concreto "two”usando Result en lugar de InputPath.
La salida resultante ahora es
{k1:1, k2:2, k3:3, concat: ["1","two","3"]}

3. Evite lambda :: invoke

Si usa la interfaz de usuario y / o consulta la documentación de AWS, la ruta recomendada actual para invocar una lambda es establecer su Resourceclave en arn:aws:states:::lambda:invoke. El problema aquí es que la respuesta que obtiene de Lambda incluye todos los metadatos del SDK en el resultado de la invocación. Esto te deja mucho trabajo por hacer para limpiar y mejorar tu estado. Normalmente, solo está interesado en la respuesta que devolvió su lambda, por lo que necesitamos encontrar una mejor manera.

¡No hagas esto!

"THE BAD WAY": {
  "Type": "Task",
  "Resource": "arn:aws:states:::lambda:invoke",
  "ResultPath": "$.theOutput",
  "Parameters": {
    "FunctionName": "<THE_LAMBDA_ARN_HERE>",
    "Payload": {
      "param1.$": "$.k1"
     }
   },
 "End": true
}

En lugar de hacer lo anterior, puede invocar el recurso directamente, es decir, NO a través de la metodología lambda:invoke recomendada , de la siguiente manera:

HAGA ESTO EN LUGAR

"THE GOOD WAY": {
   "Type": "Task",
   "Resource": "<THE_LAMBDA_ARN_HERE>",
   "ResultPath": "$.theOutput",
   "Parameters": {
      "param1.$": "$.k1"
    },
  "End": true
}

Ahora deberíamos obtener solo el mensaje de retorno que produce nuestra lambda en la ruta $.theOutput en nuestro estado de función de paso. 👍

4. Manejo de valores perdidos (valores opcionales)

El uso de JSONPath por AWS no tiene en cuenta las claves opcionales / faltantes y, por lo tanto, no hay forma de ignorar o predeterminar estos valores faltantes.

Dos cargas útiles de ejemplo podrían verse así: {"always": "here"}y{"always": "here", "sometimes": "here"}

Por lo general, encontrará esto cuando desee hacer algo como invocar un flujo de trabajo con un dateen un escenario, pero NO una fecha en otro (porque desea que el paso del flujo de trabajo asuma que la hora es now()). En realidad, la única opción para resolver esta situación es tener una clave sustituta que siempre utilice para dividir su flujo de trabajo en función de si tiene la clave o no.

El principal inconveniente aquí es que terminará copiando y pegando su invocación de paso en 2 lugares.

{
   "Comment": "A conditional parameter workflow",
   "StartAt": "Has Optional Parameter",
   "States": {
      "Has Optional Parameter": {
         "Type": "Choice",
         "InputPath": "$",
         "Choices":[
           {
              "Variable": "$.hasTheConditional",
              "BooleanEquals": true,
              "Next": "With Optional"
           },
           {
              "Variable": "$.hasTheConditional",
              "BooleanEquals": false,
              "Next": "Without Optional"
            } 
          ],
          "Default": "Without Optional"
        },
        "With Optional": {
           "Type": "Pass",
           "End": true
         },
         "Without Optional": {
            "Type": "Pass",
            "Result": "$.conditionalParameter",
            "End": true
         }
    }
}

Conclusión

Gracias por leer. Si te gustaron mis historias, dale una palmada o deja un comentario si hay algo que quieras que cubra la próxima vez. Si no te gustó, espero tener la oportunidad de complacerte en otro momento 🤷‍♂. Mientras tanto, siga adelante y use lo que ha aprendido para hacer que sus funciones de pasos sean un poco más fáciles de manejar. Recuerde que no siempre necesita una lambda para resolver su problema con las funciones de pasos.