Esquema de definición del flujo de trabajo

Descripción general

Una definición de flujo de trabajo describe el proceso automatizado a ejecutar. Las definiciones de flujo de trabajo utilizan YAML con una convención de nomenclatura camelCase. Cada flujo de trabajo consta de:

• Propiedades del esquema: información básica (nombre, descripción y entradas)
• Pasos: La secuencia de acciones a realizar
• Expresiones: Valores dinámicos utilizando la sintaxis jq
• Secretos: Referencias de credenciales seguras

Estructura del esquema

Propiedades del esquema

La siguiente tabla describe las propiedades de nivel superior de una definición de flujo de trabajo.

workflowInputs (Opcional)

El siguiente ejemplo muestra una definición de workflowInputs:

workflowInputs:
  myInput1:
    type: String
  myInput2:
    type: Number
    defaultValue: 42

Cada entrada admite los siguientes campos:

• workflowInputs.<inputName> (Requerido)

  • Tipo: Cadena (conforme al patrón seguro para expresiones)
  • Longitud mínima: 1
  • Longitud máxima: 50
  • Descripción: El nombre de la entrada del flujo de trabajo.

• workflowInputs.<inputName>.type (Requerido)

  • Tipo: Enumeración (Boolean, List, Map, String, Int, Float, Enum)
  • Descripción: El tipo de datos de la entrada del flujo de trabajo.

• workflowInputs.<inputName>.defaultValue (Opcional)

  • Tipo: cualquier valor que se ajuste a type.
  • Descripción: El valor predeterminado para la entrada del flujo de trabajo.

• workflowInputs.<inputName>.required (Opcional)

  • Tipo: Booleano (True, False).
  • Descripción: el valor predeterminado para este campo es true.

• workflowInputs.<inputName>.enumValues (Opcional)

  • Tipo: Lista (String).
  • Descripción: este campo tiene como valor predeterminado una lista vacía {}. Es obligatorio cuando el tipo workflowInputs es Enum.

• workflowInputs.<inputName>.validations (Opcional)

  • Tipo: matriz de mapas.
  • Descripción: las validaciones a ejecutar en las entradas del flujo de trabajo que proporciona el usuario. Las propiedades enumeradas aquí se aplican a todos los tipos de validación. Los tipos de validación específicos admiten propiedades adicionales. Consulte Tipos de validación para obtener más detalles.

• validations[*].type (Requerido)

  • Tipo: Cadena
  • Descripción: el tipo de validación que indica qué validación se produce en este campo. Consulte Tipos de validación para obtener más información sobre cada tipo de validación.

• validations[*].errorMessage (Requerido)

  • Tipo: Cadena
  • Descripción: el mensaje de error que se mostrará cuando falle una validación en particular.

Ejemplo de YAML para validaciones

name: calendar_demo

workflowInputs:
  timezone:
    type: String
    defaultValue: 'America/Los_Angeles'
    validations:
      - type: regex
        errorMessage: "The provided timezone is not correct"
        pattern: "^[A-Za-z]+\/[A-Za-z_]+(?:\/[A-Za-z_]+)?$"

      - type: maxLength
        errorMessage: "Timezone length should be less than 100"
        length: 100
      
  accountId:
    type: Int
    validations:
      - type: minIntValue
        errorMessage: "Account id should be greater than 100000"
        minValue: 100000
      - type: maxIntValue
        errorMessage: "Account id should be less than 9999999"
        maxValue: 9999999

steps:
  - name: getCurrentTime
    type: action
    action: http.get
    version: 1
    inputs:
      url: 'https://worldtimeapi.org/api/timezone/${{ .workflowInputs.timezone }}'
      selectors:
        - name: timezone
          expression: '.responseBody | fromjson.abbreviation'
        - name: datetime
          expression: '.responseBody | fromjson.datetime'

workflowConstants (Opcional)

