# Slik bruker du systemctl til å administrere tjenester og enheter I Linux spiller systemctl en sentral rolle i administrasjonen av init-systemet og tjenestestyringssystemet systemd. Med systemctl har brukerne kontroll over systemd-tjenester, enhetene og konfigurasjonene, noe som gjør det til et uunnværlig verktøy for systemadministrasjon. Fra oppstartskontroll til tilpasning av systemtilstander tilbyr systemctl et omfattende utvalg av funksjoner. ## Hva er systemctl? systemctl er et kommandolinjeverktøy for administrasjon **av systemd**, et init-system og en systemadministrator for Linux-operativsystemer. systemd er nå standard init-systemet for flere Linux-distribusjoner og Linux-serverdistribusjoner, som Ubuntu, Debian, Fedora, Red Hat Enterprise Linux (RHEL), CentOS, Arch Linux, Mageia og Gentoo. Det er imidlertid ikke implementert i alle distribusjoner. I systemd-økosystemet spiller systemctl en **sentral rolle i administrasjonen av systemtjenester, konfigurasjon, oppstartsatferd og systemvedlikehold**. Verktøyets funksjonalitet strekker seg utover det å bare starte og stoppe tjenester. Det gir omfattende kontroll over nesten alle aspekter av et Linux-system. I denne veiledningen finner du praktiske kodeeksempler og [Linux-kommandoer](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/linux-kommandoer-en-oversikt-over-terminalkommandoer/) for bruk av systemctl. Eksemplene nedenfor er basert på **Ubuntu 22.04**. ## Tjenestestyring Hovedformålet med init-systemet er å starte komponentene som trengs etter oppstart av Linux-kjernen (brukergrensesnittkomponenter). Init-systemet brukes også til å styre tjenester og bakgrunnsprosesser på en server på en effektiv måte når som helst mens systemet er i drift. I systemd er de fleste prosesser knyttet til ressurser som administreres av systemet. Disse kalles **enheter**. Enhetene klassifiseres etter hvilken type ressurs de representerer, og defineres gjennom enhetsfiler. Du kan gjenkjenne enhetstypen på filtypen. Ved administrasjon av tjenester er tjenesteenhetene som slutter med suffikset *.service* viktige. Det er imidlertid ikke alltid nødvendig å bruke dette suffikset i kommandoer for tjenesteadministrasjon. systemd kan gjenkjenne at slike kommandoer vanligvis refererer til tjenester. ### Starte og stoppe tjenester En av de vanligste oppgavene man utfører under Linux med systemctl, er å starte og stoppe tjenester. Disse funksjonene er grunnleggende for systemadministrasjon og gir deg mulighet til å holde kontroll over prosessene som kjører på systemet. For å starte en tjeneste bruker du kommandoen `start`. Hvis du arbeider som bruker uten root-rettigheter, må du bruke `sudo`. ```bash $ sudo systemctl start application.service ``` Siden systemd er utviklet for automatisk å søke etter *.service-filer* for tjenestestyringskommandoer, kan kommandoen også skrives inn i en forenklet form: ```bash $ sudo systemctl start application ``` For eksempel, for å starte Apache-webserveren, skriver du inn: ```bash $ sudo systemctl start apache2 ``` Hvis du vil stoppe en tjeneste som kjører, bruk `stop`: ```bash $ sudo systemctl stop application.service ``` ### Start på nytt og last inn på nytt For å starte en tjeneste på nytt, noe som ofte er nødvendig etter en konfigurasjonsendring, bruker du kommandoen `restart`: ```bash $ sudo systemctl restart application.service ``` Hvis et program kan laste inn **konfigurasjonsfilene** sine på nytt **uten å starte på nytt**, kan kommandoen `reload` brukes til å sette i gang prosessen: ```bash $ sudo systemctl reload application.service ``` Hvis du er usikker på om en tjeneste støtter muligheten til å laste inn konfigurasjonen på nytt, kan du bruke kommandoen `reload-or-restart`. Dette vil laste inn konfigurasjonen på nytt hvis denne funksjonen støttes. Hvis den ikke støttes, vil kommandoen starte tjenesten på nytt for å iverksette konfigurasjonsoppdateringen. ```bash $ sudo systemctl reload-or-restart application.service ``` ### Aktiver og deaktiver tjenester Ved å aktivere og deaktivere tjenester kan du angi om en tjeneste skal startes automatisk når systemet starter opp. Dette er særlig viktig for systemytelsen, sikkerheten og håndteringen av avhengigheter mellom ulike tjenester. Bruk kommandoen `enable` til å konfigurere automatisk aktivering ved systemoppstart: ```bash $ sudo systemctl enable application.service ``` Når denne prosessen utføres, opprettes det en symbolsk lenke. Denne lenken kobler til kopien av systemtjenestefilen. Systemtjenestefilen finnes vanligvis under */lib/systemd/system* eller */etc/systemd/system*. Her finner du også katalogen på harddisken der systemd søker etter filer for automatisk oppstart. Dette skjer vanligvis under */etc/systemd/system/some\_target.target.wants*. ```bash $ sudo systemctl enable application.service ``` For å hindre at en tjeneste starter automatisk ved oppstart, bruk `disable`: ```bash $ sudo systemctl disable application.service ``` Deretter blir den symbolske lenken som angir automatisk aktivering ved oppstart slettet. **Merk**: Det er ikke nok å bare aktivere en tjeneste for at den skal startes umiddelbart i den aktuelle økten. For å starte tjenesten umiddelbart og konfigurere den til å starte automatisk ved oppstart, må du **utføre både** kommando `start` og `enable`. ### Sjekk statusen på tjenestene systemctl gjør det mulig å vise informasjon om tjenestenes status. Dette er spesielt nyttig for å overvåke og diagnostisere den aktuelle statusen til system- og applikasjonstjenester. Bruk kommandoen `status` for å sjekke: ```bash $ systemctl status application.service ``` Denne kommandoen gir en rekke opplysninger, blant annet tjenestens nåværende status (aktiv, inaktiv, feil, osv.), de sist utførte prosessene og loggmeldingene, cgroup-hierarkiet og de første logglinjene. For å sjekke den aktuelle statusen til en tjeneste under Linux med systemctl, brukes `is-active`. Denne kommandoen angir om en tjeneste er aktiv for øyeblikket eller ikke: ```bash $ systemctl is-active application.service ``` Den nåværende statusen angis vanligvis som `active` hvis tjenesten er aktiv, eller `inactive` hvis tjenesten er inaktiv. For å sjekke om en tjeneste er konfigurert til å startes automatisk ved systemoppstart, kan du bruke kommandoen `is-enabled`. Dette er spesielt nyttig for å administrere oppstartskonfigurasjonen til tjenester på et Linux-system. ```bash $ systemctl is-enabled application.service ``` Kommandoen angir om tjenesten er aktivert eller deaktivert, og setter avslutningskoden til «0» eller «1» avhengig av svaret. Du kan også bruke kommandoen `is-failed` til å sjekke om en bestemt **tjeneste har feilstatus**: ```bash $ systemctl is-failed application.service ``` Hvis utførelsen lykkes, vises `active`. Hvis det oppstår en feil, vises `failed`. Hvis enheten ble stoppet med vilje, kan `unknown` eller `inactive` vises som svar. En avslutningsstatus på `0` indikerer at det har oppstått en feil, mens `1` indikerer en hvilken som helst annen status. ## Systemstatus Kommandoene som er presentert så langt, har fokusert på administrasjon av enkeltstående tjenester. Disse kommandoene gir imidlertid ikke innsikt i systemets aktuelle status. Det finnes en rekke systemctl-kommandoer som kan gi nettopp denne typen informasjon. `list-units` er et nyttig verktøy for å få oversikt over de aktuelle enhetene i Linux: ```bash $ systemctl list-units ``` Når du kjører denne kommandoen, viser systemctl en liste over enheter som administreres av systemd. Utdataene fra denne listen inneholder ulike kolonner med spesifikk informasjon om hver enkelt enhet. Følgende kolonner vises: - **UNIT**: Navnet på enheten (dette hentes ofte fra filnavnet til enheten, f.eks. *sshd.service* for SSH-demonen - **LOAD**: Angir om enhetsfilen ble lastet inn; mulige verdier er `loaded`, `not-found` eller `error`. - **ACTIVE**: Enhetens aktivitetsstatus, som kan veksle mellom moduser som `active`, `inactive`, `activating` eller `deactivating` - **SUB**: Den underordnede aktivitetsstatusen som gir ytterligere detaljer om enhetens tilstand (For eksempel kan en `active` ha en SUB-status på `running`, `exited` eller `failed`.) - **DESCRIPTION**: En kort beskrivelse av enheten, som ofte gjenspeiler enhetens formål eller funksjonalitet Kommandoen **viser** imidlertid som standard **kun aktive enheter**. Av denne grunn viser LOAD-kolonnen i utdataene vanligvis `loaded`, mens ACTIVE-kolonnen viser `active`. Ved hjelp av tilleggsflagg kan systemctl konfigureres slik at den også viser ytterligere informasjon. Hvis du for eksempel bruker flagget `--all`, vil alle enheter som er lastet inn av systemd vises, uavhengig av deres nåværende aktivitetsstatus. ```bash $ systemctl list-units --all ``` Resultatet kan videre finjusteres ved å bruke tilleggsflagg som `--state=` for å filtrere ut bestemte tilstander i kategoriene LOAD, ACTIVE eller SUB. Det er viktig å beholde flagget `--all` slik at også inaktive enheter vises: ```bash $ systemctl list-units --all --state=inactive ``` Du kan også bruke filter `--type=` til å vise bestemte typer enheter, f.eks. hvis du bare vil se enheter i aktiv tjeneste: ```bash $ systemctl list-units --type=service ``` ### Vis alle enhetsfiler For å vise en liste over alle enhetsfiler på Linux med systemctl (inkludert de som systemd ikke har forsøkt å laste inn), kan du bruke `list-unit-files`. Denne kommandoen viser alle enhetsfiler som systemd har kjennskap til, inkludert tjenester, sokler, mål og mer. ```bash $ systemctl list-units-files ``` Kommandoen viser ulike tilstander for enhetsfiler. Disse tilstandene angir hvordan de respektive enhetene er konfigurert, særlig med hensyn til hvordan de oppfører seg ved systemoppstart. De vanligste tilstandene er - **Aktivert**: Enheten er konfigurert til å startes automatisk ved systemoppstart. - **Deaktivert**: Enheten er ikke konfigurert for automatisk oppstart under oppstartsprosessen. - **Maskert**: Enheten er fullstendig deaktivert, slik at den ikke kan startes manuelt eller automatisk. - **Statisk**: Enheten startes ikke uavhengig, men er vanligvis avhengig av en annen enhet og startes kun i denne sammenhengen. ## Enhetsledelse En av systemctls viktigste oppgaver er å administrere enheter. systemctl tilbyr en rekke nyttige kommandoer og alternativer som gjør det enklere å hente frem spesifikk informasjon om enkeltstående enheter og å administrere dem. ### Vis en enhetsfil Hvis du vil at innholdet i en bestemt enhetsfil skal vises direkte i konsollen, kan du bruke kommandoen `cat`. Hvis du for eksempel vil se enhetsfilen til en tjeneste som *ssh.service*, skriver du inn: ```bash $ systemctl cat ssh.service ``` ### Vis avhengigheter Hvis du bruker `list-dependencies`, vises avhengighetene til en bestemt enhet i en trestruktur. Kommandoen ser slik ut: ```bash $ systemctl list-dependencies sshd.service ``` Det er standard at avhengigheter vises for `.target` enheter som representerer ulike systemtilstander. Bruk flagget `--all` for å få en fullstendig, rekursiv liste over alle avhengigheter. For å vise omvendte avhengigheter (dvs. enheter som er avhengige av den angitte enheten), legger du til `--reverse` i kommandoen. Med flaggene `--before` og `—after` kan du også se avhengighetene som starter før eller etter den aktuelle enheten. ### Enheter for å skjule og vise Når en enhet maskeres, deaktiveres den effektivt, slik at den ikke kan startes manuelt eller automatisk. Dette brukes ofte for å sikre at en tjeneste eller en enhet ikke startes ved et uhell eller automatisk på grunn av avhengigheter. Maskering gjøres ved å opprette en symbolsk lenke fra den aktuelle enhetsfilen til `/dev/null` ved hjelp av kommandoen `mask`: ```bash $ sudo systemctl mask nginx.service ``` Dette sikrer at Nginx-tjenesten ikke kan startes manuelt eller automatisk mens den er i skjult modus. Avmaskering fjerner maskeringen fra en enhet, slik at den kan startes på nytt som vanlig. Kommandoen for avmaskering er `unmask`: ```bash $ sudo systemctl unmask nginx.service ``` ## Redigering av enhetsfiler systemctl har funksjoner for å tilpasse og endre enhetsfiler. Disse funksjonene ble introdusert i versjon 218 av systemd. Hvis du bruker kommandoen `edit`, åpnes en enhetsfil i den valgte enheten automatisk for redigering: ```bash $ sudo systemctl edit nginx.service ``` Når du redigerer, opprettes det en tom fil for å legge til eller endre bestemte instruksjoner i en enhetsdefinisjon. For hver enhet (f.eks. `nginx.service`) opprettes det en undermappe i katalogen */etc/systemd/system*, der filnavnet får suffikset *.d*. I eksemplet ovenfor vil undermappen hete *nginx.service.d*. Det opprettes en *override.conf-fil* i denne undermappen. Når systemd laster inn enheten, kombinerer den innholdet i denne utdragsfilen med den opprinnelige enhetsfilen. Her har instruksjonene i utdraget forrang. For å behandle hele enhetsfilen kan flagget `--full` brukes: ```bash $ sudo systemctl edit --full nginx.service ``` Hvis du trykker på `--full`, åpnes den eksisterende enhetsfilen i et redigeringsprogram slik at du kan gjøre endringer. Når du lukker redigeringsprogrammet, lagrer systemet den redigerte filen i */etc/systemd/system*. For å angre endringer du selv har gjort, kan du enten slette enhetens konfigurasjonsmappe `.d` eller den endrede filen i `/etc/systemd/system`: ```bash $ sudo rm -r /etc/systemd/system/nginx.service.d ``` En fullstendig revidert enhetsfil kan slettes med følgende kommando: ```bash $ sudo rm /etc/systemd/system/nginx.service ``` Etter at du har slettet filen eller mappen, må du laste inn systemd på nytt, slik at det slutter å henvise til de slettede filene og i stedet bruker systemets egen kopi: ```bash $ sudo systemctl daemon-reload ``` ## Justering av systemtilstand (kjøringsnivå) med mål systemd bruker først og fremst «target» til å gruppere ulike enheter. Dette gjøres for å oppnå en bestemt systemtilstand, på samme måte som kjøringsnivåer i andre init-systemer. Filene med filtypen `.target` fungerer som referansepunkter som angir tilgjengelighetsstatusen til visse funksjoner. Dette gjør det mulig for brukerne å angi den ønskede samlede tilstanden, i stedet for de enkelte enhetene som kreves. Et praktisk eksempel er `swap.target`, som angir statusen for bytteberedskap. Enheter som er involvert i bytteprosessen, kan tilpasse seg dette målet ved hjelp av konfigurasjonsalternativer som `WantedBy=` eller `RequiredBy=`. Enheter som er avhengige av byttet, kan derimot angi dette med innstillinger som `Wants=`, `Requires=` og `After=` for å uttrykke sin avhengighet og startrekkefølge i forhold til byttet. ### Hent og angi standarddestinasjon Ved å hente og konfigurere standardmålet kan du definere en standardtilstand for systemet ved oppstart. Slik finner du standardmålet for systemet ditt: ```bash $ systemctl get-default Output multi-user.target ``` Hvis du vil endre standardmålet, bruker du kommandoen `set-default` sammen med navnet på målet. Bruk følgende kommando for å angi standardmålet til `graphical.target`, som starter et grafisk brukergrensesnitt: ```bash $ sudo systemctl set-default graphical.target ``` ### Vis tilgjengelige reisemål For å vise en liste over alle destinasjoner som er tilgjengelige på systemet ditt, kan du bruke følgende kommando: ```bash $ systemctl list-unit-files --type=target ``` Dette viser en liste over alle målenhetsfiler som er installert på systemet ditt. Banen og gjeldende status (f.eks. aktivert eller deaktivert) vises for hvert mål. ### Isolere mål Med `isolate` kan du samtidig aktivere alle enheter som er koblet til et bestemt mål, og deaktivere alle andre enheter som ikke er koblet til det. La oss anta at du arbeider i et miljø der `graphical.target` er aktivt, og at du ønsker å bytte til en ren flerbrukermodus uten grafisk brukergrensesnitt. I dette tilfellet kan du deaktivere det grafiske systemet ved å isolere `multi-user.target`. Siden `graphical.target` er avhengig av `multi-user.target`, men ikke omvendt, stoppes alle grafiske tjenester ved byttet. Du bør imidlertid sjekke de tilknyttede avhengighetene før du isolerer et mål. Dette vil forhindre at viktige prosesser stoppes ved en feiltakelse. ```bash $ systemctl list-dependencies multi-user.target ``` Hvis du har merket av de aktive enhetene du ønsker å beholde og er enig i valget, kan du velge ønsket destinasjon: ```bash $ sudo systemctl isolate multi-user.target ``` ### Snarveier til viktige begivenheter Det finnes spesifikke kommandoer for viktige operasjoner som å slå av eller starte systemet på nytt. Under Linux tilbyr imidlertid systemctl også praktiske snarveier som gir tilleggsfunksjoner. For eksempel kan du, for å sette systemet i redningsmodus (enbrukermodus), ganske enkelt bruke `rescue` i stedet for `isolate rescue.target`: ```bash $ sudo systemctl rescue ``` Du kan stoppe systemet ved å taste `stop`: ```bash $ sudo systemctl stop ``` Du kan starte en fullstendig nedstengning med `poweroff`: ```bash $ sudo systemctl poweroff ``` Du kan derimot starte en omstart med `reboot`: ```bash $ sudo systemctl reboot ``` Hvis du er logget inn, vil disse kommandoene gi deg informasjon om kommende hendelser. Du får ikke denne informasjonen ved bare å kjøre eller isolere målet. Det er viktig å vite at mange datamaskiner kobler de kortere kommandoene for disse handlingene til systemd for å sikre korrekt utførelse. Følgende kommando er vanligvis tilstrekkelig for å starte systemet på nytt: ```bash $ sudo reboot ``` This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/systemctl/](https://www.ionos.com/nb-no/digitalguide/server/konfigurasjon/systemctl/) for AI/LLM consumption.