DevOps-bootcamp · Oppitunti

Lokien seuraaminen reaaliajassa ja suoratoistohälytykset

Seuraa ja suodata reaaliaikaisia lokivirtoja, jotta hälytykset laukeavat heti virhemallien ilmaantuessa.

Oppitunti 2/413 vaihetta

Lokien seuraaminen reaaliajassa ja suoratoistohälytykset on ilmainen DevOps-bootcamp-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu DevOps-bootcamp-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. DevOps-bootcamp-kurssilla on yhteensä 4 oppituntia.

Miksi lokien reaaliaikainen seuranta on tärkeää

Tuotantojärjestelmissä lokitiedostot kasvavat jatkuvasti. Jos odotatte ongelman ilmoittamista ennen lokien tutkimista, käyttökatko on jo ehtinyt aiheuttaa kustannuksia. Lokien reaaliaikainen seuranta mahdollistaa tapahtumien tarkkailun heti niiden kirjoittamisen hetkellä, joten voitte reagoida välittömästi vikoihin, tietoturvatapahtumiin ja suorituskyvyn heikkenemiseen.

Verkkopalvelimet kirjoittavat yhden rivin pyyntöä kohden — virheet näkyvät heti
Sovelluspalvelut kirjaavat pinonjäljet heti poikkeuksen syntyessä
Todennusjärjestelmät tallentavat epäonnistuneet kirjautumisyritykset reaaliajassa

Unix-järjestelmien perustyökalu tähän on tail -f. Yhdistämällä sen suodatus- ja hälytystyökaluihin voitte muuttaa raakalogivirrat hyödynnettäviksi signaaleiksi.

tail -f: lokin reaaliaikainen seuranta

tail -f (follow) pitää tiedoston avoinna ja tulostaa uudet rivit sitä mukaa, kun niitä lisätään. Se on yksinkertaisin ja lähes kaikkialla saatavilla oleva reaaliaikaisen lokiseurannan työkalu.

Yleisiä käyttötapoja:

tail -f /var/log/syslog — seuraa järjestelmälokia
tail -n 50 -f app.log — näyttää viimeiset 50 riviä ja jatkaa sitten seurantaa
tail -f /var/log/nginx/access.log — seuraa nginxin pyyntöjä reaaliajassa

Lopeta painamalla Ctrl+C. Prosessi pysyy liitettynä, kunnes peruutatte sen tai pääte sulkeutuu.

#!/usr/bin/env bash
# Simulate a live log and follow it
LOGFILE='/tmp/demo_app.log'

# Write a header
echo '[INFO] Application started' >> "$LOGFILE"

# In a real scenario you would run:
# tail -f "$LOGFILE"
# Below we demonstrate tail showing the last 3 lines then exit
tail -n 3 "$LOGFILE"

tail -F: lokikierron kestävä seuranta

Monet järjestelmät kierrättävät lokitiedostoja keskiyöllä tai niiden saavuttaessa kokorajan. Tällöin alkuperäinen tiedosto nimetään uudelleen (esimerkiksi app.log.1) ja uusi app.log luodaan. Komennolla tail -f jatkatte huomaamatta vanhan, uudelleennimetyn tiedoston lukemista ja menetätte kaiken uuden tulosteen.

tail -F (iso F) ratkaisee ongelman tarkkailemalla tiedostonimeä, ei tiedostokuvaajaa. Kun tiedosto katoaa ja ilmestyy uudelleen, tail -F avaa sen automaattisesti uudelleen ja jatkaa seurantaa.

Suosikaa tuotantoskripteissä aina tail -F-komentoa komennon tail -f sijaan
Toimii logrotate- ja newsyslog-työkalujen sekä tiedostoja kierrättävien Docker-lokiohjainten kanssa

# Follow nginx access log, surviving log rotation
tail -F /var/log/nginx/access.log

# Follow multiple files simultaneously
tail -F /var/log/nginx/access.log /var/log/nginx/error.log

Virran suodattaminen grep-komennolla

Kiireisen lokin seuraaminen sellaisenaan on kuormittavaa — aktiivinen verkkopalvelin voi kirjoittaa satoja rivejä sekunnissa. Ohjatkaa komennon tail -F tuloste grep-komennolle, jotta voitte eristää vain haluamanne kuviot.

Suoratoistossa käytettävän grep-komennon tärkeät valitsimet:

--line-buffered — tyhjentää puskurin jokaisen täsmäävän rivin jälkeen sen sijaan, että tuloste puskuroitaisiin; pakollinen putkissa, muuten tuloste viivästyy tai katoaa
-i — kirjainkoosta riippumaton haku
-E — laajennetut säännölliset lausekkeet vaihtoehtojen esittämiseen (error|warn|crit)
-v — käänteinen haku (sulkee rivit pois)

# Show only ERROR and WARN lines from a live application log
tail -F /var/log/myapp/app.log | grep --line-buffered -Ei 'error|warn|critical'

# Follow nginx and exclude health-check requests
tail -F /var/log/nginx/access.log | grep --line-buffered -v '/health'

Aikaleimojen ja asiayhteyden lisääminen awk-komennolla

Lokiriveiltä puuttuu joskus vian selvittämisessä hyödyllistä asiayhteyttä. Voitte täydentää virtaa reaaliajassa awk-komennolla — lisätä paikallisen aikaleiman, poimia kenttiä tai muotoilla tulosteen uudelleen luettavampaan muotoon.

awk toimii putkeen ohjattuna myös suoratoistotilassa (rivipuskuroituna), joten sitä on turvallista käyttää reaaliaikaisissa putkissa ilman lisävalitsimia.

# Prepend a reception timestamp to every ERROR line
tail -F /var/log/myapp/app.log | \
  grep --line-buffered -i 'error' | \
  awk '{ print strftime("[%Y-%m-%d %H:%M:%S]"), $0; fflush() }'

# Extract HTTP status code (field 9) and URL (field 7) from nginx combined log
tail -F /var/log/nginx/access.log | \
  awk '{ print $9, $7; fflush() }' | \
  grep --line-buffered '^5'

Hälytysten lähettäminen Slack Webhookeilla

Suodatus on vasta puolet työstä — kun havaitsette virhekuvion, teidän on ilmoitettava jollekulle. Slackin saapuvan webhookin avulla voitte lähettää viestin kanavalle yhdellä curl-kutsulla ilman Slack SDK:ta tai muita tunnistetietoja kuin webhook-URL-osoitteen.

Malli on seuraava: suodattakaa virta ja lähettäkää jokaisesta täsmäävästä rivistä HTTP POST -pyyntö.

#!/usr/bin/env bash
# Real-time alert: send every ERROR line to a Slack channel
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'

tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
  payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
  curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
    -d "$payload" "$WEBHOOK_URL"
done

Hälytysten nopeusrajoitus kohinan estämiseksi

Lokimyrsky voi tuottaa tuhansia virherivejä minuutissa. Yhden Slack-viestin lähettäminen jokaisesta rivistä täyttää kanavan ja aiheuttaa hälytysväsymystä. Tarvitsette nopeusrajoituksen — lähettäkää hälytys ja estäkää sitten uudet ilmoitukset jäähdytysjakson ajaksi.

Tämä onnistuu yksinkertaisella aikaleimatiedostolla: tallentakaa viimeksi lähetetyn hälytyksen ajankohta ja ohittakaa hälytys, jos jäähdytysaika ei ole vielä kulunut.

#!/usr/bin/env bash
# Alert on ERROR lines but no more than once every 60 seconds
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
COOLDOWN=60
LAST_ALERT_FILE='/tmp/last_alert_ts'

tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
  now=$(date +%s)
  last=0
  [ -f "$LAST_ALERT_FILE" ] && last=$(cat "$LAST_ALERT_FILE")

  if (( now - last >= COOLDOWN )); then
    echo "$now" > "$LAST_ALERT_FILE"
    payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
    curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
      -d "$payload" "$WEBHOOK_URL"
    echo "[$(date)] Alert sent: $line"
  else
    echo "[$(date)] Suppressed (cooldown): $line"
  fi
done

Virhepiikkien laskeminen liukuvalla ikkunalla

Yksittäinen virherivi ei aina ole merkittävä — mutta 20 virhettä 30 sekunnissa on vakava ongelma. Liukuvaan ikkunaan perustuvan laskurin avulla voitte käynnistää hälytykset vain, kun virhetiheyden kynnysarvo ylittyy, mikä vähentää vääriä positiivisia havaintoja.

Tekniikassa kunkin täsmäävän tapahtuman epoch-aikaleima tallennetaan väliaikaiseen tiedostoon, minkä jälkeen ikkunan sisälle osuvien tapahtumien määrä lasketaan ennen päätöstä hälyttää.

