GNU/Linux >> Linux Esercitazione > >> Panels >> Docker

Come installare OpenVZ su Debian 9

Cos'è OpenVZ?

OpenVZ è uno strumento di virtualizzazione del sistema operativo basato su software che consente la distribuzione, la gestione e la modifica di ambienti Linux virtuali isolati dall'interno di una distribuzione Linux host. Un'ampia gamma di modelli di sistemi operativi predefiniti in una varietà di distribuzioni Linux consente agli utenti di scaricare e distribuire rapidamente ambienti virtuali con facilità.

Prima di iniziare

L'esecuzione di questo tutorial richiede un account utente root e viene scritto come se i comandi venissero emessi come utente root. I lettori che scelgono di utilizzare un account utente limitato dovranno anteporre ai comandi sudo dove richiesto. Se devi ancora creare un account utente limitato, segui i passaggi nella guida Configurazione e protezione di un'istanza di calcolo.
Le istruzioni in questa guida sono state scritte e testate solo su Debian 9. È improbabile che funzionino con altre distribuzioni Debian o Ubuntu.
Per eseguire OpenVZ sono necessarie alcune modifiche essenziali al tuo sistema Debian 9, inclusa la rimozione e la sostituzione di Systemd con SystemV e l'uso di un kernel Linux personalizzato. Prima di continuare, accertarsi che tutto il software attualmente installato sulla macchina sia compatibile con queste modifiche.

Nota Sebbene non sia necessario, si consiglia di creare una partizione del filesystem Ext4 separata per i modelli OpenVZ. Per impostazione predefinita, sia il programma di installazione Debian 9 che Linode Manager formattano le partizioni appena create con Ext4. Per informazioni su come eseguire questa configurazione, segui i passaggi per creare un disco nella guida Gestione dei dischi e archiviazione su un Linode.

Facoltativo:crea una partizione separata per i modelli OpenVZ

Se intendi dedicare un intero Linode VPS all'esecuzione di OpenVZ e nessun altro servizio, ti consigliamo di creare partizioni separate per il server host e i suoi processi, e qualsiasi modello di server virtuale OpenVZ. La tabella seguente illustra lo schema di partizionamento consigliato:

Partizione	Descrizione	Dimensione tipica
/	Partizione radice	4-12 GB
scambia	Partizione di paging	2 volte RAM o RAM + 2 GB (a seconda dello spazio disponibile sul disco rigido)
/vz	Partizione per ospitare modelli OpenVZ	Tutto lo spazio rimanente sul disco rigido

Accedi al tuo Linode Manager e seleziona il tuo Linode. Spegnere la macchina e verificare il completamento del lavoro visualizzando la Coda lavori host sezione. Sotto i Dischi scheda, fai clic su Crea un nuovo disco . Aggiungi un'etichetta a tua scelta, seleziona "ext4" nel Tipo menu a discesa e alloca quanto più spazio possibile nella Dimensione campo. Fai clic su Salva modifiche; una configurazione ottimale assomiglierà all'immagine qui sotto.
Sotto la Dashboard scheda, fai clic sul tuo profilo di configurazione principale. Sotto Blocca assegnazione dispositivo scheda, assegna la tua nuova partizione a un dispositivo aperto. Fai clic su Salva modifiche al termine.
Avvia il Linode e accedi tramite SSH. Emettere il comando seguente per verificare che il nuovo disco sia stato creato correttamente. L'output mostrerà il disco appena creato.
```
fdisk -l
```
Crea un punto di montaggio per il nuovo dispositivo:
```
 mkdir /vztemp
```
Monta il nuovo disco. Assicurati di sostituire /dev/sdc con il nome del tuo dispositivo:
```
 mount /dev/sdc /vztemp
```

Rimuovi la funzione Metadata_csum dai volumi Ext4

Prima di poter installare OpenVZ, il sistema deve essere configurato per la compatibilità. Debian 9 supporta una nuova funzionalità di checksum incompatibile con i kernel OpenVZ personalizzati. A seconda delle tue preferenze, puoi scegliere di rimuovere metadata_csum da una partizione montata o riformattare la partizione interessata in un volume Ext4 compatibile. Scegli uno dei metodi e segui le istruzioni nella sezione appropriata di seguito.

