Como executar o Raspberry Pi OS em uma máquina virtual com Qemu e KVM

Embora muitos sistemas operacionais estejam disponíveis para o Raspberry Pi, o oficial é o Raspberry Pi OS. O sistema operacional é feito para executar para o braço arquitetura e pode ser facilmente instalado no cartão SD, que será usado como o principal dispositivo de armazenamento Raspberry Pi. Às vezes, podemos querer realizar alguns testes ou experimentar alguns aplicativos sem ter uma máquina física de Raspberry Pi; Neste tutorial, veremos como podemos criar uma máquina virtual com o sistema Raspberry Pi OS usando Qemu e KVM (Máquina virtual do kernel).

Neste tutorial, você aprenderá:

• Como instalar Qemu e KVM
• Como baixar e verificar a integridade da versão mais recente do Raspberry Pi OS (Buster)
• Como executar o Raspberry Pi OS em uma máquina virtual

Requisitos de software e convenções usadas

Instalando Qemu

Qemu, conforme definido no site oficial, é um “emulador de máquina de código aberto e genérico e virtualizador de máquina de código aberto”. Podemos usá -lo para executar o sistema operacional para qualquer tipo de máquina. No Linux, é frequentemente usado em combinação com KVM, que é uma solução completa de virtualização incluída no kernel. Para poder virtualizar nosso Raspberry Pi OS, precisamos instalá -lo em nossa distribuição favorita, juntamente com o Qemu-System-Arm pacote, que fornece o emulador do sistema para BRAÇO sistemas. Qemu e KVM estão disponíveis nos repositórios de software das principais distribuições Linux. Para instalá -los no Fedora, podemos usar o DNF gerenciador de pacotes:

$ sudo dnf install @virtualization qemu-system-arma 

Aqui instalamos o virtualização grupo de pacotes (observe o @ prefixo): Inclui tudo o necessário para a virtualização no Fedora, exceto o Qemu-System-Arm pacote, que instalamos separadamente.

Nas distribuições baseadas em Debian e Debian, podemos lançar os seguintes comandos para sincronizar nossa distribuição com os repositórios remotos e obter os pacotes necessários em nosso sistema:

$ sudo apt-get update && sudo apt-get install qemu-system-arm-kv-kvm libvirt-clients libvirt-daemon-system ponte-utils virinst libvirt-daemon virt-manager 

Baixando e verificando a imagem mais recente do Raspberry Pi OS

Podemos baixar o lançamento mais recente do Raspberry Pi OS do site oficial do Raspberry Pi. Podemos basicamente escolher entre 3 versões do sistema: alguns são mais mínimos, outros vêm com um conjunto maior de pacotes e um
Desktop gráfico já instalado. Os links de download são os seguintes:

• Raspberry Pi OS Lite
• Raspberry Pi OS com desktop
• Raspberry Pi OS com desktop e pacotes adicionais

Neste tutorial, usaremos a versão Raspberry Pi OS “Lite”. Faça o download usando um navegador da web, é apenas uma questão de clicar em um dos links fornecidos acima. Se quisermos baixá -lo na linha de comando, em vez disso, podemos usar ferramentas como wget ou ondulação:

# Usando wget $ wget https: // downloads.Raspberry Pi.org/raspios_lite_armhf/imagens/raspios_lite_armhf-2021-01-12/2021-01-11-Raspios-buster-armhf-lite.ZIP # usando Curl $ CURL -O HTTPS: // Downloads.Raspberry Pi.org/raspios_lite_armhf/imagens/raspios_lite_armhf-2021-01-12/2021-01-11-Raspios-buster-armhf-lite.fecho eclair 

Ao executar um dos dois comandos acima, a imagem será baixada no diretório de trabalho atual. Uma vez concluído o download, podemos verificar a integridade da imagem comparando seu SHA256SUM com o fornecido no site.
No nosso caso, o hashsum deve ser D49D6FAB1B8E533F7EFC40416E98EC16019B9C034BC89C59B83D0921C2AEFEEF. Para verificar, podemos executar o seguinte comando:

$ SHA256SUM 2021-01-11-RASPIOS-BUSTER-ARMHF-LITE.fecho eclair 

O comando acima, em nosso caso, retorna o seguinte resultado:

49D6FAB1B8E533F7EFC40416E98EC16019B9C034BC89C59B83D0921C2AEFEEF 2021-01-11-11-RASPIOS-BUSER-ARMHF-LITE.fecho eclair 

Você pode ver que os dois hashs de hashs, então estamos prontos para ir. O que precisamos fazer agora é extrair a imagem, uma vez que ela é fechada. Para fazer isso, podemos executar o seguinte comando:

$ UNZIP 2021-01-11-RASPIOS-BUSTER-ARMHF-LITE.fecho eclair 

Como o kernel incluído na imagem oficial do sistema não pode ser inicializado diretamente do qemu, devemos clonar um repositório Git que contém uma série de kernel construída para esse propósito exato. Veremos como fazer isso na próxima seção.

Obtendo kernels prontos para qemu do Github

O repositório que precisamos clonar do github é dhruvvyas90/qemu-rpi-kernel. Tudo o que precisamos fazer é executar o seguinte comando:

$ git clone https: // github.com/dhruvvyas90/qemu-rpi-kernel 

O processo de clonagem pode demorar um pouco para terminar, isso depende da velocidade da sua conexão com a Internet. Depois que o repositório é clonado, estamos prontos para ir. Aqui está o seu conteúdo:

$ ls qemu-rpi-kernel kernel-qemu-3.10.25-wheezy ReadMe.MD Kernel-Qemu-4.14.Ferramentas de 79-Stretch Kernel-Qemu-4.19.50 buster versatile-pb-buster-5.4.51.DTB Kernel-Qemu-4.4.34-Jessie Versatile-PB-Buster.DTB Kernel-Qemu-5.4.51-Buster Versatile-PB.EM-EMAÇÃO NATIVA DO DTB 

Como queremos imitar a versão mais recente do Raspberry Pi OS, os arquivos que precisamos são kernel-qemu-4.19.50-buster e Versátil-PB-buster.dtb. O primeiro é a imagem real do kernel, o segundo é um Blob da árvore do dispositivo. Qual é o objetivo deste arquivo?

Para descrever o hardware disponível em um sistema em uma placa Raspberry Pi, Dts (Os arquivos da árvore do dispositivo) são usados; A versão compilada desses arquivos é chamada Dtb e armazenado em arquivos com o .dtb extensão. No nosso caso, poderíamos usar alternativamente o kernel-qemu-5.4.51-buster, junto com o Versatile-PB-Buster-5.4.51.dtb arquivo.

Emulando o Raspberry Pi OS

Com todos os arquivos necessários, podemos finalmente virtualizar a imagem Raspberry Pi OS. Observe que aqui presumo que o diretório de trabalho é o mesmo onde baixamos a imagem do sistema. Antes de executarmos o comando real, apenas no Debian, precisamos iniciar a rede de pontes natadas padrão, que não é iniciada automaticamente; Para fazer isso, devemos correr:

$ sudo virsh--conect = qemu: /// System Net-start Padrão 

Para começar automaticamente, podemos executar:

$ sudo virsh--conect = qemu: // System Net-Autostart Padrão 

Agora, para construir a máquina virtual, devemos executar o seguinte comando:

$ sudo virt-install \-name rpios \ --arch Armv6l \-MACHINE versatilepb \-cpu ARM1176 \ --vcpus 1 \-Memória 256 \ --import \--Disk 2021-01-11-RASPIOS -buster-armhf-lite.img, formato = bruto, barramento = virtio \--network ponte, fonte = virbr0, modelo = virtio \ --video vga \ --graphics spice \ --boot 'dtb = qemu-rpi-kernel/versatile-pb-buster.dtb, kernel = qemu-rpi-kernel/kernel-qemu-4.19.50-buster, kernel_args = root =/dev/vda2 panic = 1 '\ --events on_reboot = destruição 

Uma janela Virt-Viewer deve aparecer; Lá, deveríamos poder visualizar a inicialização do Raspberry Pi OS:

Vamos dar uma breve olhada nas opções que usamos para construir a máquina virtual com o Virt-Install comando; Alguns são bastante óbvios, outros um pouco mais obscuros.

Primeiro de tudo, usamos o --nome Opção: Com ele, podemos definir o nome da instância da máquina virtual (deve ser exclusiva). A segunda opção que usamos é --arco: é necessário solicitar uma arquitetura de CPU não nativa para o convidado
sistema; Se não o usarmos, a arquitetura do host é assumida.

Com o --máquina opção, passamos o tipo de máquina para imitar para qemu: neste caso, usamos Versatilepb. Com o --CPU opção, configuramos o modelo da CPU e os recursos expostos ao hóspede; Aqui usamos ARM1176, desde o
Raspberry Pi é baseado no braço arquitetura.

O --vcpus É necessária opção para definir o número de CPUs virtuais para a máquina de convidados, apenas uma neste caso. Como poderia ser facilmente adivinhado, o --memória A opção, em vez disso, é usada para definir a memória para alocar o convidado.

O --importar A opção é realmente importante aqui, pois é usada para instruir o aplicativo para pular a instalação do sistema operacional e apenas construir um hóspede em torno de uma imagem já existente, que é mais tarde especificada com o --disco opção.

Nós usamos --rede Para conectar o hóspede à rede host. Nesse caso, nos conectamos através do Virbr0 ponte, que é criada por padrão por libvirt. Com o --vídeo opção, especificamos que tipo de dispositivo de vídeo deve ser anexado ao hóspede e com --gráficos Especificamos como a exibição gráfica do hóspede pode ser acessada: neste caso, usamos especiaria, Para usar o protocolo com o mesmo nome.

Com o --bota opção é possível especificar o dtb e a núcleo arquivo para usar, mas também a linha de comando do kernel com kernel_args. Finalmente, com o --eventos opção, especificamos valores de eventos para o convidado. Neste caso nós destruir para o on_reboot evento.

Uma vez iniciado a máquina virtual, também podemos gerenciá -la graficamente através do virt-manager aplicativo. Agora podemos desfrutar do nosso OS virtualizado de Raspberry Pi!

Conclusão

Neste tutorial, vimos como podemos executar uma imagem crua de Raspberry Pi OS usando Qemu e KVM, sem um hardware Raspberry Pi de verdade. Vimos como baixar e verificar a imagem do sistema, como extraí -la, como clonar o repositório Git que contém os arquivos de kernel e DTB necessários para inicializar a imagem com qemu e o comando real que devemos executar para iniciar a virtualização do sistema.

Tutoriais do Linux relacionados:

• Uma introdução à automação, ferramentas e técnicas do Linux
• Coisas para instalar no Ubuntu 20.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Mastering Bash Script Loops
• Introdução aos mecanismos de armazenamento MySQL
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Sistema Linux Hung? Como escapar para a linha de comando e…
• Arquivos de configuração do Linux: os 30 primeiros mais importantes
• Como verificar uma saúde do disco rígido na linha de comando…
• Ubuntu 20.04 Guia