Aula 17: Bhyve — virtualização nativa no FreeBSD

Nesta Aula 17 do curso FreeBSD — Do Zero ao Avançado, vamos mergulhar no Bhyve, o hipervisor nativo do FreeBSD. O Bhyve é uma peça central na estratégia de virtualização de muitos administradores de sistemas e engenheiros de infraestrutura que buscam desempenho, estabilidade e integração profunda com o kernel do sistema operacional. Diferente de soluções como VirtualBox ou VMware, o Bhyve foi projetado especificamente para aproveitar as extensões de virtualização de hardware presentes em processadores modernos da Intel e da AMD, oferecendo virtualização de primeira classe sem a necessidade de módulos proprietários ou camadas de abstração excessivas. Ao longo desta aula, você vai entender por que o Bhyve se tornou uma escolha popular para ambientes de produção, laboratórios de testes e consolidação de servidores no ecossistema FreeBSD.

O objetivo desta aula é fornecer uma base sólida e, ao mesmo tempo, um guia prático passo a passo para que você possa instalar, configurar e operar máquinas virtuais com o Bhyve de forma imediata. Veremos a teoria por trás do hipervisor, os módulos de kernel necessários, a criação de dispositivos virtuais de rede e armazenamento, e a inicialização de sistemas convidados como FreeBSD e distribuições Linux. A cada etapa, serão apresentados comandos reais, explicações linha por linha e saídas esperadas do terminal, garantindo que você possa acompanhar o processo em seu próprio ambiente de laboratório sem lacunas de execução.

Esta aula tem nível intermediário e assume que você já concluiu as aulas anteriores do curso, nas quais instalamos e configuramos o FreeBSD, entendemos a hierarquia de diretórios, o gerenciamento de pacotes e a administração de serviços. Se você ainda não executou uma instalação mínima do FreeBSD, recomendamos fortemente revisar a Aula 3 e a Aula 6 do curso antes de prosseguir. Além disso, é importante ter acesso a uma máquina física ou a um ambiente de laboratório com suporte a virtualização aninhada habilitado na BIOS/UEFI, pois o Bhyve depende diretamente de recursos de CPU como VT-x/EPT (Intel) ou AMD-V/RVI (AMD) para funcionar corretamente.

Ao final desta aula, você será capaz de criar, iniciar, pausar e destruir máquinas virtuais usando o Bhyve, configurar redes bridge com interfaces TAP, provisionar discos virtuais, gerenciar o ciclo de vida das VMs com ferramentas nativas como bhyvectl e vmrun.sh, e diagnosticar problemas comuns de virtualização. Também apresentaremos boas práticas adotadas em nossos projetos na JRT Technology Solutions, onde nossos especialistas utilizam diariamente o Bhyve para consolidar cargas de trabalho em servidores FreeBSD com alta disponibilidade e eficiência energética. Vamos começar.

O que você vai aprender nesta aula

Esta aula foi estruturada para transformar você de um iniciante em virtualização no FreeBSD em um operador confiante do Bhyve. Abaixo está a lista completa dos objetivos de aprendizagem que você dominará ao final do conteúdo:

• Compreender os fundamentos de virtualização por hardware e o papel do Bhyve como hipervisor nativo do FreeBSD.
• Verificar se o processador do seu servidor ou estação de trabalho suporta as extensões necessárias para o Bhyve.
• Carregar e habilitar corretamente os módulos de kernel vmm, nmdm e as interfaces de rede if_tap e if_bridge.
• Configurar o dispositivo /dev/vmm e as permissões adequadas para usuários administradores.
• Criar discos virtuais com arquivos esparsos e discos ZFS zvol, escolhendo o formato mais adequado ao seu cenário.
• Inicializar uma máquina virtual FreeBSD usando bhyveload e uma VM Linux usando firmware UEFI.
• Construir uma rede bridge para conectar as máquinas virtuais à rede física, com configuração persistente no /etc/rc.conf.
• Utilizar ferramentas de gerenciamento como bhyvectl, bhyve-list e o script vmrun.sh para monitorar e controlar VMs.
• Diagnosticar e resolver erros comuns de inicialização, permissões e configuração de rede no Bhyve.

