Migrace pravidel detekce splunku do Služby Microsoft Sentinel

Článek
03/13/2024

Tento článek popisuje, jak identifikovat, porovnat a migrovat pravidla detekce splunku do integrovaných pravidel služby Microsoft Sentinel.

Pokud chcete migrovat nasazení Splunk Observability, přečtěte si další informace o tom, jak migrovat z Splunku do protokolů služby Azure Monitor.

Identifikace a migrace pravidel

Microsoft Sentinel používá analýzy strojového učení k vytváření vysoce věrných a použitelných incidentů a některé z vašich existujících detekcí můžou být v Microsoft Sentinelu redundantní. Proto nemigrujte všechna pravidla detekce a analýzy nevidomě. Tyto aspekty si projděte při identifikaci existujících pravidel detekce.

Nezapomeňte vybrat případy použití, které odůvodňují migraci pravidel, a zvažte obchodní prioritu a efektivitu.
Zkontrolujte, že rozumíte typům pravidel Služby Microsoft Sentinel.
Zkontrolujte, že rozumíte terminologii pravidel.
Zkontrolujte všechna pravidla, která za posledních 6 až 12 měsíců neaktivovala žádná upozornění, a zjistěte, jestli jsou stále relevantní.
Odstraňte hrozby nebo výstrahy nízké úrovně, které pravidelně ignorujete.
Použijte existující funkce a zkontrolujte, jestli předdefinovaná analytická pravidla Microsoft Sentinelu můžou řešit vaše aktuální případy použití. Vzhledem k tomu, že Microsoft Sentinel používá analýzy strojového učení k vytváření vysoce věrných a použitelných incidentů, je pravděpodobné, že některé z vašich existujících detekcí už nebudou potřeba.
Potvrďte připojené zdroje dat a zkontrolujte metody datového připojení. Znovu se můžete podívat na konverzace shromažďování dat, abyste zajistili hloubku a šířku dat napříč případy použití, které plánujete zjistit.
Otestujte možnosti prostředí migrace SIEM a zjistěte, jestli je automatický překlad vhodný.
Prozkoumejte komunitní zdroje, jako je MARKETPLACE pro detekci hlavních hrozeb SOC, a zkontrolujte, jestli jsou vaše pravidla dostupná.
Zvažte, jestli pro vaše pravidla může fungovat online převaděč dotazů, například Uncoder.io.
Pokud nejsou pravidla dostupná nebo není možné je převést, je potřeba je vytvořit ručně pomocí dotazu KQL. Zkontrolujte mapování pravidel a vytvořte nové dotazy.

Přečtěte si další informace o osvědčených postupech pro migraci pravidel detekce.

Migrace analytických pravidel do Služby Microsoft Sentinel:

Ověřte, že máte zaveden testovací systém pro každé pravidlo, které chcete migrovat.
1. Připravte proces ověření pro migrovaná pravidla, včetně kompletních testovacích scénářů a skriptů.
2. Ujistěte se, že váš tým má užitečné zdroje k otestování migrovaných pravidel.
3. Ověřte, že máte připojené všechny požadované zdroje dat, a zkontrolujte metody datového připojení.
Ověřte, jestli jsou vaše detekce dostupné jako předdefinované šablony v Microsoft Sentinelu:
- Využijte prostředí migrace SIEM k automatizaci překladu a migrace.
  
  Další informace najdete v tématu Použití prostředí migrace SIEM.
- Pokud jsou předdefinovaná pravidla dostatečná, vytvořte pravidla pro vlastní pracovní prostor pomocí předdefinovaných šablon pravidel.
  
  V Microsoft Sentinelu přejděte na kartu Šablony pravidel analýzy > konfigurace > a vytvořte a aktualizujte každé relevantní analytické pravidlo.
  
  Další informace najdete v tématu Detekce hrozeb, které jsou předdefinované.
- Pokud máte detekce, které nejsou součástí předdefinovaných pravidel Microsoft Sentinelu, zkuste online převaděč dotazů, jako je Uncoder.io nebo SPL2KQL , a převeďte dotazy na KQL.
  
  Identifikujte podmínku triggeru a akci pravidla a pak vytvořte a zkontrolujte dotaz KQL.
