Preparare una macchina virtuale basata su RedHat per Azure

Articolo
04/26/2023

Si applica a: set di scalabilità uniformi di ✔️ macchine virtuali Linux ✔️ ✔️

Questo articolo illustra come preparare una macchina virtuale Red Hat Enterprise Linux (RHEL) da usare in Azure. Le versioni di RHEL descritte in questo articolo sono 6.X, 7.X e 8.X. Gli hypervisor per la preparazione illustrati in questo articolo sono Hyper-V, KVM (Kernel-based Virtual Machine) e VMware. Per altre informazioni sui requisiti di idoneità per partecipare al programma di accesso al cloud di Red Hat, vedere gli articoli relativi al sito web di accesso al cloud di Red Hat e all'esecuzione di RHEL in Azure. Per informazioni su come automatizzare la creazione di immagini RHEL, vedere Image Builder di Azure.

Nota

Tenere presente le versioni che sono End Of Life (EOL) e non sono più supportate da Redhat. Le immagini caricate che si trovano a o oltre EOL saranno supportate su base aziendale ragionevole. Collegamento al ciclo di vita del prodotto redhat

Console di gestione di Hyper-V

Questa sezione illustra come preparare una macchina virtuale RHEL 6, RHEL 7 o RHEL 8 usando la console di gestione di Hyper-V.

Prerequisiti

Questa sezione presuppone che sia già stato ottenuto un file ISO dal sito Web Red Hat e che l'immagine RHEL sia stata installata in un disco rigido virtuale (VHD). Per altri dettagli su come usare la console di gestione di Hyper-V per installare un'immagine del sistema operativo, vedere l'articolo su come installare il ruolo Hyper-V e configurare una macchina virtuale.

Note sull'installazione di RHEL

Azure non supporta il formato VHDX. Azure supporta solo dischi rigidi virtuali a dimensione fissa. È possibile usare la console di gestione di Hyper-V o il cmdlet convert-vhd per convertire il disco in formato VHD. Se si usa VirtualBox, durante la creazione del disco selezionare Fixed size (A dimensione fissa) anziché l'opzione predefinita di allocazione dinamica.
macchine virtuali supporto tecnico di Azure Gen1 (avvio BIOS) e Gen2 (avvio UEFI).
La dimensione massima consentita per il disco rigido virtuale è 1.023 GB.
Il modulo kernel vfat deve essere abilitato nel kernel.
LVM (Logical Volume Manager) è supportato e può essere usato nel disco del sistema operativo o nei dischi dati in macchine virtuali di Azure. Tuttavia, in generale, è consigliabile usare partizioni standard nel disco del sistema operativo anziché LVM. Questa procedura consentirà di evitare conflitti di nome LVM con le macchine virtuali clonate, in particolare se fosse eventualmente necessario collegare un disco del sistema operativo a un'altra macchina virtuale identica per la risoluzione dei problemi. Vedere la documentazione di LVM e RAID .
È necessario il supporto del kernel per il montaggio di file system UDF (Universal Disk Format). Al primo avvio in Azure, i supporti con formattazione UDF collegati al guest passano la configurazione di provisioning alla macchina virtuale Linux. L'agente Linux di Azure deve essere in grado di montare il file system UDF per leggerne la configurazione ed effettuare il provisioning della macchina virtuale, senza questo, il provisioning avrà esito negativo.
Non configurare una partizione di scambio sul disco del sistema operativo. Altre informazioni su questo argomento sono disponibili nei passaggi riportati di seguito.
Le dimensioni virtuali di tutti i dischi rigidi virtuali su Azure devono essere allineate a 1 MB. Quando si converte un disco non formattato in un disco rigido virtuale, prima della conversione è necessario assicurarsi che le dimensioni del disco non formattato siano un multiplo di 1 MB. Altri dettagli sono disponibili nelle procedure seguenti. Per altre informazioni, vedere anche Note sull'installazione di Linux.

Nota

Cloud-init >= 21.2 rimuove il requisito della funzione definita dall'utente. Tuttavia, senza il modulo UDF abilitato, il cdrom non verrà montato durante il provisioning, impedendo l'applicazione di dati personalizzati. Una soluzione alternativa consiste nell'applicare dati personalizzati usando i dati utente. Tuttavia, a differenza dei dati personalizzati, i dati utente non vengono crittografati. https://cloudinit.readthedocs.io/en/latest/topics/format.html

RHEL 6 con la console di gestione di Hyper-V

Importante

A partire dal 30 novembre 2020, Red Hat Enterprise Linux 6 raggiungerà la fase di manutenzione. La fase di manutenzione è seguita dalla fase di durata estesa. Quando Red Hat Enterprise Linux 6 esce dalle fasi di manutenzione completa, è consigliabile eseguire l'aggiornamento a Red Hat Enterprise Linux 7, 8 o 9. Se i clienti devono rimanere in Red Hat Enterprise Linux 6, è consigliabile aggiungere il componente aggiuntivo Red Hat Enterprise Linux Extended Life Cycle Support (ELS).

Nella console di gestione di Hyper-V selezionare la macchina virtuale.
Fare clic su Connetti per aprire una finestra della console per la macchina virtuale.
In RHEL 6, NetworkManager può interferire con l'agente Linux di Azure. Disinstallare il pacchetto eseguendo questo comando:
```
sudo rpm -e --nodeps NetworkManager
```
Creare o modificare il file /etc/sysconfig/network e aggiungere il testo seguente:
```
NETWORKING=yes
HOSTNAME=localhost.localdomain
```
Creare o modificare il file /etc/sysconfig/network-scripts/ifcfg-eth0 e aggiungere il testo seguente:
```
DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
```
Spostare o eliminare le regole udev per evitare la generazione di regole statiche per l'interfaccia Ethernet. Le regole seguenti provocano problemi quando si clona una macchina virtuale in Microsoft Azure o Hyper-V:
```
sudo ln -s /dev/null /etc/udev/rules.d/75-persistent-net-generator.rules
sudo rm -f /etc/udev/rules.d/70-persistent-net.rules
```

Nota

** Quando si usa la rete accelerata (AN) l'interfaccia sintetica creata deve essere configurata per essere non gestita usando una regola udev. Ciò impedirà a NetworkManager di assegnare lo stesso ip all'interfaccia primaria.

Per applicarlo:

sudo cat <<EOF>> /etc/udev/rules.d/68-azure-sriov-nm-unmanaged.rules
# Accelerated Networking on Azure exposes a new SRIOV interface to the VM.
# This interface is transparentlybonded to the synthetic interface,
# so NetworkManager should just ignore any SRIOV interfaces.
SUBSYSTEM=="net", DRIVERS=="hv_pci", ACTION=="add", ENV{NM_UNMANAGED}="1"
EOF

Assicurarsi che il servizio di rete venga eseguito all'avvio attivando il comando seguente:
```
sudo chkconfig network on
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL eseguendo questo comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
È stato effettuato il push del pacchetto WALinuxAgent WALinuxAgent-<version> nel repository di funzionalità aggiuntive di Red Hat. Abilitare il repository di funzionalità aggiuntive eseguendo questo comando:
```
sudo subscription-manager repos --enable=rhel-6-server-extras-rpms
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere ulteriori parametri del kernel per Azure. Per eseguire questa modifica, aprire /boot/grub/menu.lst in un editor di testo e verificare che il kernel predefinito includa i parametri seguenti:
```
console=ttyS0 earlyprintk=ttyS0
```
In questo modo si garantisce inoltre che tutti i messaggi della console vengano inviati alla prima porta seriale, agevolando così il supporto di Azure nella risoluzione dei problemi di debug.

