# [Risolto] Creazione stage 4 per installazione

## zar Marco

Ciao a tutti, ho letto L'HOW-TO per creare uno stage 4 come backup però vorrei fare una cosa un pelo diversa.

Allora io vorrei crearmi uno stage 4 da usare per l'installazione al posto dello stage 3.

Se ho inteso bene L'HOW-TO, esso crea una copia di tutti i pacchetti attualmente installati. 

Ma se io volessi crearlo con solo certi determinati pacchetti? Come potrei muovermi? 

La mia scarsa anglofonia non mi aiuta, però ho cercato e non ho trovato nullaLast edited by zar Marco on Wed May 22, 2019 3:00 pm; edited 1 time in total

----------

## oscarandrea

 *zar Marco wrote:*   

> Ciao a tutti, ho letto L'HOW-TO per creare uno stage 4 come backup però vorrei fare una cosa un pelo diversa.
> 
> Allora io vorrei crearmi uno stage 4 da usare per l'installazione al posto dello stage 3.
> 
> Se ho inteso bene L'HOW-TO, esso crea una copia di tutti i pacchetti attualmente installati. 
> ...

 

credo che dovresti dare un occhiata a Catalyst https://wiki.gentoo.org/wiki/Catalyst

----------

## zar Marco

Grazie mille, ora ci do una bella occhiata

----------

## sabayonino

se hai bisogno solo di determinati pacchetti , puoi crearti i binari dei soli pacchetti che ti interessano .

https://wiki.gentoo.org/wiki/Binary_package_guide

(e) semplicemente crearti un tuo set

https://wiki.gentoo.org/wiki//etc/portage/sets

----------

## zar Marco

Permettete una domanda molto nubbia, ma all'interno di uno stage3 i pacchetti presenti sono dei binari giusto? Che vengono ricompilati solo una volta scelto il profilo e lanciato un @world?

----------

## fedeliallalinea

 *zar Marco wrote:*   

> Permettete una domanda molto nubbia, ma all'interno di uno stage3 i pacchetti presenti sono dei binari giusto? Che vengono ricompilati solo una volta scelto il profilo e lanciato un @world?

 

No non vengono ricompilati se non c'e' un aggiornamento del pacchetto in questione.

----------

## zar Marco

 *sabayonino wrote:*   

> se hai bisogno solo di determinati pacchetti , puoi crearti i binari dei soli pacchetti che ti interessano .
> 
> https://wiki.gentoo.org/wiki/Binary_package_guide
> 
> (e) semplicemente crearti un tuo set
> ...

 

Quindi, mi conviene creare i binari ed inserirli in /etc/portage/sets? 

Poi se da qui volessi inserirli in uno stage per creare il mio personale stage 4?

Potrei scaricare uno stage 3, scompattarlo, inserirci la cartella con i binari e ricompattarlo?

----------

## sabayonino

Guarda che lo stage4 non è altro che un archivio , backup del tuo sistema , completo o incompleto che sia.

----------

## zar Marco

Sì sì lo so, ma volevo appunto farne uno incompleto, o per meglio dire con solo ciò che voglio, così per imparare in primis, e poi per eventualmente provare un installazione cambiando fs

----------

## sabayonino

Guarda questo questo script di installazione di Ago se può interessarti a velocizzare l'installazione

Leggi molto bene le indicazioni.

Ovviamente per le personalizzazioni più estreme non è adatto

----------

## sabayonino

 *zar Marco wrote:*   

> Sì sì lo so, ma volevo appunto farne uno incompleto, o per meglio dire con solo ciò che voglio, così per imparare in primis, e poi per eventualmente provare un installazione cambiando fs

 

Lo scopo dello stage4 è proprio (anche) questo.

Ti fai un sistema base generico (magari senza il DE) , con i vari tools e kernel installati , lo "tarri" e lo puoi utilizzare come base per altre installazioni dove richiedono configurazioni simili e con i pacchetti base già pronti che non sono inclusi nello stage3.

----------

## zar Marco

Sì ci avevo già dato un occhio, quello che mi sfugge è il concetto di selezione dei pacchetti, lo stesso Ago mi ha consigliato di prendere uno stage 3 scompattarlo in una cartella, installare quello che voglio e poi ricompattarlo.

Però pensavo anche di fare una cosa mista, cioè installo tipo le cose base, magari tipo xorg, e poi inserire i binari per esempio per il de, in maniera da avere un sistema di installazione velocizzato. 

Non so se mi son spiegato bene

----------

