IT-üzemeltetés — szolgáltatásmegbízhatóság Élő modell

Ügyeletes egy webszolgáltatásnál: egy terheléselosztó példányok flottája előtt, egy gyorsítótár egy adatbázis előtt, és 99,9 %-os rendelkezésre állási cél. Minden percben a modell tankönyvi képletekből számolja a sorbanállási késleltetést, az időtúllépéseket, a gyorsítótár-találatokat és az adatbázis-terhelést — és hogy mibe kerülnek a döntései.

Mit fog megtanulni

Szimulátor

Idő: 0 min
Kérések 1125 · Hibaarány 0,00% · p99 késleltetés 342 ms · Kiszolgáló példányok 10 (+0) · Gyorsítótár-találati arány 77% · Adatbázis-kihasználtság 19% · Hátralévő hibakeret (30 nap) 50,0%⇉1125 kérés/s▶▶▶▶▶▶▶▶▶▶······························▶ 10 · ⚙ 0 · 52% · p99 342 msFlotta kihasználtsága 52%Gyorsítótár-találati arány 77%Adatbázis-kihasználtság 19%⚠ 0,00% · 🔥 0,0×50%$ 4,00/h · Σ $0,00
  • Kiszolgáló példány
  • Induló példány
  • Példány a hibás buildön
  • Szabad hely
  • Beérkező kérések

Vezérlők

A flotta alsó határa. Emelése azonnal indít példányokat — ezek kiszolgálás előtt még kivárják az indítási késleltetést.

Célkövetés a kihasználtságon; nincs új kiskálázás, amíg példányok még indulnak. Ki = pontosan a minimum.

Alacsonyabb = nagyobb tartalék és több költség. A mért kihasználtság nem haladhatja meg a 100 %-ot, ezért a telített flotta csak lépésenként nő.

Hosszabb TTL = több találat, de a válaszok régebbiek lehetnek (átlagos életkor ≈ TTL/2).

6 percig tölti a forró kulcsokat (percenként a gyorsítótár +12 %-a) 600 többlet adatbázis-lekérdezés/s árán.

Az alacsony prioritású 30 % (előtöltés, kötegelt, robotok) azon része, amelyet a terheléselosztó „próbálja később” üzenettel elutasít.

A nehéz funkció kérésenként 20 ms CPU-t és egy adatbázis-lekérdezést ad. Ki = kíméletes leépülés.

Újratelepíti az utolsó jó buildet egy friss flottán (5 perc, kétszer számlázva), majd átkapcsolja a forgalmat. Újbóli megnyomása újraindítja az előkészítést; ha nincs rossz build élesben, csak pénzbe kerül.

Mutatók

Hibaarány
0,00%
normális
p99 késleltetés
342ms
normális
Hátralévő hibakeret (30 nap)
50,0%
normális
Flotta kihasználtsága
52%
normális
Égési ráta (1 óra)0,0 ×
Kérések1125 req/s
Kiszolgáló példányok10
Induló példányok0
Gyorsítótár-találati arány77 %
Adatbázis-kihasználtság19 %
Eldobott forgalom0 %
Flottaköltség4,00 $/h
Eddigi költség0,00 $
A gyorsítótárazott válaszok átlagos életkora30 s
Forgalom a hibás buildön0 %
Elérhető ajánlások100 %

Trend

Hibaarány: — %20,000,00

Válsághelyzeti forgatókönyvek

1. szint · Hibás kiadás

09:10-kor új build kerül ki. A hónap már így is nehéz volt: a hibakeretből csak 20 % maradt. A telepítés után percekkel megszólal az égésiráta-riasztás. Védje a keretet.

  • A hátralévő hibakeret a végén ≥ 18,5 %
  • Átlagos hibaarány ≤ 0,65 % a telepítés után
  • Flottaköltség ≤ 9,50 $

2. szint · Villámtömeg

A szolgáltatásra mutató link gyorsan terjed, és ma délelőtt valamikor forgalmi hullám várható — senki sem tudja, mikor és mekkora. Az új példányoknak ma 8 perc kell az induláshoz. Amikor megérkezik, tartsa alacsonyan a hibákat és a késleltetést anélkül, hogy pénzt égetne üresjáratú kapacitásra.

  • Átlagos hibaarány ≤ 0,2 %
  • Átlagos p99 késleltetés ≤ 400 ms
  • Átlagosan eldobott forgalom ≤ 5 %
  • Teljes költség ≤ 21 $
  • Ajánlások elérhetők az idő ≥ 85 %-ában

3. szint · Hideg gyorsítótár

Déli csúcsban egy karbantartó szkript kiüríti a teljes gyorsítótárat. Minden kérés most az adatbázishoz megy, amelyet a szokásos 85 %-os találati arányra méreteztek. Állítsa helyre a szolgáltatást az adatbázis túlterhelése nélkül.

  • Átlagos hibaarány ≤ 1,5 %
  • Az adatbázis-kihasználtság az első perc után soha nem több 90 %-nál
  • A gyorsítótárazott válaszok átlagos életkora átlagosan ≤ 90 s
  • Teljes költség ≤ 9 $
  • Ajánlások elérhetők az idő ≥ 80 %-ában
  • Átlagosan eldobott forgalom ≤ 5 %

Alap — a számok mögötti modell

A szimulátor által használt minden összefüggés a forrásával. A feltevésként jelölt állandók szemléltető kalibrációk.

