Migrar regras de deteção do Splunk para o Microsoft Sentinel

Artigo
03/13/2024

Este artigo descreve como identificar, comparar e migrar suas regras de deteção do Splunk para regras internas do Microsoft Sentinel.

Se você quiser migrar sua implantação do Splunk Observability, saiba mais sobre como migrar do Splunk para os Logs do Azure Monitor.

Identificar e migrar regras

O Microsoft Sentinel usa análises de aprendizado de máquina para criar incidentes acionáveis e de alta fidelidade, e algumas de suas deteções existentes podem ser redundantes no Microsoft Sentinel. Portanto, não migre todas as suas regras de deteção e análise cegamente. Analise estas considerações à medida que identifica as regras de deteção existentes.

Certifique-se de selecionar casos de uso que justifiquem a migração de regras, considerando a prioridade e a eficiência do negócio.
Verifique se você entende os tipos de regras do Microsoft Sentinel.
Verifique se você entende a terminologia da regra.
Analise as regras que não dispararam alertas nos últimos 6 a 12 meses e determine se elas ainda são relevantes.
Elimine ameaças ou alertas de baixo nível que você ignora rotineiramente.
Use a funcionalidade existente e verifique se as regras de análise internas do Microsoft Sentinel podem resolver seus casos de uso atuais. Como o Microsoft Sentinel usa análises de aprendizado de máquina para produzir incidentes acionáveis e de alta fidelidade, é provável que algumas de suas deteções existentes não sejam mais necessárias.
Confirme as fontes de dados conectadas e revise seus métodos de conexão de dados. Revisite as conversas de coleta de dados para garantir a profundidade e a amplitude dos dados nos casos de uso que você planeja detetar.
Teste os recursos da experiência de migração do SIEM para determinar se a tradução automática é adequada.
Explore os recursos da comunidade, como o SOC Prime Threat Detection Marketplace , para verificar se suas regras estão disponíveis.
Considere se um conversor de consulta online, como o Uncoder.io, pode funcionar para suas regras.
Se as regras não estiverem disponíveis ou não puderem ser convertidas, elas precisarão ser criadas manualmente, usando uma consulta KQL. Revise o mapeamento de regras para criar novas consultas.

Saiba mais sobre as práticas recomendadas para migrar regras de deteção.

Para migrar suas regras de análise para o Microsoft Sentinel:

Verifique se você tem um sistema de teste em vigor para cada regra que deseja migrar.
1. Prepare um processo de validação para suas regras migradas, incluindo cenários de teste completos e scripts.
2. Certifique-se de que sua equipe tenha recursos úteis para testar suas regras migradas.
3. Confirme se você tem todas as fontes de dados necessárias conectadas e revise seus métodos de conexão de dados.
Verifique se suas deteções estão disponíveis como modelos internos no Microsoft Sentinel:
- Use a experiência de migração SIEM para automatizar a tradução e a migração.
  
  Para obter mais informações, consulte Usar a experiência de migração do SIEM.
- Se as regras internas forem suficientes, use modelos de regras internos para criar regras para seu próprio espaço de trabalho.
  
  No Microsoft Sentinel, vá para a guia Modelos > de Regra do Configuration Analytics > e crie e atualize cada regra de análise relevante.
  
  Para obter mais informações, consulte Detetar ameaças prontas para uso.
- Se você tiver deteções que não são cobertas pelas regras internas do Microsoft Sentinel, tente um conversor de consulta online, como Uncoder.io ou SPL2KQL para converter suas consultas em KQL.
  
  Identifique a condição de gatilho e a ação da regra e, em seguida, construa e revise sua consulta KQL.
