schéma de définition du workflow

Schéma

Les définitions de workflow sont écrites en YAML. Les clés utilisent une convention de nommage camelCase.

Propriétés du schéma

workflowInputs

Exemple:

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

• workflowInputs.<inputName> (Obligatoire)

  • 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 (Obligatoire)

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

• workflowInputs.<inputName>.defaultValue (Facultatif)

  • Type: Tout ; doit être 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: La valeur par défaut de ce champ est une liste vide {}. Ceci est requis lorsque le type workflowInput est Enum.

• workflowInputs.<inputName>.validations (Facultatif)

  • Type: Tableau de cartes.
  • Description: Les validations à effectuer sur les entrées de workflow fournies par l'utilisateur. Ceci est un champ facultatif. Les propriétés décrites ici sont présentes dans tous les types de validation. Les types de validation spécifiques prennent en charge des propriétés supplémentaires, comme indiqué dans la section Types de validation.

• validations[*].type (Obligatoire)

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

• validations[*].errorMessage (Obligatoire)

  • Type: Chaîne de caractères
  • Description: Le message d'erreur que l'utilisateur souhaite obtenir 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'

Étapes

Propriétés d'étape courantes

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

  • Type: Chaîne de caractères
  • Description: Nom complet de la fonction d'action à exécuter. Elle devrait respecter la convention suivante : <company domain>.<category of work>.<action name in camelCase>

Exemple:

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

• Action via Slack : slack.chat.postMessage

• steps[*].version (Obligatoire)

  • 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 données d'entrée à transmettre à la fonction d'action. Les entrées spécifiques acceptées sont définies par chaque action.
    • Les entrées peuvent utiliser des expressions. Consultez la section Chaînes d'expressions pour plus de détails.

  Important

  Aucune donnée sensible (ni clé API ni secret, ni PII, ni PHI, ni aucune donnée permettant d'identifier une personne) ne doit être transmise 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.
    • Les expressions peuvent être utilisées. Consultez la section Chaînes d'expression pour plus de détails.

Exemple:

• Dans l'exemple donné, nous obtenons timezone et datetime comme réponse 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 parcourra une collection donnée définie par in et créera des variables de boucle index et element pour chacune de ses itérations. Ces variables de boucle ne sont accessibles à l'intérieur de la boucle qu'avec l'expression ${{ .steps.<loopStepName>.loop.element }} ou ${{ .steps.<loopStepName>.loop.index }

Pour plus de détails :

• steps[*].for (Obligatoire)

  • Type: Constant
  • Description: Signal de démarrage d'une boucle

• steps[*].in (Obligatoire)

  • Type: chaîne (expression)

  • Description: Une expression qui doit être évaluée en une collection d'éléments.

  • steps[*].steps (Facultatif)

    • Description: Étapes à exécuter à chaque itération de la boucle. Voir la définition des étapes ci-dessus.

Exemple:

name: myWorkflow
  steps:
    - name: loopStep
      type: loop
      for:
        in: "${{ [range(1; 5)] }}"
        steps:
          - name: step1
            type: action
            action: newrelic.ingest.sendLogs
            version: 1
            inputs:
              logs:
                - message: "Loop: ${{ .steps.loopStep.loop.element }}"

Switch

• Une étape qui vérifie diverses conditions et emprunte la première branche qui s'évalue à vrai.

• Un commutateur peut contenir un nombre quelconque d'éléments condition dans une liste. Il vérifiera les conditions dans l'ordre et traitera la première qui s'évalue à vrai. Si aucune ne s'évalue à vrai, il exécutera son étape next comme défini dans steps[*].next.

  • steps[*].switch (Obligatoire)

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

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

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

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

    • 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 peut être utilisé pour indiquer que cette étape doit être la dernière à s'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

  Copier

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 avoir une étape suivante correspondante définie dans une liste. Si un signal est reçu pendant la période d'attente, le premier signal reçu sera traité et le workflow exécutera son étape suivante définie. Si aucun signal n'est reçu, le workflow continue normalement une fois la période d'attente terminée.

La valeur reçue d'un signal est stockée dans la sortie de l'étape d'attente et peut être utilisée dans les étapes suivantes pour la logique ou le traitement.

Exemple:

name: waitSignalExample
  workflowInputs:
  steps:
    - name: waitStep
      type: wait
      seconds: 300
      signals: [{name: 'mySignalName', next: 'firstStep'}]
    - name: endStep
      type: action
      action: newrelic.instrumentation.log
      version: 1
      inputs:
        message: "didn't get signal"
      next: end
    - name: firstStep
      type: action
      action: newrelic.instrumentation.log
      version: 1
      inputs:
        message: ${{ .steps.waitStep.outputs.signalInputs.myString }}

• steps[*].seconds (Obligatoire)

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

• steps[*].signals

  • Type: Tableau
  • Description: Les signaux qui, lorsqu'ils sont reçus, modifient le flux du programme.

• 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: É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 qui peuvent être référencées dans les étapes suivantes. En définissant toutes les variables au même endroit, ce type d'étape rend les workflows plus lisibles et optimisés.

Exemple de workflow:

name: sampleWorkflowWithAssign
  description: WorkflowAssignDemo

  workflowInputs:
    initialValue:
      type: String
    anotherValue:
      type: Int

  steps:
    - name: runAction
      type: action
      action: internal.http.post
      version: 1
      inputs:
        url: 'http://localhost:8505/tasks/gc' # temporal-activity-worker-java service port
        selectors:
          - name: statusCode
            expression: '.statusCode'
          - name: responseBody
            expression: '.responseBody'
    - 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 }}"
        statusCode: ${{ .steps.runAction.outputs.statusCode }}

    - name: wait
      type: wait
      seconds: 2

    - 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 }}"
          - message: "statusCode: ${{ .steps.variableInitialization.outputs.statusCode }}"

