Guida ai pacchetti binari

Oltre al supporto classico alle ebuild, Portage supporta anche la costruzione e l'installazione di pacchetti binari. Questa guida spiega come crearli, installartli, e come configurare un server di pacchetti binari.

Introduzione

Ci sono molte ragioni per cui ad alcuni amministratori di sistemi piace usare pacchetti binari per le installazioni di software su Gentoo:

1. Permette agli amministratori di "risparmiare tempo nel momento in cui sistemi simili devono essere aggiornati". Dover compilare tutto da sorgenti può diventare consumare molto tempo. Mantenere numerosi sistemi simili, alcuni dei quali con hardware più datati, può essere molto più facile se solo un sistema deve compilare tutto da sorgente e gli altri usano i pacchetti binari.
2. Fare aggiornamenti sicuri. Per sistemi di importanza critica per la produzione è importante rimanere "usabili" il maggior tempo possibile. Ciò si può ottenere tramite un server di staging che effettua prima tutti gli aggiornamenti su di sé. Una volta osservato che il server è in uno stato funzionante, gli aggiornamenti possono essere estesi ai sistemi critici. Una variante di questo approccio consiste nell'applicare gli aggiornamenti in un chroot sullo stesso sistema e poi usare i binari creati qui sul sistema reale.
3. Come backup. Spesso i pacchetti binari sono l'unica maniera per ripristinare un sistema non funzionante (per esempio, un compilatore che non funziona). Avere a disposizione dei binari precompilati su un server o localmente può essere di grande aiuto in caso di catena di compilazione danneggiata.
4. Permette di aggiornare sistemi molto vecchi. L'attività di aggiornamento di sistemi molto vecchi può essere ampiamente facilitata usando pacchetti binari. È solitamente utile installare pacchetti binari su vecchi sistemi in quanto essi non necessitano l'installazione o l'aggiornamento delle dipendenze necessarie per la compilazione. I pacchetti binari evitano anche errori nel processo di compilazione in quanto sono già precompilati.

Questa guida si concentrerà sui seguenti argomenti:

• Creare pacchetti binari.
• Distribuire i pacchetti ai client.
• Implementare i pacchetti binari.
• Mantenere i pacchetti binari.

Verso la fine verranno coperti ulteriori dettagli più avanzati su come gestire i pacchetti binari.

Nota
Tutti gli strumenti usati in questa guida fanno parte di sys-apps/portage, a meno che non sia specificato diversamente.

Creare pacchetti binari

Esistono tre metodi principali per la creazione di pacchetti binari:

1. Dopo un'installazione regolare, usando l'applicazione quickpkg.
2. In maniera esplicita durante un'operazione emerge usando l'opzione --buildpkg (-b).
3. In maniera automatica usando il valore buildpkg nella variabile FEATURES di Portage.

Tutti e tre i metodi creeranno un pacchetto binario nella directory indicata dalla variabile PKGDIR (che ha un valore predefinito uguale a /usr/portage/packages).

Usare quickpkg

L'applicazione quickpkg prende uno o più atom di dipedenza (o insiemi di pacchetti) e crea pacchetti binari per tutti i pacchetti installati corrispondenti a quell'atom.

Per esempio, per creare pacchetti binari di tutte le versioni di GCC installate:

root #quickpkg sys-devel/gcc

Per creare pacchetti binari di tutti i pacchetti installati nel sistema, si usi il simbolo *:

root #quickpkg "*/*"

Occorre fare una precisazione riguardo questo metodo: esso si basa sui file installati, che possono essere un problema nel caso dei file di configurazione. Gli amministratori cambiano spesso i file di configurazione dopo aver installato del software. Poiché ciò potrebbe far trasparire dati importanti (magari anche confidenziali) nei pacchetti, quickpkg non include in maniera predefinita tutti i file di configurazione protetti tramite il metodo CONFIG_PROTECT. Per forzare l'inclusione dei file di configurazione, si usino le opzioni --include-config o --include-unmodified-config.

Usare --buildpkg come opzione di emerge

Quando si installa del software usando emerge, si può chiedere a Portage di creare pacchetti binari usando l'opzione --buildpkg (-b):

root #emerge --ask --buildpkg sys-devel/gcc

È anche possibile chiedere a Portage di creare solamente un pacchetto binario ma di non installare il software sul sistema live. Per questo, si può usare l'opzione --buildpkgonly (-B):