Elenca le partizioni del disco disponibili.
```
 lsblk
```
Controlla se "metadata_csum" è installato in qualsiasi partizione del disco montata mostrata nel passaggio 1 (esclusa la partizione SWAP). Segui il formato seguente per ciascuna partizione, sostituendo /dev/sda1 con il nome del volume appropriato. Se il comando seguente non produce output per i volumi del disco montati, puoi saltare questa sezione.
```
 dumpe2fs -h /dev/sda1 2>/dev/null | grep -e metadata_csum
```

Rimuovi Metadata_csum dalle partizioni montate

Emetti i comandi seguenti per aggiungere codice a fsck file:

 echo "copy_exec /sbin/e2fsck" | sudo tee -a /usr/share/initramfs-tools/hooks/fsck
 echo "copy_exec /sbin/tune2fs" | sudo tee -a /usr/share/initramfs-tools/hooks/fsck

Crea un nuovo file nella directory indicata di seguito e chiamalo tune . Copia e incolla il testo qui sotto in questo nuovo file e salva:
File:/ etc/initramfs-tools/scripts/local-premount/tune
1 2 3 4 5 6 7 8 9

#!/bin/sh if [ "$readonly" != "y" ] ; then exit 0 ; fi e2fsck -f $Volume tune2fs -O -metadata_csum $Volume e2fsck -f $Volume
Aggiorna le proprietà del file e l'immagine initramfs esistente per caricare il tune sceneggiatura:
```
 chmod 755 /etc/initramfs-tools/scripts/local-premount/tune
 update-initramfs -u -k all
```
Riavvia il sistema ed esegui il comando seguente per verificare che metadata_csum sia stato disabilitato da tutte le partizioni interessate. Di nuovo, sostituisci "/dev/sda1" con i nomi di volume corretti.
```
 dumpe2fs -h /dev/sda1 2>/dev/null | grep -e metadata_csum
```

Formatta un volume Ext4 compatibile

Scegli il volume Ext4 che desideri formattare ed esegui il comando seguente, sostituendo /dev/sda3 con il volume selezionato. Un output di "0" indica il successo.

Attenzione Formattazione di un volume con mkfs comando potrebbe causare la perdita di dati.
```
 mkfs -t ext4 -O -metadata_csum /dev/sda3
```

Sostituisci Systemd con SystemV

Installa le utilità SystemV.

 apt install sysvinit-core sysvinit-utils

Da Linode Manager, riavvia la macchina per rilasciare Systemd.
Rimuovi Systemd dalla tua macchina:
```
 apt --auto-remove remove systemd
```
Crea il file avoid-systemd e incolla il contenuto qui sotto:
File:/ etc/apt/preferences.d/avoid-systemd
1 2 3

Package: *systemd* Pin: release * Pin-Priority: -1

Aggiungi repository OpenVZ

Crea un nuovo file sorgente del repository e incolla il contenuto di seguito:
File:/ etc/apt/sources.list.d/openvz.list
```
deb http://download.openvz.org/debian jessie main
deb http://download.openvz.org/debian wheezy main
```

Aggiungi la chiave del repository al tuo sistema:

 wget -qO - http://ftp.openvz.org/debian/archive.key | sudo apt-key add -

Alla data di pubblicazione di questa guida, la chiave del repository OpenVZ non è valida e sta emettendo l'apt update comando genererà un avviso dal sistema. Il comando dovrebbe riuscire. In caso contrario, aggiorna il sistema con il seguente argomento:
```
 apt --allow-unauthenticated update
```

Installa pacchetti OpenVZ

Installa OpenVZ con i pacchetti richiesti.

 KPackage="linux-image-openvz-$(dpkg --print-architecture)"
 sudo apt --allow-unauthenticated --install-recommends install $KPackage vzdump ploop initramfs-tools dirmngr

L'installazione dovrebbe creare una nuova directory, /vz . Se questa directory non esiste dopo l'installazione, creare un collegamento simbolico utilizzando il comando seguente:
```
 ln -s /var/lib/vz/ /vz
```
Crea il file vznet.conf e incolla nella riga sottostante:
File:/ etc/vz/vznet.conf
1

EXTERNAL_SCRIPT="/usr/sbin/vznetaddbr"
Questo passaggio è facoltativo e causerà l'arresto delle istanze virtuali OpenVZ quando il servizio OpenVZ viene interrotto. Se si desidera questo comportamento, eseguire il comando seguente.
```
 echo 'VE_STOP_MODE=stop' | sudo tee -a /etc/vz/vznet.conf
```