A kérések napi görbét plusz zavarokat követnek; a percenkénti darabszám véletlen (Poisson, normális közelítés) kis lökésszerűséggel.
λ(t) = base × (1 + 0.25·sin(2π(t + clock − 6 h)/24 h)) × surge(t), clock = time of day at the start (peak at 12:00); count/min ≈ N(60λ, √(60λ)) × (1 + N(0, 0.02))[6]Feltevés: a worker-számok, a kiszolgálási idők, az adatbázis kapacitása, a gyorsítótár mérete, a feltöltési sebesség, az árak és a hibás build hibaaránya szemléltető értékek egy közepes webszolgáltatáshoz.
Erlang C: annak valószínűsége, hogy egy kérésnek szabad workerre kell várnia egy M/M/N rendszerben.
N = instances × 16 workers, a = λ·S; C(a, N) = B / (1 − (a/N)(1 − B)), B = Erlang B[3][6]
Várakozási idő farka: annak esélye, hogy t-nél tovább várunk, exponenciálisan csökken; a 2 s-os időtúllépésnél még várakozó kérések hibáznak. A kapacitás felett a többlet hibázik.
P(W > t) = C·e^(−(N/S − λ)·t); timeouts = P(W > 2 s); a ≥ N ⇒ failed share = 1 − N/a[3]
p99 késleltetés a kiszolgálási és várakozási idők kvantiliseiből.
p99 ≈ S·ln 100 + ln(C/0.01)/(N/S − λ) (service + waiting quantile, an approximation)[3][6]Közelítés: a kiszolgálási és várakozási kvantilisek összeadása nem az összegük pontos p99-e (kissé magas vagy alacsony lehet); a sort percenként belül állandósultnak tekintjük, mert a kérések ezredmásodpercekig tartanak.
Little-törvény: foglalt workerek = érkezési ráta × kiszolgálási idő.
busy workers L = λ·S ⇒ utilization = λ·S / N[4]
TTL-gyorsítótár: véletlen kéréseknél minden téves találat egy TTL-időszakot indít, amely alatt a kérések találnak.
hit = warm × rT/(1 + rT), r = λ / 20,000 objects; mean age of a cached answer ≈ T/2[5]
A gyorsítótár-tévesztések terhelik az adatbázist; sorbanállási késleltetése minden hozzá nyúló kérést lassít, ami az alkalmazás workereit is megtölti.
DB load = λ·q·(1 − hit); query time = 5 ms/(1 − ρ_db) (≤ 250 ms); S = S_app + (1 − hit)·q·query time[6]Feltevés: a worker-számok, a kiszolgálási idők, az adatbázis kapacitása, a gyorsítótár mérete, a feltöltési sebesség, az árak és a hibás build hibaaránya szemléltető értékek egy közepes webszolgáltatáshoz.
SLO és hibakeret: az égési ráta megmondja, hányszor gyorsabban fogy a keret a megengedettnél.
budget = 1 − SLO = 0.1 %; burn = error rate / 0.1 %; Δbudget per min = burn / 43,200; burn (1 h) = mean error rate over the last 60 min / 0.1 % (window pre-filled with the opening minute)[1][2]
Célkövető automatikus skálázó indítási késleltetéssel és lehűlési idővel.
desired = ⌈serving × utilization / target⌉ (utilization saturates at 100 %); new instances serve after the boot delay[6]Feltevés: a worker-számok, a kiszolgálási idők, az adatbázis kapacitása, a gyorsítótár mérete, a feltöltési sebesség, az árak és a hibás build hibaaránya szemléltető értékek egy közepes webszolgáltatáshoz.
A modell által használt egyéb üzemi állandók.
16 workers/instance · app time 50 ms (+20 ms and +1 query with the feature on) · 2 queries/request · DB 4,000 queries/s · 20,000 hot objects · cache refill τ = 30 min (slower while the DB is saturated) · warm-up job +12 %/min for 6 min, +600 queries/s · timeout 2 s · 30 % low-priority traffic · bad build +5 % errors, ×1.25 CPU · rollback 5 min · $0.40 per instance-hour · scale-in by ≤ 20 % of the fleet after 10 quiet minutes · up to 40 instancesFeltevés: a worker-számok, a kiszolgálási idők, az adatbázis kapacitása, a gyorsítótár mérete, a feltöltési sebesség, az árak és a hibás build hibaaránya szemléltető értékek egy közepes webszolgáltatáshoz.

Véletlenszerűség: magolt mulberry32 generátor; a használt eloszlások — egyenletes, exponenciális (inverz CDF), normális (Box–Muller), Poisson (Knuth). A mag látható és megosztható.

Források

  1. Site Reliability Engineering — Ch. 3 Embracing Risk (error budgets), Ch. 4 Service Level Objectives — Beyer, Jones, Petoff, Murphy (eds.), O'Reilly, 2016
  2. The Site Reliability Workbook — Ch. 5 Alerting on SLOs (burn rate; 14.4× over 1 h = 2 % of a 30-day budget) — Beyer, Murphy, Rensin, Kawahara, Thorne (eds.), O'Reilly, 2018
  3. Teletraffic Engineering Handbook — Erlang C formula; waiting-time distribution for M/M/n, FCFS — ITU-D Study Group 2 Question 16/2 (V. B. Iversen), 2005
  4. J. D. C. Little — A Proof for the Queuing Formula: L = λW — Operations Research 9(3):383–387, 1961
  5. J. Jung, A. W. Berger, H. Balakrishnan — Modeling TTL-based Internet Caches — IEEE INFOCOM 2003, 2003
  6. M. Harchol-Balter — Performance Modeling and Design of Computer Systems: Queueing Theory in Action (M/M/k, server farms, capacity provisioning) — Cambridge University Press, 2013

Kik csinálják ezt hivatásszerűen

Oktatási modell — nem működési döntésekhez. A valódi telephelyek minden állandót a saját berendezésükhöz és adataikhoz kalibrálnak.