Novo Plugin QEMU Bacula Enterprise (Proxmox, KVM, Oracle Virtualization etc.). Guia Rápido

Novo Plugin QEMU Bacula Enterprise (Proxmox, KVM, Oracle Virtualization etc.). Guia Rápido

Visão Geral das Funcionalidades

  • Backup online baseado em transações de quaisquer VMs QEMU em execução
  • Backup de imagem de disco virtual completo e incremental em nível de blocos
  • Recuperação fácil de VM para o cluster original ou alternativo
  • Capacidade de restaurar imagens de disco virtual como arquivos QCOW2
  • Capacidade de restaurar completamente um convidado VM, incluindo configurações da VM
  • Capacidade de restaurar completamente imagens de disco de destino para QEMU genuíno
  • Capacidade de restaurar imagens de disco virtual VM para um diretório alternativo

Backup de Imagem com Plugin QEMU

Com a estratégia de backup em nível de imagem, o Plugin Bacula Enterprise QEMU salvará discos de VM como imagens QCOW2 para VMs QEMU, tanto para backups completos quanto incrementais.

Para que isso funcione, não é necessário um Daemon de Arquivo Bacula em cada convidado VM. O Plugin Bacula QEMU entrará em contato com o hipervisor QEMU para ler e salvar o conteúdo dos discos da máquina virtual usando a função de backups de transações QMP e os despejará usando a API QMP.

O Bacula não precisa percorrer os sistemas de arquivos do cliente para iniciar, abrir, ler e fechar arquivos, portanto, ele consome menos recursos na infraestrutura QEMU do que um backup de nível de arquivo em cada VM faria. Por outro lado, o Bacula também lerá e salvará dados inúteis nas VMs, como arquivos swap ou temporários.

Visão Geral do Backup e Restauração

Backup

O Plugin QEMU suporta o protocolo de controle QMP, que é uma interface de gerenciamento de baixo nível para todos os sabores de hipervisores QEMU. Na maioria dos casos, essa interface é usada por ferramentas de gerenciamento de hipervisor para gerenciar convidados VM QEMU.

A versão atual do Plugin foi testada em alguns tipos de hipervisores QEMU:

  • QEMU genuíno – modo=QEMU (o padrão)
  • Proxmox (PVE) – modo=PVE
  • Oracle Virtualization
  • KVM

O procedimento central de backup e restauração é o mesmo para cada tipo de hipervisor QEMU. A principal diferença é a maneira como um VM é selecionado para ser restaurado e como o processo de restauração é finalizado.

O backup central de um único convidado VM consiste nos seguintes passos:

  • Consultar informações do VM e salvá-las
  • Para um nível de backup completo, durante a transação de backup, criar ou limpar o dirtyblock e despejar a imagem do disco VM na área de trabalho (verificar a Localização do Diretório de Trabalho)
  • Para um nível de backup incremental, durante a transação de backup, despejar a imagem incremental do disco VM na área de trabalho e limpar o bitmap sujo
  • Quando o despejo da imagem do disco VM estiver pronto, o FileDaemon do Bacula enviará os dados para o Storage Daemon.

Os backups podem ser executados apenas para VMs em estado de execução. Qualquer primeiro backup completo criará uma cadeia de backup usada para backups incrementais subsequentes. A versão atual do plugin cria e mantém uma única cadeia de backup para cada VM.

Aviso

Você nunca deve misturar diferentes trabalhos de backup para uma única VM QEMU, pois isso quebrará a cadeia de backup e os backups se tornarão irrecuperáveis!

O Plugin QEMU registrará o início e o fim de cada backup da VM:

JobId 104: Start Backup JobId 104, Job=proxmox.2021-10-28_12.04.54_42
JobId 104: Recycled volume "vol01"
JobId 104: Using Device "FileChgr1-Dev2" to write.
JobId 104: qemu: Connected to Proxmox pve-manager/6.4-13/9f411e79 (running kernel: 5.4.143-1-pve)
JobId 104: qemu: Start Backup vm: vm1 (100)
JobId 104: qemu: Finish backup of vm1/drive-scsi0
...

O backup criará um único arquivo (.qcow2) para cada dispositivo de disco VM salvo e um único arquivo de configuração de VM (config.json) durante um backup completo.

/@qemu/<nome-vm>/<vmid>/<nome-drive>.qcow2 para cada imagem de disco VM
/@qemu/<nome-vm>/<vmid>/config.json para dados de configuração da VM

Dica

Para o modo QEMU genuíno, <vmid> geralmente será sempre definido como zero e <nome-vm> é o valor definido pelo parâmetro de execução do QEMU -name na linha de comando do QEMU.

Vários arquivos serão criados durante um backup se várias VMs de convidados forem copiadas com um trabalho (apenas no modo de backup Proxmox). Os nomes distintos de arquivos, conforme mostrado acima, ajudarão a localizar as imagens adequadas dos convidados para a restauração.

Restauração

O Plugin QEMU permite os seguintes destinos para operações de restauração:

  • Restauração para um diretório local como arquivos de imagem de disco QCOW2 e um único arquivo de configuração
  • Restauração para um hipervisor QEMU Genuíno no local original do arquivo de dispositivo
  • Restauração para a infraestrutura de virtualização Proxmox como um VMID original ou novo
  • Restauração para um Diretório Local

Para usar esse modo, o parâmetro where=/algum_diretório de uma restauração Bacula é definido como um caminho completo no servidor onde o Plugin QEMU está instalado. Se o caminho não existir, o Plugin QEMU do Bacula o criará. O Bacula irá automaticamente aplicar os backups incrementais nos discos de destino. O resultado final será um arquivo de imagem de disco QCOW2 “pronto para uso”. Para esse tipo de destino, você sempre obterá imagens de disco no formato QCOW2.

Restauração para QEMU Genuíno

Para usar esse modo de restauração, o parâmetro where=/ de uma restauração Bacula é usado. As imagens de disco dos convidados VM serão restauradas e automaticamente patcheadas com todos os backups incrementais no diretório de trabalho (verifique o Local do Diretório de Trabalho para obter detalhes). Em seguida, todos os arquivos de imagem patcheados e prontos para uso serão convertidos de volta para o local de destino original e o formato de imagem quando o parâmetro de plugin de restauração convdestination: yes for definido. Isso permite obter imagens de VMs de convidados do QEMU prontas para serem executadas em seu local original.

Esse modo de restauração é selecionado para todos os backups executados para o QEMU Genuíno.

Restauração para Proxmox

Para usar esse modo de restauração, o parâmetro where=/ de uma restauração Bacula é usado. As imagens de disco das VMs serão restauradas e automaticamente patcheadas com todos os backups incrementais no diretório de trabalho (verifique o Local do Diretório de Trabalho para obter detalhes). Em seguida, todos os arquivos de imagem patcheados e prontos para uso serão transferidos para o armazenamento Proxmox conectado à imagem original.

O Plugin QEMU tentará criar o mesmo VMID que estava durante o backup. Se o convidado VM já existir com esse VMID, o plugin alocará um novo VMID. Ele nunca sobrescreverá um convidado VM existente.

Todos os outros parâmetros de configuração de convidados VM serão restaurados conforme foram copiados, incluindo os endereços MAC de rede. Por esse motivo, é recomendável inspecionar e possivelmente atualizar a configuração da VM antes de iniciá-la. Caso contrário, conflitos de recursos podem surgir.

O alvo de armazenamento a ser usado para os disco(s) de convidado VM restaurados pode ser definido usando a opção de restauração de armazenamento do plugin. Se essa opção não for definida, todos os discos da VM serão restaurados em seu Armazenamento original.

Para listar os Armazenamentos disponíveis, um modo de listagem está disponível, descrito no capítulo de listagem.

Esse modo de restauração é selecionado para todos os backups executados para o Proxmox.

Atenção

O Plugin QEMU não pode ser usado para migração automática de convidados VM QEMU do QEMU Genuíno para uma infraestrutura de virtualização Proxmox, mas você pode realizar uma migração de Proxmox para QEMU Genuíno usando o modo de backup=QEMU para ambos.

Instalação

O File Daemon do Bacula Enterprise e seu Plugin QEMU precisam ser instalados no host do hipervisor Proxmox que executa os convidados VM que serão copiados. O Proxmox usa uma distribuição Debian personalizada, portanto, o File Daemon do Bacula Enterprise para essa plataforma deve ser usado.

A instalação do File Daemon e Plugin Bacula Enterprise QEMU é mais facilmente realizada utilizando o bee_installation_manager: https://www.bacula.lat/automatic-server-installation-with-bacula-enterprise-manager-centos-debian-etc/

Na falta de conexão do cliente com a Internet, os pacotes bacula-enterprise-client, libs/common, e do plugin qemu, podem ser baixados e instalados manutalmente através dos comandos dpkg (família Debian) ou rpm (família RedHat).

Configuração do Plugin

O plugin é configurado usando Parâmetros de Plugin definidos na seção Include de um FileSet na configuração do Diretor do Bacula Enterprise.

Parâmetros Genéricos do Plugin

Os seguintes parâmetros do Plugin QEMU afetam qualquer tipo de Job (Backup, Estimativa ou Restauração).

  • abort_on_error[=<0|1>]
    especifica se o plugin deve abortar a execução (e falhar o Job do Bacula) se ocorrer um erro fatal durante uma operação de Backup, Estimativa ou Restauração. Esse parâmetro é opcional. O valor padrão é 0.
  • working=</path/to/dir>
    especifica o diretório usado para qualquer operação de backup ou restauração do Plugin QEMU. O valor padrão é o parâmetro de configuração WorkingDir do Bacula FD (verificar Localização do Diretório de Trabalho). Esse parâmetro é opcional.

Parâmetros Genéricos de Estimativa e Backup do QEMU Autêntico

