virt-p2v - Online nel cloud

PROGRAMMA:

NOME

virt-p2v - Converti una macchina fisica per usare KVM

SINOSSI

virt-p2v

virt-p2v.iso

DESCRIZIONE

Virt-p2v converte una macchina fisica per l'esecuzione virtualizzata su KVM, gestita da libvirt,
OpenStack, oVirt, Red Hat Enterprise Virtualization (RHEV) o uno degli altri obiettivi
sostenuto da virt-v2v(1).

Normalmente non si esegue direttamente il programma virt-p2v. Invece devi avviare il
macchina fisica utilizzando il CD-ROM avviabile, l'immagine ISO o PXE. Questa immagine avviabile
contiene il binario virt-p2v e lo esegue automaticamente. L'avvio da un CD-ROM/etc è
richiesto perché i dischi in fase di conversione devono essere quiescenti. Non è sicuro
prova a convertire una macchina fisica in esecuzione in cui altri programmi potrebbero modificare il disco
contenuto allo stesso tempo.

Questa pagina di manuale documenta l'esecuzione del programma virt-p2v. Per creare l'immagine avviabile devi
dovrebbe guardare virt-p2v-crea-disco(1) o virt-p2v-make-kickstart(1).

NETWORK IMPOSTARE

Virt-p2v viene eseguito sulla macchina fisica che si desidera convertire. Deve parlare con
un altro server chiamato "server di conversione" che deve avere virt-v2v(1) installato su di esso.
Parla sempre con il server di conversione su SSH:

┌─────────────┐ ┌─────────────────┐
virt-p2v │ │ virt-v2v │
│ (connessione fisica │ ssh │ (conversione │
│server) ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍▶ server) │
└──────────────┘ └─────────────────┘

Il programma virt-v2v sul server di conversione esegue la conversione effettiva (fisica in
le conversioni da virtuale e da virtuale a virtuale sono sufficientemente simili da poter essere utilizzate allo stesso modo
programma per fare entrambe le cose).

La connessione SSH viene sempre avviata dal server fisico. Tutti i dati vengono trasferiti
tramite la connessione SSH. In termini di firewall e configurazione di rete, devi solo
assicurarsi che il server fisico abbia accesso a una porta (di solito la porta TCP 22) sul
server di conversione. Si noti che la macchina fisica potrebbe riconnettersi più volte durante il
processo di conversione.

La funzione di inoltro della porta inversa di ssh (es. "ssh -R") è richiesta da virt-p2v e
non funzionerà se questo è disabilitato sul server di conversione. ("Consenti TcpForwarding" deve essere
"sì" in sshd_config(5) file sul server di conversione).