Avvia nel kernel OpenVZ

Il sistema deve essere configurato per avviare il kernel OpenVZ ogni volta che il server viene riavviato.

Apri il grub.cfg file in less o il tuo editor di testo preferito:
```
 less /boot/grub/grub.cfg
```

All'interno di grub.cfg file, cerca una sezione simile alla seguente:

File:/ boot/grub/grub.cfg

. . .

menuentry 'Debian GNU/Linux' --class debian --class gnu-linux --class gnu --class os $menuentry_id_option 'gnulinux-simple-e025e52b-91c4-4f64-962d-79f244caa92a' {
    gfxmode $linux_gfx_mode
    insmod gzio
    if [ x$grub_platform = xxen ]; then insmod xzio; insmod lzopio; fi
    insmod ext2
    set root='hd0'
    if [ x$feature_platform_search_hint = xy ]; then
        search --no-floppy --fs-uuid --set=root --hint-bios=hd0 --hint-efi=hd0 --hint-baremetal=ahci0  e025e52b-91c4-4f64-962d-79f244caa92a
    else
        search --no-floppy --fs-uuid --set=root e025e52b-91c4-4f64-962d-79f244caa92a
    fi
    echo    'Loading Linux 4.9.0-3-amd64 ...'
    linux   /boot/vmlinuz-4.9.0-3-amd64 root=/dev/sda ro console=ttyS0,19200n8 net.ifnames=0
    echo    'Loading initial ramdisk ...'
    initrd  /boot/initrd.img-4.9.0-3-amd64
    }
submenu 'Advanced options for Debian GNU/Linux' $menuentry_id_option 'gnulinux-advanced-e025e52b-91c4-4f64-962d-79f244caa92a'

. . .

Copy the text entry preceeding `submenu`, in this example the text would be: **Advanced options for Debian GNU/Linux**.

All'interno di grub.cfg file sotto la riga "sottomenu", vedrai più sezioni "menuentry" rientrate. Questi rappresentano i kernel disponibili. Da questi, è necessario individuare la voce di menu del kernel OpenVZ appena installata. Dovrebbe essere simile al contenuto qui sotto. Nota che alcuni saranno kernel di ripristino e dovrebbero essere ignorati:

File:/ boot/grub/grub.cfg

. . .

    menuentry 'Debian GNU/Linux, with Linux 2.6.32-openvz-042stab123.9-amd64' --class debian --class gnu-linux --class gnu --class os $menuentry_id_option 'gnulinux-2.6.32-openvz-042stab123.9-amd64-advanced-e025e52b-91c4-4f64-962d-79f244caa92a' {
            gfxmode $linux_gfx_mode
            insmod gzio
            if [ x$grub_platform = xxen ]; then insmod xzio; insmod lzopio; fi
            insmod ext2
            set root='hd0'
            if [ x$feature_platform_search_hint = xy ]; then
              search --no-floppy --fs-uuid --set=root --hint-bios=hd0 --hint-efi=hd0 --hint-baremetal=ahci0  e025e52b-91c4-4f64-962d-79f244caa92a
            else
              search --no-floppy --fs-uuid --set=root e025e52b-91c4-4f64-962d-79f244caa92a
            fi
            echo    'Loading Linux 2.6.32-openvz-042stab123.9-amd64 ...'
            linux   /boot/vmlinuz-2.6.32-openvz-042stab123.9-amd64 root=/dev/sda ro console=ttyS0,19200n8 net.ifnames=0
            echo    'Loading initial ramdisk ...'
            initrd  /boot/initrd.img-2.6.32-openvz-042stab123.9-amd64
    }

. . .

  Again, write down the text directly after "menuentry" in single quotes. Here, the text to copy is **Debian GNU/Linux, with Linux 2.6.32-openvz-042stab123.9-amd64**.