È consigliabile anche rimuovere i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB. Questa configurazione potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Verificare che il server SSH (Secure Shell) sia installato e configurato per l'esecuzione all'avvio, che è in genere l'impostazione predefinita. Modificare /etc/ssh/sshd_config per includere la riga seguente:
```
ClientAliveInterval 180
```
Installare l'agente Linux di Azure eseguendo il comando seguente:
```
sudo yum install WALinuxAgent
sudo chkconfig waagent on
```
L'installazione del pacchetto WALinuxAgent rimuove i pacchetti NetworkManager e NetworkManager-gnome se non sono già stati rimossi nel passaggio 3.
Non creare spazio di scambio sul disco del sistema operativo.

L'agente Linux di Azure può configurare automaticamente lo spazio di swapping usando il disco risorse locale collegato alla macchina virtuale dopo il provisioning della macchina virtuale in Azure. Si noti che il disco di risorse locale è un disco temporaneo e che potrebbe essere svuotato se la macchina virtuale viene deprovisionata. Dopo aver installato l'agente Linux di Azure nel passaggio precedente, modificare nel modo appropriato i parametri seguenti in /etc/waagent.conf:
```
ResourceDisk.Format=y
ResourceDisk.Filesystem=ext4
ResourceDisk.MountPoint=/mnt/resource
ResourceDisk.EnableSwap=y
ResourceDisk.SwapSizeMB=2048    ## NOTE: set this to whatever you need it to be.
```
Annullare la sottoscrizione (se necessario) eseguendo il comando seguente:
```
sudo subscription-manager unregister
```
Eseguire i comandi seguenti per effettuare il deprovisioning della macchina virtuale e prepararla per il provisioning in Azure:

Nota

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, ignorare il passaggio di deprovisioning.

    sudo waagent -force -deprovision
    sudo export HISTSIZE=0

Fare clic su Azione>Arresta nella console di gestione di Hyper-V. Il disco rigido virtuale Linux è ora pronto per essere caricato in Azure.

RHEL 7 con la console di gestione di Hyper-V

Nella console di gestione di Hyper-V selezionare la macchina virtuale.
Fare clic su Connetti per aprire una finestra della console per la macchina virtuale.
Creare o modificare il file /etc/sysconfig/network e aggiungere il testo seguente:
```
NETWORKING=yes
HOSTNAME=localhost.localdomain
```

Creare o modificare il file /etc/sysconfig/network-scripts/ifcfg-eth0 e aggiungere il testo seguente:

DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
PERSISTENT_DHCLIENT=yes
NM_CONTROLLED=yes

Assicurarsi che il servizio di rete venga eseguito all'avvio attivando il comando seguente:
```
sudo systemctl enable network
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL eseguendo questo comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere ulteriori parametri del kernel per Azure. Per eseguire questa modifica, aprire /etc/default/grub in un editor di testo e modificare il GRUB_CMDLINE_LINUX parametro . Ad esempio:
```
GRUB_CMDLINE_LINUX="console=tty1 console=ttyS0,115200n8 earlyprintk=ttyS0 net.ifnames=0"
GRUB_TERMINAL_OUTPUT="serial console"
GRUB_SERIAL_COMMAND="serial --speed=115200 --unit=0 --word=8 --parity=no --stop=1"
ENABLE_BLSCFG=true
```
Nota

Se ENABLE_BLSCFG=false è presente invece /etc/default/grub di strumenti "ENABLE_BLSCFG=true", ad esempio grubedit o gubby, che si basano sulla specifica del caricatore di avvio (BLS) per la gestione delle voci di avvio e delle configurazioni, potrebbe non funzionare correttamente in RHEL 8 e 9. Se ENABLE_BLSCFG non è presente, il comportamento predefinito è "false".

Ciò garantisce inoltre che tutti i messaggi della console vengano inviati alla prima porta seriale e abilitino l'interazione con la console seriale, che può aiutare supporto tecnico di Azure con i problemi di debug. Questa configurazione disattiva anche le nuove convenzioni di denominazione di RHEL 7 per le schede di interfaccia di rete.
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB e questo potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Dopo aver completato la modifica /etc/default/grub, eseguire il comando seguente per ricompilare la configurazione grub:
```
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
Nota

Se si carica una macchina virtuale abilitata per UEFI, il comando per aggiornare grub è grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg.
Verificare che il server SSH sia installato e configurato per l'esecuzione all'avvio, che è in genere l'impostazione predefinita. Modificare /etc/ssh/sshd_config per poter includere la riga seguente:
```
ClientAliveInterval 180
```
È stato effettuato il push del pacchetto WALinuxAgent WALinuxAgent-<version> nel repository di funzionalità aggiuntive di Red Hat. Abilitare il repository di funzionalità aggiuntive eseguendo questo comando:
```
sudo subscription-manager repos --enable=rhel-7-server-extras-rpms
```

Installare l'agente Linux di Azure, cloud-init e altre utilità necessarie eseguendo il comando seguente:

sudo yum install -y WALinuxAgent cloud-init cloud-utils-growpart gdisk hyperv-daemons
sudo systemctl enable waagent.service
sudo systemctl enable cloud-init.service

Configurare cloud-init per gestire il provisioning:

Configurare waagent per cloud-init:

sudo sed -i 's/Provisioning.Agent=auto/Provisioning.Agent=auto/g' /etc/waagent.conf
sudo sed -i 's/ResourceDisk.Format=y/ResourceDisk.Format=n/g' /etc/waagent.conf
sudo sed -i 's/ResourceDisk.EnableSwap=y/ResourceDisk.EnableSwap=n/g' /etc/waagent.conf

Nota

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, impostare Provisioning.Agent=disabled sulla /etc/waagent.conf configurazione.

Configurare i montaggi:

sudo echo "Adding mounts and disk_setup to init stage"
sudo sed -i '/ - mounts/d' /etc/cloud/cloud.cfg
sudo sed -i '/ - disk_setup/d' /etc/cloud/cloud.cfg
sudo sed -i '/cloud_init_modules/a\\ - mounts' /etc/cloud/cloud.cfg
sudo sed -i '/cloud_init_modules/a\\ - disk_setup' /etc/cloud/cloud.cfg

Configurare l'origine dati di Azure:

sudo echo "Allow only Azure datasource, disable fetching network setting via IMDS"
sudo cat > /etc/cloud/cloud.cfg.d/91-azure_datasource.cfg <<EOF
datasource_list: [ Azure ]
datasource:
    Azure:
        apply_network_config: False
EOF

Se configurata, rimuovere lo swapfile esistente:

if [[ -f /mnt/resource/swapfile ]]; then
echo "Removing swapfile" #RHEL uses a swapfile by default
swapoff /mnt/resource/swapfile
rm /mnt/resource/swapfile -f
fi

Configurare la registrazione cloud-init:

