PricingLoginStart free
Erlang OTP: programmering av distribuerte og feiltolerante systemer · leksjon

Integrasjon av målinger og overvåking

Implementer innsamling av målinger og integrer med eksterne overvåkingssystemer som Prometheus og Grafana for bedre systeminnsikt.

Leksjon 3 av 412 trinn

Integrasjon av målinger og overvåking er en gratis leksjon i Erlang OTP: programmering av distribuerte og feiltolerante systemer på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Erlang OTP: programmering av distribuerte og feiltolerante systemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Erlang OTP: programmering av distribuerte og feiltolerante systemer inneholder totalt 4 leksjoner.

Observerbarhet med metrikker

Velkommen til integrasjon av metrikker og overvåking! I moderne systemer er det avgjørende å forstå hva som skjer inne i applikasjonen. Dette kalles observerbarhet.

Observerbarhet bygger på tre grunnpilarer:

  • Logger: Registreringer av enkeltstående hendelser.
  • Spor: Forespørselsflyter fra ende til ende på tvers av tjenester.
  • Metrikker: Aggregerte numeriske datapunkter over tid.

Denne leksjonen fokuserer på metrikker, som gir en overordnet oversikt over systemets tilstand og ytelsestrender.

Hvorfor metrikker er viktige

Metrikker er numeriske målinger som samles inn med jevne mellomrom. De hjelper Dem med å svare på spørsmål som:

  • Hvor mange forespørsler per sekund håndterer tjenesten min?
  • Hva er den gjennomsnittlige svartiden?
  • Hvor mye minne bruker Erlang-VM-en min?
  • Oppstår det noen feil?

Ved å følge med på disse verdiene over tid kan De oppdage trender, identifisere flaskehalser og reagere proaktivt på problemer.

Typer metrikker

Det finnes flere vanlige typer metrikker:

  • Tellere: En enkelt verdi som bare øker (for eksempel totalt antall forespørsler eller feil).
  • Målere: En enkelt verdi som kan øke eller synke (for eksempel antall aktive brukere eller CPU-bruk).
  • Histogrammer: Eksempelobservasjoner, som forespørselsvarigheter, og opptelling av dem i konfigurerbare intervaller. De oppgir ofte også sum og antall.
  • Sammendrag: Ligner på histogrammer, men beregner konfigurerbare kvantiler (for eksempel latenstid ved 99-persentilen) på klientsiden.

Erlangs innebygde statistikk

Erlang tilbyr grunnleggende systemstatistikk direkte gjennom funksjonen erlang:statistics/1. Denne statistikken er nyttig for grunnleggende helsesjekker av VM-en.

De kan hente data som:

  • scheduler_wall_time: CPU-tid brukt av planleggerne.
  • io: Totalt antall I/O-operasjoner.
  • memory: Detaljer om minnebruk.

Selv om dette er nyttig, er det ofte ikke nok til å gi applikasjonsspesifikk innsikt. Vi trenger egendefinerte metrikker.

Egendefinert innsamling av metrikker

For applikasjonsspesifikke metrikker oppretter De ofte Deres egne. Et vanlig mønster er å bruke en gen_server-prosess til å administrere og oppdatere metrikverdier, slik at oppdateringene blir atomiske.

Prøv å kjøre dette eksempelet på en enkel teller som administreres av en gen_server:

-module(main).
-export([main/0]).

% --- simple_counter.erl (simplified for single file demo) ---
% A simple GenServer to maintain a counter
-behaviour(gen_server).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).

% GenServer callbacks
init([]) -> {ok, 0}.
handle_call(get_value, _From, State) -> {reply, State, State}.
handle_cast(increment, State) -> {noreply, State + 1}.
handle_cast(stop, _State) -> {stop, normal, ok}.
handle_info(_Info, State) -> {noreply, State}.
terminate(_Reason, _State) -> ok.
code_change(_OldVsn, State, _Extra) -> {ok, State}.

% Client API for our counter
start_counter() -> gen_server:start({local, my_counter}, ?MODULE, [], []).
increment_counter() -> gen_server:cast(my_counter, increment).
get_counter_value() -> gen_server:call(my_counter, get_value).
stop_counter() -> gen_server:cast(my_counter, stop).
% --- End simple_counter.erl ---

main() ->
    io:format("Starting a simple counter process...~n"),
    {ok, _Pid} = start_counter(),
    io:format("Initial counter value: ~p~n", [get_counter_value()]),

    increment_counter(),
    io:format("After 1 increment: ~p~n", [get_counter_value()]),

    increment_counter(),
    increment_counter(),
    io:format("After 3 increments: ~p~n", [get_counter_value()]),

    stop_counter(),
    io:format("Counter process stopped.~n").

Telemetry-biblioteket

For mer avansert og standardisert innsamling av metrikker i Erlang/Elixir brukes Telemetry-biblioteket mye. Det tilbyr en felles måte å sende ut hendelser fra applikasjonen på.

