---
title: Nach der Installation
description: Schritte zur Konfiguration nach der Installation von CachyOS
tableOfContents:
  minHeadingLevel: 1
  maxHeadingLevel: 4
---

import { Tabs, TabItem, Steps, LinkButton, Icon } from '@astrojs/starlight/components';
import ImageComponent from '~/components/image-component.astro';

## Empfohlene Schritte nach der Installation

### Das System aktualisieren

:::tip
Schau dir unbedingt unsere [Sicherheit & bewährte Praktiken](/de/cachyos_basic/faq#sicherheit--bewährte-praktiken) an, um häufige Fehler zu vermeiden und dein System sicher zu halten.
:::

<Tabs>

<TabItem label="Shelly (GUI & CLI)">
    <LinkButton icon="external" href="https://www.seafoam-labs.org/shelly-alpm/overview/">Shellys Wiki</LinkButton>
    <LinkButton icon="external" href="https://www.seafoam-labs.org/shelly-alpm/docs/cli-reference/">Shelly CLI</LinkButton>

    [Shelly](https://github.com/Seafoam-Labs/Shelly-ALPM) ist eine moderne Interpretation des Arch Linux Package Managers, entworfen um eine intuitivere und benutzerfreundlichere Alternative zu Pacman und Octopi zu sein.

    Entwickelt von: [Seafoam-Labs](https://github.com/Seafoam-Labs)

    Erlaubt den Benutzern ihre Pakete zu verwalten ohne das Terminal benutzen zu müssen.

    Features von Shelly sind unter anderem:

    Installieren/Deinstallieren von Paketen vom AUR, offiziellen Repositories, AppImages, Flatpaks und lokalen Paketen, Paket-Details einsehen, Paket Gruppen verwalten und vieles mehr.

    Warum Shelly anstatt Octopi?
    - Es hat ein moderneres und benutzerfreundlicheres Interface.
    - Stetige Weiterentwicklung und Updates mit neuen Features und Verbesserungen.
    - Unterstützt mehr Paket-Formate (AUR, AppImages, Flatpaks, etc.)
    - Sicherheitsfeatures wie PKGBUILDs-Verifizierung, sieh dir die [Security Checks](https://www.seafoam-labs.org/shelly-alpm/docs/security/) für mehr Informationen an.

    <details>
        <summary>Shelly Homepage Screenshot</summary>
        <ImageComponent imgsrc={import('~/assets/images/shelly-homepage.png')} />
    </details>
    <details>
        <summary>Paket Management Tab</summary>
        <ImageComponent imgsrc={import('~/assets/images/shelly-package-management.png')} />
    </details>
    Hier sind einige nützliche Befehle, um mit Shelly's CLI zu starten:

    <details>
    <summary>Alle Pakete upgraden (AUR, offizielle Repositories, Flatpak, etc.):</summary>
    ```sh
    shelly
    ```
    </details>
    <details>
    <summary>Standard-Pakete upgraden (Arch-Derivate) + Paket installieren:</summary>
    ```sh
    shelly install --upgrade {pkg}
    # Beispiel:
    shelly install --upgrade discord
    ```
    </details>
    <details>
    <summary>Paket und Abhängigkeiten entfernen:</summary>
    ```sh
    shelly remove {pkg}
    # Beispiel:
    shelly remove discord
    ```
    </details>
    <details>
    <summary>AUR-Paket suchen:</summary>
    ```sh
    shelly aur search {pkg}
    ```
    </details>
</TabItem>

<TabItem label="Mit Octopi (GUI)">

Octopi ist ein grafischer Paketmanager für Arch-basierte Distributionen, der eine bequeme Möglichkeit bietet, Pakete und Updates zu verwalten.
Um dein System mit Octopi zu aktualisieren, befolge diese Schritte:

<Steps>

1. Starte **Octopi** aus dem Anwendungsmenü.
2. Klicke im Hauptfenster auf den Button **Check updates** (oben links) und dann daneben auf **System upgrade.**
3. Octopi prüft nun auf verfügbare Updates und fordert dich auf, sie entweder direkt in Octopi oder in einem Terminal zu installieren.
4. Um mit dem Update fortzufahren, klicke auf den **Apply**-Button.
5. Octopi wird die Updates herunterladen und installieren.
6. Es wird empfohlen, den Computer nach einem großen Update neu zu starten **(insbesondere wenn der Kernel ein Update erhalten hat)**.

</Steps>

</TabItem>

<TabItem label="Mit Pacman">

<Steps>

1. Öffne einen Terminal-Emulator (oder drücke `Strg + Alt + T` - `Mod + Return` in einem WM wie z.B. Qtile).
2. Führe den folgenden Befehl aus, um das System zu aktualisieren:

   ```sh
   sudo pacman -Syu
   ```
3. Es wird empfohlen, den Computer nach einem großen Update neu zu starten **(insbesondere wenn der Kernel ein Update erhalten hat)**.

</Steps>

</TabItem>

<TabItem label="Offline-Systemupdate">

*CachyOS unterstützt Offline-Systemupgrades mit dem [`pacman-offline`](https://github.com/eworm-de/pacman-offline) Skript. Dadurch kann dein System Paketupdates herunterladen und beim nächsten Neustart anwenden. (Ja, wie bei Windows)*

:::note
Das `pacman-offline`-Tool integriert sich in die Offline-Update-Funktion von systemd. Es kümmert sich automatisch um Kernel-Updates und das Laden von Modulen.

Die Datei `/etc/pacman.d/offline.conf` ist entscheidend für die Verwaltung, welche Pakete bei regulären und Offline-Updates aktualisiert werden. Stelle sicher, dass sie für deinen gewünschten Kernel korrekt konfiguriert ist oder füge die Pakete hinzu, die nur während der Ausführung von pacman-offline aktualisiert und bei einem regulären Update ignoriert werden sollen. Beispiel: `pacman -Syu`.

**Wenn du den automatischen Update-Timer aktivierst, musst du dein System nicht mehr manuell aktualisieren.**
:::

<Steps>

1. **Installiere das pacman-offline Paket**

   ```bash
   sudo pacman -S pacman-offline
   ```

2. **Pacman anweisen, die separate Paket-Ignorierliste zu lesen.**

   :::note[Füge die Zeile nach dem Abschnitt [options] ein. Schau dir das Beispiel unten als Referenz an.]
   :::

   ```bash title='Füge die folgende Zeile zur Datei /etc/pacman.conf hinzu'
   Include = /etc/pacman.d/offline.conf
   ```
   *Beispiel*
   ```bash
   # /etc/pacman.conf
   # REPOSITORIES
   #   - can be defined here or included from another file
   #   - pacman will search repositories in the order defined here
   #   - local/custom mirrors can be added here or in separate files
   #   - repositories listed first will take precedence when packages
   #     have identical names, regardless of version number
   #   - URLs will have $repo replaced by the name of the current repo
   #   - URLs will have $arch replaced by the name of the architecture
   #
   # Repository entries are of the format:
   #       [repo-name]
   #       Server = ServerName
   #       Include = IncludePath
   #
   # The header [repo-name] is crucial - it must be present and
   # uncommented to enable the repo.
   #
   # GENERAL OPTIONS
   [options]
   # other options like 'Color', 'CheckSpace', etc. can be here
   Include = /etc/pacman.d/offline.conf
   ```
3. **Hinzufügen der CachyOS-Kernel, damit pacman sie bei regulären Updates ignoriert**

   Das `pacman-offline`-Tool verwendet diese Datei, um zu bestimmen, welche Pakete bei traditionellen Pacman-Updates ignoriert werden sollen.

   Beispiel: wenn du `sudo pacman -Syu` ausführst

   *Ersetze den Inhalt der Datei `/etc/pacman.d/offline.conf` durch Folgendes:*

   ```text
   # Arch Linux kernels
   IgnorePkg = linux linux-headers linux-docs
   IgnorePkg = linux-lts linux-lts-headers linux-lts-docs
   IgnorePkg = linux-zen linux-zen-headers linux-zen-docs
   IgnorePkg = linux-hardened linux-hardened-headers linux-hardened-docs

   # CachyOS kernels
   IgnorePkg = linux-cachyos linux-cachyos-headers linux-cachyos-nvidia-open linux-cachyos-zfs
   IgnorePkg = linux-cachyos-bmq linux-cachyos-bmq-headers linux-cachyos-bmq-nvidia-open linux-cachyos-bmq-zfs
   IgnorePkg = linux-cachyos-bore linux-cachyos-bore-headers linux-cachyos-bore-nvidia-open linux-cachyos-bore-zfs
   IgnorePkg = linux-cachyos-deckify linux-cachyos-deckify-headers linux-cachyos-deckify-nvidia-open linux-cachyos-deckify-zfs
   IgnorePkg = linux-cachyos-eevdf linux-cachyos-eevdf-headers linux-cachyos-eevdf-nvidia-open linux-cachyos-eevdf-zfs
   IgnorePkg = linux-cachyos-gcc linux-cachyos-gcc-headers linux-cachyos-gcc-nvidia-open linux-cachyos-gcc-zfs
   IgnorePkg = linux-cachyos-hardened linux-cachyos-hardened-headers linux-cachyos-hardened-nvidia-open linux-cachyos-nvidia-hardened-zfs
   IgnorePkg = linux-cachyos-lts linux-cachyos-lts-headers linux-cachyos-lts-nvidia-open linux-cachyos-lts-zfs
   IgnorePkg = linux-cachyos-rc linux-cachyos-rc-headers linux-cachyos-rc-nvidia-open linux-cachyos-rc-nvidia-open linux-cachyos-rc-zfs
   IgnorePkg = linux-cachyos-rt-bore linux-cachyos-rt-bore-headers linux-cachyos-rt-bore-nvidia-open
   IgnorePkg = linux-cachyos-server linux-cachyos-server-headers linux-cachyos-server-nvidia-open linux-cachyos-server-zfs
   ```

   *Jetzt werden all diese Pakete bei den regulären Updates ignoriert, aber während der Offline-Vorbereitung überprüft.*

3. **Starte die Vorbereitung für das Offline-Update nur einmal**

   ```bash title='Führe den folgenden Befehl aus'
   sudo systemctl start pacman-offline-prepare.service
   ```
   Dieser Befehl bewirkt, dass pacman-offline einmal ausgeführt wird, die Paketdatenbanken synchronisiert und Updates herunterlädt, aber nicht installiert.

</Steps>

*Wenn du möchtest, dass dieses Skript automatisiert wird, befolge die folgenden Schritte:*

<Steps>

1. **Aktiviere den Vorbereitungs-Timer**

   Wenn der `pacman-offline-prepare.timer` aktiviert ist, wird systemd dieses Skript täglich nach einigen Minuten nach jedem Systemstart auslösen, um Updates herunterzuladen.

   ```bash
   sudo systemctl enable pacman-offline-prepare.timer
   ```

2. **Starte dein System neu:**

   Die Updates werden während des nächsten Systemneustarts installiert.

3. **(Optional) Automatische Systemneustarts:**

    Aktiviere den `pacman-offline-reboot.timer`, um dein System standardmäßig um **3 Uhr morgens** (deine Zeitzone) automatisch neu zu starten, wenn Updates anstehen. Sei dir bewusst, dass es aufgrund der Einbeziehung von `RandomizedDelaySec`, das standardmäßig auf 2 Stunden eingestellt ist, nicht immer zur gleichen Zeit geschieht.

    ```bash
    sudo systemctl enable pacman-offline-reboot.timer
    ```

    :::tip
    Du kannst die Datei `pacman-offline-reboot.timer` bearbeiten, um entweder die Zeit zu ändern, zu der dein System bei anstehenden Updates neu gestartet werden soll, oder den zufälligen Zeitplan zu deaktivieren.
    :::

</Steps>

</TabItem>

<TabItem label="Cachy-Update">

Fork von [Arch-Update](https://github.com/Antiz96/arch-update)

Ein Update-Benachrichtiger & -Anwender für Arch Linux, der dich bei wichtigen Aufgaben vor/nach dem Update unterstützt.
Enthält ein dynamisches & klickbares Systray-Applet für eine einfache Integration in jede Desktop-Umgebung / jeden Window Manager.

<details>
    <summary>Wie man Cachy-Update aktiviert</summary>
    Aktiviere Cachy-Update in `CachyOS Hello > Apps/Tweaks > Cachy Update enabled`
</details>
<details>
    <summary>Wie man Cachy-Update deaktiviert</summary>
        Deaktiviere Cachy-Update in `CachyOS Hello > Apps/Tweaks > Cachy Update disabled`
            :::tip
            Wenn du Cachy-Update behalten und nur das Systray-Applet deaktivieren möchtest, öffne ein Terminal und führe die folgenden Befehle aus:
            ```bash
            mkdir -p ~/.config/autostart
            echo -e "[Desktop Entry]\nHidden=true" > ~/.config/autostart/arch-update-tray.desktop
            ```
            Wenn du das System-Tray-Applet aktiviert lassen willst und einfach die automatische Update-Prüfung deaktivieren möchtest, führe den folgenden Befehl aus:
            ```bash
            systemctl --user disable --now arch-update.timer
            ```
            :::
</details>

- Features:
  - Automatische Überprüfung und Auflistung verfügbarer Updates.
  - Überprüfung auf aktuelle Arch Linux News (und bietet an, sie anzuzeigen, falls vorhanden).
  - Überprüfung auf verwaiste Pakete (und bietet an, sie zu entfernen, falls vorhanden).
  - Überprüfung auf alte & deinstallierte Pakete im Cache (und bietet an, sie zu entfernen, falls vorhanden).
  - Überprüfung auf anstehende Kernel-Updates, die einen Neustart erfordern (und bietet an, dies zu tun, falls vorhanden).
  - Überprüfung auf Dienste, die nach einem Upgrade einen Neustart erfordern (und bietet an, dies zu tun, falls vorhanden).
  - Unterstützung für `sudo`, `sudo-rs`, `doas` & `run0`.

**Intervall für die Update-Prüfung:** `Einmal zwei Minuten nach dem Booten und dann einmal täglich mit einer einstündigen zufälligen Verzögerung.`

- Wie man das Intervall für die Update-Prüfung ändert:

```sh title='Führe den folgenden Befehl aus'
systemctl --user edit --full arch-update.timer
# Tipp: Du kannst statt `nano` auch jeden anderen Texteditor deiner Wahl verwenden
# z.B. EDITOR=micro systemctl --user edit --full arch-update.timer
```

<details>
<summary>Standardinhalt der Datei:</summary>
    ```systemd
    [Timer]
    OnStartupSec=2min # Prüfe zwei Minuten nach dem Booten auf Updates
    RandomizedDelaySec=1h # Einstündige zufällige Verzögerung
    OnUnitActiveSec=1d # Prüfe einmal täglich auf Updates
    ```
</details>
Im Grunde kannst du den Wert `OnUnitActiveSec` auf alles ändern, was du willst. Wenn du zum Beispiel alle 30 Minuten auf Updates prüfen möchtest, ändere ihn auf `30m`. Oder alle 6 Stunden, ändere ihn auf `6h`. Schau dir dieses [Dokument](https://www.freedesktop.org/software/systemd/man/latest/systemd.time.html#Parsing%20Time%20Spans) an für mehr Details, wie man das Zeitintervall einstellt.

Falls du möchtest, dass Cachy-Update nur einmal beim Booten auf neue Updates prüft, kannst du einfach die Zeile `OnUnitActiveSec` komplett löschen.

Danke an [Antiz](https://github.com/Antiz96) für die Wartung des Upstream-Projekts Arch-Update und für die Implementierung von Cachy-Update.

</TabItem>

</Tabs>

## Firewall konfigurieren (ufw)
:::note
UFW ist nach der Installation standardmäßig aktiviert.
:::
Um ufw zu konfigurieren, befolge diese Schritte:

<Tabs>

<TabItem label="Aktivieren">

```bash
sudo ufw enable
```

</TabItem>

<TabItem label="Deaktivieren">

```bash
sudo ufw disable
```

</TabItem>

<TabItem label="Erlauben">

Ufw ignoriert standardmäßig eingehenden Traffic und lässt ausgehenden durch. Du kannst aber eigene Regeln zur Firewall hinzufügen, um bestimmte Verbindungen zu blockieren oder zu erlauben.

```bash
# Beispiel 1, SSH-Traffic erlauben:
sudo ufw allow ssh
# Beispiel 2, Port 12345 für TCP & UDP Traffic öffnen:
sudo ufw allow 12345

# Text oder Portnummer kann angepasst werden, wie 12345/udp um nur UDP-Traffic zu erlauben oder ssh durch einen Programmnamen zu ersetzen
```

</TabItem>

<TabItem label="Verweigern">

Ufw ignoriert standardmäßig eingehenden Traffic und lässt ausgehenden durch. Du kannst aber eigene Regeln zur Firewall hinzufügen, um bestimmte Verbindungen zu blockieren oder zu erlauben.

```bash
# Beispiel 1, SSH-Traffic verweigern:
sudo ufw deny ssh
# Beispiel 2, Port 12345 für TCP & UDP Traffic schließen:
sudo ufw deny 12345

# Text oder Portnummer kann angepasst werden, wie 12345/udp um nur UDP-Traffic zu verweigern oder ssh durch einen Programmnamen zu ersetzen
```

</TabItem>

<TabItem label="Status">

```bash
sudo ufw status verbose
```
:::tip
Wenn du nicht vergessen willst, warum du einen Port geöffnet/geschlossen hast, füge einen Kommentar zur Regel hinzu.
```bash
# Beispiel 1, Port 12345 für TCP & UDP Traffic mit einem Kommentar öffnen:
sudo ufw allow 12345 comment 'Beispiel'
# Beispiel 2, Port 6789 für TCP mit einem Kommentar schließen:
sudo ufw deny 6789/tcp comment 'Kommentare können Leerzeichen haben'
```
:::
</TabItem>

</Tabs>

:::note
Sei vorsichtig beim Konfigurieren von Firewall-Regeln, da falsch konfigurierte Regeln dich aus deinem eigenen System aussperren können.
:::

:::note
Du kannst sie auch grafisch über den Abschnitt "Firewall" in den KDE Plasma-Einstellungen konfigurieren.
:::

:::note
Änderungen an allow/deny treten in Kraft, nachdem ufw neu gestartet wurde. Deaktiviere und aktiviere ufw erneut für sofortige Ergebnisse.
:::

### Globales Menü aktivieren
Bei einigen Apps wie Visual Studio Code funktioniert das globale Menü möglicherweise nicht oder ist an die übergeordnete App statt an das Panel angeheftet.

```sh
# Um die Unterstützung für das globale Menü zu aktivieren, führe den Befehl aus und starte die App neu.
sudo pacman -S appmenu-gtk-module libdbusmenu-glib
```

## Optionale Einstellungen

### Die Standard Shell ändern

Derzeit verwendet CachyOS [fish](https://fishshell.com/) als Standard-Login-Shell des Benutzers. Du kannst jedoch
die Standard-Shell nach Belieben ändern.

<Tabs>
   <TabItem label='bash'>

      Dies ist die Standard-Shell auf fast jeder Linux-Distribution. Sie wird auch immer noch als Login-Shell des root-Benutzers verwendet. bash
      verfügt über grundlegende Autovervollständigungsfunktionen und eine einfache Verlaufsverwaltung. Es unterscheidet sich von zsh und fish dadurch, dass es nicht das ausgefallene Anpassungs- und Plugin-Ökosystem hat, das sowohl fish als auch zsh besitzen.


      ```sh title='Ändere deine Standard-Shell auf bash'
      chsh -s /usr/bin/bash
      ```

   </TabItem>

   <TabItem label='zsh'>

      Wir bieten eine [zsh-Konfiguration](https://github.com/CachyOS/cachyos-zsh-config) mit häufig verwendeten Plugins und Konfigurationen an.
      Sie zielt darauf ab, eine 1:1-Funktionalität mit unserer [fish-Konfiguration](https://github.com/CachyOS/cachyos-fish-config) zu haben.
      Dies ist auch die Standard-Shell, die in MacOS verwendet wird.

      ```sh title='Ändere die Standard-Shell auf zsh'
      chsh -s /usr/bin/zsh
      ```

   </TabItem>
</Tabs>

### Updaten mit [tldr](https://github.com/tldr-pages/tldr)

:::note
CachyOS verwendet [tealdeer](https://github.com/tealdeer-rs/tealdeer), eine schnellere, auf Rust basierende Implementierung des ursprünglichen tldr
:::

Dieses Tool ist extrem nützlich für diejenigen, die nicht viel lesen oder Zeit mit dem Lesen einer Hilfe-/Manpage verschwenden wollen.

<Steps>

1. ```sh title="Öffne ein Terminal und führe den folgenden Befehl aus"
   tldr --update
   ```
2. Beispiel für die Verwendung von tldr:
   ```sh
   tldr java
     Execute a `.jar` program:

      java -jar filename.jar

   # Wie du sehen kannst, ist es wirklich nützlich, und im Laufe der Zeit werden neue Tools/Seiten hinzugefügt.
   ```

</Steps>

## Appimages verwalten

Appimages sind portable Anwendungen, die auf den meisten Linux-Distributionen laufen, ohne dass eine Installation oder root-Rechte erforderlich sind.

:::note[Alle AppImages benötigen Ausführungsberechtigungen, um zu laufen.]
Du kannst die Ausführungsberechtigung mit dem folgenden Befehl setzen:
```sh
chmod +x /pfad/zu/deinem/appimage
```
Oder klicke mit der rechten Maustaste auf die AppImage-Datei, gehe zu `Eigenschaften` > `Berechtigungen` und aktiviere das Kontrollkästchen `Datei als Programm ausführen erlauben.`
:::

:::note[Bevor du AppImages ausführst, stelle sicher, dass FUSE (Filesystem in Userspace) auf deinem System installiert ist.]
```sh
sudo pacman -S fuse2
```
:::

Um AppImages zu verwalten, kannst du [gearlever](https://github.com/mijorus/gearlever) verwenden, der eine einfache Möglichkeit bietet, AppImages in dein System zu integrieren.

`gearlever` ist ein grafisches Werkzeug, das die Verwaltung von AppImages auf deinem System vereinfacht. Es integriert sich in deine Desktop-Umgebung und macht es einfach, AppImages auszuführen und zu verwalten.

Um gearlever zu installieren, befolge diese Schritte:

<Steps>
    1. Installiere flatpak, falls du es noch nicht getan hast:
        ```sh
        sudo pacman -S flatpak
        ```
    2. Starte dein System neu.
    3. Installiere gearlever mit flatpak:
        ```sh
        flatpak install flathub it.mijorus.gearlever
        ```
    4. Nach der Installation. Logge dich aus und wieder ein, um gearlever in deinem Anwendungsmenü zu sehen.
</Steps>

## Zugriff auf Samba-Freigaben konfigurieren

Samba ist eine freie Software-Neuimplementierung des SMB-Netzwerkprotokolls. Um eine Verbindung zu deinem Samba-Server herzustellen, wurde den CachyOS-Benutzern eine nützliche Konfiguration zur Verfügung gestellt, die jedoch eine Änderung der Konfiguration deines Samba-Servers erfordert.

### Installieren und Verwenden der CachyOS smb.conf-Datei

Um die praktische smb.conf-Datei zu verwenden, installiere zuerst ein spezifisches Paket, das die erforderliche smb.conf-Datei bereitstellt. Ersetze dann die vorhandene smb.conf deines Servers durch diese Datei und konfiguriere deine freigegebenen Volumes neu.

:::note[Diese Anleitung geht davon aus, dass du bereits einen funktionierenden Samba-Server hast]
:::

<Steps>
    1. Erstelle eine Sicherungskopie deiner ursprünglichen `smb.conf`-Datei, die sich typischerweise unter `/etc/samba/smb.conf` auf Linux-Systemen befindet.
    2. Installiere das CachyOS-Samba-Einstellungspaket auf deiner Client-Maschine:
        ```sh
        sudo pacman -S cachyos-samba-settings
        ```
    3. Kopiere die `smb.conf` von deiner Client-Maschine auf den Samba-Server.
    4. Öffne und bearbeite die Datei, um deine freigegebenen Verzeichnisse, Drucker usw. hinzuzufügen.
    5. Starte den Samba-Dienst auf deinem Server neu:
        ```sh
        sudo systemctl restart --now samba
        ```
    6. Greife auf der Client-Maschine über deinen Dateimanager auf deine freigegebenen Ressourcen zu (z.B., `smb://<deine_server_ip>/<freigabename>`).

        Wenn alles richtig konfiguriert ist, wirst du nach Anmeldeinformationen gefragt. Denke daran, die Option zum Speichern deiner Anmeldeinformationen auszuwählen, wenn du das möchtest.
</Steps>

### Ünterstützung von AppArmor durch AppArmor.d-Profile

Zitat von Wikipedia:

*AppArmor ("Application Armor") ist ein Linux-Kernel-Sicherheitsmodul, das dem Systemadministrator erlaubt, die Fähigkeiten von Programmen mit per-Programm-Profilen einzuschränken. Profile können Fähigkeiten wie Netzwerkzugriff, Raw-Socket-Zugriff und die Berechtigung zum Lesen, Schreiben oder Ausführen von Dateien auf passenden Pfaden erlauben.*

Dies ist nur eine Einführung, wie man ein grundlegendes AppArmor-Setup installiert, falls du mit AppArmor nicht vertraut bist. Fahre bitte nicht fort, ohne die Implikationen zu verstehen.

Für detailliertere Informationen über AppArmor.d und wie man eigene Profile erstellt, schau dir die [AppArmor.d-Dokumentation](https://github.com/roddhjav/apparmor.d?tab=readme-ov-file#configuration) an.

:::caution[Sei vorsichtig. Ein schlecht konfiguriertes AppArmor-Setup kann Probleme verursachen.]
:::

<Steps>

1. Füge die folgenden Kernel-Parameter zu deinem Boot-Manager hinzu, siehe [Boot Manager Configuration](/de/configuration/boot_manager_configuration) als Referenz

   ```text
   lsm=landlock,lockdown,yama,integrity,apparmor,bpf
   ```

2. Installiere die Pakete apparmor und apparmord **(Set mit über +1500 Profilen)**
   ```bash
   sudo pacman -S apparmor apparmor.d
   ```

3. Aktiviere/Starte den AppArmor-Dienst

   ```bash
   systemctl enable --now apparmor.service
   ```

4. Aktiviere das Caching für AppArmor-Profile

   ```shell
   # /etc/apparmor/parser.conf
   ## Füge die folgenden Zeilen hinzu:
   write-cache
   Optimize=compress-fast
   cache-loc /etc/apparmor/earlypolicy/
   ```
   Speichere die Datei und starte dein System neu.
</Steps>