Kommandot `tail` i Linux är ett verktyg för att visa data från slutet av en fil. Det kan dessutom observera och visa uppdateringar i realtid när data läggs till i filen. Vi kommer nu att gå igenom hur man använder detta kommando.
`Systemd` och `tail`?
Vanligtvis läggs ny information till i slutet av en fil, vilket gör `tail` till ett praktiskt sätt att snabbt granska de senaste tilläggen. Det är också kapabelt att övervaka en fil och presentera nya textinslag som sker i filen. Detta gör det till ett ovärderligt instrument för att hålla koll på loggfiler.
Många nutida Linux-distributioner använder sig av `systemd`, en system- och tjänstehanterare. Denna process är den första som startar (med process-ID 1) och fungerar som förälder till alla andra processer. Tidigare sköttes denna roll av det äldre init-systemet.
Med denna förändring kom även ett nytt format för systemloggfiler. Istället för att lagras som vanlig text, registreras de i binärt format under `systemd`. För att läsa dessa loggfiler, måste du använda verktyget `journalctl`. Kommandot `tail` fungerar med vanliga textformat och kan inte hantera binära filer. Innebär detta att `tail` är ett föråldrat verktyg? Har det fortfarande något att erbjuda?
Absolut! `Tail` kan göra mer än att bara visa uppdateringar i realtid. Dessutom finns det fortfarande många loggfiler som inte är systemgenererade och som fortfarande skapas som vanliga textfiler. Exempelvis har loggfiler som skapas av applikationer inte genomgått någon formatförändring.
Använda `tail`
Om du skickar ett filnamn till `tail` kommer det att visa de sista tio raderna i filen. Exempelfilerna vi använder är listor med sorterade ord. Varje rad är numrerad för att göra det enklare att följa exemplen och se hur de olika alternativen påverkar utmatningen.
tail word-list.txt
För att se ett specifikt antal rader, använd alternativet `-n` (antal rader):
tail -n 15 word-list.txt
Det är möjligt att utelämna `-n` och endast använda ett bindestreck `-` följt av numret. Se till att det inte finns något mellanrum emellan. Tekniskt sett är detta en föråldrad kommandoform, men den finns fortfarande dokumenterad i manualen och fungerar.
tail -12 word-list.txt
Använda `tail` med flera filer
Du kan använda `tail` för att hantera flera filer samtidigt. Ange bara filnamnen i kommandoraden:
tail -n 4 list-1.txt list-2.txt list-3.txt
En liten rubrik visas för varje fil så att du kan se vilken fil raderna tillhör.
Visa rader från början av en fil
Genom att använda modifieraren `+` (räkna från början) kan `tail` visa rader från början av en fil med start vid ett angivet radnummer. Om filen är mycket lång och du väljer ett radnummer nära början, kan du få mycket information utskriven i terminalen. Om detta sker, är det lämpligt att skicka utdata från `tail` till `less`.
tail +440 list-1.txt
Du kan nu navigera genom texten på ett kontrollerat sätt.
Eftersom den här filen innehåller 20445 rader, är detta kommando likvärdigt med att använda alternativet `-6`:
tail +20440 list-1.txt
Använda bytes med `tail`
Du kan instruera `tail` att använda byte-förskjutningar istället för rader genom att använda alternativet `-c` (bytes). Detta är användbart om du har en textfil som är formaterad till poster med en jämn storlek. Kom ihåg att en ny rad räknas som en byte. Följande kommando visar de sista 93 byten i filen:
tail -c 93 list-2.txt
Du kan kombinera alternativet `-c` (bytes) med modifieraren `+` (räkna från början) och ange en offset i byte från början av filen:
tail -c +351053 list-e.txt
`Piping` till `tail`
Tidigare skickade vi utdata från `tail` till `less`. Vi kan även skicka utdata från andra kommandon till `tail`.
För att identifiera de fem filer eller mappar med de äldsta modifieringstiderna, kan du använda alternativet `-t` (sortera efter modifieringstid) med `ls` och sedan skicka utdata till `tail`.
ls -tl | tail -5
Kommandot `head` visar textrader från början av en fil. Vi kan kombinera detta med `tail` för att extrahera en specifik del av filen. Här använder vi `head` för att extrahera de 200 första raderna från en fil. Detta skickas sedan till `tail`, som tar ut de sista tio raderna. Resultatet blir raderna 191 till och med 200, vilket motsvarar de sista tio raderna av de första 200 raderna:
head -n 200 list-1.txt | tail -10
Följande kommando listar de fem processer som använder mest minne.
ps aux | sort -nk +4 | tail -5
Låt oss bryta ner det.
Kommandot `ps` visar information om pågående processer. Alternativen som används är:
`a`: Listar alla processer, inte bara de för den aktuella användaren.
`u`: Visar användarorienterad utdata.
`x`: Listar alla processer, även de som inte körs i en TTY.
Kommandot `sort` sorterar utdata från `ps`. Alternativen som används med `sort` är:
`n`: Sortera numeriskt.
`k +4`: Sortera efter den fjärde kolumnen.
Kommandot `tail -5` visar de sista fem processerna från den sorterade utmatningen, vilket motsvarar de fem processer som använder mest minne.
Använda `tail` för att följa filer i realtid
Att övervaka nya textinslag som läggs till i en fil, oftast en loggfil, är enkelt med `tail`. Ange filnamnet i kommandoraden och använd alternativet `-f` (följ).
tail -f geek-1.log
Varje gång en ny loggpost läggs till i loggfilen uppdaterar `tail` visningen i terminalen.
Du kan förfina utdata så att det bara inkluderar rader som är av intresse. Här använder vi `grep` för att visa endast rader som innehåller ordet ”genomsnittlig”:
tail -f geek-1.log | grep average
För att följa förändringar i två eller fler filer, ange filnamnen i kommandoraden:
tail -f -n 5 geek-1.log geek-2.log
Varje post märks med en rubrik som visar vilken fil texten kommer ifrån.
Visningen uppdateras varje gång en ny post läggs till i en följd fil. För att ange uppdateringsperioden använder du alternativet `-s` (sömnperiod). Det instruerar `tail` att vänta ett visst antal sekunder, fem i detta exempel, mellan filkontrollerna.
tail -f -s 5 geek-1.log
Även om du inte kan se det genom att titta på en skärmdump, sker uppdateringarna av filen en gång varannan sekund. De nya filposterna visas i terminalfönstret en gång var femte sekund.
När du följer texttillägg till fler än en fil kan du dölja rubrikerna som anger vilken loggfil texten kommer ifrån. Använd alternativet `-q` (tyst) för att åstadkomma detta:
tail -f -q geek-1.log geek-2.log
Utdata från filerna visas i en sömlös textblandning. Det finns ingen indikation på vilken loggfil varje post kommer ifrån.
`tail` har fortfarande ett värde
Även om åtkomst till systemloggfiler nu hanteras av `journalctl`, har `tail` fortfarande mycket att erbjuda. Detta gäller särskilt när det används i kombination med andra kommandon, genom att skicka utdata till eller från `tail`.
`systemd` kan ha förändrat spelplanen, men det finns fortfarande utrymme för traditionella verktyg som följer Unix-filosofin att göra en sak och göra det bra.