Creare un Repository Debian: differenze tra le versioni
Nessun oggetto della modifica |
(→Uso in locale: allow-insecure per un repository locale non firmato) |
||
(8 versioni intermedie di 3 utenti non mostrate) | |||
Riga 3: | Riga 3: | ||
|successivo=Gestione di un repository con debarchiver | |successivo=Gestione di un repository con debarchiver | ||
}} | }} | ||
{{Versioni compatibili}} | {{Versioni compatibili|Squeeze|Wheezy|Jessie}} | ||
== Introduzione == | == Introduzione == | ||
La creazione di un repository Debian personale può essere utile nel caso si vogliano rendere disponibili per l'installazione tramite l'[[Introduzione all' | 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. | ||
Esistono fondamentalmente due diversi approcci alla creazione di un repository: | Esistono fondamentalmente due diversi approcci alla creazione di un repository: | ||
Riga 80: | Riga 80: | ||
=== I file di Release === | === I file di Release === | ||
Se volete poter usare il | 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. | ||
Questi file sono chiamati file <code>'''Release'''</code>, sono normali file di testo ed hanno una struttura del tipo: | Questi file sono chiamati file <code>'''Release'''</code>, sono normali file di testo ed hanno una struttura del tipo: | ||
Riga 125: | Riga 125: | ||
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: | 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> | <pre> | ||
deb file:///home/utente/debian binary/ | deb [allow-insecure=yes] file:///home/utente/debian binary/ | ||
deb-src file:///home/utente/debian source/ | deb-src [allow-insecure=yes] file:///home/utente/debian source/ | ||
</pre> | </pre> | ||
dove, alla parola ''utente'' dovete sostituire lo username dell'utente nella cui home risiede il repository. | 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. | ||
Una volta fatto questo lanciate: | Una volta fatto questo lanciate: | ||
Riga 235: | Riga 235: | ||
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: | 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: | ||
<pre>deb http://www.tuSito.do/debian/ sid main</pre> | <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 === | === Creazione pacchetto chiave GPG === | ||
Per prima cosa esportiamo la nostra chiave con | Per prima cosa esportiamo la nostra chiave con | ||
<pre>gpg --export myKeyId > myrepo-debian-key.gpg</pre> | <pre>gpg --export myKeyId > myrepo-debian-key.gpg</pre> | ||
In seguito creiamo | In seguito creiamo il seguente alvero di directory (si ricorda che control e myrepo-debian-key.gpg sono files): | ||
<pre> | <pre> | ||
├── DEBIAN | |||
│ └── control | |||
└── etc | |||
└── apt | |||
└── trusted.gpg.d | |||
└── myrepo-debian-key.gpg | |||
</pre> | </pre> | ||
Inserire all'interno del file control: | |||
<pre>Package: | <pre>Package: myrepo-archive-keyring | ||
Version: 2014.4 | Version: 2014.4 | ||
Architecture: all | Architecture: all | ||
Riga 266: | Riga 264: | ||
contains the archive keys used for that. | contains the archive keys used for that. | ||
</pre> | </pre> | ||
Il file myrepo-debian-key.gpg è il file precedentemente creato con GPG. | |||
Posizionarsi all'esterno della directory pkg e lanciare i seguenti comandi: | Posizionarsi all'esterno della directory pkg e lanciare i seguenti comandi: | ||
<pre> | <pre> | ||
# chown -R root:root ./pkg | # chown -R root:root ./pkg | ||
$ dpkg-deb -b ./pkg | $ dpkg-deb -b ./pkg myrepo-archive-keyring_2014.4_all.deb | ||
</pre> | </pre> | ||
Il pacchetto contiene la chiave per autenticare il repository. | Il pacchetto contiene la chiave per autenticare il repository. | ||
Riga 277: | Riga 275: | ||
|Verificata_da= | |Verificata_da= | ||
: [[Utente:Tima|Tima]] 10:41, 16 mag 2013 (CEST) | : [[Utente:Tima|Tima]] 10:41, 16 mag 2013 (CEST) | ||
: [[Utente:Marcomg|marcomg]] 17:50, 23 mag 2014 (CEST) | |||
|Estesa_da= | |Estesa_da= | ||
: [[Utente:Marcomg|marcomg]] | : [[Utente:Marcomg|marcomg]] | ||
|Numero_revisori=2 | |Numero_revisori=2 | ||
}} | }} | ||
[[Categoria:Creare repository]] | [[Categoria:Creare repository]] |
Versione attuale delle 07:46, 14 lug 2019
|
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. |
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
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
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) | Debianized 60% |
Estesa da: | |
Verificata da: | |
Verificare ed estendere la guida | Cos'è una guida Debianized |