Las constantes de flujo de trabajo proporcionan acceso a metadatos en tiempo de ejecución sobre el flujo de trabajo que se está ejecutando actualmente. Estas constantes están disponibles automáticamente en todas las definiciones de flujo de trabajo y puede referenciarlas mediante la sintaxis de expresión ${{ .workflowConstants.<constantName> }}.

Constantes disponibles

Las siguientes constantes están disponibles en todas las definiciones de flujo de trabajo.

Ejemplos de uso

name: testWorkflowConstantsWithJQ
 description: Test workflow to demonstrate workflowConstants usage
  steps:
    - name: logWithConstants
      type: action
      action: newrelic.ingest.sendLogs
      version: '1'
      inputs:
        logs:
          - message: Workflow Execution Started
            attributes:
              accountId: ${{ .workflowConstants.accountId }}
              orgId: ${{ .workflowConstants.organizationId }}
              version: ${{ .workflowConstants.definitionVersion }}
              scopeType: ${{ .workflowConstants.definitionScopeType }}
              startedAt: ${{ .workflowConstants.startedAt }}
              runId: ${{ .workflowConstants.runId }}
              workflowDefinitionName: ${{ .workflowConstants.definitionName }}

Use constantes de flujo de trabajo con expresiones jq para transformar valores:

steps:
    - name: transformConstants
      type: action
      action: newrelic.ingest.sendLogs
      version: '1'
      inputs:
        logs:
          - message: Testing JQ transformations on workflowConstants
            attributes:
              # Convert epoch milliseconds to ISO8601 format
              startedAtISO8601: ${{ (.workflowConstants.startedAt / 1000) | todateiso8601 }}
              # Convert to uppercase
              runIdUppercase: ${{ .workflowConstants.runId | ascii_upcase }}
              # Get string length
              definitionNameLength: ${{ .workflowConstants.definitionName | length }}
              # Convert to string
              accountIdString: ${{ .workflowConstants.accountId | tostring }}
              # Combine multiple constants
              combinedMetadata: ${{ .workflowConstants.definitionName + "-" + .workflowConstants.runId }}

El siguiente ejemplo convierte un timestamp utilizando la acción DateTime:

steps:
    - name: convertStartedAtFromEpoch
      type: action
      action: utils.datetime.fromEpoch
      version: 1
      inputs:
        timestamp: ${{ .workflowConstants.startedAt }}
        timezoneId: UTC
        pattern: "yyyy-MM-dd HH:mm:ss"
        timestampUnit: MILLISECONDS
        selectors:
          - name: datetime
            expression: ".datetime"
          - name: timezone
            expression: ".timezone"

Restricciones y comportamiento

Pasos

La siguiente tabla describe la propiedad steps de una definición de flujo de trabajo.

Propiedades comunes de los pasos

Las siguientes propiedades se aplican a todos los tipos de pasos.

Tipos de pasos

Acción

Un paso que ejecuta una acción específica. Consulte el Catálogo de acciones para ver las opciones disponibles.

• steps[*].action (Requerido)

  • Tipo: Cadena
  • Descripción: el nombre completo de la función de acción a ejecutar. Debe seguir esta convención: <company domain>.<category of work>.<action name in camelCase>

Los siguientes son ejemplos de nombres de acción válidos:

• Acción que usa los servicios de New Relic (por ejemplo, a través de NerdGraph): newrelic.dashboards.getDashboard

• Acción mediante Slack: slack.chat.postMessage

• steps[*].version (Requerido)

  • Tipo: Cadena
  • Descripción: La versión de la función de acción que se va a ejecutar.

• steps[*].inputs (Opcional)

  • Tipo: Mapa de valores (incluye expresiones)

  • Descripción:

    • Las entradas que se pasarán a la función de acción. Cada acción define las entradas específicas que acepta.
    • Puede usar expresiones. Consulte la sección de cadenas de expresiones para obtener más detalles.

  Importante

  No pase datos confidenciales (clave de API, secretos, PII, PHI o cualquier dato de identificación personal) como argumentos.

