Fornitura di Fedora CoreOS su Azure

Questa guida mostra come fornire nuovi nodi Fedora CoreOS (FCOS) su Azure. Attualmente, Fedora non pubblica immagini Fedora CoreOS all’interno di Azure, quindi devi scaricare un’immagine Azure da Fedora e caricarla nel tuo abbonamento Azure.

FCOS non supporta le macchine virtuali legacy di [Azure Service Manager](https://learn.microsoft.com/en-us/azure/virtual-machines/classic-vm-deprecation).

Prerequisiti

Fedora CoreOS supports configuring access via SSH keys using Afterburn on this platform. Once you have configured your SSH Key in the platform configuration, you can provision and access Fedora CoreOS instances with the default user core, without using an Ignition config.

We recommend using an Ignition config once you are more familiar with Fedora CoreOS and want to automate the deployment of systems.

You need to have access to an Azure subscription. The examples below use the Azure CLI.

Scaricando un’immagine Hetzner

Fedora CoreOS è progettato per aggiornarsi automaticamente, con programmi differenti a seconda dello stream. Una volta scelto lo stream rilevante, scarica, verifica e decomprimi l’ultima immagine per Oracle Cloud Infrastructure:

FLUSSO="stabile"
coreos-installer download --decompress -s $FLUSSO -p openstack -f qcow2.xz

In alternativa, puoi scaricare manualmente un’immagine di Azure dalla [pagina di download](https://fedoraproject.org/coreos/download/?stream=stable#cloud_images). Verifica il download seguendo le istruzioni su quella pagina e decomprimilo.

Caricamento dell’immagine su Azure

Crea tutte le risorse non ancora presenti nel tuo account Azure:

Esempio di creazione delle risorse Azure

az_region="westus2"
az_resource_group="my-group"
az_storage_account="mystorageacct"
az_container="my-container"
# Crea il gruppo di risorse
az group create -l "${az_region}" -n "${az_resource_group}"
# Crea l'account di archiviazione per caricare l'immagine FCOS
az storage account create -g "${az_resource_group}" -n "${az_storage_account}"
# Recupera la stringa di connessione per l'account di archiviazione
cs=$(az storage account show-connection-string -n "${az_storage_account}" -g "${az_resource_group}" | jq -r .connectionString)
# Crea il contenitore di archiviazione per caricare l'immagine FCOS
az storage container create --connection-string "${cs}" -n "${az_container}"

Crea un’immagine FCOS:

Esempio di creazione dell’immagine Azure

downloaded_image_file="./image.vhd"
az_image_name="my-fcos-image"
az_image_blob="${az_image_name}.vhd"
# Carica il blob dell'immagine
az storage blob upload --connection-string "${cs}" -c "${az_container}" -f "${downloaded_image_file}" -n "${az_image_blob}"
# Crea l'immagine
az image create -n "${az_image_name}" -g "${az_resource_group}" --source "https://${az_storage_account}.blob.core.windows.net/${az_container}/${az_image_blob}" --location "${az_region}" --os-type Linux
# Elimina il blob caricato
az storage blob delete --connection-string "$cs" -c "${az_container}" -n "${az_image_blob}"

Avvio di un’istanza VM (Macchina Virtuale) tramite custom-data

Avvia un server. La tua configurazione Ignition può essere passata alla VM come i suoi user data, oppure puoi saltare il passaggio degli user data se vuoi solo l’accesso SSH. Questo fornisce un modo semplice per testare FCOS senza dover prima creare una configurazione Ignition.
Esempio di avvio dell’immagine Azure
```
az_vm_name="my-fcos-vm"
ignition_path="./config.ign"
az vm create -n "${az_vm_name}" -g "${az_resource_group}" --image "${az_image_name}" --admin-username core --custom-data "$(cat ${ignition_path})"
```
Ora dovresti poter effettuare l’accesso SSH all’istanza utilizzando l’indirizzo IP associato.
Esempio di connessione
```
ssh core@<indirizzo ip>
```

Avvio di un’istanza VM (Macchina Virtuale) tramite custom-data e un blob di Azure privato

Definisci le variabili per il nome della VM e le configurazioni di Ignition:

Definisci le tue variabili

az_vm_name=my-fcos-vm
ignition_path="./config.ign"
az_blob_ignition_path=./privateConfig.ign
az_blob_ignition_file_name=privateConfig.ign

Carica il tuo file .ign (Ignition) nell’archiviazione blob di Azure

az storage blob upload --connection-string "${cs}" -c "${az_blob_ignition_file_name}" -f  "${az_blob_ignition_path}" -n "${ignition_file_name}"

Crea la tua configurazione remota di Ignition per fare riferimento a questo nuovo blob. Maggiori informazioni sono disponibili qui Utilizzo di una configurazione Ignition remota

Il campo source dovrebbe avere un valore simile a https://${az_storage_account}.blob.core.windows.net/${az_image_blob}/${az_blob_ignition_file_name}

Crea un’identità e assegnale il corretto accesso al tuo account di archiviazione:

# Crea un'identità gestita assegnata dall'utente
az identity create --name "${az_vm_name}-identity" --resource-group "${az_resource_group}"
# Recupera l'ID entità (Principal ID) dell'identità appena creata
identity_principal_id=$(az identity show --name "${az_vm_name}-identity" --resource-group "${az_resource_group}" --query principalId -o tsv)
# Recupera l'ID risorsa (Resource ID) completo dell'identità
identity_id=$(az identity show --name "${az_vm_name}-identity" --resource-group "${az_resource_group}" --query id -o tsv)

# Assegna il ruolo "Storage Blob Data Contributor" all'identità gestita per l'account di archiviazione specificoaz role assignment create --assignee "${identity_principal_id}" --role "Storage Blob Data Contributor" --scope /subscriptions/${subscription_id}/resourceGroups/${az_resource_group}/providers/Microsoft.Storage/storageAccounts/${az_storage_account}

Crea la VM passando la nuova identità

az vm create -n "${az_vm_name}" -g "${az_resource_group}" --image "${az_image_name}" --admin-username core --custom-data "$(cat ${ignition_path})" --assign-identity "${identity_id}"

Lancio di un’istanza VM riservata Confidential VM

Il supporto per il Confidential Computing è in fase di sviluppo in Fedora CoreOS. Vedi l’issue #1719.

For an overview about confidential VMs on Azure see confidential VM overview.

To launch a confidential VM, we need to create an image that supports confidential computing in an Azure Compute Gallery.

Example creating a gallery image that supports confidential computing

# Create an image gallery
gallery_name="mygallery"
az sig create --resource-group "${az_resource_group}" --gallery-name "${gallery_name}"

# Create a gallery image definition
gallery_image_definition="mygallery-def"
az sig image-definition create \
    --resource-group "${az_resource_group}" \
    --gallery-name "${gallery_name}" \
    --gallery-image-definition "${gallery_image_definition}" \
    --publisher azure \
    --offer example \
    --sku standard \
    --features SecurityType=ConfidentialVmSupported \
    --os-type Linux \
    --hyper-v-generation V2

# Get the source VHD URI of OS disk
os_vhd_storage_account=$(az storage account list -g ${az_resource_group} | jq -r .[].id)

# Create a new image version
gallery_image_version="1.0.0"
az sig image-version create \
    --resource-group "${az_resource_group}" \
    --gallery-name "${gallery_name}" \
    --gallery-image-definition "${gallery_image_definition}" \
    --gallery-image-version "${gallery_image_version}" \
    --os-vhd-storage-account "${os_vhd_storage_account}" \
    --os-vhd-uri https://${az_storage_account}.blob.core.windows.net/${az_container}/${az_image_blob}

To launch a confidential FCOS instance, you need to specify the confidential compute type and use a machine type that supports confidential computing.

From the command-line, use --security-type ConfidentialVM and --size.

Example launching a Confidential VM instance

vm_name="my-fcos-cvm"
ignition_path="./config.ign"

# Specify a size that supports confidential computing (using AMD SEV-SNP for example)
vm_size="Standard_DC2as_v5"

# Get gallery image id
gallery_image_id=$(az sig image-version show --gallery-image-definition "${gallery_image_definition}" --gallery-image-version "${gallery_image_version}" --gallery-name "${gallery_name}" --resource-group $az_resource_group | jq -r .id)

# Create a VM with confidential computing enabled using the gallery image and an ignition config as custom-data
az vm create \
    --name "${vm_name}" \
    --resource-group $az_resource_group \
    --size "${vm_size}" \
    --image "${gallery_image_id}" \
    --admin-username core \
    --generate-ssh-keys \
    --custom-data "$(cat ${ignition_path})" \
    --enable-vtpm true \
    --public-ip-sku Standard \
    --security-type ConfidentialVM \
    --os-disk-security-encryption-type VMGuestStateOnly \
    --enable-secure-boot true

We pass parameter --enable-secure-boot true to enable Secure Boot. Use false to disable secure boot.

To get the full console log, append the parameter --boot-diagnostics-storage ${az_storage_account}.

Esempio di verifica dell’avvio di una VM riservata

ssh core@<ip address>
# Conferma che la VM stia utilizzando il tipo riservato `AMD SEV-SNP`
sudo systemd-detect-virt --cvm
sev-snp

# Confirm the VM is using `Intel TDX` confidential type
sudo systemd-detect-virt --cvm
tdx

Note: Another way to confirm is looking at "Group B" and see that it ends with 2 (HV_ISOLATION_TYPE_SNP), or ends with 3 (HV_ISOLATION_TYPE_TDX).

Example Confidential VM Boot Verification by checking dmesg log

# `AMD SEV-SNP` confidential type
dmesg | grep "Hyper-V: Isolation Config"
[    0.000000] Hyper-V: Isolation Config: Group A 0x1, Group B 0xba2

# `Intel TDX` confidential type
dmesg | grep "Hyper-V: Isolation Config"
[    0.000000] Hyper-V: Isolation Config: Group A 0x1, Group B 0xbe3

Want to help? Learn how to contribute to Fedora Docs ›