schéma de définition du workflow

Présentation

Une définition de workflow décrit le processus automatisé à exécuter. Les définitions de workflow utilisent YAML avec une convention de nommage camelCase. Chaque workflow se compose de :

• Propriétés du schéma: informations de base (nom, description et entrées)
• Étapes: La séquence d'actions à effectuer
• Expressions: valeurs dynamiques utilisant la syntaxe jq
• Secrets: Références d'informations d'identification sécurisées

Structure du schéma

Propriétés du schéma

Le tableau suivant décrit les propriétés de niveau supérieur d’une définition de workflow.

workflowInputs (Facultatif)

L'exemple suivant montre une définition workflowInputs :

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

Chaque entrée prend en charge les champs suivants :

• workflowInputs.<inputName> (Requis)

  • Type: Chaîne (conforme au modèle sécurisé pour les expressions)
  • Longueur minimale: 1
  • Longueur maximale: 50
  • Description: Nom de l'entrée workflow.

• workflowInputs.<inputName>.type (Requis)

  • Type: Enum (Boolean, List, Map, String, Int, Float, Enum)
  • Description: Type de données de l'entrée workflow.

• workflowInputs.<inputName>.defaultValue (Facultatif)

  • Type: toute valeur conforme à type.
  • Description: Valeur par défaut de l'entrée workflow.

• workflowInputs.<inputName>.required (Facultatif)

  • Type: Booléen (True, False).
  • Description: la valeur par défaut de ce champ est true.

• workflowInputs.<inputName>.enumValues (Facultatif)

  • Type: Liste (String).
  • Description: ce champ est défini par défaut sur une liste vide {}. Il est requis lorsque le type workflowInputs est Enum.

• workflowInputs.<inputName>.validations (Facultatif)

  • Type: Tableau de cartes.
  • Description: les validations à exécuter sur les entrées de workflow fournies par l'utilisateur. Les propriétés listées ici s'appliquent à tous les types de validation. Les types de validation spécifiques prennent en charge des propriétés supplémentaires. Consultez la section Types de validation pour plus de détails.

• validations[*].type (Requis)

  • Type: Chaîne de caractères
  • Description: le type de validation indiquant quelle validation a lieu sur ce champ. Consultez Types de validation pour plus d’informations sur chaque type de validation.

• validations[*].errorMessage (Requis)

  • Type: Chaîne de caractères
  • Description: le message d’erreur à afficher lorsqu'une validation particulière échoue.

Exemple YAML pour les validations

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 (Facultatif)

Les constantes de workflow permettent d'accéder aux métadonnées d'exécution du workflow en cours d'exécution. Ces constantes sont automatiquement disponibles dans toutes les définitions de workflow, et vous pouvez les référencer à l'aide de la syntaxe d'expression ${{ .workflowConstants.<constantName> }}.

Constantes disponibles

Les constantes suivantes sont disponibles dans toutes les définitions de workflow.

Exemples d'utilisation

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 }}

Utilisez les constantes de workflow avec des expressions jq pour transformer les valeurs :

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 }}

L’exemple suivant convertit un horodatage à l’aide de l’action 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"

Contraintes et comportement

Étapes

Le tableau suivant décrit la propriété steps d’une définition de workflow.

Propriétés d'étape courantes

Les propriétés suivantes s’appliquent à tous les types d’étapes.

Types d'étapes

Action

Une étape qui exécute une action spécifique. Reportez-vous au Catalogue d'actions pour les options disponibles.

• steps[*].action (Requis)

  • Type: Chaîne de caractères
  • Description: le nom complet de la fonction d’action à exécuter. Il doit suivre cette convention : <company domain>.<category of work>.<action name in camelCase>

Voici des exemples de noms d’action valides :

• Action utilisant les services New Relic (par exemple, via NerdGraph) : newrelic.dashboards.getDashboard

• Action via Slack : slack.chat.postMessage