sudo echo "Add console log file"
sudo cat >> /etc/cloud/cloud.cfg.d/05_logging.cfg <<EOF

# This tells cloud-init to redirect its stdout and stderr to
# 'tee -a /var/log/cloud-init-output.log' so the user can see output
# there without needing to look on the console.
output: {all: '| tee -a /var/log/cloud-init-output.log'}
EOF

Scambiare la configurazione. Non creare spazio di scambio sul disco del sistema operativo.

In precedenza, l'agente Linux di Azure veniva usato per configurare automaticamente lo spazio di scambio usando il disco delle risorse locale collegato alla macchina virtuale dopo il provisioning della macchina virtuale in Azure. Tuttavia, questa operazione è ora gestita da cloud-init, non è necessario usare l'agente Linux per formattare il disco delle risorse per creare il file di scambio, modificare i parametri seguenti in /etc/waagent.conf modo appropriato:
```
ResourceDisk.Format=n
ResourceDisk.EnableSwap=n
```
Se si desidera montare, formattare e creare lo scambio, è possibile:
- Passalo come configurazione cloud-init ogni volta che crei una macchina virtuale tramite customdata. Questo è il metodo consigliato.
- Usare una direttiva cloud-init inserita nell'immagine che eseguirà questa operazione ogni volta che viene creata la macchina virtuale.
```
sudo echo 'DefaultEnvironment="CLOUD_CFG=/etc/cloud/cloud.cfg.d/00-azure-swap.cfg"' >> /etc/systemd/system.conf
sudo cat > /etc/cloud/cloud.cfg.d/00-azure-swap.cfg << EOF
#cloud-config
# Generated by Azure cloud image build
disk_setup:
  ephemeral0:
    table_type: mbr
    layout: [66, [33, 82]]
    overwrite: True
fs_setup:
  - device: ephemeral0.1
    filesystem: ext4
  - device: ephemeral0.2
    filesystem: swap
mounts:
  - ["ephemeral0.1", "/mnt/resource"]
  - ["ephemeral0.2", "none", "swap", "sw,nofail,x-systemd.requires=cloud-init.service,x-systemd.device-timeout=2", "0", "0"]
EOF
```
Se si vuole annullare la registrazione della sottoscrizione, eseguire il comando seguente:
```
sudo subscription-manager unregister
```
Effettuare il deprovisioning

Eseguire i comandi seguenti per effettuare il deprovisioning della macchina virtuale e prepararla per il provisioning in Azure:

Attenzione

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, ignorare il passaggio di deprovisioning. L'esecuzione del comando waagent -force -deprovision+user consente di rendere inutilizzabile il computer di origine. Questo passaggio è destinato solo a creare un'immagine generalizzata.
```
sudo rm -f /var/log/waagent.log
sudo cloud-init clean
sudo waagent -force -deprovision+user
sudo rm -f ~/.bash_history
sudo export HISTSIZE=0
```
Fare clic su Azione>Arresta nella console di gestione di Hyper-V. Il disco rigido virtuale Linux è ora pronto per essere caricato in Azure.

RHEL 8+ con la console di gestione di Hyper-V

Nella console di gestione di Hyper-V selezionare la macchina virtuale.
Fare clic su Connetti per aprire una finestra della console per la macchina virtuale.
Assicurarsi che il servizio Network Manager venga avviato all'avvio eseguendo il comando seguente:
```
sudo systemctl enable NetworkManager.service
```
Configurare l'interfaccia di rete per l'avvio automatico e usare DHCP:
```
sudo nmcli con mod eth0 connection.autoconnect yes ipv4.method auto
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL eseguendo questo comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione grub per includere parametri del kernel aggiuntivi per Azure e abilitare la console seriale.
1. Rimuovere i parametri GRUB correnti:
```
sudo grub2-editenv - unset kernelopts
```
1. Modificare /etc/default/grub in un editor di testo e aggiungere i parametri seguenti:
```
GRUB_CMDLINE_LINUX="console=tty1 console=ttyS0,115200n8 earlyprintk=ttyS0,115200 earlyprintk=ttyS0 net.ifnames=0"
GRUB_TERMINAL_OUTPUT="serial console"
GRUB_SERIAL_COMMAND="serial --speed=115200 --unit=0 --word=8 --parity=no --stop=1"
```
Ciò garantisce inoltre che tutti i messaggi della console vengano inviati alla prima porta seriale e abilitino l'interazione con la console seriale, che può aiutare supporto tecnico di Azure con i problemi di debug. Questa configurazione disattiva anche le nuove convenzioni di denominazione per le schede di interfaccia di rete.
1. È inoltre consigliabile rimuovere i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB e questo potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Dopo aver terminato di modificare /etc/default/grub, eseguire questo comando per ricompilare la configurazione GRUB:
```
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
Per una macchina virtuale abilitata per UEFI, eseguire il comando seguente:
```
sudo grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg
```
Verificare che il server SSH sia installato e configurato per l'esecuzione all'avvio, che è in genere l'impostazione predefinita. Modificare /etc/ssh/sshd_config per poter includere la riga seguente:
```
ClientAliveInterval 180
```

Installare l'agente Linux di Azure, cloud-init e altre utilità necessarie eseguendo il comando seguente:

sudo yum install -y WALinuxAgent cloud-init cloud-utils-growpart gdisk hyperv-daemons
sudo systemctl enable waagent.service
sudo systemctl enable cloud-init.service

Configurare cloud-init per gestire il provisioning:

Configurare waagent per cloud-init:

sudo sed -i 's/Provisioning.Agent=auto/Provisioning.Agent=cloud-init/g' /etc/waagent.conf
sudo sed -i 's/ResourceDisk.Format=y/ResourceDisk.Format=n/g' /etc/waagent.conf
sudo sed -i 's/ResourceDisk.EnableSwap=y/ResourceDisk.EnableSwap=n/g' /etc/waagent.conf

Nota

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, impostare Provisioning.Agent=disabled nella /etc/waagent.conf configurazione.

Configurare i montaggi:

sudo echo "Adding mounts and disk_setup to init stage"
sudo sed -i '/ - mounts/d' /etc/cloud/cloud.cfg
sudo sed -i '/ - disk_setup/d' /etc/cloud/cloud.cfg
sudo sed -i '/cloud_init_modules/a\\ - mounts' /etc/cloud/cloud.cfg
sudo sed -i '/cloud_init_modules/a\\ - disk_setup' /etc/cloud/cloud.cfg

Configurare l'origine dati di Azure:

sudo echo "Allow only Azure datasource, disable fetching network setting via IMDS"
sudo cat > /etc/cloud/cloud.cfg.d/91-azure_datasource.cfg <<EOF
datasource_list: [ Azure ]
datasource:
    Azure:
        apply_network_config: False
EOF

Se configurata, rimuovere lo swapfile esistente:

if [[ -f /mnt/resource/swapfile ]]; then
echo "Removing swapfile" #RHEL uses a swapfile by defaul
swapoff /mnt/resource/swapfile
rm /mnt/resource/swapfile -f
fi

Configurare la registrazione cloud-init:

sudo echo "Add console log file"
sudo cat >> /etc/cloud/cloud.cfg.d/05_logging.cfg <<EOF

