Creare un Repository Debian: differenze tra le versioni

Da Guide@Debianizzati.Org.
Vai alla navigazione Vai alla ricerca
(→‎Uso in locale: allow-insecure per un repository locale non firmato)
 
(34 versioni intermedie di 9 utenti non mostrate)
Riga 1: Riga 1:
==Introduzione==
{{Repository
|precedente=Immagini iso Debian da usare come repository
|successivo=Gestione di un repository con debarchiver
}}
{{Versioni compatibili|Squeeze|Wheezy|Jessie}}
== Introduzione ==
La creazione di un repository Debian personale può essere utile nel caso si vogliano rendere disponibili per l'installazione tramite l'[[Introduzione all'APT System|APT System]] i pacchetti <code>.deb</code> creati da noi. Il repository così creato può essere utilizzato all'interno della nostra LAN, oppure reso accessibile a un gran numero di utenti tramite Internet.


Spesso ci � capitato di installare dei pacchetti contenenti dei bug, conosciuti anche prima del nostro download.
Esistono fondamentalmente due diversi approcci alla creazione di un repository:
Prima di installare un pacchetto, infatti, sarebbe opportuno fare una visitina sul sito http://bugs.debian.org, dove vengono tracciati i bug segnalati. Questo motore di gestione dei bug � molto potente e funzionale..ma se non volessimo perdere tempo ogni volta?
* '''Repository Automatico''': ha una struttura complessa, gestisce un pool di pacchetti e supporta architetture (i386, sparc, ecc.) multiple. A fronte di un maggior lavoro lato server permette un uso altamente automatizzato lato client;
apt-listbugs � la risposta!
* '''Repository Semplice''': gestisce una sola architettura. È il più indicato per i piccoli repository, specie quelli personali, perché richiede un minor lavoro lato-server.
apt-listbugs, infatti, ci permette di essere informati sui bug presenti nel nostro sistema e presenti nei pacchetti che stiamo per installare...vediamo come utilizzarlo e configurarlo al meglio per le nostre esigenze!


In questa guida vedremo come realizzare il secondo tipo di repository.


==Installazione==
== Repository semplice ==
 
=== La Struttura ===
Per installare apt-listbugs, � sufficiente un
Per prima cosa dovremo scegliere dove risiederà fisicamente il nostro repository. Una buona scelta può essere una directory all'interno della nostra home, come anche una directory all'interno di <code>/usr/share</code>. In questa guida creeremo il repository nella nostra home, ma sentitevi liberi di posizionarlo dove più vi aggrada.
<pre>
$ mkdir ~/debian
</pre>
Ora dobbiamo creare le due sottodirectory <code>binary</code> e <code>source</code> che conterranno rispettivamente le versioni binarie e sorgenti dei nostri pacchetti:
<pre>
<pre>
# apt-get install apt-listbugs
$ mkdir ~/debian/binary
$ mkdir ~/debian/source
</pre>
In questo modo avremo una struttura di questo tipo:
<pre>$ tree debian
debian
|-- binary
`-- sources
</pre>
</pre>


=== I file di indice ===
Ultimata la creazione della struttura del repository e popolati binary e source (se abbiamo anche le versioni sorgenti) con i nostri pacchetti, dobbiamo creare i relativi file di indice. Questi file vengono scaricati da APT quando impartiamo il comando <code>'''apt-get update'''</code> e contengono la lista di tutti i pacchetti presenti in un repository. Quando effettuiamo la ricerca di un pacchetto o quando desideriamo installarlo, APT consulta questi file per stabilire in quale repository esso è contenuto.


==Configurazione==
La creazione dei file di indice è ottenuta tramite due utility: <code>'''dpkg-scanpackages'''</code> e <code>'''dpkg-scansources'''</code>. Il funzionamento dei due programmi è identico, ma il primo esamina i file binari ed il secondo quelli sorgenti.


Apt-listbugs � gi� configurato per interagire con dpkg e apt in quanto aggiunge uno script nella directory '''/etc/apt/apt.conf.d/''', che contiene gli script da eseguire al termine del download dei pacchetti. Raccomando di non modificare il contenuto di questa directory, a meno di non sapere esattamente cosa fare pena l'impossibilit� di installare pacchetti e/o il cattivo funzionamento di dpkg e apt-get).
Entrambi gli strumenti restituiscono i loro risultati sullo standard output (<code>stdout</code>): questo significa che di default vedremo l'output a schermo. Per questo motivo è necessario reindirizzare il risultato di <code>dpkg-scanpackages</code> e <code>dpkg-scansources</code> su file appositi. Per convenzione questi file sono compressi in formato <code>gzip</code> e chiamati <code>'''Packages.gz'''</code> all'interno di <code>binary</code> e <code>'''Sources.gz'''</code> all'interno di <code>source</code>.
Nella directory '''/etc/apt/''' verr� aggiunta una nuova folder: "listbugs" che conterr� dei file di supporto per il normale funzionamento del programma (ad esempio il file ignore_bugs, contenente la lista dei bug ignorati durante l'installazione dei pacchetti).


Nell'esempio di questa guida il nostro repository contiene due pacchetti di tipo binario (apt e apt-best) ed un pacchetto di tipo sorgente (apt). Vedremo ora come creare i relativi file <code>Packages.gz</code> e <code>Sources.gz</code>


==Utilizzo==
La struttura del repository di esempio è questa:
<pre>
$ tree debian
debian
|-- binary
|  |-- apt-best-0.3.deb
|  |-- apt-doc_0.5.28.6_all.deb
|  |-- apt-utils_0.5.28.6_i386.deb
|  |-- apt_0.5.28.6_i386.deb
|  |-- libapt-pkg-dev_0.5.28.6_i386.deb
|  `-- libapt-pkg-doc_0.5.28.6_all.deb
`-- source
    |-- apt_0.5.28.6.dsc
    `-- apt_0.5.28.6.tar.gz
</pre>
Procediamo con la creazione del file <code>Packages.gz</code>:
<pre>
$ cd ~/debian
$ dpkg-scanpackages binary /dev/null | gzip -9c > binary/Packages.gz
  apt apt-best apt-doc apt-utils libapt-pkg-dev libapt-pkg-doc
Wrote 6 entries to output Packages file.
$ ls ~/debian/binary/ |grep Packages
Packages.gz
</pre>
Per la creazione del file indice <code>Packages.gz</code> in Wheezy:
<pre>
$ cd ~/debian
$ apt-ftparchive packages binary | gzip > binary/Packages.gz
$ ls ~/debian/binary/ |grep Packages
Packages.gz
</pre>
e del file <code>Sources.gz</code>
<pre>
$ cd ~/debian
$ dpkg-scansources source /dev/null | gzip -9c > source/Sources.gz
$ ls ~/debian/source/ |grep Sources
Sources.gz
</pre>


L'utilizzo base del programma � semplicissimo:
=== I file di Release ===
ogni volta che installeremo o aggiorneremo dei pacchetti, apt-listbugs interrogher� i server Debian per sapere se ci sono dei bug aperti per le applicazioni installate; raccolte le informazioni ci avvertir� in caso di bug (altrimenti lascer� continuare normalmente il processo di installazione).
Se volete poter usare il [[pinning]] o permetterne l'uso agli utenti del vostro repository, una volta creati i file <code>Packages.gz</code> e <code>Sources.gz</code>, dovete necessariamente creare un file apposito in ciascuna directory del vostro repository.
In caso di presenza di bug, mostrer� a video la lista di quelli presenti (sia aperti che chiusi); ecco un esempio:
 
Questi file sono chiamati file <code>'''Release'''</code>, sono normali file di testo ed hanno una struttura del tipo:
<pre>
<pre>
Retrieving bug reports... Done
Archive: archivio
critical bugs of login (1:4.0.3-30.7 -> 1:4.0.3-30.8) <done>
Component: componente
#290803 - login: /var/log/btmp is created with insecure permissions
Origin: origine
critical bugs of postfix (2.1.4-5 -> 2.1.5-5) <done>
Label: etichetta
#288728 - postfix gives up with warning: no MX host for xxxx.com has a valid A record
Architecture: architettura
grave bugs of mysql-server (4.0.23-1 -> 4.0.23-3) <open>
#291378 - mysql-server: Security fixes pending in experimental version
grave bugs of postfix (2.1.4-5 -> 2.1.5-5) <open>
#285111 - postfix: newaliases not working due to some library problem
#291031 - postfix: Upgrade from Postfix 2.1.4-5 to 2.1.5-4 fails #3
#292086 - stock installed master.cf file causes postfix to fail to start
Summary:
mysql-server(1 bug), login(1 bug), postfix(4 bugs)
Are you sure you want to install/upgrade the above packages? [Y/n/?/...]
</pre>
</pre>
dove:
* <code>archivio</code>: è l'archivio Debian a cui i pacchetti appartengono (ad es.: stable, testing. ecc.);
* <code>componente</code>: indica il tipo di componente (ad es.: main, contrib, non-free);
* <code>origine</code>: specifica il proprietario del repository;
* <code>etichetta</code>: identifica il repository: potete inserire descrizioni, ecc.;
* <code>architettura</code>: l' architettura dei pacchetti contenuti nel repository (ad es.: i386, sparc, source, ecc.).
Vediamo i file Release per i repository di questa guida.


Per l' archivio ''binary'' abbiamo:
<pre>
$ cat ~/debian/binary/Release
Archive: unstable
Component: main
Origin: keltik
Label: Repository di esempio
Architecture: i386
</pre>
e per quello ''source'':
<pre>
$ cat ~/debian/source/Release
Archive: unstable
Component: main
Origin: keltik
Label: Repository di esempio
Architecture: source
</pre>


Come potete vedere, visualizza una lista di bug presenti, divisi per categoria (prima quelli 'Critical', poi quelli 'Grave') e poi per pacchetto. Inoltre i bug sono contraddistinti da 2 tag: '''<done>''' e '''<open>''':<br/>
=== Uso del repository ===
'''<done>''' rappresenta un bug corretto<br/>
==== Uso in locale ====
'''<open>''' rappresenta un bug ancora aperto<br/>
Finalmente è venuto il momento di mettere alla prova il nostro repository.


Ecco una tabella riassuntiva delle categorie in cui sono divisi i bug:
Già fin d'ora possiamo utilizzarlo così com'è in locale sulla nostra macchina: tutto quello che dobbiamo fare consiste nell'aggiungere al nostro file <code>/etc/apt/sources.list</code> l'[[URI]] attraverso il quale reperire i pacchetti.
; critical : si riferisce a problemi che bloccano il pacchetto o l'intero sistema; oppure causano la perdita di dati importanti; oppure introducono dei problemi di sicurezza sui sistemi nei quali installi il pacchetto.<br/>
; grave : rende il pacchetto in questione inusabile o quasi; oppure causa la perdita di dati; oppure introduce dei problemi di sicurezza legati agli utenti del pacchetto.<br/>
; serious : indica una seria violazione della policy Debian (vale a dire di tutto quello che � identificato come "must" o "required") o che comunque secondo il manutentore del pacchetto rende lo stesso inappropriato per il rilascio.<br/>
; important : un bug che abbia un effetto pesante sull'usabilit� del pacchetto, senza per� renderlo inusabile per tutti.<br/>
; normal : il valore predefinito, utilizzabile per i bug normali.<br/>
; minor : un bug che non inficia l'usabilit� del pacchetto e che � facile da correggere.<br/>
; wishlist : per ogni richiesta di cambiamento del programma non legata a bug.<br/>
(fonte: http://www.debian.org/Bugs/Developer#severities)


In questo esempio abbiamo creato il repository nella directory <code>~/debian</code> e cioè nella directory <code>debian</code> all'interno della nostra home. Dovremo quindi aggiungere al file <code>/etc/apt/sources.list</code> due linee così composte:
<pre>
deb [allow-insecure=yes] file:///home/utente/debian binary/
deb-src [allow-insecure=yes] file:///home/utente/debian source/
</pre>
dove, alla parola ''utente'' dovete sostituire lo username dell'utente nella cui home risiede il repository. L'uso di <code>allow-insecure=yes</code> permette l'uso di un repository non firmato e/o la cui chiave pubblica corrispondente non è stata aggiunta alle chiavi fidate di APT.


Apt-listbugs ci mostra prevalentemente quelli appartenenti alle prime due categorie.
Una volta fatto questo lanciate:
<pre> # apt-get update</pre>
per rigenerare la lista degli indici di APT.


Tornando ad apt-listbugs, in caso di bug rilevati, viene chiesto cosa fare.
Ora vediamo se il nostro repository funziona. Iniziamo con il cercare il pacchetto '''apt'''. Il comando da impartire è:
Le opzioni disponibili sono:<br/>
<pre>
; y : Continua l'installazione ignorando i bug trovati;<br/>
$ apt-cache show apt
; n : Interrompe immediatamente l'installazione;<br/>
</pre>
; <num> : Inserendo il numero del bug (quello preceduto da #) al posto di � possibile ottenere maggioni informazioni riguardo il bug;<br/>
; r : Mostra la lista dei bug (comodo dopo la visualizzazione dei dettagli, ad esempio);<br/>
; p : Esegui il pinning di tutti i pacchetti segnalati nel bug report (cio� lo 'blocca' e non lo installa); questa opzione richiede l'uscita da '''apt-get''' e una riesecuzione del comando di installazione/aggiornamento precedentemente lanciato;<br/>
; p <pkg> : Esegue il pinning del pacchetto indicato;<br/>
; i : Ignora il bug corrispondente a (per evitare il pinning di pacchetti il cui bug � segnato come "done";<br/>
; ? : Mostra un piccolo help con le opzioni utilizzabili;<br/>
; w : Mostra il report bug in html (mai usato...).


Il funzionamento, quindi, � molto semplice!
Se tutto ha funzionato dovremmo ottenere come risultato due diversi pacchetti: entrambi si chiamano apt, entrambi hanno numero di versione 0.5.28.6, ecc. Per capire se e quale proviene dal nostro repository dobbiamo andare a controllare la voce <code>Filename</code>.
Basta leggere con attenzione la lista dei bug riscontrati ed agire di conseguenza!
Ricordo che, nel caso di pinning di anche un solo pacchetto, � necessario ricominciare il processo di aggiornamento/installazione...


In caso di pinning di uno o pi� pacchetti, � necessario (al prossimo aggiornamento) rimuoverlo da '''/etc/apt/preferences''':
Nel caso del pacchetto proveniente dal repository ufficiale di Debian avremo:
Nel file '''/etc/apt/preferences''', ad esempio, trovo questo blocco relativo a postfix (prima l'ho pinnato, visto che il bug comprometteva gravemente il funzionamento):
<pre>
<pre>
Explanation: Pinned by apt-listbugs at Mon Jan 31 22:17:38 CET 2005
[ ... omissis ...]
Explanation:   #288728: postfix gives up with warning: no MX host for xxxx.com has a valid
Filename: pool/main/a/apt/apt_0.5.28.6_i386.deb
A record
[ ... omissis ...]
Explanation:  #285111: postfix: newaliases not working due to some library problem
Explanation:  #291031: postfix: Upgrade from Postfix 2.1.4-5 to 2.1.5-4 fails #3
Explanation:  #292086: stock installed master.cf file causes postfix to fail to start
Package: postfix
Pin: version 2.1.4-5
Pin-Priority: 1000
</pre>
</pre>
mentre per il pacchetto proveniente dal nostro repository avremo:
<pre>
[ ... omissis ...]
Filename: binary/apt_0.5.28.6_i386.deb
[ ... omissis ...]
</pre>
Per fare in modo che il nostro repository sia usato come preferenziale rispetto agli altri possiamo inserire nel file <code>/etc/apt/sources.list</code> le linee ad esso relativo all'inizio del file, prima di tutti gli altri repository.
In questo modo, quando impartiamo il comando:
<pre> # apt-get install nome_pacchetto</pre>
APT provvederà ad installare quello fornito dal repository elencato per primo in <code>/etc/apt/sources.list</code>. Ecco l'esempio sempre relativo ad ''apt'':
<pre>
# apt-get install apt -s
Lettura della lista dei pacchetti in corso... Fatto
Generazione dell'albero delle dipendenze in corso... Fatto
Pacchetti suggeriti:
  aptitude apt-doc
I seguenti pacchetti saranno aggiornati:
  apt
1 aggiornati, 0 installati, 0 da rimuovere e 1 non aggiornati.
Inst apt [0.5.28.6] (0.5.28.6 Repository di esempio:unstable)
Conf apt (0.5.28.6 Repository di esempio:unstable)
</pre>
Nelle ultime due linee possiamo notare come la provenienza del pacchetto sia '''Repository di esempio:unstable''' come indicato nel nostro file '''Release'''.


==== Uso in rete (http) ====
Rendere disponibile in rete il repository che abbiamo appena creato è un'operazione estremamente semplice. Non dovremo fare altro che copiare la root del repository in una directory accessibile al nostro server web ed indicare l'[[URI]] corretto nei file <code>/etc/apt/sources.list</code> delle macchine che dovranno accedere ad esso.


al prossimo aggiornamento, per controllare se sono presenti nuove versioni di postfix, dovr� rimuovere queste indicazioni, altrimenti il pacchetto in questione verr� assunto sempre come 'aggiornato'.
Nel caso in cui stiamo usando Apache e la DocumentRoot sia <code>/var/www</code> sarà sufficiente impartire:
Se non sono mai state fatte modifiche al file '''/etc/apt/preferences''' (soprattutto per quanto riguarda pinning per l'utilizzo di pi� release insieme) lo si pu� tranquillamente eliminare prima di ogni aggiornamento.
<pre>
# cp -R /home/utente/debian/ /var/www/
</pre>


Ora dobbiamo modificare i file <code>/etc/apt/sources.list</code> in modo che puntino a questo repository.


L'utilizzo di apt-listbugs in modo manuale (richiamandolo direttamente da shell) � inutile, ma pu� servire (seguito dal parametro -h oppure consultando il manuale (man apt-listbugs)) per modificare il comportamento del programma (i parametri possono essere modificati nel file '''/etc/apt/apt.conf.d/10apt-listbugs''', anche se raccomando l'utilizzo delle opzioni di default, che fino ad ora si sono rivelate le migliori.
Poniamo che il server che mette a disposizione il repositry abbia il [[FQDN]] debian.prova.net. La sintassi da utilizzare in <code>/etc/apt/sources.list</code> è la seguente:
<pre>
deb http://debian.prova.net/debian/ binary/
deb-src http://debian.prova.net/debian/ source/
</pre>
Dobbiamo fare '''estrema''' attenzione agli slash ("/") perché hanno un uso preciso all'interno di <code>/etc/apt/sources.list</code>. Nel nostro caso è '''necessario''' che sia l'URL (http://debian.prova.net/debian) sia l' archivio (binary o source) termini con un "/", altrimenti otterremo un errore di questo tipo:
<pre>
# apt-get update
E: La linea x in /etc/apt/sources.list (dist parse) non è corretta
</pre>
Se abbiamo invece scritto correttamente, quando lanceremo <code>apt-get update</code>, vedremo APT dialogare con il nostro web server e reperire l'elenco dei nostri pacchetti:
<pre>
# apt-get update
Get:1 http://debian.prova.net binary/ Packages [1377B]
Get:2 http://debian.prova.net binary/ Release [97B]
Get:3 http://debian.prova.net source/ Sources [412B]
Get:4 http://debian.prova.net source/ Release [100B]
</pre>
Per il test e l'ordine con cui i pacchetti vengono installati da APT, vi rimando alla lettura del [[#Uso_in_locale|paragrafo precedente]]


==Conclusione==
== Repository ufficiale ==
=== Configurazione repository ===
Per creare un repository ufficiale (fatto a regola d'arte, come quello di debian) per prima cosa installiamo il programma reprepro con il comando:
<pre># apt-get install reprepro</pre>
in seguito scegliamo il percorso dove creare il nostro repo (nella guida sarà indicato come ~/debian/) quindi creiamo la cartella e posizioniamovici dentro:
<pre>$ mkdir ~/debian/
$ cd ~/debian/</pre>
Ora dobbiamo creare un file di configurazione per reprepro quindi:
<pre>$ mkdir conf
$ cd conf</pre>
dentro creiamo un file chiamato distributions e riempiamolo nel seguente modo:
<pre>Origin: nomeMioRepo
Label: Etichetta nomeMioRepo
Suite: unstable
Codename: sid
Architectures: amd64
Components: main
Description: Unofficial Debian packages
SignWith: myKeyId
</pre>
{{Warningbox|Al posto di myKeyId bisogna insere l'id della chiave GPG creata appositamente per firmare i pacchetti.}}
ora riposizioniamoci nella cartella debian dando il comando:
<pre>cd ~/debian</pre>
facciamo creare i file necessari con:
<pre>reprepro check</pre>
per aggiungere un pacchetto al repo:
<pre>reprepro includedeb unstable /tmp/mypackage_1.1.1-1_all.deb</pre>
per rimuoverlo:
<pre>reprepro remove unstable mypackage</pre>


apt-listbugs � senza dubbio uno strumento utilissimo, in quanto previene l'installazione di pacchetti che possono rendere inusabile o instabile la nostra Debian Box.
Provvedere a mettere online il repository rendendo accessibile da un server web la cartella debian escludendo le directory db e conf, quindi modificare il file <code>/etc/apt/sources.list</code> aggiungendo la seguente riga:
Ovviamente non viene a sostituire le normali visite al sito http://bugs.debian.org, dove sono elencati tutti i bug di tutti i pacchetti presenti in Debian (che invito a controllare prima di chiedere aiuto per un comportamento strano di una applicazione).
<pre>deb http://www.tuSito.do/debian/ sid main</pre>
{{Suggerimento|Per impedire l'accesso alle directory db e conf si potrebbe creare all'interno di ciascune di essa un file .htaccess contentente:<pre>deny from all</pre>}}


=== Creazione pacchetto chiave GPG ===
Per prima cosa esportiamo la nostra chiave con
<pre>gpg --export myKeyId > myrepo-debian-key.gpg</pre>
In seguito creiamo il seguente alvero di directory (si ricorda che control e myrepo-debian-key.gpg sono files):
<pre>
├── DEBIAN
│   └── control
└── etc
    └── apt
        └── trusted.gpg.d
            └── myrepo-debian-key.gpg
</pre>
Inserire all'interno del file control:
<pre>Package: myrepo-archive-keyring
Version: 2014.4
Architecture: all
Maintainer: yourNick <mail@domain.do>
Depends: gpgv
Recommends: gnupg
Breaks: apt (<< 0.7.25.1)
Section: misc
Priority: important
Multi-Arch: foreign
Description: GnuPG archive keys of the archive archive
The archive project digitally signs its Release files. This package
contains the archive keys used for that.
</pre>
Il file myrepo-debian-key.gpg è il file precedentemente creato con GPG.
Posizionarsi all'esterno della directory pkg e lanciare i seguenti comandi:
<pre>
# chown -R root:root ./pkg
$ dpkg-deb -b ./pkg myrepo-archive-keyring_2014.4_all.deb
</pre>
Il pacchetto contiene la chiave per autenticare il repository.
{{Autori
|Autore=[[Utente:Keltik|Keltik]] 09:20, Giu 26, 2005 (EDT)
|Verificata_da=
: [[Utente:Tima|Tima]] 10:41, 16 mag 2013 (CEST)
: [[Utente:Marcomg|marcomg]] 17:50, 23 mag 2014 (CEST)
|Estesa_da=
: [[Utente:Marcomg|marcomg]]
|Numero_revisori=2
}}


---- [[User:MaXeR|MaXeR]]
[[Categoria:Creare repository]]

Versione attuale delle 07:46, 14 lug 2019

I repository
Arrow left.png

Introduzione ai repository

Repository ufficiali di Debian

Repository esterni

Extra

Arrow right.png



Edit-clear-history.png Attenzione. Questa guida è da considerarsi abbandonata, per via del tempo trascorso dall'ultima verifica.

Potrà essere resa obsoleta, previa segnalazione sul forum, se nessuno si propone per l'adozione.


Debian-swirl.png Versioni Compatibili

Debian 6 "squeeze"
Debian 7 "wheezy"
Debian 8 "jessie"

Introduzione

La creazione di un repository Debian personale può essere utile nel caso si vogliano rendere disponibili per l'installazione tramite l'APT System i pacchetti .deb creati da noi. Il repository così creato può essere utilizzato all'interno della nostra LAN, oppure reso accessibile a un gran numero di utenti tramite Internet.

Esistono fondamentalmente due diversi approcci alla creazione di un repository:

  • Repository Automatico: ha una struttura complessa, gestisce un pool di pacchetti e supporta architetture (i386, sparc, ecc.) multiple. A fronte di un maggior lavoro lato server permette un uso altamente automatizzato lato client;
  • Repository Semplice: gestisce una sola architettura. È il più indicato per i piccoli repository, specie quelli personali, perché richiede un minor lavoro lato-server.

In questa guida vedremo come realizzare il secondo tipo di repository.

Repository semplice

La Struttura

Per prima cosa dovremo scegliere dove risiederà fisicamente il nostro repository. Una buona scelta può essere una directory all'interno della nostra home, come anche una directory all'interno di /usr/share. In questa guida creeremo il repository nella nostra home, ma sentitevi liberi di posizionarlo dove più vi aggrada.

$ mkdir ~/debian

Ora dobbiamo creare le due sottodirectory binary e source che conterranno rispettivamente le versioni binarie e sorgenti dei nostri pacchetti:

$ mkdir ~/debian/binary
$ mkdir ~/debian/source

In questo modo avremo una struttura di questo tipo:

$ tree debian
debian
|-- binary
`-- sources

I file di indice

Ultimata la creazione della struttura del repository e popolati binary e source (se abbiamo anche le versioni sorgenti) con i nostri pacchetti, dobbiamo creare i relativi file di indice. Questi file vengono scaricati da APT quando impartiamo il comando apt-get update e contengono la lista di tutti i pacchetti presenti in un repository. Quando effettuiamo la ricerca di un pacchetto o quando desideriamo installarlo, APT consulta questi file per stabilire in quale repository esso è contenuto.

La creazione dei file di indice è ottenuta tramite due utility: dpkg-scanpackages e dpkg-scansources. Il funzionamento dei due programmi è identico, ma il primo esamina i file binari ed il secondo quelli sorgenti.

Entrambi gli strumenti restituiscono i loro risultati sullo standard output (stdout): questo significa che di default vedremo l'output a schermo. Per questo motivo è necessario reindirizzare il risultato di dpkg-scanpackages e dpkg-scansources su file appositi. Per convenzione questi file sono compressi in formato gzip e chiamati Packages.gz all'interno di binary e Sources.gz all'interno di source.

Nell'esempio di questa guida il nostro repository contiene due pacchetti di tipo binario (apt e apt-best) ed un pacchetto di tipo sorgente (apt). Vedremo ora come creare i relativi file Packages.gz e Sources.gz

La struttura del repository di esempio è questa:

$ tree debian
debian
|-- binary
|   |-- apt-best-0.3.deb
|   |-- apt-doc_0.5.28.6_all.deb
|   |-- apt-utils_0.5.28.6_i386.deb
|   |-- apt_0.5.28.6_i386.deb
|   |-- libapt-pkg-dev_0.5.28.6_i386.deb
|   `-- libapt-pkg-doc_0.5.28.6_all.deb
`-- source
    |-- apt_0.5.28.6.dsc
    `-- apt_0.5.28.6.tar.gz

Procediamo con la creazione del file Packages.gz:

$ cd ~/debian
$ dpkg-scanpackages binary /dev/null | gzip -9c > binary/Packages.gz
   apt apt-best apt-doc apt-utils libapt-pkg-dev libapt-pkg-doc
 Wrote 6 entries to output Packages file.
$ ls ~/debian/binary/ |grep Packages
Packages.gz

Per la creazione del file indice Packages.gz in Wheezy:

$ cd ~/debian
$ apt-ftparchive packages binary | gzip > binary/Packages.gz
$ ls ~/debian/binary/ |grep Packages
Packages.gz

e del file Sources.gz

$ cd ~/debian
$ dpkg-scansources source /dev/null | gzip -9c > source/Sources.gz
$ ls ~/debian/source/ |grep Sources
Sources.gz

I file di Release

Se volete poter usare il pinning o permetterne l'uso agli utenti del vostro repository, una volta creati i file Packages.gz e Sources.gz, dovete necessariamente creare un file apposito in ciascuna directory del vostro repository.

Questi file sono chiamati file Release, sono normali file di testo ed hanno una struttura del tipo:

Archive: archivio
Component: componente
Origin: origine
Label: etichetta
Architecture: architettura

dove:

  • archivio: è l'archivio Debian a cui i pacchetti appartengono (ad es.: stable, testing. ecc.);
  • componente: indica il tipo di componente (ad es.: main, contrib, non-free);
  • origine: specifica il proprietario del repository;
  • etichetta: identifica il repository: potete inserire descrizioni, ecc.;
  • architettura: l' architettura dei pacchetti contenuti nel repository (ad es.: i386, sparc, source, ecc.).

Vediamo i file Release per i repository di questa guida.

Per l' archivio binary abbiamo:

$ cat ~/debian/binary/Release
Archive: unstable
Component: main
Origin: keltik
Label: Repository di esempio
Architecture: i386

e per quello source:

$ cat ~/debian/source/Release
Archive: unstable
Component: main
Origin: keltik
Label: Repository di esempio
Architecture: source

Uso del repository

Uso in locale

Finalmente è venuto il momento di mettere alla prova il nostro repository.

Già fin d'ora possiamo utilizzarlo così com'è in locale sulla nostra macchina: tutto quello che dobbiamo fare consiste nell'aggiungere al nostro file /etc/apt/sources.list l'URI attraverso il quale reperire i pacchetti.

In questo esempio abbiamo creato il repository nella directory ~/debian e cioè nella directory debian all'interno della nostra home. Dovremo quindi aggiungere al file /etc/apt/sources.list due linee così composte:

deb [allow-insecure=yes] file:///home/utente/debian binary/
deb-src [allow-insecure=yes] file:///home/utente/debian source/

dove, alla parola utente dovete sostituire lo username dell'utente nella cui home risiede il repository. L'uso di allow-insecure=yes permette l'uso di un repository non firmato e/o la cui chiave pubblica corrispondente non è stata aggiunta alle chiavi fidate di APT.

Una volta fatto questo lanciate:

 # apt-get update

per rigenerare la lista degli indici di APT.

Ora vediamo se il nostro repository funziona. Iniziamo con il cercare il pacchetto apt. Il comando da impartire è:

$ apt-cache show apt

Se tutto ha funzionato dovremmo ottenere come risultato due diversi pacchetti: entrambi si chiamano apt, entrambi hanno numero di versione 0.5.28.6, ecc. Per capire se e quale proviene dal nostro repository dobbiamo andare a controllare la voce Filename.

Nel caso del pacchetto proveniente dal repository ufficiale di Debian avremo:

[ ... omissis ...]
Filename: pool/main/a/apt/apt_0.5.28.6_i386.deb
[ ... omissis ...]

mentre per il pacchetto proveniente dal nostro repository avremo:

[ ... omissis ...]
Filename: binary/apt_0.5.28.6_i386.deb
[ ... omissis ...]

Per fare in modo che il nostro repository sia usato come preferenziale rispetto agli altri possiamo inserire nel file /etc/apt/sources.list le linee ad esso relativo all'inizio del file, prima di tutti gli altri repository.

In questo modo, quando impartiamo il comando:

 # apt-get install nome_pacchetto

APT provvederà ad installare quello fornito dal repository elencato per primo in /etc/apt/sources.list. Ecco l'esempio sempre relativo ad apt:

# apt-get install apt -s
Lettura della lista dei pacchetti in corso... Fatto
Generazione dell'albero delle dipendenze in corso... Fatto
Pacchetti suggeriti:
  aptitude apt-doc
I seguenti pacchetti saranno aggiornati:
  apt
1 aggiornati, 0 installati, 0 da rimuovere e 1 non aggiornati.
Inst apt [0.5.28.6] (0.5.28.6 Repository di esempio:unstable)
Conf apt (0.5.28.6 Repository di esempio:unstable)

Nelle ultime due linee possiamo notare come la provenienza del pacchetto sia Repository di esempio:unstable come indicato nel nostro file Release.

Uso in rete (http)

Rendere disponibile in rete il repository che abbiamo appena creato è un'operazione estremamente semplice. Non dovremo fare altro che copiare la root del repository in una directory accessibile al nostro server web ed indicare l'URI corretto nei file /etc/apt/sources.list delle macchine che dovranno accedere ad esso.

Nel caso in cui stiamo usando Apache e la DocumentRoot sia /var/www sarà sufficiente impartire:

# cp -R /home/utente/debian/ /var/www/

Ora dobbiamo modificare i file /etc/apt/sources.list in modo che puntino a questo repository.

Poniamo che il server che mette a disposizione il repositry abbia il FQDN debian.prova.net. La sintassi da utilizzare in /etc/apt/sources.list è la seguente:

deb http://debian.prova.net/debian/ binary/
deb-src http://debian.prova.net/debian/ source/

Dobbiamo fare estrema attenzione agli slash ("/") perché hanno un uso preciso all'interno di /etc/apt/sources.list. Nel nostro caso è necessario che sia l'URL (http://debian.prova.net/debian) sia l' archivio (binary o source) termini con un "/", altrimenti otterremo un errore di questo tipo:

# apt-get update
E: La linea x in /etc/apt/sources.list (dist parse) non è corretta

Se abbiamo invece scritto correttamente, quando lanceremo apt-get update, vedremo APT dialogare con il nostro web server e reperire l'elenco dei nostri pacchetti:

# apt-get update
Get:1 http://debian.prova.net binary/ Packages [1377B]
Get:2 http://debian.prova.net binary/ Release [97B]
Get:3 http://debian.prova.net source/ Sources [412B]
Get:4 http://debian.prova.net source/ Release [100B]

Per il test e l'ordine con cui i pacchetti vengono installati da APT, vi rimando alla lettura del paragrafo precedente

Repository ufficiale

Configurazione repository

Per creare un repository ufficiale (fatto a regola d'arte, come quello di debian) per prima cosa installiamo il programma reprepro con il comando:

# apt-get install reprepro

in seguito scegliamo il percorso dove creare il nostro repo (nella guida sarà indicato come ~/debian/) quindi creiamo la cartella e posizioniamovici dentro:

$ mkdir ~/debian/
$ cd ~/debian/

Ora dobbiamo creare un file di configurazione per reprepro quindi:

$ mkdir conf
$ cd conf

dentro creiamo un file chiamato distributions e riempiamolo nel seguente modo:

Origin: nomeMioRepo
Label: Etichetta nomeMioRepo
Suite: unstable
Codename: sid
Architectures: amd64
Components: main
Description: Unofficial Debian packages
SignWith: myKeyId
Warning.png ATTENZIONE
Al posto di myKeyId bisogna insere l'id della chiave GPG creata appositamente per firmare i pacchetti.


ora riposizioniamoci nella cartella debian dando il comando:

cd ~/debian

facciamo creare i file necessari con:

reprepro check

per aggiungere un pacchetto al repo:

reprepro includedeb unstable /tmp/mypackage_1.1.1-1_all.deb

per rimuoverlo:

reprepro remove unstable mypackage

Provvedere a mettere online il repository rendendo accessibile da un server web la cartella debian escludendo le directory db e conf, quindi modificare il file /etc/apt/sources.list aggiungendo la seguente riga:

deb http://www.tuSito.do/debian/ sid main
Bulb.png Suggerimento
Per impedire l'accesso alle directory db e conf si potrebbe creare all'interno di ciascune di essa un file .htaccess contentente:
deny from all


Creazione pacchetto chiave GPG

Per prima cosa esportiamo la nostra chiave con

gpg --export myKeyId > myrepo-debian-key.gpg

In seguito creiamo il seguente alvero di directory (si ricorda che control e myrepo-debian-key.gpg sono files):

├── DEBIAN
│   └── control
└── etc
    └── apt
        └── trusted.gpg.d
            └── myrepo-debian-key.gpg

Inserire all'interno del file control:

Package: myrepo-archive-keyring
Version: 2014.4
Architecture: all
Maintainer: yourNick <mail@domain.do>
Depends: gpgv
Recommends: gnupg
Breaks: apt (<< 0.7.25.1)
Section: misc
Priority: important
Multi-Arch: foreign
Description: GnuPG archive keys of the archive archive
 The archive project digitally signs its Release files. This package
 contains the archive keys used for that.

Il file myrepo-debian-key.gpg è il file precedentemente creato con GPG. Posizionarsi all'esterno della directory pkg e lanciare i seguenti comandi:

# chown -R root:root ./pkg
$ dpkg-deb -b ./pkg myrepo-archive-keyring_2014.4_all.deb

Il pacchetto contiene la chiave per autenticare il repository.



Guida scritta da: Keltik 09:20, Giu 26, 2005 (EDT) Swirl-auth60.png Debianized 60%
Estesa da:
marcomg
Verificata da:
Tima 10:41, 16 mag 2013 (CEST)
marcomg 17:50, 23 mag 2014 (CEST)

Verificare ed estendere la guida | Cos'è una guida Debianized