Software installieren ist nur ein Teil der Paketverwaltung. Im Sysadmin-Alltag müssen auch Paketstände geprüft, Dateien ihren Paketen zugeordnet, Abhängigkeiten untersucht und fehlgeschlagene Installationen repariert werden. Ebenso wichtig ist die Frage, welche Änderungen ein geplanter Befehl tatsächlich auslösen würde.
Unter Debian und darauf aufbauenden Distributionen arbeiten dafür mehrere Werkzeuge zusammen: **[dpkg](https://manpages.debian.org/trixie/dpkg/dpkg.1.en.html)** verwaltet die lokale Paketinstallation. **[APT](https://manpages.debian.org/trixie/apt/index.html)** ergänzt die Arbeit mit Paketquellen, verfügbaren Versionen und Abhängigkeiten. Die Werkzeuge ersetzen sich nicht gegenseitig, sondern betrachten unterschiedliche Ebenen derselben Paketverwaltung.
Die Werkzeuge und ihre Zuständigkeiten
--------------------------------------
| Werkzeug | Hauptaufgabe |
|---|---|
| `dpkg` | Pakete lokal installieren, konfigurieren, entfernen und prüfen |
| `dpkg-query` | Die lokale Paketdatenbank abfragen |
| `dpkg-deb` | Lokale `.deb`-Archive untersuchen und entpacken |
| `apt` | Benutzerorientierte Oberfläche für häufige Verwaltungsaufgaben |
| `apt-get` | Paketaktionen mit einer für Automatisierung geeigneteren Schnittstelle |
| `apt-cache` | Bekannte Paketinformationen, Versionen und Abhängigkeiten abfragen |
| `apt-file` | Dateien in den erfassten Paketen der Paketquellen suchen |
| `apt-mark` | Automatische beziehungsweise manuelle Installation und Holds verwalten |
`dpkg` reicht einige Abfrage- und Archivoptionen intern an `dpkg-query` beziehungsweise `dpkg-deb` weiter. Deshalb funktionieren beispielsweise sowohl `dpkg -L` als auch `dpkg-query -L`.
### apt oder apt-get?
Für die interaktive Arbeit ist `apt` meist die bequemste Wahl. Es bündelt häufig benötigte Funktionen und bereitet die Ausgabe für Menschen auf.
Für Skripte sind `apt-get` und `apt-cache` vorzuziehen. Die Oberfläche von `apt` ist ausdrücklich nicht als dauerhaft stabile Skriptschnittstelle vorgesehen. Dabei sind die Standardverhaltensweisen nicht immer identisch – besonders bei `upgrade`.
### Hinweise zu den Beispielen
> Die folgenden Befehle sind nach Aufgaben gegliedert und keine Anleitung, die vollständig nacheinander ausgeführt werden soll. Namen wie `paketname`, `VERSION` und `paket.deb` sind Platzhalter.
Lesende Abfragen benötigen normalerweise keine Root-Rechte. Änderungen am System sind mit `sudo` gekennzeichnet. Installation und Aktualisierung können außerdem Paketskripte ausführen und Dienste beeinflussen; sie gehören auf produktiven Systemen in einen geplanten Wartungsablauf.
Paketinformationen aktualisieren und Software finden
----------------------------------------------------
### Paketlisten aktualisieren
```
sudo apt update
```
APT lädt die aktuellen Paketinformationen der eingerichteten Quellen herunter. Dadurch erfährt es, welche Pakete und Versionen verfügbar sind. Bereits installierte Programme werden dabei noch nicht aktualisiert.
Das entsprechende Kommando für `apt-get` lautet:
```
sudo apt-get update
```
Die Aktualisierung der Paketlisten sollte vor einer geplanten Paketaktualisierung erfolgen. Fehler und Warnungen müssen dabei geprüft werden: Eine teilweise fehlgeschlagene Aktualisierung kann dazu führen, dass für einzelne Quellen weiterhin ältere Informationen verwendet werden.
### Nach Paketen suchen
```
apt search nginx
```
Die Suche berücksichtigt Paketnamen und Beschreibungen. Wenn nur Paketnamen durchsucht werden sollen:
```
apt-cache search --names-only nginx
```
Beide Werkzeuge arbeiten mit den lokal vorliegenden Paketinformationen. Ohne vorheriges `update` können diese veraltet sein.
### Paketdetails anzeigen
```
apt show nginx
```
Alternativ:
```
apt-cache show nginx
```
Die Ausgabe enthält unter anderem Beschreibung, Version und Abhängigkeiten. `apt-cache show` kann bei mehreren bekannten Versionen mehrere Datensätze ausgeben. Diese Informationen beschreiben bekannte Pakete und sind kein Beweis dafür, dass das Paket installiert ist.
### Installierte Version, Kandidat und Herkunft prüfen
```
apt-cache policy nginx
```
Für die Administration ist diese Abfrage besonders nützlich. Sie zeigt:
- die installierte Version, sofern vorhanden,
- den Installationskandidaten,
- bekannte Versionen mit ihren Quellen und Prioritäten.
Der Kandidat ist die Version, die APT unter den aktuellen Auswahlregeln normalerweise installieren würde. Er muss nicht in jedem Fall die numerisch neueste bekannte Version sein.
Eine kompaktere Versionsübersicht liefert:
```
apt-cache madison nginx
```
Damit lässt sich vor einer Installation prüfen, ob die benötigte Version überhaupt in den aktuell erfassten Paketquellen vorhanden ist.
Den installierten Paketbestand untersuchen
------------------------------------------
### Installierte Pakete auflisten
```
apt list --installed
```
Für eine schnelle Übersicht eignet sich außerdem:
```
dpkg -l
```
> Hier ist eine wichtige Einschränkung zu beachten: `dpkg -l` zeigt Einträge aus der lokalen Paketdatenbank und nicht ausschließlich vollständig installierte Pakete. Auch entfernte Pakete mit verbliebenen Konfigurationsdateien können erscheinen.
### Den Zustand eines bestimmten Pakets prüfen
```
dpkg -l nginx
dpkg -s nginx
```
`dpkg -l` liefert eine kompakte Statuszeile. `dpkg -s` zeigt ausführlichere Informationen aus der lokalen Datenbank. Ein vollständig installiertes Paket besitzt typischerweise den Status:
```
Status: install ok installed
```
Bei der Kurzansicht sind diese Kennzeichnungen besonders wichtig:
| Anzeige | Bedeutung |
|---|---|
| `ii` | Gewünschter Zustand: installiert; aktueller Zustand: installiert |
| `rc` | Gewünschter Zustand: entfernt; Konfigurationsreste sind noch vorhanden |
| `iU` | Gewünschter Zustand: installiert; Paket ist entpackt, aber noch nicht konfiguriert |
| `iF` | Gewünschter Zustand: installiert; Konfiguration ist nur teilweise abgeschlossen |
Die Zeichen stehen für unterschiedliche Statusfelder. Ein Eintrag in `dpkg -l` allein bedeutet deshalb noch nicht, dass ein Paket betriebsbereit installiert ist.
### Paketinformationen gezielt ausgeben
Für Inventarisierung und Skripte ist eine definierte Ausgabe hilfreicher als eine für Menschen formatierte Tabelle:
```
dpkg-query -W -f='${binary:Package}t${Version}t${Status}n'
```
Der Befehl gibt Paketname, Version und Zustand aus. Der Zustand sollte bei der Auswertung berücksichtigt werden, weil die Datenbank auch nicht vollständig installierte beziehungsweise bereits entfernte Pakete enthalten kann. Die einfachen Anführungszeichen verhindern, dass die Shell die Feldnamen selbst interpretiert.
Software installieren und erneut installieren
---------------------------------------------
### Ein oder mehrere Pakete installieren
```
sudo apt install nginx
```
Mehrere Pakete lassen sich gemeinsam angeben:
```
sudo apt install nginx curl
```
APT ermittelt die benötigten Abhängigkeiten und schlägt einen Installationsplan vor. Vor der Bestätigung sollten insbesondere zusätzliche Installationen, Aktualisierungen und mögliche Entfernungen gelesen werden.
Das entsprechende Kommando mit `apt-get` lautet:
```
sudo apt-get install nginx curl
```
### Empfehlungen bewusst weglassen
```
sudo apt install --no-install-recommends nginx
```
Damit werden Pakete aus `Recommends` nicht automatisch wie üblich berücksichtigt. Zwingende Abhängigkeiten bleiben erforderlich.
Die Option kann für schlanke Systeme sinnvoll sein, verändert aber die vom Paket vorgesehene Standardausstattung. Sie sollte deshalb nicht unüberlegt an jeden Installationsbefehl angehängt werden.
### Ein Paket erneut installieren
```
sudo apt reinstall nginx
```
Alternativ:
```
sudo apt-get install --reinstall nginx
```
Eine Neuinstallation kann beispielsweise paketgelieferte Programmdateien wiederherstellen. Sie ist jedoch kein allgemeines Zurücksetzen auf Werkseinstellungen: Lokal angepasste Konfigurationsdateien werden nicht pauschal überschrieben.
### Eine bestimmte Version installieren
Zunächst die bekannten Versionen prüfen:
```
apt-cache policy nginx
```
Anschließend eine tatsächlich verfügbare Version auswählen:
```
sudo apt install nginx=VERSION
```
Die vollständige Versionszeichenfolge muss zur verfügbaren Version passen. Auch die Abhängigkeiten müssen auflösbar sein. Ein Downgrade ist eine gesondert zu bewertende Änderung und sollte nicht durch zusätzliche Erzwingungsoptionen unbesehen durchgesetzt werden.
Änderungen zuerst simulieren
----------------------------
Vor größeren Änderungen ist eine Simulation besonders hilfreich:
```
sudo apt-get --simulate install nginx
sudo apt-get --simulate remove nginx
sudo apt-get --simulate dist-upgrade
```
Dabei berechnet APT den geplanten Ablauf, installiert oder entfernt aber keine Pakete. In der Ausgabe stehen unter anderem:
| Kennzeichnung | Geplante Aktion |
|---|---|
| `Inst` | Paket entpacken beziehungsweise installieren oder aktualisieren |
| `Conf` | Paket konfigurieren |
| `Remv` | Paket entfernen |
Eine Simulation ist eine Planungsgrundlage, keine Erfolgsgarantie. Sie führt keine Paketskripte aus, und der Systemzustand kann sich bis zur tatsächlichen Ausführung ändern.
Pakete aktualisieren
--------------------
### Verfügbare Aktualisierungen anzeigen
```
sudo apt update
apt list --upgradable
```
Die erste Zeile aktualisiert die Informationsgrundlage. Die zweite zeigt darauf basierend Pakete mit verfügbaren Aktualisierungen.
### Regulär aktualisieren
```
`sudo apt upgrade`
```
`apt upgrade` aktualisiert installierte Pakete. Falls eine neue Version zusätzliche Pakete als Abhängigkeiten benötigt, dürfen diese mitinstalliert werden. Bereits installierte Pakete werden nicht entfernt. Würde eine Aktualisierung eine Entfernung erfordern, wird sie zurückgehalten.
```
`sudo apt-get upgrade`
```
`apt-get upgrade` ist standardmäßig zurückhaltender: Es aktualisiert vorhandene Pakete, installiert aber keine zusätzlichen Pakete und entfernt auch keine. Benötigt eine neue Version eine bisher nicht installierte Abhängigkeit, wird das betreffende Paket deshalb vorerst nicht aktualisiert.
```
`sudo apt-get --with-new-pkgs upgrade`
```
Mit `--with-new-pkgs` darf auch `apt-get upgrade` zusätzliche benötigte Pakete installieren. In diesem Punkt verhält es sich damit wie `apt upgrade`. Paketentfernungen bleiben ausgeschlossen.
### Aktualisierungen mit möglichen Paketentfernungen
```
sudo apt full-upgrade
```
Das entsprechende klassische Kommando lautet:
```
sudo apt-get dist-upgrade
```
Diese Aktionen dürfen bei der Auflösung veränderter Abhängigkeiten auch installierte Pakete entfernen. Deshalb ist der vorgeschlagene Plan sorgfältig zu prüfen.
> Der Name `dist-upgrade` bedeutet nicht, dass allein dieser Befehl automatisch zur nächsten Debian- oder Ubuntu-Version wechselt. Die Aktion arbeitet zunächst mit den eingerichteten Quellen; ein Distributionsupgrade benötigt einen dazu passenden, distributionsspezifischen Ablauf.
### Nur ein bestimmtes Paket aktualisieren
```
sudo apt-get install --only-upgrade nginx
```
Damit wird das angegebene Paket nur dann aktualisiert, wenn es bereits installiert ist. Erforderliche Änderungen an seinen Abhängigkeiten werden weiterhin berücksichtigt.
Pakete entfernen und aufräumen
------------------------------
### Entfernen und Bereinigen unterscheiden
```
sudo apt remove nginx
```
Entfernt das Paket, lässt aber insbesondere die von der Paketverwaltung erhaltenen Konfigurationsdateien zurück.
```
sudo apt purge nginx
```
Entfernt zusätzlich die betreffenden Konfigurationsreste. `purge` ist jedoch keine vollständige Datenbereinigung: Dateien im Home-Verzeichnis werden dadurch nicht automatisch gelöscht, und auch andere Anwendungsdaten sind gesondert zu betrachten.
Für bereits entfernte Pakete kann `purge` ebenfalls verwendet werden:
```
sudo apt purge paketname
```
### Nicht mehr benötigte Abhängigkeiten entfernen
```
sudo apt-get --simulate autoremove
```
Nach Prüfung der Liste:
```
sudo apt autoremove
```
APT berücksichtigt dabei Pakete, die als automatisch installiert markiert sind und nicht mehr benötigt werden. Die vorgeschlagene Liste muss geprüft werden, weil ein ehemals als Abhängigkeit installiertes Programm inzwischen bewusst genutzt werden könnte.
### Heruntergeladene Paketarchive bereinigen
```
sudo apt-get clean
```
Entfernt zwischengespeicherte Paketarchive aus dem APT-Archivcache.
```
sudo apt-get autoclean
```
Löscht aus dem lokalen Download-Cache nur solche Paketdateien, deren Version in den eingerichteten Paketquellen nicht mehr zum Download angeboten wird.
Beide Aktionen deinstallieren keine Programme. Sie betreffen heruntergeladene Dateien, nicht den installierten Paketbestand.
Paketmarkierungen und Aktualisierungssperren verwalten
------------------------------------------------------
APT merkt sich nicht nur, welche Pakete installiert sind, sondern auch, warum sie installiert wurden: Hast du ein Paket ausdrücklich angefordert, oder wurde es nur als Abhängigkeit eines anderen Pakets mitinstalliert? Diese Unterscheidung hilft beim späteren Aufräumen. Wird eine automatisch installierte Abhängigkeit nicht mehr benötigt, kann APT sie mit `autoremove` zur Entfernung vorschlagen.
Manchmal möchtest du diese Einordnung ändern. Angenommen, `curl` wurde ursprünglich als Abhängigkeit mitinstalliert, inzwischen verwendest du es aber selbst für administrative Aufgaben. Dann kannst du es als „*manuell installiert*“ markieren. Damit teilst du APT mit: „Dieses Paket brauche ich unabhängig von anderen Programmen. Behalte es beim automatischen Aufräumen.“
Davon getrennt sind sogenannte **Holds**. Damit hältst du ein bestimmtes Paket auf seinem aktuellen Stand, beispielsweise weil du eine neue Version erst auf ihre Verträglichkeit mit einer Anwendung prüfen möchtest.
`apt-mark` verwaltet damit zwei unterschiedliche Dinge:
- `manual` und `auto` bestimmen, ob ein Paket ausdrücklich benötigt wird oder als automatisch installierte Abhängigkeit gilt. Sie steuern nicht, ob es Updates erhält.
- `hold` und `unhold` sperren beziehungsweise erlauben reguläre Paketänderungen. Ein Hold kann dadurch auch Sicherheitsaktualisierungen verhindern.
Die Markierungen selbst installieren oder entfernen keine Pakete. Sie beeinflussen, wie APT bei späteren Verwaltungsaktionen mit ihnen umgeht.
### Markierungen anzeigen und ändern
```
apt-mark showmanual
apt-mark showauto
```
Ein bewusst benötigtes Paket lässt sich als manuell installiert kennzeichnen:
```
sudo apt-mark manual curl
```
Die Gegenrichtung lautet:
```
sudo apt-mark auto curl
```
Diese Änderung installiert oder entfernt das Paket zunächst nicht. Sie beeinflusst aber, ob APT es später als nicht mehr benötigte Abhängigkeit für `autoremove` berücksichtigen kann.
### Pakete vor automatischen Änderungen zurückhalten
```
sudo apt-mark hold nginx
```
Vorhandene Holds anzeigen:
```
apt-mark showhold
```
Hold wieder aufheben:
```
sudo apt-mark unhold nginx
```
Ein Hold verhindert reguläre automatische Änderungen am betreffenden Paket. Er ist keine Sicherheitsmaßnahme: Auch wichtige Sicherheitsaktualisierungen können dadurch ausbleiben. Solche Sperren sollten deshalb dokumentiert und regelmäßig überprüft werden.
Dateien ihren Paketen zuordnen
------------------------------
Für die Dateisuche sind drei unterschiedliche Perspektiven wichtig:
| Frage | Werkzeug |
|---|---|
| Welche Dateien gehören zu einem installierten Paket? | `` `dpkg -L paketname` `` |
| Zu welchem installierten Paket gehört diese Datei? | `` `dpkg -S /pfad/zur/datei` `` |
| Welches Paket enthält die gesuchte Datei – auch wenn das Paket nicht installiert ist? | `` `apt-file search dateiname` `` |
### Dateien eines installierten Pakets anzeigen
```
dpkg -L openssh-client
```
Die Ausgabe stammt aus der Paketdatenbank. Sie ist keine vollständige Auflistung aller Dateien, die ein Programm später selbst erzeugt, etwa Protokolle, Caches oder Benutzerdaten.
### Das Paket hinter einer vorhandenen Datei finden
```
dpkg -S /usr/bin/ssh
```
Das ist beispielsweise hilfreich, wenn eine Binärdatei einem Paket zugeordnet oder eine Neuinstallation vorbereitet werden soll.
Auch hier wird die Paketdatenbank abgefragt. Bei nicht paketverwalteten Dateien gibt es keinen passenden Eintrag. Unterschiede zwischen gespeicherten Pfaden und aufgelösten Symlink-Pfaden können bei der Suche ebenfalls eine Rolle spielen.
### Dateien in Paketquellen suchen
Manchmal kennst man den Namen einer benötigten Datei, weißt aber nicht, welches Paket sie enthält. Hier hilft `apt-file`: Es durchsucht die Dateilisten der eingerichteten Paketquellen. Die Pakete müssen dafür nicht installiert sein.
Installiere zunächst das Werkzeug:
```
sudo apt install apt-file
```
Lade anschließend die aktuellen Paketinformationen einschließlich der verfügbaren Dateilisten:
```
sudo apt update
```
Nun kannst du beispielsweise nach dem Programmpfad `usr/bin/ssh` suchen. Der führende `/` fehlt, weil `apt-file` in Paketdateilisten sucht, in denen die Pfade ohne diesen Schrägstrich gespeichert sind.
```
apt-file search usr/bin/ssh
```
Die Ausgabe nennt passende Pakete und die darin gefundenen Dateipfade. So lässt sich erkennen, welches Paket die gesuchte Datei bereitstellt. Da nach dem angegebenen Text gesucht wird, können auch längere Dateinamen wie `usr/bin/ssh-add` als Treffer erscheinen.
Wenn du bereits den Paketnamen kennst und seine enthaltenen Dateien sehen möchtest, verwendest du:
```
apt-file list openssh-client
```
Beide Abfragen funktionieren, ohne das untersuchte Paket zu installieren oder seine `.deb`-Datei herunterzuladen.
Die Suche ist allerdings auf die eingerichteten Paketquellen und deren verfügbare Dateilisten begrenzt. Kein Treffer bedeutet deshalb nur: In den aktuell durchsuchbaren Listen wurde die Datei nicht gefunden.
Abhängigkeiten untersuchen
--------------------------
### Wovon hängt ein Paket ab?
```
apt-cache depends nginx
```
Die Ausgabe enthält Paketbeziehungen und mögliche Erfüllungen. Dabei müssen verpflichtende Abhängigkeiten von Empfehlungen und Vorschlägen unterschieden werden.
### Welche Pakete hängen davon ab?
```
apt-cache rdepends nginx
```
Auf installierte Pakete beschränken:
```
apt-cache --installed rdepends nginx
```
Diese Abfragen helfen beim Verständnis. Sie ersetzen aber keine Simulation einer geplanten Entfernung: Welche konkreten Änderungen APT vorschlägt, zeigt zuverlässiger der berechnete Aktionsplan.
```
sudo apt-get --simulate remove nginx
```
### Installierte Abhängigkeiten prüfen
```
sudo apt-get check
```
Der Befehl prüft auf beschädigte beziehungsweise nicht erfüllte Abhängigkeiten. Er ist ein Diagnosewerkzeug und nicht dasselbe wie eine automatische Reparatur.
Lokale Debian-Pakete verwalten
------------------------------
### Ein Paketarchiv vor der Installation untersuchen
```
dpkg-deb --info ./paket.deb
```
Zeigt Paketinformationen, etwa Name, Version, Architektur und Abhängigkeiten.
```
dpkg-deb --contents ./paket.deb
```
Listet die im Datenarchiv enthaltenen Dateien auf.
Die entsprechenden Kurzformen über `dpkg` sind:
```
dpkg -I ./paket.deb
dpkg -c ./paket.deb
```
Beide untersuchen das Archiv, ohne es zu installieren.
### Ein Paket nur entpacken
```
dpkg-deb --extract ./paket.deb ./paketinhalt
```
Das legt die enthaltenen Dateien im Zielverzeichnis ab, führt aber keine reguläre Installation durch: Es gibt keinen normalen Paketstatus und keine Ausführung der Installationsskripte. Deshalb darf Entpacken nicht mit Installieren verwechselt werden.
### Lokale Pakete mit APT installieren
```
sudo apt install ./paket.deb
```
Der Pfad mit `./` kennzeichnet eine lokale Datei. APT kann erforderliche Abhängigkeiten aus den eingerichteten Quellen beziehen, sofern passende Pakete verfügbar sind.
> Für übliche lokale Installationen ist das meist praktischer als der direkte Aufruf von `dpkg`, weil die Abhängigkeitsauflösung mit berücksichtigt wird.
### Direkte Installation mit dpkg
```
sudo dpkg -i ./paket.deb
```
`dpkg` installiert das lokale Archiv, lädt fehlende Abhängigkeiten aber nicht selbst aus Paketquellen nach. Fehlen Voraussetzungen, kann das Paket in einem unvollständigen Zustand zurückbleiben.
> Ein lokales Paket muss aus einer vertrauenswürdigen Quelle stammen. **Die Installation kann Paketskripte mit Root-Rechten ausführen**; das Anzeigen von Name und Version bestätigt nicht seine Vertrauenswürdigkeit.
Unvollständige Installationen untersuchen und reparieren
--------------------------------------------------------
### Auffällige Paketzustände prüfen
```
dpkg --audit
```
Die Kurzform lautet:
```
dpkg -C
```
Damit werden unter anderem teilweise installierte Pakete und bestimmte Unstimmigkeiten ihrer Verwaltungsdaten gesucht.
### Ausstehende Konfiguration abschließen
```
sudo dpkg --configure -a
```
Der Befehl versucht, alle bereits entpackten, aber noch nicht vollständig konfigurierten Pakete zu konfigurieren.
Er lädt keine fehlenden Abhängigkeiten herunter. Schlägt die Konfiguration erneut fehl, ist die konkrete Fehlermeldung maßgeblich – beispielsweise ein Fehler in einem Paketskript.
### Beschädigte Abhängigkeiten reparieren
Zuerst den Vorschlag prüfen:
```
sudo apt-get --simulate --fix-broken install
```
Anschließend gegebenenfalls ausführen:
```
sudo apt-get --fix-broken install
```
Die Kurzform ist:
```
sudo apt-get -f install
```
APT versucht, einen konsistenten Abhängigkeitszustand herzustellen. Der Vorschlag kann zusätzliche Installationen oder Paketentfernungen enthalten. „Reparieren“ bedeutet nicht automatisch, dass jedes zuvor angeforderte Paket erhalten bleibt.
Diese Befehle sind keine universelle Reparaturkette. Welche Maßnahme passt, hängt davon ab, ob die Ursache etwa fehlende Abhängigkeiten, ein fehlgeschlagenes Paketskript oder ein anderer Systemfehler ist.
Paketdateien auf Veränderungen prüfen
-------------------------------------
```
dpkg --verify openssh-client
```
Kurzform:
```
dpkg -V openssh-client
```
Ohne Paketnamen werden alle Pakete berücksichtigt:
```
dpkg -V
```
> `dpkg -V` vergleicht Dateiinhalte mit gespeicherten MD5-Prüfsummen, sofern diese vorhanden sind. So lassen sich beispielsweise lokale Änderungen oder beschädigte Dateien erkennen. MD5 als Verfahren bietet jedoch keinen verlässlichen Schutz gegen gezielte Manipulation. Die Prüfung hilft deshalb bei der Fehlersuche, beweist aber nicht, dass das System sicher oder unverändert ist.
Paketquellen und APT-Konfiguration prüfen
-----------------------------------------
### Wichtige Orte kennen
| Pfad | Aufgabe |
|---|---|
| `/etc/apt/sources.list` | Paketquellen im einzeiligen Format |
| `/etc/apt/sources.list.d/*.list` | Weitere Quellen im einzeiligen Format |
| `/etc/apt/sources.list.d/*.sources` | Quellen im Deb822-Format |
| `/etc/apt/apt.conf.d/` | Zusätzliche APT-Einstellungen |
| `/etc/apt/preferences` und `/etc/apt/preferences.d/` | Regeln zur Versionsauswahl, auch als Pinning bezeichnet |
| `/var/lib/apt/lists/` | Heruntergeladene Paketindizes |
| `/var/cache/apt/archives/` | Zwischengespeicherte Paketarchive |
Welche Quelldateien vorhanden sind, hängt von Distribution und Installation ab. Eine fehlende oder leere `/etc/apt/sources.list` bedeutet deshalb nicht automatisch, dass keine Quellen eingerichtet sind.
Quellendateien lassen sich beispielsweise so anzeigen:
```
grep -R -n --include='*.list' --include='*.sources' .
/etc/apt/sources.list /etc/apt/sources.list.d/ 2>/dev/null
```
Die Ausgabe zeigt die Dateien einschließlich möglicher Kommentare und deaktivierter Einträge.
```
apt-cache policy
```
Zeigt die APT bekannten Paketquellen und ihre Prioritäten. Wenn du die genaue Konfiguration untersuchen möchtest, findest du sie in `/etc/apt/sources.list` und den Dateien unter `/etc/apt/sources.list.d/`
Die wirksame APT-Konfiguration lässt sich mit folgendem Befehl untersuchen:
```
apt-config dump
```
> Quellenkonfiguration, heruntergeladene Indizes und installierter Paketstand sind verschiedene Dinge. Erst durch ihre gemeinsame Betrachtung lässt sich erklären, woher ein Paket stammt und warum APT eine bestimmte Version auswählt.
### Vertrauensschlüssel gezielt zuordnen
APT verwendet öffentliche Signaturschlüssel, um zu prüfen, ob die bereitgestellten Paketinformationen von einer vertrauenswürdigen Quelle stammen und nicht verändert wurden. Zusätzlichen Paketquellen sollte deshalb über `Signed-By` gezielt der Schlüssel zugeordnet werden, mit dem APT ihre Signaturen überprüfen darf.
Als Ablageorte sind insbesondere vorgesehen:
- `/etc/apt/keyrings/` für administrativ verwaltete Schlüssel,
- `/usr/share/keyrings/` für durch Pakete verwaltete Schlüssel.
So gilt der Schlüssel nur für die zugeordnete Paketquelle und nicht automatisch auch für andere Quellen. Ältere Anleitungen mit `apt-key add` verwenden diese Begrenzung nicht und sollten deshalb nicht einfach übernommen werden.
Pakete herunterladen und Änderungen nachvollziehen
--------------------------------------------------
### Ein Paket herunterladen, ohne es zu installieren
```
apt-get download nginx
```
Das Paketarchiv wird im aktuellen Verzeichnis abgelegt. Abhängigkeiten werden dabei nicht als vollständiger Installationssatz mit heruntergeladen.
Eine geplante Installation einschließlich der benötigten Downloads vorbereiten, aber nicht ausführen:
```
sudo apt-get --download-only install nginx
```
Der Befehl lädt die für die geplante Installation benötigten Paketdateien herunter und speichert sie unter `/var/cache/apt/archives/`. Installiert werden sie dabei noch nicht.
### Änderungsprotokoll anzeigen
```
apt-get changelog nginx
```
Das Änderungsprotokoll hilft dabei, die Änderungen einer Paketversion nachzuvollziehen. Standardmäßig bezieht sich die Abfrage auf die installierte Version; andere Versionen lassen sich gezielt angeben.
### In Skripten Fehler berücksichtigen
Ein einfacher Ablauf kann so aussehen:
```
sudo apt-get update && sudo apt-get install nginx
```
Durch `&&` wird die Installation nur gestartet, wenn der vorherige Befehl erfolgreich beendet wurde. Für Automatisierung, die auch einzelne Abruffehler beim Aktualisieren strikt als Fehler behandeln soll, unterstützt `apt-get`:
```
sudo apt-get --error-on=any update
```
`-y` bestätigt APT-Rückfragen automatisch, ersetzt aber weder die Prüfung des Aktionsplans noch eine vollständige Behandlung aller möglichen Paket- oder Konfigurationsdialoge.
Die wichtigsten Befehle im Überblick
------------------------------------
| Aufgabe | Befehl |
|---|---|
| Paketinformationen aktualisieren | `sudo apt update` |
| Pakete suchen | `apt search suchbegriff` |
| Paketdetails anzeigen | `apt show paketname` |
| Installierte und verfügbare Versionen vergleichen | `apt-cache policy paketname` |
| Installierte Pakete anzeigen | `apt list --installed` |
| Lokalen Paketstatus prüfen | `dpkg -s paketname` |
| Paket installieren | `sudo apt install paketname` |
| Paket erneut installieren | `sudo apt reinstall paketname` |
| Aktualisierungen anzeigen | `apt list --upgradable` |
| Regulär aktualisieren | `sudo apt upgrade` |
| Aktualisierung mit möglichen Entfernungen | `sudo apt full-upgrade` |
| Paket entfernen | `sudo apt remove paketname` |
| Paket einschließlich Konfigurationsresten entfernen | `sudo apt purge paketname` |
| Nicht mehr benötigte Abhängigkeiten entfernen | `sudo apt autoremove` |
| Aktion simulieren | `sudo apt-get --simulate install paketname` |
| Paketdateien auflisten | `dpkg -L paketname` |
| Lokalen Dateipfad zuordnen | `dpkg -S /pfad/zur/datei` |
| Datei in Paketquellen suchen | `apt-file search dateiname` |
| Abhängigkeiten anzeigen | `apt-cache depends paketname` |
| Rückwärtsabhängigkeiten anzeigen | `apt-cache rdepends paketname` |
| Lokales Archiv untersuchen | `dpkg-deb --info ./paket.deb` |
| Lokales Paket mit Abhängigkeitsauflösung installieren | `sudo apt install ./paket.deb` |
| Unvollständige Paketzustände suchen | `dpkg --audit` |
| Ausstehende Konfiguration abschließen | `sudo dpkg --configure -a` |
| Abhängigkeiten prüfen | `sudo apt-get check` |
| Abhängigkeitsreparatur vorschlagen lassen | `sudo apt-get --simulate --fix-broken install` |
| Änderungen an Paketdateien prüfen | `dpkg -V paketname` |
| Paket zurückhalten | `sudo apt-mark hold paketname` |
| Zurückgehaltene Pakete anzeigen | `apt-mark showhold` |
| Paket als ausdrücklich benötigt markieren | `sudo apt-mark manual paketname` |
| Heruntergeladene Paketarchive bereinigen | `sudo apt-get clean` |
Die Übersicht fasst die beschriebenen Aufgaben zusammen. Bei Änderungen bleiben die Unterschiede zwischen lesender Abfrage, Simulation und tatsächlicher Ausführung entscheidend.
Fazit
-----
Sichere Debian-Paketverwaltung besteht nicht darin, möglichst viele Installationsbefehle auswendig zu kennen. Entscheidend ist, für jede Frage die passende Ebene zu wählen: `dpkg` und `dpkg-query` erklären den lokalen Zustand, APT berücksichtigt Quellen und Abhängigkeiten, `apt-cache` macht die Versionsauswahl nachvollziehbar und `apt-file` ordnet gesuchte Dateien Repository-Paketen zu.
Für den Sysadmin-Alltag ergibt sich daraus ein verlässlicher Ablauf: Informationen aktualisieren, Zustand und Herkunft prüfen, Änderungen simulieren, den Plan lesen und erst dann ausführen. Bei Fehlern wird zunächst die Ursache eingegrenzt, statt unbesehen Reparatur- oder Erzwingungsoptionen anzuwenden.
Debian-Paketverwaltung: dpkg und die APT-Werkzeuge sicher einsetzen
Submitted 14 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78450