# This tells cloud-init to redirect its stdout and stderr to
# 'tee -a /var/log/cloud-init-output.log' so the user can see output
# there without needing to look on the console.
output: {all: '| tee -a /var/log/cloud-init-output.log'}
EOF

Scambia configurazione Non creare spazio di scambio sul disco del sistema operativo.

In precedenza, l'agente Linux di Azure veniva usato per configurare automaticamente lo spazio di scambio usando il disco delle risorse locale collegato alla macchina virtuale dopo il provisioning della macchina virtuale in Azure. Tuttavia, questa operazione è ora gestita da cloud-init, non è necessario usare l'agente Linux per formattare il disco delle risorse per creare il file di scambio, modificare i parametri seguenti in /etc/waagent.conf modo appropriato:
```
ResourceDisk.Format=n
ResourceDisk.EnableSwap=n
```
- Passalo come configurazione cloud-init ogni volta che crei una macchina virtuale tramite customdata. Questo è il metodo consigliato.
- Usare una direttiva cloud-init inserita nell'immagine che eseguirà questa operazione ogni volta che viene creata la macchina virtuale.
```
sudo echo 'DefaultEnvironment="CLOUD_CFG=/etc/cloud/cloud.cfg.d/00-azure-swap.cfg"' >> /etc/systemd/system.conf
sudo cat > /etc/cloud/cloud.cfg.d/00-azure-swap.cfg << EOF
#cloud-config
# Generated by Azure cloud image build
disk_setup:
  ephemeral0:
    table_type: mbr
    layout: [66, [33, 82]]
    overwrite: True
fs_setup:
  - device: ephemeral0.1
    filesystem: ext4
  - device: ephemeral0.2
    filesystem: swap
mounts:
  - ["ephemeral0.1", "/mnt/resource"]
  - ["ephemeral0.2", "none", "swap", "sw,nofail,x-systemd.device-timeout=2,x-systemd.requires=cloud-init.service", "0", "0"]
EOF
```
Se si vuole annullare la registrazione della sottoscrizione, eseguire il comando seguente:
```
sudo subscription-manager unregister
```
Effettuare il deprovisioning

Eseguire i comandi seguenti per effettuare il deprovisioning della macchina virtuale e prepararla per il provisioning in Azure:
```
sudo cloud-init clean
sudo waagent -force -deprovision+user
sudo rm -f ~/.bash_history
sudo sudo rm -f /var/log/waagent.log
sudo export HISTSIZE=0
```
Attenzione

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, ignorare il passaggio di deprovisioning. L'esecuzione del comando waagent -force -deprovision+user consente di rendere inutilizzabile il computer di origine. Questo passaggio è destinato solo a creare un'immagine generalizzata.
Fare clic su Azione>Arresta nella console di gestione di Hyper-V. Il disco rigido virtuale Linux è ora pronto per essere caricato in Azure.

KVM

Questa sezione illustra come usare KVM per preparare una distribuzione RHEL 6 o RHEL 7 da caricare in Azure.

RHEL 6 con KVM

Importante

Scaricare l'immagine KVM di RHEL 6 dal sito Web Red Hat.
Impostare una password radice.

Generare una password crittografata e copiare l'output del comando:
```
sudo openssl passwd -1 changeme
```
Impostare una password radice con guestfish:
```
sudo guestfish --rw -a <image-name>
> <fs> run
> <fs> list-filesystems
> <fs> mount /dev/sda1 /
> <fs> vi /etc/shadow
> <fs> exit
```
Modificare il secondo campo dell'utente radice da "!!" alla password crittografata.
Creare una macchina virtuale in KVM dall'immagine qcow2. Impostare il tipo di disco su qcow2 e il modello del dispositivo di interfaccia di rete virtuale su virtio. Avviare quindi la macchina virtuale e accedere come utente ROOT.
Creare o modificare il file /etc/sysconfig/network e aggiungere il testo seguente:
```
NETWORKING=yes
HOSTNAME=localhost.localdomain
```
Creare o modificare il file /etc/sysconfig/network-scripts/ifcfg-eth0 e aggiungere il testo seguente:
```
DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
```
Spostare o eliminare le regole udev per evitare la generazione di regole statiche per l'interfaccia Ethernet. Le regole seguenti causano problemi quando si clona una macchina virtuale in Azure o Hyper-V:
```
sudo ln -s /dev/null /etc/udev/rules.d/75-persistent-net-generator.rules
sudo rm -f /etc/udev/rules.d/70-persistent-net.rules
```

Nota

Per applicarlo:

sudo cat <<EOF>> /etc/udev/rules.d/68-azure-sriov-nm-unmanaged.rules
# Accelerated Networking on Azure exposes a new SRIOV interface to the VM.
# This interface is transparently bonded to the synthetic interface,
# so NetworkManager should just ignore any SRIOV interfaces.
SUBSYSTEM=="net", DRIVERS=="hv_pci", ACTION=="add", ENV{NM_UNMANAGED}="1"
EOF