• steps[*].inputs.selectors (Opcional)

  • Tipo: lista de mapas en formato name con expression.

  • Descripción:

    • La entrada selectors le permite redefinir la salida para devolver solo los elementos especificados.
    • Puede usar expresiones. Consulte la sección Cadenas de expresión para obtener más detalles.

  • El siguiente ejemplo recupera timezone y datetime de la salida de la acción http.get.

name: calendar_demo

  workflowInputs:
    timezone:
      type: String
      defaultValue: 'America/Los_Angeles'
    accountId:
      type: Int

  steps:
    - name: getCurrentTime
      type: action
      action: http.get
      version: 1
      inputs:
        url: 'https://worldtimeapi.org/api/timezone/${{ .workflowInputs.timezone }}'
        selectors:
          - name: timezone
            expression: '.responseBody | fromjson.abbreviation'
          - name: datetime
            expression: '.responseBody | fromjson.datetime'

Bucle

Un bucle itera sobre colecciones (listas, mapas, matriz) y crea automáticamente las variables index y element para cada iteración. Puede acceder a estas variables de bucle solo dentro del bucle usando ${{ .steps.<loopStepName>.loop.element }} o ${{ .steps.<loopStepName>.loop.index }}.

El paso de bucle admite las siguientes propiedades:

• steps[*].for (Requerido)

  • Tipo: Constante
  • Descripción: señala el inicio de un bucle.

• steps[*].in (Requerido)

  • Tipo: Cadena (expresión)
  • Descripción: expresión que se evalúa como una colección de elementos.

• steps[*].steps (Requerido)

  • Descripción: pasos a ejecutar en cada iteración. Cada paso puede ser de cualquier tipo de paso, incluidos los bucles anidados.

Ejemplo: Bucle básico

name: myRangeIterator
steps:
  - name: looper
    type: loop
    for:
      # iterate over [1..5]
      in: ${{ [range(1; 6)] }}
      steps:
        - name: logProgress
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Element: ${{ .steps.looper.loop.element | tostring }}" # not exist outside of this loop
                attributes:
                  # ranges over [0..4]
                  index: ${{ .steps.looper.loop.index }}

Ejemplo: usar un bucle for con una expresión jq

name: process-orders
description: Process and validate orders

workflowInputs:
  validStatuses:
    type: List
    defaultValue: ["pending", "confirmed", "shipped"]

steps:
  - name: getOrders
    type: assign
    inputs:
      orders:
        - { id: "001", status: "pending", amount: 100 }
        - { id: "002", status: "invalid", amount: 50 }
        - { id: "003", status: "shipped", amount: 200 }

  - name: processOrders
    type: loop
    for:
      in: ${{ .steps.getOrders.outputs.orders }}
      steps:
        - name: validateStatus
          type: switch
          switch:
            - condition: ${{ .steps.processOrders.loop.element.status as $status | .workflowInputs.validStatuses | index($status) != null }}
              next: validOrder
          next: invalidOrder

        - name: invalidOrder
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Invalid order status"
                attributes:
                  orderId: ${{ .steps.processOrders.loop.element.id }}
                  status: ${{ .steps.processOrders.loop.element.status }}

        - name: validOrder
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Processing valid order"
                attributes:
                  orderId: ${{ .steps.processOrders.loop.element.id }}
                  status: ${{ .steps.processOrders.loop.element.status }}
                  amount: ${{ .steps.processOrders.loop.element.amount }}

Ejemplo: Bucle en mapa

name: myMapIterator
steps:
  - name: looper
    type: loop
    for:
      in: '${{ [ {"key1": "val1"}, {"key2": "val2"} ] }}'
      steps:
        - name: logProgress
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Element: ${{ .steps.looper.loop.element | tostring }}"

Ejemplo: Saltar dentro de un bucle

Puede saltar entre pasos dentro del mismo bucle. No puede saltar dentro o fuera de bucles, entre diferentes bucles o a bucles padre/hijo.