Chiudi il grub.cfg file e apri /etc/default/grub nel tuo editor di testo preferito. Individua la riga che inizia con GRUB_DEFAULT= . Elimina il valore predefinito per questo parametro e inserisci il testo copiato nei passaggi precedenti, seguendo il formato seguente. Con l'esempio sopra, il valore sarebbe il seguente:
```
 GRUB_DEFAULT="Advanced options for Debian GNU/Linux>Debian GNU/Linux, with Linux 2.6.32-openvz-042stab123.9-amd64"
```
Nota che entrambe le stringhe copiate sono separate dal carattere ">" della carota.
Salva e chiudi il grub file ed emettere il comando seguente per ricaricare il bootloader grub con il nuovo valore del kernel:
```
 update-grub
```
Per impostazione predefinita, il caricamento del kernel non è gestito da Grub, ma da Linode Manager. Accedi al tuo Linode Manager e seleziona il tuo Linode. Clicca sul tuo profilo di configurazione. Nella sezione "Impostazioni di avvio", seleziona "GRUB 2" dall'elenco a discesa del kernel (vedi immagine sotto). Salva le modifiche ed esci.
Riavvia il tuo server ed emetti il comando seguente per verificare che il kernel OpenVZ sia stato caricato:
```
 uname -r
```
Se il kernel OpenVZ non è stato caricato, è molto probabile che sia grub file che è configurato in modo errato. Controlla e assicurati che il kernel corretto sia stato scelto e inserito correttamente.

Scarica e distribuisci un modello di sistema operativo

Avvia il servizio OpenVZ:
```
 service vz start
 service vz status
```

Registrati con il repository di modelli OpenVZ ufficiale:

 sudo gpg --recv-keys $(echo $(sudo gpg --batch --search-keys [email protected] 2>&1 | grep -ie ' key.*created' | sed -e 's|key|@|g' | cut -f 2 -d '@') | cut -f 1 -d ' ' | cut -f 1 -d ',')

Modifica /etc/vz/vz.conf e cambia la riga seguente per usare simfs invece di ploop :
File:/ etc/vz/vz.conf
1

VE_LAYOUT=simfs
Elenca i modelli di sistema operativo disponibili per il download:
```
 vztmpl-dl --list-remote
```
Dall'elenco disponibile di modelli, selezionane uno da scaricare. Utilizzando il formato seguente, immetti il seguente comando, sostituendo centos7-x86_64 con il modello che hai selezionato:
```
 vztmpl-dl --gpg-check centos7-x86_64
```
OpenVZ fa riferimento a ciascun modello di sistema operativo installato come "Contenitore". È necessario creare un ID contenitore (CTID) per ogni modello scaricato. Emetti il comando seguente, sostituendo [CTID] con qualsiasi numero (si consiglia 101) e il nome del modello CentOS 7 con il modello scaricato.
```
 vzctl create [CTID] --ostemplate centos7-x86_64
```
Se imposti una partizione del disco separata per i modelli OpenVZ, utilizza il comando seguente per creare il contenitore all'interno del nuovo disco. Sostituisci –ostilo con il nome del modello e –nome con un nome descrittivo a tua scelta:
```
vzctl create [CTID] --ostemplate debian-8.0-x86_64 --layout simfs --name centos7 --private /vztemp/vz/private/$VEID --root /vztemp/vz/root/$VEID --config basic
```

Ora sarà stato creato un file di configurazione per il modello del tuo sistema operativo. La posizione di questo file è specificata come parte dell'output del comando precedente. Apri questo file ora per apportare le seguenti modifiche di seguito. Il file di configurazione sarà denominato nel formato [CTID].conf.

Assegna un indirizzo IP al tuo ambiente virtuale. Il formato consigliato è 192.168.0.[CTID]. In questo caso sarebbe 192.168.0.101.
Fornire un server dei nomi. Il server dei nomi di Google (8.8.8.8) dovrebbe essere sufficiente.
Se hai problemi ad avviare il tuo ambiente virtuale, puoi provare a cambiare VE_LAYOUT torna a ploop da simfs .

Puoi anche configurare altre opzioni a tua discrezione, come lo SWAP e l'allocazione della RAM. Salva e chiudi quando hai finito.

File:/ etc/vz/conf/101.conf

. . .

# RAM
PHYSPAGES="0:256M"

# Swap
SWAPPAGES="0:512M"

# Disk quota parameters (in form of softlimit:hardlimit)
DISKSPACE="2G:2.2G"
DISKINODES="131072:144179"
QUOTATIME="0"

# CPU fair scheduler parameter
CPUUNITS="1000"