Pré-requisitos e Ambiente

Antes de iniciar a configuração do Bhyve, é fundamental garantir que o ambiente atenda aos requisitos mínimos. Em nossos projetos na JRT Technology Solutions, sempre começamos validando o hardware e o sistema operacional para evitar surpresas durante a implantação. O primeiro pré-requisito é um sistema FreeBSD instalado e atualizado — recomendamos o FreeBSD 13.2 ou superior, embora o Bhyve já esteja disponível de forma estável desde o FreeBSD 10.0. Execute o comando freebsd-version para confirmar a versão do seu sistema:

# Verifica a versão do FreeBSD instalada
freebsd-version

# Atualiza o repositório de pacotes e o sistema base, se necessário
freebsd-update fetch install
pkg update && pkg upgrade

Além do sistema operacional, o processador deve suportar virtualização por hardware. Em processadores Intel, os recursos necessários são VT-x (Virtualization Technology) e EPT (Extended Page Tables). Em processadores AMD, são AMD-V (Secure Virtual Machine) e RVI (Rapid Virtualization Indexing). Esses recursos normalmente estão desabilitados por padrão na BIOS/UEFI de muitos servidores e estações de trabalho. Acesse o setup da placa-mãe durante o boot e procure por opções como “Intel Virtualization Technology”, “VT-x”, “AMD-V” ou “SVM Mode”. Habilite-as e salve as configurações antes de continuar.

Para verificar se o FreeBSD reconhece o suporte à virtualização, utilize o comando sysctl e analise as flags do processador com dmesg. A saída esperada deve conter as strings VMX e EPT para Intel, ou SVM e NPT para AMD. Execute:

# Verifica as features da CPU no kernel
dmesg | grep -E "VMX|SVM|EPT|NPT"

# Também é possível consultar diretamente as features via sysctl
sysctl hw.vmm
sysctl kern.vm_guest

A quantidade de memória RAM disponível também é um fator crítico. Cada máquina virtual criada com o Bhyve reservará a quantidade de RAM especificada no momento da execução. Recomendamos que o host tenha, no mínimo, 8 GB de RAM para executar duas VMs de teste simultâneas, além de espaço em disco suficiente para as imagens ISO e discos virtuais. Se você utiliza ZFS, terá a vantagem de criar zvols, que são volumes de bloco eficientes para armazenamento das VMs. Abordaremos esse tópico mais adiante.

Por fim, tenha em mente que, para usuários não root operarem o Bhyve, é necessário pertencer ao grupo vmm e ter permissões de leitura/gravação em /dev/vmm. Durante a instalação, configuraremos esses detalhes. Se você está seguindo este curso em um ambiente de laboratório virtualizado, como um VirtualBox ou VMware, certifique-se de habilitar a virtualização aninhada no software de virtualização — caso contrário, o Bhyve não conseguirá inicializar as VMs e você verá erros como “SVM/VMX not available”.

Conceitos Fundamentais do Bhyve

O Bhyve, pronunciado “beehive”, é um hipervisor do tipo 2 que utiliza as instruções de virtualização assistida por hardware para executar máquinas virtuais com alto desempenho. Seu nome é uma referência à arquitetura que utiliza as extensões de virtualização da CPU para criar ambientes isolados, chamados de virtual machines ou VMs. Ao contrário de hipervisores do tipo 1, como o Xen, o Bhyve executa como um processo do usuário sobre o kernel do FreeBSD, mas se beneficia diretamente do suporte nativo a EPT/RVI e VT-x/AMD-V para reduzir a sobrecarga de virtualização. Isso significa que o Bhyve não emula um processador completo; em vez disso, ele permite que o código da VM execute diretamente no hardware, enquanto o hipervisor gerencia os eventos privilegiados.

