Aprovisionar Fedora CoreOS sobre Azure

Esta guía muestra cómo aprovisionar nodos de Fedora CoreOS (FCOS) nuevos en Azure. Actualmente, Fedora no publica imágenes de Fedora CoreOS en Azure, por lo que debe descargar una imagen de Azure desde Fedora y cargarla en su suscripción de Azure.

FCOS no admite máquinas virtuales Azure Service Manager heredadas.

Prerrequisitos

Antes de aprovisionar una máquina FCOS, debes tener un archivo de configuración Ignition que contenga sus personalizaciones. Si no tienes uno consulta Producción de un Archivo Ignition.

Fedora CoreOS tiene un usuario core predeterminado que puede ser usado para explorar el SO. Si usted desea utilizarlo finalice su configuración proporcionando una clave SSH.

Si no desea usar Ignition para empezar, puede usar Soporte Afterburn.

También necesita tener acceso a una suscripción de Azure. Los ejemplos siguientes utilizan Azure CLI.

Descargar una imagen de Azure

Fedora CoreOS está diseñado para ser actualizado automáticamente con diferentes horarios por transmisión. Una vez que haya elegido la transmisión relevante, descargue, verifique y descomprima la última imagen Azure:

STREAM="stable"
coreos-installer download --decompress -s $STREAM -p azure -f vhd.xz

Alternativamente, puede descargar manualmente una imagen de Azure desde la página de descarga. Verifique la descarga siguiendo las instrucciones de esa página y descomprímala.

Subir la imagen a Azure

Cree cualquier recurso que aún no exista en su cuenta de Azure:

Ejemplo de creación de recursos de Azure

az_region="westus2"
az_resource_group="my-group"
az_storage_account="mystorageacct"
az_container="my-container"
# Crear un grupo de recursos
az group create -l "${az_region}" -n "${az_resource_group}"
# Crear una cuenta de almacenamiento para cargar la imagen FCOS
az storage account create -g "${az_resource_group}" -n "${az_storage_account}"
# Recuperar la cadena de conexión para la cuenta de almacenamiento
cs=$(az storage account show-connection-string -n "${az_storage_account}" -g "${az_resource_group}" | jq -r .connectionString)
# Crear un contenedor de almacenamiento para cargar la imagen FCOS
az storage container create --connection-string "${cs}" -n "${az_container}"

Crear una imagen FCOS:

Ejemplo al crear imagen Azure

downloaded_image_file="./image.vhd"
az_image_name="my-fcos-image"
az_image_blob="${az_image_name}.vhd"
# Subir imagen blob
az storage blob upload --connection-string "${cs}" -c "${az_container}" -f "${downloaded_image_file}" -n "${az_image_blob}"
# Crea la imagen
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
# Eliminar el blob cargado
az storage blob delete --connection-string "$cs" -c "${az_container}" -n "${az_image_blob}"

Lanzar una instancia de Máquina Virtual (MV) utilizando datos adaptados

Inicie una máquina virtual. Puede pasar su configuración de Ignition a la máquina virtual como datos personalizados, o puede omitir el paso de datos personalizados si solo desea acceso SSH. Su clave pública SSH de ~/.ssh se añadirá automáticamente a la máquina virtual. Esto facilita la prueba de FCOS sin crear primero una configuración de Ignition.
Ejemplo de lanzamiento de una imagen de 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})"
```
Ahora serías capaz de acceder por SSH a la instancia usando la dirección IP asociada.
Ejemplo al conectar
```
ssh core@<dirección ip>
```

Lanzamiento de una instancia de máquina virtual mediante datos personalizados y un blob privado de Azure

Defina variables para el nombre de la máquina virtual y las configuraciones de Ignition:

Define tus variables

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

Sube tu archivo ign al almacenamiento de blobs de Azure

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

Crea tu configuración de encendido remoto para hacer referencia a este nuevo blob. Lee más aquí Uso de una configuración de encendido remoto

El campo de origen debe tener un valor similar a https://${az_storage_account}.blob.core.windows.net/${az_image_blob}/${az_blob_ignition_file_name}

Crea una identidad y dale acceso adecuado a tu cuenta de almacenamiento:

az identity create --name "${az_vm_name}-identity" --resource-group "${az_resource_group}"
identity_principal_id=$(az identity show --name "${az_vm_name}-identity" --resource-group "${az_resource_group}" --query principalId -o tsv)
identity_id=$(az identity show --name "${az_vm_name}-identity" --resource-group "${az_resource_group}" --query id -o tsv)

az 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 pasando la nueva identidad

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}"

Lanzamiento de una instancia de VM confidencial

La compatibilidad con Computación Confidencial está en desarrollo en Fedora CoreOS. Consulte issue #1719.

Para iniciar una máquina virtual confidencial, necesitamos crear una imagen que admita la computación confidencial en una Azure Compute Gallery.

Ejemplo de creación de una imagen de galería que admita la computación confidencial

# Crear una galería de imágenes
gallery_name="mygallery"
az sig create --resource-group "${az_resource_group}" --gallery-name "${gallery_name}"

# Crear una definición de imagen de galería
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

# Obtener la URI del VHD de origen del disco del sistema operativo
os_vhd_storage_account=$(az storage account list -g ${az_resource_group} | jq -r .[].id)

#Crear una nueva versión de la imagen
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}

Para iniciar una instancia FCOS confidencial, debe especificar el tipo de cómputo confidencial y utilizar un tipo de máquina que admita el cómputo confidencial.

Desde la línea de comandos, utilice --security-type ConfidentialVM y --size.

Ejemplo de lanzamiento de una instancia de VM confidencial

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

#Especifique un tamaño que admita computación confidencial (usando AMD SEV-SNP, por ejemplo)
vm_size="Standard_DC2as_v5"

# Obtener el ID de la imagen de la galería
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)

# Cree una máquina virtual con computación confidencial habilitada usando la imagen de la galería y una configuración de encendido como datos personalizados
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

Pasamos el parámetro --enable-secure-boot true para habilitar el arranque seguro. Usamos false para deshabilitarlo.

Para obtener el registro completo de la consola, agregue el parámetro --boot-diagnostics-storage ${az_storage_account}.

Ejemplo de Verificación de Arranque de MV Confidencial

ssh core@<ip address>
# Confirme que la máquina virtual esté usando el tipo confidencial `AMD SEV-SNP`
sudo systemd-detect-virt --cvm
sev-snp

# Confirme que la máquina virtual esté usando el tipo confidencial `Intel TDX`
sudo systemd-detect-virt --cvm
tdx

Nota: Otra forma de confirmar es mirar el "Grupo B" y ver que termina con 2 (HV_ISOLATION_TYPE_SNP), o termina con 3 (HV_ISOLATION_TYPE_TDX).

Ejemplo de verificación de arranque de máquina virtual confidencial mediante la comprobación de la bitácora dmesg

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

# Tipo confidencial `Intel TDX`
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 ›