NETFILTER="stateless"
VE_ROOT="/var/lib/vz/root/$VEID"
VE_PRIVATE="/var/lib/vz/private/$VEID"
VE_LAYOUT="simfs"
OSTEMPLATE="centos7-x86_64"
ORIGIN_SAMPLE="vswap-256m"
NAMESERVER="8.8.8.8"
IP_ADDRESS="192.168.0.101/24"
HOSTNAME="centos-7"

Avvia nel tuo contenitore appena creato usando i comandi seguenti. Sostituisci [CTID] con il numero CTID del tuo contenitore. Per uscire da qualsiasi sessione del contenitore lasciando in esecuzione l'ambiente virtuale, digita exit nella riga di comando.
```
 vzctl start [CTID]
 vzctl enter [CTID]
```

Configura l'accesso a Internet ai container

I container non hanno modo di accedere a Internet o di accedervi da Internet. Il server host deve essere configurato per trasmettere richieste da e verso ciascun ambiente virtuale installato.

Configura l'accesso dal container a Internet

Nota Potrebbe essere necessario accedere come root con su - per eseguire i comandi iptables-save in questa sezione.

Sul server host, immetti il seguente comando utilizzando Iptables. Sostituire le parentesi e il contenuto con le informazioni appropriate. Per l'indirizzo IP del contenitore, assicurati di elencarlo nella notazione CIDR. Includi indirizzo IP e sottorete o xxx.xxx.xxx.xxx/xx , al fine di comprendere una gamma di indirizzi IP che consentiranno l'accesso a eventuali contenitori aggiunti in futuro. Ad esempio, l'immissione di 192.168.0.0/24 imposterà il routing per gli indirizzi IP da 192.168.0.0 a 192.168.0.255:
```
 iptables -t nat -A POSTROUTING -s [container IP] -o eth0 -j SNAT --to [host server IP]
```
Se hai iptables-persistent installato, salta questo passaggio. Salva le nuove regole di Iptables:
```
 iptables-save > /etc/iptables.conf
```
Configura il firewall per consentire le richieste inoltrate. Se non stai usando iptables-persistent salva la regola:
```
 iptables -A FORWARD -s 192.168.0.0/24 -j ACCEPT
 iptables-save > /etc/iptables.conf
```
Ora dovresti avere accesso a Internet dall'ambiente contenitore. Prova ad aggiornare i pacchetti dal tuo container per verificare la connessione.

Configura l'accesso da Internet al container

Se devi accedere a un servizio specifico sul tuo container da Internet, dovrai prenotare una porta sulla macchina host e instradare l'accesso attraverso di essa. Immettere il comando seguente, sostituendo eventuali valori tra parentesi con le informazioni appropriate:
```
 iptables -t nat -A PREROUTING -p tcp -d [host_ip] --dport [host_port_number] -i eth0 -j DNAT --to-destination [container_ip:container_port_number]
```
Salva la tua nuova regola. Salta questo passaggio se hai iptables-persistent installato:
```
 iptables-save > /etc/iptables.conf
```

Dove andare da qui

Dopo aver installato OpenVZ, scaricato un modello, creato un container e configurato l'accesso a Internet, il tuo ambiente virtuale funzionerà esattamente come qualsiasi normale ambiente Linux:richiedendo aggiornamenti regolari, configurazione di sicurezza, ecc. La maggior parte della configurazione può essere eseguita dal server host tramite i comandi OpenVZ .

Vedi il link "Operazioni di base OpenVZ" nelle Risorse esterne sezione per familiarizzare con i comandi di amministrazione di base. È inoltre possibile scaricare modelli aggiuntivi creati dall'utente, che non sono inclusi nell'elenco dei modelli principale. Puoi trovarli seguendo il link "Modelli con contributo utente OpenVZ".

Maggiori informazioni

Si consiglia di consultare le seguenti risorse per ulteriori informazioni su questo argomento. Sebbene questi siano forniti nella speranza che possano essere utili, tieni presente che non possiamo garantire l'accuratezza o la tempestività dei materiali ospitati esternamente.

Operazioni di base di OpenVZ
Modelli con contributo utente OpenVZ

Quando e perché usare Docker

Come creare un Docker Swarm Manager e nodi su Linode

Docker

Come installare Skype su Debian 9

Come installare Python 3.7 su Debian 9

Come installare R su Debian 10

Come installare Debian 11

Come installare Vai su Debian 10

Come installare Vai su Debian