name: myLoopJump
steps:
  - name: fistStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "the first step"
  - name: loopStep
    type: loop
    for:
      in: ${{ [range(1; 6)] }}
      steps:
        - name: loopStep1
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop first step"
          next: loopStep3                         # Okay within the loop
        - name: loopStep2
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop second step, never executed"
        - name: loopStep3
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop third step"
          next: fistStep                        # Not okay, first step is not in the loop context

Ejemplo: Break y continue

Utilice next: break o next: continue para controlar el flujo del bucle. Estas son palabras clave reservadas dentro de los bucles. Fuera de los bucles, saltan al final del flujo de trabajo. Dentro de un bucle, end se comporta como break.

name: myLoopContinueBreak
steps:
  - name: fistStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "the first step"
  - name: loopStep
    type: loop
    for:
      in: ${{ [range(1; 6)] }}
      steps:
        - name: loopStep1
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop first step"
          # continue with next iteration without executing loopStep2
          next: continue
        - name: loopStep2
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop second step, never executed"

  - name: loopAgain
    type: loop
    for:
      in: ${{ [range(1; 6)] }}
      steps:
        - name: loopAgainStep1
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop again first step"
          # stop iterating and continue with next step after the loop
          next: break
        - name: loopAgainStep2
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop again second step, never executed"

  - name: lastStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "the last step"

Cambiar

Un paso switch comprueba varios condicionales y toma la primera rama que se evalúa como verdadera. Puede contener cualquier número de elementos condition en una lista, comprobándolos en orden y procesando el primero que se evalúa como verdadero. Si ninguno se evalúa como verdadero, ejecuta su paso next según lo definido en steps[*].next.

• steps[*].switch (Requerido)

  • Tipo: matriz
  • Descripción: Una matriz de casos switch, que especifica la lista ordenada de condiciones a evaluar.

• steps[*].switch[*].condition (Requerido)

  • Tipo: Cadena (expresión)
  • Descripción: el estado de la caja del interruptor. Si la condición se evalúa como verdadera, el flujo de trabajo ejecuta el paso next del caso.
  • Consulte la sección Cadenas de expresión para obtener más detalles.

• steps[*].switch[*].next (Requerido)

  • Tipo: Cadena (conforme al patrón seguro para expresiones)
  • Descripción: el nombre del paso a ejecutar si la condición del caso se evalúa como verdadera. La palabra clave especial end indica que este es el último paso en ejecutar.

- name: hasCompleted
    type: switch
    switch:
      - condition: ${{ .steps.waitForCompletion.outputs.automationExecutionStatus == "Failed" }}
        next: displayError
      - condition: ${{ .steps.waitForCompletion.outputs.automationExecutionStatus == "Success" }}
        next: displaySuccess
    next: displayUnexpected

Esperar

Un paso que pausa la ejecución del flujo de trabajo durante una cantidad específica de segundos antes de continuar.

El paso de espera también puede escuchar una o más señales. Cada señal debe definir un paso siguiente correspondiente. Si el paso de espera recibe una señal, procesa la primera que recibe y ejecuta su paso siguiente definido. Si no se recibe ninguna señal, el flujo de trabajo continúa con el siguiente paso después de que finaliza el período de espera.

El paso de espera almacena el valor de la señal recibida en su salida, lo que lo hace disponible para su uso en pasos posteriores.

El siguiente ejemplo muestra un paso de espera con un controlador de señales:

name: waitSignalExample
steps:
  - name: waitStep
    type: wait
    seconds: 300
    signals: [{name: 'mySignal', next: 'mySignalHandler'}]
  - name: endStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "didn't get signal"
    next: end
  - name: mySignalHandler
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        # log entry "got signal with data bar" when using signalInputs [{"foo": "bar"}]
        - message: "got signal with data ${{ .steps.waitStep.outputs.signalInputs.foo }}"

El paso de espera acepta las siguientes propiedades:

