Salva e ripristina tutti i pacchetti
Sui sistemi basati su Debian/Ubuntu puoi scaricare l'elenco dei pacchetti installati in un file
dpkg --get-selections > my_package_list.txt
e installali di nuovo eseguendo
apt-cache dumpavail | sudo dpkg --merge-avail
sudo dpkg --set-selections < my_package_list.txt
sudo apt-get dselect-upgrade
La prima riga garantisce dpkg il database di è aggiornato (al giorno d'oggi la maggior parte delle persone usa apt per installare i pacchetti che mantiene il proprio database), la seconda riga importa le selezioni salvate e il terzo comando installa i pacchetti selezionati. Vedere il Debian Administrator's Handbook per i dettagli.
Nel caso in cui tu abbia installato pacchetti da repository di terze parti, devi aggiungere questi repository prima di seguire i passaggi precedenti per il ripristino.
Salva e ripristina solo i pacchetti installati esplicitamente
Aptitude installa automaticamente le dipendenze (ad esempio una libreria richiesta da un'applicazione). Questi pacchetti sono contrassegnati come "automatici" e possono essere rimossi automaticamente quando non sono più necessari. Nel caso tu voglia conservare questi flag "automatici" non possiamo usare dpkg poiché non tiene traccia dei pacchetti installati automaticamente. Invece dobbiamo usare il leggermente più criptico
LC_ALL=C aptitude search -F '%p %C' '~i!~M' > my_package_list.txt
Questo cercherà tutti i pacchetti installati (~i ) e non (! ) contrassegnato come automatico (~M ). Per ogni pacchetto corrispondente il nome del pacchetto (%p ) e lo stato (%C ) verrà stampato (questo imita l'output di dpkg --get-selections ). LC_ALL=C assicura che tutto l'output sia fatto in inglese senza traduzione in una lingua madre. Utilizzare i comandi menzionati sopra per installare i pacchetti da questo elenco. Fare riferimento al manuale utente di aptitude per i dettagli.
Ansible è uno strumento open source per il provisioning del software, la gestione della configurazione e la distribuzione delle applicazioni. Funziona su molti sistemi simili a Unix e può configurare sia sistemi simili a Unix che Microsoft Windows. Include il proprio linguaggio dichiarativo per descrivere la configurazione del sistema
(Da Wikipedia.) Homepage (GitHub).
Ce ne sono molti altri nella stessa categoria. La lettura di ansible dovrebbe fornirti il vocabolario per cercare gli altri e confrontare, se necessario. Nix è un nuovo contendente. Alcuni dicono "più complesso, ma forse giusto". anche lo chef è sulla scena.
Esempio Ansible per il nome host myhost , modulo apt (sostituire con yum o altro):
ansible -K -i myhost, -m apt -a "name=tcpdump,tmux state=present" --become myhost
L'elenco "tcpdump,tmux" può essere esteso con virgole. (Il fatto che il nome host myhost è due volte nella riga di comando, perché non stiamo usando un elenco di inventario host fisso, ma uno ad hoc, con la virgola finale.)
Questo graffia solo la superficie, Ansible ha una vasta collezione di moduli.
Se vuoi solo installare un mucchio di pacchetti, un semplice one-liner potrebbe fare come:
sudo bash -c 'for package in "tmux" "htop" "gimp"; do apt install -y --no-upgrade "$package"; done'
Il ciclo non è strettamente necessario, ma senza di esso, se apt non riesce a trovare nessuno dei programmi nell'elenco, non riuscirà ad installare nessuno degli altri pacchetti. Questo può accadere, ad esempio, se passi a una versione più recente della tua distribuzione e i pacchetti più vecchi non sono più nei repository. Se preferisci tutto o niente usa
sudo apt install -y --no-upgrade tmux htop gimp
Se vuoi anche salvare le tue configurazioni, il termine di ricerca sarebbe "dotfiles". È così che vengono chiamate le configurazioni nei sistemi simili a Unix poiché iniziano principalmente con un ".".
Un modo rapido e sporco per salvarli è semplicemente copiare tutte quelle directory di configurazione sul tuo nuovo sistema. Un modo migliore sarebbe metterli sotto il controllo della versione con strumenti come git. Uso una combinazione di git, dotbot e script scritti a mano per configurare il mio sistema.
Aggiorna
Un punto che manca dalla discussione finora è che apt in genere non è l'unico sistema di gestione dei pacchetti di cui si ha bisogno per qualcosa che vada oltre le nozioni di base. Altri strumenti di gestione dei pacchetti potrebbero essere snap , pip , conda , cargo e molti altri. Questo è implicitamente affrontato nella risposta di Alex Stragies. Ansible contiene una vasta quantità di moduli inclusi i moduli per gestire i pacchetti oltre a apt come snap e pip .Poiché la mia risposta è incentrata su scrivi-il-tuo-script, vorrei approfondire l'argomento.Un framework ben collaudato come Ansible dovrebbe generalmente essere preferito per la maggior parte delle attività, ma ai miei occhi il codice scritto da me offre un vantaggio in termini di flessibilità.
Piccolo framework di esempio
Ho scritto un piccolo codice in Python che esemplifica come potrebbe apparire un tale framework.
#!/usr/bin/env python3
import os
import re
import sys
import subprocess
def read_package_list(path):
package_list=[]
try:
with open(os.path.realpath(path)) as f:
for line in f:
match = re.search(r'^(?!\s*$)(?!#)\w+',line)
if match:
package_list.append(match.group(0))
return package_list
except Exception as e:
print(e.message)
print(e.args)
sys.exit(1)
return package_list
def install_packages(command,package_list,err_log):
try:
with open(err_log,'w+') as f:
for p in package_list:
print('executing '+command+' '+str(p))
out=subprocess.run(command+' '+p,shell=True,stderr=f)
except Exception as e:
print(e.message)
print(e.args)
sys.exit(1)
def main():
args = sys.argv[1:]
package_list = read_package_list(args[1])
err_log=os.path.realpath(args[2])
install_packages(args[0],package_list,err_log)
if __name__ == '__main__':
main()
Gli ingredienti di base sono una funzione per elaborare un elenco di pacchetti separati da newline (read_package_list ) e una funzione per eseguire il comando installer in una shell (install_packages ).Righe con solo spazi bianchi e righe che iniziano con # vengono ignorati durante la lettura nell'elenco dei pacchetti. Il main elabora gli argomenti che possono essere forniti sulla riga di comando come installer command , packagefile , errorlog .
Cosa mi dà?
Bene, puoi semplicemente usare qualsiasi comando di installazione che ti piace
./installerscript.py 'apt install --dry-run' myaptpackages.txt apt_err.log
./installerscript.py 'snap install' mysnaps.txt snap_err.log
./installerscript.py 'pip install --user' mypy.txt py_err.log
./installerscript.py 'git clone' repos.txt git_err.log
Questo potrebbe essere utile se si mantiene un elenco di pacchetti che dovrebbero essere trattati tutti allo stesso modo. Una volta che esiste un framework di questo tipo, è facile migliorarlo. Si potrebbe, ad esempio, personalizzare il modo in cui il processo di installazione viene registrato o personalizzare l'elaborazione degli argomenti della riga di comando. Un altro aspetto è che lo script probabilmente non dovrebbe eseguire ogni comando come root (se eseguito come root) come fa attualmente.