virt-p2v - Online na nuvem

PROGRAMA:

NOME

virt-p2v - Converter uma máquina física para usar KVM

SINOPSE

virt-p2v

virt-p2v.iso

DESCRIÇÃO

Virt-p2v converte uma máquina física para rodar virtualizado em KVM, gerenciado por libvirt,
OpenStack, oVirt, Red Hat Enterprise Virtualization (RHEV) ou um dos outros destinos
suportado pela virt-v2v(1).

Normalmente você não executa o programa virt-p2v diretamente. Em vez disso, você tem que inicializar o
máquina física usando o CD-ROM inicializável, imagem ISO ou PXE. Esta imagem inicializável
contém o binário virt-p2v e o executa automaticamente. A inicialização de um CD-ROM / etc é
necessário porque os discos que estão sendo convertidos devem estar inativos. Não é seguro
tente converter uma máquina física em execução onde outros programas podem estar modificando o disco
conteúdo ao mesmo tempo.

Esta página de manual documenta a execução do programa virt-p2v. Para criar a imagem inicializável você
deve olhar para virt-p2v-criar-disco(1) ou virt-p2v-make-kickstart(1).

REDE CONFIGURAÇÃO

Virt-p2v é executado na máquina física que você deseja converter. Tem que falar com
outro servidor chamado de "servidor de conversão" que deve ter virt-v2v(1) instalado nele.
Ele sempre se comunica com o servidor de conversão por SSH:

┌────────────────┐ ┌───────────────────┐
│ virt-p2v │ │ virt-v2v │
│ (conexão │ ssh física │ (conversão │
│ servidor) ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ servidor) │
└────────────────┘ └───────────────────┘

O programa virt-v2v no servidor de conversão faz a conversão real (física para
conversões virtuais e virtuais para virtuais são suficientemente semelhantes que usamos o mesmo
programa para fazer ambos).

A conexão SSH é sempre iniciada a partir do servidor físico. Todos os dados são transferidos
através da conexão SSH. Em termos de firewall e configuração de rede, você só precisa
certifique-se de que o servidor físico tenha acesso a uma porta (geralmente a porta TCP 22) no
servidor de conversão. Observe que a máquina física pode se reconectar várias vezes durante o
processo de conversão.

O recurso de encaminhamento de porta reversa do ssh (ou seja, "ssh -R") é exigido por virt-p2v, e ele
não funcionará se estiver desabilitado no servidor de conversão. ("AllowTcpForwarding" deve ser
"sim" no sshd_config(5) arquivo no servidor de conversão).