Esses parâmetros do plugin são relevantes apenas para os jobs de Backup e Estimativa:

  • qmpcontrol=</path/to/qmp/socket>
    especifica o local do socket de controle QMP usado para operações de backup. Quando este parâmetro é definido, isso implica o modo=QEMU. Este parâmetro é obrigatório para o QEMU Autêntico e é configurado automaticamente para outras plataformas de virtualização. Para outras plataformas de virtualização, esse parâmetro é proibido.
  • mode=[QEMU|PVE]
    especifica o tipo padrão de suporte QEMU. Deve ser definido como QEMU para virtualização QEMU Autêntica e PVE para virtualização Proxmox. Quando não definido, o modo de operação QEMU é configurado, o que requer um parâmetro qmpcontrol=… adequado para ser configurado.
  • timeout=<segundos>
    especifica o tempo que o Plugin QEMU aguardará o término de um despejo de imagem. Quando esse tempo limite for atingido, o job falhará. Se não definido, um valor padrão de 3600 segundos será usado. Esse parâmetro é opcional.
  • bitmap-persistence=[0|1]
    especifica se o QEMU deve persistir um mapa de blocos sujos usado para backups incrementais no próprio dispositivo. A persistência do bitmap é suportada apenas nos arquivos de imagem QCOW2. Definir essa opção em dispositivos que não a suportam causará a falha do job de backup. A persistência do bitmap é definida apenas durante o primeiro job de backup Full. Para o Proxmox, esse parâmetro é definido como ‘0’. Esse parâmetro é opcional.

Importante

O bitmap de bloco sujo efêmero (quando bitmap-persistence=0) será recriado a cada reinicialização da VM, forçando um backup VM completo.

  • vm=<nome>
    especifica o nome de uma VM convidada para backup. Todas as VMs convidadas com o <nome> fornecido serão selecionadas para backup. Múltiplos parâmetros vm=… são permitidos. Se uma VM convidada com <nome> não puder ser encontrada, um erro de job único será gerado e o backup continuará para a próxima VM, a menos que abort_on_error seja definido, o que fará com que o job de backup falhe. Esse parâmetro é opcional e usado apenas quando o modo é PVE.
  • vmid=<vmid>
    especifica o VMID de uma VM convidada para backup. Múltiplos parâmetros vmid=… podem ser fornecidos. Se uma VM convidada com <vmid> não puder ser encontrada, um erro de job será gerado e o backup continuará para a próxima VM, a menos que abort_on_error seja definido, o que fará com que o job de backup falhe. Esse parâmetro é opcional e usado apenas quando o modo é PVE.
  • include=<nome-regex>
    especifica uma lista de nomes de VMs convidadas para backup usando a sintaxe de expressão regular. Todas as VMs convidadas com nomes que correspondam à expressão regular name-regex fornecida serão selecionadas para backup. Múltiplos parâmetros include=… podem ser fornecidos. A correspondência é insensível a maiúsculas e minúsculas. Se nenhuma VM convidada corresponder à expressão name-regex fornecida, o backup continuará para os próximos parâmetros ou terminará com sucesso sem fazer backup de nenhuma VM. O parâmetro abort_on_error não falhará o job quando nenhuma VM convidada for encontrada usando a correspondência de nome. Esse parâmetro é opcional e usado apenas quando o modo é PVE.
  • exclude=<nome-regex>
    especifica uma lista de nomes de VMs convidadas que serão excluídas do backup usando correspondência de expressão regular. Todas as VMs convidadas com nomes que correspondam à expressão regular fornecida e selecionadas para backup usando o parâmetro include=… serão excluídas. A correspondência não é sensível a maiúsculas e minúsculas. Esse parâmetro não afeta nenhuma VM convidada selecionada para backup usando os parâmetros vm=…, vmid=…, include=… ou exclude=…. Múltiplos parâmetros exclude=… podem ser fornecidos. Esse parâmetro é opcional e usado apenas quando o modo é PVE.

Se nenhum dos parâmetros vm=…, vmid=…, include=… e exclude=… for especificado, todas as VMs convidadas disponíveis no hipervisor Proxmox serão incluídas no backup. Para o QEMU Autêntico, uma única VM apontada pelo parâmetro qmpcontrol=… será incluída no backup.

Localização do Diretório de Trabalho

Para realizar qualquer uma das operações de job de backup ou restauração, o Plugin QEMU requer algum espaço de armazenamento disponível. O espaço necessário depende do tamanho do maior arquivo de imagem de disco durante o backup e da soma das imagens de disco da VM durante a restauração. Para as operações de restauração, o espaço é necessário para o patch incremental adequado da imagem.

Essa limitação é uma consequência direta da limitação de backup da unidade QEMU QMP, que suporta arquivos de imagem de disco salvos apenas em um arquivo regular.

A localização exata da área de trabalho pode ser selecionada com o parâmetro de plugin working=…. Quando esse parâmetro não é definido, um valor padrão do parâmetro WorkingDirectory do Bacula será usado.

Esse espaço de armazenamento é automaticamente limpo após a operação, a menos que você selecione uma operação de restauração sem conversão da imagem de disco para o destino (verifique o parâmetro de restauração convdestination).

Exemplos de FileSet

Como mostrado na Figura 1, tanto o FileSet quanto o job de backup do Plugin QEMU podem ser configurados através da interface gráfica do Bacula Enterprise, atualmente o BWeb.

Figura 1. Exemplo ilustrativo FileSet para backup de VM no Bweb.

No exemplo abaixo, uma única VM QEMU será feita backup.

FileSet {
  Name = FS_qemu
  Include {
    Plugin = "qemu: qmpcontrol=/images/vm1.qmp"
  }
}

Agora a mesma VM QEMU, mas com localização de trabalho personalizada.

FileSet {
  Name = FS_qemu_working
  Include {
    Plugin = "qemu: qmpcontrol=/images/vm1.qmp working=/tmp"
  }
}

No exemplo abaixo, todas as VMs convidadas do Promox serão feitas backup.

FileSet {
  Name = FS_ProxmoxAll
  Include {
    Plugin = "qemu: mode=PVE"
  }
}

Neste exemplo, uma única VM com o nome “VM1” será feita backup.

FileSet {
  Name = FS_Proxmox_VM1
  Include {
    Plugin = "qemu: mode=PVE vm=VM1"
  }
}

O mesmo exemplo anterior, mas usando vmid em vez disso:

FileSet {
  Name = FS_Proxmox_VM1
  Include {
    Plugin = "qemu: mode=PVE vmid=101"
  }
}

No exemplo a seguir, todas as VMs que contêm “Prod” em seus nomes serão feitas backup.

FileSet {
  Name = FS_Proxmox_ProdAll
  Include {
    Plugin = "qemu: mode=PVE include=Prod"
  }
}

Neste exemplo final, todas as VMs convidadas, exceto as VMs cujo nome começa com “Test”, serão feitas backup.

FileSet {
  Name = FS_Proxmox_AllbutTest
  Include {
    Plugin = "qemu: mode=PVE include=.* exclude=^Test"
  }
}

Parâmetros de Restauração do Plugin

Durante a restauração, o Plugin QEMU usará os mesmos parâmetros que foram definidos para o job de backup. Essas configurações são salvas no catálogo no momento em que o job de backup é executado. Alguns deles podem ser alterados durante o processo de restauração, se necessário.

  • convdestination: [yes|no]
    especifica se uma imagem de disco restaurada deve ser convertida para o formato e localização originais, conforme definido durante o backup. Esse parâmetro funciona apenas no modo QEMU Autêntico. Se não definido ou definido como no (o padrão), as imagens de disco virtual do QEMU estarão disponíveis no local de trabalho (consulte o próximo parâmetro) como arquivos no formato QCOW2. Nesse caso, você pode movê-lo manualmente para o destino necessário ou convertê-lo para o formato desejado. Esse parâmetro é opcional.
  • working: </path/to/dir>
    especifica o diretório usado para operações de restauração do Plugin QEMU, conforme descrito em Localização do Diretório de Trabalho. O valor padrão é o mesmo que o de backup e pode ser definido pela configuração do plugin ou pelo parâmetro de configuração WorkingDir do Bacula FD. Esse parâmetro é opcional.
  • storage: <storage>
    especifica um Armazenamento Proxmox para o qual as VMs convidadas restauradas serão restauradas. Se não for definido, uma VM convidada será restaurada no Armazenamento Proxmox do qual foi feito o backup. Se esse parâmetro apontar para um Armazenamento inexistente, o Armazenamento original da VM convidada será usado. Esse parâmetro é opcional.

Exemplos Práticos de Restauração

Como mostrado na Figura 2, todos os jobs de restauração podem ser executados através da interface gráfica do Bacula Enterprise, atualmente o BWeb, pelo Dashboard de VMs ou do Menu Restore, ou através dos comandos CLI arrolados mais adiante.

Figura 2. Exemplo de Restore de VMs pelo Bweb, “VM Dashboard”.

Restauração com o QEMU Genuíno

Para restaurar uma VM ou VMs usando o modo Verdadeiro QEMU, você deve executar o comando de restauração e especificar o parâmetro “where” como neste exemplo:

* restore where=/

e, em seguida, definir quaisquer outros parâmetros de restauração necessários para o plugin de restauração.
No exemplo a seguir de sessão de restauração, a opção de restauração do plugin “convdestination” é definida como “sim”:

* restore where=/
...
Run Restore job
JobName: RestoreFiles
Bootstrap: /opt/bacula/working/qemu-test-dir.restore.2.bsr
Where: /
Replace: Always
FileSet: Full Set
Backup Client: qemu-test-fd
Restore Client: qemu-test-fd
Storage: File1
When: 2021-11-01 13:19:16
Catalog: MyCatalog
Priority: 10
Plugin Options: *None*
OK to run? (yes/mod/no): mod
Parameters to modify:
1: Level
2: Storage
3: Job
4: FileSet
5: Restore Client
6: When
7: Priority
8: Bootstrap
9: Where
10: File Relocation
11: Replace
12: JobId
13: Plugin Options
Select parameter to modify (1-13): 13
Automatically selected : qemu: qmpcontrol=/images/vm1.qmp abort_on_error
Plugin Restore Options
Option Current Value Default Value
working: *None* (*None*)
convdestination: *None* (*None*)
Use above plugin configuration? (yes/mod/no): mod
You have the following choices:
1: working (Plugin working directory)
2: convdestination (Convert qcow2 restore to original destination)
Select parameter to modify (1-2): 2
Please enter a value for convdestination: yes
Plugin Restore Options
Option Current Value Default Value
working: *None* (*None*)
convdestination: yes (*None*)
Use above plugin configuration? (yes/mod/no): yes
...

Durante um trabalho de restauração, você deve obter informações sobre cada processo de restauração, incluindo o incremento de dispositivos de disco restaurados e o processo de conversão de destino.

JobId 121: Start Restore Job RestoreFiles.2021-11-01_13.05.11_03
JobId 121: Restoring files from JobId(s) 115,116,120
JobId 121: Using Device "FileChgr1-Dev1" to read.
JobId 121: qemu: VM to restore: VM1 (oid:0)
JobId 121: qemu: Start Restore vm: VM1 (rid:0) devices: 2
JobId 121: qemu: Restoring device: ide0-hd0
JobId 121: qemu: Restoring device: ide0-hd1
JobId 121: qemu: Patching incremental: ide0-hd0
JobId 121: qemu: Patching incremental: ide0-hd1
JobId 121: qemu: Patching incremental: ide0-hd0
JobId 121: qemu: Patching incremental: ide0-hd1

A nova VM de hóspede criada durante a restauração receberá um novo VMID (se o VMID original estiver em uso), mas o nome / nome do host permanecerá o mesmo que era com a VM original.

Restauração para um Hypervisor Proxmox

Para restaurar uma VM ou VMs para um hypervisor Proxmox, você deve executar o mesmo comando de restauração acima, e o processo básico de restauração é o mesmo. A principal diferença está na configuração final e no procedimento de importação de dispositivos, conforme mostrado abaixo:

JobId 117: Start Restore Job RestoreFiles.2021-11-02_17.26.25_07
JobId 117: Restoring files from JobId(s) 104,105,106,115,116
JobId 117: Using Device "FileChgr1-Dev2" to read.
JobId 117: qemu: VM to restore: vm1 (oid:100)
JobId 117: qemu: Start Restore vm: vm1 (rid:104) devices: 1
JobId 117: qemu: Restoring device: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: Elapsed time=00:06:42, Transfer rate=20.28 M Bytes/second
JobId 117: qemu: Successfully imported device drive-scsi0 as local-lvm:vm-104-disk-0
...

A nova VM criada durante a restauração receberá um novo VMID (se o VMID original estiver em uso), mas o nome / nome do host permanecerá o mesmo que era com a VM original.

Restauração para um Diretório Local

É possível restaurar a(s) imagem(s) de disco da VM de hóspede para um diretório local em vez de restaurá-las para um hypervisor como uma nova VM. Para fazer isso, a opção de restauração “where” deve apontar para um diretório local:

* restore where=/tmp/bacula/restores

Confira o seguinte exemplo para o teste “Restauração local da VM”:

JobId 118: Start Restore Job RestoreFiles.2021-11-02_17.37.34_09
JobId 118: Restoring files from JobId(s) 104,105,106,115,116
JobId 118: Using Device "FileChgr1-Dev1" to read.
JobId 118: Ready to read from volume "vol01" on File device "FileChgr1-Dev1" (/opt/bacula/archive).
JobId 118: qemu: VM local restore: vm1 (oid:100)
JobId 118: Forward spacing Volume "vol01" to addr=227
JobId 118: qemu: Restoring device: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: Elapsed time=00:06:57, Transfer rate=19.55 M Bytes/second
...

O log do trabalho de restauração mostrará que a restauração foi feita para um diretório local.

Outros

Listagem de Recursos

O Plugin QEMU da Bacula Enterprise suporta o recurso de listagem de plugin da Bacula Enterprise 8.x ou posterior. Esse modo permite que um plugin exiba informações úteis sobre os recursos Proxmox disponíveis, como:

  • Lista de nomes de VMs de hóspedes
  • Lista de VMIDs de hóspedes
  • Lista de Armazenamentos Proxmox

Esse recurso usa o “comando de ponto” .ls especial com o parâmetro “plugin=”. O comando requer os seguintes parâmetros a serem definidos:

  • client=
    Um nome de Cliente Bacula com o Plugin QEMU instalado.
  • plugin=
    Um nome de plugin, que seria “qemu:” neste caso, com parâmetros opcionais de plugin conforme descrito na seção “genericparameters”.
  • path=
    Um caminho de objeto a ser exibido.

Os valores suportados para o parâmetro “path=” são:

  • /
    para exibir tipos de objetos disponíveis para listagem.
  • vm
    para exibir uma lista de nomes de etiquetas de VMs de hóspedes.
  • vmid
    para exibir uma lista de VMIDs de hóspedes e ponteiros de etiquetas de nome.
  • storage
    para mostrar a lista de Armazenamentos disponíveis.

Para exibir os tipos de objeto disponíveis, siga o exemplo de comando a seguir:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 vm
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 vmid
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 storage
2000 OK estimate files=3 bytes=0

Para exibir a lista de todas as VMs disponíveis, o exemplo de comando a seguir pode ser usado:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/vm
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:18 vm1
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:18 vm3
2000 OK estimate files=2 bytes=17,179,869,184

Para exibir a lista de VMIDs de hóspedes, use o exemplo de comando a seguir:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/vmid
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:46 100 -> vm1
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:46 102 -> vm3
2000 OK estimate files=2 bytes=17,179,869,184

As listas de VM e VMID exibem um tamanho estimado da VM de hóspede com base nos tamanhos de imagens de disco virtuais ou reais.
Para exibir os Armazenamentos Proxmox disponíveis, o exemplo de comando a seguir pode ser usado:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/storage
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
brw-r----- 1 root root 0 2021-11-01 12:57:56 data
brw-r----- 1 root root 0 2021-11-01 12:57:56 local-lvm
2000 OK estimate files=2 bytes=0

Consulta de Recursos

O Plugin QEMU da Bacula Enterprise suporta o recurso de consulta de plugin da Bacula Enterprise 14.0 ou posterior. Esse modo permite que um plugin exiba as mesmas informações sobre os recursos Proxmox disponíveis que são definidas na listagem de recursos. O Plugin QEMU retorna dados de resposta no formato JSON.
Neste exemplo, há uma consulta sobre as VMs disponíveis:

*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=vm
[{"name":"vm1","vmid":100},{"name":"vm3","vmid":102}]
*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=vmid
[{"name":"vm3","vmid":102},{"name":"vm1","vmid":100}]

Neste exemplo, há uma consulta sobre os armazenamentos Proxmox disponíveis:

*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=storage
[{"name":"local"},{"name":"local-lvm"}]

Limitações

  • Não é possível executar o mesmo trabalho de backup da mesma VM de hóspede simultaneamente (trabalho duplicado).
  • Não é possível ter trabalhos de backup diferentes que fazem backup da mesma VM de hóspede, pois isso quebrará a cadeia de backup de mapa de bits sujo incremental. Nesse caso, uma recuperação bem-sucedida sequer será possível.
  • Os modelos de VM disponíveis no sistema Proxmox não podem ser salvos. Isso é uma limitação do Proxmox.
  • No modo de listagem e consulta com os parâmetros vm ou vmid, o plugin exibirá apenas as VMs em execução.
  • Toda operação de backup ou restauração de VM requer espaço de armazenamento suficiente no diretório de trabalho (verifique a Localização do Diretório de Trabalho). Isso é uma limitação geral do procedimento de backup QEMU QMP.

Referências

  • QEMU plugin (Bacula System SA)

Leave a Reply

New QEMU Bacula Enterprise Plugin (Proxmox, KVM, Oracle Virtualization etc.). Quick guide

New QEMU Bacula Enterprise Plugin (Proxmox, KVM, Oracle Virtualization etc.). Quick guide

Features Overview

  • Online backup based on transactions of any running QEMU VMs
  • Full and incremental virtual disk image backup at the block level
  • Easy VM recovery to the original or alternative cluster
  • Capability to restore virtual disk images as QCOW2 files
  • Capability to fully restore a guest VM, including VM configurations
  • Capability to fully restore destination disk images for genuine QEMU
  • Capability to restore VM virtual disk images to an alternate directory

Image Backup with QEMU Plugin

With the image-level backup strategy, the Bacula Enterprise QEMU Plugin will save VM disks as QCOW2 images for QEMU VMs, both for full and incremental backups.

For this to work, a Bacula File Daemon is not required in each guest VM. The Bacula QEMU Plugin will contact the QEMU hypervisor to read and save the content of virtual machine disks using the QMP transaction backup function and will dump them using the QMP API.

Bacula doesn’t need to traverse the client’s file systems to initiate, open, read, and close files, so it consumes fewer resources in the QEMU infrastructure than file-level backup in each VM would. On the other hand, Bacula will also read and save unnecessary data in VMs, such as swap or temporary files.

Backup and Restoration Overview

Backup

The QEMU Plugin supports the QMP control protocol, which is a low-level management interface for all flavors of QEMU hypervisors. In most cases, this interface is used by hypervisor management tools to manage QEMU guest VMs.