• steps[*].version (Requis)

  • Type: Chaîne de caractères
  • Description: Version de la fonction d'action à exécuter.

• steps[*].inputs (Facultatif)

  • Type: Carte de valeurs (inclut les expressions)

  • Description:

    • Les entrées à transmettre à la fonction d’action. Chaque action définit les entrées spécifiques qu’elle accepte.
    • Vous pouvez utiliser des expressions. Consultez la section Chaînes d’expressions pour plus de détails.

  Important

  Ne transmettez pas de données sensibles (clés API, secrets, PII, PHI, ou toute donnée personnellement identifiable) en tant qu’arguments.

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

  • Type: liste de cartes sous la forme de name avec expression.

  • Description:

    • L'entrée selectors vous permet de redéfinir la sortie pour ne renvoyer que les éléments spécifiés.
    • Vous pouvez utiliser des expressions. Consultez la section Chaînes d’expression pour plus de détails.

  • L'exemple suivant récupère timezone, et datetime à partir de la sortie de l'action 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'

Boucle

Une boucle itère sur les collections (listes, cartes, éventails) et crée automatiquement les variables index et element pour chaque itération. Vous ne pouvez accéder à ces variables de boucle qu’à l’intérieur de la boucle à l’aide de ${{ .steps.<loopStepName>.loop.element }} ou ${{ .steps.<loopStepName>.loop.index }}.

L’étape de boucle prend en charge les propriétés suivantes :

• steps[*].for (Requis)

  • Type: Constant
  • Description: signale le début d’une boucle.

• steps[*].in (Requis)

  • Type: Chaîne (expression)
  • Description: expression qui s’évalue en une collection d’éléments.

• steps[*].steps (Requis)

  • Description: étapes à exécuter à chaque itération. Chaque étape peut être n’importe quel type d’étape, y compris les boucles imbriquées.

Exemple : boucle de base

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 }}

Exemple : utiliser une boucle for avec une expression 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 }}

Exemple : Boucle sur la carte

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 }}"

Exemple : Sauter dans une boucle

Vous pouvez sauter entre les étapes au sein de la même boucle. Vous ne pouvez pas sauter à l'intérieur, ou à l'extérieur des boucles, entre différentes boucles, ou vers des boucles parent/enfant.

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

Exemple : Interrompre et continuer

Utilisez next: break ou next: continue pour contrôler le flux de la boucle. Ce sont des mots-clés réservés dans les boucles. En dehors des boucles, ils sautent à la fin du workflow. Dans une boucle, end se comporte comme 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"

Switch

Une étape commutateur vérifie diverses conditions et prend la première branche qui s’évalue à vrai. Elle peut contenir un nombre quelconque d’éléments condition dans une liste, en les vérifiant dans l’ordre et en traitant la première qui s’évalue à vrai. Si aucune ne s’évalue à vrai, elle exécute son étape next comme défini dans steps[*].next.

• steps[*].switch (Requis)

  • Type: Tableau
  • Description: Un éventail de cas de commutation, spécifiant la liste ordonnée des conditions à évaluer.

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

  • Type: Chaîne (expression)
  • Description: la condition du cas de commutateur. Si la condition est évaluée à true, le workflow exécute l’étape next du cas.
  • Consultez la section Chaînes d'expression pour plus de détails.

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

  • Type: Chaîne (conforme au modèle sécurisé pour les expressions)
  • Description: le nom de l'étape à exécuter si la condition du cas est évaluée à true. Le mot-clé spécial end indique qu'il s'agit de la dernière étape à exécuter.

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

Attendez

Une étape qui met en pause l'exécution du workflow pendant un nombre spécifié de secondes avant de continuer.

L’étape d’attente peut également écouter un ou plusieurs signaux. Chaque signal doit définir une étape suivante correspondante. Si l’étape d’attente reçoit un signal, elle traite le premier reçu et exécute son étape suivante définie. Si aucun signal n’est reçu, le workflow passe à l’étape suivante une fois la période d’attente terminée.

