Come creare un pacchetto RPM Linux

Questo articolo mostra come impacchettare uno script in un file RPM per una facile installazione, aggiornamento e rimozione dai tuoi sistemi Linux. Prima di entrare nei dettagli, spiegherò cos'è un pacchetto RPM e come puoi installarlo, interrogarlo, rimuoverlo e, soprattutto, crearne uno tu stesso.

Questo articolo copre:

• Che cos'è un pacchetto RPM.
• Come creare un pacchetto RPM.
• Come installare, interrogare e rimuovere un pacchetto RPM.

Cos'è un pacchetto RPM?

RPM sta per Red Hat Package Manager . È stato sviluppato da Red Hat ed è utilizzato principalmente su sistemi operativi Linux basati su Red Hat (Fedora, CentOS, RHEL, ecc.).

Un pacchetto RPM utilizza .rpm estensione ed è un bundle (una raccolta) di file diversi. Può contenere quanto segue:

• File binari, noti anche come eseguibili (nmap , stat , xattr , ssh , sshd , e così via).
• File di configurazione (sshd.conf , updatedb.conf , logrotate.conf , ecc.).
• File di documentazione (README , TODO , AUTHOR , ecc.).

Il nome di un pacchetto RPM segue questo formato:

<name>-<version>-<release>.<arch>.rpm

Un esempio:

bdsync-0.11.1-1.x86_64.rpm

Alcuni pacchetti includono anche una versione abbreviata della distribuzione per cui sono stati creati, ad esempio:

bdsync-0.11.1-1.el8.x86_64.rpm

[ Potresti anche divertirti: Gestione dei pacchetti Linux con YUM e RPM ]

Come creare un pacchetto RPM

Avrai bisogno dei seguenti componenti per creare un pacchetto RPM:

• Una workstation o una macchina virtuale che esegue una distribuzione basata su RPM, come RHEL o Fedora.
• Software per creare il pacchetto.
• Codice sorgente da imballare.
• File SPEC per creare l'RPM.

Installazione del software richiesto

I seguenti pacchetti devono essere installati per compilare il pacchetto RPM:

$ sudo dnf install -y rpmdevtools rpmlint

Dopo aver installato rpmdevtools , crea l'albero dei file di cui hai bisogno per creare i pacchetti RPM:

$ rpmdev-setuptree

Crei i pacchetti RPM come un utente normale (non root), quindi il tuo ambiente di compilazione viene posizionato nella tua home directory. Contiene questa struttura di directory:

rpmbuild/
├── BUILD
├── RPMS
├── SOURCES
├── SPECS
└── SRPMS

• Il BUILD viene utilizzata durante il processo di compilazione del pacchetto RPM. Qui è dove i file temporanei vengono archiviati, spostati, ecc.
• I RPM directory contiene i pacchetti RPM creati per diverse architetture e noarch se specificato in .spec file o durante la compilazione.
• Le FONTI directory, come suggerisce il nome, contiene le fonti. Questo può essere un semplice script, un progetto C complesso che deve essere compilato, un programma precompilato, ecc. Di solito, i sorgenti sono compressi come .tar.gz o .tgz file.
• La SPEC contiene il .spec File. Il .spec file definisce come viene creato un pacchetto. Ne parleremo più avanti.
• Gli SRPMS la directory contiene il .src.rpm Pacchetti. Un pacchetto Source RPM non appartiene a un'architettura oa una distribuzione. Il .rpm attuale la compilazione del pacchetto è basata su .src.rpm pacchetto.

Un .src.rpm è molto flessibile, perché può essere compilato e ricostruito su qualsiasi altra distribuzione e architettura basata su RPM.

Ora hai familiarità con ciò che ogni directory contiene, quindi ora crea un semplice script da distribuire:

$ cat << EOF >> hello.sh
#!/bin/sh
echo "Hello world"
EOF

Questo crea uno script di shell chiamato hello.sh , che stampa "Hello world" sul terminale. È semplice, ma è sufficiente per dimostrare il confezionamento.

Posiziona lo script nella directory designata