• steps[*].seconds (Requerido)

  • Tipo: Número
  • Descripción: Número de segundos que se deben esperar antes de continuar con la ejecución del flujo de trabajo.

• steps[*].signals

  • Tipo: matriz
  • Descripción: las señales que desvían el flujo del programa cuando el paso de espera las recibe.

• steps[*].signals[*].name

  • Tipo: Cadena
  • Descripción: El nombre de la señal que se debe escuchar.

• steps[*].signals[*].next

  • Tipo: Cadena
  • Descripción: el paso a ejecutar si se recibe la señal especificada.

Asignar

Un paso que define variables para su uso en todo el flujo de trabajo. Este paso asigna valores a variables que los pasos posteriores pueden referenciar. Este tipo de paso le permite definir todas las variables en un solo lugar para su uso en todo el flujo de trabajo.

El siguiente flujo de trabajo de ejemplo muestra cómo usar el paso de asignación:

name: sampleWorkflowWithAssign

workflowInputs:
  initialValue:
    type: String
    defaultValue: "abcd"
  anotherValue:
    type: Int
    defaultValue: 1234

steps:
  - name: variableInitialization
    type: assign
    inputs:
      stringVar: "${{ .workflowInputs.initialValue }}"
      intVar: "${{ .workflowInputs.anotherValue }}"
      concatenationVar: "${{ .workflowInputs.initialValue }} - concatenated"
      booleanVar: true
      mapVar:
        key1: "value1"
        key2: "${{ .workflowInputs.initialValue }}"
      listVar:
        - "listItem1"
        - "${{ .workflowInputs.initialValue }}"
        - "${{ .workflowInputs.anotherValue }}"

  - name: logVariables
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "stringVar: ${{ .steps.variableInitialization.outputs.stringVar }}"
        - message: "intVar: ${{ .steps.variableInitialization.outputs.intVar }}"
        - message: "concatenationVar: ${{ .steps.variableInitialization.outputs.concatenationVar }}"
        - message: "booleanVar: ${{ .steps.variableInitialization.outputs.booleanVar }}"
        - message: "mapVar: ${{ .steps.variableInitialization.outputs.mapVar | tojson }}"
        - message: "listVar: ${{ .steps.variableInitialization.outputs.listVar | tojson }}"

El paso de asignación acepta la siguiente entrada:

• steps[*].inputs (Requerido)

  • Tipo: Mapa de valores (incluye expresiones)
  • Descripción:
    • Las entradas son un mapa de nombres de variables y sus valores asignados. Cuando asigna referencias secretas a variables, estas permanecen como referencias y el sistema no las convierte a sus valores reales. Sin embargo, el flujo de trabajo evalúa y convierte otras expresiones (como las entradas del flujo de trabajo) a sus valores reales.
  • Tipos de entrada permitidos: Integer, Double, Boolean, String, Array, Map

Estado

Un paso que almacena pares de valor principal en el estado compartido del flujo de trabajo. Los valores persisten durante la ejecución del flujo de trabajo. Los pasos posteriores pueden acceder a estos valores utilizando el accesor .workflowState. Si varios pasos de estado establecen la misma clave, cada valor posterior sobrescribe al anterior.

El paso de estado acepta la siguiente entrada:

• steps[*].inputs (Requerido)

  • Tipo: mapa de pares de valor principal

  • Descripción: los pares de valor principal para almacenar en el estado del flujo de trabajo.

    • Las claves deben ser identificadores válidos.
    • Los valores pueden ser de cualquier tipo — String, Integer, Boolean, List o Map (incluidas las estructuras anidadas). Los valores incluyen expresiones. El tiempo de ejecución no resuelve las referencias secretas —las almacena tal cual.

Para acceder a los valores de estado en las expresiones, use .workflowState.<keyName> en cualquier paso que siga al paso de estado:

${{ .workflowState.myKey }}

El siguiente ejemplo muestra un paso de estado que almacena y recupera valores:

name: workflow-state-example
description: Store and retrieve state across steps
steps:
  - name: storeInitialData
    type: state
    inputs:
      count: 1
      foo: "bar"
  - name: updateCount
    type: state
    inputs:
      color: "green"
      count: 2
  - name: logState
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "foo=${{ .workflowState.foo }}, color=${{ .workflowState.color }}, count=${{ .workflowState.count }}"

El paso de estado tiene las siguientes restricciones:

• Patrón de nombre de clave: ^[a-zA-Z_][a-zA-Z0-9_]*$
• Longitud máxima del nombre de la clave: 255 caracteres
• Claves máximas por paso de estado: 10
• Claves de estado totales máximas por ejecución de flujo de trabajo: 100
• Longitud máxima del valor de estado: 1000 caracteres

Error

Un paso que finaliza el flujo de trabajo y reporta un error con un mensaje personalizado. Si hay un condition presente, el flujo de trabajo lo evalúa primero y se detiene solo cuando la condición es true. Si no proporciona un message, el paso utiliza el mensaje predeterminado failed as requested from step: failureStep.

El siguiente ejemplo muestra un paso de error con una condición:

name: sendLogWorkflow
description: 'This workflow send Logs to newrelic'
steps:
  - name: sendLog
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: Sending Logs to NewRelic
  - name: error_4
    type: error
    condition: ${{.steps.sendLog.outputs.success == false}}
    message: Terminating Workflow as sendLog failed.
    next: end

La siguiente tabla describe las entradas aceptadas por el paso de error.

Tipos de validación

Los siguientes tipos de validación están disponibles para workflowInputs.

Expresiones y secretos

Cadenas de expresión

Varias propiedades aceptan valores de cadena con expresiones integradas que el flujo de trabajo evalúa durante la ejecución, lo que permite valores dinámicos en las definiciones de flujo de trabajo.

Las cadenas de expresión pueden contener una o más expresiones, cada una encerrada entre llaves dobles. jq evalúa el contenido dentro de las llaves, lo que le permite acceder, filtrar y transformar valores.

El siguiente ejemplo obtiene la longitud de una cadena de entrada de flujo de trabajo:

${{ .workflowInputs.myString | length }}

Para validar y probar sus expresiones, emplee JQ Playground.

Propiedades de expresión

Puede acceder a estas propiedades con expresiones. Viven en un objeto scope, por lo que las expresiones deben comenzar con un punto (.) para acceder a esas propiedades del objeto de alcance.

Las propiedades disponibles son:

• workflowInputs — Objeto que contiene las entradas pasadas al flujo de trabajo al inicio.

  Ejemplo: ${{ .workflowInputs.myInput }}

• workflowState — Objeto que contiene pares de valor principal almacenados por los pasos state durante la ejecución actual del flujo de trabajo.

  Ejemplos (clave plana, propiedad anidada, índice de matriz): ${{ .workflowState.myKey }} · ${{ .workflowState.myMap.nestedProperty }} · ${{ .workflowState.myList[0] }}

• steps — Objeto que contiene una propiedad para cada paso en el flujo de trabajo.

  • steps.<stepName> — Objeto que contiene propiedades para un paso específico.
  • steps.<stepName>.outputs — Objeto que contiene propiedades de resultado, específicas del paso o acción.

  Ejemplo: ${{ .steps.myStep.outputs.myResult }}

Resultados de la evaluación de la expresión

Una sola expresión jq puede evaluar cualquier tipo JSON. Sin embargo, el resultado final de una cadena de expresión depende de si la cadena contiene solo la expresión o contenido adicional.

Expresión única (conserva el tipo JSON)

Si una cadena de expresión consta de una sola expresión sin contenido circundante, se evalúa como el resultado de la expresión jq mientras mantiene su tipo JSON original. Por ejemplo, ${{ .workflowInputs.myArray }} se evalúa como una matriz. Esto conserva el tipo de estructuras de datos complejas al pasarlas entre pasos.

Múltiples expresiones o contenido mixto (se convierte en cadena)

