# En oversigt over de vigtigste Linux-kommandoer Ligesom de fleste moderne operativsystemer indeholder Linux også en **shell**, som du kan bruge til at styre dit system via **kommandolinjekommandoer**. Alle de indstillinger, du foretager via den grafiske brugergrænseflade (GUI), kan også foretages via shellen. Vi viser dig de vigtigste Linux-kommandoer og forklarer deres funktion og anvendelse. ## Liste over de 50 vigtigste Linux-kommandoer
Kommando Beskrivelse
sudo Kør programmer med en anden brugers rettigheder
ls Vis indholdet af et bibliotek
cd Navigation i mappestrukturen
touch Opret ny fil
mkdir Opret ny mappe
rm Slet fil
rmdir Slet mappe
mv Flyt fil eller mappe
cp Kopier fil eller mappe
pwd Vis nuværende placering i mappestrukturen
zip Skriv filer til zip-arkiver
unzip Udpak filer fra zip-arkiver
ln Opret symbolsk link
cat Kombiner filindhold
grep Søg i tekstfiler
diff Find forskelle mellem tekstfiler
cmp Juster filer på byte-niveau
tar Skriv og udpak filer til tar-arkiver
echo Udskriv streng til standardspecifikationen
clear Ryd terminal
ssh Opret forbindelse til en anden computer via en *sikker shell*
wget Download fil direkte fra internettet
ping Forespørg server og mål ventetid
ftp, sftp Overfør filer via (S)FTP
ip forespørg og konfigurer netværksgrænseflader
apt/pacman/yum Download og administrer softwarepakker
netstat Vis status for netværksgrænseflader
traceroute Spor datapakker
route Vis og rediger IP-routingtabeller
dig Anmod om DNS-oplysninger
mount/unmount Integrer filsystemer (opsæt/monter)
dd Kopier filer, partitioner eller datamedier bit for bit
chmod Administrer adgangsrettigheder
chown Administrer ejerskabsrettigheder
adduser Tilføj/rediger brugerkonto
passwd Opret/rediger adgangskoder til brugerkonti
groupadd Opret brugergrupper
chattr Administrer filattributter
lsattr Vis filattributter
chgrp Administrer gruppetilhørsforhold for filer og mapper
man Åbn brugervejledning
shutdown, reboot Luk/genstart systemet
top Dynamisk procesoversigt
lscpu Vis processoroplysninger
lshw Vis hardwareoplysninger
kill Stop og afslut proces via PID
killall Stop og afslut processer via navn
nice Definer procesprioriteter
pgrep Identificer PID via søgeord
ps Vis liste over alle kørende processer
### sudo-kommandoen i Linux [Linux-kommandoen `sudo`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-sudo/)(*substitute user do*) gør det muligt at køre et program med en anden brugers rettigheder. Som regel kræves der en adgangskode for at udføre dette. Kommandoen `sudo` beder altid om adgangskoden til den brugerkonto, der skal kaldes frem. Hvis kommandoen indtastes uden et brugernavn, angives superbrugeren root som målbruger. ```bash sudo -u USERNAME PROGRAM CALL ``` ### ls-kommandoen i Linux ls `ls` står for *»list«* og bruges til at vise indholdet af et bibliotek (navnene på alle filer og mapper, der findes i det pågældende bibliotek). Kommandoens syntaks er som følger: ```bash ls [OPTIONS] DIRECTORY ``` Hvis man bruger `ls` uden at angive et bibliotek, viser kommandoen indholdet af det aktuelle bibliotek. Ved hjælp af yderligere indstillinger kan man angive, hvilke oplysninger der skal vises, og hvordan de skal præsenteres. ### cd-kommandoen i Linux [Kommandoen](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-cd/) `[`cd`](t3://page?uid=25699)` [ `cd` Linux](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-cd/) står for *»change directory*« og bruges til at navigere i mappestrukturen. Kommandoens syntaks er som følger: ```bash cd [OPTION] DIRECTORY ``` Hvis der ikke angives nogen målmappe, skifter `cd` automatisk til brugerens hjemmemappe. Hvis `cd` bruges efterfulgt af et minustegn (-), skifter den tilbage til den forrige mappe. ### touch-kommandoen i Linux [Linux-kommandoen `touch`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-touch/) kan bruges til at ændre filers adgangs- og ændringstidspunkter. Hvis `touch` anvendes på en fil, der endnu ikke findes, oprettes den automatisk, hvilket betyder, at kommandoen også kan bruges til at oprette tomme filer. Brug `touch` efter følgende mønster: ```bash touch [OPTIONS] FILE ``` For at indstille tidsstemplet for en fil til den ønskede dato skal du bruge OPTION `-t` sammen med tidsoplysningerne i formularerne `[YY]MMDDhhmm[.ss]`. Eksempel: ```bash touch -t 1703231037 file.txt ``` Tidspunkter for adgang og ændringer er nu sat til 23. marts 2017, kl. 10:37. Ændringen kan begrænses til enten adgangs- eller ændringstidspunkter ved hjælp af indstillingerne `-a` og `-m`. Hvis kommandoen `touch` bruges uden indstilling `-t`, anvendes det aktuelle tidspunkt. ### Kommandoen `mkdir` i Linux [Kommandoen](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-mkdir/) `[Linux`mkdir`](t3://page?uid=25750)` står for *»make directory*« og giver Linux-brugere mulighed for at oprette nye mapper. Brug følgende syntaks til at oprette en ny mappe i den aktuelle mappe: ```bash mkdir [OPTION] DIRECTORY NAME ``` Hvis der skal oprettes en mappe i en bestemt målmappe, skal du angive den absolutte eller relative sti til mappen. ### rm-kommandoen i Linux Kommandoen `[linux`rm`](t3://page?uid=25585)` (*remove*) sletter filer eller hele mapper permanent. Kommandoen bruges med følgende syntaks: ```bash rm [OPTIONS] FILE/DIRECTORY ``` Hvis en mappe skal slettes sammen med alle dens undermapper, skal du bruge `rm` sammen med indstillingen `-R` (*–recursive*). ### Kommandoen `rmdir` i Linux Hvis du vil slette et bestemt bibliotek, skal du bruge kommandolinjeparameteren `rmdir` (*fjern bibliotek*) i henhold til følgende syntaks: ```bash rmdir [OPTION] DIRECTORY ``` Du kan kun slette tomme mapper med `rmdir`. Hvis du vil slette en mappe sammen med alle dens filer og undermapper, skal du bruge kommandoen `rm` (*remove*) med parameteren `–r`. I andre artikler kan du finde flere måder at slette en Linux-fil eller et Linux-mappe på. ### mv-kommandoen i Linux [Kommandoen](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-mv/) `*move*` [ `mv` Linux](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-mv/) kopierer en fil eller et bibliotek og sletter det oprindelige element. Hvis den bruges inden for det samme bibliotek, kan `mv` bruges til at omdøbe filer. Programkaldet er baseret på følgende syntaks: ```bash mv [OPTIONS] SOURCE TARGET ``` ### cp-kommandoen i Linux Linux-kommandoen cp (*copy*) bruges til at kopiere filer og mapper. Kommandoens grundlæggende syntaks er: ```bash cp [OPTIONS] SOURCE TARGET ``` KILDEN er det element, der skal kopieres. Derefter angives enten en fil eller en mappe som MÅL for kopieringsprocessen. Hvis du angiver en eksisterende fil som målfil, overskrives dens indhold med kildefilen. Du har også mulighed for at oprette en ny fil med et navn efter eget valg som målfil. ### pwd-kommandoen i Linux Brug \[kommandoen `linux`pwd`](t3://page?uid=25824)` (forkortelse for *»print working directory«*) til at få vist navnet på det aktuelle arbejdsmappe. Kommandoens syntaks er som følger: ```bash pwd [OPTIONS] ``` ### zip-kommandoen i Linux Brug kommandoen `zip` til at komprimere flere filer til et zip-arkiv. Kommandoens syntaks er: ```bash zip DESTINATION FILES ``` DESTINATION er navnet eller stien til den færdige zip-fil. FILES angiver filnavnene eller stierne til de filer, der skal komprimeres (adskilt af mellemrum). ### Kommandoen ‘unzip’ i Linux Du kan bruge `unzip` til at udpakke filer fra zip-arkiver. Syntaksen er: ```bash unzip FILE.zip -d DESTINATION ``` Her henviser FILE til de zip-arkiver, hvorfra filerne skal udpakkes. Du kan eventuelt bruge indstillingen -d TARGET til at angive et målkatalog, hvor de resulterende filer skal gemmes. Ellers gemmes filerne i det aktuelle katalog. ### ln-kommandoen i Linux Kommandoen `[linux`ln`](t3://page?uid=2998)` (forkortelse for *`link`*) opretter en genvej til en fil eller et bibliotek. Dette skaber en ekstra bibliotekshenvisning til denne fil, hvilket giver dig mulighed for at få adgang til den pågældende fil via en anden filsti. Opkaldet til `ln` skal altid indeholde mindst stien til kildefilen. ```bash ln [OPTIONS] path/to/sourcefile ``` I dette tilfælde oprettes der en genvej i det aktuelle arbejdsbibliotek med samme navn. Du kan også indtaste en målsti og derefter give genvejen det navn, du ønsker: ```bash ln [OPTIONS] path/to/sourcefile path/to/shortcut ``` ### cat-kommandoen i Linux Kommandoen Linux cat (forkortelse for *»concatenate«*) blev udviklet som et værktøj til sammenkædning af filindhold og kan bruges som en pager til visning af filindhold i terminalen. Brug `cat` med følgende syntaks i terminalen til at læse en fil og sende den til `stdout` (standardudgangen): ```bash cat OPTIONS FILE ``` Flere filer kan adskilles med mellemrum: ```bash cat OPTIONS FILE1 FILE2 ``` ### grep-kommandoen i Linux Med kommandoen Linux grep kan du søge i tekstfiler. Alle tegnstrenge eller regulære udtryk kan bruges som søgemønster. Brug `grep` i henhold til følgende syntaks: ```bash grep [OPTIONS] SEARCH PATTERN [FILE(S)] ``` Hvis `grep` finder en streng, der svarer til søgemønsteret, vises linjenummeret sammen med filnavnet på skærmen. Som udgangspunkt anvendes `grep` på alle filer i det aktuelle bibliotek. Indstillingen `-r` aktiverer en rekursiv søgning i underbibliotekerne. ### diff-kommandoen i Linux Kommandolinjeprogrammet `diff` bruges til at sammenligne to filer. Du kan også bruge `diff` til at kontrollere, om to mapper indeholder de samme filer. Start programmet i terminalen ved hjælp af følgende syntaks: ```bash diff [OPTIONS] FILE1 FILE2 ``` ### cmp-kommandoen i Linux `cmp` er en del af `diff` og bruges til at sammenligne filindhold. I modsætning til `diff` foregår sammenligningen på byte-niveau og er derfor særligt velegnet til binære filer. Brug `cmp` i henhold til følgende syntaks: ```bash cmp [OPTIONS] FILE1 FILE2 ``` Hvis `cmp` finder afvigelser, viser kommandolinjeprogrammet byte- og linjenummeret for den første afvigelse i terminalen. ### tar-kommandoen i Linux Med kommandoen `tar` kan du skrive forskellige filer og mapper sekventielt til en `tar` og bruge den som sikkerhedskopi til gendannelse, hvis det bliver nødvendigt. I modsætning til det zip-format, der er almindeligt i Windows, bevares alle brugerrettighederne til den arkiverede fil, selv efter udpakning. Brug følgende syntaks: ```bash tar [OPTIONS] FILES ``` Hvis du vil oprette et nyt arkiv, skal du bruge `tar` sammen med indstillingerne `-c` (opret nyt arkiv) og `-f` (skriv arkivet til en angiven fil eller læs fra den). Læs mere i vores artikel om tar-sikkerhedskopier og hvordan man opretter arkiver under Linux. ### echo-kommandoen i Linux Brug \[kommandoen `Linux`echo`](t3://page?uid=3405)` til at skrive strenge ud linje for linje på standardudgangen (normalt terminalen). Den generelle kommandosyntaks lyder således: ```bash echo [OPTIONS] STRING ``` ### clear-kommandoen i Linux Brug kommandolinjedirektivet `clear` til at rydde skærmens indhold. ```bash clear ``` Du får en tom terminal med en kommandolinje. De ældre indtastninger forbliver i scrollback-bufferen. I stedet for at bruge denne kommando kan du også rydde terminalen ved at trykke på tastkombinationen \[Ctrl\] + \[L\]. ### ssh-kommandoen i Linux Du kan bruge `ssh` til at oprette forbindelse mellem din computer og en ekstern computer via SSH-protokollen, hvilket betyder, at du derefter befinder dig i den anden computers shell. Syntaksen er som følger: ```bash ssh USERNAME@HOSTNAME ``` Her angiver USERNAME og HOSTNAME det brugernavn, du ønsker at logge ind med, og adressen på den eksterne computer. ### wget-kommandoen i Linux Du kan bruge \[kommandoen `Linux`wget`](t3://page?uid=25698)` til at downloade filer fra internettet. Brug følgende syntaks til dette: ```bash wget [OPTION] LINK ``` Her angiver LINK den URL, hvor filen kan findes. Du kan eventuelt bruge det valgfri argument `-c` til at genoptage en afbrudt download. ### ping-kommandoen i Linux Brug \[kommandoen `linux`ping`](t3://page?uid=25690)` til at teste, om andre computere i netværket er tilgængelige. Kommandoen følger denne syntaks: ```bash ping [OPTIONS] TARGET ``` Ud over rundrejsetiden (*RTT*) – det tidsrum, der går mellem afsendelse af datapakken og modtagelse af et svar – skriver `ping` også IP-adressen på målsystemet i terminalen. Du kan bruge valgfrie argumenter til at angive antallet af pakker eller sekunder, hvorefter `ping` afslutter sig selv. ### ftp- eller sftp-kommandoen i Linux Dette giver dig mulighed for at udveksle filer mellem det lokale system og en anden computer i netværket. Brug FTP (File Transfer Protocol) i henhold til følgende syntaks for at oprette forbindelse til FTP-serveren på målcomputeren: ```bash ftp [OPTIONS] [HOST[PORT]] ``` Adresseringen sker via værtsnavn eller IP-adresse. Det er valgfrit at angive et portnummer. Brug kun FTP i netværk, du stoler på, da denne protokol ikke er sikker. Af sikkerhedsmæssige årsager er det næsten altid tilrådeligt at bruge SFTP (SSH File Transfer Protocol). Kommandolinjeprogrammet `sftp` fungerer som `ftp` til at overføre data i netværket, men her er overførslen krypteret. SFTP bruger Secure Shell (SSH) som standard, dvs. også dets godkendelsesmetoder. Vi forklarer, hvordan du bruger SSH-nøgler til din netværksforbindelse i en anden artikel. ### ip-kommandoen i Linux Kommandolinjeprogrammet `ip` er en del af programsamlingen `iproute2`, som bruges til at anmode om og konfigurere netværksgrænseflader via terminalen. Den generelle syntaks for kommandoen er: ```bash ip [OPTIONS] OBJECT [COMMAND [ARGUMENT]] ``` Hvilken handling der udføres af `ip`, defineres ved hjælp af objekter, underkommandoer og deres argumenter. Programmet understøtter forskellige objekter, såsom `address` (IP-adresse), `link` (netværksgrænseflade), `route` (post i routingtabellen) eller `tunnel`, hvortil der kan tilføjes underkommandoer som `add`, `change`, `del`, `list` eller `show`. Hvis du f.eks. vil hente IP-adressen for et bestemt netværkskort (dvs. `eth0`), skal du bruge kommandoen `ip` sammen med objektet `address`, kommandoen `show` og argumentet `dev eth0`: ```bash ip address show dev eth0 ``` I en anden artikel vil vi vise dig mere detaljeret, hvordan du viser en IP-adresse i Linux. ### Kommandoerne apt, pacman og yum i Linux Alle Linux-distributioner har en **pakkehåndtering**, som du kan bruge til at downloade og administrere softwarepakker. Syntaksen til installation af programmer 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å den pakke eller det program, du vil installere. I de fleste tilfælde skal disse kommandoer udføres via `sudo` i root-tilstand. For andre distributioner, der bruger andre pakkehåndteringsprogrammer, kan kommandoerne være anderledes. Hvert program har også kommandoer til blandt andet at fjerne pakker, opdatere pakkelisten og opdatere alle installerede pakker. På Ubuntu er disse kommandoer som følger. ```bash apt remove [PACKET] # remove package apt update # update package list apt upgrade # upgrade packages ``` ### netstat-kommandoen i Linux Kommandolinjeprogrammet `netstat` bruges til at hente statusoplysninger om netværksgrænseflader. Kommandoens generelle syntaks er: ```bash netstat [OPTIONS] ``` Brug `netstat` uden argumenter for at få vist alle åbne sokler i terminalen. Du kan også bruge følgende argumenter til at se routingtabellen (`-r`), grænsefladestatistikker (`-i`), maskerede forbindelser (`-M`) eller meddelelser om netværksforbindelser (`-N`). Læs mere i vores introduktion til netstat. ### traceroute-kommandoen i Linux For at spore en IP-datapakkes transportrute mellem dit system og en målcomputer kan du bruge kommandoen traceroute. Brug følgende mønster. ```bash traceroute [OPTIONS] HOSTNAME ``` Med `traceroute` kan du se, hvilke routere og internetknudepunkter en IP-pakke passerer på vej til målcomputeren – for eksempel for at finde årsagen til en forsinkelse. ### kommandoen route i Linux Med kommandolinjeprogrammet `route` kan man hente og redigere kernens IP-routing-tabel. Kommandoen følger denne syntaks: ```bash route [OPTIONS] [add|del] [-net|-host] TARGET ``` Brug kommandoen uden parametre for at få vist kernens fulde routing-tabel: ```bash route ``` Hvis du vil angive en rute til et netværk, skal du bruge underkommandoen `add`. ```bash route add -net 10.0.0.0 ``` ### dig-kommandoen i Linux `dig` er et opslagsværktøj, der kan bruges til at hente oplysninger fra DNS-serveren og vise dem i terminalen. Kommandolinjeprogrammet bruges normalt med følgende syntaks til at hente IP-adressen og andre DNS-oplysninger for et givet domænenavn: ```bash dig [@SERVER] [DOMAIN] [TYPE] ``` SERVER er den DNS-server, der skal søges på for at finde de ønskede oplysninger. Hvis der ikke angives nogen server, identificerer `dig` standard-DNS-serveren fra filen `/etc/resolv.conf`. DOMAIN angiver det domænenavn, hvorfra DNS-oplysningerne skal hentes. TYPE bruges til at angive forespørgselstypen, dvs. ANY (alle poster), A (IPv4-post for en vært) eller AAAA (IPv6-post for en vært). Standardforespørgselstypen er defineret som A. ### Kommandoen mount og unmount i Linux Hvis et filsystem skal integreres i operativsystemets mappestruktur via mappestrukturen, anvendes kommandolinjeprogrammet `mount` under Linux. Kommandoens generelle syntaks er: ```bash mount [OPTIONS] DEVICE MOUNTPOINT ``` DEVICE = Stien til den fil, der angiver den lagerenhed, du vil montere som en partition. MOUNTPOINT = Det sted i operativsystemets mappestruktur, hvor du ønsker at montere partitionen. Monteringspunktet angives normalt som en absolut sti. Eksempel: ```bash mount /dev/sdd /media/usb ``` Enheden `sdd` er monteret i skabet `/media/usb`. ### Kommandoen dd i Linux Kommandolinjeprogrammet `dd` muliggør en kopieringsproces, hvor data læses ud bit for bit fra en indlæsningsfil (`if`) og skrives til en udlæsningsfil (`of`). Programkaldet følger følgende syntaks: ```bash dd if=Source of=Target [OPTIONS] ``` Som kilde og mål kan du angive både enkelte filer og hele partitioner (f.eks. /dev/sda1) eller en hel lagerenhed (f.eks. /dev/sda). ```bash dd if=/dev/sda5 of=/dev/sdb1 ``` ### chmod-kommandoen i Linux Kommandolinjeprogrammet `chmod` (forkortelse for *»change mode«*) bruges til at tildele rettigheder i Unix-lignende filsystemer (dvs. ext2, ext3, ext4, reiser, xfs). Kommandoens generelle syntaks er: ```bash chmod [OPTIONS] MODE FILE ``` eller ```bash chmod [OPTIONS] MODE DIRECTORY ``` Pladsholderen MODE står for den gældende rettighedsmaske. Du kan læse mere om, hvordan man opretter et sådant system, og hvad man skal være opmærksom på, i vores guide til adgangsrettigheder med chmod. Ved hjælp af indstillingen `-R` kan rettigheder tildeles rekursivt til undermapper og filer i et bibliotek. ### chown-kommandoen i Linux \[Kommandoen `Linux`chown`](t3://page?uid=25778)` står for *»skift ejer«* og giver dig mulighed for at ændre ejerrettighederne. ```bash chown [OPTIONS] [USER][:[GROUP]] FILE ``` eller ```bash chown [OPTIONS] [USER][:[GROUP]] DIRECTORY ``` Der findes fire mulige kombinationer til at indstille ejerrettigheder for en bruger eller en gruppe. Ejer og gruppe nulstilles i henhold til indtastningen: ```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`. ``` ### Kommandoen `adduser` i Linux Den nemmeste måde at oprette en brugerkonto på er ved hjælp af kommandolinjeprogrammet `adduser`. Dette er et Perl-script, der er baseret på [Linux-kommandoen `useradd`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-useradd/) og tilbyder de samme funktioner på en brugervenlig måde. Kommandoen `adduser` kræver root-rettigheder og bruges i henhold til følgende syntaks: ```bash adduser [OPTIONS] USERNAME ``` Brug `adduser` uden argumenter for automatisk at oprette et bruger-id, et hjemmekatalog og en brugergruppe med samme navn sammen med den nye brugerkonto. ```bash adduser test ``` Derefter vises en interaktiv dialogboks, hvor du kan angive adgangskoden og andre brugeroplysninger (rigtigt navn, kontornummer, telefonnummer osv.). ### passwd-kommandoen i Linux Brug \[kommandoen `linux`passwd`](t3://page?uid=25774)` til at ændre en brugers adgangskode eller til at definere, kontrollere og ændre intervaller. Kommandoen følger denne syntaks: ```bash passwd [OPTIONS] USERNAME ``` Hvis du vil ændre en anden brugers adgangskode, skal du have root-rettigheder. Brug kommandoen `passwd` uden et brugernavn for at ændre din egen adgangskode. Hvis adgangskoden skal spærres, skal du bruge kommandoen `passwd` med indstillingen `-l` (*–lock*). Andre indstillinger giver dig mulighed for at angive en gyldighedsperiode for adgangskoder ( `(-x)` samt advarsels- ( `(-w)` og kontrolintervaller ( `(-i)`). ### Kommandoen `groupadd` i Linux Kommandolinjeprogrammet `groupadd` bruges til at oprette brugergrupper. Brug `groupadd` med root-rettigheder i henhold til følgende syntaks: ```bash sudo groupadd [OPTIONS] GROUPS ``` Hver nyoprettet gruppe har sit eget gruppe-ID (GID). Gruppe-ID’er mellem 0 og 99 er forbeholdt systemgrupper. Hvis du selv vil angive GID’et for en ny brugergruppe, skal du bruge kommandolinjeparameteren `groupadd` sammen med indstillingen `-g` (GID). Hvis du vil oprette en systemgruppe, skal du bruge indstillingen `-r` (root). ### chattr-kommandoen i Linux Kommandolinjeprogrammet `chattr` (forkortelse for *»change attribute«*) giver dig mulighed for at se filer eller mapper med attributter. Brug `chattr` i henhold til følgende syntaks for at angive et attribut: ```bash chattr [OPTIONS] +ATTRIBUTE FILE ``` Erstat plustegnet med et minustegn for at fjerne attributterne igen. Indstil f.eks. attribut `-i` for at forhindre ændringer (sletning eller redigering) af en fil eller et bibliotek. Se programmanualen til `chattr` for yderligere attributter og mulige indstillinger. ### lsattr-kommandoen i Linux Hvis du vil se, hvilke attributter der er angivet for en fil eller et bibliotek, skal du bruge 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 *»skift gruppe«* og bruges til at administrere gruppetilhørsforhold for filer og mapper. For at kunne bruge `chgrp` på en valgt fil eller mappe skal du have ejer- eller root-rettigheder. Det er de eneste grupper, du kan tilhøre. `chgrp` bruges efter følgende syntaks: ```bash chgrp [OPTIONS] GROUP FILE ``` eller ```bash chgrp [OPTIONS] GROUP DIRECTORY ``` Indstilling `-R` vedrører undermapper og filer i et bibliotek. ### kommandoen `man` i Linux Kommandoen `man` åbner manual-siderne (*man-siderne*) for din Linux-distribution direkte i terminalen. Brug følgende fremgangsmåde til at åbne manual-siderne: ```bash man [OPTION] TOPIC ``` Linux-man-siderne er opdelt i 10 emneområder: Brugerkommandoer, systemkald, funktioner i programmeringssproget C, filformater, konfigurationsfiler, spil, diverse, systemadministrationskommandoer, kernefunktioner, nye kommandoer. ### shutdown-kommandoen i Linux \[Kommandoen `linux`shutdown`](t3://page?uid=2619)` kan bruges af root-brugeren til at lukke systemet ned. Kommandoen følger denne syntaks: ```bash shutdown [OPTIONS] [TIME] [MESSAGE] ``` Hvis du ønsker at udløse en nedlukning, har du mulighed for at angive et tidspunkt, hvor systemet skal slukkes. Til dette formål kan du enten indtaste et konkret klokkeslæt (tt:mm) eller en nedtælling (+m). Andre brugere på systemet vil modtage en besked om nedlukning. Denne kan om nødvendigt ledsages af en personlig besked. Hvis kommandoen `shutdown` bruges sammen med optionen `-r`, efterfølges nedlukningen af systemet af en genstart. ### top-kommandoen i Linux Kommandoen `top` henter en dynamisk oversigt over alle kørende processer. Opkaldet følger følgende mønster: ```bash top [OPTIONS] ``` Visningen af procesoplysningerne kan tilpasses ved hjælp af forskellige indstillinger. Procesoversigten `top` (blandt andre) understøtter følgende genvejstaster til at sortere visningerne: - \[P\] = Sorterer resultaterne efter CPU-belastning - \[M\] = Sorterer udskriften efter lagerbehov - \[N\] = Sorterer udskriften numerisk efter PID - \[A\] = Sorterer udskriften efter alder - \[T\] = Sorterer udskriften efter tid - \[U BRUGERNAVN eller UID\] = Filtrerer udskriften efter den respektive bruger Brug genvejstasten \[H\] for at få vist en hjælpeside, eller \[Q\] for at lukke procesoversigten. ### Kommandoen lscpu i Linux Brug `lscpu` (forkortelse for *»list cpu«*) efter nedenstående mønster for at få vist oplysninger om CPU-arkitekturen i terminalen. ```bash lscpu [OPTIONS] ``` Se vejledningen til dit operativsystem for at se de mulige indstillinger. ### Kommandoen lshw i Linux Kommandoen `lshw` viser *en liste* over *hardware* og viser oplysninger om hardwarekomponenterne i terminalen. Brug `lshw` i henhold til følgende syntaks: ```bash lshw [OPTIONS] ``` Kommandoen understøtter forskellige indstillinger til tilpasning af outputformatet (`-html`, `-xml`, `-short`, `-businfo`) samt omfanget af de viste oplysninger (f.eks. `–sanitize` til at skjule følsomme oplysninger). ### kommandoen kill i Linux `kill` er et kommandolinjeprogram, der kan bruges til at stoppe og afslutte processer. Kommandoen udføres efter følgende skema med et ønsket signal og ID’et for den valgte proces. ```bash kill [OPTIONS] [-SIGNAL] PID ``` Typiske tegn er: 1. `TERM`: Får en proces til at afslutte sig selv (standard) 2. `KILL`: Tvinger afslutningen af en proces (via systemet) 3. `STOP`: Stopper en proces 4. `CONT`: Tillader en stoppet proces at fortsætte ### kommandoen killall i Linux Brug [kommandoen `linux`killall``](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-killall/) sammen med et bestemt søgeord for kun at afslutte de processer, hvis navne stemmer overens (de første 15 tegn bruges til at finde et match). ```bash killall [OPTIONS] [-SIGNAL] [PROCESS NAME] ``` Med indstillingen `-e` (*–exact*) kan du udvide søgningen til at omfatte alle tegn i procesnavnet. ### En god kommando i Linux Kommandolinjeparameteren `nice` angiver en procesværdi mellem -20 og +19 ved processtart i heltal, hvorefter systemets tilgængelige regnekraft fordeles. Intervallet fra -20 til +19 svarer til Linux-prioritetsniveauerne 100 til 139. En proces med en `nice` på -20 har højere prioritet end en proces med en `nice` på 19. Solo-syntaksen lyder: ```bash nice [OPTION] [COMMAND] ``` Medmindre andet er angivet, starter alle processer med en værdi på 0 for `nice`. Brug parameter `-n` til at definere procesprioriteten. Det skal bemærkes, at negative prioriteter kun kan tildeles med root-rettigheder. ### pgrep-kommandoen i Linux Kommandolinjeprogrammet `pgrep` sammenligner listen over kørende processer med et søgeord og viser de relevante PID’er, hvis der findes resultater. Den generelle syntaks er: ```bash pgrep [OPTIONS] Search term ``` Som standard viser `pgrep` PID’erne for alle processer, der indeholder søgeordet. Hvis søgningen kun skal omfatte nøjagtige match, skal du bruge kommandoen sammen med optionen `-x`. Hvis du ud over procesnavnet også vil have PID’en, skal du bruge `pgrep` sammen med optionen `-l`. Ligesom `grep` understøtter `pgrep` søgeord baseret på regulære udtryk. ### ps-kommandoen i Linux \[Kommandoen `linux`ps`](t3://page?uid=25686)` viser en liste over alle kørende processer i terminalen. ```bash ps [OPTIONS] ``` Hvis du har brug for en detaljeret udskrift, skal du bruge `ps` sammen med indstillingerne `-f` (detaljeret) eller `-F` (meget detaljeret). Se manualen til dit operativsystem for yderligere indstillinger. ## Oversigt over yderligere Linux-kommandoer ### Grundlæggende kommandoer I kategorien »Grundlæggende kommandoer« finder du de grundlæggende Linux-kommandoer, der bruges til **at styre terminalen**. Lær, hvordan du rydder terminalens skærmbillede, henter tidligere indtastninger fra historikken eller afslutter terminalsessionen. **1. Afslut** Kommandolinjekommandoen `exit` afslutter den aktuelle session og lukker terminalen. ```bash exit ``` I stedet kan du bruge tastkombinationen \[Ctrl\] + \[D\]. **2. hjælp** Brug kommandoen `help` for at få vist en liste over alle integrerede shell-kommandoer (indbyggede kommandoer). Indtast `help` sammen med en shell-kommando for at få en kort beskrivelse af den pågældende kommando. ```bash help COMMAND ``` **3. historie** I Bash gemmes de sidste 500 kommandoer, der er indtastet i kommandolinjen, i historikken. Denne funktion fungerer som indtastningshjælp og giver dig mulighed for at gennemse listen over tidligere kommandoer ved hjælp af piletasterne og udføre dem igen. Du kan søge i historikken ved hjælp af nøgleord med tastkombinationen \[Ctrl\] + \[R\]. Du har også mulighed for at se den komplette liste, nummereret i terminalen. Brug kommandoen `history` uden indstillinger og argumenter. ```bash history ``` Hvis du vil filtrere resultaterne, skal du kombinere `history` via Linux Pipe med kommandolinjeprogrammet `grep` (se søgemuligheder) og et søgeord. ```bash history | grep SEARCH TERM ``` ### Hjælpesider Er du gået i stå og ved ikke, hvad du skal gøre? Bare rolig. Under Linux findes der forskellige **hjælp- og dokumentationssider**, der er tilgængelige direkte via terminalen, såsom *Unix-man-siderne* og *GNU-info-siderne*. Disse indeholder en detaljeret beskrivelse af alle kommandolinjeprogrammer, systemkald, konfigurationsfiler, filformater og kernefunktioner. Med [Linux-kommandoerne `whatis`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-whatis/) og `apropos` kan du finde kommandolinjeprogrammer i kategorien hjælpesider, hvilket giver dig mulighed for at søge efter nøgleord i manual-siderne til dit operativsystem. **1. apropos** Brug `apropos` til at søge efter nøgleord i sidetitlerne og beskrivelserne i manualen til dit operativsystem. Se nedenstående oversigt: ```bash apropos [OPTIONS] SEARCH TERM ``` Kommandoen understøtter forskellige indstillinger. Brug indstillingen `-e` for at begrænse søgningen til nøjagtige søgeresultater, eller brug jokertegn (`-w '*SEARCH TERM'`) og regulære udtryk (`-r`). **2. info** Med kommandoen `info` kan du hente GNU info-siderne for et bestemt emne. I de fleste tilfælde svarer disse sider til de manual-sider, der kan åbnes via `man`, men i modsætning til disse indeholder de links, der gør det nemmere at læse manualens indholdsfortegnelse. Brug følgende syntaks: ```bash info [OPTION] TOPIC ``` Hvis du kalder programmet uden at angive en indstilling eller et emne, kommer du til hovedmenuen på GNU info-siden. **3. pinfo** Med `pinfo` får du en variant af kommandolinjeprogrammet `info`, der er baseret på kommandolinjebrowseren Lynx og viser informationssider med fremhævede links. Brug `pinfo` på samme måde som kommandoen `info`: ```bash pinfo [OPTIONS] TOPIC ``` **4. hvad er** Kommandolinjeprogrammet `whatis` fungerer som en søgefunktion efter nøgleord i manualerne. Start dette program med et almindeligt nøgleord for at søge efter nøjagtige resultater i dit operativsystems manual. Hvis der findes et match, viser `whatis` en kort beskrivelse i terminalen. ```bash whatis [OPTIONS] SEARCH TERM ``` `whatis` (`-w '\*SEARCH TERM'`) understøtter også pladsholdere og regulære udtryk (`-r`). ### Håndtering af mapper Du vil bruge Linux-kommandoer til mappehåndtering til at oprette, slette og administrere mapper på dit system via terminalen samt navigere i mappestrukturen. De vigtigste kommandolinjekommandoer i denne kategori er `cd`, `ls`, `mkdir` og `rmdir`. **1. chroot** Kommandoen `chroot` (forkortelse for *»change root«*) bruges til at udføre en kommando i et andet rodkatalog. For eksempel bruges `chroot` til at isolere kritiske programmer fra resten af filsystemet. Kørsel af programmet kræver root-rettigheder og følger denne formel: ```bash chroot DIRECTORY COMMAND ``` **2. Opret en mappe her** Med `mkdirhier` kan du oprette hele mappehierarkier med en enkelt kommandolinjekommando: ```bash mkdirhier [OPTION] /home/user/directory1/directory2/directory3 ``` Hvis `directory1` og `directory2` allerede findes, opretter `mkdirhier` kun `directory3`. Ellers oprettes alle tre mapper. **3. træ** Mens `ls` kun viser indholdet af en mappe, kan kommandolinjekommandoen `tree` bruges til at vise hele mappestrukturen rekursivt som en træstruktur. Kommandoen bruger følgende syntaks: ```bash tree [OPTIONS] [DIRECTORY] ``` ### Filhåndtering Med Linux-kommandoerne i denne oversigt kan du udføre forskellige filhåndteringsopgaver fra terminalen. Brug de grundlæggende Linux-kommandoer som `cp`, `mv` og `rm` til at kopiere, flytte, omdøbe eller slette filer på dit system. **1. basename** En filsti overføres til kommandolinjedirektivet `basename`, som blot returnerer filnavnet uden en standardsti. Kommandoens syntaks er som følger: ```bash basename [OPTIONS] path/to/files [SUFFIX] ``` Kommandoen kan udvides til at omfatte flere filer ved hjælp af indstillinger. **2. komm.** Brug kommandolinjeprogrammet `comm` til at sammenligne sorterede filer (dvs. via `sort`) linje for linje. Programmet kaldes ved hjælp af følgende syntaks: ```bash comm [OPTIONS] FILE1 FILE2 ``` Programmet understøtter tre muligheder: - -1: fjern unikke linjer fra `FILE1` - -2: udelad unikke linjer fra `FILE2` - -3: udelad alle linjer, der findes i begge filer **3. skær** Kommandoen `cut` giver dig mulighed for at udtrække indholdet af en fil fra en tekstlinje i en fil (f.eks. log- eller CSV-filer). Kommandoens syntaks er som følger: ```bash cut [OPTIONS] FILE ``` Den nøjagtige placering af et udtrukket afsnit defineres via indstillingerne `-b` (byteposition), `-c` (tegnposition), `-d` (afgrænsningstegn) og `-f` (felt). **4. dirname** `dirname` er modstykket til `basename`. Kommandolinjedirektivet giver dig mulighed for at udtrække stidelen fra en filsti og vise den i terminalen uden filnavne. Kommandoens syntaks er som følger: ```bash dirname [OPTIONS] path/to/file ``` **5. fil** Med kommandolinjeparameteren `file` kan du få vist oplysninger om en fils filtype. Kommandoen bruges efter følgende syntaks: ```bash file [OPTIONS] FILE ``` **6. lsof** [Kommandoen](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-lsof/) `[linux`lsof`](t3://page?uid=25776)` står for *»list open files«* og er et værktøj, der viser oplysninger om åbne filer i terminalen, sorteret efter PID (proces-ID). Start programmet i terminalen ved hjælp af følgende syntaks: ```bash lsof [OPTIONS] ``` Da Unix-lignende systemer som Linux generelt følger princippet om, at »alt er en fil«, er den liste, der vises ved hjælp af kommandoen `lsof`, tilsvarende lang. Som regel bruges indstillingerne til at begrænse denne udskrift. **7. md5sum** Kommandolinjekommandoen `md5sum` hjælper dig med at beregne og kontrollere MD5-kontrolsummer for filer. **8. indsæt** Ligesom `cat` gør kommandolinjeprogrammet `paste` det også muligt at sende filindhold til standardudgangen. Men mens `cat` blot sammenkæder indhold, sammenkæder `paste` kolonne for kolonne. Kommandoens grundlæggende syntaks er: ```bash paste [OPTIONS] FILE1 FILE2 … ``` Du kan med indstillingen `-d` angive, hvilket skilletegn der skal bruges af `paste`. Som standard bruges tabulatorer som skilletegn. En anden tilstand kan aktiveres ved hjælp af indstillingen `-s` (seriel). Hermed overføres alle linjer i den første indlæsningsfil til den første linje i udskriften. Dataene fra alle andre indlæsningsfiler følger i separate udskriftslinjer, så hver linje i udskriften kun indeholder indholdet fra én indlæsningsfil. **9. omdøb** Kommandolinjeprogrammet `rename` gør det muligt at omdøbe filer og mapper ved hjælp af regulære udtryk (regex). I modsætning til `mv` er funktionen `rename` velegnet til filhåndtering, hvor navnene på flere filer skal ændres helt eller delvist. Brug `rename` i henhold til følgende syntaks: ```bash rename [OPTIONS] 'REGULAR_EXPRESSION' FILE ``` Regulære udtryk følger nedenstående syntaks ved erstatninger: ```bash s/SEARCHPATTERN/REPLACEMENT/MODIFIER ``` **10. strimle** `shred` er et kommandolinjeprogram, der gør det muligt at slette filer på en sikker måde. De udvalgte filer overskrives under sletningsprocessen og kan derfor ikke gendannes ved hjælp af kriminaltekniske metoder. Kommandoens generelle syntaks er som følger: ```bash shred [OPTIONS] FILE ``` **11. sortere** Brug kommandolinjeparameteren `sort` til at sortere fillister og programudskrifter numerisk, alfabetisk og efter række. Kommandoens generelle syntaks er: ```bash sort [OPTIONS] FILE ``` Sorteringsmetoden kan tilpasses ved hjælp af indstillingerne. For eksempel numerisk (`-n`), tilfældig (`-R`) eller i omvendt rækkefølge (`-r`). **12. opdeling** Kommandolinjedirektivet `split` bruges til at opdele filer. Den underliggende syntaks er som følger: ```bash split [OPTIONS] [INPUT [PREFIX]] ``` Pladsholderen INPUT svarer til den fil, der skal opdeles. *PREFIX* angiver navnene på de involverede filer. Deres navne følger følgende mønster: ```bash PREFIXaa, PREFIXab, PREFIXac … ``` Hvis der ikke er angivet noget præfiks, bruger `split` standardpræfikset `x`. Indstillingen `-b` (bytes) kan bruges til at angive størrelsen på de delvise filer. Dette kan angives enten i bytes (b), kilobytes (k) eller megabytes (m). Eksempel: ```bash split -b 95m archive.tgz split-archive.tgz. ``` **13. statistik** Kommandolinjekommandoen `stat` (*status*) viser tidsstempler for adgang og ændringer for udvalgte filer og mapper. Den generelle syntaks for kommandoen er: ```bash stat [OPTIONS] FILE ``` Udgangsformatet kan tilpasses ved hjælp af indstillinger. **14. uniq** Kommandolinjedirektivet `uniq` bruges normalt sammen med `sort` til at fjerne dubletter fra sorterede filer. I det følgende eksempel er kommandoen `sort` forbundet med kommandoen `uniq` via en pipe (`|`), så filen først sorteres og derefter udskrives uden dubletter. ```bash sort file.txt | uniq ``` ### Søgemuligheder Linux tilbyder forskellige kommandolinjekommandoer, der gør det muligt at søge i systemet direkte fra terminalen. **1. find** Med `find` kan du søge i en Linux-fil. Det fungerer efter følgende syntaks: ```bash find [OPTIONS] [DIRECTORY] [SEARCHCONDITION] [ACTIONS] ``` Det angivne bibliotek er udgangspunktet for søgningen. Kommandoen søger derefter i udgangsbiblioteket og dets underbiblioteker. Hvis der ikke angives noget bibliotek, starter `find` søgningen fra det aktuelle arbejdsbibliotek. Med indstillingerne kan du definere søgekriterier og handlinger. Standardhandlingen er forudindstillet til `-print`: Udsendelse af de fulde filnavne på alle søgeresultater til standardudgangen (normalt terminalen). Yderligere indstillinger gør det muligt at filtrere efter filnavn, filstørrelse, adgangstidspunkt osv. Disse er angivet på den tilhørende man-side. **2. find** Kommandolinjeprogrammet `locate` giver dig også mulighed for at søge efter filer via terminalen. Men i modsætning til `find` søger det ikke i filmappen, men i en specielt oprettet og regelmæssigt opdateret database. Derfor leverer `locate` resultaterne langt hurtigere end `find`. For at søge efter en bestemt fil i databasen bruges `locate` i henhold til følgende syntaks: ```bash locate SEARCHPATTERN ``` Søgemønsteret kan indeholde metategn som pladsholdere (`*`). Sæt disse i anførselstegn for at forhindre, at shell’en fortolker dem. **3. tre-agrep** `tre-agrep` bruges også til at søge efter tekstrækker i tekstfiler ud fra søgemønstre. Men i modsætning til `grep` vises der ikke kun nøjagtige resultater, men også vage resultater, f.eks. resultater med ombyttede bogstaver eller manglende tegn. Programmet er baseret på TRE-biblioteket og gør det tilgængeligt fra kommandolinjen. Syntaksen for `tre-agrep` svarer til syntaksen for kommandoen `grep`: ```bash tre-agrep [OPTIONS] SEARCHPATTERN FILE(S) ``` Ved hjælp af indstillingerne kan du angive en maksimal tilladt fejlmargen. I det følgende eksempel tolereres der højst én afvigelse. ```bash tre-agrep -1 'Linux' test .txt ``` **4. updatedb** En `locate` fungerer kun korrekt, hvis `/var/lib/locatedb` løbende holdes opdateret. Med kommandoen `updatedb` kan du manuelt opdatere databasen. Bemærk, at du skal have root-rettigheder for at gøre dette: ```bash updatedb ``` **5. hvor er** Med kommandoen `whereis` kan du finde binærkoden, kildekoden eller manualfilerne til det valgte program. Kommandoens generelle syntaks er: ```bash whereis [OPTIONS] PROGRAM ``` Man kan bruge indstillinger til at begrænse søgningen til bestemte filtyper eller mapper. **6. hvilken** Hvis du vil finde de binære filer til et program, skal du bruge kommandoen `which` med følgende syntaks for at få vist stien i terminalen. ```bash which [OPTIONS] PROGRAM ``` I standardtilstand viser `which` den første fil, den finder. Brug indstillingen `-a` for at få vist alle filer, der opfylder søgekriterierne. ### Brugeroplysninger Brug kommandolinjeprogrammerne til nedenstående kategorier for at få adgang til **detaljerede oplysninger om de registrerede brugere i systemet** samt deres grupper og processer. **1. finger** Kommandolinjeprogrammet `finger` bruges til at få adgang til brugeroplysninger. Brug kommandoen sammen med det ønskede brugernavn: ```bash finger [options] [USERNAME] ``` Brug `finger` uden brugernavn for at få oplysninger om din egen konto. **2. grupper** Kommandoen `groups` viser de grupper, som en valgt brugerkonto er medlem af. Brug `groups` uden et brugernavn for at få vist alle de grupper, som din brugerkonto er medlem af. Brug kommandolinjedirektivet efter følgende mønster: ```bash groups [OPTIONS] [USERNAME] ``` **3. id** Kommandolinjekommandoen `id` viser bruger- og gruppe-id’er for de valgte brugerkonti. Hvis du vil se dine egne id’er, skal du bruge kommandoen uden et brugernavn. ```bash id [OPTIONS] [USERNAME] ``` Udgangssignalets rækkevidde kan begrænses ved hjælp af indstillinger. **4. sidst** Brug kommandoen `last` efter nedenstående skabelon for at få vist en liste over brugere, der for nylig har logget ind, inklusive ind- og udlogningstidspunkter. ```bash last [OPTIONS] [USERNAME] ``` De relevante oplysninger hentes fra filen `wtmp` under `/var/log/wtmp`. Hvis du kun ønsker at anmode om oplysninger om en bestemt konto, skal du indtaste kommandolinjedirektivet med det ønskede brugernavn. **5. w** Kommandoen `w` viser en liste over alle registrerede brugere, herunder alle de processer, de har kørt. Brug `w` sammen med et brugernavn for at begrænse kommandoen til netop denne brugerkonto: ```bash w [OPTIONS] [USERNAME] ``` Udskriftens omfang og format kan tilpasses ved hjælp af indstillinger. **6. hvem** Kommandoen `who` viser detaljerede oplysninger om de brugere, der er registreret i systemet. Den generelle syntaks for kommandoen er: ```bash who [OPTION] [SOURCEFILE] ``` Som standard henviser `who` til data om de aktuelt registrerede brugere fra filen `/var/run/utmp`. Du har mulighed for at angive en af følgende filer som kilde til oplysningerne. **7. whoami** Brug kommandoen `whoami` for at få dit eget brugernavn. ```bash whoami [OPTIONS] ``` ### Administration af brugerkonti Linux stiller en række programmer til rådighed, som du kan bruge til at oprette, slette og administrere brugerkonti og grupper direkte fra terminalen. Her har vi samlet en oversigt over de vigtigste **Linux-kommandoer til administration af brugerkonti**. I denne kategori finder du også Linux-terminalkommandoer, der giver dig mulighed for at få adgang til koder med andre brugerrettigheder, herunder superbrugeren root. **1. chfn** Kommandolinjedirektivet `chfn` (forkortelse for *»change finger«*) giver dig mulighed for at tilpasse yderligere oplysninger på en brugerkonto, såsom det rigtige navn, kontornummer samt private eller arbejdsrelaterede telefonnumre. Den generelle syntaks er: ```bash chfn [OPTION "NEW VALUE"] [USERNAME] ``` Hvilke brugeroplysninger der skal tildeles en ny værdi, defineres ved hjælp af indstillingerne `-f` (rigtigt navn), `-r` (kontornummer), `-w` (arbejdstelefon) og `-h` (privat telefonnummer). **2. chsh** Kommandolinjedirektivet `chsh` (forkortelse for *»change shell«*) ændrer login-shellen for en valgt bruger. Brug følgende skabelon som vejledning, når du indtaster oplysningerne: ```bash chsh [OPTIONS] USERNAME ``` Du kan bruge indstillingen `-s` til at ændre login-shellen for en brugerkonto. **3. vrangforestilling** Kommandolinjeprogrammet `deluser` sletter alle poster for en valgt brugerkonto fra systemets kontofiler. Kørsel af `deluser` kræver root-rettigheder og bruger følgende syntaks: ```bash deluser [OPTIONS] USERNAME ``` Hvis du også ønsker at slette alle filer i brugerens hjemmemappe, skal du bruge kommandoen med indstillingerne `--remove-home`. Hvis du vil slette alle brugerfiler fra systemet, skal du bruge indstillingerne `--remove-all-files`. **4. delgroup** Kommandolinjekommandoen `delgroup` (forkortelse for *»delete group«*) sletter en eksisterende brugergruppe. Der kræves root-rettigheder for at udføre kommandoen. Den generelle syntaks for `delgroup` er: ```bash delgroup [OPTIONS] GROUP ``` **5. groupmod** Navne og gruppe-ID’er (GID) for eksisterende brugergrupper kan tilpasses via `groupmod`. Kommandolinjedirektivet bruges med root-rettigheder i henhold til følgende syntaks: ```bash groupmod OPTIONS GROUP ``` Brug `groupmod` sammen med parameteren `-g` for at tilpasse GID’et. Kør kommandoen med parameteren `-n` for at overskrive gruppens navn. **6. newgrp** Kommandoen `newgrp` (forkortelse for *»ny gruppe«*) giver registrerede brugere mulighed for at ændre deres nuværende gruppe-ID uden at skulle logge ud og ind igen. Den generelle syntaks for kommandoen er: ```bash newgrp [-] [GROUP] ``` Hvis kommandoen `newgrp` bruges med den valgfri parameter \[-\], medfører skiftet af gruppe en genstart af brugermiljøet – som om brugeren havde logget ind igen. Brugere, der anvender `newgrp` uden angivelse af gruppe, skifter til standardgruppen, der er angivet under `/etc/passwd`. **7. søndag** Kommandoen `su` gør det også muligt at skifte bruger midlertidigt for at køre et program med den valgte brugers rettigheder. I modsætning til `sudo` udføres denne kommando ikke direkte. I stedet sker der et identitetsskift. I stedet for at bede om den kaldende brugers adgangskode, bliver der bedt om den valgte brugers adgangskode. Kommandoens generelle syntaks er: ```bash su [OPTIONS] [USERNAME] ``` Et opkald uden et brugernavn vælger `root` som målbruger. **8. usermod** Kommandolinjekommandoen `usermod` giver dig mulighed for at redigere tidligere oprettede brugerkonti. Brug `usermod` med root-rettigheder i henhold til følgende syntaks: ```bash usermod [OPTIONS] USERNAME ``` Hvilke ændringer der skal foretages, kan angives ved hjælp af indstillinger. Du kan f.eks. ændre brugernavnet med indstillingen `-l NEW_NAME`. Yderligere indstillinger findes på den tilhørende man-side. ### Systemkommandoer I kategorien »Systemkommandoer« finder du de grundlæggende Linux-kommandoer til styring af systemet. Brug følgende kommandoer til at genstarte og lukke systemet ned fra terminalen – og styr dem med en timer, hvis du ønsker det. **1. logger** Brug `logger` efter følgende mønster: ```bash logger "YOUR MESSAGE" ``` Find systemloggen under `/var/log/syslog`. **2. genstart** Kommandolinjedirektivet `reboot` medfører en genstart af systemet. For at udløse en genstart skal kommandoen udføres med root-rettigheder. ```bash reboot [OPTIONS] ``` **3. rtcwake** Kommandolinjedirektivet `rtcwake` giver dig mulighed for at starte og lukke systemet ned i henhold til en tidsindstilling. Kommandoen følger denne syntaks: ```bash rtcwake [OPTIONS] [MODE] [Time] ``` Vælg en bestemt tilstand (`-m MODE`), som systemet skal skifte til på et bestemt tidspunkt angivet i sekunder (`-s TIME IN SECONDS`). Du har også mulighed for at vække systemet på et præcist angivet tidspunkt (`-t UNIXTIME`). ### Systemoplysninger I kategorien »Systemoplysninger« har vi samlet kommandolinjeprogrammer, som du kan **bruge til at hente oplysninger og statusrapporter**, så du får et samlet overblik over dit systems tilstand. **1. dato** Kommandoen `date` viser systemtiden inklusive datoen. ```bash date [OPTIONS] [OUTPUTFORMAT] ``` Hvis du ønsker at arbejde med et bestemt tidspunkt i forbindelse med et programkald (se `rtcwake`), skal du definere dette ved hjælp af indstillingen `-d 'DATE'`. Derudover understøttes forskellige indstillinger, der kan konvertere dato- og tidsoplysninger til et ønsket format. **2. df** Brug kommandoen `df` (*disk free*) efter følgende skema. ```bash df [OPTIONS] [FILE] ``` Hvis kommandoen bruges sammen med en bestemt fil, angiver systemet kun den ledige plads på den partition, hvor filen befinder sig. I alle andre tilfælde vises den ledige plads på monterede partitioner. Indstillingen `-l` (*lokal*) begrænser `df` til det lokale filsystem. Den understøtter også indstillinger, der giver dig mulighed for at tilpasse udskriftsformatet. **3. dmesg** Programmet `dmesg` (forkortelse for *»display message«*) viser meddelelser fra systemets cirkulære buffer i terminalen og gør det muligt at lokalisere hardware- og driverfejl. Brug `dmesg` efter følgende skabelon: ```bash dmesg [OPTIONS] ``` Udskriften `dmesg` indeholder alle meddelelser fra opstartsrutinen og er derfor temmelig lang. Kommandolinjeprogrammet bruges ofte sammen med et sidevisningsprogram, som f.eks. `more`, `less` eller `tail`. **4. gratis** Kommandoen `free` viser hukommelsesforbruget. Den generelle syntaks er: ```bash free [OPTIONS] ``` Som output får du to specifikationer: `Mem` (*Hukommelse*) og `Swap`. `Free` understøtter desuden indstillingen `-h`, der viser hukommelsesforbruget i et læsbart format. **5. værtsnavn** Brug kommandoen `hostname` efter nedenstående skema for at få vist systemets DNS-navne. ```bash hostname [OPTIONS] ``` **6. uname** Kommandolinjedirektivet `uname` står for `unix name` og bruges til at hente systemoplysninger fra kernen. Kommandoen understøtter forskellige indstillinger, som gør det muligt at filtrere udskriften efter de ønskede oplysninger. Disse findes i den tilhørende man-side. ```bash uname [OPTIONS] ``` **7. oppetid** Hvis du vil finde ud af, hvor længe systemet har kørt siden sidste genstart, skal du bruge kommandolinjeparameteren `uptime` efter følgende skema: ```bash uptime ``` **8. vmstat** Ved hjælp af overvågningsværktøjet `vmstat` kan du få adgang til oplysninger om virtuel hukommelse, læse- og skriveoperationer på disken samt CPU-aktivitet. Indtast `vmstat` i henhold til nedenstående syntaks for at få vist gennemsnitsværdierne siden sidste systemstart. ```bash vmstat [OPTIONS] ``` `vmstat` tilbyder desuden en tilstand til kontinuerlig overvågning, der henter systemværdier så ofte som ønsket inden for et valgt tidsinterval i sekunder. ```bash vmstat [Options] [INTERVAL [REPETITIONS]] ``` ### Hardwareoplysninger Linux-kommandoerne i denne kategori giver **detaljerede oplysninger om de hardwarekomponenter**, der udgør grundlaget for dit system. **1. lspci** Brug `lspci` (forkortelse for *»list pci«*) efter nedenstående skabelon for at få vist detaljerede oplysninger om PCI-enheder. ```bash lspci [OPTIONS] ``` Se vejledningen til dit operativsystem for at se de mulige indstillinger. **2. lsusb** Brug `lsusb` (forkortelse for *»list usb«*) til at få vist detaljerede oplysninger om USB-enheder i terminalen. ```bash lsusb [OPTIONS] ``` Se vejledningen til dit operativsystem for at se de mulige indstillinger. ### Processtyring I Linux kaldes en kørende programinstans for en proces. De følgende terminalkommandoer er en del af standardværktøjet til processtyring og giver dig mulighed for **nemt at overvåge alle processer på dit system fra terminalen** og styre dem efter behov. **1. chrt** Kommandolinjeprogrammet `chrt` håndterer styring af kontinuerlige processer og gør det muligt at identificere og tilpasse realtidsattributterne (planlægningsregler og prioritet) for kørende processer eller at udføre kommandoer og deres argumenter med specificerede realtidsattributter. Kommandoens generelle syntaks er: ```bash chrt [OPTIONS] [PRIOTITY] PID/COMMAND [ARGUMENT] ``` Brug `chrt` uden at angive en prioritet og sammen med indstillingen `-p` til at identificere realtidsattributterne for de valgte processer. `chrt` giver også mulighed for at indstille eller definere planlægningsreglerne for kørende eller nystartede processer ved hjælp af indstillinger. Yderligere oplysninger herom findes i den tilhørende man-side. **2. ionice** Kommandolinjedirektivet `ionice` bruges til at ændre prioriteten for en proces, der benytter kernens I/O-grænseflade. Den generelle syntaks for kommandoen er: ```bash ionice [OPTIONS] COMMAND ``` For at kunne køre ionice skal du have root-rettigheder. Kommandoen skelner mellem tre planlægningsklasser, som angives via parameteren `-c class`. Mulige værdier er 1, 2 og 3. - 1 = Realtid: I/O-handlingen udføres med det samme. - 2 = Best effort: I/O-handlingen udføres så hurtigt som muligt. - 3 = Inaktiv: I/O-handlingen udføres kun, når ingen andre processer bruger I/O-tid. **3. nohup** Normalt afsluttes alle en brugers afhængige processer automatisk, så snart terminalsessionen lukkes (dvs. via `exit`). [Linux-kommandoen `nohup`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-nohup/) (forkortelse for *»no hangup«*) fjerner en kommando fra den aktuelle session og giver dig mulighed for at lade den køre videre, selv når du logger ud af systemet. ```bash nohup COMMAND ``` **4. pidof** Kommandolinjeprogrammet `pidof` viser proces-id’erne (PID’er) for alle et programs processer. Identificer PID’erne via `pidof` efter følgende mønster: ```bash pidof [OPTIONS] PROGRAM ``` Hvis du kun vil vise det første proces-ID, skal du bruge `pidof` sammen med indstillingen `-s` (forkortelse for *»single shot«*). **5. pidkill** Ligesom `kill` sender kommando `pkill` også et signal til en valgt proces. Adresseringen sker dog ikke via PID. I stedet angives et søgeord, der matcher navnet på den kørende proces. Dette kan også formuleres som et regulært udtryk. `pkill` videresender standardsignalet TERM, så længe der ikke er defineret andre signaler. Kommandoens generelle syntaks er: ```bash pkill [OPTIONS] [-SIGNAL] [SEARCHTERM] ``` Der kan anvendes yderligere indstillinger til at begrænse kommandoen til en bestemt brugers processer (`-U UID`), underprocesserne til en bestemt overordnet proces (`-P PID`) eller de nyeste (`-n`) eller ældste (`-o`) processer. **6. pstree** Brug `pstree` til at vise alle kørende processer i en træstruktur. Kommandoens generelle syntaks er: ```bash pstree [OPTIONS] ``` Udskriftens format og omfang kan tilpasses ved hjælp af forskellige indstillinger. **7. renice** Kommandolinjeparameteren `renice` giver dig mulighed for at tilpasse prioriteten for en kørende proces. Den generelle syntaks er: ```bash renice PRIORITY [OPTIONS] ``` **8. søvn** Med \[kommandoen `Linux`sleep`](t3://page?uid=25828)` kan du afbryde den aktuelle terminalsession i et bestemt tidsrum. Kommandoens generelle syntaks er: ```bash sleep NUMBER[SUFFIX] ``` Hvis du bruger `sleep` uden et suffiks, tolkes det angivne tal som tid i sekunder (s). Du har også mulighed for at afbryde terminalsessionen i minutter (m), timer (h) eller dage (d). **9. opgavesæt** Kommandolinjedirektivet `taskset` anvendes til avanceret processtyring, som bruges i multiprocessorsystemer til at tildele processer eller kommandoer til bestemte processorer. Kommandoen kræver root-rettigheder og bruger et af følgende mønstre: ```bash taskset [OPTIONS] MASK COMMAND taskset [OPTIONS] -p PID ``` Tildeling af en proces eller kommando til en processor sker ved hjælp af en hexadecimal bitmaske. Da en sådan tildeling via bitmaske ikke er særlig intuitiv, bruges `taskset` normalt sammen med indstillingen `-c` (–cpu-list) for at muliggøre en numerisk tildeling af processorer (f.eks. 0, 5, 7, 9–11). ### Personalalarm Vil du bruge din oversigt til at holde styr på indholdet i filer, der består af flere sider? Med et kommandolinjeprogram fra kategorien »pager« kan du vælge, hvilke afsnit der skal vises i terminalen, og om nødvendigt rulle gennem filen i interaktiv tilstand. **1. hoved** Kommandoen `[Linux`head`](t3://page?uid=3151)` bruges til at vise den første del af en fil. Den generelle syntaks for kommandoen er: ```bash head [OPTIONS] File ``` Brug indstillingen `-n NUMBER_LINES` til at angive, hvor mange linjer der skal udskrives, regnet fra starten. **2. mindre** Kommandolinjeprogrammet `less` gør det muligt at vise indholdet af en tekstfil i terminalen. Den generelle syntaks er: ```bash less [OPTIONS] FILE ``` Visningen sker automatisk i interaktiv tilstand. Dette giver dig mulighed for at bladre gennem det valgte dokument eller søge efter nøgleord. Tast \[Q\] afslutter den interaktive læsetilstand. Andre kontroltaster og tilgængelige indstillinger findes i programmets manual. **3. hale** Mens `head` som standard viser de første 10 linjer af en valgt fil, viser Linux-kommandoen tail de sidste 10. Begge pagere bruges på samme måde (se `head`). ### Redaktører Under Linux behøver du ikke et grafisk tekstredigeringsprogram for at tilpasse konfigurationsfiler, redigere kodestykker eller skrive korte noter. **Enkle tekstredigeringsprogrammer** kan nemt åbnes i terminalen uden forsinkelser. Her præsenterer vi tre programmer, du bør kende. **1. emacs** *Emacs* er et platformsuafhængigt tekstredigeringsprogram, der kan udvides efter behov via et programmeringsgrænseflade. Som standard starter Emacs med en grafisk brugergrænseflade, men kan også åbnes i terminalen ved hjælp af indstillingen `--no-window-system`. ```bash emacs --no-window-system ``` Emacs har en indbygget vejledning, som du kan åbne ved at trykke på tastkombinationen \[CTRL\] + \[H\], \[T\]. **2. nano** Nano er en terminalbaseret teksteditor. Nano har færre funktioner end lignende redigeringsprogrammer (f.eks. *Vim*), men udmærker sig ved at være særdeles brugervenlig. Den generelle syntaks for programkaldet er: ```bash nano [OPTIONS] FILE ``` Programmet åbner den angivne fil i et redigeringsvindue i terminalen. Hvis du starter Nano uden at angive et filnavn, oprettes der en ny tekstfil, som gemmes i det aktuelt valgte bibliotek. **3. vim** Vim (forkortelse for *Vi Improved*) er en videreudvikling af teksteditoren *Vi*, der udmærker sig ved en lang række udvidelser, såsom syntaksfremhævning, et omfattende hjælpesystem, indbygget scripting, automatisk kodekomplettering og visuel tekstmarkering. Dette open source-program tilbyder forskellige driftsformer til redigering af rene tekstfiler og kan bruges enten i terminalen eller som et selvstændigt program med en grafisk brugergrænseflade (*GVim*). Et centralt anvendelsesområde for programmet er redigering af programkode. Hvis du starter Vim i konsollen, foregår betjeningen via tastaturet. Normalt startes programmet sammen med en tekstfil efter følgende mønster: ```bash vim [OPTIONS] FILE ``` Vim tilbyder programmet `vimtutor` som en omfattende introduktion, der ligeledes startes fra kommandolinjen. Vores grundlæggende artikel om Linux-editoren Vim indeholder desuden yderligere oplysninger om installation og programmets forskellige driftsformer. ### Netværksadministration **Netværksadministration** kan også nemt styres fra terminalen i Linux. Uanset om du vil teste forbindelsen, hente DNS-oplysninger, konfigurere grænsefladen eller overføre filer til en anden computer på netværket, er en enkelt kommando nok til at sætte dit projekt i gang med de følgende programmer. **1. arp** Kommandolinjeprogrammet `arp` giver dig mulighed for at få adgang til og ændre operativsystemets ARP-cache. Brug `arp` uden nogen argumenter for at få vist indholdet af ARP-tabellen i terminalen. ```bash arp [OPTION] ``` Du kan også begrænse udskriften ved hjælp af indstillinger eller oprette eller slette poster: - `-a HOSTNAME` = Begræns udskriften til poster for bestemte værtsnavne (alternativ til en IP-adresse) - `-s HOSTNAME MAC_ADDRESS` = Opret ARP-post med angivet værtsnavn og MAC-adresse - `-d HOSTNAME` = Slet APR-post **2. iw** Kommandolinjeprogrammet `iw` bruges til konfiguration af WLAN-grænseflader og er blevet et aktuelt alternativ til `iwconfig`. Kommandoen bygger på en syntaks, der ligner den, der bruges i kommandoen `ip`: ```bash iw [OPTIONS] OBJECT [COMMAND] ``` Mulige objekter er: - dev NAME\_OF\_INTERFACE = Netværksgrænseflade - phy NAVN\_PÅ\_ENHED = WLAN-enhed (efter navn) - phy#INDEX\_OF\_DEVICE = WLAN-enhed (efter indeks) - reg = Reguleringsagent til konfiguration af regionale og nationale indstillinger Du kan finde en oversigt over de mulige kommandoer og indstillinger i den tilhørende man-side. **3. nslookup** Ligesom `dig` er nslookup også en tjeneste til navneopløsning. Kommandolinjeprogrammet findes i to tilstande: interaktiv og ikke-interaktiv. Hvis du vil bruge `nslookup` i ikke-interaktiv tilstand, skal du køre programmet sammen med et værtsnavn eller en IP-adresse. ```bash nslookup [OPTIONS] [HOST/IP] ``` For at starte den interaktive tilstand skal du indtaste kommandoen `nslookup` i terminalen uden yderligere oplysninger og derefter indtaste værtsnavne eller IP-adresser for at få vist de tilhørende IP-adresser eller værtsnavne. Da programmet **officielt** er **forældet**, opfordres brugerne til at bruge `dig` i stedet. **4. rsync** Kommandolinjeprogrammet `rsync` giver dig mulighed for at synkronisere filer lokalt eller via et netværk. Til dette formål sammenlignes de pågældende filers størrelse og ændringstidspunkt. Syntaksen for kommandoen er: ```bash rsync [OPTIONS] SOURCE(S) TARGET ``` Kommandoen rsync udføres normalt med indstillingen `-a`, hvilket sikrer, at alle undermapper og symbolske links kopieres, og at alle brugerrettigheder overføres. **5. scp** Med Linux-kommandoen scp (forkortelse for *»secure copy«*) er der et andet program til sikker dataoverførsel i netværket, som kan bruges direkte via terminalen. `scp` kopierer data fra en computer til en anden og bruger netværksprotokollen SSH. Klientprogrammet fungerer på samme måde som filkommandoen `cp`, men anvendes på hele systemet i henhold til følgende syntaks: ```bash scp [OPTIONS] FILE [[user@]remote_host:]PATH ``` Når man angiver stien til fjerncomputeren, sættes brugernavnet og det tilhørende værtsnavn foran. Lokale filer angives eksplicit ved hjælp af relative eller absolutte stier. Eksempel: ```bash scp/home/max/images/image.jpg max@example.com:/home/max/archive ``` Med de ekstra indstillinger kan du justere overførselstypen og krypteringsindstillingerne. **6. tty** Kommandolinjedirektivet `tty` viser filnavnene på den terminal, der er angivet som standardindgang. Den generelle syntaks for kommandoen er: ```bash tty [OPTIONS] ``` ### Arkiver og komprimer Linux tilbyder forskellige teknologier, der gør det muligt at pakke og komprimere filer i arkiver. Det skal bemærkes, at **ikke alle arkiver indeholder en komprimering**. Derfor bruges `tar` – et program til arkivering af filer – normalt sammen med et komprimeringsprogram som f.eks. `gzip`, `bzip2` eller `xz`. **1. gzip** `gzip` er et program, som du nemt kan bruge til at komprimere eller udpakke filer via kommandolinjen. Kommandoens generelle syntaks er: ```bash gzip [OPTIONS] FILE(S) ``` Bemærk, at `gzip` som standard sletter den oprindelige fil som led i komprimeringsprocessen. Dette kan undgås ved at bruge indstillingen `-k`. Programmet kan om nødvendigt bruges til flere filer på samme tid. Hver outputfil konverteres til en separat `gz`. Hvis du ønsker at samle flere filer i et enkelt komprimeret arkiv, skal du bruge `gzip` sammen med arkiveringsprogrammet `tar`. Hvis du vil udpakke en gz-fil, skal du bruge kommandoen `gzip` med parameteren `-d`. **2. bzip2** Et populært alternativ til `gzip` er kommandolinjeprogrammet `bzip2`. Dette bruger samme syntaks som `gzip`, men er baseret på en tretrins komprimeringsproces, der giver mulighed for en betydeligt højere komprimeringsgrad. Filer, der er komprimeret med bzip2, har filtypenavnet `.bz2`. Brug `bzip` efter følgende mønster til at komprimere filer: ```bash bzip2 [OPTIONS] FILE(S) ``` `bzip2` kan også anvendes på `tar` -arkiver. Dekomprimeringen foregår på samme måde som ved `gzip` og udføres ved hjælp af indstillingen `-d`. **3. xz** Kommandolinjeprogrammet `xz` konverterer filer til det datakomprimeringsformat, der bærer samme navn, `xz`. Programkaldet følger samme mønster som `gzip` og `bzip2`. ```bash xz [OPTIONS] FILE(S) ``` Filer, der er komprimeret med `xz`, har filtypen `.xz`. Dekomprimeringen foregår på samme måde som med `gzip` og `bzip` ved hjælp af indstillingen `-d`. Kommandoen `unxz` kan også bruges. Ligesom gz- og bz2-filer er xz-filer heller ikke arkivfiler. Hvis du vil samle flere filer i én og samme komprimerede xz-fil, skal du også bruge arkiveringsværktøjet `tar` sammen med dette komprimeringsprogram. **4. cpio** Arkiveringsprogrammet `cpio` (forkortelse for *»copy in, copy out«*) giver dig mulighed for at skrive data til en arkivfil (.cpio) og udpakke data fra den. ### Partitionsstyring Hvis du vil få adgang til et filsystem på en anden partition i Linux, skal du først integrere det i operativsystemets mappestruktur. Dette kaldes at »montere« en partition. Om nødvendigt kan dette gøres via den grafiske brugergrænseflade. Kommandolinjeprogrammer som `lsblk`, `blkid` og `mount` giver også mulighed for at hente oplysninger om tilsluttede bloklagringsenheder og for at montere eller afmontere dem, når det er nødvendigt. **1. lsblk** Brug kommandoen `lsblk` (forkortelse for *»list block devices«*) til at vise alle tilsluttede bloklagringsenheder og partitioner som en træstruktur. Disse behøver ikke nødvendigvis at være involveret. Kommandoen følger følgende syntaks: ```bash lsblk [OPTIONS] ``` Om nødvendigt kan output og en liste over ønskede attributter tilpasses individuelt ved hjælp af indstillingen `-o` (*–output*) for at hente yderligere oplysninger, såsom identifikationsnummeret (UUID), filsystemet (FSTYPE) eller status (STATE). I standardindstillingerne springes tomme lagringsenheder over. Hvis du også vil medtage disse i oversigten, skal du bruge `lsblk` sammen med indstillingen `-a` (*–all*). Hvis du kun vil hente oplysninger om en bestemt enhed, skal du bruge `lsblk` efter følgende mønster: ```bash lsblk [OPTIONS] DEVICE ``` **2. blkid** Ligesom `lsblk` viser `blkid` også oplysninger om tilsluttede bloklagringsenheder. Brug `blkid` efter nedenstående skema for at få identifikationsnummeret (`UUID`) og filsystemtypen (`TYPE`) for alle tilsluttede bloklagringsenheder. ```bash blkid [OPTIONS] ``` Ved tabelformet udskrift skal du bruge indstillingen `-o` sammen med værdien `list`. Du kan også begrænse `blkid` til en bestemt enhed: ```bash blkid [OPTIONS] DEVICE ``` ### Diverse Følgende liste indeholder yderligere grundlæggende Linux-kommandoer, der ikke hører til nogen af de tidligere kategorier. **1. alias** Interaktionen med shell’en foregår normalt via kommandoer, der kan bruges til at starte **kommandolinjeprogrammer** med samme navn. Du bruger et programkald til hver handling, du ønsker at udføre via terminalen. Med [Linux-kommandoen `alias`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-alias/) kan du definere korte navne til programkald. Brug `alias` efter følgende mønster: ```bash alias NICKNAME= 'COMMAND' ``` Erstat pladsholderen COMMAND med en vilkårlig kommandolinjeparameter, herunder eventuelle indstillinger. Dette vil indsætte den indsatte streng i stedet for pladsholderen NICKNAME. **2. kl.** Kør kommandolinjeprogrammet `at` efter nedenstående skabelon for at udføre en tidsstyret kommando. ```bash at TIME ``` Indtast derefter kommandoen, og luk den interaktive tilstand med \[CTRL\] + \[D\]. **3. cal** Brug `cal` efter nedenstående skabelon til at vise en kalender i terminalen. ```bash cal [OPTIONS] [[MONTH] Year] ``` **4. pr** Brug kommandolinjeprogrammet `pr` til at forberede tekstfiler til udskrivning. Kommandoens generelle syntaks er: ```bash pr [OPTIONS] File ``` I standardindstillingerne genererer `pr` en sidehoved, der indeholder filnavnet, den aktuelle dato og sidetallet. **5. manuskript** Kommandolinjeprogrammet `script` giver dig mulighed for at gemme en terminalsession i filen `typescript`. Hvis der allerede findes en optagelse af en tidligere session i `typescript`, overskrives denne. Optagelsen starter automatisk, når programmet kaldes: ```bash script ``` Brug tastkombinationen \[CTRL\] + \[D\] for at afslutte optagelsen. Hvis du vil gemme optagelsen i en anden fil i stedet for i `typescript`, skal du trykke på `script` sammen med et filnavn eller en sti. **6 ff.** Brug kommandoen `seq` til at udskrive en talrække til standardudgangen. Angiv en startværdi, en slutværdi og et trin (valgfrit). ```bash seq [OPTIONS] STARTVALUE INCREMENT ENDVALUE ``` **7. tasksel** Kommandolinjeprogrammet `tasksel` fungerer som installationshjælp til standardapplikationer (mailserver, DNS-server, OpenSSH-server, LAMP-server osv.). Brug værktøjet til automatisk at installere alle de pakker og programmer, der kræves til en opgave, i den rigtige rækkefølge. Kør `tasksel` med indstillingen `--list-tasks` for at få vist en liste over alle tilgængelige standardapplikationer. ```bash tasksel --list-tasks ``` Hvis du vil have flere oplysninger om et standardprogram på listen, skal du indtaste `tasksel` sammen med valgmuligheden `--task-desc` og den tilhørende opgave. Hvis du vil se en liste over alle pakker, der hører til opgaven »mail-server«, skal du indtaste `tasksel` sammen med valgmuligheden `--task-packages`. For at installere alle pakker i et standardprogram skal du bruge underkommandoen `install`. Dette kræver root-rettigheder. **8. tee** Kommandoen `[Linux`tee`](t3://page?uid=23016)` bruges til at fordoble et programs output. Den ene del af outputtet sendes til standardudgangen, mens den anden skrives til den fil, der angives med kommandoen ``tee``. ```bash tee [OPTIONS] FILE ``` `tee` bruges normalt sammen med omdirigeringsoperatoren Pipe (`|`). ```bash ls | tee example.txt ``` **9. gang** Brug kommandoen `time` efter nedenstående mønster til at se, hvor længe de programmer, du har startet via terminalen, har kørt. ```bash time [OPTIONS] Command [ARGUMENTS] ``` **10. tr** Brug `tr` til at slette et ønsket tegnsæt eller erstatte det med et andet. For at gøre dette læser `tr` datastrømmen fra standardindgangen (f.eks. en fil) og skriver den til standardudgangen i overensstemmelse med den ønskede ændring. Hvis et tegnsæt skal erstattes af et andet, bruges `tr` med to argumenter. ```bash tr OPTION CHARACTERSET1 CHARACTERSET2 ``` Det andet argument (CHARACTERSET2) erstatter det første (CHARACTERSET1). Hvis du vil slette en tegnsekvens, skal du bruge `tr` sammen med indstillingen `-d` og angive det sæt, der skal slettes, som argument. ```bash tr -d CHARACTERSET ``` Kommandolinjeprogrammet bruges normalt sammen med omdirigeringstegnene (< og >) til at ændre filer. ```bash tr 'a-z' 'A-Z' < example1.txt > example2.txt ``` `tr` læser indholdet af filen `example1.txt`, erstatter små bogstaver fra a til z med store bogstaver og skriver resultatet til filen `example2.txt`. **11. væg** Kommandolinjeprogrammet `wall` giver dig mulighed for at sende en besked til alle brugere, der er registreret på et system. For at sende en besked skal du starte programmet med følgende kommando: ```bash wall ``` Bekræft programvalget med \[Enter\] og indtast din besked. Bekræft derefter igen med \[Enter\] og send med tastkombinationen \[CTRL\] + \[D\]. Alle brugere, der er registreret i systemet, modtager din besked som en udsendelse i terminalen. Det er værd at bemærke, at du skal give andre brugere skriveadgang til din terminal for at kunne modtage beskeder. Brug kommandoen `mesg` til dette: Hvis du vil sende filindhold til alle registrerede brugere, skal du bruge `wall` sammen med en input-omdirigering og det pågældende filnavn: ```bash wall < FILENAME ``` **12. se** Kommandolinjeprogrammet `watch` giver dig mulighed for at indstille en kommando til at køre med jævne mellemrum. Programmet kaldes ved hjælp af følgende syntaks: ```bash watch [OPTIONS] COMMAND ``` Det tidsinterval, hvor kommandoen angivet i `watch` skal udføres, angives med indstillingen `-n SECONDS`. Afslut `watch` med tastkombinationen \[CTRL\] + \[C\]. **13. toilet** [Kommandoen Linux `wc`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-wc/) (forkortelse for *ordtælling*) viser antallet af linjer, ord, bogstaver, tegn og/eller bytes i en tekstfil, alt efter hvad der ønskes. Kommandoens generelle syntaks er: ```bash wc [OPTIONS] FILE ``` Hvis `wc` kaldes uden parametre, svarer udskriften til mønsteret `LINES WORDS CHARACTERS FILE`. For at få en filtreret udskrift understøtter kommandolinjeprogrammet følgende parametre: `-l` (linjer), `-c` (bytes), `-m` (tegn), `-L` (længden af den længste linje) og `-w` (ord). **14. xargs** [Kommandoen Linux `xargs`](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoen-xargs/) giver dig mulighed for at overføre output fra en tidligere kommando til en ny kommando som et argument. Normalt bruges denne sammen med Pipe (`|`) som en omdirigeringsoperator. Brug `xargs` i henhold til følgende syntaks: ```bash COMMAND1 | xargs [OPTIONS] COMMAND2 ``` `xargs` kan f.eks. bruges sammen med kommandoen `find`. I det følgende eksempel identificerer `find` alle filer i det aktuelle bibliotek, der matcher søgeordet `*.tmp`, og sender deres navne til standardudgangen. Derfra hentes filnavnene fra `xargs` og videregives som argumenter til kommandoen `rm`. ```bash find . -name '*.tmp' | xargs rm ``` Den oversigt, der præsenteres her, gør ikke krav på at være udtømmende, men indeholder grundlæggende Linux-kommandoer med udvalgte anvendelseseksempler til det daglige arbejde med Unix-lignende operativsystemer. En uddybende beskrivelse af de kommandolinjeprogrammer, der præsenteres her, samt alle andre kommandoer, findes i manualen til dit operativsystem. En onlineversion af disse hjælp- og dokumentationssider er tilgængelig via [Linux man-pages-projektet](https://www.kernel.org/doc/man-pages/ "Linux man-pages project by Michael Kerrisk") af Michael Kerrisk. This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoer-en-oversigt-over-terminalkommandoer/](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoer-en-oversigt-over-terminalkommandoer/) for AI/LLM consumption.