root #emerge --ask --buildpkgonly sys-devel/gcc

Quest'ultimo approccio tuttavia richiede che tutte le dipendenze per la compilazione siano state già installate.

Implementare buildpkg come funzionalità di Portage

La maniera più comune per creare automaticamente pacchetti binari ogni qual volta che un pacchetto viene installato da Portage è quella di usare la funzionalità buildpkg, che può essere impostata in /etc/portage/make.conf come di seguito:

FILE /etc/portage/make.confAbilitare la funzionalità buildpkg di Portage

FEATURES="buildpkg"

Con questa funzionalità attivata, ogni volta che Portage installerà del software esso creerà anche un pacchetto binario.

Escludere la creazione di alcuni pacchetti

È possibile dire a Portage di non creare pacchetti binari per una certa selezione di pacchetti o categorie. Per ottnere ciò, si deve passare l'opzione --buildpkg-exclude ad emerge:

root #emerge -uDN @world --buildpkg --buildpkg-exclude "virtual/* sys-kernel/*-sources"

Ciò può essere usato per pacchetti che hanno poco o nulla da beneficiare nell'avere disponibili un pacchetto binario. Dei casi possibili sono le sorgenti del kernel Linux o i pacchetti binari upstream (quelli che terminano con -bin come www-client/firefox-bin).

Configurare un host di pacchetti binari

Portage supporta un grande numero di protocolli per lo scaricamento di pacchetti binari: FTP, FTPS, HTTP, HTTPS e SSH. Ciò lascia spazio a molte implementazioni di host di pacchetti binari diverse.

Non esiste, tuttavia, un metodo "automatico" fornito da Portage per la distribuzione di pacchetti binari. A seconda dell'installazione desiderata sarà necessario scaricare ulteriore software.

Host di pacchetti binari basato sulla rete

Un approccio comune per la distribuzione di pacchetti binari consiste nella creazione di un host di pacchetti binari basato sulla rete.

Si usi un server di rete come lighttpd (www-servers/lighttpd) e lo si configuri per fornire accesso in lettura al percorso /etc/portage/make.conf di PKGDIR.

FILE /etc/lighttpd/lighttpd.confEsempio di configurazione di lighttpd

# Aggiungere questo alla fine della configurazione standard
server.modules += ( "mod_alias" )
alias.url = ( "/packages" => "/usr/portage/packages/" )

In seguito, sui sistemi client, si configuri di conseguenza la variabile PORTAGE_BINHOST:

FILE /etc/portage/make.confUso di un host di pacchetti binari basato sulla rete

PORTAGE_BINHOST="http://binhost.example.com/packages"

Host di pacchetti binari SSH

Per fornire un approccio più autenticato per i pacchetti binari, si può considerare l'uso di SSH.

Quando si usa SSH, è possibile usare la chiave SSH dell'utente root di Linux (senza password in quanto le installazioni devono avvenire in background) per connettersi ad un host di pacchetti binari remoto.

Per questo, è necessario assicurarsi che la chiave SSH dell'utente root sia permessa sul server. Ciò dovrà accadere per ogni macchina che si connetterà all'host SSH:

root #cat root.id_rsa.pub >> /home/binpkguser/.ssh/authorized_keys

La variabile PORTAGE_BINHOST dovrà quindi essere come di seguito:

FILE /etc/portage/make.confConfigurazione di PORTAGE_BINHOST per l'accesso tramite SSH

PORTAGE_BINHOST="ssh://binpkguser@binhostserver/usr/portage/packages"

Nota
Non usare i file di configurazione di SSH che si trovano in ~/.ssh/config per configurare le porte od il nome utente. Questo percorso viene ignorato quando Portage tenta di effettuare l'rsync dei pacchetti sul client. Impostare invece correttamente tutte le opzioni nella variabile PORTAGE_BINHOST.

Esportato su NFS

Quando si usano pacchetti binari su una rete interna, può risultare più facile esportare i pacchetti tramite NFS e montarlo sui client.

Il file /etc/exports potrebbe essere così:

FILE /etc/exportsEsportazione della directory dei pacchetti

/usr/portage/packages   2001:db8:81:e2::/48(ro,no_subtree_check,root_squash) 192.168.100.1/24(ro,no_subtree_check,root_squash)