Entre os componentes principais do Bhyve, destacam-se o utilitário bhyve(8), responsável por executar as máquinas virtuais; o bhyvectl(8), usado para controlar o estado das VMs (iniciar, pausar, destruir); o bhyveload(8), que carrega o kernel do sistema convidado FreeBSD na memória da VM antes da execução; e o vmrun.sh, um script auxiliar fornecido pelo FreeBSD que simplifica o gerenciamento de VMs. Para sistemas operacionais convidados que não sejam FreeBSD, como distribuições Linux ou Windows, utilizamos o firmware UEFI fornecido pelo pacote edk2-bhyve ou pelo port sysutils/uefi-edk2-bhyve, que permite o boot via grub2-bhyve ou diretamente com bhyve -l bootrom.

A virtualização de dispositivos no Bhyve é amplamente baseada no padrão VirtIO, um conjunto de drivers paravirtualizados que oferecem excelente desempenho para discos, redes e consoles. Em vez de emular hardware legado como placas de rede Intel PRO/1000 ou controladoras SATA, o Bhyve pode expor dispositivos virtio-blk para armazenamento, virtio-net para rede e virtio-console para acesso serial. Os sistemas convidados devem possuir drivers VirtIO instalados — o FreeBSD já os inclui por padrão, e as distribuições Linux modernas também têm suporte nativo. Em convidados Windows, é necessário instalar os drivers VirtIO manualmente.

Outro conceito importante é o nmdm(4), o driver de dispositivos de modem nulo usado pelo Bhyve para fornecer consoles seriais às VMs. Quando você especifica -l com1,/dev/nmdm0A no comando do bhyve, o sistema cria um par de dispositivos /dev/nmdm0A e /dev/nmdm0B; o primeiro é conectado à VM, e o segundo pode ser acessado com cu -l /dev/nmdm0B para interagir com o console. Essa abordagem é essencial para gerenciar VMs headless, ou seja, sem interface gráfica, em servidores remotos.

A tabela a seguir compara o Bhyve com outras soluções de virtualização comuns, destacando suas características técnicas e casos de uso:

Instalando e habilitando o Bhyve no FreeBSD

O processo de instalação do Bhyve no FreeBSD é relativamente simples, mas exige atenção a detalhes de configuração do kernel e do subsistema de dispositivos. O Bhyve faz parte do sistema base, portanto não é necessário instalar pacotes adicionais para usar a funcionalidade básica. No entanto, como vimos, ele depende de módulos de kernel que precisam ser carregados. Em nossos projetos na JRT Technology Solutions, padronizamos o carregamento dos módulos vmm, nmdm, if_tap e if_bridge no arquivo /boot/loader.conf, garantindo que o suporte ao hipervisor esteja disponível desde o boot do sistema.

O primeiro passo é carregar os módulos manualmente para testar a compatibilidade com o hardware. Execute os comandos a seguir como root. O módulo vmm é o coração do Bhyve, responsável por criar e gerenciar as máquinas virtuais no nível do kernel. O módulo nmdm fornece os dispositivos de console serial. Os módulos if_tap e if_bridge são necessários para a criação de interfaces de rede TAP e bridges Ethernet, respectivamente. Vamos executá-los e analisar a saída:

# Carrega o módulo principal do hipervisor Bhyve
kldload vmm

# Carrega o módulo de dispositivos de console serial (null modem)
kldload nmdm

# Carrega o módulo para interfaces TAP (necessário para rede das VMs)
kldload if_tap

# Carrega o módulo para bridges Ethernet
kldload if_bridge

# Verifica se os módulos foram carregados corretamente
kldstat | grep -E "vmm|nmdm|tap|bridge"