O servidor de conversão não precisa ser uma máquina física. Poderia ser um virtual
máquina, desde que tenha memória e espaço em disco suficientes para fazer a conversão, e como
contanto que a máquina física possa se conectar diretamente à sua porta SSH. (Veja também "RECURSOS
REQUISITOS "em virt-v2v(1)).

Porque todos os dados no (s) disco (s) rígido (s) do servidor físico devem ser copiados sobre o
rede, a velocidade de conversão é amplamente determinada pela velocidade da rede entre
as duas máquinas.

GUI INTERATIVO CONFIGURAÇÃO

Ao iniciar o virt-p2v, você verá uma caixa de diálogo de configuração gráfica que o orienta
através da conexão com o servidor de conversão, pede a senha, quais discos rígidos locais
que você deseja converter e outras coisas como o nome do convidado a ser criado e o número
de CPUs virtuais para oferecer.

SSH CONFIGURAÇÃO DIÁLOGO
Quando virt-p2v inicia no modo GUI, a primeira caixa de diálogo se parece com esta:

┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ───────┐
│ virt-p2v │
│ │
│ Servidor de conversão: [_________________________________] │
│ │
│ Porta SSH: [22_______________________________] │
│ │
│ Nome de usuário: [root_____________________________] │
│ │
│ Senha: [_________________________________] │
│ │
│ URL de identidade SSH: [_________________________________] │
│ │

Nos campos acima, você deve inserir os detalhes do servidor de conversão: o nome do host,
Número da porta SSH, nome de usuário remoto e a senha ou identidade SSH (chave privada)
URL O servidor de conversão deve ter uma versão atualizada do virt-v2v.

Normalmente você deve fazer login no servidor de conversão como root, mas se você verificar o seguinte
caixa:

│ │
│ [] Use sudo ao executar virt-v2v │
│ │

então você pode fazer login como outro usuário, e virt-p2v usará o sudo(8) comando para elevar
privilégios para fazer root. Observe que o sudo não deve exigir uma senha.

Também é possível executar virt-v2v no servidor de conversão inteiramente como não-root, mas
os modos de saída podem ser limitados. Consulte o virt-v2v(1) página de manual para detalhes.

Na parte inferior da caixa de diálogo estão estes botões:

│ │
│ [Conexão de teste] │
│ │
│ [Configurar rede] [Sobre virt-p2v] [Próximo] │
│ │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ───────┘

Você deve pressionar o botão "Testar conexão" primeiro para testar a conexão SSH com o
servidor de conversão. Se for bem sucedido (ou seja, você forneceu o nome de servidor correto,
nome de usuário, senha, etc., e uma versão adequada de virt-v2v disponível remotamente), então
pressione o botão "Avançar" para avançar para a próxima caixa de diálogo.

Você pode usar o botão "Configurar rede" se precisar atribuir um endereço IP estático para
a máquina física ou usar Wifi, ligação ou outros recursos de rede.

DISCO E REDE CONFIGURAÇÃO DIÁLOGO
A segunda caixa de diálogo de configuração permite configurar os detalhes de conversão, incluindo
o que converter e para onde enviar o convidado.

Na coluna da esquerda, começando no topo, as propriedades de destino permitem que você selecione o
nome do convidado (ou seja, após a conversão) e quantas CPUs virtuais e quanta RAM para
dê. Os padrões vêm da máquina física e geralmente você pode deixá-los
inalterado:

┌─────────────────────────────────────────────────────────────────────────
│ Propriedades de destino:
│
│ Nome: [nome do host______________]
│
│ # vCPUs: [4________________________________]
│
│ Memória (MB): [16384_________________]
│

O segundo painel à esquerda controla as opções de saída do virt-v2v. Para entender estes
opções, é realmente uma boa ideia ler o virt-v2v(1) página de manual. Você pode deixar o
opções no padrão para criar um convidado como uma imagem de disco mais o arquivo XML libvirt localizado em
/ var / tmp no host de conversão. Esta é uma boa ideia se você for um virt-p2v pela primeira vez
usuário.

│
│ Opções de saída Virt-v2v:
│
│ Saída para (-o): [local ▼]
│
│ Conector de saída. (-oc): [___________________]
│
│ Armazenamento de saída (-os): [/ var / tmp ___________]
│
│ Formato de saída (-of): [___________________]
│
│ Alocação de saída (-oa): [esparso ▼]
│

Todas as opções de saída e caminhos são relativos ao servidor de conversão (não para o físico
servidor).

A opção final neste painel permite a depuração do lado do servidor. Isso produz muito
saída, mas é essencial se você estiver rastreando problemas virt-p2v ou virt-v2v, e pode
geralmente fica ativado:

│
│ [✔] Habilite a depuração do lado do servidor
│

Finalmente na coluna da esquerda está uma caixa de informação dando a versão de virt-p2v (em
o servidor físico) e virt-v2v (no servidor de conversão). Você deve fornecer este
informações ao relatar bugs.

Na coluna da direita estão três painéis que controlam quais discos rígidos, mídia removível
dispositivos e interfaces de rede serão criados no convidado de saída. Normalmente saindo
estes nas configurações padrão está bom.

─ ─ ───────────────────────────────────────────────────────────────┐
Discos rígidos fixos │
│
Converter modelo de tamanho de dispositivo (GB) │
[✔] sda 1024 HITACHI │
[✔] sdb 119 HITACHI │
│

Normalmente, você deseja converter todos os discos rígidos. Se você quiser virt-p2v completamente
ignore um disco rígido local, desmarque-o. O disco rígido que contém o sistema operacional
deve ser selecionado. Se um disco rígido for parte de uma matriz RAID ou grupo de volume LVM (VG), então
todos os discos rígidos nessa matriz / VG devem ser selecionados ou nenhum deles.

│
Mídia removível │
│
Converter dispositivo │
[✔]sr0 │
│

Se a máquina física tiver unidades de CD ou DVD, você pode usar o painel de mídia removível
para criar unidades correspondentes no convidado após a conversão. Observe que quaisquer CDs / DVDs de dados
que são montados nas unidades são não copiado.

│
Interfaces de rede │
│
Converter dispositivo conectar em ... |
[✔] em1 [padrão_____________] │
[] wlp3s0 [padrão_____________] │
│

No painel de interfaces de rede, selecione as interfaces de rede que devem ser criadas em
o convidado após a conversão. Você também pode conectá-los a redes de hipervisor de destino (para
mais informações sobre este recurso, consulte "REDES E PONTES" em virt-v2v(1)).

Quando estiver pronto para iniciar a conversão, pressione o botão "Iniciar conversão":

│
[Voltar] [Iniciar conversão] │
│
─ ─ ───────────────────────────────────────────────────────────────┘

CONVERSÃO CORRENDO DIÁLOGO
Quando a conversão estiver em execução, você verá esta caixa de diálogo:

┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ───────┐
│ virt-p2v │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ──┐ │
│ │ ▲ │ │
│ │ │ │
│ │ │ │
∼ ∼ ∼ ∼
│ │ │ │
│ │ │ │
│ │ ▼ │ │
│ └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ──┘ │
│ │
│ Arquivos de log ... em / tmp / virt-p2v-xxx │
│ │
│ Fazendo conversão ... │
│ │
│ [Cancelar conversão] │
│ │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── ───────┘

Na área de rolagem principal, você verá mensagens de log do processo virt-v2v.

Abaixo da área principal, virt-p2v mostra a localização do diretório na conversão
servidor que contém arquivos de log e outras informações de depuração. Abaixo disso está a corrente
status e um botão para cancelar a conversão.

Assim que a conversão for concluída, você deve desligar a máquina física. Se a conversão for
bem-sucedido, você nunca deve reiniciá-lo.

NÚCLEO COMANDO LINHA CONFIGURAÇÃO

Se você não quiser configurar as coisas usando a IU gráfica, uma alternativa é
configure através da linha de comando do kernel. Isso é especialmente conveniente se você for
convertendo muitas máquinas físicas que são inicializadas usando PXE.

Onde exatamente você define os argumentos da linha de comando depende de sua implementação PXE, mas para
pxelinux você os coloca no campo "ANEXAR" no pxelinux.cfg Arquivo. Por exemplo:

PADRÃO p2v
TEMPO LIMITE 20
AVISO 0
ETIQUETA p2v
KERNEL vmlinuz0
APPEND initrd = initrd0.img [....] p2v.server = conv.example.com p2v.password = segredo p2v.o = libvirt

Você deve definir alguns ou todos os seguintes argumentos de linha de comando:

p2v.server = SERVER
O nome ou endereço IP do servidor de conversão.

Isso sempre é necessário se você estiver usando o método de configuração do kernel. Se virt-p2v
não encontra isso na linha de comando do kernel, então ele muda para a GUI
método de configuração (interativo).

p2v.port = NN
O número da porta SSH no servidor de conversão (padrão: 22).

p2v.username = USERNAME
O nome de usuário SSH com o qual efetuamos login no servidor de conversão (padrão: "root").

p2v.password = SENHA
A senha SSH que usamos para fazer login no servidor de conversão.

O padrão é tentar sem senha. Se isso falhar, virt-p2v irá perguntar ao usuário
para digitar a senha (provavelmente várias vezes durante a conversão).

Esta configuração será ignorada se "p2v.identity" estiver presente.

p2v.identity = URL
Fornece um URL apontando para um arquivo de identidade SSH (chave privada). O URL é interpretado
by enrolar(1) portanto, qualquer URL compatível com curl pode ser usado aqui, incluindo "https: //" e
"Arquivo://". Para obter mais informações sobre o uso de identidades SSH, consulte "IDENTIDADES SSH" abaixo.

Se "p2v.identity" estiver presente, ele substitui "p2v.password". Não há retrocesso.

p2v.sudo
Use "p2v.sudo" para dizer a virt-p2v para usar sudo(8) para obter privilégios de root no
servidor de conversão após efetuar login como usuário não root (padrão: não use sudo).

p2v.name = GUESTNAME
O nome do convidado criado. O padrão é tentar derivar um nome de
o nome do host da máquina física (se possível), caso contrário, use um nome gerado aleatoriamente.

p2v.vcpus = NN
O número de CPUs virtuais a serem fornecidas ao convidado. O padrão é usar o mesmo que
o número de CPUs físicas.

p2v.memory = NN (M | G)
O tamanho da memória do convidado. Você deve especificar a unidade como megabytes ou
gigabytes usando (por exemplo) "p2v.memory = 1024M" ou "p2v.memory = 1G".

O padrão é usar a mesma quantidade de RAM da máquina física.

p2v.debug
Use isso para habilitar a depuração completa de virt-v2v.

Se solicitado a diagnosticar um problema com virt-p2v, você deve adicionar "p2v.debug" ao kernel
linha de comando e examine o arquivo de log que foi deixado em / Tmp no servidor de conversão.

p2v.disks = sdX, sdY, ..
Uma lista de discos rígidos físicos a serem convertidos, por exemplo:

p2v.disks = sda, sdc

O padrão é converter todos os discos rígidos locais encontrados.

p2v.removable = srX, srY, ..
Uma lista de mídias removíveis a serem convertidas. O padrão é criar removível virtual
dispositivos para cada dispositivo físico removível encontrado. Observe que o conteúdo de removível
a mídia nunca é copiada.

p2v.interfaces = em1, ..
Uma lista de interfaces de rede a serem convertidas. O padrão é criar uma rede virtual
interfaces para cada interface de rede física encontrada.

p2v.network = interface: destino, ...
Controla como as interfaces de rede são conectadas a redes virtuais no destino
hipervisor. O padrão é conectar todas as interfaces de rede ao "padrão" de destino
rede.

Você fornece uma lista separada por vírgulas de pares "interface: destino", mais opcionalmente um padrão
alvo. Por exemplo:

p2v.network = em1: rhevm

mapeia a interface "em1" para a rede alvo "rhevm".

p2v.network = em1: rhevm, em2: gerenciamento, outro

mapeia a interface "em1" para "rhevm" e "em2" para "gerenciamento" e qualquer outra interface
que é encontrado para "outro".

p2v.o = [libvirt | local | ...]
Defina o modo de saída. Este é o mesmo que virt-v2v -o opção. Veja "OPÇÕES" em
virt-v2v(1).

Se não for especificado, o padrão é "local", e o convidado convertido é escrito para
/ var / tmp.

p2v.oa = esparso | pré-alocado
Defina o modo de alocação de saída. Este é o mesmo que virt-v2v -oa opção. Ver
"OPÇÕES" em virt-v2v(1).

p2v.oc = ...
Defina o URI de libvirt da conexão de saída. Este é o mesmo que virt-v2v -oc opção.
Veja "OPÇÕES" em virt-v2v(1) e http://libvirt.org/uri.html

p2v.of = raw | qcow2 | ...
Defina o formato de saída. Este é o mesmo que virt-v2v -do opção. Veja "OPÇÕES" em
virt-v2v(1).

p2v.os = ...
Defina o armazenamento de saída. Este é o mesmo que virt-v2v -osso opção. Veja "OPÇÕES"
in virt-v2v(1).

Se não for especificado, o padrão é / var / tmp (no servidor de conversão).

p2v.pre = COMANDO
p2v.pre = "COMANDO ARG ... "
Selecione um comando de pré-conversão para executar. Qualquer comando ou script pode ser especificado aqui.
Se o comando contiver espaços, você deve colocar todo o comando entre aspas duplas.
O padrão é não executar nenhum comando.

p2v.post = poweroff
p2v.post = reboot
p2v.post = COMANDO
p2v.post = "COMANDO ARG ... "
Selecione um comando de pós-conversão a ser executado se a conversão for bem-sucedida. Isso pode ser qualquer
comando ou script. Se o comando contém espaços, você deve citar todo o comando
com aspas duplas.

If virt-p2v está sendo executado como root, e a linha de comando foi definida a partir de / proc / cmdline (Não é
--cmdline), então o padrão é executar o desligar(8) comando. Caso contrário, o padrão
não é executar nenhum comando.

p2v.fail = COMANDO
p2v.fail = "COMANDO ARG ... "
Selecione um comando de pós-conversão a ser executado se a conversão falhar. Qualquer comando ou script
pode ser especificado aqui. Se o comando contém espaços, você deve citar o todo
comando com aspas duplas. O padrão é não executar nenhum comando.

ip = dhcp
Use DHCP para configurar a interface de rede (este é o padrão).

SSH IDENTIDADES

Como uma alternativa um pouco mais segura para autenticação de senha, você pode usar um SSH
identidade (chave privada) para autenticação.

Primeiro crie um par de chaves. Deve ter uma senha longa vazia:

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

Isso cria um par de chave privada ("id_rsa") e uma chave pública ("id_rsa.pub").

A chave pública deve ser anexada ao arquivo "authorized_keys" na conversão virt-v2v
servidor (geralmente para "/root/.ssh/authorized_keys").

Para distribuir a chave privada, existem quatro cenários do menos seguro ao mais
seguro:

1. Não usar identidades SSH, ou seja, autenticação de senha.

Qualquer pessoa que possa detectar os parâmetros de inicialização PXE da rede ou observar a senha
alguma outra maneira pode fazer login no servidor de conversão virt-v2v.

2. Identidade SSH incorporada no ISO virt-p2v ou imagem de disco. Na GUI, use:

│ Senha: [ ] │
│ │
│ URL de identidade SSH: [arquivo: /// var / tmp / id_rsa _____________] │

ou na linha de comando do kernel:

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

A chave privada SSH ainda pode ser detectada na rede se estiver usando o PXE padrão.

3. Identidade SSH baixada de um site. Na GUI, use:

│ Senha: [ ] │
│ │
│ URL de identidade SSH: [https://internal.example.com/id_rsa] │

ou na linha de comando do kernel:

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

Qualquer pessoa ainda pode baixar a chave privada e usá-la para fazer login no virt-v2v
servidor de conversão, mas você pode fornecer alguma segurança extra configurando o
servidor para permitir apenas conexões de máquinas P2V.

4. Identidade SSH incorporada no ISO virt-p2v ou imagem de disco (como 2.), e uso de seguro
PXE, PXE em rede física separada ou sneakernet para distribuir virt-p2v para o
máquina física.

Ambos virt-p2v-criar-disco(1) e virt-p2v-make-kickstart(1) tem a mesma opção
--inject-ssh-identidade para injetar a chave privada na imagem de disco virt-p2v / ISO.
Consulte também as seguintes seções do manual:

"ADICIONANDO UMA IDENTIDADE SSH" em virt-p2v-criar-disco(1).

"ADICIONANDO UMA IDENTIDADE SSH" em virt-p2v-make-kickstart(1).

OPÇÕES

--Socorro
Exibir ajuda.

--cmdline = CMDLINE
Isso é usado para depuração. Em vez de analisar a linha de comando do kernel de
/ proc / cmdline, analise o parâmetro de string "CMDLINE".

-v
--verbose
Habilite a depuração (no servidor de conversão).

-V
--versão
Exibe o número da versão e sai.

COMO VIRT-P2V FUNCIONA

Observação esse seção is não normativo. Podemos mudar a forma como virt-p2v funciona a qualquer momento no
futuro.

Conforme descrito acima, virt-p2v é executado em uma máquina física, interroga o usuário ou o
linha de comando do kernel para configuração e, em seguida, estabelece uma ou mais conexões ssh para
o servidor de conversão virt-v2v. As conexões ssh são sessões de shell interativas para o
host remoto, mas os comandos enviados são gerados inteiramente pelo próprio virt-p2v, não pelo
do utilizador. Para transferência de dados, virt-p2v usará o recurso de encaminhamento de porta reversa do ssh (ou seja,
"ssh -R").

Ele fará primeiro uma ou mais conexões de teste, que são usadas para consultar o controle remoto
versão do virt-v2v e seus recursos. As conexões de teste são fechadas antes da conversão
começa.

┌────────────────┐ ┌───────────────────┐
│ virt-p2v │ │ virt-v2v │
│ (física │ conexão de controle │ (conversão │
│ servidor) ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ servidor) │
└────────────────┘ └───────────────────┘

Assim que virt-p2v estiver pronto para iniciar a conversão, ele abrirá uma única conexão de controle ssh.
Ele primeiro envia um comando mkdir para criar um diretório temporário no servidor de conversão.
O nome do diretório é escolhido aleatoriamente e é exibido na GUI. Possui a forma:

/ tmp / virt-p2v-AAAAMMDD-XXXXXXXX

onde "AAAAMMDD" é a data atual e os X são caracteres aleatórios.

Neste diretório estão gravados vários arquivos que incluem:

dmesg
(antes conversão)

A saída dmesg da máquina física. Útil para detectar problemas como
drivers de dispositivo ausentes ou firmware no ISO virt-p2v.

nome
(antes conversão)

O nome (geralmente o nome do host) da máquina física.

Physical.xml
(antes conversão)

Libvirt XML que descreve a máquina física. É usado para passar dados sobre o
host de origem física para virt-v2v(1) por meio do -i libvirtxml opção.

Observe que este não é um XML libvirt "real" (e deve nunca ser carregado na libvirt, que
iria rejeitá-lo de qualquer maneira). Além disso, não é o mesmo que o XML libvirt que virt-v2v
gera em certos modos de saída.

estado
(depois de conversão)

O status final da conversão. 0 se a conversão foi bem-sucedida. Diferente de zero se
a conversão falhou.

tempo
(antes conversão)

A data / hora de início da conversão.

virt-v2v-conversion-log.txt
(durante / depois conversão)

O registro de conversão. Esta é apenas a saída do comando virt-v2v na conversão
servidor. Se a conversão falhar, você deve examinar este arquivo de log e pode ser solicitado
para fornecer o bio-descontaminação, não editado arquivo de log em quaisquer relatórios de bug ou tíquetes de suporte.

Antes que a conversão realmente comece, virt-p2v então faz uma ou mais conexões ssh adicionais
para o servidor para transferência de dados. O protocolo de transferência usado atualmente é NBD (Rede
Dispositivo de bloco), que é proxy sobre ssh. O servidor é qemu-nbd(1). Há um ssh
conexão por disco rígido físico na máquina de origem (o caso comum - um único disco rígido
disco - é mostrado abaixo):

┌────────────────┐ ┌───────────────────┐
│ virt-p2v │ │ virt-v2v │
│ (física │ conexão de controle │ (conversão │
│ servidor) ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ servidor) │
│ │ │ │
│ │ conexão de dados │ │
│ ╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍ ▶ │
│qemu-nbd ← ─┘ │ │└─ ← NBD │
│ / dev / sda │ │ solicitações │
∼ ∼ ∼ ∼
└────────────────┘ └───────────────────┘

Embora a conexão de dados ssh seja originada do servidor físico e termine em
o servidor de conversão, na verdade, as solicitações NBD fluem na direção oposta. Isto é
porque o recurso de encaminhamento de porta reversa do ssh ("ssh -R") é usado para abrir uma porta no
interface de loopback do servidor de conversão que é proxy de volta por ssh para o qemu-nbd
servidor em execução na máquina física. O efeito é que virt-v2v via libguestfs pode
conexões nbd abertas que leem diretamente o (s) disco (s) rígido (s) do servidor físico.

Duas camadas de proteção são usadas para garantir que não haja gravações nos discos rígidos:
Em primeiro lugar, o qemu-nbd -r (somente leitura) opção é usada. Em segundo lugar, libguestfs cria um
sobreposição na parte superior da conexão NBD que armazena as gravações em um arquivo temporário no
arquivo de conversão.

A etapa final é enviar o comando "virt-v2v -i libvirtxml physical.xml ..." para o
servidor de conversão através da conexão de controle. Isso faz referência ao Physical.xml arquivo (ver
acima), que por sua vez faz referência à (s) porta (s) de escuta NBD da (s) conexão (ões) de dados.

A saída do comando virt-v2v (mensagens, depuração, etc.) é salva no arquivo de log
no servidor de conversão e enviado pela conexão de controle para ser exibido no
IU gráfica.

Use virt-p2v online usando serviços onworks.net