- Pokud žádná předdefinovaná pravidla ani online převaděč pravidel nestačí, budete muset pravidlo vytvořit ručně. V takových případech začněte vytvářet pravidlo pomocí následujících kroků:
  1. Identifikujte zdroje dat, které chcete použít ve svém pravidle. Budete chtít vytvořit tabulku mapování mezi zdroji dat a tabulkami dat v Microsoft Sentinelu, abyste identifikovali tabulky, které chcete dotazovat.
  2. Identifikujte všechny atributy, pole nebo entity ve vašich datech, které chcete použít ve svých pravidlech.
  3. Identifikujte kritéria a logiku pravidla. V této fázi můžete chtít použít šablony pravidel jako ukázky pro vytvoření dotazů KQL.
    
    Zvažte filtry, pravidla korelace, aktivní seznamy, referenční sady, seznamy ke zhlédnutí, detekce anomálií, agregace atd. Můžete použít odkazy poskytované starší verzí SIEM, abyste pochopili , jak nejlépe namapovat syntaxi dotazu.
  4. Identifikujte podmínku triggeru a akci pravidla a pak vytvořte a zkontrolujte dotaz KQL. Při kontrole dotazu zvažte prostředky s pokyny k optimalizaci KQL.
Otestujte pravidlo s jednotlivými relevantními případy použití. Pokud neposkytuje očekávané výsledky, můžete si ho zkontrolovat a znovu ho otestovat.
Až budete spokojeni, můžete zvážit migraci pravidla. Podle potřeby vytvořte playbook pro akci pravidla. Další informace najdete v tématu Automatizace reakcí na hrozby pomocí playbooků v Microsoft Sentinelu.

Další informace o analytických pravidlech:

Vytvořte vlastní analytická pravidla pro detekci hrozeb. Seskupením výstrah můžete snížit únavu výstrah seskupením výstrah, ke kterým dochází v daném časovém rámci.
Namapujte datová pole na entity v Microsoft Sentinelu , aby inženýři SOC mohli definovat entity jako součást důkazů ke sledování během vyšetřování. Mapování entit také umožňuje analytikům SOC využívat intuitivní [graf šetření] (vyšetřovací případy.md#use-the-investigation-graph-to-deep-dive), které můžou pomoct zkrátit čas a úsilí.
Prozkoumejte incidenty s daty UEBA, jako příklad použití důkazů k zobrazení událostí, výstrah a jakýchkoli záložek přidružených k určitému incidentu v podokně náhledu incidentu.
dotazovací jazyk Kusto (KQL), které můžete použít k odesílání požadavků jen pro čtení do databáze Log Analytics za účelem zpracování dat a vrácení výsledků. KQL se také používá v jiných služby Microsoft, jako je Microsoft Defender for Endpoint a Přehledy aplikací.

Porovnání terminologie pravidel

Tato tabulka vám pomůže objasnit koncept pravidla v Microsoft Sentinelu ve srovnání s Splunkem.

	Splunk	Microsoft Sentinel
Typ pravidla	•Naplánované •Real-time	• Naplánovaný dotaz •Fusion • Zabezpečení Microsoftu • Analýza chování strojového Učení (ML)
Kritéria	Definice v SPL	Definice v KQL
Podmínka triggeru	• Počet výsledků • Počet hostitelů • Počet zdrojů •Vlastní	Prahová hodnota: Počet výsledků dotazu
Akce	• Přidání do aktivovaných upozornění • Událost protokolu • Výsledky výstupu pro vyhledání • A další	• Vytvoření upozornění nebo incidentu • Integruje se s Logic Apps

Mapování a porovnání ukázek pravidel

Pomocí těchto ukázek můžete porovnat a mapovat pravidla z Splunku na Microsoft Sentinel v různých scénářích.

Běžné vyhledávací příkazy

Příkaz SPL	Popis	Operátor KQL	Příklad KQL
`chart/ timechart`	Vrátí výsledky v tabulkovém výstupu pro grafy časových řad.	render – operátor	`… \| render timechart`
`dedup`	Odebere následné výsledky, které odpovídají zadanému kritériu.	• jedinečné • shrnutí	`… \| summarize by Computer, EventID`
`eval`	Vypočítá výraz. Přečtěte si o běžných valovacích příkazech.	Rozšířit	`T \| extend duration = endTime - startTime`
`fields`	Odebere pole z výsledků hledání.	• projekt • projektový pobyt	`T \| project cost=price*quantity, price`
`head/tail`	Vrátí první nebo poslední N výsledky.	Top	`T \| top 5 by Name desc nulls last`
`lookup`	Přidá hodnoty polí z externího zdroje.	• externaldata • vyhledávání	Příklad KQL
`rename`	Přejmenuje pole. Pomocí zástupných znaků můžete zadat více polí.	přejmenování projektu	`T \| project-rename new_column_name = column_name`
`rex`	Určuje názvy skupin pomocí regulárních výrazů k extrakci polí.	odpovídá regulárnímu výrazu	`… \| where field matches regex "^addr.*"`
`search`	Filtruje výsledky na výsledky, které odpovídají hledanému výrazu.	search	`search "X"`
`sort`	Seřadí výsledky hledání podle zadaných polí.	sort	`T \| sort by strlen(country) asc, price desc`
`stats`	Poskytuje statistiky, volitelně seskupené podle polí. Přečtěte si další informace o běžných příkazech statistik.	Sumarizovat	Příklad KQL
`mstats`	Podobně jako statistiky se používají u metrik místo událostí.	Sumarizovat	Příklad KQL
`table`	Určuje, která pole se mají uchovávat v sadě výsledků, a uchovává data v tabulkovém formátu.	Projektu	`T \| project columnA, columnB`
`top/rare`	Zobrazí nejběžnější hodnoty pole.	Top	`T \| top 5 by Name desc nulls last`
`transaction`	Seskupí výsledky hledání do transakcí. Příklad SPL	Příklad: row_window_session	Příklad KQL
`eventstats`	Vygeneruje souhrnné statistiky z polí ve vašich událostech a uloží tyto statistiky do nového pole. Příklad SPL	Příklady: • spojení • make_list • mv-expand	Příklad KQL
`streamstats`	Najděte kumulativní součet pole. Příklad SPL: `... \| streamstats sum(bytes) as bytes _ total \\| timechart`	row_cumsum	`...\\| serialize cs=row_cumsum(bytes)`
`anomalydetection`	Vyhledání anomálií v zadaném poli Příklad SPL	series_decompose_anomalies()	Příklad KQL
`where`	Filtruje výsledky hledání pomocí `eval` výrazů. Používá se k porovnání dvou různých polí.	Kde	`T \| where fruit=="apple"`

lookup command: KQL example

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

Příkaz statistiky: Příklad KQL

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

příkaz mstats: příklad KQL

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

transaction command: SPL example

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

transaction command: KQL example

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

Slouží row_window_session() k výpočtu počátečních hodnot relace pro sloupec v serializované sadě řádků.

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

eventstats command: SPL example

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

eventstats command: KQL example

Tady je příklad s příkazem join :

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

Tady je příklad s příkazem make_list :

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

příkaz anomalydetection: příklad SPL

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

příkaz anomalydetection: příklad 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)

Běžné příkazy pro hodnocení