Per creare un pacchetto per il tuo script, devi mettere lo script nella directory in cui il sistema di build RPM si aspetta che si trovi. Crea una directory per esso, usando il controllo delle versioni semantico come fanno la maggior parte dei progetti, quindi sposta hello.sh dentro:

$ mkdir hello-0.0.1
$ mv hello.sh hello-0.0.1

La maggior parte del codice sorgente viene distribuito come archivio, quindi usa il comando tar per creare un file di archivio:

$ tar --create --file hello-0.0.1.tar.gz hello-0.0.1

Quindi sposta il tarball che hai appena creato in SOURCES directory:

$ mv hello-0.0.1.tar.gz SOURCES

Crea un file .spec

Un pacchetto RPM è definito da un .spec file. La sintassi di un .spec il file è rigoroso, ma rpmdev può generare un file boilerplate per te:

$ rpmdev-newspec hello

Questo genera un file chiamato hello.spec , che devi spostare in SPECS directory. Esegui tree ~/rpmbuild per vedere come appare la struttura della directory:

/home/tux/rpmbuild/
├── BUILD
├── BUILDROOT
├── RPMS
├── SOURCES
│   └── hello-0.0.1.tar.gz
├── SPECS
│   └── hello.spec
└── SRPMS

Il hello.spec generato fornisce un buon punto di partenza, ma non ha informazioni specifiche su ciò che stai costruendo. Il .spec generato presuppone che compilerò e creerò software.

Stai impacchettando uno script Bash, quindi c'è qualche semplificazione che puoi fare. Ad esempio, non esiste Build process perché non c'è codice da compilare. Ho aggiunto BuildArch:noarch perché questo pacchetto è valido per 32 bit, 64 bit, Arm e qualsiasi altra architettura CPU che esegue Bash.

Ho anche aggiunto Richiede:bash in modo che il pacchetto assicuri che Bash sia installato. Questo semplice script "hello world" viene eseguito su qualsiasi shell, ovviamente, ma non è vero per tutti gli script, quindi questo è un buon modo per dimostrare le dipendenze.

Name:           hello
Version:        0.0.1
Release:        1%{?dist}
Summary:        A simple hello world script
BuildArch:      noarch

License:        GPL
Source0:        %{name}-%{version}.tar.gz

Requires:       bash

%description
A demo RPM build

%prep
%setup -q

%install
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/%{_bindir}
cp %{name}.sh $RPM_BUILD_ROOT/%{_bindir}

%clean
rm -rf $RPM_BUILD_ROOT

%files
%{_bindir}/%{name}.sh

%changelog
* Sun Nov  18 2020 Valentin Bajrami <[email protected]> - 0.0.1
- First version being packaged

Come puoi vedere, ci sono molte scorciatoie in .spec File. Si chiamano macro e c'è un eccellente elenco di ciò che è disponibile nella documentazione del packaging di Fedora. È importante utilizzare le macro nel tuo .spec File. Aiutano a garantire la coerenza in tutti i sistemi RPM, aiutano a evitare errori nei nomi dei file e nella numerazione delle versioni e semplificano l'aggiornamento di .spec quando rilasci una nuova versione del tuo script.

Ad esempio, è necessario specificare esattamente quali file sono installati in %files sezione. Qui ho inserito esplicitamente la seguente riga:

%files
%{_bindir}/%{name}.sh