L’étape d’attente stocke la valeur du signal reçu dans sa sortie, la rendant disponible pour une utilisation dans les étapes ultérieures.

L’exemple suivant montre une étape d’attente avec un gestionnaire de signaux :

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 }}"

L’étape d’attente accepte les propriétés suivantes :

• steps[*].seconds (Requis)

  • Type: Nombre
  • Description: Nombre de secondes à attendre avant de poursuivre l'exécution workflow.

• steps[*].signals

  • Type: Tableau
  • Description: les signaux qui détournent le flux du programme lorsque l’étape d’attente les reçoit.

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

  • Type: Chaîne de caractères
  • Description: Le nom du signal à écouter.

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

  • Type: Chaîne de caractères
  • Description: l'étape à exécuter si le signal spécifié est reçu.

Attribuer

Une étape qui définit les variables à utiliser tout au long du workflow. Cette étape affecte des valeurs aux variables que les étapes suivantes peuvent référencer. Ce type d’étape vous permet de définir toutes les variables à un seul endroit pour les utiliser tout au long du workflow.

L’exemple de workflow suivant montre comment utiliser l’étape assign :

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 }}"

L’étape d’assignation accepte l’entrée suivante :

• steps[*].inputs (Requis)

  • Type: Carte de valeurs (inclut les expressions)
  • Description:
    • Les entrées sont une carte des noms de variables et de leurs valeurs attribuées. Lorsque vous affectez des références secrètes à des variables, elles restent des références, et le système ne les convertit pas en leurs valeurs réelles. Cependant, le workflow évalue, et convertit d'autres expressions (telles que les entrées de workflow) en leurs valeurs réelles.
  • Types d'entrée autorisés : Integer, Double, Boolean, String, Array, Map

État

Une étape qui stocke des paires valeur clé dans l'état partagé du workflow. Les valeurs persistent pendant toute la durée de l'exécution du workflow. Les étapes suivantes peuvent accéder à ces valeurs à l'aide de l'accesseur .workflowState. Si plusieurs étapes d'état définissent la même clé, chaque valeur ultérieure écrase la précédente.

L’étape state accepte l’entrée suivante :

• steps[*].inputs (Requis)

  • Type: mappage de paires valeur clé

  • Description: les paires valeur clé à stocker dans l’état du workflow.

    • Les clés doivent être des identifiants valides.
    • Les valeurs peuvent être de n’importe quel type : String, Integer, Boolean, List ou Map (y compris les structures imbriquées). Les valeurs incluent des expressions. Le runtime ne résout pas les références secrètes : il les stocke telles quelles.

Pour accéder aux valeurs d’état dans les expressions, utilisez .workflowState.<keyName> dans toute étape qui suit l’étape state :

${{ .workflowState.myKey }}

L’exemple suivant montre une étape d’état stockant et récupérant des valeurs :

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 }}"

L’étape d’état a les contraintes suivantes :

• Modèle de nom de clé : ^[a-zA-Z_][a-zA-Z0-9_]*$
• Longueur maximale du nom de clé : 255 caractères
• Nombre maximal de clés par étape d’état : 10
• Nombre maximal total de clés d’état par exécution de workflow : 100
• Longueur maximale de la valeur d'état : 1000 caractères

Erreur

Une étape qui termine le workflow et signale un échec avec un message personnalisé. Si un condition est présent, le workflow l’évalue en premier et ne s’arrête que lorsque la condition est true. Si vous ne fournissez pas de message, l’étape utilise le message par défaut failed as requested from step: failureStep.

L’exemple suivant montre une étape d’erreur avec une condition :

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

Le tableau suivant décrit les entrées acceptées par l’étape error.

Types de validation

Les types de validation suivants sont disponibles pour workflowInputs.

Expressions et secrets

chaînes d'expression

