Esquema de definição de fluxo de trabalho

Visão geral

Uma definição de fluxo de trabalho descreve o processo automatizado a executar. As definições de fluxo de trabalho usam YAML com uma convenção de nomenclatura camelCase. Cada fluxo de trabalho consiste em:

• Propriedades do esquema: informações básicas (nome, descrição e entradas)
• Etapas: A sequência de ações a serem executadas
• Expressões: Valores dinâmicos usando a sintaxe jq
• Segredos: Referências de credenciais seguras

Estrutura do esquema

Propriedades do esquema

A tabela a seguir descreve as propriedades de nível superior de uma definição de fluxo de trabalho.

workflowInputs (Opcional)

O exemplo a seguir mostra uma definição de workflowInputs:

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

Cada entrada suporta os seguintes campos:

• workflowInputs.<inputName> (Obrigatório)

  • Tipo: String (em conformidade com o padrão de segurança de expressão)
  • Comprimento mínimo: 1
  • Comprimento máximo: 50
  • Descrição: O nome da entrada do fluxo de trabalho.

• workflowInputs.<inputName>.type (Obrigatório)

  • Tipo: Enum (Boolean, List, Map, String, Int, Float, Enum)
  • Descrição: O tipo de dados da entrada do fluxo de trabalho.

• workflowInputs.<inputName>.defaultValue (Opcional)

  • Tipo: qualquer valor em conformidade com type.
  • Descrição: O valor padrão para a entrada do fluxo de trabalho.

• workflowInputs.<inputName>.required (Opcional)

  • Tipo: Booleano (True, False).
  • Descrição: o valor padrão para este campo é true.

• workflowInputs.<inputName>.enumValues (Opcional)

  • Tipo: Lista (String).
  • Descrição: este campo tem como padrão uma lista vazia {}. É obrigatório quando o tipo de workflowInputs é Enum.

• workflowInputs.<inputName>.validations (Opcional)

  • Tipo: matriz de mapas.
  • Descrição: as validações a serem executadas nas entradas do fluxo de trabalho fornecidas pelo usuário. As propriedades listadas aqui se aplicam a todos os tipos de validação. Tipos de validação específicos suportam propriedades adicionais. Consulte Tipos de validação para obter detalhes.

• validations[*].type (Obrigatório)

  • Tipo: String
  • Descrição: o tipo da validação indicando qual validação ocorre neste campo. Consulte Tipos de validação para obter mais informações sobre cada tipo de validação.

• validations[*].errorMessage (Obrigatório)

  • Tipo: String
  • Descrição: a mensagem de erro a ser exibida quando uma validação específica falha.

Exemplo de YAML para validações

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)

As constantes de fluxo de trabalho fornecem acesso a metadados de tempo de execução sobre o fluxo de trabalho atualmente em execução. Essas constantes estão automaticamente disponíveis em todas as definições de fluxo de trabalho e podem ser referenciadas usando a sintaxe de expressão ${{ .workflowConstants.<constantName> }}.

Constantes disponíveis

As seguintes constantes estão disponíveis em todas as definições de fluxo de trabalho.

Exemplos 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 fluxo de trabalho com expressões 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 }}

O exemplo a seguir converte um timestamp usando a ação 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"

Restrições e comportamento

Passos

A tabela a seguir descreve a propriedade steps de uma definição de fluxo de trabalho.

Propriedades comuns dos degraus

As seguintes propriedades se aplicam a todos os tipos de etapa.

Tipos de etapas

Ação

Uma etapa que executa uma ação específica. Consulte o Catálogo de ações para as opções disponíveis.

• steps[*].action (Obrigatório)

  • Tipo: String
  • Descrição: o nome totalmente qualificado da função de ação a ser executada. Deve seguir esta convenção: <company domain>.<category of work>.<action name in camelCase>

A seguir estão exemplos de nomes de ação válidos:

• Ação usando serviços da New Relic (por exemplo, por meio do NerdGraph): newrelic.dashboards.getDashboard

• Ação usando o Slack: slack.chat.postMessage

• steps[*].version (Obrigatório)

  • Tipo: String
  • Descrição: A versão da função de ação a ser executada.

• steps[*].inputs (Opcional)

  • Tipo: Mapa de valores (inclui expressões)

  • Descrição:

    • As entradas a serem passadas para a função de ação. Cada ação define as entradas específicas que aceita.
    • É possível usar expressões. Consulte a seção de strings de expressão para obter detalhes.

  Importante

  Não devem ser passados dados confidenciais (chaves de API, segredos, PII, PHI ou quaisquer dados de identificação pessoal) como argumentos.

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

  • Tipo: lista de mapas no formato name com expression.

  • Descrição:

    • A entrada selectors permite redefinir a saída para retornar apenas os elementos especificados.
    • É possível usar expressões. Consulte a seção Strings de Expressão para obter detalhes.

  • O exemplo a seguir recupera timezone e datetime da saída da ação 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'

Laço

Um loop itera sobre coleções (listas, mapas, matrizes) e cria automaticamente as variáveis index e element para cada iteração. É possível acessar essas variáveis de loop apenas dentro do loop usando ${{ .steps.<loopStepName>.loop.element }} ou ${{ .steps.<loopStepName>.loop.index }}.

A etapa de loop suporta as seguintes propriedades:

• steps[*].for (Obrigatório)

  • Tipo: Constante
  • Descrição: sinaliza o início de um loop.

• steps[*].in (Obrigatório)

  • Tipo: String (expressão)
  • Descrição: expressão que avalia uma coleção de elementos.

• steps[*].steps (Obrigatório)

  • Descrição: etapas a serem executadas em cada iteração. Cada etapa pode ser de qualquer tipo de etapa, incluindo loops aninhados.

Exemplo: Loop 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 }}

Exemplo: use o loop for com a expressão 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 }}

Exemplo: Loop no 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 }}"

Exemplo: Pular dentro de um loop

É permitido pular entre as etapas dentro do mesmo loop. Não é permitido pular para dentro ou para fora de loops, entre loops diferentes ou para loops pai/filho.

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

Exemplo: Interromper e continuar

Use next: break ou next: continue para controlar o fluxo do loop. Estas são palavras-chave reservadas dentro de loops. Fora dos loops, eles saltam para o final do fluxo de trabalho. Dentro de um loop, 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"

Trocar

Uma etapa de switch verifica várias condicionais e segue a primeira ramificação que é avaliada como verdadeira. Pode conter qualquer número de elementos condition em uma lista, verificando-os em ordem e processando o primeiro que for avaliado como verdadeiro. Se nenhum for avaliado como verdadeiro, a etapa next será executada conforme definido em steps[*].next.

• steps[*].switch (Obrigatório)

  • Tipo: matriz
  • Descrição: Uma matriz de casos de alternância, especificando a lista ordenada de condições a serem avaliadas.

• steps[*].switch[*].condition (Obrigatório)

  • Tipo: String (expressão)
  • Descrição: a condição do switch case. Se a condição for avaliada como verdadeira, o fluxo de trabalho executará a etapa next do caso.
  • Consulte a seção Cadeias de expressão para obter detalhes.

• steps[*].switch[*].next (Obrigatório)

  • Tipo: String (em conformidade com o padrão de segurança de expressão)
  • Descrição: o nome da etapa a ser executada se a condição do caso for avaliada como verdadeira. A palavra-chave especial end indica que esta é a última etapa a ser executada.

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

Espere

Uma etapa que pausa a execução do fluxo de trabalho por um número específico de segundos antes de continuar.

A etapa de espera também pode escutar um ou mais sinais. Cada sinal deve definir uma próxima etapa correspondente. Se a etapa de espera receber um sinal, ela processará o primeiro recebido e executará sua próxima etapa definida. Se nenhum sinal for recebido, o fluxo de trabalho continuará para a próxima etapa após o término do período de espera.