#!/usr/bin/env bash
# Alert when more than 10 errors occur within any 60-second window
LOGFILE='/var/log/myapp/app.log'
WINDOW=60
THRESHOLD=10
TS_FILE='/tmp/error_timestamps'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'

tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
  now=$(date +%s)
  echo "$now" >> "$TS_FILE"

  # Keep only timestamps within the window
  cutoff=$(( now - WINDOW ))
  tmp=$(mktemp)
  awk -v c="$cutoff" '$1 > c' "$TS_FILE" > "$tmp" && mv "$tmp" "$TS_FILE"

  count=$(wc -l < "$TS_FILE")
  if (( count > THRESHOLD )); then
    msg="*[BURST ALERT]* ${count} errors in ${WINDOW}s — last: ${line}"
    curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
      -d "{\"text\":\"$msg\"}" "$WEBHOOK_URL"
    # Clear to avoid re-alerting until next burst
    > "$TS_FILE"
  fi
done

journalctl -f: systemd-journalien seuranta

Nykyajan Linux-järjestelmissä (RHEL, Ubuntu 20.04+, Debian 10+) palvelut kirjoittavat systemd-journaliin tavallisten tekstitiedostojen sijaan. journalctl -f vastaa journalille komentoa tail -F.

Hyödyllisiä valitsimia:

-u myapp.service — seuraa vain tiettyä yksikköä
-p err — suodata prioriteetin mukaan (emerg, alert, crit, err, warning, notice, info, debug)
--since '5 min ago' — aloita suhteellisesta ajankohdasta
-o json — tulosta jäsenneltyä JSON-muotoa koneellista käsittelyä varten

# Follow only error-and-above entries for nginx
journalctl -f -u nginx.service -p err

# Stream journal as JSON and extract MESSAGE field with jq
journalctl -f -u myapp.service -o json | \
  jq --unbuffered -r 'select(.PRIORITY <= "3") | .MESSAGE'

multitail ja värikoodattu usean lähteen seuranta

Kun tarvitsette useiden lokilähteiden samanaikaista seurantaa, multitail jakaa päätteen ruutuihin — jokainen ruutu seuraa eri tiedostoa tai komentoa — ja voi haluttaessa käyttää kuvioihin perustuvaa värikoodausta.

Jos multitail ei ole asennettuna, kevyt, puhtaasti Bashiin perustuva vaihtoehto on lisätä kunkin virran eteen lähteen nimi ja yhdistää virrat yhdeksi näkymäksi.

# multitail: watch nginx access + error + app log in split panes
# (requires: apt install multitail  or  brew install multitail)
multitail /var/log/nginx/access.log /var/log/nginx/error.log /var/log/myapp/app.log

# Pure-Bash alternative — merge three streams with labeled prefixes
(
  tail -F /var/log/nginx/access.log | sed --unbuffered 's/^/[nginx-access] /' &
  tail -F /var/log/nginx/error.log  | sed --unbuffered 's/^/[nginx-error]  /' &
  tail -F /var/log/myapp/app.log    | sed --unbuffered 's/^/[myapp]        /' &
  wait
)

Itsenäisen hälytystaustaprosessin rakentaminen

Kun kaikki tämän oppitunnin aiheet yhdistetään, tuotantokelpoinen hälytystaustaprosessi sisältää seuraavat ominaisuudet:

Seuraa lokitiedostoa luotettavasti komennolla tail -F
Suodattaa kriittiset kuviot puskuroivalla grep-komennolla
Rajoittaa ilmoitusten määrää hälytysväsymyksen välttämiseksi
Kirjaa oman toimintansa, jotta voitte tarkastaa lähetetyt ilmoitukset
Suoritetaan taustaprosessina systemd:n tai valvontaohjelman hallinnoimana

Alla oleva skripti on minimaalinen mutta täydellinen taustaprosessi, jonka voitte sijoittaa hakemistoon /usr/local/bin/ ja jota voitte hallita systemd:llä.

#!/usr/bin/env bash
# log_alert_daemon.sh — tail a log and fire Slack alerts with cooldown
set -euo pipefail

LOGFILE=${1:-'/var/log/myapp/app.log'}
PATTERN=${2:-'error|critical|fatal'}
WEBHOOK_URL=${SLACK_WEBHOOK_URL:?'Set SLACK_WEBHOOK_URL env var'}
COOLDOWN=${ALERT_COOLDOWN:-120}
DAEMON_LOG='/var/log/log_alert_daemon.log'
LAST_SENT_FILE='/tmp/log_alert_last_sent'

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$DAEMON_LOG"; }