Plusieurs propriétés acceptent des valeurs de chaîne avec des expressions intégrées que le workflow évalue lors de l'exécution, ce qui permet d'obtenir des valeurs dynamiques dans les définitions de workflow.

Les chaînes d’expression peuvent contenir une ou plusieurs expressions, chacune étant placée entre des accolades doubles. jq évalue le contenu entre les accolades, vous permettant d’accéder, de filtrer, et de transformer les valeurs.

L’exemple suivant obtient la longueur d’une chaîne d’entrée de workflow :

${{ .workflowInputs.myString | length }}

Pour valider et tester vos expressions, utilisez le JQ Playground.

propriétés d'expression

Vous pouvez accéder à ces propriétés avec des expressions. Elles se trouvent dans un objet scope, les expressions doivent donc commencer par un point (.) pour accéder à ces propriétés de l’objet scope.

Les propriétés disponibles sont :

• workflowInputs — Objet contenant les entrées passées au workflow au démarrage.

  Exemple: ${{ .workflowInputs.myInput }}

• workflowState — Objet contenant des paires valeur clé stockées par les étapes state pendant l'exécution actuelle du workflow.

  Exemples (clé plate, propriété imbriquée, index d’éventail) : ${{ .workflowState.myKey }} · ${{ .workflowState.myMap.nestedProperty }} · ${{ .workflowState.myList[0] }}

• steps - Objet contenant une propriété pour chaque étape du workflow.

  • steps.<stepName> - Objet contenant des propriétés pour une étape spécifique.
  • steps.<stepName>.outputs — Objet contenant les propriétés de résultat, spécifiques à l'étape, ou à l'action.

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

Résultats de l'évaluation de l'expression

Une seule expression jq peut être évaluée à n'importe quel type JSON. Cependant, le résultat final d'une chaîne d'expression dépend de savoir si la chaîne contient uniquement l'expression ou du contenu supplémentaire.

Expression unique (conserve le type JSON)

Si une chaîne d’expression se compose d’une seule expression sans contenu environnant, elle est évaluée au résultat de l’expression jq tout en conservant son type JSON d’origine. Par exemple, ${{ .workflowInputs.myArray }} est évalué en un éventail. Cela préserve le type des structures de données complexes lors de leur passage entre les étapes.

Expressions multiples ou contenu mixte (convertit en chaîne)

Si une chaîne d’expression contient autre chose qu’une seule expression, elle est évaluée en un résultat de chaîne. Cela se produit lorsqu’une expression contient du contenu avant ou après elle, ou lorsque la chaîne contient plusieurs expressions en son sein. jq évalue chaque expression et la convertit en une représentation sous forme de chaîne.

Les exemples suivants utilisent myArray avec la valeur [1, 2, 3].

Modèle sécurisé d'expression

Les propriétés que vous utilisez dans les expressions doivent être conformes à : ^[A-Za-z_][A-Za-z0-9_]*$

Références secrètes

Utilisez des valeurs secrètes dans les actions en fournissant des chaînes de référence qui spécifient le nom d’un secret à rechercher dans le service de secrets. Pour faire référence à un secret dans une définition workflow, utilisez la syntaxe suivante :

• ${{ :secrets:<SECRET_NAME> }} pour un secret pas dans un namespace
• ${{ :secrets:<NAMESPACE>:<SECRET_NAME> }} pour un secret dans un namespace
• ${{ :secrets:<SCOPE>:<NAMESPACE>:<SECRET_NAME> }} pour un secret dans une portée et un espace de nommage

SCOPE accepte ACCOUNT ou ORGANIZATION.

Une chaîne d’expression peut contenir des expressions jq, des références secrètes, ou les deux.

Voici des exemples de références de secrets utilisées dans les actions :

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> }}

Exemple complet

Démo de calendrier

Cet exemple complet de workflow illustre plusieurs fonctionnalités de workflow, notamment les constantes de workflow, les sélecteurs, les étapes d'attente, les requêtes NRDB, et les instructions 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 }}"

Sujets connexes