A etapa de espera armazena o valor do sinal recebido em sua saída, tornando-o disponível para uso em etapas subsequentes.

O exemplo a seguir mostra uma etapa de espera com um manipulador de sinal:

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

A etapa de espera aceita as seguintes propriedades:

• steps[*].seconds (Obrigatório)

  • Tipo: Número
  • Descrição: O número de segundos a aguardar antes de continuar a execução do fluxo de trabalho.

• steps[*].signals

  • Tipo: matriz
  • Descrição: os sinais que desviam o fluxo do programa quando a etapa de espera os recebe.

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

  • Tipo: String
  • Descrição: O nome do sinal a ser monitorado.

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

  • Tipo: String
  • Descrição: a etapa a ser executada se o sinal especificado for recebido.

Atribuir

Uma etapa que define variáveis para uso em todo o fluxo de trabalho. Esta etapa atribui valores a variáveis que as etapas subsequentes podem referenciar. Este tipo de etapa permite definir todas as variáveis em um só lugar para uso em todo o fluxo de trabalho.

O fluxo de trabalho de exemplo a seguir mostra como usar a etapa de atribuição:

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

A etapa de atribuição aceita a seguinte entrada:

• steps[*].inputs (Obrigatório)

  • Tipo: Mapa de valores (inclui expressões)
  • Descrição:
    • As entradas são um mapa de nomes de variáveis e seus valores atribuídos. Ao atribuir referências de segredos a variáveis, elas permanecem como referências e o sistema não as converte em seus valores reais. No entanto, o fluxo de trabalho avalia e converte outras expressões (como entradas do fluxo de trabalho) em seus valores reais.
  • Tipos de entrada permitidos: Integer, Double, Boolean, String, Array, Map

Estado

Um passo que armazena pares de valor principal no estado compartilhado do fluxo de trabalho. Os valores persistem durante a execução do fluxo de trabalho. Os passos subsequentes podem acessar esses valores usando o acessador .workflowState. Se vários passos de estado definirem a mesma chave, cada valor posterior sobrescreve o anterior.

A etapa de estado aceita a seguinte entrada:

• steps[*].inputs (Obrigatório)

  • Tipo: mapa de pares de valor principal

  • Descrição: os pares de valor principal a serem armazenados no estado do fluxo de trabalho.

    • As chaves devem ser identificadores válidos.
    • Os valores podem ser de qualquer tipo — String, Integer, Boolean, List ou Map (incluindo estruturas aninhadas). Os valores incluem expressões. O tempo de execução não resolve referências de segredos — ele as armazena como estão.

Para acessar valores de estado em expressões, utilize .workflowState.<keyName> em qualquer etapa que siga a etapa de estado:

${{ .workflowState.myKey }}

O exemplo a seguir mostra uma etapa de estado armazenando e recuperando 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 }}"

A etapa de estado tem as seguintes restrições:

• Padrão de nome de chave: ^[a-zA-Z_][a-zA-Z0-9_]*$
• Comprimento máximo do nome da chave: 255 caracteres
• Máximo de chaves por etapa de estado: 10
• Máximo total de chaves de estado por execução de fluxo de trabalho: 100
• Comprimento máximo do valor de estado: 1.000 caracteres

Erro

Uma etapa que encerra o fluxo de trabalho e relata uma falha com uma mensagem personalizada. Se um condition estiver presente, o fluxo de trabalho o avaliará primeiro e parará apenas quando a condição for true. Se não for fornecido um message, a etapa usará a mensagem padrão failed as requested from step: failureStep.

O exemplo a seguir mostra uma etapa de erro com uma condição:

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

A tabela a seguir descreve as entradas aceitas pela etapa de erro.

Tipos de validação

Os seguintes tipos de validação estão disponíveis para workflowInputs.