Sui client, il percorso può poi essere montato. Un esempio di /etc/fstab potrebbe essere:

FILE /etc/fstabVoce per il montaggio della cartella dei pacchetti

binhost:/usr/portage/packages      /usr/portage/packages    nfs    defaults    0 0

Usare i pacchetti binari

Affinché i pacchetti binari siano utilizzabili su altri sistemi, essi devono soddisfare alcuni requisiti:

• Le architetture del client e del server e la variabile CHOST devono corrispondere.
• Le variabili CFLAGS e CXXFLAGS usate per compilare i pacchetti binari devono essere compatibili con tutti i client.
• I flag USE per funzionalità di insiemi di istruzioni specifiche del processore (come MMX, SSE, ecc.) devono essere selezionate con attenzione; tutti i client devono supportarli.

Importante
Portage non controlla se tali requisiti sono soddisfatti. È responsabilità degli amministratori assicurarsi di controllare tali impostazioni.

Oltre a ciò, Portage controllerà se il pacchetto binario viene costruito con gli stessi flag USE attesi dal client. Se un pacchetto viene costruito con una combinazione di flag USE diversa, Portage ignorerà il pacchetto binario (ed userà una compilazione basata su sorgenti) oppure fallirà, a seconda delle opzioni passate al comando emerge al momento dell'invocazione dello stesso (consultare la sezione installazione dei pacchetti binari).

Sui client, sono necessari alcuni cambiamenti di configurazione affinché i pacchetti binari possano essere usati.

Installare i pacchetti binari

Alcune opzioni possono essere passate al comando emerge per informare Portage di usare i pacchetti binari:

Opzione	Descrizione
--usepkg (-k)	Tenta di usare il pacchetto binario od i pacchetti binari nella cartella disponibile localmente packages. Utile quando si usano host di pacchetti binari montati su NFS/it o SSHFS/it. Se i pacchetti binari non vengono trovati, verrà effettuata un'installazione reolare (basata sui sorgenti).
--usepkgonly (-K)	Simile a --usepkg (-k) ma fallisce se il pacchetto binario non viene trovato. Questa opzione è utile se devono essere usati solo pacchetti binari pre-costruiti.
--getbinpkg (-g)	Scarica il pacchetto binario od i pacchetti binari da un host di pacchetti binari remoto. Se i pacchetti binari non vengono trovati, verrà effettuata un'installazione regolare (basata su sorgenti).
--getbinpkgonly (-G)	Simile a --getbinpkg (-g) ma fallisce se il pacchetto binario od i pacchetti binari non possono essere scaricati. Questa opzione è utile se devono essere usati solo pacchetti pre-costruiti.

Per usare automaticamente installazioni di pacchetti binari, si può aggiungere l'opzione appropriata alla variabile EMERGE_DEFAULT_OPTS:

FILE /etc/portage/make.confAutomatically fetch binary packages and fail the package if not available

EMERGE_DEFAULT_OPTS="${EMERGE_DEFAULT_OPTS} --getbinpkgonly"

There is a Portage feature that automatically implements the equivalent of --getbinpkg (-g) without the need for updating the EMERGE_DEFAULT_OPTS variable with the --getbinpkg value:

FILE /etc/portage/make.confEnabling getbinpkg in the FEATURES variable

FEATURES="getbinpkg"

Pulling packages from a binary package host

When using a binary package host, clients need to have the PORTAGE_BINHOST variable set. Otherwise the client will not know where the binary packages are stored which results in Portage being unable to retrieve them.

FILE /etc/portage/make.confSetting PORTAGE_BINHOST

PORTAGE_BINHOST="http://binhost.example.com/packages"

The PORTAGE_BINHOST variable uses a space-separated list of URIs. This allows administrators to use several binary package servers simultaneously. The URI must always point to the directory in which the Packages file resides.

Note
The support for multiple binary package servers is somewhat incomplete. If several servers serve a binary package for the same package version, then only the first one will be considered. This can be problematic when these binary packages differ in their USE variable configuration and the USE variable configuration of a later binary package would match the systems configuration.

Reinstalling modified binary packages

Passing the --rebuilt-binaries option to emerge will reinstall every binary that has been rebuilt since the package was installed. This is useful in case rebuilding tools like revdep-rebuild are run on the binary package server.