Non è necessario che il server di conversione sia una macchina fisica. Potrebbe essere un virtuale
macchina, purché disponga di memoria e spazio su disco sufficienti per eseguire la conversione, e come
purché la macchina fisica possa connettersi direttamente alla sua porta SSH. (Vedi anche "RISORSE
REQUISITI" in virt-v2v(1)).

Poiché tutti i dati sui dischi rigidi del server fisico devono essere copiati sul
rete, la velocità di conversione è in gran parte determinata dalla velocità della rete tra
le due macchine.

GUI INTERACTIVE CONFIGURAZIONE

Quando avvii virt-p2v, vedrai una finestra di configurazione grafica che ti guiderà
tramite connessione al server di conversione, richiede la password, quali hard disk locali
vuoi convertire e altre cose come il nome dell'ospite da creare e il numero
di CPU virtuali per darlo.

SSH CONFIGURAZIONE DIALOGO
Quando virt-p2v si avvia in modalità GUI, la prima finestra di dialogo si presenta così:

? ?
virt-p2v
│ │
│ Server di conversione: [_________________________________] │
│ │
│ Porta SSH: [22_______________________________] │
│ │
│ Nome utente: [root_____________________________] │
│ │
Password: [_________________________________]
│ │
│ URL identità SSH: [_________________________________] │
│ │

Nei campi sopra, devi inserire i dettagli del server di conversione: il nome host,
Numero di porta SSH, nome utente remoto e password o identità SSH (chiave privata)
URL. Il server di conversione deve avere una versione aggiornata di virt-v2v.

Normalmente devi accedere al server di conversione come root, ma se controlli quanto segue
box:

│ │
│ [ ] Usa sudo durante l'esecuzione di virt-v2v │
│ │

quindi puoi accedere come un altro utente e virt-p2v utilizzerà il sudo(8) comando per elevare
privilegi di root. Nota che sudo non deve richiedere una password.

È anche possibile eseguire virt-v2v sul server di conversione interamente come non root, ma
le modalità di uscita possono essere limitate. Consulta il virt-v2v(1) pagina di manuale per i dettagli.

Nella parte inferiore della finestra di dialogo ci sono questi pulsanti:

│ │
│ [ Collegamento di prova ] │
│ │
│ [ Configura rete ] [ Informazioni su virt-p2v ] [ Avanti ] │
│ │
? ?

È necessario premere prima il pulsante "Test connection" per testare la connessione SSH al
server di conversione. Se ha esito positivo (ad esempio, hai fornito il nome del server corretto,
nome utente, password, ecc. e una versione adatta di virt-v2v è disponibile in remoto) quindi
premere il pulsante "Avanti" per passare alla finestra di dialogo successiva.

È possibile utilizzare il pulsante "Configura rete" se è necessario assegnare un indirizzo IP statico a
la macchina fisica o utilizzare Wi-Fi, bonding o altre funzionalità di rete.

DISCO E NETWORK CONFIGURAZIONE DIALOGO
La seconda finestra di configurazione consente di configurare i dettagli della conversione, incluso
cosa convertire e dove inviare l'ospite.

Nella colonna di sinistra, partendo dall'alto, le proprietà di destinazione consentono di selezionare il
nome del guest (es. dopo la conversione) e quante CPU virtuali e quanta RAM
darlo. Le impostazioni predefinite provengono dalla macchina fisica e di solito puoi lasciarle
invariato:

┌────────────────────────────────────── ─ ─ ───────── ─ ─ ─
│ Proprietà di destinazione:
│
│ Nome: [nome host______________]
│
│ # vCPU: [4_____________________]
│
│ Memoria (MB): [16384_________________]
│

Il secondo pannello a sinistra controlla le opzioni di output di virt-v2v. Per capirli
opzioni è davvero una buona idea leggere il virt-v2v(1) pagina di manuale. Puoi lasciare il
opzioni predefinite per creare un ospite come immagine del disco più file XML libvirt che si trova in
/ Var / tmp sull'host di conversione. Questa è una buona idea se sei un virt-p2v per la prima volta
utente.

│
│ Opzioni di uscita Virt-v2v:
│
│ Uscita su (-o): [local ▼]
│
Uscita conn. (-oc): [___________________]
│
│ Memoria output (-os): [/var/tmp___________]
│
│ Formato di output (-di): [___________________]
│
│ Allocazione dell'output (-oa): [sparse ▼]
│

Tutte le opzioni e i percorsi di output sono relativi al server di conversione (non è un al fisico
server).

L'ultima opzione in questo pannello abilita il debug lato server. Questo produce molto
output, ma è essenziale se stai rintracciando problemi virt-p2v o virt-v2v, e puoi
generalmente essere lasciato abilitato:

│
│ [✔] Abilita il debug lato server
│

Infine nella colonna di sinistra c'è una casella di informazioni che fornisce la versione di virt-p2v (on
il server fisico) e virt-v2v (sul server di conversione). Dovresti fornire questo
informazioni durante la segnalazione di bug.

Nella colonna di destra ci sono tre pannelli che controllano quali dischi rigidi, supporti rimovibili
i dispositivi e le interfacce di rete verranno creati nel guest di output. Normalmente in partenza
questi alle impostazioni predefinite va bene.

─ ─ ─────────────────────────────────────
Dischi fissi
│
Converti dimensione dispositivo (GB) modello │
[✔] sda 1024 HITACHI
[✔] sdb 119 HITACHI
│

Normalmente vorresti convertire tutti i dischi rigidi. Se vuoi che virt-p2v sia completamente
ignora un disco rigido locale, deselezionalo. Il disco rigido che contiene il sistema operativo
deve essere selezionato. Se un disco rigido fa parte di un array RAID o di un gruppo di volumi LVM (VG), allora
è necessario selezionare tutti i dischi rigidi in quell'array/VG oppure nessuno di essi.

│
Supporti rimovibili
│
Converti dispositivo
[✔] sr0
│

Se la macchina fisica dispone di unità CD o DVD, è possibile utilizzare il pannello dei supporti rimovibili
per creare unità corrispondenti sul guest dopo la conversione. Notare che qualsiasi CD/DVD di dati
che sono montati nelle unità sono non è un copiato.