Příkaz SPL	Popis	Příklad SPL	Příkaz KQL	Příklad KQL
`abs(X)`	Vrátí absolutní hodnotu X.	`abs(number)`	abs()	`abs(X)`
`case(X,"Y",…)`	Přebírá dvojice argumentů a `Y` argumentů`X`, kde `X` jsou argumenty logickými výrazy. Při vyhodnocení na `TRUE`vrátí argumenty odpovídající `Y` argument.	Příklad SPL	case	Příklad KQL
`ceil(X)`	Strop čísla X.	`ceil(1.9)`	ceiling()	`ceiling(1.9)`
`cidrmatch("X",Y)`	Identifikuje IP adresy, které patří do konkrétní podsítě.	`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,…)`	Vrátí první hodnotu, která nemá hodnotu null.	`coalesce(null(), "Returned val", null())`	coalesce()	`coalesce(tolong("not a number"),` `tolong("42"), 33) == 42`
`cos(X)`	Vypočítá kosinus X.	`n=cos(0)`	cos()	`cos(X)`
`exact(X)`	Vyhodnotí výraz X pomocí aritmetiky s plovoucí desetinnou čárkou s dvojitou přesností.	`exact(3.14*num)`	todecimal()	`todecimal(3.14*2)`
`exp(X)`	Vrátí eX.	`exp(3)`	exp()	`exp(3)`
`if(X,Y,Z)`	Pokud `X` se vyhodnotí jako `TRUE`, výsledek je druhý argument `Y`. Pokud `X` se vyhodnotí jako `FALSE`, výsledek se vyhodnotí jako třetí argument `Z`.	`if(error==200,` `"OK", "Error")`	iif()	Příklad KQL
`isbool(X)`	Vrátí `TRUE` , pokud `X` je logická hodnota.	`isbool(field)`	• iif() • gettype	`iif(gettype(X) =="bool","TRUE","FALSE")`
`isint(X)`	Vrátí `TRUE` , pokud `X` je celé číslo.	`isint(field)`	• iif() • gettype	Příklad KQL
`isnull(X)`	Vrátí `TRUE` hodnotu `X` null.	`isnull(field)`	isnull()	`isnull(field)`
`isstr(X)`	Vrátí `TRUE` , pokud `X` je řetězec.	`isstr(field)`	• iif() • gettype	Příklad KQL
`len(X)`	Tato funkce vrátí délku znaku řetězce `X`.	`len(field)`	strlen()	`strlen(field)`
`like(X,"y")`	Vrátí `TRUE` , pokud a pouze pokud `X` je jako vzor SQLite v `Y`.	`like(field, "addr%")`	• má • obsahuje • začíná s • odpovídá regulárnímu výrazu	Příklad KQL
`log(X,Y)`	Vrátí protokol prvního argumentu `X` pomocí druhého argumentu `Y` jako základu. Výchozí hodnota atributu `Y` je `10`.	`log(number,2)`	• protokol • log2 • log10	`log(X)` `log2(X)` `log10(X)`
`lower(X)`	Vrátí hodnotu malá písmena .`X`	`lower(username)`	Tolower	`tolower(username)`
`ltrim(X,Y)`	Vrátí `X` znaky v parametru `Y` oříznuté z levé strany. Výchozí výstup `Y` je mezery a tabulátory.	`ltrim(" ZZZabcZZ ", " Z")`	trim_start()	`trim_start(“ ZZZabcZZ”,” ZZZ”)`
`match(X,Y)`	Vrátí, pokud X odpovídá vzoru regulárního výrazu Y.	`match(field, "^\d{1,3}.\d$")`	odpovídá regulárnímu výrazu	`… \| where field matches regex @"^\d{1,3}.\d$")`
`max(X,…)`	Vrátí maximální hodnotu ve sloupci.	`max(delay, mydelay)`	• max() • arg_max()	`… \| summarize max(field)`
`md5(X)`	Vrátí hodnotu hash MD5 řetězcové hodnoty `X`.	`md5(field)`	hash_md5	`hash_md5("X")`
`min(X,…)`	Vrátí minimální hodnotu ve sloupci.	`min(delay, mydelay)`	• min_of() • min() • arg_min	Příklad KQL
`mvcount(X)`	Vrátí číslo (celkem) `X` hodnot.	`mvcount(multifield)`	Dcount	`…\| summarize dcount(X) by Y`
`mvfilter(X)`	Filtruje pole s více hodnotami na základě logického `X` výrazu.	`mvfilter(match(email, "net$"))`	mv-apply	Příklad KQL
`mvindex(X,Y,Z)`	Vrátí podmnožinu argumentu s `X` více hodnotami z počáteční pozice (založené na nule) `Y` na `Z` (volitelné).	`mvindex( multifield, 2)`	array_slice	`array_slice(arr, 1, 2)`
`mvjoin(X,Y)`	Při použití vícehodnotového pole `X` a oddělovače `Y`řetězců a spojí jednotlivé hodnoty `X` použití `Y`.	`mvjoin(address, ";")`	strcat_array	Příklad KQL
`now()`	Vrátí aktuální čas reprezentovaný v unixovém čase.	`now()`	now()	`now()` `now(-2d)`
`null()`	Nepřijímá argumenty a vrací .`NULL`	`null()`	null	`null`
`nullif(X,Y)`	Obsahuje dva argumenty a `Y`vrátí, `X` pokud jsou argumenty `X` odlišné. V opačném případě vrátí hodnotu `NULL`.	`nullif(fieldA, fieldB)`	Iif	`iif(fieldA==fieldB, null, fieldA)`
`random()`	Vrátí pseudonáhodné číslo mezi `0` hodnotami `2147483647`.	`random()`	rand()	`rand()`
`relative_ time(X,Y)`	Vzhledem k času epochy `X` a specifikátoru `Y`relativního času vrátí hodnotu času epochy použitého `Y` na `X`.	`relative_time(now(),"-1d@d")`	unixový čas	Příklad KQL
`replace(X,Y,Z)`	Vrátí řetězec vytvořený nahrazením řetězce `Z` pro každý výskyt řetězce `Y` regulárního výrazu v řetězci `X`.	Vrátí datum s přepnulými čísly měsíců a dnů. Například pro `4/30/2015` vstup je `30/4/2009`výstup: `replace(date, "^(\d{1,2})/ (\d{1,2})/", "\2/\1/")`	Replace()	Příklad KQL
`round(X,Y)`	Vrátí `X` zaokrouhlenou na počet desetinných míst určených `Y`hodnotou . Výchozí hodnota je zaokrouhlit na celé číslo.	`round(3.5)`	Kolo	`round(3.5)`
`rtrim(X,Y)`	Vrátí `X` znaky `Y` oříznuté z pravé strany. Pokud `Y` není zadáno, mezery a tabulátory se oříznou.	`rtrim(" ZZZZabcZZ ", " Z")`	trim_end()	`trim_end(@"[ Z]+",A)`
`searchmatch(X)`	Vrátí `TRUE` , pokud událost odpovídá hledanému řetězci `X`.	`searchmatch("foo AND bar")`	iif()	`iif(field has "X","Yes","No")`
`split(X,"Y")`	Vrátí `X` jako pole s více hodnotami rozdělené oddělovačem `Y`.	`split(address, ";")`	split()	`split(address, ";")`
`sqrt(X)`	Vrátí druhou odmocninu .`X`	`sqrt(9)`	sqrt()	`sqrt(9)`
`strftime(X,Y)`	Vrátí hodnotu `X` epochového času vykreslenou pomocí formátu určeného parametrem `Y`.	`strftime(_time, "%H:%M")`	format_datetime()	`format_datetime(time,'HH:mm')`
`strptime(X,Y)`	Vzhledem k času reprezentovaného řetězcem `X`vrátí hodnotu parsovanou z formátu `Y`.	`strptime(timeStr, "%H:%M")`	format_datetime()	Příklad KQL
`substr(X,Y,Z)`	Vrátí pole `X` podřetězdce od počáteční pozice (jedno) `Y` pro `Z` (volitelné) znaky.	`substr("string", 1, 3)`	substring()	`substring("string", 0, 3)`
`time()`	Vrátí hodinový čas s rozlišením mikrosekund.	`time()`	format_datetime()	Příklad KQL
`tonumber(X,Y)`	Převede vstupní řetězec `X` na číslo, kde `Y` (volitelná výchozí hodnota je `10`) definuje základ čísla, na který se má převést.	`tonumber("0A4",16)`	toint()	`toint("123")`
`tostring(X,Y)`	Popis	Příklad SPL	Tostring()	`tostring(123)`
`typeof(X)`	Vrátí řetězcovou reprezentaci typu pole.	`typeof(12)`	gettype()	`gettype(12)`
`urldecode(X)`	Vrátí dekódovanou adresu URL `X` .	Příklad SPL	url_decode	Příklad KQL

