Preparare una macchina virtuale basata su RedHat per Azure

Articolo
07/04/2024

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

In questo articolo viene descritto come preparare una macchina virtuale Red Hat Enterprise Linux (RHEL) per l'utilizzo in Azure. Le versioni di RHEL trattate in questo articolo sono la 6.X, la 7.X e la 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 compilazione di immagini RHEL, vedere Image Builder di Azure.

Nota

Tenere presente le versioni che si trovano alla fine del ciclo di vita (EOL) e non sono più supportate da Red Hat. Le immagini caricate che si trovano alla fine del servizio o l’hanno oltrepassato sono supportate ragionevolmente in base all’azienda. Per altre informazioni, vedere i cicli di vita del prodotto di Red Hat.

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

In questa sezione si presuppone che si sia già ottenuto un file ISO dal sito Web Red Hat e che sia già stata installata un'immagine RHEL in un disco rigido virtuale (VHD). Per altre informazioni 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. Se si usa VirtualBox, durante la creazione del disco selezionare Fixed size (A dimensione fissa) anziché l'opzione predefinita di allocazione dinamica.
Azure supporta macchine virtuali 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. In genere è consigliabile usare partizioni standard sul disco del sistema operativo anziché LVM. Questa procedura consente 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. Per altre informazioni, vedere la documentazione di LVM e RAID.
Per montare file system UDF (Universal Disk Format) è necessario il supporto del kernel. Al primo avvio in Azure, i supporti con formattazione UDF collegati al guest passano la configurazione di provisioning alla macchina virtuale Linux. È necessario che l'agente Linux di Azure possa montare il file system UDF per leggere la relativa configurazione ed eseguire il provisioning della macchina virtuale. Senza questo passaggio, il provisioning ha esito negativo.
Non configurare una partizione di swapping sul disco del sistema operativo. Per altre informazioni, leggere i passaggi seguenti.
Le dimensioni di tutti i dischi rigidi virtuali in 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. Per altre informazioni, leggere i passaggi seguenti. Vedere anche Note generali sull'installazione di Linux.

Nota

Cloud-init >= 21.2 rimuove il requisito di UDF. Senza il modulo UDF abilitato, tuttavia, il CD-ROM non verrà montato durante il provisioning, impedendo l'applicazione dei dati personalizzati. Una soluzione alternativa consiste nell'applicare i dati personalizzati usando i dati utente. A differenza dei dati personalizzati, i dati utente non sono crittografati. Per altre informazioni, vedere Formati dei dati utente.

RHEL 6 tramite la Console di gestione di Hyper-V

Importante

Il 30 novembre 2020 RHEL 6 ha raggiunto il termine della fase di manutenzione. La fase di manutenzione è seguita dalla fase di durata estesa. Quando RHEL 6 esce dalle fasi di completamento/manutenzione, è consigliabile eseguire l'aggiornamento a RHEL 7, 8 o 9. Se è necessario rimanere in RHEL 6, è consigliabile aggiungere il componente aggiuntivo di assistenza alla durata estesa di RHEL.

Nella Console di gestione di Hyper-V, selezionare la macchina virtuale.
Selezionare Connetti per aprire una finestra della console per la macchina virtuale.
In RHEL 6, NetworkManager può interferire con l'agente Linux di Azure. Disinstallare questo pacchetto:
```
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 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

Quando si usa rete accelerata, l'interfaccia sintetica creata deve essere configurata in modo da non essere gestita usando una regola Udev. Questa azione impedisce a NetworkManager di assegnare lo stesso indirizzo IP dell'interfaccia primaria.

Per applicarla:

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 avviato all'avvio:
```
sudo chkconfig network on
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL:
```
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 aggiuntivo:
```
sudo subscription-manager repos --enable=rhel-6-server-extras-rpms
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure. Per eseguire questa modifica, aprire /boot/grub/menu.lst in un editor di testo. Verificare che il kernel predefinito includa i parametri seguenti:
```
console=ttyS0 earlyprintk=ttyS0
```
Questa azione 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 avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. Questo parametro riduce la quantità di memoria disponibile nella macchina virtuale di almeno 128 MB. Questa configurazione potrebbe rappresentare un problema per le dimensioni delle macchine virtuali più piccole.
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 poter includere la riga seguente:
```
ClientAliveInterval 180
```
Installare l'agente Linux di Azure:
```
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 lo spazio di swapping sul disco del sistema operativo.

L'agente Linux di Azure può configurare automaticamente l'area di swapping usando il disco risorse locale collegato alla VM dopo il provisioning della VM in Azure. Il disco risorse locale è un disco temporaneo e potrebbe essere svuotato in seguito al deprovisioning della macchina virtuale. 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):
```
sudo subscription-manager unregister
```
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
```
Selezionare Azione>Arresta nella Console di gestione di Hyper-V. Il file VHD Linux è ora pronto per il caricamento in Azure.