│
Interfacce di rete
│
Converti dispositivo Connetti a ... |
[✔] em1 [predefinito_____________] │
[ ] wlp3s0 [predefinito_____________] │
│

Nel pannello Interfacce di rete, seleziona le interfacce di rete che dovrebbero essere create in
l'ospite dopo la conversione. Puoi anche connetterli alle reti di hypervisor di destinazione (per
ulteriori informazioni su questa funzione, vedere "RETI E PONTI" in virt-v2v(1)).

Quando sei pronto per iniziare la conversione, premi il pulsante "Avvia conversione":

│
[Indietro] [Inizia conversione] │
│
─ ─ ─────────────────────────────────────

CONVERSIONE JOGGING vs RUNNING DIALOGO
Quando la conversione è in esecuzione vedrai questa finestra di dialogo:

? ?
virt-p2v
│ │
│ ┌──────────────────────────────────────────────── ──┐ │
│ │ ▲│ │
│ │ │ │
│ │ │ │
∼ ∼ ∼ ∼
│ │ │ │
│ │ │ │
│ │ ▼│ │
│ └──────────────────────────────────────────────── ──┘ │
│ │
│ File di registro ... in /tmp/virt-p2v-xxx │
│ │
│ Conversione in corso... │
│ │
│ [ Annulla conversione ] │
│ │
? ?

Nell'area di scorrimento principale vedrai i messaggi di registro dal processo virt-v2v.

Sotto l'area principale, virt-p2v mostra la posizione della directory sulla conversione
server che contiene file di registro e altre informazioni di debug. Sotto c'è la corrente
stato e un pulsante per annullare la conversione.

Al termine della conversione, è necessario spegnere la macchina fisica. Se la conversione è
successo, non dovresti mai riavviarlo.

NOCCIOLO COMANDO LINE CONFIGURAZIONE

Se non vuoi configurare le cose usando l'interfaccia utente grafica, un'alternativa è
configurare tramite la riga di comando del kernel. Questo è particolarmente conveniente se lo sei
convertire molte macchine fisiche che vengono avviate utilizzando PXE.

Il punto esatto in cui imposti gli argomenti della riga di comando dipende dalla tua implementazione PXE, ma per
pxelinux li metti nel campo "APPEND" nel pixelinux.cfg file. Per esempio:

PREDEFINITO p2v
TEMPO 20
RICHIEDI 0
ETICHETTA p2v
KERNEL vmlinuz0
APPEND initrd=initrd0.img [....] p2v.server=conv.example.com p2v.password=segreto p2v.o=libvirt

Devi impostare alcuni o tutti i seguenti argomenti della riga di comando:

p2v.server=SERVER
Il nome o l'indirizzo IP del server di conversione.

Questo è sempre necessario se stai usando il metodo di configurazione del kernel. Se virt-p2v
non lo trova sulla riga di comando del kernel, quindi passa alla GUI
(interattivo) metodo di configurazione.

p2v.porta=NN
Il numero di porta SSH sul server di conversione (predefinito: 22).

p2v.nomeutente=NOME UTENTE
Il nome utente SSH con cui accediamo al server di conversione (predefinito: "root").

p2v.password=PASSWORD
La password SSH che utilizziamo per accedere al server di conversione.

L'impostazione predefinita è provare senza password. Se fallisce, virt-p2v chiederà all'utente
per digitare la password (probabilmente più volte durante la conversione).

Questa impostazione viene ignorata se è presente "p2v.identity".

p2v.identità=URL
Fornisci un URL che punta a un file di identità SSH (chiave privata). L'URL è interpretato
by arricciare(1) quindi qualsiasi URL supportato da curl può essere utilizzato qui, inclusi "https://" e
"file://". Per ulteriori informazioni sull'utilizzo delle identità SSH, vedere "IDENTITÀ SSH" di seguito.

Se è presente "p2v.identity", sovrascrive "p2v.password". Non c'è ripiego.

p2v.sudo
Usa "p2v.sudo" per dire a virt-p2v di usare sudo(8) per ottenere i privilegi di root sul
server di conversione dopo l'accesso come utente non root (impostazione predefinita: non utilizzare sudo).

p2v.name=NOMEGUEST
Il nome dell'ospite che viene creato. L'impostazione predefinita è provare a derivare un nome da
il nome host della macchina fisica (se possibile) altrimenti usa un nome generato casualmente.