Expressões e segredos

Cadeias de expressões

Várias propriedades aceitam valores de string com expressões embutidas que o fluxo de trabalho avalia durante a execução, permitindo valores dinâmicos nas definições de fluxo de trabalho.

As cadeias de caracteres de expressão podem conter uma ou mais expressões, cada uma entre chaves duplas. O jq avalia o conteúdo dentro das chaves, permitindo acessar, filtrar e transformar valores.

O exemplo a seguir obtém o comprimento de uma string de entrada de fluxo de trabalho:

${{ .workflowInputs.myString | length }}

Para validar e testar suas expressões, use o JQ Playground.

Propriedades de expressão

É possível acessar essas propriedades com expressões. Elas residem em um objeto scope, portanto, as expressões devem começar com um ponto (.) para acessar essas propriedades do objeto de escopo.

Os imóveis disponíveis são:

• workflowInputs — Objeto contendo as entradas passadas para o fluxo de trabalho no início.

  Exemplo: ${{ .workflowInputs.myInput }}

• workflowState — Objeto contendo pares de valor principal armazenados por etapas state durante a execução atual do fluxo de trabalho.

  Exemplos (chave plana, propriedade aninhada, índice de matriz): ${{ .workflowState.myKey }} · ${{ .workflowState.myMap.nestedProperty }} · ${{ .workflowState.myList[0] }}

• steps — Objeto contendo uma propriedade para cada etapa no fluxo de trabalho.

  • steps.<stepName> — Objeto contendo propriedades para uma etapa específica.
  • steps.<stepName>.outputs — Objeto contendo propriedades de resultado, específicas da etapa ou ação.

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

Resultados da avaliação da expressão

Uma única expressão jq pode resultar em qualquer tipo JSON. No entanto, o resultado final de uma string de expressão depende de a string conter apenas a expressão ou conteúdo adicional.

Expressão única (preserva o tipo JSON)

Se uma string de expressão consistir em apenas uma expressão sem conteúdo ao redor, ela será avaliada como o resultado da expressão jq, mantendo seu tipo JSON original. Por exemplo, ${{ .workflowInputs.myArray }} é avaliado como uma matriz. Isso preserva o tipo de estruturas de dados complexas ao passá-las entre as etapas.

Várias expressões ou conteúdo misto (converte para string)

Se uma string de expressão contiver conteúdo diferente de uma única expressão, ela será avaliada como um resultado de string. Isso ocorre quando uma expressão tem conteúdo antes ou depois dela, ou quando a string tem várias expressões dentro dela. O jq avalia cada expressão e a converte em uma representação de string.

Os exemplos a seguir utilizam myArray com o valor [1, 2, 3].

Expressão padrão seguro

As propriedades usadas em expressões devem estar em conformidade com: ^[A-Za-z_][A-Za-z0-9_]*$

Referências secretas

Use valores secretos em ações fornecendo strings de referência que especificam o nome de um segredo a ser pesquisado no Secrets Service. Para referenciar um segredo em uma definição de fluxo de trabalho, use a sintaxe:

• ${{ :secrets:<SECRET_NAME> }} para um segredo que não está em um namespace
• ${{ :secrets:<NAMESPACE>:<SECRET_NAME> }} para um segredo em um namespace
• ${{ :secrets:<SCOPE>:<NAMESPACE>:<SECRET_NAME> }} para um segredo em um escopo e namespace

SCOPE aceita ACCOUNT ou ORGANIZATION.

Uma string de expressão pode conter expressões jq, referências de segredos ou ambas.

A seguir estão exemplos de referências de segredos usadas em ações:

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

Exemplo completo

Demonstração do calendário

Este exemplo completo de fluxo de trabalho demonstra vários recursos de fluxo de trabalho, incluindo constantes de fluxo de trabalho, seletores, etapas de espera, consulta NRDB e instruções 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 }}"

Tópicos relacionados