• steps[*].inputs (Obligatoire)

  • 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 des références secrètes sont affectées à des variables, elles restent des références secrètes et ne sont pas converties en leurs valeurs réelles. Cependant, d'autres expressions (telles que les entrées de workflow) sont évaluées et converties en leurs valeurs réelles.
  • Types d'entrée autorisés : Integer, Double, Boolean, String, Array, Map

Types de validation

Types partagés

chaînes d'expression

Plusieurs propriétés acceptent des valeurs de chaîne avec des expressions intégrées qui sont évaluées lors de l'exécution du workflow, 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. Le contenu entre les accolades est évalué à l'aide de jq, qui offre de puissantes capacités pour accéder aux valeurs et les utiliser.

Exemple:

Obtenir 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

Un certain nombre de propriétés sont accessibles avec des expressions. Ces propriétés 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 }}

• 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 tableau. Ceci est utile pour passer des structures de données complexes dans un workflow.

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. Chaque expression dans la chaîne est évaluée et convertie en une représentation de chaîne.

Exemple:

Supposons que myArray ait une valeur de [1, 2, 3].

Modèle sécurisé d'expression

Les propriétés qui peuvent être utilisées dans les expressions doivent être conformes à : ^[A-Za-z_][A-Za-z0-9_]*$

Références secrètes

Les valeurs secrètes peuvent être utilisées dans les actions via 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 la portée et l'espace de noms. scope n'accepte que ACCOUNT ou ORGANIZATION pour le moment.

Une chaîne d'expression peut contenir un mélange de références secrètes et d'expressions JQ and/or plusieurs références secrètes.

Exemples:

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

Exemples

Démo de calendrier

Un exemple complet de workflow qui démontre plusieurs fonctionnalités de workflow, notamment les entrées de workflow, les actions HTTP, les sélecteurs, les étapes d'attente, les requêtes NRQL, les instructions switch et les notifications Slack.

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'

    - name: logTime
      type: action
      action: newrelic.instrumentation.log
      version: 1
      inputs:
        message: 'DEMO: In the ${{ .steps.getCurrentTime.outputs.timezone }} timezone, the current time is ${{ .steps.getCurrentTime.outputs.datetime }}'
        licenseKey: ${{ :secrets:STAGING_NEW_RELIC_LICENSE_KEY }}

    - name: wait
      type: wait
      seconds: 1

    - name: queryForLog
      type: action
      action: newrelic.nrql.query
      version: 1
      inputs:
        accountIds: ['${{ .workflowInputs.accountId }}']
        query: FROM Log SELECT * WHERE message LIKE 'DEMO:%${{ .steps.getCurrentTime.outputs.datetime }}'

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

    - name: postWaitingMessage
      type: action
      action: slack.chat.postMessage
      version: 1
      inputs:
        channel: test-channel-workflow
        text: Waiting for log message...
        token: ${{ :secrets:dn_staging_slack_token }}
      next: wait

    - name: postResultsMessage
      type: action
      action: slack.chat.postMessage
      version: 1
      inputs:
        channel: test-channel-workflow
        text: 'Found log message! ${{ .steps.queryForLog.outputs.results[0].message }}'
        token: ${{ :secrets:dn_staging_slack_token }}