[[Vorlage(Getestet, general)]] 

{{{#!vorlage Wissen
[:Terminal: Ein Terminal öffnen]
[:sudo: Root-Rechte erlangen] 
}}}
[[Inhaltsverzeichnis()]]

[[Bild(Wiki/Icons/terminal.png, 48, align=left)]]
Alle Kommandos von '''apt-get''' werden im [:Terminal:] eingegeben [1]. Allgemein besteht ein apt-get-Befehl aus den Optionsschaltern, dem "command" (Kommando) und gegebenenfalls aus einem oder mehreren Paketnamen. Manche Kommandos benötigen keine Angabe von Paketnamen. Allerdings benötigt apt-get außer im Fall von `-h` oder `--help` die Angabe eines Kommandos. Ein Paketname besteht nur aus dem Namen des Pakets ohne Versionsangabe.

Eine Übersicht der auf [:APT:] aufsetzenden Programme bzw. graphischen Oberflächen findet sich im Artikel [:Paketverwaltung:].

{{{#!vorlage Hinweis
apt-get benötigt in den allermeisten Fällen Root-Rechte [2].
}}}

Die allgemeine Form sieht so aus:
{{{#!vorlage Befehl
[sudo] apt-get [OPTIONEN] KOMMANDO [PAKET1] [PAKET2]
}}}