RHEL 7 tramite la Console di gestione di Hyper-V

Nella Console di gestione di Hyper-V, selezionare la macchina virtuale.
Selezionare 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 avviato all'avvio:
```
sudo systemctl enable network
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure. Per eseguire questa modifica, aprire /etc/default/grub in un editor di testo e modificare il parametro GRUB_CMDLINE_LINUX. 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 in /etc/default/grub anziché ENABLE_BLSCFG=true, strumenti come grubedit o gubby, che si basano sulla specifica del caricatore di avvio (BLS) per la gestione delle voci di avvio e delle configurazioni, potrebbero non funzionare correttamente in RHEL 8 e 9. Se ENABLE_BLSCFG non è presente, il comportamento predefinito è false.

Questa modifica, inoltre, garantisce che tutti i messaggi della console vengano inviati alla prima porta seriale e abilitino l’interazione con la console seriale, agevolando così il supporto tecnico di Azure nella risoluzione dei problemi di debug. Questa configurazione disattiva anche le nuove convenzioni di denominazione di RHEL 7 per le schede di interfaccia di rete (NIC).
```
rhgb quiet crashkernel=auto
```
Gli avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. 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
```
Nota

Se si sta caricando 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 aggiuntivo:
```
sudo subscription-manager repos --enable=rhel-7-server-extras-rpms
```

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

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 nella configurazione /etc/waagent.conf.

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 il file di scambio 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

Configurazione dello swapping:
- Non creare lo spazio di swapping sul disco del sistema operativo.
  
  In precedenza, l'agente Linux di Azure era usato per configurare automaticamente lo spazio di swapping usando il disco risorse locale collegato alla VM dopo il provisioning della VM in Azure. Questa azione è ora gestita da cloud-init. Non bisogna usare l'agente Linux per formattare il disco delle risorse per creare il file di scambio. Modificare appropriatamente i parametri seguenti in /etc/waagent.conf:
```
ResourceDisk.Format=n
ResourceDisk.EnableSwap=n
```
- Se si vuole montare, formattare e creare il file di scambio, è possibile:
  - Passare questo codice come configurazione cloud-init ogni volta che si crea una macchina virtuale tramite i dati personalizzati. È consigliabile adottare questa soluzione.
  - Usare una direttiva cloud-init integrata nell'immagine che esegue questo passaggio 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 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 rende 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
```
Selezionare Azione>Arresta nella Console di gestione di Hyper-V. Il file VHD Linux è ora pronto per il caricamento in Azure.

RHEL 8+ tramite la Console di gestione di Hyper-V

Nella Console di gestione di Hyper-V, selezionare la macchina virtuale.
Selezionare Connetti per aprire una finestra della console per la macchina virtuale.
Assicurarsi che il servizio di Gestione rete venga avviato all'avvio:
```
sudo systemctl enable NetworkManager.service
```
Configurare l'interfaccia di rete per l'avvio automatico e usare il Dynamic Host Configuration Protocol:
```
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:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure e abilitare la console seriale.
Rimuovere i parametri GRUB correnti:
```
sudo grub2-editenv - unset kernelopts
```
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"
```
Questa modifica, inoltre, garantisce che tutti i messaggi della console vengano inviati alla prima porta seriale e abilitino l’interazione con la console seriale, agevolando così il supporto tecnico di Azure nella risoluzione dei problemi di debug. Questa configurazione disattiva anche le nuove convenzioni di denominazione per le schede di interfaccia di rete.
È consigliabile rimuovere anche i parametri seguenti:
```
rhgb quiet crashkernel=auto
```
Gli avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. 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 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:

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 configurazione /etc/waagent.conf.

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 il file di scambio 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

Configurazione dello swapping:
- Non creare lo spazio di swapping sul disco del sistema operativo.
  
  In precedenza, l'agente Linux di Azure era usato per configurare automaticamente lo spazio di swapping usando il disco risorse locale collegato alla VM dopo il provisioning della VM in Azure. Questa azione è ora gestita da cloud-init. Non bisogna usare l'agente Linux per formattare il disco delle risorse per creare il file di scambio. Modificare appropriatamente i parametri seguenti in /etc/waagent.conf:
```
ResourceDisk.Format=n
ResourceDisk.EnableSwap=n
```
  - Passare questo codice come configurazione cloud-init ogni volta che si crea una macchina virtuale tramite i dati personalizzati. È consigliabile adottare questa soluzione.
  - Usare una direttiva cloud-init integrata nell'immagine che esegue questo passaggio 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
```
Eseguire i comandi seguenti per effettuare il deprovisioning della VM 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 rende inutilizzabile il computer di origine. Questo passaggio è destinato solo a creare un'immagine generalizzata.
Selezionare Azione>Arresta nella Console di gestione di Hyper-V. Il file VHD Linux è ora pronto per il caricamento 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
```

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 applicarla:

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 avviato all'avvio:
```
sudo chkconfig network on
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure. Per eseguire questa configurazione, aprire /boot/grub/menu.lst in un editor di testo. Verificare che il kernel predefinito includa i parametri seguenti:
```
console=ttyS0 earlyprintk=ttyS0
```
Questo passaggio 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 avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. 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 poter 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 aggiuntivo:
```
sudo subscription-manager repos --enable=rhel-6-server-extras-rpms
```