Si una cadena de expresión contiene contenido que no sea una sola expresión, se evalúa como un resultado de cadena. Esto ocurre cuando una expresión tiene contenido antes o después de ella, o cuando la cadena tiene múltiples expresiones dentro de ella. jq evalúa cada expresión y la convierte en una representación de cadena.

Los siguientes ejemplos usan myArray con el valor [1, 2, 3].

Patrón seguro de expresión

Las propiedades que use en las expresiones deben cumplir con: ^[A-Za-z_][A-Za-z0-9_]*$

Referencias secretas

Utilice valores secretos en las acciones proporcionando cadenas de referencia que especifiquen el nombre de un secreto para buscar en el Secrets Service. Para hacer referencia a un secreto en una definición del flujo de trabajo, utilice la sintaxis:

• ${{ :secrets:<SECRET_NAME> }} para un secreto que no está en un namespace
• ${{ :secrets:<NAMESPACE>:<SECRET_NAME> }} para un secreto en un namespace
• ${{ :secrets:<SCOPE>:<NAMESPACE>:<SECRET_NAME> }} para un secreto en un alcance y namespace

SCOPE acepta ACCOUNT o ORGANIZATION.

Una cadena de expresión puede contener expresiones jq, referencias secretas o ambas.

Los siguientes son ejemplos de referencias secretas usadas en acciones:

steps:
  - name: mySecretStep
    type: action
    action: newrelic.instrumentation.log
    inputs:
      message: My message
      licenseKey: ${{ :secrets:<SECRET_NAME> }}

steps:
    - name: bearer_auth
      type: action
      action: utils.http.post
      inputs:
        headers:
          Authorization: Bearer ${{ :secrets:<SECRET_NAME> }}

Ejemplo completo

Demostración del calendario

Este ejemplo completo de flujo de trabajo demuestra múltiples características de flujo de trabajo, incluidas constantes de flujo de trabajo, selectores, pasos de espera, consulta NRDB e instrucciones switch.

name: calendar_demo

steps:
  - name: getUserCreated
    type: action
    action: newrelic.nerdgraph.execute
    version: 1
    inputs:
      graphql: |
        {
          actor {
            user {
              id
              createdAt
              timeZoneName
            }
          }
        }
      selectors:
        - name: id
          expression: ".data.actor.user.id"
        - name: createdAt
          expression: ".data.actor.user.createdAt"
        - name: timeZoneName
          expression: ".data.actor.user.timeZoneName"

  - name: getCreatedTime
    type: action
    action: utils.datetime.fromEpoch
    version: 1
    inputs:
      timestamp: ${{ .steps.getUserCreated.outputs.createdAt }}
      pattern: "yyyy-MM-dd HH:mm:ss"
      timezoneId: ${{ .steps.getUserCreated.outputs.timeZoneName }}
      selectors:
        - name: datetime
          expression: ".datetime"
        - name: abbreviation
          expression: ".timezone.abbreviation"

  - name: logTime
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "Demo ${{ .workflowConstants.runId }} userId ${{ .steps.getUserCreated.outputs.id }} created at ${{ .steps.getCreatedTime.outputs.datetime }} ${{ .steps.getCreatedTime.outputs.abbreviation }}"

  - name: wait
    type: wait
    seconds: 1

  - name: queryForLog
    type: action
    action: newrelic.nrdb.query
    version: 1
    inputs:
      query: "FROM Log SELECT message, timestamp SINCE 5 minute ago WHERE message LIKE 'Demo ${{ .workflowConstants.runId }} userId ${{ .steps.getUserCreated.outputs.id }} created at%'"

  - name: checkQuery
    type: switch
    switch:
      - condition: ${{ .steps.queryForLog.outputs.results | length > 0 }}
        next: postResultsMessage

  - name: postWaitingMessage
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "Waiting for log message..."
    next: wait

  - name: postResultsMessage
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "Found log message! ${{ .steps.queryForLog.outputs.results[0].message }}"

Temas relacionados