Id Refs Address                Size Name
 5    1 0xffffffff83200000   4d2c8 vmm.ko
 6    1 0xffffffff8324e000    4d10 nmdm.ko
 7    1 0xffffffff83253000   10f40 if_tap.ko
 8    1 0xffffffff83264000   15a00 if_bridge.ko

Na saída acima, vemos os quatro módulos carregados com seus respectivos identificadores e tamanhos. O módulo vmm.ko é o mais importante; sem ele, o dispositivo /dev/vmm não será criado e o comando bhyve falhará com “No such file or directory”. Após confirmar que o hardware é suportado, devemos tornar o carregamento persistente. Edite o arquivo /boot/loader.conf com seu editor preferido e adicione as seguintes linhas. Se o arquivo não existir, crie-o com o conteúdo completo abaixo:

# /boot/loader.conf — carregamento automático de módulos para o Bhyve

# Módulo principal do hipervisor
vmm_load="YES"

# Módulo de console serial para VMs
nmdm_load="YES"

# Módulos de rede para TAP e bridge
if_tap_load="YES"
if_bridge_load="YES"

Cada linha do arquivo /boot/loader.conf utiliza a sintaxe nome_do_modulo_load=”YES” para instruir o carregador de boot a carregar o módulo no início do sistema. Com essa configuração, o Bhyve estará pronto para uso a cada reinicialização, sem a necessidade de comandos kldload manuais. Para aplicar as alterações imediatamente sem reiniciar, você pode executar os comandos kldload vmm, kldload nmdm, kldload if_tap e kldload if_bridge novamente, pois se os módulos já estiverem carregados, o comando retornará um erro inofensivo de que o módulo já existe.

Agora precisamos configurar as permissões do dispositivo /dev/vmm. Por padrão, apenas o usuário root pode acessar esse dispositivo. Para permitir que usuários do grupo vmm gerenciem VMs, editamos o arquivo /etc/devfs.rules. Mostre o conteúdo completo abaixo e, em seguida, crie o grupo e adicione seu usuário administrador:

# /etc/devfs.rules — regras para o device filesystem

# Regra número 10: permite que o grupo vmm acesse o dispositivo vmm
[localrules=10]
add path 'vmm' mode 0660 group vmm
add path 'vmm.io' mode 0660 group vmm
add path 'nmdm*' mode 0660 group vmm
add path 'tap*' mode 0660 group vmm

O arquivo /etc/devfs.rules define regras que são aplicadas ao sistema de arquivos de dispositivos devfs durante o boot. A primeira linha define um conjunto de regras chamado localrules com número 10. As linhas seguintes utilizam o comando add path para modificar as permissões dos dispositivos especificados. A regra mode 0660 group vmm concede leitura e gravação para o dono (root) e para o grupo vmm, negando acesso a outros usuários. Os dispositivos vmm, vmm.io, nmdm* e tap* são os principais pontos de acesso do Bhyve e de sua infraestrutura de rede.

Para ativar as regras do devfs, edite também o arquivo /etc/rc.conf e adicione a variável devfs_system_ruleset=”localrules”. Em seguida, crie o grupo vmm e adicione o usuário desejado. Supondo que o usuário seja admin, execute:

# Cria o grupo vmm (se ele ainda não existir)
pw groupadd vmm -M admin

# Adiciona um usuário ao grupo vmm (exemplo com usuário "admin")
pw groupmod vmm -m admin

# Habilita as regras do devfs no arquivo /etc/rc.conf
sysrc devfs_system_ruleset="localrules"

# Aplica as regras imediatamente sem reiniciar
service devfs restart

devfs_system_ruleset: localrules -> localrules
Stopping devfs.
Starting devfs.