case(X;"Y",...) Příklad SPL

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

case(X;"Y",...) Příklad KQL

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

if(X;Y;Z) Příklad KQL

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

příklad isint(X) KQL

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

isstr(X) KQL example

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

like(X;"y") příklad

… | where field has "addr"

… | where field contains "addr"

… | where field startswith "addr"

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

min(X,...) Příklad KQL

min_of (expr_1, expr_2 ...)

…|summarize min(expr)

…| summarize arg_min(Price,*) by Product

Příklad Mvfilter(X) KQL

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

Příklad Mvjoin(X;Y) KQL

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

relativní čas(X;Y) příklad KQL

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

replace(X;Y;Z) Příklad KQL

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

Strptime(X;Y) Příklad KQL

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

Time() Příklad KQL

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

tostring(X;Y)

Vrátí hodnotu X pole jako řetězec.

Pokud je hodnota X čísla, X přeformátuje se na řetězcovou hodnotu.
Je-li X logická hodnota, X je přeformátována na TRUE nebo FALSE.
Pokud X je číslo, druhý argument Y je nepovinný a může být hex buď (převeden X na šestnáctkový), commas (formát X s čárkami a dvěma desetinnými místyX), nebo duration (převede z formátu času v sekundách na čitelný formát času: HH:MM:SS).

