# Sådan bruger du systemctl til at administrere tjenester og enheder I Linux spiller systemctl en central rolle i administrationen af init-systemet og servicestyringssystemet systemd. Med systemctl har brugerne kontrol over systemd-tjenester, deres enheder og konfigurationer, hvilket gør det til et uundværligt værktøj til systemadministration. Fra styring af opstart til tilpasning af systemtilstande tilbyder systemctl en bred vifte af funktioner. ## Hvad er systemctl? systemctl er et kommandolinjeværktøj til administration **af systemd**, et init-system og en systemadministrator til Linux-operativsystemer. systemd er i dag standard-init-systemet i flere Linux-distributioner og Linux-serverdistributioner, såsom Ubuntu, Debian, Fedora, Red Hat Enterprise Linux (RHEL), CentOS, Arch Linux, Mageia og Gentoo. Det er dog ikke implementeret i alle distributioner. I systemd-økosystemet spiller systemctl en **central rolle i administrationen af systemtjenester, konfiguration, opstartsadfærd og systemvedligeholdelse**. Værktøjets funktionalitet rækker langt ud over blot at starte og stoppe tjenester. Det giver mulighed for omfattende administration af næsten alle aspekter af et Linux-system. I denne vejledning finder du praktiske kodeeksempler og [Linux-kommandoer](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/linux-kommandoer-en-oversigt-over-terminalkommandoer/) til brug af systemctl. Eksemplerne nedenfor er baseret på **Ubuntu 22.04**. ## Servicestyring Hovedformålet med init-systemet er at starte de komponenter, der er nødvendige efter opstart af Linux-kernen (brugergrænsefladekomponenter). Init-systemet bruges også til effektivt at styre tjenester og daemons på en server på ethvert tidspunkt under systemets drift. I systemd fokuserer de fleste processer på ressourcer, der administreres af systemet. Disse kaldes **enheder**. Enhederne klassificeres efter den type ressource, de repræsenterer, og defineres via enhedsfiler. Du kan genkende enhedstypen på filtypen. Når man administrerer tjenester, er de tjenesteenheder, der slutter med endelsen *.service*, vigtige. Det er dog ikke altid nødvendigt at bruge denne endelse i kommandoer til tjenesteadministration. systemd kan genkende, at sådanne kommandoer generelt henviser til tjenester. ### Start og stop tjenester En af de mest almindelige opgaver, der udføres under Linux med systemctl, er at starte og stoppe tjenester. Disse funktioner er afgørende for systemadministration og giver dig mulighed for at bevare kontrollen over de processer, der kører på systemet. For at starte en tjeneste skal du bruge kommandoen `start`. Hvis du arbejder som bruger uden root-rettigheder, skal du bruge `sudo`. ```bash $ sudo systemctl start application.service ``` Da systemd er udviklet til automatisk at søge efter *.service* -filer til kommandoer til tjenestestyring, kan kommandoen også indtastes i en forenklet form: ```bash $ sudo systemctl start application ``` Hvis du f.eks. vil starte Apache-webserveren, skal du skrive: ```bash $ sudo systemctl start apache2 ``` Hvis du vil stoppe en kørende tjeneste, skal du bruge `stop`: ```bash $ sudo systemctl stop application.service ``` ### Genstart og genindlæs For at genstarte en tjeneste, hvilket ofte er nødvendigt efter en konfigurationsændring, skal du bruge kommandoen `restart`: ```bash $ sudo systemctl restart application.service ``` Hvis et program kan genindlæse sine **konfigurationsfiler uden at genstarte**, kan kommandoen `reload` bruges til at starte processen: ```bash $ sudo systemctl reload application.service ``` Hvis du er i tvivl om, hvorvidt en tjeneste understøtter genindlæsning af konfigurationen, kan du bruge kommandoen `reload-or-restart`. Dette vil genindlæse konfigurationen, hvis denne funktion understøttes. Hvis den ikke understøttes, vil kommandoen genstarte tjenesten for at igangsætte konfigurationsopdateringen. ```bash $ sudo systemctl reload-or-restart application.service ``` ### Aktivér og deaktiver tjenester Ved at aktivere og deaktivere tjenester kan du angive, om en tjeneste skal startes automatisk, når systemet starter op. Dette er især vigtigt for systemets ydeevne, sikkerheden og styringen af afhængigheder mellem forskellige tjenester. Brug kommandoen `enable` til at konfigurere automatisk aktivering ved systemstart: ```bash $ sudo systemctl enable application.service ``` Når denne proces udføres, oprettes der et symbolsk link. Dette link forbinder kopien af systemtjenestefilen. Systemtjenestefilen findes normalt under */lib/systemd/system* eller */etc/systemd/system*. Her finder du også den mappe på harddisken, hvor systemd søger efter filer til autostart. Dette sker normalt under */etc/systemd/system/some\_target.target.wants*. ```bash $ sudo systemctl enable application.service ``` For at forhindre, at en tjeneste starter automatisk ved opstart, skal du bruge `disable`: ```bash $ sudo systemctl disable application.service ``` Herefter slettes det symbolske link, der angiver automatisk aktivering ved opstart. **Bemærk**: Det er ikke nok blot at aktivere en tjeneste for at starte den med det samme i den aktuelle session. For at starte tjenesten med det samme og indstille den til at starte automatisk ved opstart skal du **udføre både** kommando `start` og `enable`. ### Tjek status for tjenesterne Med systemctl kan man få vist oplysninger om tjenesternes status. Dette er især nyttigt til overvågning og fejlfinding af den aktuelle status for system- og programtjenester. Brug kommandoen `status` til at tjekke: ```bash $ systemctl status application.service ``` Denne kommando giver en række oplysninger, herunder tjenestens aktuelle status (aktiv, inaktiv, fejlbehæftet osv.), de senest udførte processer og logmeddelelser, cgroup-hierarkiet samt de første loglinjer. For at kontrollere den aktuelle aktivitetsstatus for en tjeneste under Linux med systemctl bruges `is-active`. Denne kommando angiver, om en tjeneste i øjeblikket er aktiv eller ej: ```bash $ systemctl is-active application.service ``` Den aktuelle status angives normalt som `active`, hvis tjenesten er aktiv, eller `inactive`, hvis tjenesten er inaktiv. For at kontrollere, om en tjeneste er konfigureret til automatisk at blive aktiveret ved systemstart, kan du bruge kommandoen `is-enabled`. Dette er især nyttigt til at administrere startkonfigurationen af tjenester på et Linux-system. ```bash $ systemctl is-enabled application.service ``` Kommandoen angiver, om tjenesten er aktiveret eller deaktiveret, og indstiller afslutningskoden til henholdsvis ’0’ eller ’1’ afhængigt af svaret. Du kan også bruge kommandoen `is-failed` til at kontrollere, om en bestemt **tjeneste har en fejlstatus**: ```bash $ systemctl is-failed application.service ``` Hvis udførelsen lykkes, vises `active`. Hvis der opstår en fejl, vises `failed`. Hvis enheden blev stoppet bevidst, kan `unknown` eller `inactive` vises som svar. En afslutningsstatus på `0` angiver, at der er opstået en fejl, mens `1` angiver en anden status. ## Systemstatus De kommandoer, der er blevet gennemgået indtil nu, har fokuseret på administrationen af de enkelte tjenester. Disse kommandoer giver dog ikke indsigt i systemets aktuelle status. Der findes en række systemctl-kommandoer, der netop kan levere denne type information. `list-units` er et nyttigt værktøj til at få et overblik over de aktuelle enheder i Linux: ```bash $ systemctl list-units ``` Når du kører denne kommando, viser systemctl en liste over de enheder, der administreres af systemd. Listen indeholder forskellige kolonner med specifikke oplysninger om hver enkelt enhed. Følgende kolonner vises: - **UNIT**: Navnet på enheden (dette hentes ofte fra enhedens filnavn, f.eks. *sshd.service* for SSH-daemonen - **LOAD**: Angiver, om enhedsfilen blev indlæst korrekt; mulige værdier er `loaded`, `not-found` eller `error`. - **ACTIVE**: Enhedens aktivitetsstatus, som kan skifte mellem tilstande såsom `active`, `inactive`, `activating` eller `deactivating` - **SUB**: Den underordnede aktivitetsstatus, der giver yderligere detaljer om enhedens tilstand (For eksempel kan en `active` have en SUB-status på `running`, `exited` eller `failed`.) - **DESCRIPTION**: En kort beskrivelse af enheden, der ofte afspejler enhedens formål eller funktionalitet Kommandoen **viser** dog som standard **kun aktive enheder**. Af denne grund viser kolonnen LOAD i udskriften typisk `loaded`, mens kolonnen ACTIVE viser `active`. Ved hjælp af yderligere flag kan systemctl konfigureres til også at vise yderligere oplysninger. Hvis man f.eks. bruger flaget `--all`, vises alle enheder, der er indlæst af systemd, uanset deres aktuelle aktivitetsstatus. ```bash $ systemctl list-units --all ``` Resultatet kan yderligere finjusteres ved hjælp af yderligere flag, f.eks. `--state=`, til at filtrere efter bestemte tilstande i kategorierne LOAD, ACTIVE eller SUB. Det er vigtigt at beholde flag `--all`, så inaktive enheder også vises: ```bash $ systemctl list-units --all --state=inactive ``` Du kan også bruge filter `--type=` til at vise bestemte typer enheder, f.eks. hvis du kun vil se enheder i aktiv tjeneste: ```bash $ systemctl list-units --type=service ``` ### Vis alle enhedsfiler For at få vist en liste over alle enhedsfiler på Linux med systemctl (herunder dem, som systemd ikke har forsøgt at indlæse), kan du bruge `list-unit-files`. Denne kommando viser alle enhedsfiler, som systemd har kendskab til, herunder tjenester, sockets, mål og mere. ```bash $ systemctl list-units-files ``` Kommandoen viser forskellige tilstande for enhedsfiler. Disse tilstande angiver, hvordan de pågældende enheder er konfigureret, især med hensyn til deres adfærd ved systemstart. De mest almindelige tilstande er - **Aktiveret**: Enheden er konfigureret til at blive aktiveret automatisk ved systemstart. - **Deaktiveret**: Enheden er ikke konfigureret til automatisk opstart under boot-processen. - **Maskeret**: Enheden er fuldstændigt deaktiveret, så den hverken kan startes manuelt eller automatisk. - **Statisk**: Enheden startes ikke uafhængigt, men afhænger typisk af en anden enhed og startes kun i denne sammenhæng. ## Afdelingsledelse En af systemctls vigtigste opgaver er administrationen af enheder. systemctl tilbyder en række nyttige kommandoer og indstillinger, der gør det nemmere at få specifikke oplysninger om de enkelte enheder og at administrere dem. ### Vis en enhedsfil Hvis du ønsker, at indholdet af en bestemt enhedsfil skal vises direkte i konsollen, kan du bruge kommandoen `cat`. Hvis du f.eks. vil se enhedsfilen for en tjeneste som *ssh.service*, skal du indtaste: ```bash $ systemctl cat ssh.service ``` ### Vis afhængigheder Hvis du bruger `list-dependencies`, vises afhængighederne for en bestemt enhed i en træstruktur. Kommandoen ser således ud: ```bash $ systemctl list-dependencies sshd.service ``` Som standard vises afhængighederne for `.target` enheder, der repræsenterer forskellige systemtilstande. Brug flagget `--all` for at få en komplet, rekursiv liste over alle afhængigheder. For at få vist omvendte afhængigheder (dvs. enheder, der afhænger af den angivne enhed) skal du tilføje `--reverse` til kommandoen. Med flagene `--before` og `—after` kan du også se de afhængigheder, der starter før eller efter den pågældende enhed. ### Skjul og vis enheder Når man maskerer en enhed, deaktiveres den reelt, så den hverken kan startes manuelt eller automatisk. Dette bruges ofte til at sikre, at en tjeneste eller en enhed ikke startes ved et uheld eller automatisk på grund af afhængigheder. Maskering sker ved at oprette et symbolsk link fra den relevante enhedsfil til `/dev/null` ved hjælp af kommandoen `mask`: ```bash $ sudo systemctl mask nginx.service ``` Dette sikrer, at Nginx-tjenesten ikke kan startes manuelt eller automatisk, mens den er i maskeret tilstand. Fjernelse af maskering ophæver en enheds maskerede status, så den igen kan startes normalt. Kommandoen til fjernelse af maskering er `unmask`: ```bash $ sudo systemctl unmask nginx.service ``` ## Redigering af enhedsfiler systemctl har funktioner til at tilpasse og ændre enhedsfiler. Disse funktioner blev introduceret med version 218 af systemd. Hvis du bruger kommandoen `edit`, åbnes en enhedsfil i den valgte enhed automatisk, så du kan redigere den: ```bash $ sudo systemctl edit nginx.service ``` Når man redigerer, oprettes der en tom fil, hvor man kan tilføje eller ændre specifikke instruktioner til en enhedsdefinition. For hver enhed (f.eks. `nginx.service`) oprettes der en undermappe i mappen */etc/systemd/system*, hvor filnavnet får tilføjet *endelsen .d*. I eksemplet ovenfor vil undermappen hedde *nginx.service.d*. Der oprettes en *override.conf-fil* i denne undermappe. Når systemd indlæser enheden, kombinerer det indholdet af denne fil med den oprindelige enhedsfil. Her har instruktionerne i denne fil forrang. For at behandle hele enhedsfilen kan flagget `--full` bruges: ```bash $ sudo systemctl edit --full nginx.service ``` Hvis du trykker på `--full`, åbnes den eksisterende enhedsfil i et redigeringsprogram, så du kan foretage ændringer. Når du lukker redigeringsprogrammet, gemmer systemet den redigerede fil i */etc/systemd/system*. Hvis du vil fortryde ændringer, du selv har foretaget, kan du enten slette enhedens konfigurationsmappe `.d` eller den ændrede fil i `/etc/systemd/system`: ```bash $ sudo rm -r /etc/systemd/system/nginx.service.d ``` En fuldstændig revideret enhedsfil kan slettes med følgende kommando: ```bash $ sudo rm /etc/systemd/system/nginx.service ``` Når du har slettet filen eller mappen, skal du genstarte systemd, så det ikke længere henviser til de slettede filer, men i stedet bruger systemets egen kopi: ```bash $ sudo systemctl daemon-reload ``` ## Justering af systemtilstand (kørselstilstand) med mål systemd bruger primært »target« til at samle forskellige enheder i grupper. Dette gøres for at opnå en bestemt systemtilstand, svarende til runlevels i andre init-systemer. Filerne med filtypen `.target` fungerer som orienteringspunkter, der angiver, om bestemte funktioner er tilgængelige. Dette giver brugerne mulighed for at angive den ønskede overordnede tilstand i stedet for de enkelte enheder, der kræves. Et konkret eksempel er `swap.target`, som angiver, at enheden er klar til udskiftning. Enheder, der indgår i udskiftningsprocessen, kan tilpasse sig dette mål ved hjælp af konfigurationsindstillinger som `WantedBy=` eller `RequiredBy=`. Enheder, der er afhængige af udskiftningen, kan derimod angive dette med indstillinger som `Wants=`, `Requires=` og `After=` for at udtrykke deres afhængighed og startsekvens i forhold til udskiftningen. ### Hent og konfigurer standarddestination Ved at hente og konfigurere standardmålet kan du definere en standardtilstand for dit system ved opstart. Sådan finder du standardmålet for dit system: ```bash $ systemctl get-default Output multi-user.target ``` Hvis du vil ændre standardmålet, skal du bruge kommandoen `set-default` sammen med navnet på målet. Brug følgende kommando til at indstille standardmålet til `graphical.target`, hvilket starter en grafisk brugergrænseflade: ```bash $ sudo systemctl set-default graphical.target ``` ### Vis tilgængelige destinationer For at få vist alle de destinationer, der er tilgængelige på dit system, kan du bruge følgende kommando: ```bash $ systemctl list-unit-files --type=target ``` Her vises en liste over alle målenhedsfiler, der er installeret på dit system. Der vises sti og aktuel status (f.eks. aktiveret eller deaktiveret) for hvert mål. ### Udvælg mål Med `isolate` kan du samtidig aktivere alle enheder, der er knyttet til et bestemt mål, og deaktivere alle andre enheder, der ikke er knyttet til det. Lad os antage, at du arbejder i et miljø, hvor `graphical.target` er aktiv, og at du ønsker at skifte til en ren flerbrugertilstand uden grafisk brugergrænseflade. I dette tilfælde kan du deaktivere det grafiske system ved at isolere `multi-user.target`. Da `graphical.target` er afhængig af `multi-user.target`, men ikke omvendt, stoppes alle grafiske tjenester ved skiftet. Du bør dog kontrollere de tilknyttede afhængigheder, før du isolerer et mål. På den måde undgår du, at vigtige processer uforvarende stoppes. ```bash $ systemctl list-dependencies multi-user.target ``` Hvis du har markeret de aktive enheder, du vil beholde, og er enig i valget, kan du angive den ønskede destination: ```bash $ sudo systemctl isolate multi-user.target ``` ### Genveje til vigtige begivenheder Der findes specifikke kommandoer til vigtige handlinger som f.eks. at lukke systemet ned eller genstarte det. Under Linux tilbyder systemctl dog også praktiske genveje, der giver adgang til yderligere funktioner. Hvis du f.eks. vil sætte systemet i redningstilstand (enkeltbrugertilstand), kan du blot bruge `rescue` i stedet for `isolate rescue.target`: ```bash $ sudo systemctl rescue ``` Du kan stoppe systemet ved at indtaste `stop`: ```bash $ sudo systemctl stop ``` Du kan starte en fuldstændig nedlukning med `poweroff`: ```bash $ sudo systemctl poweroff ``` Du kan derimod starte en genstart med `reboot`: ```bash $ sudo systemctl reboot ``` Hvis du er logget ind, vil disse kommandoer give dig oplysninger om kommende begivenheder. Du får ikke disse oplysninger ved blot at køre eller isolere målet. Det er vigtigt at vide, at mange computere forbinder de kortere kommandoer til disse handlinger med systemd for at sikre korrekt udførelse. Følgende kommando er normalt tilstrækkelig til at genstarte systemet: ```bash $ sudo reboot ``` This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/server/konfiguration/systemctl/](https://www.ionos.com/da-dk/digitalguide/server/konfiguration/systemctl/) for AI/LLM consumption.