- Se nem as regras internas nem um conversor de regras online forem suficientes, você precisará criar a regra manualmente. Nesses casos, use as seguintes etapas para começar a criar sua regra:
  1. Identifique as fontes de dados que você deseja usar em sua regra. Você desejará criar uma tabela de mapeamento entre fontes de dados e tabelas de dados no Microsoft Sentinel para identificar as tabelas que deseja consultar.
  2. Identifique quaisquer atributos, campos ou entidades em seus dados que você deseja usar em suas regras.
  3. Identifique os critérios e a lógica da regra. Nesta etapa, você pode querer usar modelos de regras como exemplos de como construir suas consultas KQL.
    
    Considere filtros, regras de correlação, listas ativas, conjuntos de referências, listas de observação, anomalias de deteção, agregações e assim por diante. Você pode usar referências fornecidas pelo SIEM herdado para entender a melhor forma de mapear a sintaxe da consulta.
  4. Identifique a condição de gatilho e a ação da regra e, em seguida, construa e revise sua consulta KQL. Ao revisar sua consulta, considere os recursos de orientação de otimização do KQL.
Teste a regra com cada um dos seus casos de uso relevantes. Se ele não fornecer os resultados esperados, você pode querer revisar o KQL e testá-lo novamente.
Quando estiver satisfeito, você pode considerar a regra migrada. Crie um manual para sua ação de regra, conforme necessário. Para obter mais informações, consulte Automatizar a resposta a ameaças com playbooks no Microsoft Sentinel.

Saiba mais sobre as regras de análise:

Crie regras de análise personalizadas para detetar ameaças. Use o agrupamento de alertas para reduzir a fadiga do alerta agrupando alertas que ocorrem dentro de um determinado período de tempo.
Mapeie campos de dados para entidades no Microsoft Sentinel para permitir que os engenheiros SOC definam entidades como parte das evidências a serem rastreadas durante uma investigação. O mapeamento de entidades também possibilita que os analistas SOC aproveitem um [gráfico de investigação] intuitivo (investigate-cases.md#use-the-investigation-graph-to-deep-dive) que pode ajudar a reduzir o tempo e o esforço.
Investigue incidentes com dados UEBA, como um exemplo de como usar evidências para exibir eventos, alertas e quaisquer marcadores associados a um incidente específico no painel de visualização de incidentes.
Kusto Query Language (KQL), que você pode usar para enviar solicitações somente leitura para seu banco de dados do Log Analytics para processar dados e retornar resultados. O KQL também é usado em outros serviços da Microsoft, como o Microsoft Defender for Endpoint e o Application Insights.

Comparar terminologia de regras

Esta tabela ajuda você a esclarecer o conceito de uma regra no Microsoft Sentinel em comparação com o Splunk.

	Splunk	Microsoft Sentinel
Tipo de regra	• Agendado • Em tempo real	• Consulta agendada • Fusão • Segurança Microsoft • Análise de Comportamento de Machine Learning (ML)
Critérios	Definir em SPL	Definir em KQL
Condição do gatilho	• Número de resultados • Número de anfitriões • Número de fontes • Personalizado	Limite: Número de resultados da consulta
Ação	• Adicionar aos alertas acionados • Registrar evento • Resultados de saída para pesquisa • E muito mais	• Criar alerta ou incidente • Integra-se com Aplicativos Lógicos

Mapear e comparar exemplos de regras

Use esses exemplos para comparar e mapear regras do Splunk para o Microsoft Sentinel em vários cenários.

Comandos de pesquisa comuns

Comando SPL	Description	Operador KQL	Exemplo de KQL
`chart/ timechart`	Retorna resultados em uma saída tabular para gráficos de séries temporais.	operador de renderização	`… \| render timechart`
`dedup`	Remove resultados subsequentes que correspondem a um critério especificado.	• distinto • resumir	`… \| summarize by Computer, EventID`
`eval`	Calcula uma expressão. Saiba mais sobre os comandos eval comuns.	estender	`T \| extend duration = endTime - startTime`
`fields`	Remove campos dos resultados da pesquisa.	• Projeto • Projeto Fora	`T \| project cost=price*quantity, price`
`head/tail`	Devolve o primeiro ou o último N resultados.	Início	`T \| top 5 by Name desc nulls last`
`lookup`	Adiciona valores de campo de uma fonte externa.	• dados externos • pesquisa	Exemplo de KQL
`rename`	Renomeia um campo. Use curingas para especificar vários campos.	projeto-renomear	`T \| project-rename new_column_name = column_name`
`rex`	Especifica nomes de grupos usando expressões regulares para extrair campos.	corresponde regex	`… \| where field matches regex "^addr.*"`
`search`	Filtra os resultados para resultados que correspondem à expressão de pesquisa.	search	`search "X"`
`sort`	Classifica os resultados da pesquisa pelos campos especificados.	sort	`T \| sort by strlen(country) asc, price desc`
`stats`	Fornece estatísticas, opcionalmente agrupadas por campos. Saiba mais sobre comandos comuns de estatísticas.	resumir	Exemplo de KQL
`mstats`	Semelhante às estatísticas, usadas em métricas em vez de eventos.	resumir	Exemplo de KQL
`table`	Especifica quais campos devem ser mantidos no conjunto de resultados e retém dados em formato tabular.	projeto	`T \| project columnA, columnB`
`top/rare`	Exibe os valores mais ou menos comuns de um campo.	Início	`T \| top 5 by Name desc nulls last`
`transaction`	Agrupa os resultados da pesquisa em transações. Exemplo de SPL	Exemplo: row_window_session	Exemplo de KQL
`eventstats`	Gera estatísticas de resumo a partir de campos em seus eventos e salva essas estatísticas em um novo campo. Exemplo de SPL	Exemplos: • aderir • make_list • MV-Expandir	Exemplo de KQL
`streamstats`	Encontre a soma cumulativa de um campo. Exemplo de SPL: `... \| streamstats sum(bytes) as bytes _ total \\| timechart`	row_cumsum	`...\\| serialize cs=row_cumsum(bytes)`
`anomalydetection`	Encontre anomalias no campo especificado. Exemplo de SPL	series_decompose_anomalies()	Exemplo de KQL
`where`	Filtra os resultados da pesquisa usando `eval` expressões. Usado para comparar dois campos diferentes.	em que	`T \| where fruit=="apple"`

comando lookup: exemplo KQL

Users 
| where UserID in ((externaldata (UserID:string) [
@"https://storageaccount.blob.core.windows.net/storagecontainer/users.txt" 
h@"?...SAS..." // Secret token to access the blob 
])) | ...

comando stats: exemplo KQL

Sales 
| summarize NumTransactions=count(), 
Total=sum(UnitPrice * NumUnits) by Fruit, 
StartOfMonth=startofmonth(SellDateTime)

comando mstats: exemplo KQL

T | summarize count() by price_range=bin(price, 10.0)

comando transaction: exemplo SPL

sourcetype=MyLogTable type=Event
| transaction ActivityId startswith="Start" endswith="Stop"
| Rename timestamp as StartTime
| Table City, ActivityId, StartTime, Duration

comando transaction: exemplo KQL

let Events = MyLogTable | where type=="Event";
Events
| where Name == "Start"
| project Name, City, ActivityId, StartTime=timestamp
| join (Events
| where Name == "Stop"
| project StopTime=timestamp, ActivityId)
on ActivityId
| project City, ActivityId, StartTime, 
Duration = StopTime – StartTime

Use row_window_session() para calcular valores de início de sessão para uma coluna em um conjunto de linhas serializado.

...| extend SessionStarted = row_window_session(
Timestamp, 1h, 5m, ID != prev(ID))

comando eventstats: exemplo de SPL

… | bin span=1m _time
|stats count AS count_i by _time, category
| eventstats sum(count_i) as count_total by _time

comando eventstats: exemplo KQL

Aqui está um exemplo com a join declaração:

let binSize = 1h;
let detail = SecurityEvent 
| summarize detail_count = count() by EventID,
tbin = bin(TimeGenerated, binSize);
let summary = SecurityEvent
| summarize sum_count = count() by 
tbin = bin(TimeGenerated, binSize);
detail 
| join kind=leftouter (summary) on tbin 
| project-away tbin1

Aqui está um exemplo com a make_list declaração:

let binSize = 1m;
SecurityEvent
| where TimeGenerated >= ago(24h)
| summarize TotalEvents = count() by EventID, 
groupBin =bin(TimeGenerated, binSize)
|summarize make_list(EventID), make_list(TotalEvents), 
sum(TotalEvents) by groupBin
| mvexpand list_EventID, list_TotalEvents

comando anomalydetection: exemplo SPL

sourcetype=nasdaq earliest=-10y
| anomalydetection Close _ Price

comando anomalydetection: exemplo KQL

let LookBackPeriod= 7d;
let disableAccountLogon=SignIn
| where ResultType == "50057"
| where ResultDescription has "account is disabled";
disableAccountLogon
| make-series Trend=count() default=0 on TimeGenerated 
in range(startofday(ago(LookBackPeriod)), now(), 1d)
| extend (RSquare,Slope,Variance,RVariance,Interception,
LineFit)=series_fit_line(Trend)
| extend (anomalies,score) = 
series_decompose_anomalies(Trend)

Comandos eval comuns

Comando SPL	Description	Exemplo de SPL	Comando KQL	Exemplo de KQL
`abs(X)`	Devolve o valor absoluto de X.	`abs(number)`	abs()	`abs(X)`
`case(X,"Y",…)`	Usa pares de `X` e `Y` argumentos, onde os `X` argumentos são expressões booleanas. Quando avaliados para `TRUE`, os argumentos retornam o argumento correspondente `Y` .	Exemplo de SPL	caixa	Exemplo de KQL
`ceil(X)`	Teto de um número X.	`ceil(1.9)`	teto()	`ceiling(1.9)`
`cidrmatch("X",Y)`	Identifica endereços IP que pertencem a uma sub-rede específica.	`cidrmatch` `("123.132.32.0/25",ip)`	• ipv4_is_match() • ipv6_is_match()	`ipv4_is_match('192.168.1.1', '192.168.1.255')` `== false`
`coalesce(X,…)`	Retorna o primeiro valor que não é nulo.	`coalesce(null(), "Returned val", null())`	coalescência()	`coalesce(tolong("not a number"),` `tolong("42"), 33) == 42`
`cos(X)`	Calcula o cosseno de X.	`n=cos(0)`	cos()	`cos(X)`
`exact(X)`	Avalia uma expressão X usando aritmética de ponto flutuante de precisão dupla.	`exact(3.14*num)`	todecimal()	`todecimal(3.14*2)`
`exp(X)`	Devolve eX.	`exp(3)`	exp()	`exp(3)`
`if(X,Y,Z)`	Se `X` avaliado como `TRUE`, o resultado é o segundo argumento `Y`. Se `X` for avaliado como `FALSE`, o resultado será avaliado para o terceiro argumento `Z`.	`if(error==200,` `"OK", "Error")`	IIF()	Exemplo de KQL
`isbool(X)`	Retorna `TRUE` se `X` for booleano.	`isbool(field)`	• IIF() • GetType	`iif(gettype(X) =="bool","TRUE","FALSE")`
`isint(X)`	Retorna `TRUE` se `X` for um inteiro.	`isint(field)`	• IIF() • GetType	Exemplo de KQL
`isnull(X)`	Retorna `TRUE` se `X` for null.	`isnull(field)`	isnull()	`isnull(field)`
`isstr(X)`	Retorna `TRUE` se `X` for uma cadeia de caracteres.	`isstr(field)`	• IIF() • GetType	Exemplo de KQL
`len(X)`	Esta função retorna o comprimento do caractere de uma cadeia de caracteres `X`.	`len(field)`	strlen()	`strlen(field)`
`like(X,"y")`	Retorna `TRUE` se e somente se `X` for como o padrão SQLite em `Y`.	`like(field, "addr%")`	• tem • contém • começa com • corresponde regex	Exemplo de KQL
`log(X,Y)`	Retorna o log do primeiro argumento `X` usando o segundo argumento `Y` como base. O valor padrão de `Y` é `10`.	`log(number,2)`	• registo • Log2 • Log10	`log(X)` `log2(X)` `log10(X)`
`lower(X)`	Devolve o valor minúsculo de `X`.	`lower(username)`	abaixar	`tolower(username)`
`ltrim(X,Y)`	Retorna `X` com os caracteres no parâmetro `Y` cortados do lado esquerdo. A saída padrão de `Y` é espaços e guias.	`ltrim(" ZZZabcZZ ", " Z")`	trim_start()	`trim_start(“ ZZZabcZZ”,” ZZZ”)`
`match(X,Y)`	Retorna se X corresponder ao padrão regex Y.	`match(field, "^\d{1,3}.\d$")`	corresponde regex	`… \| where field matches regex @"^\d{1,3}.\d$")`
`max(X,…)`	Devolve o valor máximo numa coluna.	`max(delay, mydelay)`	• máx() • arg_max()	`… \| summarize max(field)`
`md5(X)`	Retorna o hash MD5 de um valor `X`de cadeia de caracteres.	`md5(field)`	hash_md5	`hash_md5("X")`
`min(X,…)`	Devolve o valor mínimo numa coluna.	`min(delay, mydelay)`	• min_of() • min() • arg_min	Exemplo de KQL
`mvcount(X)`	Devolve o número (total) de `X` valores.	`mvcount(multifield)`	dcount	`…\| summarize dcount(X) by Y`
`mvfilter(X)`	Filtra um campo de vários valores com base na expressão booleana `X` .	`mvfilter(match(email, "net$"))`	mv-aplicar	Exemplo de KQL
`mvindex(X,Y,Z)`	Retorna um subconjunto do argumento de vários valores `X` de uma posição inicial (baseada em zero) `Y` para `Z` (opcional).	`mvindex( multifield, 2)`	array_slice	`array_slice(arr, 1, 2)`
`mvjoin(X,Y)`	Dado um campo `X` de vários valores e delimitador `Y`de cadeia de caracteres , e une os valores individuais do uso `Y`do `X` .	`mvjoin(address, ";")`	strcat_array	Exemplo de KQL
`now()`	Retorna a hora atual, representada na hora Unix.	`now()`	agora()	`now()` `now(-2d)`
`null()`	Não aceita argumentos e devoluções `NULL`.	`null()`	nulo	`null`
`nullif(X,Y)`	Inclui dois argumentos `X` e `Y`, e retorna `X` se os argumentos forem diferentes. Caso contrário, retorna `NULL`.	`nullif(fieldA, fieldB)`	IFI	`iif(fieldA==fieldB, null, fieldA)`
`random()`	Devolve um número pseudoaleatório entre `0` .`2147483647`	`random()`	Rand()	`rand()`
`relative_ time(X,Y)`	Dado um especificador de tempo `X` de época e tempo relativo, retorna o valor de tempo de época de `Y` aplicado a `X`.`Y`	`relative_time(now(),"-1d@d")`	Tempo UNIX	Exemplo de KQL
`replace(X,Y,Z)`	Retorna uma cadeia de caracteres formada pela substituição de string `Z` para cada ocorrência de string `Y` de expressão regular em string `X`.	Data de retorno com os números de mês e dia trocados. Por exemplo, para a `4/30/2015` entrada, a saída é `30/4/2009`: `replace(date, "^(\d{1,2})/ (\d{1,2})/", "\2/\1/")`	substituir()	Exemplo de KQL
`round(X,Y)`	Devolve `X` arredondado para o número de casas decimais especificado por `Y`. O padrão é arredondar para um inteiro.	`round(3.5)`	redondo	`round(3.5)`
`rtrim(X,Y)`	Retorna `X` com os caracteres de cortados `Y` do lado direito. Se `Y` não for especificado, os espaços e as guias serão cortados.	`rtrim(" ZZZZabcZZ ", " Z")`	trim_end()	`trim_end(@"[ Z]+",A)`
`searchmatch(X)`	Retorna `TRUE` se o evento corresponder à cadeia de caracteres `X`de pesquisa .	`searchmatch("foo AND bar")`	IIF()	`iif(field has "X","Yes","No")`
`split(X,"Y")`	Retorna `X` como um campo de vários valores, dividido por delimitador `Y`.	`split(address, ";")`	divisão()	`split(address, ";")`
`sqrt(X)`	Devolve a raiz quadrada de `X`.	`sqrt(9)`	sqrt()	`sqrt(9)`
`strftime(X,Y)`	Retorna o valor `X` de tempo de época renderizado usando o formato especificado por `Y`.	`strftime(_time, "%H:%M")`	format_datetime()	`format_datetime(time,'HH:mm')`
`strptime(X,Y)`	Dado um tempo representado por uma cadeia de caracteres `X`, retorna o valor analisado do formato `Y`.	`strptime(timeStr, "%H:%M")`	format_datetime()	Exemplo de KQL
`substr(X,Y,Z)`	Retorna um campo `X` de substring da posição inicial (baseado em um) `Y` para `Z` caracteres (opcionais).	`substr("string", 1, 3)`	substring()	`substring("string", 0, 3)`
`time()`	Devolve o tempo do relógio de parede com resolução de microssegundos.	`time()`	format_datetime()	Exemplo de KQL
`tonumber(X,Y)`	Converte a cadeia de caracteres `X` de entrada em um número, onde `Y` (opcional, o valor padrão é `10`) define a base do número para o qual converter.	`tonumber("0A4",16)`	toint()	`toint("123")`
`tostring(X,Y)`	Descrição	Exemplo de SPL	tostring()	`tostring(123)`
`typeof(X)`	Retorna uma representação de cadeia de caracteres do tipo de campo.	`typeof(12)`	gettype()	`gettype(12)`
`urldecode(X)`	Retorna a URL `X` decodificada.	Exemplo de SPL	url_decode	Exemplo de KQL

caso(X,"Y",...) Exemplo de SPL

case(error == 404, "Not found",
error == 500,"Internal Server Error",
error == 200, "OK")

caso(X,"Y",...) Exemplo de KQL

T
| extend Message = case(error == 404, "Not found", 
error == 500,"Internal Server Error", "OK")

Exemplo if(X,Y,Z) KQL

iif(floor(Timestamp, 1d)==floor(now(), 1d), 
"today", "anotherday")

Exemplo de ISINT(X) KQL

iif(gettype(X) =="long","TRUE","FALSE")

Exemplo de isstr(X) KQL

iif(gettype(X) =="string","TRUE","FALSE")

exemplo like(X,"y")

… | where field has "addr"

… | where field contains "addr"

… | where field startswith "addr"

… | where field matches regex "^addr.*"

min (X,...) Exemplo de KQL

min_of (expr_1, expr_2 ...)

…|summarize min(expr)

…| summarize arg_min(Price,*) by Product

Exemplo de KQL mvfilter(X)

T | mv-apply Metric to typeof(real) on 
(
 top 2 by Metric desc
)

Exemplo de mvjoin(X,Y) KQL

strcat_array(dynamic([1, 2, 3]), "->")

Exemplo de tempo relativo (X,Y) KQL

let toUnixTime = (dt:datetime)
{
(dt - datetime(1970-01-01))/1s 
};

Exemplo de replace(X,Y,Z) KQL

replace( @'^(\d{1,2})/(\d{1,2})/', @'\2/\1/',date)

Exemplo de strptime(X,Y) KQL

format_datetime(datetime('2017-08-16 11:25:10'),
'HH:mm')

exemplo de time() KQL

format_datetime(datetime(2015-12-14 02:03:04),
'h:m:s')

tostring (X, Y)

Retorna um valor de campo como uma cadeia de X caracteres.

Se o valor de for um número, X será reformatado para um valor de cadeia de X caracteres.
Se X for um valor booleano, X é reformatado para TRUE ou FALSE.
Se X for um número, o segundo argumento Y é opcional e pode ser hex (converte para um hexadecimal), commas (formatos X com vírgulas XX e duas casas decimais) ou duration (converte de um formato de hora em segundos para um formato de hora legível: HH:MM:SS).

Exemplo de tostring(X,Y) SPL

Este exemplo retorna:

foo=615 and foo2=00:10:15:

… | eval foo=615 | eval foo2 = tostring(
foo, "duration")

Exemplo de SPL urldecode(X)

urldecode("http%3A%2F%2Fwww.splunk.com%2Fdownload%3Fr%3Dheader")

Exemplo de KQL de comandos de estatísticas comuns

Comando SPL	Description	Comando KQL	Exemplo de KQL
`avg(X)`	Devolve a média dos valores do campo `X`.	média()	`avg(X)`
`count(X)`	Devolve o número de ocorrências do campo `X`. Para indicar um valor de campo específico a ser correspondido, formate `X` como `eval(field="value")`.	contagem()	`summarize count()`
`dc(X)`	Devolve a contagem de valores distintos do campo `X`.	dcount()	`…\\| summarize countries=dcount(country) by continent`
`earliest(X)`	Devolve o valor `X`cronologicamente mais antigo de .	arg_min()	`… \\| summarize arg_min(TimeGenerated, *) by X`
`latest(X)`	Devolve o valor `X`cronologicamente mais recente de .	arg_max()	`… \\| summarize arg_max(TimeGenerated, *) by X`
`max(X)`	Devolve o valor máximo do campo `X`. Se os valores de `X` não forem numéricos, o valor máximo será encontrado por ordem alfabética.	máx()	`…\\| summarize max(X)`
`median(X)`	Devolve o valor intermédio do campo `X`.	percentil()	`…\\| summarize percentile(X, 50)`
`min(X)`	Devolve o valor mínimo do campo `X`. Se os valores de `X` não forem numéricos, o valor mínimo será encontrado por ordem alfabética.	min()	`…\\| summarize min(X)`
`mode(X)`	Devolve o valor mais frequente do campo `X`.	top-hitters()	`…\\| top-hitters 1 of Y by X`
`perc(Y)`	Devolve o valor percentil `X` do campo `Y`. Por exemplo, `perc5(total)` retorna o valor do quinto percentil de um campo `total`.	percentil()	`…\\| summarize percentile(Y, 5)`
`range(X)`	Devolve a diferença entre os valores máximo e mínimo do campo `X`.	intervalo()	`range(1, 3)`
`stdev(X)`	Devolve o desvio padrão da amostra do campo `X`.	Stdev	`stdev()`
`stdevp(X)`	Devolve o desvio padrão da população do campo `X`.	Stdevp()	`stdevp()`
`sum(X)`	Devolve a soma dos valores do campo `X`.	soma()	`sum(X)`
`sumsq(X)`	Devolve a soma dos quadrados dos valores do campo `X`.
`values(X)`	Retorna a lista de todos os valores distintos do campo `X` como uma entrada de vários valores. A ordem dos valores é alfabética.	make_set()	`…\\| summarize r = make_set(X)`
`var(X)`	Devolve a variância de amostra do campo `X`.	variância	`variance(X)`

Próximos passos

Neste artigo, você aprendeu como mapear suas regras de migração do Splunk para o Microsoft Sentinel.

Migre sua automação SOAR