A related option is --rebuilt-binaries-timestamp. It causes emerge not to consider binary packages for a re-install if those binary packages have been built before the given time stamp. This is useful to avoid re-installing all packages, if the binary package server had to be rebuild from scratch but --rebuilt-binaries is used otherwise.

Additional client settings

Next to the getbinpkg feature, Portage also listens to the binpkg-logs feature. This one controls if log files for successful binary package installations should be kept. It is only relevant if the PORT_LOGDIR variable has been set and is enabled by default.

Similar to excluding binary packages for a certain set of packages or categories, clients can be configured to exclude binary package installations for a certain set of packages or categories.

To accomplish this, use the --usepkg-exclude option:

root #emerge -uDNg @world --usepkg-exclude "sys-kernel/gentoo-sources virtual/*"

To enable such additional settings for each emerge command, add the options to the EMERGE_DEFAULT_OPTS variable in the make.conf file:

FILE /etc/portage/make.confEnabling emerge settings on every invocation

EMERGE_DEFAULT_OPTS="${EMERGE_DEFAULT_OPTS} --usepkg-exclude 'sys-kernel/gentoo-sources virtual/*'"

Maintaining binary packages

Exporting and distributing the binary packages will lead to useless storage consumption if the binary package list is not actively maintained.

Removing outdated binary packages

In the app-portage/gentoolkit package an application called eclean is provided. It allows for maintaining Portage-related variable files, such as downloaded source code files, but also binary packages.

The following command will remove all binary packages that have no corresponding ebuild in the installed ebuild repositories:

root #eclean packages

For more details please read the Eclean article.

Another tool that can be used is the qpkg tool from the app-portage/portage-utils package. However, this tool is a bit less configurable.

To clean up unused binary packages (in the sense of used by the server on which the binary packages are stored):

root #qpkg -c

Maintaining the Packages file

Inside the packages directory exists a manifest file called Packages. This file acts as a cache for the metadata of all binary packages in the packages directory. The file is updated whenever Portage adds a binary package to the directory. Similarly, eclean updates it when it removes binary packages.

If for some reason binary packages are simply deleted or copied into the packages directory, or the Packages file gets corrupted or deleted, then it must be recreated. This is done using emaint command:

root #emaint binhost --fix

Advanced topics

Creating snapshots of the packages directory

When deploying binary packages for a large number of client systems it might become worthwhile to create snapshots of the packages directory. The client systems then do not use the packages directory directly but use binary packages from the snapshot.

Snapshots can be created using the /usr/lib64/portage/python2.7/binhost-snapshot or /usr/lib64/portage/python3.3/binhost-snapshot tool. It takes four arguments:

1. A source directory (the path to the packages directory).
2. A target directory (that must not exist).
3. A URI.
4. A binary package server directory.

The files from the package directory are copied to the target directory. A Packages file is then created inside the binary package server directory (fourth argument) with the provided URI.

Client systems need to use an URI that points to the binary package server directory. From there they will be redirected to the URI that was given to binhost-snapshot. This URI has to refer to the target directory.

Understanding the binary package format

Binary packages created by Portage have the file name ending with .tbz2. These files consist of two parts:

1. A .tar.bz2 archive containing the files that will be installed on the system.
2. A xpak archive containing package metadata, the ebuild, and the environment file.

See man xpak for a description of the format.

In app-portage/portage-utils some tools exists that are able to split or create tbz2 and xpak files.

The following command will split the tbz2 into a .tar.bz2 and an .xpak file:

user $qtbz2 -s <package>.tbz2

The .xpak file can be examined using the qxpak utility.

To list the contents:

user $qxpak -l <package>.xpak

The next command will extract a file called USE which contains the enabled USE flags for this package:

user $qxpak -x package-manager-0.xpak USE

The PKGDIR layout

The currently used format version 2 has the following layout:

CODE Packages directory layout (version 2)

PKGDIR
`+- Packages
 +- app-accessibility/
 |  +- pkg1-version.tbz2
 |  `- pkgN-version.tbz2
 +- app-admin/
 |  `- ...
 `- ...

The Packages file is the major improvement (and also the trigger for Portage to know that the binary package directory uses version 2) over the first binary package directory layout (version 1). In version 1, all binary packages were also hosted inside a single directory (called All/) and the category directories only had symbolic links to the binary packages inside the All/ directory.

Unpacking with quickunpkg

Zoobab wrote a simple shell tool named quickunpkg to quickly unpack tbz2 files.