The current version of the Plugin has been tested on a few types of QEMU hypervisors:

  • Genuine QEMU – mode=QEMU (default)
  • Proxmox (PVE) – mode=PVE
  • Oracle Virtualization
  • KVM

The core procedure of backup and restoration is the same for each type of QEMU hypervisor. The main difference is how a VM is selected to be restored and how the restoration process is finalized.

The central backup of a single guest VM consists of the following steps:

  • Query VM information and save it
  • For a full backup level, during the backup transaction, create or clear the dirty block and dump the VM disk image to the workspace (check Working Directory Location)
  • For an incremental backup level, during the backup transaction, dump the incremental VM disk image to the workspace and clear the dirty bitmap
  • Once the VM disk image dump is ready, the Bacula FileDaemon will send the data to the Storage Daemon.

Backups can only be performed for running VMs. Any initial full backup will create a backup chain used for subsequent incremental backups. The current version of the plugin creates and maintains a single backup chain for each VM.

Warning

You should never mix different backup jobs for a single QEMU VM, as this will break the backup chain and backups will become unrecoverable!

The QEMU Plugin will log the start and end of each guest VM backup:

JobId 104: Start Backup JobId 104, Job=proxmox.2021-10-28_12.04.54_42
JobId 104: Recycled volume "vol01"
JobId 104: Using Device "FileChgr1-Dev2" to write.
JobId 104: qemu: Connected to Proxmox pve-manager/6.4-13/9f411e79 (running kernel: 5.4.143-1-pve)
JobId 104: qemu: Start Backup vm: vm1 (100)
JobId 104: qemu: Finish backup of vm1/drive-scsi0
...

The backup will create a single file (.qcow2) for each saved VM disk device and a single VM configuration file (config.json) during a full backup.

/@qemu/<vm-name>/<vmid>/<drive-name>.qcow2 for each VM disk image
/@qemu/<vm-name>/<vmid>/config.json for VM configuration data

Tip

For genuine QEMU mode, <vmid> is generally set to zero, and <vm-name> is the value defined by the QEMU -name execution parameter in the QEMU command line.

Several files will be created during a backup if multiple guest VMs are backed up with a job (only in Proxmox backup mode). The distinct file names, as shown above, will help locate the appropriate guest images for restoration.

Restore

The QEMU Plugin allows the following destinations for restore operations:

  • Restoration to a local directory as QCOW2 disk image files and a single configuration file
  • Restoration to a genuine QEMU hypervisor at the original device file location
  • Restoration to the Proxmox virtualization infrastructure as an original or new VMID
  • Restoration to a Local Directory

To use this mode, the where=/some_directory parameter of a Bacula restoration is set as a complete path on the server where the QEMU Plugin is installed. If the path doesn’t exist, the Bacula QEMU Plugin will create it. Bacula will automatically apply incremental backups to the target disks. The end result will be a QCOW2 disk image file “ready for use”. For this type of destination, you will always get disk images in the QCOW2 format.

Restore to Genuine QEMU

To use this restoration mode, the where=/ parameter of a Bacula restoration is used. The VM guest disk images will be restored and automatically patched with all incremental backups in the workspace (check Working Directory Location for details). Then, all patched and ready-to-use image files will be converted back to the original destination location and image format when the restoration plugin parameter convdestination: yes is set. This allows obtaining QEMU guest VM images ready to run in their original location.

This restoration mode is selected for all backups performed for Genuine QEMU.

Restore to Proxmox

To use this restoration mode, the where=/ parameter of a Bacula restore is used. The VM disk images will be restored and automatically patched with all incremental backups in the workspace (check Working Directory Location for details). Then, all patched and ready-to-use image files will be transferred to the Proxmox storage connected to the original image.

The QEMU Plugin will attempt to create the same VMID that was present during backup. If the guest VM already exists with that VMID, the plugin will allocate a new VMID. It will never overwrite an existing guest VM.

All other guest VM configuration parameters will be restored as they were copied, including network MAC addresses. For this reason, it’s recommended to inspect and possibly update the VM configuration before starting it. Otherwise, resource conflicts may arise.

The target storage to be used for the restored guest VM disk(s) can be defined using the storage restoration option of the plugin. If this option is not set, all VM disks will be restored to their original storage.

To list available storages, a listing mode is available, as described in the listing chapter.

This restoration mode is selected for all backups performed for Proxmox.

Attention

The QEMU Plugin cannot be used for automatic migration of QEMU guest VMs from Genuine QEMU to a Proxmox virtualization infrastructure, but you can perform a migration from Proxmox to Genuine QEMU using the backup=QEMU mode for both.

Installation

The Bacula Enterprise File Daemon and its QEMU Plugin need to be installed on the Proxmox hypervisor host running the guest VMs that will be copied. Proxmox uses a customized Debian distribution, so the Bacula Enterprise File Daemon for this platform should be used.

The installation of the File Daemon and Bacula Enterprise QEMU Plugin is most easily performed using the bee_installation_manager: https://www.bacula.lat/automatic-server-installation-with-bacula-enterprise-manager-centos-debian-etc/?lang=en

In the absence of a client’s Internet connection, the bacula-enterprise-client, libs/common, and qemu plugin packages can be downloaded and manually installed using the dpkg (Debian family) or rpm (RedHat family) commands.

Plugin Configuration

The plugin is configured using Plugin Parameters defined in the Include section of a FileSet in the Bacula Enterprise Director configuration.

Generic Plugin Parameters

The following QEMU Plugin parameters affect any type of Job (Backup, Estimate, or Restore).

  • abort_on_error[=<0|1>]
    specifies whether the plugin should abort execution (and fail the Bacula Job) if a fatal error occurs during a Backup, Estimate, or Restore operation. This parameter is optional. The default value is 0.
  • working=</path/to/dir>
    specifies the directory used for any QEMU Plugin backup or restore operation. The default value is the WorkingDir configuration parameter of the Bacula FD (check Working Directory Location). This parameter is optional.

Generic QEMU Authentic Estimate and Backup Parameters

These plugin parameters are relevant only for Backup and Estimate jobs:

  • qmpcontrol=</path/to/qmp/socket>
    specifies the location of the QMP control socket used for backup operations. When this parameter is set, it implies mode=QEMU. This parameter is mandatory for Genuine QEMU and is automatically configured for other virtualization platforms. For other virtualization platforms, this parameter is prohibited.
  • mode=[QEMU|PVE]
    specifies the default QEMU support type. It should be set to QEMU for Genuine QEMU virtualization and PVE for Proxmox virtualization. When not set, QEMU operation mode is configured, which requires a suitable qmpcontrol=… parameter to be configured.
  • timeout=<seconds>
    specifies the time the QEMU Plugin will wait for an image dump to finish. When this timeout is reached, the job will fail. If not set, a default value of 3600 seconds will be used. This parameter is optional.
  • bitmap-persistence=[0|1]
    specifies whether QEMU should persist a dirty block map used for incremental backups on the device itself. Bitmap persistence is supported only on QCOW2 image files. Setting this option on devices that do not support it will cause the backup job to fail. Bitmap persistence is only set during the first Full backup job. For Proxmox, this parameter is set to ‘0’. This parameter is optional.

Important

Ephemeral dirty block bitmap (when bitmap-persistence=0) will be recreated after each VM reboot, forcing a full VM backup.

      • vm=<name>
        specifies the name of a guest VM for backup. All guest VMs with the provided <name> will be selected for backup. Multiple vm=… parameters are allowed. If a guest VM with the <name> cannot be found, a single job error will be generated, and the backup will continue to the next VM, unless abort_on_error is set, which will cause the backup job to fail. This parameter is optional and used only when the mode is PVE.
      • vmid=<vmid>
        specifies the VMID of a guest VM for backup. Multiple vmid=… parameters can be provided. If a guest VM with the <vmid> cannot be found, a job error will be generated, and the backup will continue to the next VM, unless abort_on_error is set, which will cause the backup job to fail. This parameter is optional and used only when the mode is PVE.
      • include=<name-regex>
        specifies a list of guest VM names for backup using regular expression syntax. All guest VMs with names that match the provided name-regex expression will be selected for backup. Multiple include=… parameters can be provided. The matching is case-insensitive. If no guest VMs match the provided name-regex expression, the backup will continue to the next parameters or will complete successfully without backing up any VMs. The abort_on_error parameter will not fail the job when no guest VM is found using name matching. This parameter is optional and used only when the mode is PVE.
      • exclude=<name-regex>
        specifies a list of guest VM names that will be excluded from backup using regular expression matching. All guest VMs with names that match the provided expression and were selected for backup using the include=… parameter will be excluded. The matching is case-insensitive. This parameter does not affect any guest VM selected for backup using the vm=…, vmid=…, include=…, or exclude=… parameters. Multiple exclude=… parameters can be provided. This parameter is optional and used only when the mode is PVE.

    </ul > If none of the vm=…, vmid=…, include=…, and exclude=… parameters are specified, all available guest VMs on the Proxmox hypervisor will be included in the backup. For Genuine QEMU, a single VM pointed to by the qmpcontrol=… parameter will be included in the backup.

Working Directory Location

To perform any of the backup or restore job operations, the QEMU Plugin requires some available storage space. The required space depends on the size of the largest disk image file during backup and the sum of the VM disk images during restore. For restore operations, space is needed for proper incremental image patching.

This limitation is a direct consequence of the QEMU QMP backup unit limitation, which supports saved disk image files only as regular files.

The exact location of the workspace can be selected using the working=… plugin parameter. When this parameter is not defined, a default value from the Bacula WorkingDirectory parameter will be used.

This storage space is automatically cleaned up after the operation, unless you select a restore operation without disk image conversion to the destination (check the convdestination restore parameter).

FileSet Examples