Assicurarsi che il servizio di rete venga eseguito all'avvio attivando il comando seguente:
```
sudo chkconfig network on
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL eseguendo questo comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere ulteriori parametri del kernel per Azure. Per eseguire questa configurazione, aprire /boot/grub/menu.lst in un editor di testo e verificare che il kernel predefinito includa i parametri seguenti:
```
console=ttyS0 earlyprintk=ttyS0
```
In questo modo si garantisce inoltre che tutti i messaggi della console vengano inviati alla prima porta seriale, agevolando così il supporto di Azure nella risoluzione dei problemi di debug.

È consigliabile anche rimuovere i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB e questo potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Aggiungere i moduli Hyper-V a initramfs:

Modificare /etc/dracut.conf e aggiungere il contenuto seguente:
```
add_drivers+=" hv_vmbus hv_netvsc hv_storvsc "
```
Ricompilare initramfs:
```
sudo dracut -f -v
```
Disinstallare cloud-init:
```
sudo yum remove cloud-init
```
Verificare che il server SSH sia installato e configurato per l'esecuzione all'avvio:
```
sudo chkconfig sshd on
```
Modificare /etc/ssh/sshd_config per includere le righe seguenti:
```
PasswordAuthentication yes
ClientAliveInterval 180
```
È stato effettuato il push del pacchetto WALinuxAgent WALinuxAgent-<version> nel repository di funzionalità aggiuntive di Red Hat. Abilitare il repository di funzionalità aggiuntive eseguendo questo comando:
```
sudo subscription-manager repos --enable=rhel-6-server-extras-rpms
```
Installare l'agente Linux di Azure eseguendo il comando seguente:
```
sudo yum install WALinuxAgent
sudo chkconfig waagent on
```
L'agente Linux di Azure può configurare automaticamente lo spazio di swapping usando il disco risorse locale collegato alla macchina virtuale dopo il provisioning della macchina virtuale in Azure. Si noti che il disco di risorse locale è un disco temporaneo e potrebbe essere svuotato se la macchina virtuale viene deprovisionata. Dopo aver installato l'agente Linux di Azure nel passaggio precedente, modificare nel modo appropriato i parametri seguenti in /etc/waagent.conf:
```
ResourceDisk.Format=y
ResourceDisk.Filesystem=ext4
ResourceDisk.MountPoint=/mnt/resource
ResourceDisk.EnableSwap=y
ResourceDisk.SwapSizeMB=2048    ## NOTE: set this to whatever you need it to be.
```
Annullare la sottoscrizione (se necessario) eseguendo il comando seguente:
```
sudo subscription-manager unregister
```
Eseguire i comandi seguenti per effettuare il deprovisioning della macchina virtuale e prepararla per il provisioning in Azure:

Nota

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, ignorare il passaggio di deprovisioning
```
sudo rm -rf /var/lib/waagent/
sudo rm -f /var/log/waagent.log
sudo waagent -force -deprovision+user
sudo rm -f ~/.bash_history
sudo export HISTSIZE=0
```
Arrestare la macchina virtuale in KVM.
Convertire l'immagine qcow2 nel formato VHD.

Nota

C'è un bug noto nelle versioni >qemu-img =2.2.1 che genera un disco rigido virtuale formattato in modo non corretto. Il problema è stato risolto in QEMU 2.6. Si consiglia di usare qemu-img 2.2.0 o versione precedente oppure di eseguire l'aggiornamento alla versione 2.6 o successiva. Riferimento: https://bugs.launchpad.net/qemu/+bug/1490611.

Convertire innanzitutto l'immagine in formato non elaborato:
```
sudo qemu-img convert -f qcow2 -O raw rhel-6.9.qcow2 rhel-6.9.raw
```
Verificare che le dimensioni dell'immagine non elaborata siano pari a 1 MB. In caso contrario, arrotondare le dimensioni a 1 MB:
```
MB=$((1024*1024))
size=$(qemu-img info -f raw --output json "rhel-6.9.raw" | \
gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
rounded_size=$((($size/$MB + 1)*$MB))
sudo qemu-img resize rhel-6.9.raw $rounded_size
```
Convertire il disco non formattato in un disco rigido virtuale a dimensione fissa:
```
sudo qemu-img convert -f raw -o subformat=fixed -O vpc rhel-6.9.raw rhel-6.9.vhd
```
Oppure, con qemu versione 2.6+ includere l'opzione force_size:
```
sudo qemu-img convert -f raw -o subformat=fixed,force_size -O vpc rhel-6.9.raw rhel-6.9.vhd
```

RHEL 7 con KVM

Scaricare l'immagine KVM di RHEL 7 dal sito Web di Red Hat. Questa procedura usa RHEL 7 come esempio.
Impostare una password radice.

Generare una password crittografata e copiare l'output del comando:
```
sudo openssl passwd -1 changeme
```
Impostare una password radice con guestfish:
```
sudo  guestfish --rw -a <image-name>
> <fs> run
> <fs> list-filesystems
> <fs> mount /dev/sda1 /
> <fs> vi /etc/shadow
> <fs> exit
```
Modificare il secondo campo dell'utente radice da "!!" alla password crittografata.
Creare una macchina virtuale in KVM dall'immagine qcow2. Impostare il tipo di disco su qcow2 e il modello del dispositivo di interfaccia di rete virtuale su virtio. Avviare quindi la macchina virtuale e accedere come utente ROOT.
Creare o modificare il file /etc/sysconfig/network e aggiungere il testo seguente:
```
NETWORKING=yes
HOSTNAME=localhost.localdomain
```

Creare o modificare il file /etc/sysconfig/network-scripts/ifcfg-eth0 e aggiungere il testo seguente:

DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
PERSISTENT_DHCLIENT=yes
NM_CONTROLLED=yes

Assicurarsi che il servizio di rete venga eseguito all'avvio attivando il comando seguente:
```
sudo systemctl enable network
```
Registrare la propria sottoscrizione Red Hat per abilitare l’installazione dei pacchetti dall’archivio RHEL eseguendo il seguente comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere ulteriori parametri del kernel per Azure. A tale scopo, aprire /etc/default/grub in un editor di testo e modificare il GRUB_CMDLINE_LINUX parametro . Ad esempio:
```
GRUB_CMDLINE_LINUX="console=ttyS0 earlyprintk=ttyS0 net.ifnames=0"
```
Questo comando, inoltre, garantisce che tutti i messaggi della console vengano inviati alla prima porta seriale, agevolando così il supporto di Azure nella risoluzione dei problemi di debug. Il comando disattiva anche le nuove convenzioni di denominazione di RHEL 7 per le schede di interfaccia di rete. È consigliabile anche rimuovere i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB e questo potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Dopo aver terminato di modificare /etc/default/grub, eseguire questo comando per ricompilare la configurazione GRUB:
```
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
Aggiungere i moduli Hyper-V in initramfs.

Modificare /etc/dracut.conf e aggiungere il contenuto:
```
add_drivers+=" hv_vmbus hv_netvsc hv_storvsc "
```
Ricompilare initramfs:
```
sudo dracut -f -v
```
Disinstallare cloud-init:
```
sudo yum remove cloud-init
```
Verificare che il server SSH sia installato e configurato per l'esecuzione all'avvio:
```
sudo systemctl enable sshd
```
Modificare /etc/ssh/sshd_config per includere le righe seguenti:
```
PasswordAuthentication yes
ClientAliveInterval 180
```
È stato effettuato il push del pacchetto WALinuxAgent WALinuxAgent-<version> nel repository di funzionalità aggiuntive di Red Hat. Abilitare il repository di funzionalità aggiuntive eseguendo questo comando:
```
sudo subscription-manager repos --enable=rhel-7-server-extras-rpms
```
Installare l'agente Linux di Azure eseguendo il comando seguente:
```
sudo yum install WALinuxAgent
```
Abilitare il servizio waagent:
```
sudo systemctl enable waagent.service
```
Installare cloud-init Seguire la procedura descritta in "Preparare una macchina virtuale RHEL 7 dalla console di gestione di Hyper-V", passaggio 12, "Installare cloud-init per gestire il provisioning".
Configurazione di scambio

Non creare spazio di scambio sul disco del sistema operativo. Seguire la procedura descritta in "Preparare una macchina virtuale RHEL 7 dalla console di gestione di Hyper-V", passaggio 13, "Scambia configurazione"
Annullare la sottoscrizione (se necessario) eseguendo il comando seguente:
```
sudo subscription-manager unregister
```
Effettuare il deprovisioning

Seguire i passaggi descritti in "Preparare una macchina virtuale RHEL 7 dalla console di gestione di Hyper-V", passaggio 15, "Deprovision"
Arrestare la macchina virtuale in KVM.
Convertire l'immagine qcow2 nel formato VHD.

Nota

C'è un bug noto nelle versioni >qemu-img =2.2.1 che genera un disco rigido virtuale formattato in modo non corretto. Il problema è stato risolto in QEMU 2.6. Si consiglia di usare qemu-img 2.2.0 o versione precedente oppure di eseguire l'aggiornamento alla versione 2.6 o successiva. Riferimento: https://bugs.launchpad.net/qemu/+bug/1490611.

Convertire innanzitutto l'immagine in formato non elaborato:
```
sudo qemu-img convert -f qcow2 -O raw rhel-7.4.qcow2 rhel-7.4.raw
```
Verificare che le dimensioni dell'immagine non elaborata siano pari a 1 MB. In caso contrario, arrotondare le dimensioni a 1 MB:
```
MB=$((1024*1024))
size=$(qemu-img info -f raw --output json "rhel-7.4.raw" | \
gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
rounded_size=$((($size/$MB + 1)*$MB))
sudo qemu-img resize rhel-7.4.raw $rounded_size
```
Convertire il disco non formattato in un disco rigido virtuale a dimensione fissa:
```
sudo qemu-img convert -f raw -o subformat=fixed -O vpc rhel-7.4.raw rhel-7.4.vhd
```
Oppure, con qemu versione 2.6+ includere l'opzione force_size:
```
sudo qemu-img convert -f raw -o subformat=fixed,force_size -O vpc rhel-7.4.raw rhel-7.4.vhd
```

VMware

Questa sezione illustra come preparare una distribuzione di RHEL 6 o RHEL 7 da VMware.

Prerequisiti

In questa sezione si presuppone che una macchina virtuale RHEL sia già stata installata in VMware. Per informazioni dettagliate su come installare un sistema operativo in VMware, vedere la guida all'installazione del sistema operativo guest VMware.

Quando si installa il sistema operativo Linux è consigliabile usare partizioni standard anziché LVM, che è spesso l'impostazione predefinita per numerose installazioni. Questo consentirà di evitare conflitti di nome LVM con la macchina virtuale clonata, in particolare se fosse eventualmente necessario collegare un disco del sistema operativo a un'altra macchina virtuale per la risoluzione dei problemi. Se si preferisce, su dischi di dati si può usare LVM o RAID.
Non configurare una partizione di scambio sul disco del sistema operativo. È possibile configurare l'agente Linux per poter creare un file di scambio sul disco temporaneo delle risorse. Altre informazioni su questo argomento sono disponibili nei passaggi riportati di seguito.
Quando si crea il disco rigido virtuale, selezionare Store virtual disk as a single file(Archivia disco virtuale come singolo file).

RHEL 6 con VMware

Importante

A partire dal 30 novembre 2020, Red Hat Enterprise Linux 6 raggiungerà la fase di manutenzione. La fase di manutenzione è seguita dalla fase di durata estesa. Poiché Red Hat Enterprise Linux 6 esce dalle fasi di manutenzione completa, è consigliabile eseguire l'aggiornamento a Red Hat Enterprise Linux 7 o 8 o 9. Se i clienti devono rimanere in Red Hat Enterprise Linux 6, è consigliabile aggiungere il componente aggiuntivo Red Hat Enterprise Linux Extended Life Cycle Support (ELS).

In RHEL 6, NetworkManager può interferire con l'agente Linux di Azure. Disinstallare il pacchetto eseguendo questo comando:
```
sudo rpm -e --nodeps NetworkManager
```
Creare nella directory /etc/sysconfig/ un file denominato network contenente il testo seguente:
```
NETWORKING=yes
HOSTNAME=localhost.localdomain
```
Creare o modificare il file /etc/sysconfig/network-scripts/ifcfg-eth0 e aggiungere il testo seguente:
```
DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
```
Spostare o eliminare le regole udev per evitare la generazione di regole statiche per l'interfaccia Ethernet. Le regole seguenti causano problemi quando si clona una macchina virtuale in Azure o Hyper-V:
```
sudo ln -s /dev/null /etc/udev/rules.d/75-persistent-net-generator.rules
sudo rm -f /etc/udev/rules.d/70-persistent-net.rules
```

Nota

Per applicarlo:

sudo cat <<EOF>> /etc/udev/rules.d/68-azure-sriov-nm-unmanaged.rules
# Accelerated Networking on Azure exposes a new SRIOV interface to the VM.
# This interface is transparently bonded to the synthetic interface,
# so NetworkManager should just ignore any SRIOV interfaces.
SUBSYSTEM=="net", DRIVERS=="hv_pci", ACTION=="add", ENV{NM_UNMANAGED}="1"
EOF

Assicurarsi che il servizio di rete venga eseguito all'avvio attivando il comando seguente:
```
sudo chkconfig network on
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL eseguendo questo comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
È stato effettuato il push del pacchetto WALinuxAgent WALinuxAgent-<version> nel repository di funzionalità aggiuntive di Red Hat. Abilitare il repository di funzionalità aggiuntive eseguendo questo comando:
```
sudo subscription-manager repos --enable=rhel-6-server-extras-rpms
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere ulteriori parametri del kernel per Azure. A tale scopo, aprire /etc/default/grub in un editor di testo e modificare il GRUB_CMDLINE_LINUX parametro . Ad esempio:
```
GRUB_CMDLINE_LINUX="console=ttyS0 earlyprintk=ttyS0"
```
In questo modo si garantisce inoltre che tutti i messaggi della console vengano inviati alla prima porta seriale, agevolando così il supporto di Azure nella risoluzione dei problemi di debug. È consigliabile anche rimuovere i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB e questo potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Aggiungere i moduli Hyper-V a initramfs:

Modificare /etc/dracut.conf e aggiungere il contenuto seguente:
```
add_drivers+=" hv_vmbus hv_netvsc hv_storvsc "
```
Ricompilare initramfs:
```
sudo dracut -f -v
```
Verificare che il server SSH sia installato e configurato per l'esecuzione all'avvio, che è in genere l'impostazione predefinita. Modificare /etc/ssh/sshd_config per poter includere la riga seguente:
```
ClientAliveInterval 180
```
Installare l'agente Linux di Azure eseguendo il comando seguente:
```
sudo yum install WALinuxAgent
sudo chkconfig waagent on
```
Non creare spazio di scambio sul disco del sistema operativo.

L'agente Linux di Azure può configurare automaticamente lo spazio di swapping usando il disco risorse locale collegato alla macchina virtuale dopo il provisioning della macchina virtuale in Azure. Si noti che il disco di risorse locale è un disco temporaneo e potrebbe essere svuotato se la macchina virtuale viene deprovisionata. Dopo aver installato l'agente Linux di Azure nel passaggio precedente, modificare nel modo appropriato i parametri seguenti in /etc/waagent.conf:
```
ResourceDisk.Format=y
ResourceDisk.Filesystem=ext4
ResourceDisk.MountPoint=/mnt/resource
ResourceDisk.EnableSwap=y
ResourceDisk.SwapSizeMB=2048    ## NOTE: set this to whatever you need it to be.
```
Annullare la sottoscrizione (se necessario) eseguendo il comando seguente:
```
sudo subscription-manager unregister
```
Eseguire i comandi seguenti per effettuare il deprovisioning della macchina virtuale e prepararla per il provisioning in Azure:

Nota

Se si esegue la migrazione di una macchina virtuale specifica e non si vuole creare un'immagine generalizzata, ignorare il passaggio di deprovisioning.
```
sudo rm -rf /var/lib/waagent/
sudo rm -f /var/log/waagent.log
sudo waagent -force -deprovision+user
sudo rm -f ~/.bash_history
sudo export HISTSIZE=0
```
Arrestare la macchina virtuale e convertire il file VMDK in un file con estensione vhd.

Nota

C'è un bug noto nelle versioni >qemu-img =2.2.1 che genera un disco rigido virtuale formattato in modo non corretto. Il problema è stato risolto in QEMU 2.6. Si consiglia di usare qemu-img 2.2.0 o versione precedente oppure di eseguire l'aggiornamento alla versione 2.6 o successiva. Riferimento: https://bugs.launchpad.net/qemu/+bug/1490611.

Convertire innanzitutto l'immagine in formato non elaborato:
```
sudo qemu-img convert -f vmdk -O raw rhel-6.9.vmdk rhel-6.9.raw
```
Verificare che le dimensioni dell'immagine non elaborata siano pari a 1 MB. In caso contrario, arrotondare le dimensioni a 1 MB:
```
MB=$((1024*1024))
size=$(qemu-img info -f raw --output json "rhel-6.9.raw" | \
gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
rounded_size=$((($size/$MB + 1)*$MB))
sudo qemu-img resize rhel-6.9.raw $rounded_size
```
Convertire il disco non formattato in un disco rigido virtuale a dimensione fissa:
```
sudo qemu-img convert -f raw -o subformat=fixed -O vpc rhel-6.9.raw rhel-6.9.vhd
```
Oppure, con qemu versione 2.6+ includere l'opzione force_size:
```
sudo qemu-img convert -f raw -o subformat=fixed,force_size -O vpc rhel-6.9.raw rhel-6.9.vhd
```

RHEL 7 con VMware

Creare o modificare il file /etc/sysconfig/network e aggiungere il testo seguente:
```
NETWORKING=yes
HOSTNAME=localhost.localdomain
```

Creare o modificare il file /etc/sysconfig/network-scripts/ifcfg-eth0 e aggiungere il testo seguente:

DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
PERSISTENT_DHCLIENT=yes
NM_CONTROLLED=yes

Assicurarsi che il servizio di rete venga eseguito all'avvio attivando il comando seguente:
```
sudo systemctl enable network
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL eseguendo questo comando:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere ulteriori parametri del kernel per Azure. Per eseguire questa modifica, aprire /etc/default/grub in un editor di testo e modificare il GRUB_CMDLINE_LINUX parametro . Ad esempio:
```
GRUB_CMDLINE_LINUX="console=ttyS0 earlyprintk=ttyS0 net.ifnames=0"
```
Questa configurazione, inoltre, garantisce che tutti i messaggi della console vengano inviati alla prima porta seriale, agevolando così il supporto di Azure nella risoluzione dei problemi di debug. Disattiva anche le nuove convenzioni di denominazione RHEL 7 per le schede di interfaccia di rete. È consigliabile anche rimuovere i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvio grafici e non silenziosi non sono utili in un ambiente cloud in cui tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se necessario. Si noti che questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB e questo potrebbe causare problemi in macchine virtuali di dimensioni inferiori.
Dopo aver terminato di modificare /etc/default/grub, eseguire questo comando per ricompilare la configurazione GRUB:
```
sudo grub2-mkconfig -o /boot/grub2/grub.cfg
```
Aggiungere i moduli Hyper-V a initramfs.

Modificare /etc/dracut.confe aggiungere il contenuto:
```
add_drivers+=" hv_vmbus hv_netvsc hv_storvsc "
```
Ricompilare initramfs:
```
sudo dracut -f -v
```
Verificare che il server SSH sia installato e configurato per l'esecuzione all'avvio. Questa è in genere l'impostazione predefinita. Modificare /etc/ssh/sshd_config per poter includere la riga seguente:
```
ClientAliveInterval 180
```
È stato effettuato il push del pacchetto WALinuxAgent WALinuxAgent-<version> nel repository di funzionalità aggiuntive di Red Hat. Abilitare il repository di funzionalità aggiuntive eseguendo questo comando:
```
sudo subscription-manager repos --enable=rhel-7-server-extras-rpms
```

Installare l'agente Linux di Azure eseguendo il comando seguente:

sudo yum install WALinuxAgent
sudo systemctl enable waagent.service

Installare cloud-init

Seguire i passaggi descritti in "Preparare una macchina virtuale RHEL 7 dalla console di gestione di Hyper-V", passaggio 12, "Installare cloud-init per gestire il provisioning".
Configurazione di scambio

Non creare spazio di scambio sul disco del sistema operativo. Seguire la procedura descritta in "Preparare una macchina virtuale RHEL 7 dalla console di gestione di Hyper-V", passaggio 13, "Scambia configurazione"
Se si vuole annullare la registrazione della sottoscrizione, eseguire il comando seguente:
```
sudo subscription-manager unregister
```
Effettuare il deprovisioning

Seguire i passaggi descritti in "Preparare una macchina virtuale RHEL 7 dalla console di gestione di Hyper-V", passaggio 15, "Deprovision"
Arrestare la macchina virtuale e convertire il file VMDK nel formato VHD.

Nota

C'è un bug noto nelle versioni >qemu-img =2.2.1 che genera un disco rigido virtuale formattato in modo non corretto. Il problema è stato risolto in QEMU 2.6. Si consiglia di usare qemu-img 2.2.0 o versione precedente oppure di eseguire l'aggiornamento alla versione 2.6 o successiva. Riferimento: https://bugs.launchpad.net/qemu/+bug/1490611.

Convertire innanzitutto l'immagine in formato non elaborato:
```
sudo qemu-img convert -f vmdk -O raw rhel-7.4.vmdk rhel-7.4.raw
```
Verificare che le dimensioni dell'immagine non elaborata siano pari a 1 MB. In caso contrario, arrotondare le dimensioni a 1 MB:
```
MB=$((1024*1024))
size=$(qemu-img info -f raw --output json "rhel-7.4.raw" | \
gawk 'match($0, /"virtual-size": ([0-9]+),/, val) {print val[1]}')
rounded_size=$((($size/$MB + 1)*$MB))
sudo qemu-img resize rhel-7.4.raw $rounded_size
```
Convertire il disco non formattato in un disco rigido virtuale a dimensione fissa:
```
sudo qemu-img convert -f raw -o subformat=fixed -O vpc rhel-7.4.raw rhel-7.4.vhd
```
Oppure, con qemu versione 2.6+ includere l'opzione force_size:
```
sudo qemu-img convert -f raw -o subformat=fixed,force_size -O vpc rhel-7.4.raw rhel-7.4.vhd
```

File Kickstart

Questa sezione illustra come preparare una distribuzione RHEL 7 da un ISO usando un file kickstart.

RHEL 7 da un file kickstart

Creare un file kickstart che include il contenuto seguente e salvare il file. Per informazioni dettagliate sull'installazione di kickstart, vedere la guida all'installazione di kickstart.

# Kickstart for provisioning a RHEL 7 Azure VM

# System authorization information
  auth --enableshadow --passalgo=sha512

# Use graphical install
text

# Don't run the Setup Agent on first boot
firstboot --disable

# Keyboard layouts
keyboard --vckeymap=us --xlayouts='us'

# System language
lang en_US.UTF-8

# Network information
network  --bootproto=dhcp

# Root password
rootpw --plaintext "to_be_disabled"

# System services
services --enabled="sshd,waagent,NetworkManager"

# System timezone
timezone Etc/UTC --isUtc --ntpservers 0.rhel.pool.ntp.org,1.rhel.pool.ntp.org,2.rhel.pool.ntp.org,3.rhel.pool.ntp.org

# Partition clearing information
clearpart --all --initlabel

# Clear the MBR
zerombr

# Disk partitioning information
part /boot --fstype="xfs" --size=500
part / --fstyp="xfs" --size=1 --grow --asprimary

# System bootloader configuration
bootloader --location=mbr

# Firewall configuration
firewall --disabled

# Enable SELinux
selinux --enforcing

# Don't configure X
skipx

# Power down the machine after install
poweroff

%packages
@base
@console-internet
chrony
sudo
parted
-dracut-config-rescue

%end

%post --log=/var/log/anaconda/post-install.log

#!/bin/bash

# Register Red Hat Subscription
subscription-manager register --username=XXX --password=XXX --auto-attach --force

# Install latest repo update
yum update -y

# Enable extras repo
subscription-manager repos --enable=rhel-7-server-extras-rpms

# Install WALinuxAgent
yum install -y WALinuxAgent

# Unregister Red Hat subscription
subscription-manager unregister

# Enable waaagent at boot-up
systemctl enable waagent

# Install cloud-init
yum install -y cloud-init cloud-utils-growpart gdisk hyperv-daemons

# Configure waagent for cloud-init
sed -i 's/Provisioning.Agent=auto/Provisioning.Agent=cloud-init/g' /etc/waagent.conf
sed -i 's/ResourceDisk.Format=y/ResourceDisk.Format=n/g' /etc/waagent.conf
sed -i 's/ResourceDisk.EnableSwap=y/ResourceDisk.EnableSwap=n/g' /etc/waagent.conf

echo "Adding mounts and disk_setup to init stage"
sed -i '/ - mounts/d' /etc/cloud/cloud.cfg
sed -i '/ - disk_setup/d' /etc/cloud/cloud.cfg
sed -i '/cloud_init_modules/a\\ - mounts' /etc/cloud/cloud.cfg
sed -i '/cloud_init_modules/a\\ - disk_setup' /etc/cloud/cloud.cfg

# Disable the root account
usermod root -p '!!'

# Configure swap using cloud-init
echo 'DefaultEnvironment="CLOUD_CFG=/etc/cloud/cloud.cfg.d/00-azure-swap.cfg"' >> /etc/systemd/system.conf
cat > /etc/cloud/cloud.cfg.d/00-azure-swap.cfg << EOF
#cloud-config
# Generated by Azure cloud image build
disk_setup:
ephemeral0:
    table_type: mbr
    layout: [66, [33, 82]]
    overwrite: True
fs_setup:
- device: ephemeral0.1
    filesystem: ext4
- device: ephemeral0.2
    filesystem: swap
mounts:
- ["ephemeral0.1", "/mnt"]
- ["ephemeral0.2", "none", "swap", "sw,nofail,x-systemd.device-timeout=2,x-systemd.requires=cloud-init.service", "0", "0"]
EOF

# Set the cmdline
sed -i 's/^\(GRUB_CMDLINE_LINUX\)=".*"$/\1="console=tty1 console=ttyS0 earlyprintk=ttyS0"/g' /etc/default/grub

# Enable SSH keepalive
sed -i 's/^#\(ClientAliveInterval\).*$/\1 180/g' /etc/ssh/sshd_config

# Build the grub cfg
grub2-mkconfig -o /boot/grub2/grub.cfg

# Configure network
cat << EOF > /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE=eth0
ONBOOT=yes
BOOTPROTO=dhcp
TYPE=Ethernet
USERCTL=no
PEERDNS=yes
IPV6INIT=no
PERSISTENT_DHCLIENT=yes
NM_CONTROLLED=yes
EOF

# Deprovision and prepare for Azure if you are creating a generalized image
sudo cloud-init clean --logs --seed
sudo rm -rf /var/lib/cloud/
sudo rm -rf /var/lib/waagent/
sudo rm -f /var/log/waagent.log

sudo waagent -force -deprovision+user
rm -f ~/.bash_history
export HISTSIZE=0

%end

Posizionare il file kickstart in un percorso in cui sia accessibile per il sistema di installazione.
Creare una nuova macchina virtuale nella console di gestione di Hyper-V. Nella pagina Connessione disco rigido virtuale selezionare Connetti un disco rigido virtuale successivamente e completare la creazione guidata della macchina virtuale.
Aprire le impostazioni della macchina virtuale:
1. Collegare un nuovo disco rigido virtuale alla macchina virtuale. Accertarsi di selezionare Formato VHD e A dimensione fissa.
2. Collegare l'ISO di installazione all'unità DVD.
3. Impostare il BIOS per l'avvio da CD.
Avviare la macchina virtuale. Quando viene visualizzata la guida all'installazione, premere Tab per configurare le opzioni di avvio.
Inserire inst.ks=<the location of the kickstart file> alla fine di opzioni di avvio e premere Invio.
Attendere la fine dell'installazione. Al termine, la macchina virtuale verrà arrestata automaticamente. Il file VHD Linux è ora pronto per il caricamento in Azure.

Problemi noti

Non è stato possibile includere il driver Hyper-V nel disco RAM iniziale quando si usa un hypervisor non Hyper-V

In alcuni casi, i programmi di installazione di Linux potrebbero non includere i driver per Hyper-V nel disco RAM iniziale (initrd o initramfs), a meno che Linux non rilevi di essere in esecuzione in un ambiente Hyper-V.

Quando si usa un sistema di virtualizzazione diverso, ovvero VirtualBox, Xen e così via, per preparare l'immagine Linux, potrebbe essere necessario ricompilare initrd per assicurarsi che almeno i moduli kernel hv_vmbus e hv_storvsc siano disponibili nel disco RAM iniziale. Questo è un problema noto, almeno nei sistemi basati sulla distribuzione upstream di Red Hat.

Per risolvere questo problema, aggiungere i moduli Hyper-V a initramfs e ricompilarlo:

Modificare /etc/dracut.conf e aggiungere il contenuto seguente:

add_drivers+=" hv_vmbus hv_netvsc hv_storvsc "

Ricompilare initramfs:

sudo dracut -f -v

Per altri dettagli, vedere le informazioni sulla ricompilazione di initramfs.

Passaggi successivi

È ora possibile usare il disco rigido virtuale Red Hat Enterprise Linux per creare nuove macchine virtuali in Azure. Se è la prima volta che si carica il file VHD in Azure, vedere Creare una macchina virtuale Linux da un disco personalizzato.
Per altre informazioni sugli hypervisor certificati per l'esecuzione di Red Hat Enterprise Linux, visitare il sito Web di Red Hat.
Per altre informazioni sull'uso di immagini RHEL BYOS pronte per la produzione, passare alla pagina della documentazione per BYOS.

Condividi tramite

Preparare una macchina virtuale basata su RedHat per Azure

Console di gestione di Hyper-V

Prerequisiti

RHEL 6 con la console di gestione di Hyper-V

RHEL 7 con la console di gestione di Hyper-V

RHEL 8+ con la console di gestione di Hyper-V

KVM

RHEL 6 con KVM

RHEL 7 con KVM

VMware

Prerequisiti

RHEL 6 con VMware

RHEL 7 con VMware

File Kickstart

RHEL 7 da un file kickstart

Problemi noti

Non è stato possibile includere il driver Hyper-V nel disco RAM iniziale quando si usa un hypervisor non Hyper-V

Passaggi successivi

Risorse aggiuntive