tostring(X;Y) SPL example

Tento příklad vrátí:

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

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

Příklad urldecode(X) SPL

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

Příklad běžných příkazů statistik KQL

Příkaz SPL	Popis	Příkaz KQL	Příklad KQL
`avg(X)`	Vrátí průměr hodnot pole `X`.	avg()	`avg(X)`
`count(X)`	Vrátí počet výskytů pole `X`. Chcete-li označit konkrétní hodnotu pole, která se má shodovat, naformátovat `X` jako `eval(field="value")`.	count()	`summarize count()`
`dc(X)`	Vrátí počet jedinečných hodnot pole `X`.	dcount()	`…\\| summarize countries=dcount(country) by continent`
`earliest(X)`	Vrátí chronologicky nejstarší zobrazenou hodnotu `X`.	arg_min()	`… \\| summarize arg_min(TimeGenerated, *) by X`
`latest(X)`	Vrátí chronologicky poslední zobrazenou `X`hodnotu .	arg_max()	`… \\| summarize arg_max(TimeGenerated, *) by X`
`max(X)`	Vrátí maximální hodnotu pole `X`. Pokud jsou hodnoty `X` nečíselné, maximální hodnota se najde v abecedním pořadí.	max()	`…\\| summarize max(X)`
`median(X)`	Vrátí střední hodnotu pole `X`.	percentil()	`…\\| summarize percentile(X, 50)`
`min(X)`	Vrátí minimální hodnotu pole `X`. Pokud jsou hodnoty `X` nečíselné, minimální hodnota se najde v abecedním pořadí.	min()	`…\\| summarize min(X)`
`mode(X)`	Vrátí nejčastější hodnotu pole `X`.	top-hitters()	`…\\| top-hitters 1 of Y by X`
`perc(Y)`	Vrátí hodnotu percentilu `X` pole `Y`. Například `perc5(total)` vrátí pátou percentilovou hodnotu pole `total`.	percentil()	`…\\| summarize percentile(Y, 5)`
`range(X)`	Vrátí rozdíl mezi maximální a minimální hodnotou pole `X`.	range()	`range(1, 3)`
`stdev(X)`	Vrátí směrodatnou odchylku výběru pole `X`.	Stdev	`stdev()`
`stdevp(X)`	Vrátí směrodatnou odchylku základního souboru pole `X`.	stdevp()	`stdevp()`
`sum(X)`	Vrátí součet hodnot pole `X`.	sum()	`sum(X)`
`sumsq(X)`	Vrátí součet čtverců hodnot pole `X`.
`values(X)`	Vrátí seznam všech jedinečných hodnot pole `X` jako položku s více hodnotami. Pořadí hodnot je abecední.	make_set()	`…\\| summarize r = make_set(X)`
`var(X)`	Vrátí vzorek rozptylu pole `X`.	Odchylka	`variance(X)`

Další kroky

V tomto článku jste zjistili, jak namapovat pravidla migrace z Splunku na Microsoft Sentinel.

Migrace automatizace SOAR