# En oversikt over de viktigste Linux-kommandoene I likhet med de fleste moderne operativsystemer har også Linux et **skall** som du kan bruke til å styre systemet via **kommandolinjen**. Alle innstillingene du angir via det grafiske brukergrensesnittet (GUI), kan også gjøres via skallet. Vi viser deg de viktigste Linux-kommandoene og forklarer deres funksjon og anvendelse. ## Liste over de 50 viktigste Linux-kommandoene
Kommando Beskrivelse
sudo Kjør programmer med rettighetene til en annen bruker
ls Vis innholdet i katalogen
cd Navigering i katalogtreet
touch Opprett ny fil
mkdir Opprett ny katalog
rm Slett fil
rmdir Slett katalog
mv Flytt fil eller katalog
cp Kopier fil eller katalog
pwd Vis gjeldende posisjon i katalogtreet
zip Skriv filer til zip-arkiver
unzip Pakk ut filer fra zip-arkiver
ln Opprett symbolsk lenke
cat Kombiner filinnhold
grep Søk i tekstfiler
diff Finn forskjeller mellom tekstfiler
cmp Juster filer på byte-nivå
tar Skriv og pakk ut filer til tar-arkiver
echo Skriv ut streng til standardutdata
clear Tøm terminal
ssh Koble til en annen datamaskin via en *sikker shell*
wget Last ned fil direkte fra internett
ping Be om server og måle ventetid
ftp, sftp Overfør filer via (S)FTP
ip spørre om og konfigurere nettverksgrensesnitt
apt/pacman/yum Last ned og administrer programvarepakker
netstat Vis status for nettverksgrensesnitt
traceroute Spor datapakker
route Vis og rediger IP-rutetabeller
dig Be om DNS-informasjon
montere/demontere Integrere filsystemer (konfigurere/montere)
dd Kopier filer, partisjoner eller datamedier bit for bit
chmod Administrer tilgangsrettigheter
chown Administrer eierrettigheter
adduser Legg til/endre brukerkonto
passwd Opprett/rediger passord for brukerkontoer
groupadd Opprett brukergrupper
chattr Administrer filattributter
lsattr Vis filattributter
chgrp Administrer gruppetilhørighet for filer og kataloger
man Åpne brukerhåndboken
slå av, starte på nytt Slå av/start systemet på nytt
top Dynamisk prosessoverblikk
lscpu Vis prosessorinformasjon
lshw Vis maskinvareinformasjon
kill Stopp og avslutt prosess via PID
killall Stopp og avslutt prosesser via navn
nice Definer prosessprioriteter
pgrep Identifiser PID via søkeord
ps Vis liste over alle prosesser som kjører
### sudo-kommandoen i Linux [Linux-kommandoen `sudo`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-sudo/)(*substitute user do*) kan konfigurere programmet til å kjøre med en annen brukers rettigheter. Som regel må man oppgi et passord for dette. Kommandoen `sudo` ber alltid om passordet til brukerkontoen som skal påkalles. Hvis kommandoen angis uten brukernavn, blir superbrukeren root angitt som målbruker. ```bash sudo -u USERNAME PROGRAM CALL ``` ### ls-kommandoen i Linux Kommandolinjekommandoen \](t3://page?uid=25586) ls \[ ls` står for *«list»* og brukes til å vise innholdet i en katalog (navnene på alle filer og mapper som finnes i den angitte katalogen). Kommandoens syntaks er som følger: ```bash ls [OPTIONS] DIRECTORY ``` Hvis `ls` brukes uten å angi en katalog, viser kommandoen innholdet i den gjeldende katalogen. Ved hjelp av tilleggsalternativer kan du bestemme hvilken informasjon som skal vises og hvordan den skal vises. ### cd-kommandoen i Linux [Kommandoen `cd` i Linux](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-cd/) står for *«change directory*» og brukes til å navigere i katalogstrukturen. Kommandoens syntaks er som følger: ```bash cd [OPTION] DIRECTORY ``` Hvis det ikke angis noen målkatalog, går `cd` automatisk til brukerens hjemmekatalog. Hvis `cd` brukes med et minustegn etter seg (-), går den tilbake til forrige katalog. ### berøringskommando i Linux [Kommandolinjedirektivet `touch` i Linux](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-touch/) kan brukes til å endre tidsstemplene for tilgang og endring for filer. Hvis `touch` brukes på en fil som ikke eksisterer ennå, opprettes den automatisk, noe som betyr at kommandoen også kan brukes til å opprette tomme filer. Bruk `touch` etter følgende mønster: ```bash touch [OPTIONS] FILE ``` For å angi tidsstemplet for en fil til ønsket dato, bruk OPTION `-t` sammen med tidsinformasjonen i skjema `[YY]MMDDhhmm[.ss]`. Eksempel: ```bash touch -t 1703231037 file.txt ``` Tidsstemplene for tilgang og endring er nå satt til 23. mars 2017, kl. 10:37. Endringen kan begrenses til enten tilgangs- eller tidsstempler ved hjelp av alternativene `-a` og `-m`. Hvis kommandoen `touch` brukes uten alternativ `-t`, brukes det gjeldende tidsstempelet. ### mkdir-kommandoen i Linux [Kommandoen «Linux `mkdir`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-mkdir/) står for *«make directory*» og lar Linux-brukere opprette nye mapper. Bruk følgende syntaks for å opprette en ny mappe i den gjeldende mappen: ```bash mkdir [OPTION] DIRECTORY NAME ``` Hvis en mappe skal opprettes i en bestemt målmappe, må du angi den absolutte eller relative banen til mappen. ### rm-kommandoen i Linux Kommandoen «Linux rm » (*remove*) sletter filer eller hele kataloger permanent. Kommandoen brukes med følgende syntaks: ```bash rm [OPTIONS] FILE/DIRECTORY ``` Hvis en mappe skal slettes sammen med alle undermappene, bruker du `rm` sammen med alternativet `-R` (*–recursive*). ### rmdir-kommandoen i Linux Hvis du vil slette en bestemt katalog, bruker du kommandolinjedirektivet `rmdir` (*fjern katalog*) i henhold til følgende syntaks: ```bash rmdir [OPTION] DIRECTORY ``` Du kan bare slette tomme mapper med `rmdir`. For å slette en mappe sammen med alle filene og undermappene den inneholder, bruker du kommandoen `rm` (*remove*) med alternativet `–r`. I andre artikler finner du flere måter å slette en Linux-fil eller en Linux-mappe på. ### mv-kommandoen i Linux [Kommandoen](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-mv/)*«move*» [ `mv`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-mv/) kopierer en fil eller en mappe og sletter det opprinnelige elementet. Hvis den brukes i samme mappe, kan `mv` brukes til å gi filer nytt navn. Programkallet er basert på følgende syntaks: ```bash mv [OPTIONS] SOURCE TARGET ``` ### cp-kommandoen i Linux Linux-kommandoen cp (*copy*) brukes til å kopiere filer og mapper. Kommandoens grunnleggende syntaks er: ```bash cp [OPTIONS] SOURCE TARGET ``` KILDEN er elementet som skal kopieres. Deretter angis enten en fil eller en mappe som MÅL for kopieringsprosessen. Hvis du angir en eksisterende fil som målfil, blir innholdet i denne overskrevet med kildefilen. Du har også muligheten til å opprette en ny fil med et navn du selv velger som målfil. ### pwd-kommandoen i Linux Bruk \[kommandoen `linux`pwd`](t3://page?uid=25824)` (forkortelse for *«print working directory»*) for å vise navnet på den gjeldende arbeidsmappen. Kommandoens syntaks er som følger: ```bash pwd [OPTIONS] ``` ### zip-kommandoen i Linux Bruk kommandoen `zip` til å komprimere flere filer til et zip-arkiv. Kommandoens syntaks er: ```bash zip DESTINATION FILES ``` DESTINATION er navnet eller banen til den resulterende zip-filen. FILES refererer til filnavnene eller banene til filene som skal komprimeres (adskilt med mellomrom). ### unzip-kommandoen i Linux Du kan bruke `unzip` til å pakke ut filer fra zip-arkiver. Syntaksen er: ```bash unzip FILE.zip -d DESTINATION ``` Her refererer FILE til zip-arkivene som filene skal pakkes ut fra. Du kan eventuelt bruke alternativet -d TARGET for å angi en målkatalog der de resulterende filene skal lagres. Ellers lagres filene i den gjeldende katalogen. ### ln-kommandoen i Linux Kommandoen ln i Linux (forkortelse for *«link»*) oppretter en snarvei til en fil eller en katalog. Dette oppretter en ny katalogoppføring for denne filen, slik at du kan få tilgang til den aktuelle filen via en annen filbane. Kommandoen ``ln` må alltid inneholde minst banen til kildefilen. ```bash ln [OPTIONS] path/to/sourcefile ``` I dette tilfellet opprettes det en snarvei i den gjeldende arbeidskatalogen med samme navn. Du kan også angi en målbane og deretter gi snarveien det navnet du ønsker: ```bash ln [OPTIONS] path/to/sourcefile path/to/shortcut ``` ### cat-kommandoen i Linux Kommandoen Linux cat (forkortelse for *«concatenate»*) ble utviklet som et verktøy for å slå sammen filinnhold og kan brukes som en pager for visning av filinnhold i terminalen. Bruk `cat` med følgende syntaks i terminalen for å lese en fil og skrive den ut til `stdout` (standardutdata): ```bash cat OPTIONS FILE ``` Flere filer kan skilles med mellomrom: ```bash cat OPTIONS FILE1 FILE2 ``` ### grep-kommandoen i Linux Med kommandoen Linux grep kan du søke i tekstfiler. Du kan bruke hvilken som helst tegnstreng eller hvilket som helst regulært uttrykk som søkemønster. Bruk `grep` i henhold til følgende syntaks: ```bash grep [OPTIONS] SEARCH PATTERN [FILE(S)] ``` Hvis `grep` finner en streng som samsvarer med søkemønsteret, vises linjenummeret sammen med filnavnet på terminalen. Vanligvis brukes `grep` på alle filene i den gjeldende katalogen. Alternativet `-r` aktiverer et rekursivt søk i underkatalogene. ### diff-kommandoen i Linux Kommandolinjeprogrammet `diff` brukes til å sammenligne to filer. Du kan også bruke `diff` til å sjekke om to mapper inneholder de samme filene. Start programmet i terminalen ved å bruke følgende syntaks: ```bash diff [OPTIONS] FILE1 FILE2 ``` ### cmp-kommandoen i Linux `cmp` inngår i `diff` pakken og brukes til å sammenligne filinnhold. I motsetning til `diff` skjer sammenligningen på bytenivå, og er derfor spesielt egnet for binære filer. Bruk `cmp` i henhold til følgende syntaks: ```bash cmp [OPTIONS] FILE1 FILE2 ``` Hvis `cmp` finner avvik, viser kommandolinjeprogrammet byte- og linjenummeret for det første avviket i terminalen. ### tar-kommandoen i Linux Kommandoen `tar` lar deg skrive ulike filer og mapper sekvensielt inn i en `tar` og bruke den som sikkerhetskopi for gjenoppretting ved behov. I motsetning til zip-formatet som er vanlig i Windows, beholdes alle brukerrettighetene til den arkiverte filen selv etter utpakking. Bruk følgende syntaks: ```bash tar [OPTIONS] FILES ``` Hvis du vil opprette et nytt arkiv, bruker du `tar` sammen med alternativene `-c` (opprett nytt arkiv) og `-f` (skriv arkivet til en angitt fil eller les fra den). Les mer i artikkelen vår om tar-sikkerhetskopiering og hvordan du oppretter arkiver i Linux. ### echo-kommandoen i Linux Bruk kommandoen echo i Linux til å skrive ut strenger linje for linje til standardutdata (vanligvis terminalen). Den generelle kommandosyntaksen er som følger: ```bash echo [OPTIONS] STRING ``` ### clear-kommandoen i Linux Bruk kommandolinjedirektivet `clear` for å tømme skjerminnholdet. ```bash clear ``` Du får opp en tom terminal med en kommandolinje. Eldre oppføringer forblir i scrollback-bufferen. I stedet for å bruke denne kommandoen kan du også tømme terminalen ved å trykke på tastkombinasjonen \[Ctrl\] + \[L\]. ### ssh-kommandoen i Linux Du kan bruke `ssh` til å koble datamaskinen din til en ekstern datamaskin via SSH-protokollen, noe som betyr at du da befinner deg i skjellmiljøet på den andre datamaskinen. Syntaksen er som følger: ```bash ssh USERNAME@HOSTNAME ``` Her står USERNAME og HOSTNAME for brukernavnet du ønsker å logge inn med, og adressen til den eksterne datamaskinen. ### wget-kommandoen i Linux Du kan bruke \[kommandoen `Linux`wget`](t3://page?uid=25698)` til å laste ned filer fra internett. Bruk følgende syntaks for dette: ```bash wget [OPTION] LINK ``` Her angir LINK nettadressen der filen ligger. Du kan eventuelt bruke det valgfrie argumentet `-c` for å fortsette en nedlasting som har blitt avbrutt. ### ping-kommandoen i Linux Bruk [Linux-kommandoen `ping`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-ping/) til å sjekke om andre datamaskiner i nettverket er tilgjengelige. Kommandoen har følgende syntaks: ```bash ping [OPTIONS] TARGET ``` I tillegg til rundturstiden (*RTT*) – tidsrommet mellom sending av datapakken og mottak av svar – skriver `ping` også IP-adressen til målsystemet ut på terminalen. Du kan bruke valgfrie argumenter til å angi antall pakker eller sekunder etter hvilke `ping` avslutter seg selv. ### ftp- eller sftp-kommandoen i Linux Dette gir deg muligheten til å utveksle filer mellom det lokale systemet og en annen datamaskin i nettverket. Bruk FTP (File Transfer Protocol) i henhold til følgende syntaks for å opprette en forbindelse til FTP-serveren på måldatamaskinen: ```bash ftp [OPTIONS] [HOST[PORT]] ``` Adresseringen skjer via vertsnavn eller IP-adresse. Det er valgfritt å angi et portnummer. Bruk kun FTP i nettverk du stoler på, da denne protokollen ikke er sikker. Av sikkerhetsmessige årsaker er det nesten alltid tilrådelig å bruke SFTP (SSH File Transfer Protocol). Kommandolinjeprogrammet `sftp` fungerer som `ftp` for å overføre data i nettverket, men her er overføringen kryptert. SFTP bruker Secure Shell (SSH) som standard, dvs. også dets autentiseringsmetoder. Vi forklarer hvordan du bruker SSH-nøkler for nettverkstilkoblingen din i en annen artikkel. ### ip-kommandoen i Linux Kommandolinjeprogrammet `ip` inngår i programsamlingen `iproute2`, som brukes til å hente frem og konfigurere nettverksgrensesnitt via terminalen. Den generelle syntaksen for kommandoen er: ```bash ip [OPTIONS] OBJECT [COMMAND [ARGUMENT]] ``` Hvilken handling som utføres av `ip`, defineres ved hjelp av objekter, underkommandoer og deres argumenter. Programmet støtter ulike objekter, for eksempel `address` (IP-adresse), `link` (nettverksgrensesnitt), `route` (oppføring i rutetabellen) eller `tunnel`, som man kan legge til underkommandoer som `add`, `change`, `del`, `list` eller `show` til. Hvis du for eksempel ønsker å hente IP-adressen til et bestemt nettverksgrensesnitt (f.eks. `eth0`), bruker du kommandoen `ip` sammen med objektet `address`, kommandoen `show` og argumentet `dev eth0`: ```bash ip address show dev eth0 ``` Vi vil vise deg hvordan du viser en IP-adresse i Linux mer detaljert i en annen artikkel. ### Kommandoene apt, pacman og yum i Linux Alle Linux-distribusjoner har en **pakkehåndterer** som du kan bruke til å laste ned og administrere programvarepakker. Syntaksen for installasjon av apper er som følger: ```bash apt install [PACKET] # Debian-based distributions such as Ubuntu pacman -S [PACKET] # Arch-based distributions yum install [PACKET] # Red Hat-based distributions ``` `[PACKET]` er navnet på pakken eller programmet du ønsker å installere. I de fleste tilfeller må disse kommandoene kjøres via `sudo` i root-modus. For andre distribusjoner som bruker andre pakkehåndterere, kan kommandoene variere. Hver pakkehåndterer har også kommandoer for blant annet å fjerne pakker, oppdatere pakkelisten og oppdatere alle installerte pakker. På Ubuntu er disse kommandoene som følger. ```bash apt remove [PACKET] # remove package apt update # update package list apt upgrade # upgrade packages ``` ### netstat-kommandoen i Linux Kommandolinjeprogrammet `netstat` brukes til å sjekke statusen til nettverksgrensesnitt. Den generelle syntaksen for kommandoen er: ```bash netstat [OPTIONS] ``` Bruk `netstat` uten tilleggsvalg for å vise alle åpne sokler i terminalen. Du kan også bruke følgende tilleggsvalg for å se rutetabellen (`-r`), grensesnittstatistikk (`-i`), maskerte tilkoblinger (`-M`) eller nettverksforbindelsesmeldinger (`-N`). Les mer i vår introduksjon til netstat. ### traceroute-kommandoen i Linux For å spore transportruten til en IP-datapakke mellom systemet ditt og en måldatamaskin, kan du bruke kommandoen traceroute. Bruk følgende mønster. ```bash traceroute [OPTIONS] HOSTNAME ``` Ved hjelp av `traceroute` kan du finne ut hvilke rutere og internettknutepunkter en IP-pakke passerer på veien til måldatamaskinen – for eksempel for å finne årsaken til en forsinkelse. ### route-kommandoen i Linux Med kommandolinjeprogrammet `route` kan man hente frem og redigere kjernens IP-rutetabell. Kommandoen følger følgende syntaks: ```bash route [OPTIONS] [add|del] [-net|-host] TARGET ``` Bruk kommandoen uten alternativer for å vise kjernens komplette rutetabell: ```bash route ``` Hvis du vil angi en rute til et nettverk, bruker du underkommandoen `add`. ```bash route add -net 10.0.0.0 ``` ### dig-kommandoen i Linux `dig` er et oppslagsverktøy som kan brukes til å hente informasjon fra DNS-serveren og vise den i terminalen. Kommandolinjeprogrammet brukes vanligvis med følgende syntaks for å hente IP-adressen og annen DNS-informasjon for et gitt domenenavn: ```bash dig [@SERVER] [DOMAIN] [TYPE] ``` SERVER er DNS-serveren som skal søkes etter den ønskede informasjonen. Hvis ingen server er angitt, identifiserer `dig` standard-DNS-serveren fra filen `/etc/resolv.conf`. DOMAIN står for domenenavnet som DNS-informasjonen skal hentes fra. TYPE brukes til å spesifisere typen forespørsel, dvs. ANY (alle oppføringer), A (IPv4-oppføring for en vert) eller AAAA (IPv6-oppføring for en vert). Standard forespørselstype er definert som A. ### Kommandoen mount og unmount i Linux Hvis et filsystem skal integreres i operativsystemets katalogstruktur via katalogstrukturen, brukes kommandolinjeprogrammet `mount` under Linux. Kommandoens generelle syntaks er: ```bash mount [OPTIONS] DEVICE MOUNTPOINT ``` DEVICE = Stien til enhetsfilen for lagringsenheten du ønsker å montere som partisjon. MOUNTPOINT = Plasseringen i operativsystemets katalogstruktur der du ønsker å montere partisjonen. Monteringspunktet angis vanligvis som en absolutt sti. Eksempel: ```bash mount /dev/sdd /media/usb ``` Enheten `sdd` er montert i skapet `/media/usb`. ### dd-kommandoen i Linux Kommandolinjeprogrammet `dd` muliggjør en kopieringsprosess der data leses ut bit for bit fra en inndatafil (`if`) og skrives til en utdatafil (`of`). Programkallet følger følgende syntaks: ```bash dd if=Source of=Target [OPTIONS] ``` Som kilde og mål kan du angi både enkeltfiler, hele partisjoner (f.eks. /dev/sda1) og hele lagringsenheter (f.eks. /dev/sda). ```bash dd if=/dev/sda5 of=/dev/sdb1 ``` ### chmod-kommandoen i Linux Kommandolinjeprogrammet `chmod` (forkortelse for *«change mode»*) brukes til å tildele rettigheter i Unix-lignende filsystemer (f.eks. ext2, ext3, ext4, reiser, xfs). Den generelle syntaksen for kommandoen er: ```bash chmod [OPTIONS] MODE FILE ``` eller ```bash chmod [OPTIONS] MODE DIRECTORY ``` Plassholderen MODE står for den gjeldende rettighetsmasken. Du kan lese mer om hvordan du oppretter et slikt system og hva du bør være oppmerksom på i vår veiledning om tilgangsrettigheter med chmod. Ved hjelp av alternativet `-R` kan rettigheter tildeles rekursivt til undermapper og filer i en katalog. ### chown-kommandoen i Linux \[Kommandoen `linux`chown`](t3://page?uid=25778)` står for *«endre eier»* og lar deg endre eierrettighetene. ```bash chown [OPTIONS] [USER][:[GROUP]] FILE ``` eller ```bash chown [OPTIONS] [USER][:[GROUP]] DIRECTORY ``` For å angi eierrettigheter for en bruker eller gruppe finnes det fire mulige kombinasjoner. Eier og gruppe tilbakestilles i henhold til opplysningene som legges inn: ```bash chown [OPTIONS] owner_name:group_name file.txt ``` ```bash # The group is reset according to the input, the user remains unchanged: chown [OPTIONS] :group_name file.txt # The owner is reset according to the input, the group remains unchanged: chown [OPTIONS] owner_name file.txt # The user is reset according to the input. The group is set to the default group for the logged-in user: chown [OPTIONS] owner_name: file.txt # The changes are recursively extended to subdirectories with the help of OPTION `-R`. ``` ### adduser-kommandoen i Linux Den enkleste måten å opprette en brukerkonto på er ved hjelp av kommandolinjeprogrammet `adduser`. Dette er et Perl-skript basert på [Linux-kommandoen `useradd`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-useradd/), og tilbyr de samme funksjonene på en brukervennlig måte. Kommandoen `adduser` krever root-rettigheter og brukes i henhold til følgende syntaks: ```bash adduser [OPTIONS] USERNAME ``` Bruk `adduser` uten tilleggsparametere for automatisk å opprette en bruker-ID, en hjemmekatalog og en brukergruppe med samme navn, i tillegg til den nye brukerkontoen. ```bash adduser test ``` Deretter følger en interaktiv dialogboks der du kan angi passord og annen brukerinformasjon (ekte navn, kontornummer, telefonnummer osv.). ### passwd-kommandoen i Linux Bruk \[kommandoen `linux`passwd`](t3://page?uid=25774)` til å endre passordet til en bruker eller til å definere, sjekke og endre intervaller. Kommandoen følger denne syntaksen: ```bash passwd [OPTIONS] USERNAME ``` Hvis du vil endre passordet til en annen bruker, trenger du root-rettigheter. Bruk kommandoen `passwd` uten brukernavn for å endre ditt eget passord. Hvis passordet skal låses, bruker du kommandoen `passwd` med alternativet `-l` (*–lock*). Andre alternativer gir deg muligheten til å angi en varighet for passordets utløp `(-x)`, samt varslings- `(-w)` og kontrollintervaller `(-i)`. ### kommandoen `groupadd` i Linux Kommandolinjeprogrammet `groupadd` brukes til å opprette brukergrupper. Bruk `groupadd` med root-rettigheter i henhold til følgende syntaks: ```bash sudo groupadd [OPTIONS] GROUPS ``` Hver nyopprettet gruppe har sin egen gruppe-ID (GID). Gruppe-ID-er mellom 0 og 99 er reservert for systemgrupper. Hvis du selv ønsker å angi GID-en for en ny brukergruppe, bruker du kommandolinjedirektivet `groupadd` sammen med alternativet `-g` (GID). Hvis du ønsker å opprette en systemgruppe, bruker du alternativet `-r` (root). ### chattr-kommandoen i Linux Kommandolinjeprogrammet `chattr` (forkortelse for *«change attribute»*) lar deg vise filer eller mapper med attributter. Bruk `chattr` i henhold til følgende syntaks for å angi et attributt: ```bash chattr [OPTIONS] +ATTRIBUTE FILE ``` Erstatt plusstegnet med et minustegn for å fjerne attributtene igjen. Angi for eksempel attributt `-i` for å forhindre endringer (sletting eller modifisering) av en fil eller en katalog. Se bruksanvisningen til programmet `chattr` for andre attributter og mulige alternativer. ### lsattr-kommandoen i Linux Hvis du ønsker å vise hvilke attributter som er angitt for en fil eller en mappe, bruker du kommandolinjedirektivet `lsattr` (forkortelse for *«list attributes»*) i henhold til følgende syntaks: ```bash lsattr [OPTIONS] FILE/DIRECTORY ``` ### chgrp-kommandoen i Linux Kommandoen `chgrp` står for *«endre gruppe»* og brukes til å administrere gruppetilhørighet for filer og kataloger. For å kunne bruke `chgrp` på en valgt fil eller katalog, må du ha eier- eller root-rettigheter. Dette er de eneste gruppene du kan tilhøre. `chgrp` brukes i henhold til følgende syntaks: ```bash chgrp [OPTIONS] GROUP FILE ``` eller ```bash chgrp [OPTIONS] GROUP DIRECTORY ``` Alternativ `-R` gjelder undermapper og filer som finnes i en katalog. ### man-kommandoen i Linux Kommandoen `man` åpner manual-sidene (*man-sidene*) for Linux-distribusjonen din direkte i terminalen. Bruk følgende oppskrift for å åpne manual-sidene: ```bash man [OPTION] TOPIC ``` Linux-man-sidene er delt inn i 10 temaområder: Brukerkommandoer, systemkall, funksjoner i programmeringsspråket C, filformater, konfigurasjonsfiler, spill, diverse, systemadministrasjonskommandoer, kjernefunksjoner, nye kommandoer. ### kommandoen for å slå av systemet i Linux \[Kommandoen `linux`shutdown`](t3://page?uid=2619)` kan brukes av root-brukeren til å slå av systemet. Kommandoen har følgende syntaks: ```bash shutdown [OPTIONS] [TIME] [MESSAGE] ``` Hvis du ønsker å starte en nedstengning, kan du angi et tidspunkt da systemet skal slås av. Til dette kan du bruke enten et konkret klokkeslett (tt:mm) eller en nedtelling (+m). Andre brukere på systemet vil motta en melding om nedstengning. Denne kan ledsages av en personlig melding, om nødvendig. Hvis kommandoen `shutdown` brukes sammen med alternativet `-r`, følges nedstengningen av systemet av en omstart. ### top-kommandoen i Linux Kommandoen `top` henter en dynamisk oversikt over alle prosesser som kjører. Kommandoen følger følgende mønster: ```bash top [OPTIONS] ``` Visningen av prosessinformasjonen kan tilpasses ved hjelp av ulike alternativer. Prosessoversikten `top` (blant annet) støtter følgende hurtigtaster for å sortere visningene: - \[P\] = Sorterer utdataene etter CPU-belastning - \[M\] = Sorterer utdataene etter lagringsbehov - \[N\] = Sorterer utdataene numerisk etter PID - \[A\] = Sorterer utdataene etter alder - \[T\] = Sorterer utdataene etter tid - \[U BRUKERNAVN eller UID\] = Filtrerer utdataene etter respektive bruker Bruk hurtigtasten \[H\] for å vise en hjelpeside, eller \[Q\] for å lukke prosessoversikten. ### lscpu-kommandoen i Linux Bruk `lscpu` (forkortelse for *«list cpu»*) etter følgende mønster for å vise informasjon om CPU-arkitekturen i terminalen. ```bash lscpu [OPTIONS] ``` Se bruksanvisningen til operativsystemet ditt for mulige alternativer. ### lshw-kommandoen i Linux Kommandoen `lshw` står for *«list hardware»* og viser informasjon om maskinvarekomponentene i terminalen. Bruk `lshw` i henhold til følgende syntaks: ```bash lshw [OPTIONS] ``` Kommandoen støtter ulike alternativer for å tilpasse utdataformatet (`-html`, `-xml`, `-short`, `-businfo`) samt omfanget av informasjonen (f.eks. `–sanitize` for å skjule sensitiv informasjon). ### kill-kommandoen i Linux `kill` er et kommandolinjeprogram som kan brukes til å stoppe og avslutte prosesser. Kommandoen sendes videre etter følgende mønster, med et ønsket signal og ID-en til den valgte prosessen. ```bash kill [OPTIONS] [-SIGNAL] PID ``` Vanlige tegn er: 1. `TERM`: Får en prosess til å avslutte seg selv (standard) 2. `KILL`: Tvinger en prosess til å avsluttes (via systemet) 3. `STOP`: Stopper en prosess 4. `CONT`: Lar en stoppet prosess fortsette ### killall-kommandoen i Linux Bruk [kommandoen `linux`killall``](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-killall/) sammen med et bestemt søkeord for å avslutte kun de prosessene som har samsvarende navn (de første 15 tegnene brukes til å finne treff). ```bash killall [OPTIONS] [-SIGNAL] [PROCESS NAME] ``` Alternativet `-e` (*–exact*) lar deg utvide søket til å omfatte alle tegn i prosessnavnet. ### En nyttig kommando i Linux Kommandolinjeparameteren `nice` angir en prosessverdi mellom -20 og +19 ved prosessstart i heltallstrinn, hvoretter systemets tilgjengelige prosessorkraft fordeles. Området fra -20 til +19 tilsvarer Linux-prioritetsnivåene 100 til 139. En prosess med en `nice` på -20 har høyere prioritet enn en prosess med en `nice` på 19. Solo-syntaksen lyder: ```bash nice [OPTION] [COMMAND] ``` Med mindre annet er angitt, starter alle prosesser med verdien 0 for `nice`. Bruk parameter `-n` til å angi prosessprioritet. Det bør bemerkes at negative prioriteter kun kan tilordnes med root-rettigheter. ### pgrep-kommandoen i Linux Kommandolinjeprogrammet `pgrep` sammenligner listen over aktive prosesser med et søkeord og viser de aktuelle PID-ene hvis det finnes treff. Den generelle syntaksen er som følger: ```bash pgrep [OPTIONS] Search term ``` Som standard viser `pgrep` PID-ene til alle prosesser som inneholder søkeordet. Hvis søket skal begrenses til kun eksakte treff, bruker du kommandoen sammen med alternativet `-x`. Hvis du ønsker å få oppgitt PID-en i tillegg til prosessnavnet, bruker du `pgrep` sammen med alternativet `-l`. I likhet med `grep` støtter `pgrep` søkeord basert på regulære uttrykk. ### ps-kommandoen i Linux \[Kommandoen `linux`ps`](t3://page?uid=25686)` viser en liste over alle prosesser som kjører i terminalen. ```bash ps [OPTIONS] ``` Hvis du trenger en detaljert utskrift, bruk `ps` sammen med alternativene `-f` (detaljert) eller `-F` (svært detaljert). Se bruksanvisningen til operativsystemet ditt for flere alternativer. ## Oversikt over flere Linux-kommandoer ### Grunnleggende kommandoer I kategorien «Grunnleggende kommandoer» finner du de grunnleggende Linux-kommandoene som brukes til **å styre terminalen**. Lær hvordan du tømmer terminalens skjerm, henter tidligere terminalinnlegg fra historikken eller avslutter terminalsesjonen. **1. avslutt** Kommandolinjekommandoen `exit` avslutter den aktuelle økten og lukker terminalen. ```bash exit ``` I stedet kan du bruke tastkombinasjonen \[Ctrl\] + \[D\]. **2. hjelp** Bruk kommandoen `help` for å se en liste over alle integrerte skallkommandoer (innebygde kommandoer). Bruk `help` sammen med en skallkommando for å få en kort beskrivelse av den aktuelle kommandoen. ```bash help COMMAND ``` **3. historie** I Bash lagres de siste 500 kommandoene som er skrevet inn i kommandolinjen i historikken. Denne funksjonen fungerer som en innskrivingshjelp, og lar deg bla gjennom listen over tidligere kommandoer ved hjelp av piltastene og utføre dem på nytt. Du kan søke i loggen ved hjelp av nøkkelord med tastkombinasjonen \[Ctrl\] + \[R\]. Du har også muligheten til å vise hele listen, nummerert i terminalen. Bruk kommandoen `history` uten tilleggsvalg og argumenter. ```bash history ``` Hvis du vil filtrere resultatene, kan du koble `history` via Linux Pipe til kommandolinjeprogrammet `grep` (se søkealternativer) og et søkeord. ```bash history | grep SEARCH TERM ``` ### Hjelpesider Vet du ikke hva du skal gjøre? Ingen grunn til bekymring. Under Linux finnes det ulike **hjelpe- og dokumentasjonssider** tilgjengelig direkte via terminalen, for eksempel *Unix-man-sidene* og *GNU-infosidene*. Disse inneholder en detaljert beskrivelse av alle kommandolinjeprogrammer, systemkall, konfigurasjonsfiler, filformater og kjernefunksjoner. Med [Linux-kommandoene `whatis`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-whatis/) og `apropos` kan du finne kommandolinjeprogrammer i hjelpesidene-kategorien, som lar deg søke etter nøkkelord i manualene til operativsystemet ditt. **1. apropos** Bruk `apropos` til å søke etter nøkkelord i sidetitler og beskrivelser i bruksanvisningen til operativsystemet ditt. Følg denne fremgangsmåten: ```bash apropos [OPTIONS] SEARCH TERM ``` Kommandoen støtter ulike alternativer. Bruk alternativet `-e` for å begrense søket til eksakte treff, eller bruk jokertegn (`-w '*SEARCH TERM'`) og regulære uttrykk (`-r`). **2. info** Ved hjelp av kommandoen `info` kan du hente GNU info-sidene for et bestemt emne. I de fleste tilfeller tilsvarer disse sidene man-sidene som du får tilgang til via `man`, men i motsetning til disse inneholder de lenker som gjør navigasjonen i manualen enklere å følge. Bruk følgende syntaks: ```bash info [OPTION] TOPIC ``` Hvis du ringer uten å oppgi et alternativ eller et emne, kommer du til hovedmenyen på GNU info-siden. **3. pinfo** Med `pinfo` får du en variant av kommandolinjeprogrammet `info`, som er basert på kommandolinjebrowseren Lynx og viser informasjonssider med uthevede lenker. Bruk `pinfo` på samme måte som kommandoen `info`: ```bash pinfo [OPTIONS] TOPIC ``` **4. hva er** Kommandolinjeprogrammet `whatis` fungerer som et søkeverktøy for nøkkelord i manualene. Start dette programmet med et vanlig nøkkelord for å søke etter eksakte treff i operativsystemets manual. Hvis det finnes et treff, viser `whatis` en kort beskrivelse i terminalen. ```bash whatis [OPTIONS] SEARCH TERM ``` `whatis` (`-w '\*SEARCH TERM'`) støtter også plassholdere og regulære uttrykk (`-r`). ### Katalogoperasjoner Du vil bruke Linux-kommandoer for katalogoperasjoner til å opprette, slette og administrere kataloger på systemet ditt via terminalen, samt navigere i katalogstrukturen. De viktigste kommandolinjekommandoene i denne kategorien er `cd`, `ls`, `mkdir` og `rmdir`. **1. chroot** Kommandoen `chroot` (forkortelse for *«change root»*) brukes til å kjøre en kommando i en annen rotkatalog. For eksempel brukes `chroot` til å isolere kritiske programmer fra resten av filsystemet. Det kreves root-rettigheter for å kjøre programmet, og det følger denne formelen: ```bash chroot DIRECTORY COMMAND ``` **2. mkdir her** Med `mkdirhier` kan du opprette hele kataloghierarkier med én enkelt kommandolinjekommando: ```bash mkdirhier [OPTION] /home/user/directory1/directory2/directory3 ``` Hvis `directory1` og `directory2` allerede finnes, oppretter `mkdirhier` bare `directory3`. Ellers opprettes alle tre katalogene. **3. tre** Mens `ls` bare viser innholdet i en katalog, kan kommandolinjedirektivet `tree` brukes til å vise hele kataloghierarkiet rekursivt som en trestruktur. Kommandoen bruker følgende syntaks: ```bash tree [OPTIONS] [DIRECTORY] ``` ### Filhåndtering Linux-kommandoene i denne tabellen lar deg utføre ulike filoperasjoner fra terminalen. Bruk de grunnleggende Linux-kommandoene som `cp`, `mv` og `rm` til å kopiere, flytte, gi nytt navn til eller slette filer på systemet ditt. **1. basename** En filbane overføres til kommandolinjedirektivet `basename`, som ganske enkelt returnerer filnavnet uten standardbane. Kommandoens syntaks er som følger: ```bash basename [OPTIONS] path/to/files [SUFFIX] ``` Kommandoen kan utvides til å omfatte flere filer ved hjelp av alternativer. **2. komm** Bruk kommandolinjeprogrammet `comm` til å sammenligne sorterte filer (dvs. ved hjelp av `sort`) linje for linje. Programkallet følger følgende syntaks: ```bash comm [OPTIONS] FILE1 FILE2 ``` Programmet støtter tre alternativer: - -1: fjern unike linjer fra `FILE1` - -2: utelat unike linjer fra `FILE2` - -3: utelat alle linjer som finnes i begge filene **3. kutt** Kommandoen `cut` lar deg hente ut innholdet i en fil fra tekstlinjene i filen (f.eks. logg- eller CSV-filer). Kommandoens syntaks er som følger: ```bash cut [OPTIONS] FILE ``` Den nøyaktige plasseringen av en utdratt del defineres ved hjelp av alternativene `-b` (byteposisjon), `-c` (tegnposisjon), `-d` (skilletegn) og `-f` (felt). **4. dirname** `dirname` er motstykket til `basename`. Kommandolinjedirektivet lar deg trekke ut stidelen fra en filsti og vise den i terminalen uten filnavn. Kommandoens syntaks er som følger: ```bash dirname [OPTIONS] path/to/file ``` **5. fil** Med kommandolinjedirektivet `file` kan du vise informasjon om filtypen til en fil. Kommandoen følger følgende syntaks: ```bash file [OPTIONS] FILE ``` **6. lsof** [Kommandoen](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-lsof/) `[linux`lsof`](t3://page?uid=25776)` står for *«list open files»*, et verktøy som gir deg informasjon om åpne filer i terminalen, sortert etter PID (prosess-ID). Start programmet i terminalen ved å bruke følgende syntaks: ```bash lsof [OPTIONS] ``` Siden Unix-lignende systemer som Linux generelt følger prinsippet om at «alt er en fil», blir listen som vises ved bruk av kommandoen `lsof` tilsvarende lang. Som regel brukes alternativene til å begrense denne utskriften. **7. md5sum** Kommandolinjekommandoen `md5sum` hjelper deg med å beregne og kontrollere MD5-kontrollsummer for filer. **8. lim inn** I likhet med `cat` gjør også kommandolinjeprogrammet `paste` det mulig å skrive ut filinnhold til standardutdata. Men mens `cat` bare slår sammen innhold, sammenføyer `paste` kolonne for kolonne. Kommandoens grunnleggende syntaks er: ```bash paste [OPTIONS] FILE1 FILE2 … ``` Du kan velge hvilket skilletegn som skal brukes av `paste` ved hjelp av alternativet `-d`. Tabulatorer brukes som standard skilletegn. En alternativ modus kan aktiveres ved hjelp av alternativet `-s` (seriell). Med denne modusen overføres alle linjene i den første inndatafilen til den første linjen i utdatafilen. Dataene fra alle andre inndatafiler følger i separate utdatalinjer, slik at hver linje i utdatafilen kun inneholder innholdet fra én inndatafil. **9. gi nytt navn** Kommandolinjeprogrammet `rename` gjør det mulig å endre navn på filer og mapper ved hjelp av regulære uttrykk (regex). I motsetning til `mv` er funksjonen `rename` egnet for filoperasjoner der navnene på flere filer skal endres enten delvis eller fullstendig. Bruk `rename` i henhold til følgende syntaks: ```bash rename [OPTIONS] 'REGULAR_EXPRESSION' FILE ``` Regulære uttrykk følger følgende syntaks for erstatninger: ```bash s/SEARCHPATTERN/REPLACEMENT/MODIFIER ``` **10. makulere** `shred` er et kommandolinjeprogram som gjør det mulig å slette filer på en sikker måte. De valgte elementene overskrives under slettingsprosessen og kan derfor ikke gjenopprettes ved hjelp av kriminaltekniske metoder. Kommandoens generelle syntaks er som følger: ```bash shred [OPTIONS] FILE ``` **11. sortere** Bruk kommandolinjeparameteren `sort` til å sortere fillister og programutdata numerisk, alfabetisk og etter rad. Kommandoens generelle syntaks er som følger: ```bash sort [OPTIONS] FILE ``` Sorteringsmetoden kan tilpasses ved hjelp av ulike alternativer. For eksempel numerisk (`-n`), tilfeldig (`-R`) eller i omvendt rekkefølge (`-r`). **12. splitt** Kommandolinjedirektivet `split` brukes til å dele opp filer. Den underliggende syntaksen er som følger: ```bash split [OPTIONS] [INPUT [PREFIX]] ``` Plassholderen INPUT tilsvarer filen som skal deles opp. *PREFIX* angir navnene på de involverte filene. Navnene deres følger følgende mønster: ```bash PREFIXaa, PREFIXab, PREFIXac … ``` Hvis det ikke er angitt noe prefiks, bruker `split` standardprefikset `x`. Alternativet `-b` (bytes) kan brukes til å angi størrelsen på delfilene. Dette kan angis enten i byte (b), kilobyte (k) eller megabyte (m). Eksempel: ```bash split -b 95m archive.tgz split-archive.tgz. ``` **13. statistikk** Kommandolinjekommandoen `stat` (*status*) viser tidsstempler for når filer og mapper ble åpnet og endret. Den generelle syntaksen for kommandoen er: ```bash stat [OPTIONS] FILE ``` Utdataformatet kan tilpasses ved hjelp av alternativer. **14. uniq** Kommandolinjedirektivet `uniq` brukes vanligvis sammen med `sort` for å fjerne dupliserte linjer fra sorterte filer. I eksemplet nedenfor kobles kommandoen `sort` via en pipe (`|`) til kommandoen `uniq` for først å sortere en fil og deretter skrive den ut uten dupliserte linjer. ```bash sort file.txt | uniq ``` ### Søkealternativer Linux tilbyr ulike kommandolinjekommandoer for å søke i systemet direkte fra terminalen. **1. finne** Ved å bruke `find` kan du søke i en Linux-fil. Dette fungerer etter følgende syntaks: ```bash find [OPTIONS] [DIRECTORY] [SEARCHCONDITION] [ACTIONS] ``` Den angitte katalogen er utgangspunktet for søket. Kommandoen søker deretter i utgangskatalogen og dens underkataloger. Hvis ingen katalog er angitt, starter `find` søket fra den gjeldende arbeidskatalogen. Med alternativene kan du definere søkekriterier og handlinger. Standardhandlingen er forhåndsinnstilt til `-print`: utskriving av de fullstendige filnavnene til alle søkeresultatene til standardutdata (vanligvis terminalen). Ytterligere alternativer gjør det mulig å filtrere etter filnavn, filstørrelse, tilgangstidspunkt osv. Disse er oppført på den tilhørende man-siden. **2. finne** Kommandolinjeprogrammet `locate` lar deg også søke etter filer via terminalen. Men i motsetning til `find` søker det ikke gjennom filkatalogen, men i en spesialopprettet og jevnlig oppdatert database. Dermed gir `locate` resultater mye raskere enn `find`. For å søke etter en bestemt fil i databasen brukes `locate` i henhold til følgende syntaks: ```bash locate SEARCHPATTERN ``` Søkemønsteret kan inneholde metategn som plassholdere (`*`). Sett disse i anførselstegn for å hindre at skallet tolker dem. **3. tre-agrep** `tre-agrep` brukes også til å søke etter strenger i tekstfiler basert på søkemønstre. Men i motsetning til `grep` er det ikke bare eksakte treff som vises, men også vage resultater er tillatt, for eksempel resultater med ombyttede bokstaver eller manglende tegn. Programmet er basert på TRE-biblioteket og gjør det tilgjengelig i kommandolinjen. Syntaksen til `tre-agrep` samsvarer med syntaksen til kommandoen `grep`: ```bash tre-agrep [OPTIONS] SEARCHPATTERN FILE(S) ``` Ved hjelp av innstillinger kan du angi en maksimal feilmargin. I eksemplet nedenfor tillates maksimalt ett avvik. ```bash tre-agrep -1 'Linux' test .txt ``` **4. updatedb** En `locate` fungerer bare som den skal hvis `/var/lib/locatedb` holdes kontinuerlig oppdatert. Kommandoen `updatedb` lar deg oppdatere databasen manuelt. Merk at du trenger root-rettigheter for å gjøre dette: ```bash updatedb ``` **5. whereis** Med kommandoen `whereis` kan du finne binærkoden, kildekoden eller brukerhåndboken til det valgte programmet. Kommandoens generelle syntaks er: ```bash whereis [OPTIONS] PROGRAM ``` Du kan bruke alternativer til å begrense søket til bestemte filtyper eller mapper. **6. som** Hvis du ønsker å finne ut hvilke binærfiler et program består av, kan du bruke kommandoen `which` med følgende syntaks for å få vist banen i terminalen. ```bash which [OPTIONS] PROGRAM ``` I standardmodus viser `which` den første filen den finner. Bruk alternativet `-a` for å vise alle filer som oppfyller søkekriteriene. ### Brukerinformasjon Bruk kommandolinjeprogrammene for følgende kategorier for å få tilgang til **detaljert informasjon om de registrerte brukerne i systemet**, samt deres grupper og prosesser. **1. finger** Kommandolinjeprogrammet `finger` brukes til å hente brukerinformasjon. Bruk kommandoen sammen med ønsket brukernavn: ```bash finger [options] [USERNAME] ``` Bruk `finger` uten brukernavn for å få informasjon om din egen konto. **2. grupper** Kommandoen `groups` viser hvilke grupper en valgt brukerkonto tilhører. Bruk `groups` uten brukernavn for å vise alle gruppene som brukerkontoen din tilhører. Bruk kommandolinjedirektivet i henhold til dette mønsteret: ```bash groups [OPTIONS] [USERNAME] ``` **3. id** Kommandolinjekommandoen `id` viser bruker- og gruppe-ID-er for de valgte brukerkontoene. Hvis du vil se dine egne ID-er, bruker du kommandoen uten brukernavn. ```bash id [OPTIONS] [USERNAME] ``` Utgangssignalets område kan begrenses ved hjelp av innstillinger. **4. sist** Bruk kommandoen `last` etter følgende mønster for å vise en liste over brukere som nylig har logget seg på, inkludert innloggings- og utloggingstidspunkter. ```bash last [OPTIONS] [USERNAME] ``` Den aktuelle informasjonen hentes fra filen `wtmp` under `/var/log/wtmp`. Hvis du bare ønsker å be om informasjon om en bestemt konto, må du angi kommandolinjedirektivet med det ønskede brukernavnet. **5. w** Kommandoen `w` viser en liste over alle registrerte brukere, inkludert alle prosesser de har kjørt. Bruk `w` sammen med et brukernavn for å begrense kommandoen til kun denne brukerkontoen: ```bash w [OPTIONS] [USERNAME] ``` Omfanget og formatet på utdataene kan tilpasses ved hjelp av alternativene. **6. hvem** Kommandoen `who` viser detaljert informasjon om brukere som er registrert i systemet. Den generelle syntaksen for kommandoen er: ```bash who [OPTION] [SOURCEFILE] ``` Som standard refererer `who` til data om nåværende registrerte brukere fra filen `/var/run/utmp`. Du har muligheten til å angi en av følgende filer som kilde for informasjonen. **7. whoami** Bruk kommandoen `whoami` for å finne ut ditt eget brukernavn. ```bash whoami [OPTIONS] ``` ### Administrasjon av brukerkontoer Linux tilbyr en rekke programmer som du kan bruke til å opprette, slette og administrere brukerkontoer og grupper direkte fra terminalen. Her har vi samlet en oversikt over de viktigste **Linux-kommandoene for administrasjon av brukerkontoer**. I denne kategorien finner du også Linux-terminalkommandoer som gir deg tilgang til koden med andre brukerrettigheter, inkludert superbrukeren root. **1. chfn** Kommandolinjedirektivet `chfn` (forkortelse for *«change finger»*) lar deg tilpasse tilleggsinformasjon på en brukerkonto, for eksempel ekte navn, kontornummer og private eller jobbrelaterte telefonnumre. Den generelle syntaksen er: ```bash chfn [OPTION "NEW VALUE"] [USERNAME] ``` Hvilken brukerinformasjon som skal få en ny verdi, defineres ved hjelp av alternativene `-f` (ekte navn), `-r` (kontornummer), `-w` (tjenestetelefon) og `-h` (privatnummer). **2. chsh** Kommandolinjedirektivet `chsh` (forkortelse for *«change shell»*) endrer påloggingsskallet til en valgt bruker. Bruk følgende mønster som veiledning når du legger inn dataene: ```bash chsh [OPTIONS] USERNAME ``` Du kan bruke alternativet `-s` til å endre påloggingsskallet til en brukerkonto. **3. vrangforestillinger** Kommandolinjeprogrammet `deluser` sletter alle oppføringer for en valgt brukerkonto fra systemets kontofiler. For å kjøre `deluser` kreves root-rettigheter, og følgende syntaks brukes: ```bash deluser [OPTIONS] USERNAME ``` Hvis du også ønsker å slette alle filene i brukerens hjemmekatalog, bruker du kommandoen med alternativene `--remove-home`. Hvis du ønsker å slette alle brukerfiler fra systemet, bruker du alternativene `--remove-all-files`. **4. delgruppe** Kommandolinjekommandoen `delgroup` (forkortelse for *«delete group»*) sletter en eksisterende brukergruppe. For å utføre kommandoen kreves root-rettigheter. Den generelle syntaksen for `delgroup` er: ```bash delgroup [OPTIONS] GROUP ``` **5. groupmod** Navn og gruppe-ID-er (GID) for eksisterende brukergrupper kan tilpasses via `groupmod`. Kommandolinjedirektivet brukes med root-rettigheter i henhold til følgende syntaks: ```bash groupmod OPTIONS GROUP ``` Bruk `groupmod` sammen med alternativet `-g` for å tilpasse GID-en. Bruk kommandoen med alternativet `-n` for å overskrive gruppenavnet. **6. newgrp** Kommandoen `newgrp` (forkortelse for *«ny gruppe»*) gjør det mulig for registrerte brukere å endre sin nåværende gruppe-ID uten å måtte logge ut og inn igjen. Den generelle syntaksen for kommandoen er: ```bash newgrp [-] [GROUP] ``` Hvis kommandoen `newgrp` brukes med den valgfrie parameteren \[-\], fører endringen av gruppe til at brukermiljøet startes på nytt – akkurat som om brukeren hadde logget seg på på nytt. De som bruker `newgrp` uten å angi gruppe, skifter til standardgruppen som er angitt under `/etc/passwd`. **7. søndag** Kommandoen `su` gjør det også mulig å bytte bruker midlertidig for å kjøre et program med rettighetene til en målbruker. I motsetning til `sudo` blir ikke kommandoen utført direkte. I stedet skjer det et identitetsbytte. I stedet for å be om passordet til den påkallende brukeren, blir det bedt om passordet til målbrukeren. Kommandoens generelle syntaks er som følger: ```bash su [OPTIONS] [USERNAME] ``` Et anrop uten BRUKERNAVN velger `root` som målbruker. **8. usermod** Kommandolinjedirektivet `usermod` gir deg muligheten til å redigere tidligere opprettede brukerkontoer. Bruk `usermod` med root-rettigheter i henhold til følgende syntaks: ```bash usermod [OPTIONS] USERNAME ``` Hvilke endringer som skal gjøres, kan angis ved hjelp av alternativer. Du kan for eksempel endre brukernavnet med alternativet `-l NEW_NAME`. Flere alternativer finner du på den tilhørende man-siden. ### Systemkommandoer I kategorien «Systemkommandoer» finner du de grunnleggende Linux-kommandoene for systemstyring. Bruk følgende kommandoer til å starte systemet på nytt og slå det av fra terminalen – og styr dem med en tidsinnstilling hvis ønskelig. **1. logger** Bruk `logger` i henhold til følgende mønster: ```bash logger "YOUR MESSAGE" ``` Du finner systemloggen under `/var/log/syslog`. **2. start på nytt** Kommandolinjedirektivet `reboot` fører til at systemet startes på nytt. For å utløse en omstart må kommandoen kjøres med root-rettigheter. ```bash reboot [OPTIONS] ``` **3. rtcwake** Kommandolinjedirektivet `rtcwake` lar deg starte og slå av systemet i henhold til en tidsinnstilling. Kommandoen følger følgende syntaks: ```bash rtcwake [OPTIONS] [MODE] [Time] ``` Velg en bestemt modus (`-m MODE`) som systemet skal gå over til på et bestemt tidspunkt, angitt i sekunder (`-s TIME IN SECONDS`). Du har også muligheten til å vekke systemet på et nøyaktig angitt tidspunkt (`-t UNIXTIME`). ### Systeminformasjon I kategorien «Systeminformasjon» har vi samlet kommandolinjeprogrammer som du kan **bruke til å hente informasjon og statusrapporter**, slik at du får en fullstendig oversikt over systemets tilstand. **1. dato** Kommandoen `date` viser systemtiden, inkludert datoen. ```bash date [OPTIONS] [OUTPUTFORMAT] ``` Hvis du ønsker å arbeide med et bestemt tidspunkt i forbindelse med et programkall (se `rtcwake`), kan du definere dette ved hjelp av alternativet `-d 'DATE'`. I tillegg støttes det ulike alternativer som kan konvertere dato- og tidsinformasjon til et ønsket format. **2. df** Bruk kommandoen `df` (*disk free*) i henhold til følgende mønster. ```bash df [OPTIONS] [FILE] ``` Hvis kommandoen brukes sammen med en bestemt fil, viser systemet kun ledig plass på den partisjonen der filen ligger. Ellers vises ledig harddiskplass på alle monterte partisjoner. Alternativet `-l` (*local*) begrenser `df` til det lokale filsystemet. Den støtter også alternativer som lar deg tilpasse utdataformatet. **3. dmesg** Programmet `dmesg` (forkortelse for *«display message»*) viser feilmeldinger fra kjernens sirkulære buffer i terminalen og gjør det mulig å lokalisere feil i maskinvare og drivere. Bruk `dmesg` etter følgende mønster: ```bash dmesg [OPTIONS] ``` Utdataene `dmesg` inneholder alle meldingene fra oppstartsrutinen, og er derfor ganske omfattende. Kommandolinjeprogrammet brukes ofte sammen med en pager, for eksempel `more`, `less` eller `tail`. **4. gratis** Kommandoen `free` viser minnebruken. Den generelle syntaksen er som følger: ```bash free [OPTIONS] ``` Som utdata får du to spesifikasjoner: `Mem` (*Minne*) og `Swap`. `Free` støtter også alternativet `-h` for å vise minnebruken i et lesbart format. **5. vertsnavn** Bruk kommandoen `hostname` etter følgende mønster for å vise systemets DNS-navn. ```bash hostname [OPTIONS] ``` **6. uname** Kommandolinjedirektivet `uname` står for `unix name` og brukes til å hente systeminformasjon fra kjernen. Kommandoen støtter ulike alternativer som gjør det mulig å filtrere utdataene etter ønsket informasjon. Disse finnes i den tilhørende man-siden. ```bash uname [OPTIONS] ``` **7. oppetid** Hvis du vil finne ut hvor lenge systemet har vært i drift siden forrige omstart, bruker du kommandolinjeparameteren `uptime` etter følgende mønster: ```bash uptime ``` **8. vmstat** Ved hjelp av overvåkingsverktøyet `vmstat` kan du få tilgang til informasjon om virtuelt minne, lese- og skriveoperasjoner på disken samt CPU-aktivitet. Bruk `vmstat` i henhold til følgende syntaks for å vise gjennomsnittsverdiene siden sist systemet ble startet. ```bash vmstat [OPTIONS] ``` `vmstat` har også en modus for kontinuerlig overvåking som henter systemverdier så ofte som ønsket, med et angitt tidsintervall i sekunder. ```bash vmstat [Options] [INTERVAL [REPETITIONS]] ``` ### Maskinvareinformasjon Linux-kommandoene i denne kategorien gir **detaljert informasjon om maskinvarekomponentene** som utgjør grunnlaget for systemet ditt. **1. lspci** Bruk `lspci` (forkortelse for *«list pci»*) etter følgende mønster for å vise detaljert informasjon om PCI-enheter. ```bash lspci [OPTIONS] ``` Se bruksanvisningen til operativsystemet ditt for mulige alternativer. **2. lsusb** Bruk `lsusb` (forkortelse for *«list usb»*) for å vise detaljert informasjon om USB-enheter i terminalen. ```bash lsusb [OPTIONS] ``` Se bruksanvisningen til operativsystemet ditt for mulige alternativer. ### Prosessstyring I Linux kalles en kjørende programinstans en prosess. Følgende terminalkommandoer inngår i standardverktøyet for prosessadministrasjon, og gjør det mulig å **enkelt overvåke alle prosesser på systemet ditt fra terminalen** og styre dem etter behov. **1. chrt** Kommandolinjeprogrammet `chrt` håndterer kontinuerlig prosessstyring og gjør det mulig å identifisere og tilpasse sanntidsattributtene (planleggingsregler og prioritet) til prosesser som kjører, eller å utføre kommandoer og deres argumenter med angitte sanntidsattributter. Den generelle syntaksen for kommandoen er: ```bash chrt [OPTIONS] [PRIOTITY] PID/COMMAND [ARGUMENT] ``` Bruk `chrt` uten å angi prioritet, og sammen med alternativet `-p` for å identifisere sanntidsattributtene til valgte prosesser. `chrt` gir også muligheten til å angi eller definere planleggingsreglene for pågående eller nystartede prosesser ved hjelp av alternativer. Mer informasjon om dette finnes i den tilhørende man-siden. **2. ionice** Kommandolinjedirektivet `ionice` brukes til å påvirke prioriteten til en prosess som bruker kjernens I/O-grensesnitt. Den generelle syntaksen for kommandoen er: ```bash ionice [OPTIONS] COMMAND ``` For å kunne kjøre ionice, må du ha root-rettigheter. Kommandoen skiller mellom tre planleggingsklasser som angis ved hjelp av alternativet `-c class`. Mulige verdier er 1, 2 og 3. - 1 = Sanntid: I/O-handlingen utføres umiddelbart. - 2 = Best effort: I/O-handlingen utføres så raskt som mulig. - 3 = Inaktiv: I/O-handlingen utføres bare når ingen andre prosesser bruker I/O-tid. **3. nohup** Normalt avsluttes alle brukerens avhengige prosesser automatisk så snart terminalsesjonen lukkes (dvs. via `exit`). [Linux-kommandoen `nohup`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-nohup/) (forkortelse for *«no hangup»*) fjerner en kommando fra den aktuelle sesjonen og lar deg holde den i gang selv når du logger ut av systemet. ```bash nohup COMMAND ``` **4. pidof** Kommandolinjeprogrammet `pidof` viser prosess-ID-ene (PID-ene) til alle prosessene i et program. Identifiser PID-ene ved hjelp av `pidof` i henhold til følgende mønster: ```bash pidof [OPTIONS] PROGRAM ``` Hvis du kun ønsker å vise den første prosess-ID-en, bruk `pidof` sammen med alternativet `-s` (forkortelse for *«single shot»*). **5. pidkill** I likhet med `kill` sender også `pkill` et signal til en valgt prosess. Adresseringen skjer imidlertid ikke ved hjelp av PID. I stedet angis et søkeord som samsvarer med navnet på den kjørende prosessen. Dette kan også formuleres som et regulært uttrykk. `pkill` videresender standardsignalet TERM, så lenge ingen andre signaler er definert. Kommandoens generelle syntaks er som følger: ```bash pkill [OPTIONS] [-SIGNAL] [SEARCHTERM] ``` Det finnes flere alternativer som kan brukes til å begrense kommandoen til prosessene til en bestemt bruker (`-U UID`), underprosessene til en bestemt overordnet prosess (`-P PID`), eller de nyeste (`-n`) eller eldste (`-o`) prosessene. **6. pstree** Bruk `pstree` for å vise alle aktive prosesser i en trestruktur. Kommandoens generelle syntaks er: ```bash pstree [OPTIONS] ``` Utdataens format og omfang kan tilpasses ved hjelp av ulike alternativer. **7. renice** Kommandolinjeparameteren `renice` lar deg tilpasse prioriteten til en prosess som kjører. Den generelle syntaksen er: ```bash renice PRIORITY [OPTIONS] ``` **8. søvn** [Kommandoen](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-sleep/) `[Linux`sleep`](t3://page?uid=25828)` lar deg avbryte den aktuelle terminalsesjonen i en angitt tidsperiode. Den generelle syntaksen for kommandoen er: ```bash sleep NUMBER[SUFFIX] ``` Hvis du bruker `sleep` uten suffiks, tolkes tallet som tid i sekunder (s). Du kan også velge å avbryte terminalsesjonen etter minutter (m), timer (h) eller dager (d). **9. oppgavesett** Kommandolinjedirektivet `taskset` brukes til avansert prosessstyring, som benyttes i flerprosessorsystemer for å tilordne prosesser eller kommandoer til bestemte prosessorer. Kommandoen krever root-rettigheter og bruker ett av følgende mønstre: ```bash taskset [OPTIONS] MASK COMMAND taskset [OPTIONS] -p PID ``` Tildeling av en prosess eller kommando til en prosessor skjer ved hjelp av en heksadesimal bitmaske. Siden en slik tildeling via bitmaske ikke er særlig intuitiv, brukes `taskset` vanligvis sammen med alternativet `-c` (–cpu-list) for å muliggjøre numerisk tildeling av prosessorer (f.eks. 0, 5, 7, 9–11). ### Personsøker Vil du bruke oversikten din til å holde oversikt over innholdet i filer med flere sider? Med et kommandolinjeprogram fra kategorien «pager» kan du velge hvilke deler som skal vises i terminalen og bla gjennom filen i interaktiv modus om nødvendig. **1. hode** Kommandoen `[Linux`head`](t3://page?uid=3151)` brukes til å vise den første delen av en fil. Den generelle syntaksen for kommandoen er: ```bash head [OPTIONS] File ``` Bruk alternativ `-n NUMBER_LINES` til å angi hvor mange linjer som skal skrives ut, regnet fra begynnelsen. **2. mindre** Kommandolinjeprogrammet `less` gjør det mulig å vise innholdet i en tekstfil i terminalen. Den generelle syntaksen er: ```bash less [OPTIONS] FILE ``` Visningen starter automatisk i interaktiv modus. Dette gjør at du kan bla gjennom det valgte dokumentet eller søke etter nøkkelord. \[Q\]-tasten avslutter den interaktive lesemodusen. Du finner informasjon om andre kontrolltaster og tilgjengelige alternativer i programhåndboken. **3. hale** Mens `head` som standard viser de første 10 linjene i en valgt fil, viser Linux-kommandoen tail de siste 10. Begge sidevisningsprogrammene brukes på samme måte (se `head`). ### Redaktører Under Linux trenger du ikke et grafisk tekstredigeringsprogram for å tilpasse konfigurasjonsfiler, redigere kodebiter eller skrive korte notater. **Enkle tekstredigeringsprogrammer** kan enkelt startes opp i terminalen uten forsinkelser. Her presenterer vi tre programmer du bør kjenne til. **1. emacs** *Emacs* er et plattformuavhengig tekstredigeringsprogram som kan utvides etter behov ved hjelp av et programmeringsgrensesnitt. Som standard starter Emacs med et grafisk brukergrensesnitt, men kan også åpnes i terminalen ved å bruke alternativet `--no-window-system`. ```bash emacs --no-window-system ``` Emacs har en innebygd veiledning som du kan åpne ved å trykke på tastkombinasjonen \[CTRL\] + \[H\], \[T\]. **2. nano** Nano er en terminalbasert tekstredigerer. Nano har et mindre funksjonsutvalg enn tilsvarende redigeringsprogrammer (f.eks. *Vim*), men kjennetegnes av en særlig brukervennlig betjening. Den generelle syntaksen for programkommandoen er: ```bash nano [OPTIONS] FILE ``` Programmet åpner den angitte filen i et redigeringsvindu i terminalen. Hvis du starter Nano uten å oppgi filnavn, opprettes det en ny tekstfil som lagres i den valgte mappen. **3. vim** Vim (forkortelse for *«Vi Improved»*) er en videreutvikling av tekstredigeringsprogrammet *Vi*, og utmerker seg ved en rekke funksjoner som syntaksmarkering, et omfattende hjelpesystem, innebygd skripting, automatisk kodekomplettering og visuell tekstmarkering. Dette åpen kildekode-programmet tilbyr ulike driftsmoduser for redigering av rene tekstfiler, og kan brukes enten i terminalen eller som et frittstående program med et grafisk brukergrensesnitt (*GVim*). Et sentralt bruksområde for programmet er redigering av programkode. Hvis du starter Vim i konsollen, styres programmet via tastaturet. Vanligvis startes programmet sammen med en tekstfil etter følgende mønster: ```bash vim [OPTIONS] FILE ``` Vim tilbyr programmet `vimtutor` som en omfattende introduksjon, som også startes fra kommandolinjen. Vår grunnleggende artikkel om Linux-editoren Vim gir også ytterligere informasjon om installasjon og programmets ulike driftsmoduser. ### Nettverksadministrasjon **Nettverksadministrasjon kan** også enkelt håndteres fra terminalen i Linux. Enten du ønsker å teste tilkoblingen, hente DNS-informasjon, konfigurere grensesnittet eller overføre filer til en annen datamaskin i nettverket, er det nok med én enkelt kommando i de følgende programmene for å sette prosjektet i gang. **1. arp** Kommandolinjeprogrammet `arp` lar deg få tilgang til og endre operativsystemets ARP- buffer. Bruk `arp` uten tilleggsargumenter for å vise innholdet i ARP-tabellen i terminalen. ```bash arp [OPTION] ``` Alternativt kan du begrense utdataene ved hjelp av alternativer, eller opprette eller slette oppføringer: - `-a HOSTNAME` = Begrens utdata til oppføringer for bestemte vertsnavn (alternativ til en IP-adresse) - `-s HOSTNAME MAC_ADDRESS` = Opprett ARP-oppføring med angitt vertsnavn og MAC-adresse - `-d HOSTNAME` = Slett APR-oppføring **2. iw** Kommandolinjeprogrammet `iw` brukes til konfigurering av WLAN-grensesnitt og er etablert som et aktuelt alternativ til `iwconfig`. Kommandoen er basert på en syntaks som ligner på den som brukes i kommandoen `ip`: ```bash iw [OPTIONS] OBJECT [COMMAND] ``` Mulige objekter er: - dev NAME\_OF\_INTERFACE = Nettverksgrensesnitt - phy NAVN\_PÅ\_ENHET = WLAN-enhet (etter navn) - phy#INDEX\_OF\_DEVICE = WLAN-enhet (etter indeks) - reg = Reguleringsagent for konfigurering av regionale og nasjonale innstillinger En oversikt over mulige kommandoer og alternativer finnes i den tilhørende man-siden. **3. nslookup** I likhet med `dig` er også nslookup en tjeneste for navneoppløsning. Kommandolinjeprogrammet er tilgjengelig i to moduser: interaktiv og ikke-interaktiv. Hvis du vil bruke `nslookup` i ikke-interaktiv modus, må du starte programmet sammen med et vertsnavn eller en IP-adresse. ```bash nslookup [OPTIONS] [HOST/IP] ``` For å starte interaktiv modus, skriv inn kommandoen `nslookup` i terminalen uten ytterligere opplysninger, og skriv deretter inn vertsnavn eller IP-adresser for å vise tilhørende IP-adresser eller vertsnavn. Siden programmet **offisielt** er **utdatert**, oppfordres brukerne til å bruke `dig` i stedet. **4. rsync** Kommandolinjeprogrammet `rsync` lar deg synkronisere filer lokalt eller over et nettverk. Til dette formålet sammenlignes størrelsen og endringstidspunktet for de aktuelle filene. Syntaksen for kommandoen er: ```bash rsync [OPTIONS] SOURCE(S) TARGET ``` Kommandoen rsync brukes vanligvis med alternativet `-a`, som sikrer at alle underkataloger og symbolske lenker kopieres og at alle brukerrettigheter overføres. **5. scp** Med Linux-kommandoen scp (forkortelse for *«secure copy»*) er det mulig å bruke et annet program for sikker dataoverføring i nettverket direkte via terminalen. `scp` kopierer data fra én datamaskin til en annen og bruker nettverksprotokollen SSH. Klientprogrammet fungerer på samme måte som filkommandoen `cp`, men brukes systemomfattende i henhold til følgende syntaks: ```bash scp [OPTIONS] FILE [[user@]remote_host:]PATH ``` Når du angir banen til den eksterne datamaskinen, settes brukernavnet og det tilhørende vertsnavnet foran. Lokale filer angis eksplisitt ved hjelp av relative eller absolutte baner. Eksempel: ```bash scp/home/max/images/image.jpg max@example.com:/home/max/archive ``` Med flere alternativer kan du justere overføringsmodus og krypteringsinnstillingene. **6. tty** Kommandolinjedirektivet `tty` viser filnavnene til terminalen som er angitt som standardinngang. Den generelle syntaksen for kommandoen er: ```bash tty [OPTIONS] ``` ### Arkiver og komprimer Linux tilbyr ulike teknologier som kan brukes til å pakke og komprimere filer i arkiver. Det er verdt å merke seg at **ikke alle arkiver inneholder komprimering**. Derfor brukes `tar` – et program for arkivering av filer – vanligvis sammen med et komprimeringsprogram som `gzip`, `bzip2` eller `xz`. **1. gzip** `gzip` er et program som lar deg enkelt komprimere eller pakke ut filer via kommandolinjen. Den generelle syntaksen for kommandoen er: ```bash gzip [OPTIONS] FILE(S) ``` Merk at `gzip` som standard sletter den opprinnelige filen som en del av komprimeringsprosessen. Du kan forhindre dette ved å bruke alternativet `-k`. Programmet kan brukes på flere filer samtidig, om nødvendig. Hver utdatafil konverteres til en egen `gz`. Hvis du ønsker å lagre flere filer i ett enkelt komprimert arkiv, bruk `gzip` sammen med arkiveringsprogrammet `tar`. Hvis du vil pakke ut en gz-fil, bruker du kommandoen `gzip` med alternativet `-d`. **2. bzip2** Et populært alternativ til `gzip` er kommandolinjeprogrammet `bzip2`. Dette bruker samme syntaks som `gzip`, men er basert på en tretrinns komprimeringsprosess som gir en betydelig høyere komprimeringsgrad. Filer som er komprimert med bzip2, har filtypen `.bz2`. Bruk `bzip` i henhold til følgende mønster for å komprimere filer: ```bash bzip2 [OPTIONS] FILE(S) ``` `bzip2` kan også brukes på `tar` -arkiver. Dekomprimeringen foregår på samme måte som for `gzip` og utføres ved hjelp av alternativet `-d`. **3. xz** Kommandolinjeprogrammet `xz` konverterer filer til det like navngitte datakomprimeringsformatet `xz`. Programkallet følger samme mønster som `gzip` og `bzip2`. ```bash xz [OPTIONS] FILE(S) ``` Filer som er komprimert med `xz`, har filtypen `.xz`. Dekomprimeringen fungerer på samme måte som med `gzip` og `bzip`, med alternativet `-d`. Kommandoen `unxz` kan også brukes. I likhet med gz- og bz2-filer er heller ikke xz-filer arkivfiler. Hvis du ønsker å samle flere filer i én og samme komprimerte xz-fil, må du også bruke arkiveringsverktøyet `tar` sammen med dette komprimeringsprogrammet. **4. cpio** Arkiveringsprogrammet `cpio` (forkortelse for *«copy in, copy out»*) lar deg skrive data til en arkivfil (.cpio) og hente ut data fra den. ### Partisjonsadministrasjon Hvis du vil få tilgang til et filsystem på en annen partisjon i Linux, må du først integrere det i operativsystemets katalogstruktur. Dette kalles å «montere» en partisjon. Om nødvendig kan dette gjøres via det grafiske brukergrensesnittet. Kommandolinjeprogrammer som `lsblk`, `blkid` og `mount` gir også muligheten til å hente informasjon om tilkoblede blokklagringsenheter og til å montere eller demontere dem når det er nødvendig. **1. lsblk** Bruk kommandoen `lsblk` (forkortelse for *«list block devices»*) for å vise alle tilkoblede blokklagringsenheter og partisjoner i en trestruktur. Disse trenger ikke nødvendigvis å være involvert. Kommandoen følger følgende syntaks: ```bash lsblk [OPTIONS] ``` Om nødvendig kan utdataene og listen over ønskede attributter tilpasses individuelt ved hjelp av alternativet `-o` (*–output*) for å hente ytterligere informasjon, som identifikasjonsnummer (UUID), filsystem (FSTYPE) eller status (STATE). I standardinnstillingene blir tomme lagringsenheter utelatt. Hvis du også ønsker å inkludere disse i oversikten, bruker du `lsblk` sammen med alternativet `-a` (*–all*). Hvis du kun ønsker å hente informasjon om en bestemt enhet, bruker du `lsblk` etter følgende mønster: ```bash lsblk [OPTIONS] DEVICE ``` **2. blkid** I likhet med `lsblk` gir også `blkid` informasjon om tilkoblede blokklagringsenheter. Bruk `blkid` i henhold til følgende mønster for å hente identifikasjonsnummeret (`UUID`) og filsystemtypen (`TYPE`) for alle tilkoblede blokklagringsenheter. ```bash blkid [OPTIONS] ``` For tabellformet utdata bruker du alternativet `-o` sammen med verdien `list`. Du kan også begrense `blkid` til en valgt enhet: ```bash blkid [OPTIONS] DEVICE ``` ### Diverse Listen nedenfor inneholder flere grunnleggende Linux-kommandoer som ikke faller inn under noen av de tidligere kategoriene. **1. alias** Kommunikasjonen med skallet skjer vanligvis via kommandoer som kan brukes til å starte **kommandolinjeprogrammer** med samme navn. Du bruker et programkall for hver handling du ønsker å utføre via terminalen. [Kommandoen `alias` i Linux](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-alias/) lar deg definere korte navn for programkall. Bruk `alias` i henhold til følgende mønster: ```bash alias NICKNAME= 'COMMAND' ``` Erstatt plassholderen COMMAND med en hvilken som helst kommandolinjedirektiv, inkludert alternativer. Dette vil koble den innsatte strengen til plassholderen NICKNAME. **2. kl.** Kjør kommandolinjeprogrammet `at` etter følgende mønster for å utføre en tidsstyrt kommando. ```bash at TIME ``` Skriv deretter inn kommandoen og lukk den interaktive modusen med \[CTRL\] + \[D\]. **3. cal** Bruk `cal` i henhold til følgende mønster for å vise en kalender i terminalen. ```bash cal [OPTIONS] [[MONTH] Year] ``` **4. pr** Bruk kommandolinjeprogrammet `pr` til å klargjøre tekstfiler for utskrift. Kommandoens generelle syntaks er som følger: ```bash pr [OPTIONS] File ``` I standardinnstillingene genererer `pr` en sidetittel som inneholder filnavnet, dagens dato og sidetall. **5. manus** Kommandolinjeprogrammet `script` lar deg ta opp en terminalsesjon i filen `typescript`. Hvis det allerede finnes en opptak av en tidligere sesjon i `typescript`, blir denne overskrevet. Opptaket starter automatisk når programmet startes: ```bash script ``` Bruk tastkombinasjonen \[CTRL\] + \[D\] for å avslutte opptaket. Hvis du ønsker å lagre opptaket i en annen fil enn `typescript`, trykker du på `script` sammen med et filnavn eller en filbane. **6 ff.** Bruk kommandoen `seq` for å skrive ut en tallrekke til standardutdata. Angi en startverdi, en sluttverdi og et trinn (valgfritt). ```bash seq [OPTIONS] STARTVALUE INCREMENT ENDVALUE ``` **7. tasksel** Kommandolinjeprogrammet `tasksel` fungerer som installasjonshjelp for standardapplikasjoner (e-postserver, DNS-server, OpenSSH-server, LAMP-server osv.). Bruk verktøyet til å installere alle pakker og programmer som kreves for en oppgave automatisk, i riktig rekkefølge. Kjør `tasksel` med alternativet `--list-tasks` for å vise en liste over alle tilgjengelige standardapplikasjoner. ```bash tasksel --list-tasks ``` Hvis du ønsker mer informasjon om et standardprogram på listen, bruk `tasksel` sammen med alternativet `--task-desc` og den tilhørende oppgaven. Hvis du ønsker å vise alle pakker som tilhører oppgaven «mail-server», bruk `tasksel` sammen med alternativet `--task-packages`. For å installere alle pakkene til et standardprogram, bruk underkommandoen `install`. Dette krever root-rettigheter. **8. tee** Kommandoen `[Linux`tee`](t3://page?uid=23016)` brukes til å doble utdataene fra et program. Den ene utdataen sendes til standardutdata, mens den andre skrives til filen som angis med kommandoen ``tee``. ```bash tee [OPTIONS] FILE ``` `tee` brukes vanligvis sammen med omdirigeringsoperatoren Pipe (`|`). ```bash ls | tee example.txt ``` **9. gang** Bruk kommandoen `time` etter følgende mønster for å finne ut hvor lenge programmene du har startet via terminalen, har kjørt. ```bash time [OPTIONS] Command [ARGUMENTS] ``` **10. tr** Bruk `tr` til å slette et ønsket tegnsett eller erstatte det med et annet. For å gjøre dette leser `tr` datastrømmen fra standardinngangen (f.eks. en fil) og skriver den til standardutgangen i henhold til den ønskede endringen. Hvis et tegnsett skal erstattes av et annet, brukes `tr` med to argumenter. ```bash tr OPTION CHARACTERSET1 CHARACTERSET2 ``` Det andre argumentet (CHARACTERSET2) erstatter det første (CHARACTERSET1). Hvis du vil slette en tegnsekvens, bruker du `tr` sammen med alternativet `-d` og angir settet som skal slettes som argument. ```bash tr -d CHARACTERSET ``` Kommandolinjeprogrammet brukes vanligvis sammen med omdirigeringsoperatorene (< og >) for å endre filer. ```bash tr 'a-z' 'A-Z' < example1.txt > example2.txt ``` `tr` leser inn innholdet i filen `example1.txt`, erstatter små bokstavene a til z med store bokstaver og skriver resultatet til filen `example2.txt`. **11. vegg** Kommandolinjeprogrammet `wall` lar deg sende en melding til alle brukere som er registrert på et system. For å sende en melding starter du programmet med følgende kommando: ```bash wall ``` Bekreft programvalget med \[Enter\] og skriv inn meldingen din. Bekreft deretter igjen med \[Enter\] og send med tastkombinasjonen \[CTRL\] + \[D\]. Alle brukere som er registrert i systemet, mottar meldingen din som en kringkastingsmelding i terminalen. Det er verdt å merke seg at du må gi andre brukere skriveadgang til terminalen din for at de skal kunne motta meldinger. Bruk kommandoen `mesg` til dette: Hvis du vil sende filinnhold til alle registrerte brukere, bruk `wall` sammen med en innspillingsomdirigering og det aktuelle filnavnet: ```bash wall < FILENAME ``` **12. se** Kommandolinjeprogrammet `watch` lar deg angi en kommando som skal kjøres med jevne mellomrom. Kommandoen skrives etter følgende syntaks: ```bash watch [OPTIONS] COMMAND ``` Tidsintervallet som kommandoen angitt i `watch` skal kjøres med, defineres med alternativet `-n SECONDS`. Avslutt `watch` med tastkombinasjonen \[CTRL\] + \[C\]. **13. toalett** [Kommandoen Linux `wc`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-wc/) (forkortelse for *«word count»*) viser antall linjer, ord, bokstaver, tegn og/eller byte i en tekstfil, etter ønske. Kommandoens generelle syntaks er: ```bash wc [OPTIONS] FILE ``` Hvis `wc` kjøres uten alternativer, tilsvarer utdataene mønsteret `LINES WORDS CHARACTERS FILE`. For filtrert utdata støtter kommandolinjeprogrammet følgende alternativer: `-l` (linjer), `-c` (bytes), `-m` (tegn), `-L` (lengden på den lengste linjen) og `-w` (ord). **14. xargs** [Kommandoen Linux `xargs`](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoen-xargs/) lar deg overføre utdataene fra en tidligere kommando til en ny kommando som et argument. Vanligvis brukes dette sammen med Pipe (`|`) som en omdirigeringsoperator. Bruk `xargs` i henhold til følgende syntaks: ```bash COMMAND1 | xargs [OPTIONS] COMMAND2 ``` `xargs` kan for eksempel brukes sammen med kommandoen `find`. I det følgende eksemplet identifiserer `find` alle filer i den gjeldende katalogen som samsvarer med søkeordet `*.tmp`, og sender navnene deres til standardutdata. Der blir filnavnene fra `xargs` hentet og sendt videre som argumenter til kommandoen `rm`. ```bash find . -name '*.tmp' | xargs rm ``` Oversikten som presenteres her gjør ikke krav på å være fullstendig, men inneholder grunnleggende Linux-kommandoer med utvalgte eksempler på bruk i det daglige arbeidet med Unix-lignende operativsystemer. En utførlig beskrivelse av kommandolinjeprogrammene som presenteres her, samt alle andre kommandoer, finner du i operativsystemets brukerhåndbok. En nettversjon av disse hjelpe- og dokumentasjonssidene er tilgjengelig via [Linux man-pages-prosjektet](https://www.kernel.org/doc/man-pages/ "Linux man-pages project by Michael Kerrisk") av Michael Kerrisk. This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoer-en-oversikt-over-terminalkommandoer/](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoer-en-oversikt-over-terminalkommandoer/) for AI/LLM consumption.