Na saída, vemos que a variável devfs_system_ruleset foi definida com o valor localrules e que o serviço devfs foi reiniciado. Após o reinício do serviço, os dispositivos /dev/vmm e /dev/vmm.io devem estar acessíveis ao grupo vmm. Você pode verificar as permissões com o comando ls -l /dev/vmm* /dev/nmdm*. A saída deve mostrar o grupo vmm nas permissões. Caso o dispositivo não apareça, verifique se o módulo vmm está carregado com kldstat | grep vmm.

Criando sua primeira máquina virtual com Bhyve

Agora que o Bhyve está instalado e configurado, vamos criar nossa primeira máquina virtual. Utilizaremos dois exemplos práticos: uma VM com sistema convidado FreeBSD, que é o cenário mais simples e nativo, e uma VM com uma distribuição Linux, que requer o uso de firmware UEFI. Essa dualidade permitirá que você compreenda as diferenças no processo de boot e no carregamento do kernel. Antes de iniciar, crie um diretório para armazenar os discos virtuais e as imagens ISO. Em nossos servidores na JRT Technology Solutions, utilizamos a estrutura /vm para armazenar todos os artefatos das máquinas virtuais, facilitando o backup e a organização.

O primeiro passo é criar o diretório /vm e obter uma imagem ISO do sistema convidado. Para o exemplo com FreeBSD, você pode baixar a imagem mínima do FreeBSD a partir do site oficial. Para o exemplo com Linux, baixaremos o Ubuntu Server 22.04 LTS. Execute os comandos abaixo:

# Cria o diretório base para as máquinas virtuais
mkdir -p /vm/iso /vm/disks

# Baixa a imagem ISO mínima do FreeBSD (exemplo com FreeBSD 13.2)
fetch -o /vm/iso/FreeBSD-13.2-RELEASE-amd64-disc1.iso https://download.freebsd.org/releases/amd64/amd64/ISO-IMAGES/13.2/FreeBSD-13.2-RELEASE-amd64-disc1.iso

# Baixa a imagem ISO do Ubuntu Server 22.04 LTS (para o exemplo Linux)
fetch -o /vm/iso/ubuntu-22.04.3-live-server-amd64.iso https://releases.ubuntu.com/22.04.3/ubuntu-22.04.3-live-server-amd64.iso

Para criar o disco virtual da VM FreeBSD, usaremos o comando truncate para gerar um arquivo esparso de 10 GB. Um arquivo esparso ocupa apenas o espaço realmente utilizado, o que economiza armazenamento inicial. O comando truncate -s 10G aloca o arquivo freebsd-guest.img com tamanho lógico de 10 GB, mas ele crescerá conforme os dados forem gravados. Em alternativa, se você estiver usando ZFS, pode criar um zvol com o comando zfs create -V 10G zroot/vm-freebsd-disk, que oferece melhor desempenho e snapshots nativos. Para este tutorial, usaremos arquivos esparsos para simplificar o gerenciamento:

# Cria um disco virtual esparso de 10 GB para a VM FreeBSD
truncate -s 10G /vm/disks/freebsd-guest.img

# Cria um disco virtual esparso de 15 GB para a VM Ubuntu
truncate -s 15G /vm/disks/ubuntu-guest.img

# Verifica o tamanho lógico e o espaço ocupado em disco
ls -lh /vm/disks/

total 20480
-rw-r--r--  1 root  wheel    10G Aug 18 09:15 freebsd-guest.img
-rw-r--r--  1 root  wheel    15G Aug 18 09:15 ubuntu-guest.img

Na saída, o comando ls -lh mostra que os arquivos têm tamanho lógico de 10G e 15G, respectivamente. Como são arquivos esparsos, o espaço real ocupado no disco é pequeno (apenas alguns blocos). Você pode confirmar isso com du -h /vm/disks/freebsd-guest.img. Agora, vamos iniciar a VM FreeBSD. O Bhyve oferece dois métodos para boot de convidados FreeBSD: usar o bhyveload para carregar o kernel diretamente do CD ou disco, ou usar firmware UEFI. Utilizaremos o bhyveload por ser o método mais tradicional e eficiente para FreeBSD. O comando abaixo carrega o kernel do FreeBSD a partir do disco virtual e, em seguida, executa o bhyve com os dispositivos VirtIO:

# Carrega o kernel do FreeBSD na memória da VM (a partir do disco virtual)
bhyveload -c /dev/nmdm0A -m 2048M -d /vm/disks/freebsd-guest.img freebsd-guest

# Executa a máquina virtual FreeBSD com 2 GB de RAM e 2 CPUs
bhyve -c 2 -m 2048M -A -H -P \
  -s 0:0,hostbridge \
  -s 1:0,lpc \
  -s 2:0,virtio-blk,/vm/disks/freebsd-guest.img \
  -s 3:0,virtio-net,tap0 \
  -l com1,/dev/nmdm0A \
  freebsd-guest

Vamos analisar o comando bhyve linha por linha. A flag -c 2 define o número de CPUs virtuais alocadas à VM. A flag -m 2048M aloca 2048 megabytes de RAM. A flag -A habilita a emulação do APIC (Advanced Programmable Interrupt Controller), necessária para sistemas multiprocessadores. A flag -H faz com que o Bhyve mantenha a VM em execução mesmo quando o processo pai recebe um sinal SIGHUP, útil para sessões SSH. A flag -P cria a VM em modo paused, o que é recomendado para que você possa configurar dispositivos adicionais antes de iniciar a execução — porém, neste exemplo, a VM será despausada automaticamente quando o comando bhyve terminar de configurar os dispositivos.

Os parâmetros -s especificam os dispositivos PCI virtuais. O slot 0:0,hostbridge cria a ponte de barramento padrão. O slot 1:0,lpc adiciona um controlador LPC, que fornece os dispositivos de console serial e outros periféricos legados. O slot 2:0,virtio-blk,/vm/disks/freebsd-guest.img conecta o disco virtual ao barramento VirtIO, oferecendo desempenho de armazenamento próximo ao nativo. O slot 3:0,virtio-net,tap0 conecta uma interface de rede VirtIO à interface TAP chamada tap0, que ainda não criamos — faremos isso na próxima seção. Por fim, -l com1,/dev/nmdm0A conecta o console serial à UART COM1, permitindo acesso à VM via /dev/nmdm0B.

Após executar os comandos acima, a VM FreeBSD iniciará a partir do disco virtual, que ainda não contém um sistema operacional. Para instalar o FreeBSD na VM, você deve primeiro anexar a imagem ISO ao slot de CD-ROM e modificar o comando bhyve para incluir -s 4:0,ahci-cd,/vm/iso/FreeBSD-13.2-RELEASE-amd64-disc1.iso. O comando completo ficaria assim:

# Inicia a instalação do FreeBSD na VM a partir da ISO
bhyve -c 2 -m 2048M -A -H -P \
  -s 0:0,hostbridge \
  -s 1:0,lpc \
  -s 2:0,virtio-blk,/vm/disks/freebsd-guest.img \
  -s 3:0,virtio-net,tap0 \
  -s 4:0,ahci-cd,/vm/iso/FreeBSD-13.2-RELEASE-amd64-disc1.iso \
  -l com1,/dev/nmdm0A \
  freebsd-guest

O dispositivo ahci-cd emula um controlador SATA AHCI com um leitor de CD-ROM, permitindo que o instalador do FreeBSD acesse a mídia de instalação. Após iniciar a VM, você pode conectar-se ao console serial com o comando cu -l /dev/nmdm0B e seguir o processo de instalação normalmente, como faria em um servidor físico. Lembre-se de que, para o instalador FreeBSD reconhecer o disco VirtIO, o kernel do FreeBSD já possui o driver virtio_blk embutido, então não são necessários passos adicionais.