Installare l'agente Linux di Azure:

sudo yum install WALinuxAgent
sudo chkconfig waagent on

L'agente Linux di Azure può configurare automaticamente l'area di swapping usando il disco risorse locale collegato alla VM dopo il provisioning della VM in Azure. Il disco risorse locale è un disco temporaneo e potrebbe essere svuotato in seguito al deprovisioning della macchina virtuale. 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):
```
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 VM in KVM.
Convertire l'immagine qcow2 nel formato VHD.

Nota

Esiste un bug noto nelle versioni di qemu-img >= 2.2.1 che produce un disco rigido virtuale non formattato correttamente. 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. Per altre informazioni, vedere questo sito Web.

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
```
In alternativa, 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 come esempio RHEL 7.
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 avviato all'avvio:
```
sudo systemctl enable network
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure. Per eseguire questa configurazione, aprire /etc/default/grub in un editor di testo e modificare il parametro GRUB_CMDLINE_LINUX. 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 avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. 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 poter 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 aggiuntivo:
```
sudo subscription-manager repos --enable=rhel-7-server-extras-rpms
```

Installare l'agente Linux di Azure:

sudo yum install WALinuxAgent

Abilitare il servizio waagent:

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 dello swapping:
- Non creare lo spazio di swapping sul disco del sistema operativo.
- Seguire i passaggi descritti in "Preparare una macchina virtuale RHEL 7 dalla Console di gestione di Hyper-V", passaggio 13, "Effettuare lo swapping della configurazione".
Annullare la sottoscrizione (se necessario):
```
sudo subscription-manager unregister
```
Effettuare il deprovisioning seguendo i passaggi seguenti descritti in "Preparare una macchina virtuale RHEL 7 dalla Console di gestione di Hyper-V", passaggio 15, "Deprovisioning".
Arrestare la VM in KVM.
Convertire l'immagine qcow2 nel formato VHD.

Nota

Esiste un bug noto nelle versioni di qemu-img >= 1.1.1 che produce un disco rigido virtuale non formattato correttamente. Il problema è stato risolto in QEMU 1.6. Si consiglia di usare qemu-img 1.1.0 o versione precedente oppure di eseguire l'aggiornamento alla versione 1.6 o successiva. Per altre informazioni, vedere questo sito Web.

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
```
In alternativa, con qemu versione 1.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 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 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. L'uso delle partizioni consente di evitare conflitti di nome LVM con una macchina virtuale clonata, in particolare se fosse necessario collegare un disco del sistema operativo a un'altra macchina virtuale per la risoluzione dei problemi. Se si desidera, su dischi di dati si può usare LVM o RAID.
Non configurare una partizione di swapping sul disco del sistema operativo. È possibile configurare l'agente Linux per poter creare un file di scambio sul disco temporaneo delle risorse. Per altre informazioni, leggere i passaggi seguenti.
Quando si crea il disco rigido virtuale, selezionare Archivia disco virtuale come singolo file.

RHEL 6 con VMware

Importante

In RHEL 6, NetworkManager può interferire con l'agente Linux di Azure. Disinstallare questo pacchetto:
```
sudo rpm -e --nodeps NetworkManager
```
Creare un file denominato network in the /etc/sysconfig/ 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
```

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 applicarla:

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 avviato all'avvio:
```
sudo chkconfig network on
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL:
```
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 aggiuntivo:
```
sudo subscription-manager repos --enable=rhel-6-server-extras-rpms
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure. Per eseguire il passaggio, aprire /etc/default/grub in un editor di testo e modificare il parametro GRUB_CMDLINE_LINUX. Ad esempio:
```
GRUB_CMDLINE_LINUX="console=ttyS0 earlyprintk=ttyS0"
```
Questo passaggio 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 avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. 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:

sudo yum install WALinuxAgent
sudo chkconfig waagent on

Non creare uno spazio di swapping sul disco del sistema operativo.