p2v.vcpus=NN
Il numero di CPU virtuali da dare al guest. L'impostazione predefinita è utilizzare lo stesso di
il numero di CPU fisiche.

p2v.memoria=NN(M|G)
La dimensione della memoria dell'ospite. È necessario specificare l'unità come megabyte o
gigabyte utilizzando (es.) "p2v.memory=1024M" o "p2v.memory=1G".

L'impostazione predefinita prevede l'utilizzo della stessa quantità di RAM della macchina fisica.

p2v.debug
Usalo per abilitare il debug completo di virt-v2v.

Se ti viene chiesto di diagnosticare un problema con virt-p2v, dovresti aggiungere "p2v.debug" al kernel
riga di comando ed esamina il file di registro che è rimasto dentro / Tmp sul server di conversione.

p2v.disk=sdX,sdY,..
Un elenco di dischi rigidi fisici da convertire, ad esempio:

p2v.disks=sda,sdc

L'impostazione predefinita è convertire tutti i dischi rigidi locali trovati.

p2v.removibile=srX,srY,..
Un elenco di supporti rimovibili da convertire. L'impostazione predefinita è creare rimovibili virtuali
dispositivi per ogni dispositivo fisico rimovibile trovato. Si noti che il contenuto di rimovibile
il supporto non viene mai copiato.

p2v.interfacce=em1,..
Un elenco di interfacce di rete da convertire. L'impostazione predefinita è creare una rete virtuale
interfacce per ogni interfaccia di rete fisica trovata.

p2v.network=interfaccia:destinazione,...
Controlla il modo in cui le interfacce di rete sono connesse alle reti virtuali sulla destinazione
hypervisor. L'impostazione predefinita è connettere tutte le interfacce di rete al "predefinito" di destinazione
rete.

Fornisci un elenco separato da virgole di coppie "interfaccia: destinazione", più facoltativamente un valore predefinito
obbiettivo. Per esempio:

p2v.network=em1:revm

mappa l'interfaccia "em1" sulla rete di destinazione "rhevm".

p2v.network=em1:rhevm,em2:gestione,altro

mappa l'interfaccia "em1" su "rhevm" e "em2" su "management" e qualsiasi altra interfaccia
che si trova ad "altro".

p2v.o=[libvirt|locale|...]
Imposta la modalità di uscita. Questo è lo stesso di virt-v2v -o opzione. Vedere "OPZIONI" in
virt-v2v(1).

Se non specificato, il valore predefinito è "locale" e il guest convertito viene scritto in
/ Var / tmp.

p2v.oa=sparso|preallocato
Imposta la modalità di assegnazione dell'uscita. Questo è lo stesso di virt-v2v -oh opzione. Vedere
"OPZIONI" in virt-v2v(1).

p2v.oc=...
Imposta l'URI della connessione di output libvirt. Questo è lo stesso di virt-v2v -oc opzione.
Vedere "OPZIONI" in virt-v2v(1) e http://libvirt.org/uri.html

p2v.of=grezzo|qcow2|...
Imposta il formato di output. Questo è lo stesso di virt-v2v -Di opzione. Vedere "OPZIONI" in
virt-v2v(1).

p2v.os=...
Imposta la memoria di output. Questo è lo stesso di virt-v2v Hong osseo opzione. Vedi "OPZIONI"
in virt-v2v(1).

Se non specificato, il valore predefinito è / Var / tmp (sul server di conversione).

p2v.pre=COMANDO
p2v.pre="COMANDO ARG ... "
Seleziona un comando di pre-conversione da eseguire. Qualsiasi comando o script può essere specificato qui.
Se il comando contiene spazi, devi citare l'intero comando tra virgolette.
L'impostazione predefinita è non eseguire alcun comando.

p2v.post=spegnimento
p2v.post=riavvio
p2v.post=COMANDO
p2v.post="COMANDO ARG ... "
Seleziona un comando post-conversione da eseguire se la conversione ha esito positivo. Questo può essere qualsiasi
comando o script. Se il comando contiene spazi, devi citare l'intero comando
con doppie virgolette.

If virt-p2v è in esecuzione come root, e la riga di comando è stata impostata da /proc/linea cmd Non sei
--cmdline), quindi l'impostazione predefinita è eseguire il spegni(8) comando. Altrimenti l'impostazione predefinita
non è quello di eseguire alcun comando.