Para o segundo exemplo, com Ubuntu Server, utilizaremos o firmware UEFI do pacote edk2-bhyve. Primeiro, instale o firmware e o utilitário grub2-bhyve. Em sistemas FreeBSD, esses componentes são obtidos via pkg ou ports. Execute:

# Instala o firmware UEFI e o utilitário grub2-bhyve
pkg install -y edk2-bhyve grub2-bhyve

# Cria um script de inicialização para a VM Ubuntu usando UEFI
cat > /vm/start-ubuntu.sh <<'EOF'
#!/bin/sh
# Script para iniciar a VM Ubuntu com Bhyve usando firmware UEFI
bhyve -c 2 -m 2048M -A -H -P \
  -s 0:0,hostbridge \
  -s 1:0,lpc \
  -s 2:0,virtio-blk,/vm/disks/ubuntu-guest.img \
  -s 3:0,virtio-net,tap1 \
  -s 4:0,ahci-cd,/vm/iso/ubuntu-22.04.3-live-server-amd64.iso \
  -l bootrom,/usr/local/share/uefi-firmware/BHYVE_UEFI.fd \
  ubuntu-guest
EOF

# Torna o script executável
chmod +x /vm/start-ubuntu.sh

O parâmetro -l bootrom,/usr/local/share/uefi-firmware/BHYVE_UEFI.fd carrega o firmware UEFI na VM, substituindo o carregador bhyveload. Esse firmware permite que sistemas operacionais modernos com boot UEFI, como Ubuntu, Debian, CentOS e Rocky Linux, inicializem corretamente. A partir daí, o processo de instalação é idêntico ao de uma máquina física: você se conecta ao console serial ou, no caso do Ubuntu, pode usar o console gráfico VNC se adicionar o dispositivo fbuf. Para manter a simplicidade e o foco no Bhyve, utilizaremos apenas o console serial e uma instalação automatizada do Ubuntu por meio do instalador subiquity, acessível via cu -l /dev/nmdm1B se configurarmos o console corretamente.

Configuração detalhada de rede: bridge, tap e conectividade

A rede é um dos aspectos mais críticos na configuração do Bhyve. Sem uma configuração adequada, as máquinas virtuais ficam isoladas e inacessíveis. O Bhyve utiliza o modelo de dispositivo virtio-net, que se conecta a uma interface tap no host. Cada interface tap é um dispositivo virtual que representa o lado do host da conexão de rede da VM. Para permitir que múltiplas VMs compartilhem a rede física do host, criamos uma bridge (ponte) que agrega as interfaces tap e a interface física, como em0 ou igb0. Dessa forma, as VMs passam a participar da mesma rede local que o host, recebendo endereços IP do mesmo servidor DHCP e podendo se comunicar com outros dispositivos.

No FreeBSD, a configuração de bridges pode ser feita de duas formas: manualmente, com comandos ifconfig, ou de forma persistente, editando o arquivo /etc/rc.conf. Recomendamos sempre a configuração persistente para ambientes de produção. Para este tutorial, criaremos uma bridge chamada bridge0 e duas interfaces tap0 e tap1, que serão conectadas às VMs FreeBSD e Ubuntu, respectivamente. O primeiro passo é identificar a interface física do host. Execute ifconfig -l para listar as interfaces. No exemplo, usaremos em0 como interface física.

Abaixo está o conteúdo completo do arquivo /etc/rc.conf já com as configurações de rede para o Bhyve. Este arquivo define as variáveis que serão lidas pelos scripts de inicialização do FreeBSD. Incluímos também as variáveis de devfs que configuramos anteriormente:

# /etc/rc.conf — configuração de rede para o Bhyve

# Hostname do servidor FreeBSD
hostname="freebsd-host"

# Configuração da interface física
ifconfig_em0="DHCP"

# Criação da bridge0 e adição da interface física em0 como membro
cloned_interfaces="bridge0 tap0 tap1"
ifconfig_bridge0="addm em0 addm tap0 addm tap1 up"
ifconfig_tap0="up"
ifconfig_tap1="up"