## sabayonino

Se intendi inserire il tbz2 (il binario creato) ello stage3 , si puoi farlo ma tieni conto che la dimensione dell'archivio poi aumenta.

Inoltre ci sono situazioni nelle quali il binario(o alcuni binari , dipende da cosa si sta facendo)  perde il suo scopo se si cambiano le useflag perchè il pacchetto stesso richiede una ricompilazione

Newlla sezione relativa alla gestione dei binari del manuale di emerge ci sono varie opzioni per la gestione della cosa.

Oppure tieni una cartella dedicata al chroot e la aggiorni di ogni tanto e/o la comprimi 

Di swoluzioni alla cosa ce ne sono molte , devi solo trovare quella che più fa alle tue esigenze.

----------

## ilnanny

 *sabayonino wrote:*   

>  Oppure tieni una cartella dedicata al chroot e la aggiorni di ogni tanto e/o la comprimi .

 

Che cosa interessante se capissi un pò meglio di come strutturarla sarebbe l'ideale per crearmi il mio openbox ideale ,che richiede più di qualche software che non esiste negli ebuild neanche su zugaina (ed io non li sò creare)

Non è che sapresti indicarmi qualche discussione in merito ?

non sono riuscito a trovare bene la parola chiave per una ricerca sul web .

Edit .

Non serve più alcuna guida ,visto il commento esaustivo qui sotto da parte di @ago .

Grazie  :Laughing: 

----------

## ago

@Marco

visto che ne abbiamo parlato più di una volta....mi sfugge cosa non ti è chiaro.

Per creare uno stage4, devi:

- scaricare uno stage3 ( come se stessi effettuando un'installazione )

- fare chroot ( come se stessi effettuando un'installazione )

- effettuare le modifiche che vuoi, emergi roba, modifichi configurazioni ( come se stessi effettuando un'installazione )

- smontare le partizioni e creare un tar della cartella dove hai scompattato tutto in origine

Se vuoi creare uno stage4 del tuo sistema puoi farlo con:

```

cd /

tar -czpf stage4.tar.gz bin boot etc home lib lib32 lib64 mnt opt root sbin usr var

```

Assicurati di aver stoppato demoni come mysql.

Se vuoi evitare di fare lo stage4 mentre i programmi girano, puoi farlo da live o da altro sistema operativo avviato.

Ciao

----------

## zar Marco

Posso finalmente mettere risolto.

Ringrazio tutti quanti, so che è stato quasi un parto  :Very Happy:  , però alla fine ci sono riuscito.

Ora ho il mio bel stage 4 creato e funzionante per una futura installazione.

Per crearlo ho creato una cartella nella mia home, ci ho scompattato dentro lo stage 3, chrootato dentro, impostato il make.conf ed installato quello che mi serviva 

Mi rimangono solo due piccoli dubbi:

1- è possibile inserire un kernel già funzionante? Ma non è molto importante questo.

2- se io volessi aggiungere qualche altro pacchetto, poi devo ricreare l'intero archivio, oppure posso fare il tar delle sole differenze? (questa è una pura curiosità)

----------

## oscarandrea

 *zar Marco wrote:*   

> Posso finalmente mettere risolto.
> 
> Ringrazio tutti quanti, so che è stato quasi un parto  , però alla fine ci sono riuscito.
> 
> Ora ho il mio bel stage 4 creato e funzionante per una futura installazione.
> ...

 

per il kernel non vedo perché no, solo che non puoi configurarti a priori grub se non sai come configurerai la nuova installazione

per l'archivio credo che concettualmente vada bene fare le differenze

----------

## sabayonino

L'incrementale di TAR :

l'opzione -g permette di farlo

```
-g, --listed-incremental=FILE

              Handle new GNU-format incremental backups.  FILE is the name of a snapshot file, where tar stores additional information which is used to decide  which

              files changed since the previous incremental dump and, consequently, must be dumped again.  If FILE does not exist when creating an archive, it will be

              created and all files will be added to the resulting archive (the level 0 dump).  To create incremental archives of non-zero level N, create a copy  of

              the snapshot file created during the level N-1, and use it as FILE.

              When  listing  or  extracting, the actual contents of FILE is not inspected, it is needed only due to syntactical requirements.  It is therefore common

              practice to use /dev/null in its place
```

Ti consiglio di documentarti bene ed effettuare varie prove (soprattuto di ripristino) , non necessariamente devi eseguire un ripristino del sistema ma provare su directory non importanti giusto per prender confidenza con il meccanismo.

In rete trovi parecchi esempi di backup incrementali con TAR .

----------

## zar Marco

Sì sì infatti o domani o giovedì andrò a sostituire l'hdd con dentro la home mettendo un ssd, potrei provare a fare un incrementale della home e poi andare a restornare quella. Mal che vada ricreo la home

----------

## sabayonino

Ecco uno script fatto un pò velocemente , molto basico di backup incrementale (nell'esempio , la /home/utente)

```

#!/bin/bash

# La directory da effettuare il backup

SOURCEDIR="/home/$USER"

# Il nome dell'archivio prende il nome dell'ultimo elemento della directory

# Esempio /home/foo --> 00-full-foo.tar.xz

# Esempio /etc --> 00-full-etc.tar.xz

TYPE="$(basename ${SOURCEDIR})"

# Se viene indicato come directory da salvare la "/" , il nome viene impostato in "root-fs"

# per evitare di avere "/" nel nome del file

# il comando "basename /" restituisce "/"

# Il comandp "basename /etc restituisce "etc"

# e così via . 

if [[ "${TYPE}" == "/" ]] ; then

        TYPE="root-fs"

fi

if [[ "${TYP

# La directory dove salvare il backup

BASEDIR="/backups"

# Definiamo la sottodirectory di salvataggio

# nell'esempio nel formato YYYYMM (201906 --> Giugno del 2019)

FORMAT="$(date +%Y%m)"

# Definiamo la directory del mese precedente se presente

OLDARCH="$(date -r ${BASEDIR}/${FORMAT}  | date -d '1 month ago' +%Y%m)"

# Viene creata la nuova dorectory se non è prsente

if [[ ! -d ${BASEDIR}/${FORMAT} ]] ; then

        mkdir -p ${BASEDIR}/${FORMAT}

        # Se esiste la directory precedente ne viene creato un semplice archivio non compresso

        # e viene rimossa la directory

        if [[ -d ${BASEDIR}/${OLDARCH} ]] ; then

                tar -cpf ${BASEDIR}/${OLDARCH}.tar -C ${BASEDIR} ${OLDARCH}

                if [ $? -eq 0 ] ; then

                        rm -rf ${BASEDIR}/${OLDARCH} 2>/dev/null

                fi

                # Vengono i rimossi gli archivi più vecchi di 4 mesi o 120 giorni

                find ${BASEDIR} -maxdepth 1  -type f -name '*.tar' -mtime +120 -delete

        fi

fi

# Il file dove viene tenuta traccia dei cambiamenti

IDXFILE="${BASEDIR}/${FORMAT}/incremental.idx"

# Opzione personalizzabile da passare a TAR

TAROPTS="--ignore-failed-read --sparse --xattrs --auto-compress --exclude-caches-all --exclude-backups --one-file-system --absolute-names --numeric-owner"

# Il file delle esclusioni nel caso si volìglia escludere files o directory dal backup

TAROPTS+=" --exclude-from=/backups/exclude_file"

# Il comando da passare per creare l'incrementale

TAROPTS+=" --listed-incremental=${IDXFILE}"

# Funzione pre creare il primo backup completo

# Il nome del backup conterrà la data del giorno

FULL_BK () {

        if [ $(ls ${BASEDIR}/${FORMAT} | wc -l) -gt 1 ] ; then

                echo "Un backup completo è già presente , verrà effettuato un backup incrementale."

                INCR_BK

        else

                tar ${TAROPTS} -cpaf ${BASEDIR}/${FORMAT}/$(date +%d)-full-${TYPE}.tar.xz ${SOURCEDIR}

fi

}

# Funzione per creare un backup incrementale giornaliero

# Il nome del backup conterrà la data del giorno

INCR_BK () {

        if [[ -f ${BASEDIR}/${FORMAT}/$(date +%d)-incr-home.tar.xz ]] ; then

                echo "Il file incrementale è già presente.Uscita"

                exit 0

        else

                tar ${TAROPTS} -cpaf ${BASEDIR}/${FORMAT}/$(date +%d)-incr-${TYPE}.tar.xz ${SOURCEDIR}

        fi

}

# Richiama la funzione

FULL_BK

```

In pratica crea :

la directory YYYYMM (Esempio : 201906 ossia Giugno 2019)

All'interno vengono salvati : Nr.1 backup completo , Nr.X backup incrementali ed il file indice

Al mese successivo viene creata la nuova directory 

Quella precedente viene archiviata in un semplice tar non compresso

La vecchia directory viene rimossa

I vecchi archivi vengono rimossi (Nell'esempio quelli più vecchi di 120 giorni)

Ovviamente può essere migliorato/modificato ... l'ho fatto un pà di fretta ma dovrebbe essere sufficiente.

Basta modificare i percorsi ed il target

Per le opzioni che ho passato , una buona lettura al manuale di TAR

Il contenuto del file delle esclusioni potrebbe avere un contenuto simile a questo :

```

/home/saba/.cache

/home/saba/.local/share/baloo

/home/saba/.local/share/Trash

/home/saba/Scaricati

/home/saba/Downloads

**.iso

```

```
localhost /backups/201906 $ ls -lh

totale 563M

-rw-r--r-- 1 saba saba 543M 19 giu 14.34 19-full-home.tar.xz

-rw-r--r-- 1 saba saba  19M 19 giu 14.37 19-incr-home.tar.xz

-rw-r--r-- 1 saba saba 771K 19 giu 14.37 incremental.idx

```

 :Wink: 

Buon backup

----------

## zar Marco

Wow che figata, grazie mille domani me lo leggo per benino

----------

## sabayonino

Qui uno scriptino veloce per il rispristino dgli archivi creati con lo script precedente

Lo script cerca i *.tar dove sono archiviati i backups , li scompatta dopo che sono state indicate le varie directory di sorgente/destinazione

```

#!/bin/bash

clear

# Colori di primo piano

RST="\033[0m"

BLACK="\033[30m"

BLUE="\033[34m"

CYAN="\033[36m"

GREEN="\033[32m"

PURPLE="\033[35m"

RED="\033[31m"

WHITE="\033[37m"

YELLOW="\033[33m"

RESTOREDEF="/mnt/restore"

echo -e $GREEN"Ripristino degli archivi differenziali"$RST

echo

echo -en "Punto di montaggio della directory archivi  : " ; read BASESRC

if [[ ! -d "${BASESRC}" ]] ; then

        echo "Il punto di montaggio degli archivi indicato non esiste. Uscita"

        exit 1

else

        echo -en "Indicare la directory di ripristino [ ${RESTOREDEF} ] : " ; read RESTDIR

        if [[ -z "${RESTDIR}" ]] ; then

                mkdir -p "${RESTOREDEF}"

                RESTDIR="${RESTOREDEF}"

        else

                mkdir -p "${RESTDIR}"

        fi

fi

echo

ARCHIVES=($(ls "${BASESRC}" | grep -e "\.tar$"))

echo

if [[ -z ${ARCHIVES[@]} ]] ; then

        echo -e "Nessun archivio di backup presente in $CYAN"${BASESRC}$RST". "

        exit 0

else

        echo -e $GREEN"La directory contiene i seguenti archivi"$RST

fi

PS3="Archivio N. da riprisinare > "

select RESTORE in ${ARCHIVES[@]} ; do

        tar -xpf ${RESTDIR}/${RESTORE} -C ${RESTDIR}

        ARCHDIR=${RESTORE%\.*}

        clear

        echo -e $GREEN"Elenco degli archivi di backups"$RST

        echo

        FILES=($(ls ${BASESRC}/${ARCHDIR} | grep -e '[0-9]'))

        echo

        PS3="Ripristinare fino al backup N. > "

        select BACKUPS in ${FILES[@]} ; do

                if [[ -z ${BACKUPS} ]] ; then

                        echo "Selezione errata."

                        exit 1

                fi

                DAY="${BACKUPS:0:2}"

                for i in ${FILES[@]} ; do

                        if [[ "${i:0:2}" > "${DAY}" ]] ; then

                                echo

                                echo "L'ultimo archivio è stato estratto."

                                exit 0

                        fi

                        echo -e "Estrazione archivio < $CYAN $i $RST > "

                        echo -e $PUPRLE

                        tar --totals --warning=none -xpf ${BASESRC}/${ARCHDIR}/${i} -C "${RESTDIR}"

                        echo -e $RST

                done

                exit 0

        done

done

```

Esecuzione : 

```
Ripristino degli archivi

Punto di montaggio della directory archivi  : /backups

Indicare la directory di ripristino [ /mnt/restore ] : /run/media/saba/HDBACKUP

La directory contiene i seguenti archivi

1) 201906.tar

Archivio N. da riprisinare > 1

Elenco degli archivi di backups

1) 19-full-home.tar.xz  3) 20-incr-home.tar.xz

2) 19-incr-home.tar.xz  4) 21-incr-home.tar.xz

Ripristinare fino al backup N. > 4

Estrazione archivio <  19-full-home.tar.xz  > 

tar: Rimozione di "/" iniziale dai nomi dei membri

Byte totali letti: 1474529280 (1,4GiB, 34MiB/s)

Estrazione archivio <  19-incr-home.tar.xz  > 

tar: Rimozione di "/" iniziale dai nomi dei membri

Byte totali letti: 99461120 (95MiB, 43MiB/s)

Estrazione archivio <  20-incr-home.tar.xz  > 

tar: Rimozione di "/" iniziale dai nomi dei membri

Byte totali letti: 230645760 (220MiB, 29MiB/s)

Estrazione archivio <  21-incr-home.tar.xz  > 

tar: Rimozione di "/" iniziale dai nomi dei membri

Byte totali letti: 181432320 (174MiB, 29MiB/s)

```

----------

## sabayonino

Un altro scriptino meno elaborato ma abbastanza efficace , sempre per backup incrementale potrebbe essere il seguente (con un pò di fantasia se ne possono fare di tutte le salse) :

```
#!/bin/bash

BACKDIR=/backups/test

if [[ ! -d ${BACKDIR} ]] ; then

        mkdir ${BACKDIR}

fi

DATEFORMAT="$(date +%b-%d-%y%s)"

SOURCEDIR="/etc"

TYPE="$(basename "${SOURCEDIR}")"

if [[ "${TYPE}" == "/" ]] ; then

        TYPE="system-root"

fi

NAME="${DATEFORMAT}-${TYPE}.txz"

KEEP=5 #  Vengono tenuti 5 files il primo è sempre il backup completo , i restanti sono i differenziali

KEEPARCH=2 # Vengono rimossi archivi .tar più vechi di N. giorni

MOVEARCH=0 # Se impostata su 1 gli archivi .tar vengono spostati in una specifica directory (Esempio un disco esterno)

ARCHDIR="/backups/move"

TAROPTS="--totals --ignore-failed-read --sparse --xattrs --auto-compress --exclude-caches-all --exclude-backups --one-file-system --absolute-names --numeric-owner"

TAROPTS+=" --exclude-from=/backups/exclude_file"

# Spostamento degli archivi su un percorso differente (esempuio un disco esterno)

if [ ${MOVEARCH} -eq 1 ] ; then

        rsync --remove-source-files -azphS ${BACKDIR}/*.tar ${ARCHDIR}/ &>/dev/null

fi

# Pulizia del percorso differente (Esempio un disco esterno)

if [ $(ls ${ARCHDIR}/*.tar 2>/dev/null | wc -l) -ge ${KEEPARCH} ] ; then

        find ${ARCHDIR} -type f -name '*.tar' -mtime +${KEEPARCH} -delete

fi

# Backup della directory interessata

tar -g ${BACKDIR}/index ${TAROPTS} -cpaf ${BACKDIR}/${NAME} -C ${SOURCEDIR} ./

# Se fli archivi differenziali equivalgno al valore impostato su KEEP , ne viene creato un archivio semplice

# I files differenziali originali vengono rimossi

if [ $(ls ${BACKDIR}/*.txz | wc -l) -ge ${KEEP} ] ; then

        cd ${BACKDIR}

        tar --remove-files -cpf ${BACKDIR}/${DATEFORMAT}.tar *.txz

        rm ${BACKDIR}/index # Viene rimosso anche l'indice degli archivi precedenti

        # Se non viene impostato un percorso alternativo per gli archivi , viene ripulita la directory principale

        if [ ${MOVEARCH} -eq 0 ] ; then

                find ${BACKDIR} -type f -name '*.tar' -mtime +${KEEPARCH} -delete

        fi

fi

```

Il primo backup ' sempre quello full , a seguire quelli incrementali questa volta con un formato data del tipo :

giu-22-191561226571 (saranno sempre ordinati dal più vecchio al più recente)

All'interno puoi impostare quanti incrementali effettuare per poi archiviarli (nella stessa directory o in un altra directory)

Puoi eventualmente tenere gli archivi più recenti di "N" giorni.

Ovviamente è migliorabile ... ma per poche esigenze e tirato su in fretta e furia non si può pretendere troppo   :Rolling Eyes: 

----------

## zar Marco

Più vi leggo più mi sento analfabeta funzionale eh eh   :Shocked: 

Devo studiarmi bene questi script, in maniera di arrivare a capirli nella maniera corretta

----------