log "Starting alert daemon: watching $LOGFILE for pattern: $PATTERN"

tail -F "$LOGFILE" | grep --line-buffered -Ei "$PATTERN" | while IFS= read -r line; do
  now=$(date +%s)
  last=0
  [ -f "$LAST_SENT_FILE" ] && last=$(cat "$LAST_SENT_FILE")

  if (( now - last >= COOLDOWN )); then
    echo "$now" > "$LAST_SENT_FILE"
    msg=$(printf '{"text":"*[ALERT]* %s\n%s"}' "$(hostname)" "$line")
    if curl -s -o /dev/null -w '%{http_code}' -X POST \
         -H 'Content-Type: application/json' -d "$msg" "$WEBHOOK_URL" | grep -q '^200$'; then
      log "Alert sent: $line"
    else
      log "Alert FAILED to send: $line"
    fi
  else
    log "Suppressed (cooldown ${COOLDOWN}s): $line"
  fi
done

Tietotesti: lokien suoratoistoputket

Testatkaa ymmärrystänne lokien reaaliaikaisesta seurannasta ja suoratoistohälytyksistä.

Bash-putki seuraa lokitiedostoa ja lähettää Slack-hälytyksen jokaisesta täsmäävästä rivistä. Lokimyrskyn aikana 3 000 virheriviä kirjoitetaan 10 sekunnissa. Mikä yksittäinen muutos estää parhaiten skriptiä tulvittamasta Slack-kanavaa 3 000 viestillä?

Vastaa interaktiivisessa oppitunnissa

Oppitunnin kertaus: lokien reaaliaikainen seuranta ja suoratoistohälytykset

Tässä oppitunnissa rakensitte reaaliaikaisen lokien observointiputken alusta alkaen:

tail -F seuraa lokitiedostoa nimen perusteella ja kestää lokikierron — suosikaa sitä tuotannossa aina komennon tail -f sijaan
grep --line-buffered suodattaa reaaliaikaista virtaa lisäämättä viivettä; lisätkää tämä valitsin aina putkeen ohjattuihin grep-komentoihin
awk ja fflush() täydentää jokaisen rivin aikaleimoilla tai poimituilla kentillä suoratoistoon sopivalla tavalla
Slack-webhookit curl-komennolla toimittavat hälytykset yhdellä HTTP POST -pyynnöllä — SDK:ta ei tarvita
Jäähdytystiedostot estävät hälytysväsymystä lokimyrskyjen aikana pakottamalla ilmoitusten välille vähimmäisvälin
Liukuvan ikkunan laskurit havaitsevat virhepiikit (tiheyteen perustuva hälytys) sen sijaan, että reagoisivat jokaiseen yksittäiseen riviin
journalctl -f on systemd:n oma vastine komennolle tail -F, ja siinä on sisäänrakennettu prioriteettisuodatus sekä JSON-tuloste
Itsenäinen hälytystaustaprosessiskripti yhdistää kaikki nämä mallit, ja sitä voidaan hallita systemd:llä tuotantovarmuuden takaamiseksi

Näistä peruspalikoista muodostuu minkä tahansa mukautetun observointiputken perusta — ulkopuolista agenttia ei tarvita.

Aloita maksutta

Opi DevOps-bootcamp tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 142
Oppitunnit: 568

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Lokien seuraaminen reaaliajassa ja suoratoistohälytykset” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa DevOps-bootcamp-oppimispolun 3 oppituntia, myös oppitunnin “Lokien seuraaminen reaaliajassa ja suoratoistohälytykset”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. DevOps-bootcamp-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Lokien seuraaminen reaaliajassa ja suoratoistohälytykset”?

Seuraa ja suodata reaaliaikaisia lokivirtoja, jotta hälytykset laukeavat heti virhemallien ilmaantuessa. Harjoittelet DevOps-bootcamp-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni DevOps-bootcamp-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin DevOps-bootcamp-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Lokien seuraaminen reaaliajassa ja suoratoistohälytykset”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä DevOps-bootcamp-oppitunnilla?

Kyllä. Jokainen DevOps-bootcamp-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Web- ja sovelluslokien jäsentäminen suuressa mittakaavassa
Lokien seuraaminen reaaliajassa ja suoratoistohälytykset
journaldin kyselyt journalctlillä skripteissä
Mittareiden ja histogrammien laskeminen lokivirroista

← Takaisin: DevOps-bootcamp