As shown in Figure 1, both the FileSet and the QEMU Plugin backup job can be configured through the Bacula Enterprise graphical interface, currently BWeb.

Figure 1. Illustrative example of FileSet for VM backup in BWeb.

In the example below, a single QEMU VM will be backed up.

FileSet {
  Name = FS_qemu
  Include {
    Plugin = "qemu: qmpcontrol=/images/vm1.qmp"
  }
}

Now the same QEMU VM, but with a custom working location.

FileSet {
  Name = FS_qemu_working
  Include {
    Plugin = "qemu: qmpcontrol=/images/vm1.qmp working=/tmp"
  }
}

In the example below, all Proxmox guest VMs will be backed up.

FileSet {
  Name = FS_ProxmoxAll
  Include {
    Plugin = "qemu: mode=PVE"
  }
}

In this example, a single VM with the name “VM1” will be backed up.

FileSet {
  Name = FS_Proxmox_VM1
  Include {
    Plugin = "qemu: mode=PVE vm=VM1"
  }
}

The same previous example, but using vmid instead:

FileSet {
  Name = FS_Proxmox_VM1
  Include {
    Plugin = "qemu: mode=PVE vmid=101"
  }
}

In the following example, all guest VMs containing “Prod” in their names will be backed up.

FileSet {
  Name = FS_Proxmox_ProdAll
  Include {
    Plugin = "qemu: mode=PVE include=Prod"
  }
}

In this final example, all guest VMs except those whose names start with “Test” will be backed up.

FileSet {
  Name = FS_Proxmox_AllbutTest
  Include {
    Plugin = "qemu: mode=PVE include=.* exclude=^Test"
  }
}

Plugin Restore Parameters

During restoration, the QEMU Plugin will use the same parameters that were defined for the backup job. These settings are saved in the catalog at the time when the backup job is executed. Some of them can be changed during the restoration process if necessary.

      • convdestination: [yes|no]
        specifies whether a restored disk image should be converted to the original format and location as defined during backup. This parameter works only in Genuine QEMU mode. If not defined or set to no (the default), virtual QEMU disk images will be available in the workspace location (see the next parameter) as QCOW2 format files. In this case, you can manually move it to the desired destination or convert it to the desired format. This parameter is optional.
      • working: </path/to/dir>
        specifies the directory used for QEMU Plugin restoration operations, as described in the Working Directory Location section. The default value is the same as for backup and can be set either by the plugin configuration or the Bacula FD WorkingDir configuration parameter. This parameter is optional.
      • storage: <storage>
        specifies a Proxmox Storage to which the restored guest VMs will be restored. If not set, a guest VM will be restored to the Proxmox Storage from which it was backed up. If this parameter points to a non-existent Storage, the original Storage of the guest VM will be used. This parameter is optional.

Practical Restore Examples

As shown in Figure 2, all restoration jobs can be executed through the Bacula Enterprise graphical interface, currently BWeb, from the VM Dashboard or the Restore Menu, or through the CLI commands listed below.

Figure 2. Example of VM Restore through BWeb, “VM Dashboard”.

Restoration with True QEMU

To restore a VM or VMs using the True QEMU mode, you should execute the restore command and specify the “where” parameter as shown in this example:

* restore where=/

Then, proceed to set any other required restoration parameters for the restoration plugin.

In the following example of a restoration session, the restoration option “convdestination” is set to “yes”:

* restore where=/
...
Run Restore job
JobName: RestoreFiles
Bootstrap: /opt/bacula/working/qemu-test-dir.restore.2.bsr
Where: /
Replace: Always
FileSet: Full Set
Backup Client: qemu-test-fd
Restore Client: qemu-test-fd
Storage: File1
When: 2021-11-01 13:19:16
Catalog: MyCatalog
Priority: 10
Plugin Options: *None*
OK to run? (yes/mod/no): mod
Parameters to modify:
1: Level
2: Storage
3: Job
4: FileSet
5: Restore Client
6: When
7: Priority
8: Bootstrap
9: Where
10: File Relocation
11: Replace
12: JobId
13: Plugin Options
Select parameter to modify (1-13): 13
Automatically selected : qemu: qmpcontrol=/images/vm1.qmp abort_on_error
Plugin Restore Options
Option Current Value Default Value
working: *None* (*None*)
convdestination: *None* (*None*)
Use above plugin configuration? (yes/mod/no): mod
You have the following choices:
1: working (Plugin working directory)
2: convdestination (Convert qcow2 restore to original destination)
Select parameter to modify (1-2): 2
Please enter a value for convdestination: yes
Plugin Restore Options
Option Current Value Default Value
working: *None* (*None*)
convdestination: yes (*None*)
Use above plugin configuration? (yes/mod/no): yes
...

During a restore job, you should gather information about each restoration process, including the restored disk devices’ increments and the destination conversion process.

JobId 121: Start Restore Job RestoreFiles.2021-11-01_13.05.11_03
JobId 121: Restoring files from JobId(s) 115,116,120
JobId 121: Using Device "FileChgr1-Dev1" to read.
JobId 121: qemu: VM to restore: VM1 (oid:0)
JobId 121: qemu: Start Restore vm: VM1 (rid:0) devices: 2
JobId 121: qemu: Restoring device: ide0-hd0
JobId 121: qemu: Restoring device: ide0-hd1
JobId 121: qemu: Patching incremental: ide0-hd0
JobId 121: qemu: Patching incremental: ide0-hd1
JobId 121: qemu: Patching incremental: ide0-hd0
JobId 121: qemu: Patching incremental: ide0-hd1

The new guest VM created during the restoration will be assigned a new VMID (if the original VMID is in use), but the name/hostname will remain the same as it was with the original VM.

Restore to a Proxmox Hypervisor

To restore one or more VMs to a Proxmox hypervisor, you should follow the same restoration command as mentioned above, and the basic restoration process remains the same. The main difference lies in the final configuration and the device import procedure, as shown below:

JobId 117: Start Restore Job RestoreFiles.2021-11-02_17.26.25_07
JobId 117: Restoring files from JobId(s) 104,105,106,115,116
JobId 117: Using Device "FileChgr1-Dev2" to read.
JobId 117: qemu: VM to restore: vm1 (oid:100)
JobId 117: qemu: Start Restore vm: vm1 (rid:104) devices: 1
JobId 117: qemu: Restoring device: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: Elapsed time=00:06:42, Transfer rate=20.28 M Bytes/second
JobId 117: qemu: Successfully imported device drive-scsi0 as local-lvm:vm-104-disk-0
...

The new VM created during the restoration will receive a new VMID (if the original VMID is in use), but the name/hostname will remain the same as it was with the original VM.

Restoration to a Local Directory

It’s possible to restore the guest VM’s disk image(s) to a local directory instead of restoring them to a hypervisor as a new VM. To do this, the “where” restoration option should point to a local directory:

* restore where=/tmp/bacula/restores

Take a look at the following example for the “Local VM Restoration” test:

JobId 118: Start Restore Job RestoreFiles.2021-11-02_17.37.34_09
JobId 118: Restoring files from JobId(s) 104,105,106,115,116
JobId 118: Using Device "FileChgr1-Dev1" to read.
JobId 118: Ready to read from volume "vol01" on File device "FileChgr1-Dev1" (/opt/bacula/archive).
JobId 118: qemu: VM local restore: vm1 (oid:100)
JobId 118: Forward spacing Volume "vol01" to addr=227
JobId 118: qemu: Restoring device: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: Elapsed time=00:06:57, Transfer rate=19.55 M Bytes/second
...

The restoration job log will indicate that the restoration was performed to a local directory.

Others

Resource Listing

The Bacula Enterprise’s QEMU Plugin supports the resource listing feature of Bacula Enterprise 8.x or later. This mode allows a plugin to display useful information about available Proxmox resources, such as:

  • List of guest VM names
  • List of guest VM VMIDs
  • List of Proxmox storages

This feature uses the special “.ls command” with the “plugin=” parameter. The command requires the following parameters to be set:

  • client= A Bacula Client name with the QEMU Plugin installed.
  • plugin= A plugin name, which would be “qemu:” in this case, with optional plugin parameters as described in the “genericparameters” section.
  • path= An object path to be displayed.

The supported values for the “path=” parameter are:

  • / to display available object types for listing.
  • vm to display a list of guest VM name labels.
  • vmid to display a list of guest VM VMIDs and name label pointers.
  • storage to show the list of available Storages.

To display available object types, follow the example command below:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 vm
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 vmid
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 storage
2000 OK estimate files=3 bytes=0

To display the list of all available VMs, you can use the following example command:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/vm
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:18 vm1
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:18 vm3
2000 OK estimate files=2 bytes=17,179,869,184

To display the list of guest VM VMIDs, use the following example command:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/vmid
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:46 100 -> vm1
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:46 102 -> vm3
2000 OK estimate files=2 bytes=17,179,869,184

The VM and VMID lists display an estimated size of the guest VM based on the sizes of virtual or actual disk images.
To display the available Proxmox Storages, you can use the following example command:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/storage
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
brw-r----- 1 root root 0 2021-11-01 12:57:56 data
brw-r----- 1 root root 0 2021-11-01 12:57:56 local-lvm
2000 OK estimate files=2 bytes=0

Resource Query

The Bacula Enterprise QEMU Plugin supports the plugin query feature of Bacula Enterprise 14.0 or later. This mode allows a plugin to display the same information about available Proxmox resources that is defined in the resource listing. The Bacula Enterprise QEMU Plugin returns response data in JSON format.
In this example, there is a query about the available VMs:

*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=vm
[{"name":"vm1","vmid":100},{"name":"vm3","vmid":102}]
*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=vmid
[{"name":"vm3","vmid":102},{"name":"vm1","vmid":100}]

In this example, there is a query about the available Proxmox storages:

*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=storage
[{"name":"local"},{"name":"local-lvm"}]

Limitations

  • It is not possible to run the same backup job of the same guest VM simultaneously (duplicate job).
  • Having different backup jobs that back up the same guest VM is not possible, as this will break the incremental dirty bitmap backup chain. In such a case, successful recovery won’t even be possible.
  • Available VM templates in the Proxmox system cannot be saved. This is a limitation of Proxmox.
  • In listing and querying mode with the parameters vm or vmid, the plugin will only display running VMs.
  • Every VM backup or restoration operation requires sufficient storage space in the working directory (check the Location of the Working Directory). This is a general limitation of the QEMU QMP backup procedure.

References

  • QEMU plugin (Bacula System SA)

Leave a Reply

Nuevo Plugin Bacula Enterprise QEMU (Proxmox, KVM, virtualización de Oracle, etc.). Guía rápida

Nuevo Plugin Bacula Enterprise QEMU (Proxmox, KVM, virtualización de Oracle, etc.). Guía rápida

h2>Visión general de las funcionalidades

  • Backup en línea basado en transacciones de cualquier VM QEMU en ejecución
  • Backup de imagen de disco virtual completo e incremental a nivel de bloques
  • Recuperación fácil de VM para el clúster original o alternativo
  • Capacidad para restaurar imágenes de disco virtual como archivos QCOW2
  • Capacidad para restaurar completamente una VM invitada, incluyendo configuraciones de la VM
  • Capacidad para restaurar completamente imágenes de disco de destino para QEMU genuino
  • Capacidad para restaurar imágenes de disco virtual VM en un directorio alternativo

Backup de Imagen con Plugin QEMU

Con la estrategia de backup a nivel de imagen, el Plugin Bacula Enterprise QEMU guardará los discos de VM como imágenes QCOW2 para VMs QEMU, tanto para backups completos como incrementales.

Para que esto funcione, no se requiere un Daemon de Archivo Bacula en cada VM invitada. El Plugin Bacula QEMU se pondrá en contacto con el hipervisor QEMU para leer y guardar el contenido de los discos de la máquina virtual utilizando la función de backups de transacciones QMP y los volcará utilizando la API QMP.

Bacula no necesita explorar los sistemas de archivos del cliente para iniciar, abrir, leer y cerrar archivos, por lo tanto, consume menos recursos en la infraestructura QEMU que lo que haría un backup a nivel de archivo en cada VM. Por otro lado, Bacula también leerá y guardará datos inútiles en las VM, como archivos de intercambio o temporales.

Visión general de Backup y Restauración

Backup

El Plugin QEMU admite el protocolo de control QMP, que es una interfaz de gestión de bajo nivel para todos los tipos de hipervisores QEMU. En la mayoría de los casos, esta interfaz es utilizada por herramientas de gestión de hipervisores para manejar las VM invitadas de QEMU.

La versión actual del Plugin ha sido probada en algunos tipos de hipervisores QEMU:

  • QEMU genuino – modo=QEMU (por defecto)
  • Proxmox (PVE) – modo=PVE
  • Oracle Virtualization
  • KVM

El procedimiento central de backup y restauración es el mismo para cada tipo de hipervisor QEMU. La principal diferencia radica en cómo se selecciona una VM para restaurarla y cómo se finaliza el proceso de restauración.

El backup central de una única VM consta de los siguientes pasos:

  • Consultar la información de la VM y guardarla
  • Para un backup completo, durante la transacción de backup, crear o limpiar el dirtyblock y volcar la imagen del disco VM en el área de trabajo (verificar la Ubicación del Directorio de Trabajo)
  • Para un backup incremental, durante la transacción de backup, volcar la imagen incremental del disco VM en el área de trabajo y limpiar el bitmap sucio
  • Cuando la volcación de la imagen del disco VM esté lista, el FileDaemon de Bacula enviará los datos al Storage Daemon.

Los backups solo pueden ejecutarse para VMs en estado de ejecución. Cualquier primer backup completo creará una cadena de backup utilizada para backups incrementales subsiguientes. La versión actual del plugin crea y mantiene una única cadena de backup para cada VM.

Advertencia
Nunca debes mezclar diferentes trabajos de backup para una única VM QEMU, ¡ya que esto romperá la cadena de backup y los backups se volverán irreparables!

El Plugin QEMU registrará el inicio y el fin de cada backup de VM invitada:

JobId 104: Start Backup JobId 104, Job=proxmox.2021-10-28_12.04.54_42
JobId 104: Recycled volume "vol01"
JobId 104: Using Device "FileChgr1-Dev2" to write.
JobId 104: qemu: Connected to Proxmox pve-manager/6.4-13/9f411e79 (running kernel: 5.4.143-1-pve)
JobId 104: qemu: Start Backup vm: vm1 (100)
JobId 104: qemu: Finish backup of vm1/drive-scsi0
....

El backup creará un solo archivo (.qcow2) para cada dispositivo de disco VM guardado y un solo archivo de configuración de VM (config.json) durante un backup completo.

/@qemu/<nombre-vm>/<vmid>/<nombre-drive>.qcow2 para cada imagen de disco VM
/@qemu/<nombre-vm>/<vmid>/config.json para datos de configuración de VM

Consejo

Para el modo QEMU genuino, <vmid> generalmente siempre se establecerá como cero y <nombre-vm> es el valor definido por el parámetro de ejecución de QEMU -name en la línea de comandos de QEMU.

Se crearán varios archivos durante un backup si se copian varias VM invitadas con un trabajo (solo en el modo de backup Proxmox). Los nombres de archivo distintos, como se muestra arriba, ayudarán a localizar las imágenes adecuadas de las invitadas para la restauración.

Restauración

El Plugin QEMU permite los siguientes destinos para operaciones de restauración:

  • Restauración a un directorio local como archivos de imagen de disco QCOW2 y un solo archivo de configuración
  • Restauración a un hipervisor QEMU Genuino en la ubicación original del archivo de dispositivo
  • Restauración a la infraestructura de virtualización Proxmox como un VMID original o nuevo
  • Restauración a un Directorio Local

Para usar este modo, el parámetro where=/algún_directorio de una restauración Bacula se define como una ruta completa en el servidor donde está instalado el Plugin QEMU. Si la ruta no existe, el Plugin QEMU de Bacula la creará. Bacula aplicará automáticamente los backups incrementales en los discos de destino. El resultado final será un archivo de imagen de disco QCOW2 “listo para usar”. Para este tipo de destino, siempre se obtendrán imágenes de disco en formato QCOW2.

Restauración para QEMU Genuino

Para usar este modo de restauración, se utiliza el parámetro where=/ en una restauración Bacula. Las imágenes de disco de las VM invitadas se restaurarán y parchearán automáticamente con todos los backups incrementales en el directorio de trabajo (verificar la Ubicación del Directorio de Trabajo para más detalles). Luego, todos los archivos de imagen parcheados y listos para usar se convertirán de nuevo a la ubicación original de destino y al formato de imagen cuando se defina el parámetro de plugin de restauración convdestination: yes. Esto permitirá obtener imágenes de las VM invitadas de QEMU listas para ejecutarse en su ubicación original.

Este modo de restauración se selecciona para todos los backups ejecutados para QEMU Genuino.

Restauración para Proxmox

Para usar este modo de restauración, se utiliza el parámetro where=/ en una restauración Bacula. Las imágenes de disco de las VMs se restaurarán y parchearán automáticamente con todos los backups incrementales en el directorio de trabajo (verificar la Ubicación del Directorio de Trabajo para más detalles). Luego, todos los archivos de imagen parcheados y listos para usar se transferirán al almacenamiento Proxmox conectado a la imagen original.

El Plugin QEMU intentará crear el mismo VMID que estaba durante el backup. Si la VM invitada ya existe con ese VMID, el plugin asignará un nuevo VMID. Nunca sobrescribirá una VM invitada existente.

Todos los demás parámetros de configuración de VM invitada se restaurarán tal como se copiaron, incluyendo las direcciones MAC de red. Por esta razón, es recomendable inspeccionar y posiblemente actualizar la configuración de la VM antes de iniciarla. De lo contrario, podrían surgir conflictos de recursos.

El destino de almacenamiento a utilizar para los disco(s) de VM invitada restaurados se puede definir utilizando la opción de restauración de almacenamiento del plugin. Si esta opción no se define, todos los discos de la VM se restaurarán en su Almacenamiento original.

Para listar los Almacenamientos disponibles, hay un modo de listado disponible, descrito en el capítulo de listado.

Este modo de restauración se selecciona para todos los backups ejecutados para Proxmox.

Atención

El Plugin QEMU no se puede usar para migrar automáticamente las VMs invitadas de QEMU Genuino a una infraestructura de virtualización Proxmox, pero puedes realizar una migración de Proxmox a QEMU Genuino utilizando el modo de backup=QEMU para ambos.

Instalación

El File Daemon de Bacula Enterprise y su Plugin QEMU deben instalarse en el host del hipervisor Proxmox que ejecuta las VMs invitadas que serán copiadas. Proxmox utiliza una distribución Debian personalizada, por lo que debe usarse el File Daemon de Bacula Enterprise para esta plataforma.

La instalación del File Daemon y el Plugin Bacula Enterprise QEMU es más sencilla utilizando el bee_installation_manager: https://www.bacula.lat/automatic-server-installation-with-bacula-enterprise-manager-centos-debian-etc/?lang=es

En caso de que el cliente no tenga conexión a Internet, los paquetes bacula-enterprise-client, libs/common y del plugin qemu pueden descargarse e instalarse manualmente mediante los comandos dpkg (familia Debian) o rpm (familia RedHat).

Configuración del Plugin

El plugin se configura utilizando Parámetros de Plugin definidos en la sección Include de un FileSet en la configuración del Director de Bacula Enterprise.

