Componente DataFormat - Security Center: Central de Documentação do Alibaba Cloud

Ações

Cada ação tem uma finalidade específica. Consulte a tabela abaixo para escolher a ação adequada ao seu caso de uso.

Ação	Funcionalidade	Quando usar	Equivalente SQL
`joindata`	Une vários nós de dados e gera os campos especificados	Para combinar dois ou mais conjuntos de dados em que as linhas de ambos devem corresponder	INNER JOIN
`leftJoin`	Une dois nós de dados e mantém todas as linhas do nó à esquerda	Ao combinar conjuntos de dados que exigem todas as linhas do lado esquerdo, mesmo sem correspondência no lado direito	LEFT JOIN
`groupbydata`	Agrupa linhas por uma chave e calcula agregações	Para resumir dados — por exemplo, contar eventos por tipo de ataque	GROUP BY
`concatFieldtoBatch`	Concatena valores de campo em lotes formando strings	Para mesclar valores de array em strings delimitadas com prefixo/sufixo opcional	—
`convertToJson`	Converte uma string em JSONArray ou JSONObject	Para preparar dados de string para ações subsequentes que exigem entrada JSON	CAST / CONVERT
`uniondata`	Combina linhas de vários nós de dados em um único conjunto de dados	Para mesclar resultados de ramificações paralelas em uma única lista	UNION ALL
`formatdata`	Crie uma nova linha de dados com pares chave-valor especificados	Para gerar saída estruturada a partir de valores estáticos ou upstream	SELECT ... AS

Salve os dados JSON de exemplo como um arquivo antes de importar exemplos como playbooks de teste. Para saber como importar um playbook, consulte Importar um playbook .

Exemplos de configuração do componente

As seções a seguir detalham a configuração e apresentam exemplos de entrada e saída para cada ação.

joindata

Une vários nós de dados com base em uma chave compartilhada e gera os campos especificados. Trata-se de uma junção interna (inner join): apenas as linhas correspondentes em todos os nós de entrada aparecem na saída.

Parâmetros

Parâmetro	Descrição
`inputNodes`	Nós de dados a unir. Os dados de cada nó devem ser um JSONArray. Não há limite para a profundidade de aninhamento; um JSONArray pode conter JSONArrays aninhados.
`joinFields`	Campos usados para a junção. Formato: `[nodeName].[fieldName]`. Apenas campos de primeiro nível são suportados. Os tipos de campo JSONArray e String são aceitos. Campos aninhados (por exemplo, `uuid-key` dentro de `uuid`) não podem ser usados como chaves de junção.
`outputFields`	Campos a incluir na saída. Formato: `[nodeName].[fieldName]`.

Ao referenciar um nó em inputNodes , adicione o prefixo JSONArray: ao valor para garantir que os dados sejam tratados como um JSONArray. Sem esse prefixo, não é possível ler os dados do nó upstream.

Exemplo

Dados de entrada:

leftJSON: [{"action":"11","uuid":[{"uuid-key":"1"}]},{"action":"21","uuid":[{"uuid-key":"2"}]}]
rightJSON: [{"uuid":[{"uuid-key":"1"}],"host":"196.1.*.*"},{"uuid":[{"uuid-key":"1"}],"host":"196.2.*.*"}]

Valores dos parâmetros:

Parâmetro	Configuração
`inputNodes`	Linha 1 — Esquerda: `leftJSON`, Direita: `${JSONArray:leftJSON.datalist.*}`
	Linha 2 — Esquerda: `rightJSON`, Direita: `${JSONArray:rightJSON.datalist.*}`
`joinFields`	Esquerda: `leftJSON.uuid`, Direita: `rightJSON.uuid`
`outputFields`	Linha 1 — Esquerda: `myhost`, Direita: `rightJSON.host`
	Linha 2 — Esquerda: `myaction`, Direita: `leftJSON.action`
	Linha 3 — Esquerda: `uuid`, Direita: `leftJSON.uuid`

Saída:

[
    {
        "myaction": "11",
        "uuid": [{"uuid-key": "1"}],
        "myhost": "196.1.*.*"
    },
    {
        "myaction": "11",
        "uuid": [{"uuid-key": "1"}],
        "myhost": "196.2.*.*"
    }
]

A linha com action: "21" não aparece na saída porque nenhuma linha em rightJSON possui uuid-key: "2" . Use leftJoin se precisar manter as linhas do lado esquerdo sem correspondência.

leftJoin