{{{#!vorlage Tabelle
<-3 rowclass="titel"> Kommandos zu apt-get
+++
[#apt-get-update `update`]
<-2> Neueinlesen der Paketlisten
+++
[#apt-get-upgrade `upgrade`]
<-2> installierte Pakete wenn möglich auf verbesserte Version aktualisieren
+++
[#apt-get-install `install`] `PAKET(E)`
<-2> Installation von `PAKET(E)`
+++
[#apt-get-remove `remove`] `PAKET(E)`
<-2> Deinstallation von `PAKET(E)`
+++
[#apt-get-autoremove `autoremove`] `[PAKET(E)]`
<-2> Deinstallation ungenutzter Abhängigkeiten [inkl `PAKET(E)`]
+++
[#apt-get-purge `purge`] `PAKET(E)`
<-2> wie [#apt-get-remove `remove`], zusätzlich werden alle globalen Konfigurationen von `PAKET(E)` entfernt
+++
[#apt-get-source `source`] `PAKET(E)`
<-2> Quelltext von `PAKET(E)` herunterladen, entpacken und Patches anwenden
+++
[#apt-get-build-dep `build-dep`] `PAKET(E)`
<-2> zum Erstellen von `PAKET(E)` notwendigen Abhängigkeiten installieren
+++
[#apt-get-dist-upgrade `dist-upgrade`]
<-2> wie [#apt-get-upgrade `upgrade`], nur können bei dem Vorgang auch Pakete installiert bzw. entfernt werden
+++
[#apt-get-dselect-upgrade `dselect-upgrade`]
<-2> in dselect gemachten Anweisungen folgen
+++
[#apt-get-clean `clean`]
<-2> Leeren des Paketcaches (Entfernen von zur Installation heruntergeladenen Paketen)
+++
[#apt-get-autoclean `autoclean`]
<-2> wie [#apt-get-clean `clean`], nur werden ausschließlich Pakete, die nicht mehr in den Quellen verfügbar sind, gelöscht
+++
[#apt-get-check `check`]
<-2> Überprüfung auf Abhängigkeitsfehler
+++
[#apt-get-markauto `markauto`] `PAKET(E)`
`PAKET(E)` als "automatisch installiert" markieren
<|2 :> Diese beiden Befehle gelten als veraltet, es sollten stattdessen `apt-mark auto PAKET(E)` bzw. `apt-mark manual PAKET(E)` verwendet werden! Siehe dazu auch [:apt/apt-Kommandos/#apt-mark:apt-mark].
+++
[#apt-get-unmarkauto `unmarkauto`] `PAKET(E)`
`PAKET(E)` als "manuell installiert" markieren
+++
[#apt-get-changelog `changelog`] `PAKET(E)`
<-2> Herunterladen und Anzeige des Changelogs von `PAKET(E)`
+++
[#apt-get-download `download`] `PAKET(E)`
<-2> `PAKET(E)` herunterladen
}}}

= Kommandos =
==apt-get update==
`update` liest alle in der [:sources.list:/etc/apt/sources.list] und in '''/etc/apt/sources.list.d/''' eingetragenen Paketquellen neu ein. Hierbei erfolgt eine Prüfung auf die Signatur der Paketlisten. `update` benötigt keine Angabe von Paketnamen. 
##hexe25: ...Prüfung der Signatur der Paketliste. auf die liest sich komisch an.

Dieser Schritt ist vor einem ``upgrade``, ``dist-upgrade`` oder nach dem Hinzufügen einer neuen Quelle zu empfehlen, um die aktuellsten Informationen zu den verfügbaren Paketen zu erhalten.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] update 
}}}

==apt-get upgrade==
`upgrade` bringt die installierten Pakete auf den neuesten in den Paketquellen verfügbaren Stand. Hierbei werden weder neue Pakete installiert noch durch neue Abhängigkeiten unnötig gewordene Pakete deinstalliert. `upgrade` benötigt keine Angabe von Paketnamen.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] upgrade 
}}}

==apt-get dist-upgrade==
`dist-upgrade` bringt die installierten Pakete auf den neuesten in den Paketquellen verfügbaren Stand. Hierbei werden im Gegensatz zu `upgrade` neue Pakete installiert und durch neue Abhängigkeiten unnötig gewordene Pakete ersetzt, auch wenn dies alte Abhängigkeiten beeinflusst. `dist-upgrade` benötigt keine Angabe von Paketnamen.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] dist-upgrade 
}}}

{{{#!vorlage Hinweis
``dist-upgrade`` führt kein [:Upgrade:] auf eine neue Ubuntu-Version durch.
}}}

==apt-get install==
`install` lädt das Paket bzw. die Pakete inklusive der noch nicht installierten Abhängigkeiten (und eventuell der vorgeschlagenen weiteren Pakete) herunter und installiert diese. Wendet man `install` auf ein bereits installiertes Paket an, wird dieses unabhängig vom aktuellen Status als "manuell installiert" markiert. `install` benötigt die Angabe mindestens eines Paketnamens, es können beliebig viele Pakete gleichzeitig angegeben werden. Diese werden durch ein Leerzeichen voneinander getrennt.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] install PAKET1 [PAKET2] 
}}}
Es lässt sich auch eine bestimmte verfügbare Version eines Paketes angeben:
{{{#!vorlage Befehl
sudo apt-get [Option(en)] install PAKET1=VERSION [PAKET2=VERSION]
}}}

==apt-get clean==
`clean` löscht die bereits heruntergeladenen Installationsdateien aus dem Paket-Cache '''/var/cache/apt/archives/''' und gibt so Festplattenspeicher frei. `clean` benötigt keine Angabe von Paketnamen.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] clean 
}}}

==apt-get autoclean==
`autoclean` löscht alle heruntergeladenen Paketinstallationsdateien, die aktuell nicht mehr in den Quellen verfügbar sind (Unterschied: `clean` löscht ausnahmslos alle Installationsdateien). `autoclean` benötigt keine Angabe von Paketnamen:

{{{#!vorlage Befehl
sudo apt-get [Option(en)] autoclean 
}}}

==apt-get remove==
`remove` deinstalliert ein oder mehrere Paket(e). Die Konfigurationsdateien, die durch die manuelle oder Autokonfiguration des Pakets erstellt wurden, bleiben erhalten. `remove` benötigt die Angabe mindestens eines Paketnamens. Wenn mehrere Pakete gleichzeitig gelöscht werden sollen, müssen diese durch Leerzeichen voneinander getrennt werden.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] remove PAKET1 [PAKET2] 
}}}