I stedet for å oppdatere en teller manuelt kan De:

  • Definere Telemetry-hendelser (for eksempel [:my_app, :request, :start] og [:my_app, :request, :stop]).
  • Koble behandlere til disse hendelsene for å behandle og aggregere metrikker.

Dette skiller utsendingen av hendelser fra innsamlingen av metrikker og gjør systemet mer fleksibelt.

Eksponering av metrikker

Når De har samlet inn metrikker, må De gjøre dem tilgjengelige for eksterne overvåkingssystemer. Dette innebærer vanligvis en eksportør.

En eksportør er en komponent (ofte en HTTP-server) som:

  • Henter gjeldende metrikverdier fra applikasjonen.
  • Formaterer dem i et standardformat (for eksempel Prometheus-tekstformat).
  • Tilgjengeliggjør dem via et HTTP-endepunkt (for eksempel /metrics).

Overvåkingssystemer «skraper» deretter dette endepunktet for å samle inn dataene.

Prometheus: Et pull-basert system

Prometheus er et populært overvåkingssystem med åpen kildekode. Det bruker en pull-modell: I stedet for at applikasjonen sender metrikker, «skraper» (henter) Prometheus regelmessig metrikker fra konfigurerte mål (applikasjonens eksportør-endepunkter).

Deretter lagrer systemet disse metrikkene som tidsseriedata, slik at De kan spørre etter og analysere trender over tid. Prometheus egner seg svært godt til drifts- og varslingsformål.

Prometheus-tekstformat

Erlang-applikasjoner integreres med Prometheus ved å eksponere et HTTP-endepunkt som leverer metrikker i Prometheus' tekstformat for eksponering. Dette er et enkelt, menneskelesbart format.

Her er et eksempel på hva Prometheus forventer å skrape:

# HELP my_app_requests_total Total number of requests processed.
# TYPE my_app_requests_total counter
my_app_requests_total 1234

# HELP my_app_active_users Current number of active users.
# TYPE my_app_active_users gauge
my_app_active_users 50

# HELP my_app_request_duration_seconds Request duration in seconds.
# TYPE my_app_request_duration_seconds histogram
my_app_request_duration_seconds_bucket{le="0.1"} 100
my_app_request_duration_seconds_bucket{le="0.5"} 250
my_app_request_duration_seconds_bucket{le="1.0"} 350
my_app_request_duration_seconds_bucket{le="+Inf"} 400
my_app_request_duration_seconds_sum 150.0
my_app_request_duration_seconds_count 400

Grafana for visualisering

Mens Prometheus lagrer og spør etter metrikker, er Grafana det foretrukne verktøyet for å visualisere dem. Grafana kobler seg til ulike datakilder (som Prometheus) og lar Dem bygge interaktive instrumentpaneler.

Med Grafana kan De:

  • Opprette grafer, diagrammer og tabeller.
  • Kombinere data fra flere metrikker.
  • Sette opp varsler basert på visuelle terskelverdier.
  • Dele instrumentpaneler med teamet.

Kontroll av overvåkingsintegrasjon

De har lært om innsamling og eksponering av metrikker, og om hvordan Prometheus og Grafana fungerer sammen. La oss teste forståelsen Deres!

Besvar den i den interaktive leksjonen

Oppsummering og neste steg

Godt jobbet! De har gått gjennom det grunnleggende om integrasjon av metrikker og overvåking:

  • Betydningen av observerbarhet og rollen til metrikker.
  • Hvordan samle inn egendefinerte metrikker i Erlang, blant annet ved å bruke gen_server-prosesser.
  • Konseptet med eksportører og Prometheus-tekstformatet.
  • Hvordan Prometheus fungerer som en pull-basert tidsseriedatabase.
  • Hvordan Grafana tilbyr kraftig visualisering av metrikkene Deres.

Med disse verktøyene kan De få dyp innsikt i Erlang-applikasjonene Deres!

Gratis å komme i gang

Lær deg Erlang med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
12
Leksjoner
48
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrasjon av målinger og overvåking» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Erlang OTP: programmering av distribuerte og feiltolerante systemer, inkludert «Integrasjon av målinger og overvåking», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Erlang OTP: programmering av distribuerte og feiltolerante systemer inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrasjon av målinger og overvåking»?

Implementer innsamling av målinger og integrer med eksterne overvåkingssystemer som Prometheus og Grafana for bedre systeminnsikt. Du øver på Erlang OTP: programmering av distribuerte og feiltolerante systemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Erlang OTP: programmering av distribuerte og feiltolerante systemer?

Ingen tidligere erfaring er nødvendig. Erlang OTP: programmering av distribuerte og feiltolerante systemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Integrasjon av målinger og overvåking»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Erlang OTP: programmering av distribuerte og feiltolerante systemer-leksjonen?

Ja. Alle Erlang OTP: programmering av distribuerte og feiltolerante systemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Teknikker for Erlang-profilering
  2. Sporing og feilsøking av distribuerte systemer
  3. Integrasjon av målinger og overvåking
  4. Minneanalyse og justering av søppelinnsamling
← Tilbake til Erlang OTP: programmering av distribuerte og feiltolerante systemer