Executa uma junção à esquerda usando o nó esquerdo como tabela primária. Todas as linhas do nó esquerdo aparecem na saída. As linhas do nó direito sem correspondência são descartadas; já as linhas do nó esquerdo sem correspondência são incluídas com valores vazios para os campos do nó direito.

Parâmetros

Parâmetro	Descrição
`leftNode`	Nó de dados primário (esquerdo). O formato deve ser um JSONArray de objetos JSON. JSONArrays aninhados são suportados.
`rightNode`	Nó de dados secundário (direito). O formato deve ser um JSONArray de objetos JSON. JSONArrays aninhados são suportados.
`joinFields`	Campos usados para a junção. Formato: `leftNode.[fieldName]` e `rightNode.[fieldName]`. Apenas campos de primeiro nível são suportados. Campos aninhados (por exemplo, `uuid-key` dentro de `uuid`) não podem ser usados como chaves de junção.
`leftOutputFilelds`	Campos a gerar pelo nó esquerdo, com renomeação opcional de chave. Entrada esquerda: novo nome. Entrada direita: nome original do campo. Use `` na caixa esquerda para manter o nome original; use `` na caixa direita para selecione todos os campos. Separe vários campos com vírgula.
`rightOutputFields`	Campos a gerar pelo nó direito, com renomeação opcional de chave. Segue a mesma convenção de `leftOutputFilelds`.

Os dados de leftNode e rightNode devem ser convertidos para o tipo JSONArray antes do uso.

Exemplo

Dados de entrada:

leftNode:

[
    {"action": "11", "uuid": [{"uuid-key": "1"}]},
    {"action": "21", "uuid": [{"uuid-key": "2"}]}
]

rightNode:

[
    {"uuid": [{"uuid-key": "1"}], "host": "196.1.*.*"},
    {"uuid": [{"uuid-key": "1"}], "host": "196.2.*.*"}
]

Valores dos parâmetros:

Parâmetro	Configuração
`joinFields`	Esquerda: `leftNode.uuid`, Direita: `rightNode.uuid`
`leftOutputFilelds`	Esquerda: `*`, Direita: `action,uuid`
`rightOutputFields`	Esquerda: `site`, Direita: `host`

Saída:

[
    {
        "action": "11",
        "uuid": [{"uuid-key": "1"}],
        "site": "196.1.*.*"
    },
    {
        "action": "11",
        "uuid": [{"uuid-key": "1"}],
        "site": "196.2.*.*"
    },
    {
        "action": "21",
        "uuid": [{"uuid-key": "2"}]
    }
]

A linha com action: "21" é mantida mesmo sem uma linha correspondente em rightNode. O campo site está ausente nessa linha.

groupbydata

Agrupa linhas por uma chave e calcula valores agregados para cada grupo. Funciona de maneira semelhante à instrução SQL GROUP BY: linhas com a mesma chave são agrupadas e uma expressão é aplicada para gerar valores de resumo.

Parâmetros

Parâmetro	Descrição
`inputNode`	Dados a agrupar. Devem ser um JSONArray de objetos JSON.
`groupByKeys`	Campo usado para agrupamento. Linhas com o mesmo valor neste campo são colocadas no mesmo grupo.
`outputFields`	Campos calculados a incluir para cada grupo. Suporta expressões jq aplicadas aos dados agrupados.

Exemplo

Cenário: Agrupar eventos de segurança por Attack Type, calcular o número total de ataques e identificar o horário do ataque mais recente.

Dados de entrada (inputNode):

[
    {"Attack Type": "web shell", "count": "1", "startTime": "1646115503000", "endTime": "1646115503000", "securityEventIds": "330706"},
    {"Attack Type": "web shell", "count": "2", "startTime": "1646114346000", "endTime": "1646114346000", "securityEventIds": "330700"},
    {"Attack Type": "application whitelist", "count": "1", "startTime": "1646114098000", "endTime": "1646114098000", "securityEventIds": "330699"}
]

Valores dos parâmetros:

Parâmetro	Configuração
`groupByKeys`	`Attack Type`
`outputFields`	`[{"fieldName":"Attack Count","fieldType":"jq","fieldValue":".datalist	map_values(.count)	add	length"},{"fieldName":"Latest Attack Time","fieldType":"jq","fieldValue":"[.datalist[].endTime	tonumber]	max"}]`

As duas expressões jq acima funcionam da seguinte forma:

.datalist | map_values(.count)|add|length — conta o número total de eventos de ataque no grupo
[.datalist[].endTime|tonumber]|max — converte os valores de endTime para números e retorna o máximo (horário mais recente)

Saída:

[
    {"Attack Type": "web shell", "Attack Count": 2, "Latest Attack Time": 1646115503000},
    {"Attack Type": "application whitelist", "Attack Count": 1, "Latest Attack Time": 1646114098000}
]

concatFieldtoBatch

Divide um campo JSONArray em minilotes e concatena os valores de cada lote em uma string. Suporta separadores, prefixos e sufixos personalizados.

Parâmetros

Parâmetro	Descrição
`inputField`	Dados a concatenar. Devem ser um JSONArray de objetos JSON.
`batchSize`	Número de itens por lote. Por exemplo, `2` agrupa dois objetos. Use `-1` para combinar todos os objetos em uma única string.
`concatStr`	Separador inserido entre os valores concatenados. Coloque entre aspas duplas para preservar espaços — por exemplo, `" ## "`.
`fieldAddPrefix`	Prefixo adicionado ao início de cada string concatenada.
`fieldAddSuffix`	Sufixo adicionado ao final de cada string concatenada.

Exemplo

Cenário: Concatenar valores de Attack Type em grupos de dois, usando " ## " como separador, com o prefixo Prefix e o sufixo Suffix.

Dados de entrada (inputField):

[
    {"Attack Type": "web shell"},
    {"Attack Type": "web shell"},
    {"Attack Type": "web shell"},
    {"Attack Type": "application whitelist"},
    {"Attack Type": "application whitelist"}
]

Valores dos parâmetros:

Parâmetro	Valor
`batchSize`	`2`
`concatStr`	`" ## "`
`fieldAddPrefix`	`Prefix`
`fieldAddSuffix`	`Suffix`

Saída:

[
    {"concatField": "PrefixWebShellSuffix ## PrefixWebShellSuffix"},
    {"concatField": "PrefixWebShellSuffix ## PrefixApplicationWhitelistSuffix"},
    {"concatField": "PrefixApplicationWhitelistSuffix"}
]

Os cinco itens de entrada são divididos em lotes de dois (grupos 1 e 2) mais um item restante (grupo 3).

convertToJson

Converte uma string em um objeto JSON. Esta ação realiza apenas conversão de tipo e não modifique os dados.

Se a entrada for uma string JSONArray, todos os elementos são colocados diretamente no datalist.
Se a entrada for uma string JSONObject, ela é tratada como uma única linha no datalist.

Essa ação é geralmente usada para preparar dados de string upstream antes de passá-los para ações como joindata, leftJoin ou groupbydata, que exigem entrada JSONArray.

uniondata

Combina linhas de vários nós de dados upstream em um único conjunto de dados. Todas as linhas de todos os nós especificados são incluídas — equivalente a um UNION ALL do SQL.

Parâmetros

Parâmetro	Descrição
`inputNodes`	Dados dos nós a combinar.

Os rótulos da caixa de entrada esquerda (por exemplo, leftJSON , rightJSON ) servem apenas como identificadores e não afetam a saída. Adicione o prefixo JSONArray: a cada valor da caixa direita para garantir a leitura correta dos dados dos nós upstream.

Exemplo

Dados de entrada:

left: [{"action":"11","uuid":[{"uuid-key":"1"}]},{"action":"21","uuid":[{"uuid-key":"2"}]}]
right: [{"uuid":[{"uuid-key":"1"}],"host":"196.1.*.*"},{"uuid":[{"uuid-key":"1"}],"host":"196.2.*.*"}]

Valores dos parâmetros:

Parâmetro	Configuração
`inputNodes`	Linha 1 — Esquerda: `leftJSON`, Direita: `${JSONArray:left.datalist.*}`
	Linha 2 — Esquerda: `rightJSON`, Direita: `${JSONArray:right.datalist.*}`

Saída:

[
    {"action": "11", "uuid": [{"uuid-key": "1"}]},
    {"action": "21", "uuid": [{"uuid-key": "2"}]},
    {"uuid": [{"uuid-key": "1"}], "host": "196.1.*.*"},
    {"uuid": [{"uuid-key": "1"}], "host": "196.2.*.*"}
]

formatdata

Transforma e agrega dados de várias fontes em uma nova tabela. Utilize esta ação para crie saídas estruturadas com pares chave-valor explicitamente definidos a partir de valores estáticos ou referências de nós upstream.

Parâmetros

Parâmetro	Descrição
`outputFields`	Pares chave-valor a incluir na saída. Entrada esquerda: nome do campo. Entrada direita: valor do campo.

Exemplo

Valores dos parâmetros:

Esquerda (nome do campo)	Direita (valor do campo)
`name`	`test`
`age`	`18`

Saída:

{
    "name": "test",
    "age": "18"
}