# Habilita as regras do devfs para o grupo vmm
devfs_system_ruleset="localrules"

# Carregamento automático dos módulos do Bhyve (reforço)
kld_list="vmm nmdm if_tap if_bridge"

Vamos explicar cada linha do arquivo. A variável cloned_interfaces=”bridge0 tap0 tap1″ instrui o FreeBSD a criar as interfaces clonáveis bridge0, tap0 e tap1 durante o boot. A variável ifconfig_bridge0=”addm em0 addm tap0 addm tap1 up” adiciona a interface física em0 e as interfaces TAP tap0 e tap1 como membros da bridge bridge0. As variáveis ifconfig_tap0=”up” e ifconfig_tap1=”up” ativam as interfaces TAP imediatamente. A variável kld_list é uma forma alternativa de carregar módulos no boot, embora já tenhamos configurado o loader.conf; ela é redundante, mas útil para garantir que os módulos estejam carregados se a configuração do loader.conf for perdida.

Para aplicar as configurações sem reiniciar o host, execute os comandos abaixo. Eles criam as interfaces, adicionam os membros à bridge e ativam tudo. Em seguida, verifique o status da bridge com ifconfig bridge0:

# Cria e configura a bridge0 e as interfaces TAP manualmente
ifconfig bridge0 create
ifconfig tap0 create
ifconfig tap1 create
ifconfig bridge0 addm em0 addm tap0 addm tap1 up
ifconfig tap0 up
ifconfig tap1 up

# Verifica o status da bridge0
ifconfig bridge0

bridge0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
	ether 02:00:00:00:00:00
	id 00:00:00:00:00:00 priority 32768 hellotime 2 fwddelay 15
	member: em0 flags=143<LEARNING,DISCOVER,STP,AUTOEDGE,AUTOPTP>
	        ifmaxaddr 0 port 1 priority 128 path cost 2000
	member: tap0 flags=143<LEARNING,DISCOVER,STP,AUTOEDGE,AUTOPTP>
	        ifmaxaddr 0 port 7 priority 128 path cost 2000
	member: tap1 flags=143<LEARNING,DISCOVER,STP,AUTOEDGE,AUTOPTP>
	        ifmaxaddr 0 port 8 priority 128 path cost 2000

A saída do comando ifconfig bridge0 mostra a bridge ativa com três membros: em0, tap0 e tap1. O status RUNNING indica que a bridge está operacional. Agora, quando as VMs forem iniciadas com os parâmetros virtio-net,tap0 e virtio-net,tap1, seus tráfegos serão encaminhados através da bridge para a rede física. Se o host receber IP via DHCP, as VMs também receberão endereços da mesma faixa, a menos que você configure endereços estáticos dentro dos convidados.

É importante mencionar que, em ambientes com firewall, talvez seja necessário liberar o tráfego entre as interfaces da bridge. O FreeBSD possui filtragem de bridge integrada via pf ou ipfw. Por padrão, todas as interfaces da bridge têm permissão de encaminhamento, mas se você utiliza pf com regras restritivas, adicione uma regra para permitir o tráfego na bridge, como pass on bridge0 all. Em nossos projetos na JRT Technology Solutions, costumamos segmentar o tráfego das VMs com VLANs e regras de firewall específicas, mas isso foge ao escopo desta aula.

Gerenciando máquinas virtuais com bhyvectl, bhyve-list e vmrun.sh

Depois de criar e iniciar suas VMs, você precisará gerenciá-las: listar VMs em execução, pausar, retomar, destruir e monitorar o consumo de recursos. O FreeBSD fornece ferramentas nativas para o gerenciamento do Bhyve. A principal delas é o bhyvectl, que permite controlar o ciclo de vida das VMs. O comando bhyve-list, introduzido recentemente, oferece uma saída amigável com