Parámetros Genéricos del Plugin

Los siguientes parámetros del Plugin QEMU afectan a cualquier tipo de Trabajo (Backup, Estimación o Restauración).

  • abort_on_error[=<0|1>]
    especifica si el plugin debe abortar la ejecución (y fallar el Trabajo de Bacula) si ocurre un error fatal durante una operación de Backup, Estimación o Restauración. Este parámetro es opcional. El valor por defecto es 0.
  • working=</path/to/dir>
    especifica el directorio utilizado para cualquier operación de backup o restauración del Plugin QEMU. El valor por defecto es el parámetro de configuración WorkingDir del Bacula FD (verificar la Ubicación del Directorio de Trabajo). Este parámetro es opcional.

Parámetros Genéricos de Estimación y Backup del QEMU Auténtico

Estos parámetros del plugin solo son relevantes para los trabajos de Backup y Estimación:

  • qmpcontrol=</path/to/qmp/socket>
    especifica la ubicación del socket de control QMP utilizado para operaciones de backup. Cuando este parámetro se establece, implica el modo=QEMU. Este parámetro es obligatorio para QEMU Auténtico y se configura automáticamente para otras plataformas de virtualización. Para otras plataformas de virtualización, este parámetro está prohibido.
  • mode=[QEMU|PVE]
    especifica el tipo predeterminado de soporte QEMU. Debe configurarse como QEMU para virtualización QEMU Auténtica y PVE para virtualización Proxmox. Cuando no se define, se configura el modo de operación QEMU, que requiere que se configure un parámetro qmpcontrol=… adecuado.
  • timeout=<segundos>
    especifica el tiempo que el Plugin QEMU esperará para la finalización de un volcado de imagen. Cuando se alcanza este límite de tiempo, el trabajo fallará. Si no se define, se utilizará un valor predeterminado de 3600 segundos. Este parámetro es opcional.
  • bitmap-persistence=[0|1]
    especifica si QEMU debe persistir un mapa de bloques sucios utilizado para backups incrementales en el propio dispositivo. La persistencia del bitmap solo es compatible con los archivos de imagen QCOW2. Configurar esta opción en dispositivos que no la admiten hará que el trabajo de backup falle. La persistencia del bitmap se configura solo durante el primer trabajo de backup completo. Para Proxmox, este parámetro se configura como ‘0’. Este parámetro es opcional.

Importante
El bitmap de bloques sucios efímero (cuando bitmap-persistence=0) se recreará cada vez que se reinicie la VM, forzando un backup VM completo.

  • vm=<nombre>
    especifica el nombre de una VM invitada para backup. Todas las VMs invitadas con el <nombre> proporcionado serán seleccionadas para el backup. Se permiten múltiples parámetros vm=…. Si una VM invitada con el <nombre> no puede encontrarse, se generará un error de trabajo único y el backup continuará con la siguiente VM, a menos que esté definido abort_on_error, lo que hará que el trabajo de backup falle. Este parámetro es opcional y se usa solo cuando el modo es PVE.
  • vmid=<vmid>
    especifica el VMID de una VM invitada para backup. Se pueden proporcionar múltiples parámetros vmid=…. Si una VM invitada con el <vmid> no puede encontrarse, se generará un error de trabajo y el backup continuará con la siguiente VM, a menos que esté definido abort_on_error, lo que hará que el trabajo de backup falle. Este parámetro es opcional y se usa solo cuando el modo es PVE.
  • include=<nombre-regex>
    especifica una lista de nombres de VMs invitadas para backup utilizando la sintaxis de expresiones regulares. Todas las VMs invitadas con nombres que coincidan con la expresión regular proporcionada en name-regex serán seleccionadas para el backup. Se pueden proporcionar múltiples parámetros include=…. La coincidencia no distingue entre mayúsculas y minúsculas. Si ninguna VM invitada coincide con la expresión name-regex proporcionada, el backup continuará con los siguientes parámetros o finalizará con éxito sin realizar el backup de ninguna VM. El parámetro abort_on_error no hará que el trabajo falle cuando no se encuentre ninguna VM invitada mediante la coincidencia de nombre. Este parámetro es opcional y se usa solo cuando el modo es PVE.
  • exclude=<nombre-regex>
    especifica una lista de nombres de VMs invitadas que serán excluidas del backup utilizando coincidencia de expresiones regulares. Todas las VMs invitadas con nombres que coincidan con la expresión regular proporcionada y que se seleccionen para el backup mediante el parámetro include=…. serán excluidas. La coincidencia no distingue entre mayúsculas y minúsculas. Este parámetro no afecta a ninguna VM invitada seleccionada para el backup mediante los parámetros vm=…, vmid=…, include=… o exclude=…. Se pueden proporcionar múltiples parámetros exclude=…. Este parámetro es opcional y se usa solo cuando el modo es PVE.

Si no se especifica ninguno de los parámetros vm=…, vmid=…, include=… y exclude=…, se incluirán todas las VMs invitadas disponibles en el hipervisor Proxmox en el backup. Para QEMU Genuino, se incluirá una sola VM apuntada por el parámetro qmpcontrol=….

Ubicación del Directorio de Trabajo

Para llevar a cabo cualquiera de las operaciones de trabajo de backup o restauración, el Plugin QEMU requiere espacio de almacenamiento disponible. El espacio necesario depende del tamaño del archivo de imagen de disco más grande durante el backup y de la suma de las imágenes de disco de la VM durante la restauración. Para las operaciones de restauración, se necesita espacio para el parche incremental adecuado de la imagen.

Esta limitación es una consecuencia directa de la limitación de backup de la unidad QEMU QMP, que solo admite archivos de imagen de disco guardados en un archivo regular.

La ubicación exacta del área de trabajo puede seleccionarse con el parámetro de plugin working=…. Cuando este parámetro no está definido, se utilizará el valor predeterminado del parámetro WorkingDirectory del Bacula.

Este espacio de almacenamiento se limpia automáticamente después de la operación, a menos que selecciones una operación de restauración sin conversión de la imagen de disco hacia el destino (verificar el parámetro de restauración convdestination).

Ejemplos de FileSet

Como se muestra en la Figura 1, tanto el FileSet como el trabajo de backup del Plugin QEMU pueden configurarse a través de la interfaz gráfica de Bacula Enterprise, actualmente BWeb.

Figura 1. Ejemplo ilustrativo de FileSet para el backup de VM en BWeb.

En el siguiente ejemplo, se realizará el backup de una única VM de QEMU.

FileSet {
  Name = FS_qemu
  Include {
    Plugin = "qemu: qmpcontrol=/images/vm1.qmp"
  }
}

Ahora, la misma VM de QEMU, pero con una ubicación de trabajo personalizada.

FileSet {
  Name = FS_qemu_working
  Include {
    Plugin = "qemu: qmpcontrol=/images/vm1.qmp working=/tmp"
  }
}

En el siguiente ejemplo, se realizará el backup de todas las VMs invitadas de Promox.

FileSet {
  Name = FS_ProxmoxAll
  Include {
    Plugin = "qemu: mode=PVE"
  }
}

En este ejemplo, se realizará el backup de una única VM con el nombre “VM1”.

FileSet {
  Name = FS_Proxmox_VM1
  Include {
    Plugin = "qemu: mode=PVE vm=VM1"
  }
}

El mismo ejemplo anterior, pero usando vmid en su lugar:

FileSet {
  Name = FS_Proxmox_VM1
  Include {
    Plugin = "qemu: mode=PVE vmid=101"
  }
}

En el siguiente ejemplo, se realizará el backup de todas las VMs que contienen “Prod” en sus nombres.

FileSet {
  Name = FS_Proxmox_ProdAll
  Include {
    Plugin = "qemu: mode=PVE include=Prod"
  }
}

En este último ejemplo, se realizará el backup de todas las VMs invitadas, excepto aquellas cuyos nombres comienzan con “Test”.

FileSet {
  Name = FS_Proxmox_AllbutTest
  Include {
    Plugin = "qemu: mode=PVE include=.* exclude=^Test"
  }
}

Parámetros de Restauración del Plugin

Durante la restauración, el Plugin QEMU utilizará los mismos parámetros que se definieron para el trabajo de backup. Estas configuraciones se guardan en el catálogo en el momento en que se ejecuta el trabajo de backup. Algunos de ellos pueden cambiarse durante el proceso de restauración, si es necesario.

  • convdestination: [yes|no]
    especifica si una imagen de disco restaurada debe convertirse al formato y ubicación originales, como se definió durante el backup. Este parámetro solo funciona en el modo QEMU Genuino. Si no se define o se define como no (el valor predeterminado), las imágenes de disco virtual de QEMU estarán disponibles en el lugar de trabajo (verificar el siguiente parámetro) como archivos en formato QCOW2. En este caso, puedes moverlo manualmente al destino necesario o convertirlo al formato deseado. Este parámetro es opcional.
  • working: </path/to/dir>
    especifica el directorio utilizado para las operaciones de restauración del Plugin QEMU, como se describe en la Ubicación del Directorio de Trabajo. El valor predeterminado es el mismo que el del backup y puede definirse mediante la configuración del plugin o mediante el parámetro de configuración WorkingDir del Bacula FD. Este parámetro es opcional.
  • storage: <storage>
    especifica un Almacenamiento Proxmox al que se restaurarán las VMs invitadas restauradas. Si no se define, una VM invitada se restaurará en el Almacenamiento Proxmox desde el cual se realizó el backup. Si este parámetro apunta a un Almacenamiento inexistente, se usará el Almacenamiento original de la VM invitada. Este parámetro es opcional.

Exemplos Prácticos de Restauración