Funziona perché voglio che lo script vada a %{_bindir} (che è una macro che si traduce in /usr/bin per impostazione predefinita, ma è configurabile quando gli utenti desiderano eseguire l'installazione in una posizione diversa, ad esempio /usr/local/bin ). Puoi verificare i valori delle macro eseguendo:

$ rpm --eval '%{_bindir}'
/usr/bin

Altre utili macro:

• %{name} nome del pacchetto (come definito in Nome: campo)
• %{version} versione del pacchetto (come definito nella Versione: campo)
• %{_datadir} dati condivisi (/usr/sbin per impostazione predefinita)
• %{_sysconfdir} directory di configurazione (/etc per impostazione predefinita)

Controllo del file .spec in caso di errore (rpmlint)

Il rpmlint comando può trovare errori in .spec file:

$ rpmlint ~/rpmbuild/SPECS/hello.spec
SPECS/hello.spec: W: no-%build-section
SPECS/hello.spec: W: invalid-url Source0: hello-0.0.1.tar.gz
0 packages and 1 specfiles checked; 0 errors, 2 warnings.

Sono stati segnalati 2 errori, ma sono entrambi accettabili. Non c'è codice da compilare, quindi non è necessario un %build e l'archivio di origine è un file locale e non ha URL di rete.

Tutto sembra a posto.

Creazione del pacchetto (rpmbuild)

Per creare il pacchetto RPM, usa rpmbuild comando. In precedenza in questo tutorial, ho menzionato la differenza tra .src.rpm (pacchetto RPM di origine) e il .rpm pacchetto.

Per creare il .src pacchetto giri:

$ rpmbuild -bs ~/rpmbuild/SPECS/hello.spec

I flag -bs hanno i seguenti significati:

• -b:costruisci
• -s:sorgente

Per creare il pacchetto binario .rpm:

$ rpmbuild -bb ~/rpmbuild/SPECS/rm-ssh-offendingkey.spec

I flag -bb hanno i seguenti significati:

• -b:costruisci
• -b:binario

Usa -ba per costruire entrambi.

Al termine del processo di compilazione, hai la seguente struttura di directory:

$ tree ~/rpmbuild/
/home/tux/rpmbuild/
├── BUILD
│   └── hello-0.0.1
│       ├── hello.sh
├── BUILDROOT
├── RPMS
│   └── noarch
│       └── hello-0.0.1-1.el8.noarch.rpm
├── SOURCES
│   └── hello-0.0.1.tar.gz
├── SPECS
│   └── hello.spec
└── SRPMS

Installazione del pacchetto RPM

Dopo una corretta compilazione del pacchetto, puoi installare il pacchetto RPM utilizzando il dnf comando:

$ sudo dnf install ~/rpmbuild/RPMS/noarch/hello-0.0.1-1.el8.noarch.rpm

Può essere installato alternativamente con il rpm comando direttamente:

$ sudo rpm -ivh ~/rpmbuild/RPMS/noarch/hello-0.0.1-1.el8.noarch.rpm

Verifica che il pacchetto sia stato installato

Per verificare che il pacchetto sia stato installato correttamente, esegui il seguente comando:

$ rpm -qi hello
Name        : hello
Version     : 0.0.1
Release     : 1
Architecture: noarch
Install Date: Mon 09 Nov 2020 01:29:51 AM CET
Group       : Unspecified
Size        : 294
License     : GPL
Signature   : (none)
Source RPM  : hello-0.0.1-1.el8.src.rpm
Build Date  : Mon 09 Nov 2020 01:08:14 AM CET
Build Host  : slimmerAI
Summary     : A simple hello world script
Description : A demo RPM build

Il %changelog è possibile visualizzare anche l'immissione di un pacchetto:

$ rpm -q hello --changelog
* Sun Nov 08 2020 Valentin Bajrami <[email protected]> - 0.1
- First version being packaged

Guarda cosa c'è nel pacchetto RPM

È facile vedere quali file contiene un pacchetto RPM:

$ rpm -ql hello
/usr/bin/hello.sh

Rimozione del pacchetto RPM

Rimuovere il pacchetto dal sistema è facile come installarlo. Puoi usare il dnf comando:

$ sudo dnf remove hello

O il rpm comando direttamente:

$ sudo rpm --verbose --erase hello

Pensieri finali

In questo documento ho trattato le basi della creazione di pacchetti, incluso come creare, installare e rimuovere un pacchetto RPM dal sistema. Il .spec può diventare molto complicato man mano che crei software più avanzato, ma puoi leggere esempi reali su repository di software pubblici, come src.fedoraproject.org, per saperne di più.

[ Corso online gratuito:panoramica tecnica di Red Hat Enterprise Linux. ]