Software installieren, Updates einspielen, Dateien zuordnen und Paketfehler untersuchen: Diese Aufgaben gehören zum Alltag der Linux-Administration. Unter Fedora, Red Hat Enterprise Linux und verwandten Systemen arbeiten dafür mehrere Werkzeuge zusammen.
**RPM** bildet die grundlegende Paketebene. **DNF** ergänzt die Verwaltung über Paketquellen und löst Abhängigkeiten auf. Der Name YUM begegnet weiterhin in älteren Anleitungen und als Kompatibilitätsbefehl. Für eine sichere Bedienung ist deshalb wichtig, sowohl die Zuständigkeiten als auch die Unterschiede zwischen den Systemgenerationen zu kennen.
rpm, DNF und YUM: Wer übernimmt welche Aufgabe?
-----------------------------------------------
### rpm: Paketformat und lokale Paketverwaltung
RPM steht für „RPM Package Manager“. Der Name bezeichnet sowohl das Paketformat mit der Dateiendung `.rpm` als auch das zugehörige Paketverwaltungssystem.
Das Kommando `rpm` arbeitet vor allem mit der lokalen Paketdatenbank und einzelnen Paketdateien. Damit lässt sich beispielsweise feststellen:
- Ist ein Paket installiert?
- Welche Version ist vorhanden?
- Welche Dateien gehören zum Paket?
- Zu welchem Paket gehört eine bestimmte Datei?
- Weichen installierte Dateien von den gespeicherten Paketinformationen ab?
`rpm` prüft auch Abhängigkeiten, beschafft fehlende Pakete aber nicht selbst aus eingerichteten Repositories. Für normale Installationen ist deshalb meist DNF das passende Werkzeug.
### DNF: Paketquellen und Abhängigkeiten verwalten
DNF kennt die eingerichteten Paketquellen und deren verfügbare Software. Bei einer Installation berechnet es, welche zusätzlichen Pakete benötigt werden und welche Änderungen zusammengehören.
Eine solche zusammengehörige Aktion wird als Transaktion bezeichnet. Sie kann beispielsweise ein angefordertes Programm und mehrere benötigte Bibliotheken umfassen. DNF organisiert den Vorgang; die grundlegende Paketverwaltung erfolgt über RPM.
### YUM: Ältere Paketverwaltung und Kompatibilitätsname
YUM war der übergeordnete Paketmanager älterer RHEL-Generationen. DNF ist sein Nachfolger.
Die Bedeutung des Befehls `yum` hängt vom System ab: In RHEL 7 steht dahinter die ältere YUM-Implementierung. In RHEL 9 ist `yum` ein Kompatibilitätsname für DNF. Dort sind `yum install nginx` und `dnf install nginx` keine zwei unabhängig arbeitenden Paketverwaltungen.
Vor dem Start: DNF-Version und Systemtyp prüfen
-----------------------------------------------
Nicht überall steckt dieselbe DNF-Version hinter dem Befehl `dnf`. Fedora verwendet seit Fedora 41 standardmäßig DNF5. Viele bestehende Enterprise-Linux-Installationen und Anleitungen arbeiten dagegen mit DNF4. Häufige Befehle sind ähnlich, einige Unterbefehle und Erweiterungen unterscheiden sich jedoch.
Die verwendete Version zeigt:
```
dnf --version
```
Die Hilfe zu einer bestimmten Aktion erhältst du beispielsweise mit:
```
dnf install --help
```
Die folgenden Beispiele verwenden für gemeinsame Aufgaben den Namen `dnf`. Wo sich DNF4 und DNF5 unterscheiden, wird dies ausdrücklich angegeben.
> Die Befehle beziehen sich auf klassische, paketbasiert verwaltete Systeme. Auf [Fedora Atomic Desktops](https://fedoraproject.org/atomic-desktops/), [Fedora CoreOS](https://fedoraproject.org/coreos/) und anderen image-basierten Varianten wird das Basissystem anders verwaltet.
Lesende Abfragen benötigen normalerweise keine Root-Rechte. Änderungen am System sind in den Beispielen mit `sudo` gekennzeichnet. Die Befehle sind nach Aufgaben gegliedert und sollen nicht vollständig nacheinander ausgeführt werden.
Paketinformationen laden und Software suchen
--------------------------------------------
### Informationen aus den Paketquellen aktualisieren
DNF aktualisiert benötigte Repository-Metadaten bei vielen Aktionen selbst, wenn die vorhandenen Informationen abgelaufen sind. Ein gesonderter Schritt vor jeder Installation ist deshalb normalerweise nicht erforderlich.
Gezielt Metadaten herunterladen und zwischenspeichern:
```
sudo dnf makecache
```
Eine erneute Prüfung der Informationen erzwingen:
```
sudo dnf --refresh makecache
```
Dabei werden Informationen über verfügbare Pakete aktualisiert, aber noch keine installierten Programme ersetzt.
### Pakete suchen
```
dnf search nginx
```
Die Suche berücksichtigt standardmäßig Paketnamen und Kurzbeschreibungen. Sie eignet sich, wenn du einen Namen oder ein Stichwort kennst, aber noch nicht das genaue Paket.
### Paketdetails anzeigen
```
dnf info nginx
```
Die Ausgabe enthält unter anderem Name, Version, Architektur und Beschreibung. DNF kann dabei sowohl installierte als auch in Paketquellen verfügbare Pakete anzeigen.
### Installierte und verfügbare Pakete auflisten
Installierte Pakete:
```
dnf list --installed
```
Informationen zu einem bestimmten Paket:
```
dnf list nginx
```
Bekannte Versionen eines Pakets anzeigen:
```
dnf list --showduplicates nginx
```
Welche Versionen tatsächlich angeboten werden, hängt von den aktivierten Quellen und den geltenden Auswahlregeln ab.
Den lokalen Paketbestand mit rpm untersuchen
--------------------------------------------
### Ist ein Paket installiert?
```
rpm -q nginx
```
Ist es installiert, erscheint seine Paketkennung. Andernfalls meldet RPM, dass das Paket nicht installiert ist.
Alle installierten Pakete anzeigen:
```
rpm -qa
```
Ausführliche Informationen zu einem installierten Paket:
```
rpm -qi nginx
```
Diese Abfragen verwenden die lokale RPM-Datenbank. Ein Zugriff auf Paketquellen ist dafür nicht erforderlich.
### Die wichtigsten Abfrageoptionen verstehen
| Option | Bedeutung im Abfragemodus |
|---|---|
| `-q` | Paketinformationen abfragen |
| `-a` | Alle installierten Pakete auswählen |
| `-i` | Ausführliche Informationen anzeigen |
| `-l` | Paketdateien auflisten |
| `-f` | Paket zu einer vorhandenen Datei suchen |
| `-p` | Eine RPM-Datei statt eines installierten Pakets untersuchen |
| `-c` | Konfigurationsdateien anzeigen |
| `-R` | Anforderungen beziehungsweise Abhängigkeiten anzeigen |
Die Optionen lassen sich kombinieren. `rpm -qi nginx` bedeutet damit: das installierte Paket `nginx` abfragen und seine ausführlichen Informationen anzeigen.
Wichtig: Die Bedeutung einer Option hängt vom Modus ab. `rpm -i paket.rpm` installiert ein Paket; `rpm -qi paketname` zeigt Informationen an.
### Eine übersichtliche Paketliste erzeugen
Für Inventarisierung und Skripte lässt sich das Ausgabeformat festlegen:
```
rpm -qa --queryformat '%{NAME}t%{VERSION}-%{RELEASE}t%{ARCH}n'
```
Das erzeugt pro Paket eine Zeile mit Name, Version samt Release und Architektur. Die einfachen Anführungszeichen sorgen dafür, dass die Shell den Formattext unverändert weitergibt.
Pakete installieren und erneut installieren
-------------------------------------------
### Ein oder mehrere Pakete installieren
```
sudo dnf install nginx
```
Mehrere Pakete gemeinsam installieren:
```
sudo dnf install nginx curl
```
DNF ermittelt benötigte Abhängigkeiten und zeigt vor der Ausführung eine Zusammenfassung. Diese sollte vor der Bestätigung gelesen werden: Welche Pakete kommen hinzu, welche werden aktualisiert und welche gegebenenfalls ersetzt?
### Schwache Abhängigkeiten weglassen
Neben zwingenden Anforderungen gibt es schwache Abhängigkeiten. Sie können zusätzliche Funktionen oder eine vollständigere Ausstattung bereitstellen, sind aber nicht in gleicher Weise verpflichtend.
Für eine einzelne Installation lassen sie sich ausschließen:
```
sudo dnf install nginx --setopt=install_weak_deps=False
```
Das kann auf bewusst schlank gehaltenen Systemen sinnvoll sein. Es verändert aber die vorgesehene Standardausstattung und sollte deshalb gezielt eingesetzt werden.
### Ein Paket erneut installieren
```
sudo dnf reinstall nginx
```
Damit kann beispielsweise eine beschädigte, vom Paket gelieferte Programmdatei wiederhergestellt werden. Die passende Paketversion muss dafür verfügbar sein.
Eine Neuinstallation setzt nicht automatisch alle Einstellungen zurück. Der Umgang mit Konfigurationsdateien richtet sich nach den Regeln des Pakets und dem vorhandenen Dateizustand.
Den Änderungsplan prüfen, ohne ihn auszuführen
----------------------------------------------
Mit `--assumeno` beantwortet DNF Rückfragen automatisch mit Nein:
```
sudo dnf --assumeno install nginx
```
Ebenso für eine Entfernung oder Aktualisierung:
```
sudo dnf --assumeno remove nginx
sudo dnf --assumeno upgrade
```
So lässt sich der berechnete Transaktionsplan ansehen, ohne die vorgeschlagene Paketänderung zu bestätigen. DNF kann dabei trotzdem Repository-Metadaten herunterladen oder seinen Cache aktualisieren. Es handelt sich nicht um eine vollständig nebenwirkungsfreie Simulation aller Installationsschritte.
Für produktive Systeme ist besonders wichtig, vorgeschlagene Entfernungen und zusätzliche Abhängigkeiten zu prüfen, bevor die Aktion tatsächlich freigegeben wird.
Aktualisierungen prüfen und installieren
----------------------------------------
### Verfügbare Updates anzeigen
```
dnf check-update
```
Der Befehl prüft auf verfügbare Aktualisierungen, installiert sie aber nicht. Bei DNF5 heißt der dokumentierte Befehl auch `check-upgrade`; `check-update` wird als kompatibler Name verwendet.
Bei Skripten ist eine Besonderheit wichtig: Der Rückgabewert `100` bedeutet, dass Updates verfügbar sind. Er ist bei diesem Befehl kein gewöhnlicher Fehler.
### Das System aktualisieren
```
sudo dnf upgrade
```
Mit ausdrücklich erneuerter Metadatenprüfung:
```
sudo dnf --refresh upgrade
```
DNF aktualisiert die berücksichtigten Pakete und löst die zugehörigen Abhängigkeiten auf. `dnf update` ist ein gebräuchlicher Alias für `dnf upgrade` – anders als bei APT bedeutet `update` hier also nicht nur das Aktualisieren von Paketlisten.
### Ein bestimmtes Paket aktualisieren
```
sudo dnf upgrade nginx
```
Auch dabei können Änderungen an benötigten Abhängigkeiten erforderlich sein. „Ein Paket aktualisieren“ bedeutet deshalb nicht zwangsläufig, dass nur ein einziges Paket verändert wird.
### Nur sicherheitsbezogene Aktualisierungen auswählen
```
sudo dnf upgrade --security
```
Die Auswahl stützt sich auf die Sicherheitsinformationen der Paketquellen. Sie funktioniert deshalb nur so vollständig, wie die eingerichteten Quellen entsprechende Hinweise bereitstellen. Erforderliche Abhängigkeiten werden weiterhin berücksichtigt.
Pakete entfernen und ungenutzte Abhängigkeiten aufräumen
--------------------------------------------------------
### Ein Paket entfernen
```
sudo dnf remove nginx
```
DNF kann dabei auch Pakete zur Entfernung vorschlagen, die von `nginx` abhängen. Je nach Konfiguration werden außerdem nicht mehr benötigte Abhängigkeiten aufgeräumt.
Deshalb reicht es nicht, nur den angeforderten Paketnamen zu prüfen. Maßgeblich ist die gesamte Entfernungsliste.
### Nicht mehr benötigte Abhängigkeiten entfernen
Zunächst den Plan ansehen:
```
sudo dnf --assumeno autoremove
```
Anschließend gegebenenfalls ausführen:
```
sudo dnf autoremove
```
Berücksichtigt werden Pakete, die als Abhängigkeiten installiert wurden und nicht mehr benötigt werden. Ein inzwischen selbst verwendetes Programm sollte vorher als ausdrücklich gewünscht markiert werden.
### Warum gibt es kein direktes purge?
Ein direktes Gegenstück zu `apt purge` gibt es nicht. RPM behandelt Konfigurationsdateien anders als die Debian-Paketverwaltung. Je nach Paket und Dateizustand können bei Aktualisierung oder Entfernung Dateien wie `.rpmnew` und `.rpmsave` entstehen.
Die Entfernung eines Pakets darf deshalb nicht mit dem vollständigen Löschen sämtlicher Anwendungsdaten gleichgesetzt werden.
Installationsgründe und Versionssperren verwalten
-------------------------------------------------
### Warum Installationsgründe wichtig sind
DNF merkt sich, ob ein Paket ausdrücklich angefordert oder nur als Abhängigkeit installiert wurde. Diese Information beeinflusst, was beim Aufräumen als nicht mehr benötigt gilt.
Angenommen, `curl` wurde ursprünglich nur mitinstalliert, wird inzwischen aber für eigene Administrationsaufgaben gebraucht. Dann sollte es als ausdrücklich gewünscht markiert werden.
DNF4:
```
sudo dnf mark install curl
```
DNF5:
```
sudo dnf mark user curl
```
Diese Befehle ändern den Installationsgrund, installieren das Paket aber nicht neu.
Die Gegenrichtung lautet:
DNF4:
```
sudo dnf mark remove curl
```
DNF5:
```
sudo dnf mark dependency curl
```
Auch dadurch wird das Paket nicht sofort entfernt. Es kann aber später beim Aufräumen berücksichtigt werden, wenn es nicht mehr benötigt wird.
### Pakete zeitweise von Updates ausnehmen
Für eine einzelne Aktualisierung:
```
sudo dnf upgrade --exclude=nginx
```
Das überspringt das angegebene Paket nur für diese Aktion.
Für längerfristige Versionssperren dient `versionlock`:
```
sudo dnf versionlock add nginx
```
Sperren anzeigen und entfernen:
```
dnf versionlock list
sudo dnf versionlock delete nginx
```
Die Funktion kann je nach DNF-Version und Installation eine zusätzliche Erweiterung benötigen. Bei DNF4 lässt sich die Bereitstellung beispielsweise über folgende Anforderung installieren:
```
sudo dnf install 'dnf-command(versionlock)'
```
Die Funktion selbst sowie ihre Verfügbarkeit sind versionsabhängig zu prüfen.
Eine Versionssperre ist kein Sicherheitsgewinn: Sie kann auch Sicherheitsupdates verhindern. Man sollte einen dokumentierten Grund und einen vorgesehenen Überprüfungstermin haben.
Dateien ihren Paketen zuordnen
------------------------------
### Welche Dateien gehören zu einem installierten Paket?
```
rpm -ql openssh-clients
```
Nur seine Konfigurationsdateien anzeigen:
```
rpm -qc openssh-clients
```
Die Ausgabe beschreibt die im Paket verzeichneten Dateien. Später vom Programm erzeugte Daten sind damit nicht automatisch vollständig erfasst.
### Zu welchem installierten Paket gehört diese Datei?
```
rpm -qf /usr/bin/ssh
```
Das ist beispielsweise hilfreich, wenn eine auffällige Programmdatei einem Paket zugeordnet werden soll. Bei selbst installierter, nicht durch RPM verwalteter Software gibt es möglicherweise keinen passenden Eintrag.
### Welches verfügbare Paket enthält eine gesuchte Datei?
```
dnf provides /usr/bin/ssh
```
Wenn der genaue Pfad unbekannt ist:
```
dnf provides '*/ssh'
```
Die Anführungszeichen verhindern, dass die Shell den Stern bereits vor dem Aufruf auswertet. DNF sucht damit nach passenden Dateipfaden in den verfügbaren Paketinformationen.
Für diese Suche muss das gesuchte Paket nicht installiert sein. Sie ist damit das Gegenstück zur rein lokalen Zuordnung mit `rpm -qf`.
Abhängigkeiten und bereitgestellte Funktionen untersuchen
---------------------------------------------------------
### Was benötigt ein installiertes Paket?
```
rpm -qR nginx
```
Die Ausgabe enthält Anforderungen. Das sind nicht immer einfache Paketnamen: Auch Bibliotheksnamen, Dateipfade oder andere bereitgestellte Fähigkeiten können auftauchen.
### Was stellt ein Paket bereit?
```
rpm -q --provides openssh-clients
```
Ausgabe:
```
config(openssh-clients) = 10.5p1-1.fc45
openssh-clients = 10.5p1-1.fc45
openssh-clients(x86-64) = 10.5p1-1.fc45
```
Der Befehl zeigt, unter welchen Kennungen das installierte Paket bei der Paketverwaltung bekannt ist. Im Beispiel sind das der Paketname (`openssh-clients`), eine zusätzliche Kennung für die Rechnerarchitektur (`openssh-clients(x86-64)`) und eine Kennung für die zugehörige Konfiguration (`config(openssh-clients)`). Diese Angaben helfen der Paketverwaltung zu erkennen, ob benötigte Pakete vorhanden sind.
> **Ein konkreter Anlass könnte sein**: Eine Installation scheitert mit einer Meldung über eine fehlende Abhängigkeit, obwohl du glaubst, das benötigte Paket bereits installiert zu haben. Dann kannst du prüfen, ob das vorhandene Paket tatsächlich unter der geforderten Kennung registriert ist.
Gemeint ist hier also keine Liste der enthaltenen Dateien – diese zeigt `rpm -ql openssh-clients`.
### Welche zusätzlichen Pakete benötigt ein Programm?
```
dnf repoquery --requires --resolve nginx
```
Ein Programm benötigt oft weitere Pakete, zum Beispiel Bibliotheken. Der Befehl zeigt, welche Pakete die benötigten Bestandteile für `nginx` bereitstellen können. Dabei wird nichts installiert.
Die Ausgabe ist keine Liste der Pakete, die noch installiert werden müssen: Einige davon können bereits vorhanden sein. Welche Änderungen tatsächlich nötig sind, zeigt DNF vor der Installation mit `sudo dnf install nginx` an.
### Den lokalen Paketbestand auf Probleme prüfen
```
dnf check
```
Der Befehl untersucht die lokale Paketdatenbank auf Probleme, beispielsweise bei Abhängigkeiten. Er ist zunächst eine Diagnose und keine pauschale automatische Reparatur.Die Abfrage untersucht Anforderungen und zeigt passende Pakete an, die diese erfüllen können. Für die konkrete Auswirkung einer Installation oder Entfernung ist trotzdem der berechnete Transaktionsplan maßgeblich.
Lokale RPM-Dateien untersuchen und installieren
-----------------------------------------------
### Informationen vor der Installation anzeigen
```
rpm -qpi ./paket.rpm
```
Enthaltene Dateien auflisten:
```
rpm -qpl ./paket.rpm
```
Anforderungen anzeigen:
```
rpm -qpR ./paket.rpm
```
Paketskripte ansehen:
```
rpm -qp --scripts ./paket.rpm
```
Das zusätzliche `-p` bedeutet: Untersuche diese Paketdatei statt eines bereits installierten Pakets. Die Abfragen installieren das Paket nicht.
### Eine lokale RPM-Datei mit DNF installieren
```
sudo dnf install ./paket.rpm
```
DNF berücksichtigt dabei die Abhängigkeiten und kann benötigte Pakete aus den eingerichteten Quellen beziehen. Für normale lokale Installationen ist das meist die geeignetere Wahl.
### Direkt mit rpm installieren oder aktualisieren
```
sudo rpm -ivh ./paket.rpm
```
Installiert das Paket. Die zusätzlichen Optionen zeigen ausführlichere Informationen und einen Fortschritt an.
```
sudo rpm -Uvh ./paket.rpm
```
Aktualisiert ein vorhandenes Paket oder installiert es, wenn es noch nicht vorhanden ist.
```
sudo rpm -Fvh ./paket.rpm
```
Aktualisiert nur, wenn bereits eine ältere Version installiert ist.
Diese Befehle laden fehlende Abhängigkeiten nicht selbst aus Repositories nach. Fehler sollten deshalb nicht unüberlegt mit `--nodeps` oder `--force` umgangen werden.
> Pakete können bei Installation und Entfernung Skripte mit administrativen Rechten ausführen. Eine bekannte Dateiendung oder ein plausibler Paketname macht eine fremde RPM-Datei daher nicht vertrauenswürdig.
Installierte Dateien überprüfen
-------------------------------
### Ein Paket prüfen
```
rpm -V openssh-clients
```
Alle installierten Pakete prüfen:
```
sudo rpm -Va
```
RPM vergleicht unter anderem Dateigröße, Inhaltsprüfsumme, Rechte, Eigentümer, Gruppe und Änderungszeit mit den gespeicherten Informationen. Werden keine Abweichungen festgestellt, bleibt die Ausgabe normalerweise leer.
Wichtige Kennzeichnungen:
| Zeichen | Festgestellte Abweichung |
|---|---|
| `S` | Dateigröße |
| `M` | Dateityp oder Berechtigungen |
| `5` | Inhaltsprüfsumme |
| `L` | Ziel eines symbolischen Links |
| `U` | Eigentümer |
| `G` | Gruppe |
| `T` | Änderungszeit |
| `P` | Dateibezogene Capabilities |
Ein zusätzliches `c` kennzeichnet eine Konfigurationsdatei.
Beispiel:
```
S.5....T. c /etc/beispiel.conf
```
Das weist auf Änderungen an Größe, Inhalt und Änderungszeit einer Konfigurationsdatei hin. Es kann sich um eine beabsichtigte Anpassung handeln.
Die Kennzeichnung `5` ist historisch und bedeutet nicht, dass moderne RPM-Pakete zwangsläufig MD5 verwenden. Die Dokumentation beschreibt sie allgemein als abweichende Inhaltsprüfsumme.
> `rpm -V` ist ein Diagnosewerkzeug, kein vollständiger Nachweis eines unverfälschten Systems. Es vertraut unter anderem den lokal gespeicherten Vergleichsinformationen.
Paketquellen und Signaturschlüssel verwalten
--------------------------------------------
### Eingerichtete Paketquellen anzeigen
Ein häufig verwendeter, kompatibler Aufruf ist:
```
dnf repolist
```
Bei DNF5 steht dafür auch die strukturierte Form bereit:
```
dnf repo list
```
Damit lässt sich prüfen, welche Paketquellen berücksichtigt werden. Die Repository-Konfiguration liegt üblicherweise in `.repo`-Dateien unter:
```
/etc/yum.repos.d/
```
Der historische Verzeichnisname wird auch mit DNF weiterverwendet.
### Quellen aktivieren oder deaktivieren
Die Syntax des zusätzlichen Werkzeugs `config-manager` unterscheidet sich:
| Aufgabe | DNF4 | DNF5 |
|---|---|---|
| Quelle dauerhaft aktivieren | `sudo dnf config-manager --set-enabled REPO-ID` | `sudo dnf config-manager setopt REPO-ID.enabled=1` |
| Quelle dauerhaft deaktivieren | `sudo dnf config-manager --set-disabled REPO-ID` | `sudo dnf config-manager setopt REPO-ID.enabled=0` |
`REPO-ID` muss durch die tatsächliche Kennung ersetzt werden. Der Unterbefehl kann je nach Installation eine zusätzliche Erweiterung benötigen.
### Warum Signaturschlüssel nötig sind
Signaturschlüssel helfen zu prüfen, ob ein Paket von dem erwarteten Herausgeber signiert wurde und seitdem verändert wurde. Entscheidend ist aber, dass der verwendete Schlüssel tatsächlich zum vertrauenswürdigen Herausgeber gehört.
Eine lokale Paketdatei lässt sich prüfen mit:
```
rpm -K ./paket.rpm
```
> Die Ausgabe muss gelesen werden: Eine Meldung über einen fehlenden Schlüssel ist nicht dasselbe wie eine erfolgreich überprüfte Signatur. Schlüssel sollten nur nach Prüfung ihrer Herkunft und ihres Fingerabdrucks importiert werden.
Das Abschalten der Prüfung mit `--nogpgcheck` ist keine sinnvolle Standardlösung für Signaturprobleme.
Cache bereinigen und Pakete herunterladen
-----------------------------------------
### Zwischengespeicherte Pakete löschen
```
sudo dnf clean packages
```
Entfernt heruntergeladene Paketdateien aus dem DNF-Cache, deinstalliert aber keine Programme.
```
sudo dnf clean metadata
```
Entfernt Repository-Metadaten. Bei Bedarf müssen sie erneut geladen werden.
```
sudo dnf clean all
```
Bereinigt die verschiedenen Cache-Bereiche. Das sollte nicht routinemäßig vor jedem DNF-Aufruf geschehen, weil dadurch erneute Downloads nötig werden können.
### Pakete ohne Installation herunterladen
```
dnf download nginx
```
Der Befehl speichert die RPM-Datei standardmäßig im aktuellen Verzeichnis. Bei DNF4 kann dafür eine Erweiterung erforderlich sein; DNF5 bietet einen eigenen Download-Befehl.
Bei DNF5 lassen sich ein Zielverzeichnis und fehlende Abhängigkeiten ausdrücklich angeben:
```
dnf download --resolve --destdir ./pakete nginx
```
Auch bereits installierte Abhängigkeiten mit herunterladen:
```
dnf download --resolve --alldeps --destdir ./pakete nginx
```
Das Herunterladen ersetzt keine spätere Prüfung, ob der Paketsatz auf einem anderen Zielsystem tatsächlich vollständig und passend ist.
Änderungen über die Transaktionshistorie nachvollziehen
-------------------------------------------------------
### Vergangene Aktionen anzeigen
```
dnf history list
```
Details zu einer bestimmten Transaktion:
```
dnf history info 12
```
Die Zahl ist die Kennung aus der Übersicht. So lässt sich nachvollziehen, welche Pakete bei einem Vorgang installiert, aktualisiert oder entfernt wurden.
### Eine Transaktion rückgängig machen
```
sudo dnf history undo 12
```
DNF versucht, die Paketaktionen dieser Transaktion umzukehren. Ein zuvor installiertes Paket wird beispielsweise entfernt; bei einer Aktualisierung kann die vorherige Paketversion benötigt werden.
Das ist kein vollständiger System-Rollback. Benutzerdaten, Datenbankmigrationen und sämtliche Auswirkungen ausgeführter Paketskripte werden dadurch nicht automatisch zurückgesetzt. Zudem müssen benötigte ältere Pakete noch verfügbar sein.
### Paketstände mit den Quellen abgleichen
```
sudo dnf --assumeno distro-sync
```
Nach sorgfältiger Prüfung gegebenenfalls:
```
sudo dnf distro-sync
```
Den Befehl nutzt du beispielsweise, wenn du eine Test-Paketquelle deaktiviert hast und zu den Paketversionen aus den regulären Quellen zurückkehren möchtest. Dabei kann DNF Pakete sowohl aktualisieren als auch auf ältere Versionen zurücksetzen, weshalb du die vorgeschlagenen Änderungen zuerst mit `--assumeno` prüfen solltest.
Die wichtigsten Befehle im Überblick
------------------------------------
| Aufgabe | Befehl |
|---|---|
| DNF-Version prüfen | `dnf --version` |
| Metadaten erneuern | `sudo dnf --refresh makecache` |
| Pakete suchen | `dnf search suchbegriff` |
| Paketdetails anzeigen | `dnf info paketname` |
| Installierte Pakete auflisten | `dnf list --installed` |
| Lokalen Installationsstatus prüfen | `rpm -q paketname` |
| Paket installieren | `sudo dnf install paketname` |
| Lokale RPM-Datei installieren | `sudo dnf install ./paket.rpm` |
| Paket erneut installieren | `sudo dnf reinstall paketname` |
| Änderungsplan ohne Bestätigung anzeigen | `sudo dnf --assumeno install paketname` |
| Updates prüfen | `dnf check-update` |
| System aktualisieren | `sudo dnf --refresh upgrade` |
| Ein Paket aktualisieren | `sudo dnf upgrade paketname` |
| Sicherheitsupdates auswählen | `sudo dnf upgrade --security` |
| Paket entfernen | `sudo dnf remove paketname` |
| Ungenutzte Abhängigkeiten entfernen | `sudo dnf autoremove` |
| Dateien eines Pakets anzeigen | `rpm -ql paketname` |
| Konfigurationsdateien anzeigen | `rpm -qc paketname` |
| Paket zu vorhandener Datei finden | `rpm -qf /pfad/zur/datei` |
| Paket zu gesuchter Datei finden | `dnf provides '*/dateiname'` |
| Lokales RPM-Archiv untersuchen | `rpm -qpi ./paket.rpm` |
| Dateien eines RPM-Archivs anzeigen | `rpm -qpl ./paket.rpm` |
| Installierte Paketdateien überprüfen | `rpm -V paketname` |
| Lokalen Paketbestand prüfen | `dnf check` |
| Paketquellen anzeigen | `dnf repolist` |
| Transaktionen anzeigen | `dnf history list` |
| Transaktionsdetails anzeigen | `dnf history info ID` |
| Heruntergeladene Pakete bereinigen | `sudo dnf clean packages` |
Die Übersicht umfasst die häufigsten Verwaltungs- und Diagnoseaufgaben. Versionsabhängige Erweiterungen wie Markierungen, Repository-Konfiguration und Versionssperren müssen passend zu DNF4 beziehungsweise DNF5 verwendet werden.
Fazit
-----
Für die tägliche Softwareverwaltung ist DNF die zentrale Anlaufstelle: Es verbindet Paketquellen, Abhängigkeiten und zusammengehörige Änderungen. `rpm` ergänzt diese Arbeit durch direkte Abfragen, die Untersuchung einzelner Paketdateien und die Prüfung installierter Dateien.
Sichere Administration beginnt dabei vor der eigentlichen Installation. Erst werden Systemgeneration, Paketquellen und Paketstände geprüft, dann der Änderungsplan gelesen und anschließend die Transaktion freigegeben. Besonders bei Entfernungen, Versionssperren, Downgrades und Wiederherstellungsversuchen ist diese Reihenfolge wichtiger als das bloße Auswendiglernen möglichst vieler Befehle.
Fedora/RHEL-Paketverwaltung: rpm, DNF und YUM sicher einsetzen
Submitted 11 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78458