Como se muestra en la Figura 2, todos los trabajos de restauración pueden ejecutarse a través de la interfaz gráfica de Bacula Enterprise, actualmente BWeb, desde el Dashboard de VMs o desde el Menú de Restauración, o a través de los comandos de CLI enumerados más adelante.

Figura 2. Ejemplo de restauración de VMs desde BWeb, “VM Dashboard”.

Restauración con QEMU Genuino

Para restaurar una o varias VMs usando el modo Genuino de QEMU, debes ejecutar el comando de restauración y especificar el parámetro “where” como se muestra en este ejemplo:

* restore where=/

Luego, define cualquier otro parámetro necesario para la restauración del plugin.
En el siguiente ejemplo de sesión de restauración, se define la opción de restauración del plugin “convdestination” como “yes”:

* restore where=/
...
Run Restore job
JobName: RestoreFiles
Bootstrap: /opt/bacula/working/qemu-test-dir.restore.2.bsr
Where: /
Replace: Always
FileSet: Full Set
Backup Client: qemu-test-fd
Restore Client: qemu-test-fd
Storage: File1
When: 2021-11-01 13:19:16
Catalog: MyCatalog
Priority: 10
Plugin Options: *None*
OK to run? (yes/mod/no): mod
Parameters to modify:
1: Level
2: Storage
3: Job
4: FileSet
5: Restore Client
6: When
7: Priority
8: Bootstrap
9: Where
10: File Relocation
11: Replace
12: JobId
13: Plugin Options
Select parameter to modify (1-13): 13
Automatically selected : qemu: qmpcontrol=/images/vm1.qmp abort_on_error
Plugin Restore Options
Option Current Value Default Value
working: *None* (*None*)
convdestination: *None* (*None*)
Use above plugin configuration? (yes/mod/no): mod
You have the following choices:
1: working (Plugin working directory)
2: convdestination (Convert qcow2 restore to original destination)
Select parameter to modify (1-2): 2
Please enter a value for convdestination: yes
Plugin Restore Options
Option Current Value Default Value
working: *None* (*None*)
convdestination: yes (*None*)
Use above plugin configuration? (yes/mod/no): yes
...

Durante un trabajo de restauración, debes obtener información sobre cada proceso de restauración, que incluye la restauración de dispositivos de disco incrementales y el proceso de conversión de destino.

JobId 121: Start Restore Job RestoreFiles.2021-11-01_13.05.11_03
JobId 121: Restoring files from JobId(s) 115,116,120
JobId 121: Using Device "FileChgr1-Dev1" to read.
JobId 121: qemu: VM to restore: VM1 (oid:0)
JobId 121: qemu: Start Restore vm: VM1 (rid:0) devices: 2
JobId 121: qemu: Restoring device: ide0-hd0
JobId 121: qemu: Restoring device: ide0-hd1
JobId 121: qemu: Patching incremental: ide0-hd0
JobId 121: qemu: Patching incremental: ide0-hd1
JobId 121: qemu: Patching incremental: ide0-hd0
JobId 121: qemu: Patching incremental: ide0-hd1

La nueva VM huésped creada durante la restauración recibirá un nuevo VMID (si el VMID original está en uso), pero el nombre/nombre del host permanecerá igual que con la VM original.

Restauración a un Hypervisor Proxmox

Para restaurar una o varias VMs en un hipervisor Proxmox, debes ejecutar el mismo comando de restauración mencionado anteriormente, y el proceso básico de restauración es el mismo. La principal diferencia se encuentra en la configuración final y el procedimiento de importación de dispositivos, como se muestra a continuación:

JobId 117: Start Restore Job RestoreFiles.2021-11-02_17.26.25_07
JobId 117: Restoring files from JobId(s) 104,105,106,115,116
JobId 117: Using Device "FileChgr1-Dev2" to read.
JobId 117: qemu: VM to restore: vm1 (oid:100)
JobId 117: qemu: Start Restore vm: vm1 (rid:104) devices: 1
JobId 117: qemu: Restoring device: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: qemu: Patching incremental: drive-scsi0
JobId 117: Elapsed time=00:06:42, Transfer rate=20.28 M Bytes/second
JobId 117: qemu: Successfully imported device drive-scsi0 as local-lvm:vm-104-disk-0
...

La nueva VM creada durante la restauración recibirá un nuevo VMID (si el VMID original está en uso), pero el nombre/nombre del host permanecerá igual que con la VM original.

Restauración a un Directorio Local

Es posible restaurar la(s) imagen(es) de disco de la VM huésped a un directorio local en lugar de restaurarlas en un hipervisor como una nueva VM. Para lograr esto, la opción de restauración “where” debe apuntar a un directorio local:

* restore where=/tmp/bacula/restores

Revisa el siguiente ejemplo para la prueba “Restauración local de la VM”:

JobId 118: Start Restore Job RestoreFiles.2021-11-02_17.37.34_09
JobId 118: Restoring files from JobId(s) 104,105,106,115,116
JobId 118: Using Device "FileChgr1-Dev1" to read.
JobId 118: Ready to read from volume "vol01" on File device "FileChgr1-Dev1" (/opt/bacula/archive).
JobId 118: qemu: VM local restore: vm1 (oid:100)
JobId 118: Forward spacing Volume "vol01" to addr=227
JobId 118: qemu: Restoring device: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: qemu: Patching incremental: drive-scsi0
JobId 118: Elapsed time=00:06:57, Transfer rate=19.55 M Bytes/second
...

El registro del trabajo de restauración mostrará que la restauración se realizó en un directorio local.

Otros

Lista de Recursos

El Plugin QEMU de Bacula Enterprise soporta la característica de listado de plugins de Bacula Enterprise 8.x o posterior. Este modo permite que un plugin muestre información útil sobre los recursos Proxmox disponibles, como:

  • Lista de nombres de VMs huéspedes
  • Lista de VMIDs de huéspedes
  • Lista de Almacenamientos Proxmox

Esta característica utiliza el “comando de punto” .ls especial con el parámetro “plugin=”. El comando requiere que se definan los siguientes parámetros:

  • client=
    Nombre de Cliente Bacula con el Plugin QEMU instalado.
  • plugin=
    Nombre del plugin, que sería “qemu:” en este caso, con parámetros opcionales de plugin según se describe en la sección “genericparameters”.
  • path=
    Ruta del objeto que se va a mostrar.

Los valores compatibles para el parámetro “path=” son:

  • /
    para mostrar los tipos de objetos disponibles para el listado.
  • vm
    para mostrar una lista de nombres de etiquetas de VMs huéspedes.
  • vmid
    para mostrar una lista de VMIDs de huéspedes y punteros de nombres de etiquetas.
  • storage
    para mostrar la lista de Almacenamientos disponibles.

Para mostrar los tipos de objetos disponibles, sigue el siguiente ejemplo de comando:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 vm
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 vmid
drwxr-x--- 1 root root 0 2021-11-01 12:55:55 storage
2000 OK estimate files=3 bytes=0

Para mostrar la lista de todas las VMs disponibles, puedes usar el siguiente ejemplo de comando:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/vm
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:18 vm1
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:18 vm3
2000 OK estimate files=2 bytes=17,179,869,184

Para mostrar la lista de VMIDs de huéspedes, puedes usar el siguiente ejemplo de comando:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/vmid
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:46 100 -> vm1
-rw-r----- 1 root root 8589934592 2021-11-01 12:56:46 102 -> vm3
2000 OK estimate files=2 bytes=17,179,869,184

Las listas de VM y VMID muestran un tamaño estimado de la VM de huéspedes basado en los tamaños de las imágenes de disco virtuales o reales.
Para mostrar los Almacenamientos Proxmox disponibles, puedes usar el siguiente ejemplo de comando:

*.ls client=proxmoxtest-fd plugin="qemu: mode=PVE" path=/storage
Connecting to Client proxmoxtest-fd at proxmoxtest:9102
brw-r----- 1 root root 0 2021-11-01 12:57:56 data
brw-r----- 1 root root 0 2021-11-01 12:57:56 local-lvm
2000 OK estimate files=2 bytes=0

Consulta de Recursos

El Plugin QEMU de Bacula Enterprise admite la función de consulta de plugin de Bacula Enterprise 14.0 en adelante. Este modo permite que un plugin muestre la misma información sobre los recursos disponibles de Proxmox que se define en la lista de recursos. El Plugin QEMU devuelve los datos de respuesta en formato JSON.
En este ejemplo, se realiza una consulta sobre las VM disponibles:

*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=vm
[{"name":"vm1","vmid":100},{"name":"vm3","vmid":102}]
*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=vmid
[{"name":"vm3","vmid":102},{"name":"vm1","vmid":100}]

Neste exemplo, há uma consulta sobre os armazenamentos Proxmox disponíveis:

*.query client=proxmoxtest-fd plugin="qemu: mode=PVE" parameter=storage
[{"name":"local"},{"name":"local-lvm"}]

Limitaciones

  • No es posible ejecutar simultáneamente el mismo trabajo de respaldo de la misma VM de invitado (duplicación de trabajo).
  • No es posible tener trabajos de respaldo diferentes que respalden la misma VM de invitado, ya que esto romperá la cadena de respaldo de mapa de bits sucios incrementales. En este caso, ni siquiera será posible una recuperación exitosa.
  • Los modelos de VM disponibles en el sistema Proxmox no pueden ser guardados. Esto es una limitación de Proxmox.
  • En el modo de listado y consulta con los parámetros vm o vmid, el complemento solo mostrará las VM en ejecución.
  • Toda operación de respaldo o restauración de VM requiere suficiente espacio de almacenamiento en el directorio de trabajo (consulte la Ubicación del Directorio de Trabajo). Esto es una limitación general del procedimiento de respaldo QEMU QMP.

Referencias

  • Plugin QEMU (Bacula System SA)

Leave a Reply