==apt-get autoremove==
`autoremove` deinstalliert nicht mehr benötigte Pakete, die als Abhängigkeit installiert wurden. `autoremove` kann auf zwei Arten verwendet werden:

 1. Ohne Angabe eines Paketnamens. Hierbei werden alle zur Zeit nicht mehr benötigten Abhängigkeiten deinstalliert (`remove`)
 1. Mit Angabe eines oder mehrerer Paketnamen. Hierbei wird zuerst das oder die angegebenen Paket(e) deinstalliert (`remove`), dann die frei gewordenen Abhängigkeiten deinstalliert. Es werden dabei aber immer auch sonstige nicht mehr benötigten Abhängigkeiten deinstalliert, falls diese sich auf dem System befinden sollten.

``autoremove`` benötigt keine Angabe von Paketnamen:

{{{#!vorlage Befehl
sudo apt-get [Option(en)] autoremove [PAKET1] [PAKET2] 
}}} 

==apt-get purge==
`purge` kann auf zwei Arten verwendet werden:

 1. Zur Deinstallation eines Pakets inklusive Löschung der globalen Konfiguration. Dies entspricht `remove` mit dem Parameter `--purge`
 1. Zum Löschen der globalen Konfiguration eines Pakets nach der Deinstallation mit `remove`

`purge` benötigt die Angabe mindestens eines Paketnamens. Sollen mehrere Pakete und ihre globalen Konfigurationsdateien gelöscht werden, werden diese durch Leerzeichen voneinander getrennt. Der gleiche Effekt lässt sich mit dem Kommando `remove --purge` erzielen.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] purge PAKET1 [PAKET2] 
}}}

==apt-get build-dep==
`build-dep` installiert die zum Erstellen von Paket aus dem Quelltext nötigen Abhängigkeiten. `build-dep` benötigt die Angabe mindestens eines Paketnamens.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] build-dep PAKET1 [PAKET2] 
}}}

==apt-get check==
`check` überprüft die Liste der installierten Pakete auf Abhängigkeitsfehler. `check` benötigt keine Angabe eines Paketnamens.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] check 
}}}

==apt-get source==
`source` lädt das Quelltext-Paket des Pakets in das aktuelle Verzeichnis herunter, entpackt es und wendet evtl. vorhandene Patches an. `source` benötigt die Angabe mindestens eines Paketnamens, aber keine Root-Rechte.

{{{#!vorlage Befehl
apt-get [Option(en)] source PAKET1 …
}}}

==apt-get help==
`help` zeigt den Hilfetext an. Er kann auch via Option `-h` oder `--help` aufgerufen werden. Eine ausführliche Informationsseite findet man in der [:man:Manpage] zu apt-get.

{{{#!vorlage Befehl
apt-get help
}}}

==apt-get dselect-upgrade==
`dselect-upgrade` führt die von dselect gemachten oder manuell markierten Änderungen aus. `dselect-upgrade` benötigt keine Angabe eines Paketnamens.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] dselect-upgrade 
}}} 

==apt-get markauto==
`markauto` markiert die übergebenen Pakete als ''automatisch installiert''. `markauto` benötigt die Angabe mindestens eines Paketnamens.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] markauto PAKET1 [PAKET2]
}}}

Dies gilt jedoch als veraltet, es sollte stattdessen verwendet werden:

{{{#!vorlage Befehl
sudo apt-mark auto PAKET1 [PAKET2]
}}}
Siehe dazu auch [:apt/apt-Kommandos/#apt-mark:apt-mark].

==apt-get unmarkauto==
`unmarkauto` markiert die übergebenen Pakete als ''"manuell installiert"''. `unmarkauto` benötigt die Angabe mindestens eines Paketnamens.

{{{#!vorlage Befehl
sudo apt-get [Option(en)] unmarkauto PAKET1 [PAKET2]
}}}

Dies gilt jedoch als veraltet, es sollte stattdessen verwendet werden:

{{{#!vorlage Befehl
sudo apt-mark manual PAKET1 [PAKET2]
}}}
Siehe dazu auch [:apt/apt-Kommandos/#apt-mark:apt-mark].

==apt-get changelog==
`changelog` lädt den Änderungsbericht (Changelog) des angegebenen Paket herunter und zeigt ihn an. `changelog` benötigt sinnvollerweise die Angabe eines Paketnamens, aber keine Root-Rechte.

{{{#!vorlage Befehl
apt-get [Option(en)] changelog PAKET
}}}

==apt-get download==
`download` lädt die Installationsdateien des angegebenen Pakets in das aktuelle Verzeichnis herunter. `download` benötigt die Angabe mindestens eines Paketnamens, aber ebenfalls keine Root-Rechte.

{{{#!vorlage Befehl
apt-get [Option(en)] download PAKET1 [PAKET2]
}}}
Unter älteren Ubuntu-Versionen kann man stattdessen die Option `-d` (siehe unten) verwenden:

{{{#!vorlage Befehl
sudo apt-get -d --reinstall install PAKET1 [PAKET2]
}}}
Die heruntergeladenen Pakete sind dann im Ordner '''/var/cache/apt/archives/''' zu finden.

=Optionen=
apt-get bietet zahlreiche Schalter, um das Verhalten zu beeinflussen.

{{{#!vorlage Tabelle
<-3 rowclass="titel"> Kommandozeilenoptionen zu apt-get
+++
<rowclass="kopf"> Lange Option
Kürzel
Beschreibung
+++
`--arch-only`

Nur Pakete mit der zum System passenden Architektur werden heruntergeladen.
+++
<cellstyle="width: 20%;">`--assume-yes`, `--yes`
`-y`
Interaktive Fragen werden automatisch mit "YES"/"JA" beantwortet - aber nur, wenn diese keine evtl. kritischen Änderungen wie das entfernen eine gehaltenen Pakets, die Installation eines nicht-authentifizierten Pakets oder das Entfernen eines benötigten Pakets bedingen.
+++
`--compile`, `--build`
`-b`
Den Quelltext [:Programme_kompilieren:kompilieren], nachdem er heruntergeladen wurde. Benutzung in Verbindung mit `source`.
+++
`--config-file`
`-c`
Die angegebene Konfigurationsdatei benutzen, die die Standardkonfiguration ersetzt.
+++
`--diff-only`

Nur das Diff-File eines Patchsets herunterladen.
+++
`--download-only`
`-d`
Pakete werden nur heruntergeladen, nicht installiert.
+++
`--fix-broken`
`-f`
Fehlende Abhängigkeiten werden nachinstalliert, kaputte Pakete werden eventuell deinstalliert. Es erlaubt die Nutzung von `install` oder `remove` ohne Angabe von Paketnamen.
+++
`--fix-missing`, `--ignore-missing`
`-m`
Nicht downloadbare Pakete werden auf "hold" gesetzt. In Verbindung mit `--no-download` werden nur Pakete im Paket-Cache benutzt.
+++
`--ignore-hold`

Ein Paket wird trotz gesetztem Status "hold" auf die neueste Version gebracht.
+++
`--install-suggests`

[:Paketverwaltung/Empfohlene_Pakete#Hintergrund:Vorgeschlagene] Pakete werden mitinstalliert.
+++
`--list-cleanup`

apt löscht nach `update` gespeicherte Listen aus Quellen, die nicht mehr in der [:sources.list:] stehen (standardmäßig aktiv).
+++
`--no-install-recommends`

[:Paketverwaltung/Empfohlene_Pakete#Hintergrund:Empfohlene] Pakete werden nicht automatisch installiert.
+++
`--no-list-cleanup`

apt behält nach `update` die Paketlisten nicht mehr existenter Quellen der [:sources.list:]. Nützlich bei häufigem Wechsel des Mirrors.
+++
`--no-upgrade`

Bereits installierte Pakete werden auf dem alten Stand belassen und nicht auf die neueste Version gebracht. In Verbindung mit `install` ist es so eventuell möglich, alte Abhängigkeiten beizubehalten.
+++
`--only-upgrade`

Ausschließlich bereits installierte Pakete werden auf eine neue Version gebracht, keine neuen Pakete werden installiert.
+++
`--option`
`-o`
Option: Die angegebene Option benutzen, statt dem in der Standardkonfiguration festgelegten Wert.
+++
`--print-uris`

Ausgabe der "download URIs" statt Herunterladen der Quellen bzw Pakete in Verbindung mit `update` oder `install`.
+++
`--purge`

Wird in Verbindung mit `remove` oder `autoremove` benutzt. Es werden zusätzlich zu den Paketen Konfigurationsdateien gelöscht.
+++
`--quiet`
`-q`
Programmausgabe ohne Fortschrittsanzeige mit logbarer Ausgabe. Erhöhung des "Stille"-Levels mit `-qq` möglich. `-qq` impliziert `-y`, um einen automatischen Ablauf zu ermöglichen.
+++
`--reinstall`

Ein bereits installiertes Paket wird in Verbindung mit `install` neu aus den Quellen installiert, obwohl es bereits auf der aktuellen Version ist.
+++
`--show-upgraded`
`-u`
Ausgabe einer Liste aller Pakete, die auf die neueste Version gebracht werden.
+++
`--simulate`, `--just-print`, `--dry-run`, `--recon`, `--no-act`
`-s`
Die angedachten Änderungen werden simuliert, keine Änderung am System. Seit Version ?? ohne Root-Rechte möglich.
+++
`--tar-only`

Ausschließlich das TAR-File des Quelltextes herunterladen.
+++
`--target-release`, `--default-release`
`-t`
Setzt die Priorität für die Quellen des genannten Release-Namens auf 990.
+++
`--trivial-only`

Gegenstück zu `--assume-yes`. Alle Fragen werden mit "NO" beantwortet, so dass nur unkritische Operationen automatisch ausgeführt werden.
+++
`--verbose-versions`
`-V`
Die Textausgabe der heruntergeladenen Daten wird um die vollen Versionsangaben erweitert.
}}}

{{{#!vorlage Hinweis
Im Internet findet man in älteren Artikeln, Foreneinträgen etc. zu `apt-get` manchmal einen Hinweis auf die Option `--force-yes`. Diese Option gilt ab apt-get Version 1.1 - also Ubuntu 16.04 und neuere Versionen - als veraltet und sollte nicht mehr verwendet werden. Weitere Hinweise dazu findet man in der der Manpage zu apt-get.
}}}

Wie bei [:Shell:]-Befehlen üblich, lassen sich kurze Optionen zu einem Block zusammenfassen. Beispiel: [[Vorlage(Befehl, "apt-get -s -t lucid update")]] lässt sich zusammenfassen in [[Vorlage(Befehl, "apt-get -st lucid update")]]


=Beispiele=
==Deinstallation inklusive Abhängigkeiten und Konfiguration==
Durch die Kombinationen von Kommando und Optionen hat man die Möglichkeit, mehrere Aktionen zu bündeln. Zum Beispiel die Deinstallation eines Pakets, der dann nicht mehr benötigten Abhängigkeiten sowie die Löschung der zugehörigen systemweiten Konfiguration des Pakets.

{{{#!vorlage Befehl
sudo apt-get --purge autoremove PAKET
}}}

{{{#!vorlage Hinweis
Viele Anwendungsprogramme legen ihre spezifische Konfiguration durch den Benutzer in dessen [:Homeverzeichnis:] ab. Diese Daten werden niemals automatisch gelöscht.
}}}

==Beispielskripte==
Der Ablauf eines "update"-Vorgangs lässt sich als Skript abbilden und zum Beispiel mit [:Cron:cron] aufrufen. Hier werden einige Beispiele je nach gewünschtem Ergebnis gezeigt, die allerdings nur einen kleinen Teil der Möglichkeiten von `apt` nutzen.

===Halbautomatische Aktualisierung===
Falls man bei einem selten kontrollierten Rechner die Aktualisierungen vor dem Einspielen zwar einsehen möchte, aber den Zeitaufwand möglichst gering halten will, bietet sich (von diversen Automatismen abgesehen) folgender Ablauf an:

{{{#!code bash
#!/bin/bash
apt-get update
apt-get -d dist-upgrade
apt-get autoclean
}}}

Hier werden zuerst die Paketlisten auf den neuesten Stand gebracht, dann vorhandene Aktualisierungspakete heruntergeladen und schließlich in den Quellen nicht mehr vorhandene Pakete aus dem Cache gelöscht, um Speicherplatz zu sparen. Dieser Ablauf kann automatisiert werden, so dass bei der nächsten Anmeldung die nötigen Pakete für einen "update"-Vorgang bereits vorliegen.

===Automatische Sicherheitsaktualisierung===
Zusätzlich zum zuvor beschriebenen Verfahren kann man auch sicherheitskritische Aktualisierungen sofort einspielen:

{{{#!code bash
#!/bin/bash
apt-get update
apt-get -yt $(lsb_release -cs)-security dist-upgrade
apt-get -d dist-upgrade 
apt-get autoclean
}}}

===Automatische Sicherheitsaktualisierung mit Einspielen unkritischer Pakete===
Zusätzlich kann man unkritische Aktualisierungen auch automatisch einspielen und nur noch diejenigen Pakete manuell aktualisieren, die eine Nachfrage stellen:

{{{#!code bash
#!/bin/bash
apt-get update
apt-get -yt $(lsb_release -cs)-security dist-upgrade
apt-get --trivial-only dist-upgrade 
apt-get autoclean
}}}


## Anker, um Backlinks (Forum, usw.) auf diesen ehemals vorhandenen Abschnitt einzufangen.
[[Anker ("Paketliste-zur-Wiederherstellung-erzeugen")]]
= Tipps =
Tipps zum Umgang mit der Paketverwaltung finden sich im Artikel [:Paketverwaltung/Tipps:].

=Links=
 * [:APT:] {Übersicht} Übersichtsseite
  * [:Apt-Pinning:apt-pinning] - Festsetzen der Prioritäten von APT
  * [:apt/apt:apt] - Kommandozeilenprogramm zum Verwalten und Durchsuchen von Paketen
 * [wikipedia_en:Advanced_Packaging_Tool:Advanced Package Tool] - Wikipedia
 * [https://debian-handbook.info/files/2011/11/chapter-apt.pdf APT - Wartung u. Aktualisierung] {en} {dl} (PDF) - 28 Seiten, 4,2 MB. Auszug aus dem "debian handbook", Kapitel 6, v. 14.11.2011
## * [:Archiv/apt-fast:] - Shellwrapper für apt-get und [:aptitude:], um Pakete schneller herunterzuladen
 * [:Cron:cron] - Zeitgesteuerte automatische Ausführung von Skripten
  * [:cron-apt:] - Automatisierung der Aktualisierungsprozesse
 * [:dpkg:] - Debian-Paketmanager
 * [:Aktualisierungen#Problematische-Aktualisierung-deinstallieren:] - Problematische Version deinstallieren
 * [:Recovery_Modus:] - apt-get im Wiederherstellungsmodus anwenden
 * [https://linuxundich.de/gnu-linux/apt-get-apt-cache-laesst-sich-schon-lange-mit-apt-abkuerzen/ apt-get, apt-cache lässt sich schon lange mit apt abkürzen] {de} - Blog-Beitrag

# tag: System, Shell, Installation, Server, Paketverwaltung