p2v.fail=COMANDO
p2v.fail="COMANDO ARG ... "
Seleziona un comando post-conversione da eseguire se la conversione non riesce. Qualsiasi comando o script
può essere specificato qui. Se il comando contiene spazi, devi citare l'intero
comando con virgolette doppie. L'impostazione predefinita è non eseguire alcun comando.

ip = dhcp
Utilizzare DHCP per configurare l'interfaccia di rete (questa è l'impostazione predefinita).

SSH IDENTITÀ

Come alternativa un po' più sicura all'autenticazione con password, puoi utilizzare un SSH
identità (chiave privata) per l'autenticazione.

Per prima cosa crea una coppia di chiavi. Deve avere una passphrase vuota:

ssh-keygen -t rsa -N '' -f id_rsa

Questo crea una chiave privata ("id_rsa") e una chiave pubblica ("id_rsa.pub").

La chiave pubblica dovrebbe essere aggiunta al file "authorized_keys" sulla conversione virt-v2v
server (di solito in "/root/.ssh/authorized_keys").

Per la distribuzione della chiave privata, ci sono quattro scenari dal meno sicuro al più
sicuro:

1. Non utilizzare affatto le identità SSH, ad es. autenticazione della password.

Chiunque possa annusare i parametri di avvio PXE dalla rete o osservare la password
in qualche altro modo può accedere al server di conversione virt-v2v.

2. Identità SSH incorporata nell'ISO virt-p2v o nell'immagine del disco. Nella GUI, usa:

Parola d'ordine: [ ]
│ │
│ URL identità SSH: [file:///var/tmp/id_rsa_____________]

o sulla riga di comando del kernel:

p2v.identity=file:///var/tmp/id_rsa

La chiave privata SSH può ancora essere sniffata dalla rete se si utilizza PXE standard.

3. Identità SSH scaricata da un sito web. Nella GUI, usa:

Parola d'ordine: [ ]
│ │
│ URL identità SSH: [https://internal.example.com/id_rsa]

o sulla riga di comando del kernel:

p2v.identity=https://internal.example.com/id_rsa

Chiunque può ancora scaricare la chiave privata e usarla per accedere a virt-v2v
server di conversione, ma potresti fornire una maggiore sicurezza configurando il web
server per consentire solo connessioni da macchine P2V.

4. Identità SSH incorporata nell'ISO virt-p2v o nell'immagine del disco (come 2.), e uso di sicuro
PXE, PXE su una rete fisica separata o sneakernet per distribuire virt-p2v al
macchina fisica.

Entrambi virt-p2v-crea-disco(1) e virt-p2v-make-kickstart(1) hanno la stessa opzione
--inject-ssh-identità per iniettare la chiave privata nell'immagine disco virt-p2v / ISO.
Vedere anche le seguenti sezioni del manuale:

"AGGIUNGERE UN'IDENTITÀ SSH" in virt-p2v-crea-disco(1)

"AGGIUNGERE UN'IDENTITÀ SSH" in virt-p2v-make-kickstart(1)

VERSIONI

--Aiuto
Mostra aiuto.

--cmdline=RIGACMD
Questo è usato per il debug. Invece di analizzare la riga di comando del kernel da
/proc/linea cmd, analizza il parametro stringa "CMDLINE".

-v
--verboso
Abilita il debug (sul server di conversione).

-V
--versione
Visualizza il numero di versione ed esci.

abilitá VIRT-P2V OPERE

Note: questo pagina is non è un normativo. Potremmo modificare il funzionamento di virt-p2v in qualsiasi momento nel
futuro.

Come descritto sopra, virt-p2v viene eseguito su una macchina fisica, interroga l'utente o il
riga di comando del kernel per la configurazione, quindi stabilisce una o più connessioni ssh a
il server di conversione virt-v2v. Le connessioni ssh sono sessioni di shell interattive per il
host remoto, ma i comandi inviati sono generati interamente da virt-p2v stesso, non dal
utente. Per il trasferimento dei dati, virt-p2v utilizzerà la funzione reverse port forward di ssh (es.
"ssh-R").

Effettuerà prima una o più connessioni di prova, che vengono utilizzate per interrogare il telecomando
versione di virt-v2v e le sue caratteristiche. Le connessioni di prova vengono chiuse prima della conversione
comincia.

┌─────────────┐ ┌─────────────────┐
virt-p2v │ │ virt-v2v │
│ (connessione fisica │ di controllo │ (conversione │
│ server) ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ server) │
└──────────────┘ └─────────────────┘

Una volta che virt-p2v è pronto per iniziare la conversione, aprirà una singola connessione di controllo ssh.
Prima invia un comando mkdir per creare una directory temporanea sul server di conversione.
Il nome della directory viene scelto casualmente e viene visualizzato nella GUI. Ha la forma:

/tmp/virt-p2v-AAAAMMGG-XXXXXXXX

dove "AAAAMMGG" è la data corrente e le X sono caratteri casuali.

In questa directory sono scritti vari file che includono:

dmesg
(prima conversione)

L'output di dmesg dalla macchina fisica. Utile per rilevare problemi come
driver di dispositivo o firmware mancanti sull'ISO virt-p2v.

Nome
(prima conversione)

Il nome (di solito il nome host) della macchina fisica.

fisico.xml
(prima conversione)

Libvirt XML che descrive la macchina fisica. Viene utilizzato per trasmettere dati sul
host di origine fisica a virt-v2v(1) tramite il -i libvirtxml opzione.

Nota che questo non è "reale" XML di libvirt (e deve mai essere caricato in libvirt, che
lo rifiuterebbe comunque). Inoltre non è lo stesso dell'XML libvirt che virt-v2v
genera in determinate modalità di output.

status
(dopo conversione)

Lo stato finale della conversione. 0 se la conversione è andata a buon fine. Diverso da zero se
la conversione non è riuscita.

tempo
(prima conversione)

La data/ora di inizio della conversione.

virt-v2v-conversion-log.txt
(durante/dopo conversione)

Il registro di conversione. Questo è solo l'output del comando virt-v2v sulla conversione
server. Se la conversione fallisce, dovresti esaminare questo file di registro e potrebbe esserti chiesto
per fornire il completamento di una, inedito log in eventuali segnalazioni di bug o ticket di supporto.

Prima che la conversione inizi effettivamente, virt-p2v effettua una o più ulteriori connessioni ssh
al server per il trasferimento dei dati. Il protocollo di trasferimento attualmente utilizzato è NBD (Network
Block Device), che è proxy su ssh. Il server è qemu-nbd(1). C'è uno ssh
connessione per disco rigido fisico sulla macchina di origine (il caso comune — un singolo disco rigido)
disco — è mostrato sotto):

┌─────────────┐ ┌─────────────────┐
virt-p2v │ │ virt-v2v │
│ (connessione fisica │ di controllo │ (conversione │
│ server) ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ server) │
│ │ │ │
│ │ connessione dati │ │
│ ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ │
qemu-nbd ← ─┘ │ │└─ ← NBD │
│/dev/sda │ │ richieste │
∼ ∼ ∼ ∼
└──────────────┘ └─────────────────┘

Sebbene la connessione dati ssh sia originata dal server fisico e termini il
il server di conversione, infatti, le richieste NBD fluiscono nella direzione opposta. Questo è
perché la funzione di port forwarding inverso di ssh ("ssh -R") viene utilizzata per aprire una porta sul
interfaccia di loopback del server di conversione che viene reindirizzato da ssh a qemu-nbd
server in esecuzione sulla macchina fisica. L'effetto è che virt-v2v tramite libguestfs può
aprire connessioni nbd che leggono direttamente i dischi rigidi del server fisico.

Vengono utilizzati due livelli di protezione per garantire che non vi siano scritture sui dischi rigidi:
In primo luogo, il qemu-nbd -r (sola lettura) viene utilizzata l'opzione. In secondo luogo libguestfs crea an
sovrapposizione sopra la connessione NBD che memorizza le scritture in un file temporaneo sul
file di conversione.

Il passaggio finale consiste nell'inviare il comando "virt-v2v -i libvirtxml fisica.xml ..." al
server di conversione sulla connessione di controllo. Questo fa riferimento al fisico.xml file (vedi
sopra), che a sua volta fa riferimento alla/e porta/e di ascolto NBD della/e connessione/e dati.

L'output del comando virt-v2v (messaggi, debug, ecc.) viene salvato sia nel file di registro
sul server di conversione e inviato tramite la connessione di controllo per essere visualizzato nel
interfaccia utente grafica.

Usa virt-p2v online utilizzando i servizi onworks.net