L'agente Linux di Azure può configurare automaticamente l'area di swapping usando il disco risorse locale collegato alla VM dopo il provisioning della VM in Azure. Il disco risorse locale è un disco temporaneo e potrebbe essere svuotato in seguito al deprovisioning della macchina virtuale. 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):
```
sudo subscription-manager unregister
```
Eseguire i comandi seguenti per effettuare il deprovisioning della VM 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

Esiste un bug noto nelle versioni di qemu-img >= 2.2.1 che produce un disco rigido virtuale non formattato correttamente. 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. Per altre informazioni, vedere questo sito Web.

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
```
In alternativa, 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 avviato all'avvio:
```
sudo systemctl enable network
```
Registrare la propria sottoscrizione Red Hat per abilitare l'installazione dei pacchetti dall'archivio RHEL:
```
sudo subscription-manager register --auto-attach --username=XXX --password=XXX
```
Modificare la riga di avvio del kernel nella configurazione GRUB per includere altri parametri del kernel per Azure. Per eseguire questa modifica, aprire /etc/default/grub in un editor di testo e modificare il parametro GRUB_CMDLINE_LINUX. 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 avvi grafici e silenziosi non sono utili in un ambiente cloud se tutti i log devono essere inviati alla porta seriale. È possibile mantenere l'opzione crashkernel configurata, se si desidera. 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 aggiuntivo:
```
sudo subscription-manager repos --enable=rhel-7-server-extras-rpms
```

Installare l'agente Linux di Azure:

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 dello swapping:
- Non creare lo spazio di swapping sul disco del sistema operativo.
- Seguire i passaggi descritti in "Preparare una macchina virtuale RHEL 7 dalla Console di gestione di Hyper-V", passaggio 13, "Effettuare lo swapping della configurazione".
Se si vuole annullare la registrazione della sottoscrizione, eseguire il comando seguente:
```
sudo subscription-manager unregister
```
Effettuare il deprovisioning seguendo i passaggi seguenti descritti in "Preparare una macchina virtuale RHEL 7 dalla Console di gestione di Hyper-V", passaggio 15, "Deprovisioning".
Arrestare la VM e convertire il file VMDK in file VHD.

Nota

Esiste un bug noto nelle versioni di qemu-img >= 2.2.1 che produce un disco rigido virtuale non formattato correttamente. 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. Per altre informazioni, vedere questo sito Web.

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
```
In alternativa, 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 e salvare un file kickstart con il contenuto seguente. Per informazioni 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 Hyper-V. Nella pagina Connessione disco rigido virtuale selezionare Connetti un disco rigido virtuale successivamente e completare la creazione guidata della nuova 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 VM. Quando viene visualizzata la guida all'installazione, selezionare il tasto Tab per configurare le opzioni di avvio.
Inserire inst.ks=<the location of the kickstart file> alla fine di opzioni di avvio e selezionare il tasto Invio.
Attendere la fine dell'installazione. Al termine, la VM si arresta automaticamente. Il file VHD Linux è ora pronto per il caricamento in Azure.

Problemi noti

Il problema seguente è noto.

Non è 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 (ad esempio Virtualbox o Xen) per preparare l'immagine Linux, potrebbe essere necessario ricompilare initrd per assicurarsi che almeno i moduli kernel hv_vmbus e hv_storvsc siano disponibili sul disco RAM iniziale. Questo 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 altre informazioni, vedere Ricompilazione di initramfs.

È ora possibile usare il file del disco rigido virtuale RHEL 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 RHEL, visitare il sito Web di Red Hat.
Per altre informazioni sull'uso di immagini RHEL BYOS pronte per la produzione, consultare la pagina della documentazione per le sottoscrizioni proprie.

Condividi tramite

Preparare una macchina virtuale basata su RedHat per Azure

Console di gestione di Hyper-V

Prerequisiti

Note sull'installazione di RHEL

RHEL 6 tramite la Console di gestione di Hyper-V

RHEL 7 tramite la Console di gestione di Hyper-V

RHEL 8+ tramite 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 è possibile includere il driver Hyper-V nel disco RAM iniziale quando si usa un hypervisor non Hyper-V

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Preparare una macchina virtuale basata su RedHat per Azure

Console di gestione di Hyper-V

Prerequisiti

Note sull'installazione di RHEL

RHEL 6 tramite la Console di gestione di Hyper-V

RHEL 7 tramite la Console di gestione di Hyper-V

RHEL 8+ tramite 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 è possibile includere il driver Hyper-V nel disco RAM iniziale quando si usa un hypervisor non Hyper-V

Contenuto correlato

Commenti e suggerimenti

Commenti e suggerimenti

Risorse aggiuntive