Proporcionar Fedora CoreOS en Oracle Cloud Infrastructure (OCI)

Esta guía muestra como aprovisionar nodos de Fedora CoreOS (FCOS) nuevos en Oracle Cloud Infrastructure. Actualmente, las imágenes de Fedora CoreOS no se publican directamente en Oracle Cloud Infrastructure. Por lo tanto, primero debe descargar la imagen de Fedora CoreOS para Oracle Cloud Infrastructure y luego subirla a su cuenta como custom image.

Prerrequisitos

Antes de proporcionar una máquina FCOS, debes tener un archivo de configuración Ignition que contenga sus personalizaciones. Si no tiene uno, consulte Produciendo un Archivo Ignition.

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

Si no desea utilizar Ignition para comenzar, puedes utilizar el Mantenimiento de Afterburn.

Además necesitas tener acceso a una cuenta de Infraestructura de Nube Oracle. El ejemplo debajo utiliza la herramienta oci de línea de comandos y jq como un procesador JSON de línea de comandos.

Esta guía solo cubre actualmente formas de Máquina Virtual y no de Bare Metal. Consulte tema #414 para más detalles.

Descargar una imagen de Infraestructura de Nube Oracle

Fedora CoreOS está diseñado para actualizarse automáticamente, con diferentes planificaciones por flujo. Una vez seleccionado el flujo correspondiente, descargue, verifique y descomprima la imagen más reciente de Oracle Cloud Infrastructure:

ARCH="x86_64"    # o "aarch64"
STREAM="stable"  # o "testing", "next"
coreos-installer download -s $STREAM -a $ARCH -p oraclecloud -f qcow2.xz --decompress

Son admitidas ambas arquitecturas x86_64 y aarch64 en Oracle Cloud Infrastructure.

Alternativamente, puede descargar manualmente una imagen de Oracle Cloud Infraestructure desde la página de descarga.

Subir la imagen a Oracle Cloud Infrastructure

Identificar el ID de su compartimiento raíz.

Listado de compartimentos en su contrato de arrendamiento.

Lista de compartimentos de oci iam
ROOT_COMPARTMENT_ID=<root_compartment_id>

El OCID del compartimento raíz es el mismo que el OCID de su arrendamiento. Puede encontrar esta información en la configuración de la CLI en ~/.oci/config o en Cloud Console.

Si solo tiene un compartimento raíz/inquilino, puede usar el siguiente comando para obtener esa información más fácilmente.

Establezca el id del compartimento raíz en función del primer compartimento de la lista.

ROOT_COMPARTMENT_ID=$(oci iam compartment list |
                      jq --raw-output '.data[0]."compartment-id"')

Crea un compartimento nuevo para pruebas.

COMPARTMENT_ID=$(oci iam compartment create                \
                 --name fedora-coreos-test                 \
                 --compartment-id $ROOT_COMPARTMENT_ID     \
                 --description "Fedora CoreOS compartment" \
                 | jq -r '.data.id')

Crea un depósito de almacenamiento para la subida de imágenes.

BUCKET_NAME="fedora-coreos"
oci os bucket create --compartment-id $COMPARTMENT_ID --name $BUCKET_NAME

Sube la imagen al depósito de almacenamiento.

FCOS_VERSION='...'
IMAGE_NAME="fedora-coreos-${FCOS_VERSION}-oraclecloud.${ARCH}.qcow2"
FILE_PATH="./${IMAGE_NAME}"
oci os object put --bucket-name $BUCKET_NAME --file $FILE_PATH

Consulte el objeto dentro del depósito.

oci os object list -bn $BUCKET_NAME

Importa la imagen como una imagen personalizada y recuerda su ID.

NAMESPACE=$(oci os ns get | jq -r '.data')
IMAGE_ID=$(oci compute image import from-object               \
           --compartment-id $COMPARTMENT_ID                   \
           --namespace $NAMESPACE                             \
           --bucket-name $BUCKET_NAME                         \
           --name $IMAGE_NAME                                 \
           --display-name "Fedora CoreOS $FCOS_VERSION $ARCH" \
           --launch-mode PARAVIRTUALIZED                      \
           --source-image-type QCOW2                          \
           --operating-system "Linux"                         \
           | jq -r '.data.id')

Espere hasta que se complete la importación.

Repetir hasta que la imagen esté disponible.

while true; do
    state=$(oci compute image get --image-id $IMAGE_ID |
            jq -r '.data."lifecycle-state"')
    echo "$(date): $state"
    [ "$state" == "AVAILABLE" ] && break || sleep 30
done

La imagen debe configurarse para que la plataforma sepa de qué es capaz. Aquí, extraeremos el conjunto de capacidades predeterminado de la versión 1.2 y configuraremos algunas adicionales. Tenga en cuenta que algunas son específicas de la arquitectura, pero conviene, ya que también deben habilitarse en tiempo de ejecución.

Configurar capacidades de imagen adicionales.

GLOBAL_CAP_ID=$(
    oci compute global-image-capability-schema list --all | jq -r '.data[0].id')
GLOBAL_CAP_VERSION_NAME=$(
    oci compute global-image-capability-schema-version list --all \
    --global-image-capability-schema-id $GLOBAL_CAP_ID            \
    --display-name 1.2 | jq -r '.data[0].name')

oci compute image-capability-schema create \
    --global-image-capability-schema-version-name $GLOBAL_CAP_VERSION_NAME \
    --compartment-id $COMPARTMENT_ID --image-id $IMAGE_ID --schema-data '{
    "Compute.AMD_SecureEncryptedVirtualization": {
        "default-value": true,
        "descriptor-type": "boolean",
        "source": "IMAGE"
    },
    "Compute.SecureBoot": {
        "default-value": true,
        "descriptor-type": "boolean",
        "source": "IMAGE"
    },
    "Storage.Iscsi.MultipathDeviceSupported": {
        "default-value": true,
        "descriptor-type": "boolean",
        "source": "IMAGE"
    }
}'

Ahora podemos marcar la imagen como compatible con la MV de formas apropiadas.

Eliminar formas compatibles predeterminadas.

oci compute image-shape-compatibility-entry \
    list --image-id $IMAGE_ID | jq -r '.data[].shape' |
while read shape; do
    [[ "$shape" =~ Generic ]] && continue # No puede quitar formas genéricas
    echo "Quitar $shape desde $IMAGE_ID"
    oci compute image-shape-compatibility-entry remove \
        --force --image-id $IMAGE_ID --shape-name "${shape}"
done

Marcar como compatible con las formas de las MV adecuadas.

shapes_info=$(oci compute shape list --compartment-id $COMPARTMENT_ID | jq -r '.data[]')

# Limitar a formas de MV exclusivamente
# https://github.com/coreos/fedora-coreos-tracker/issues/414#issuecomment-1795808614
vm_shapes_info=$(jq -r 'select(.shape | select(startswith("VM")))' <<< "$shapes_info")

# Determine formas  x86_64 y aarch64
amd64_shape_ids=$(jq -r 'select(."processor-description"  |
                                contains("AMD", "Intel")) |
                                .shape' <<< "$vm_shapes_info")
arm64_shape_ids=$(jq -r 'select(."processor-description" |
                                contains("Ampere"))      |
                                .shape' <<< "$vm_shapes_info")

# Aplica las formas apropiadas a la imagen IMAGE
[ "$ARCH" == "x86_64" ] && shape_ids="$amd64_shape_ids"
[ "$ARCH" == "aarch64" ] && shape_ids="$arm64_shape_ids"
for shape in $shape_ids; do
    oci compute image-shape-compatibility-entry add \
        --image-id $IMAGE_ID --shape-name "${shape}"
done

Listado de todas las formas compatibles para una imagen.

oci compute image-shape-compatibility-entry list --image-id $IMAGE_ID | jq -r '.data[].shape'

Lanzar una instancia

Cree un Red de Nube Virtual.

NETWORK_ID=$(oci network vcn create        \
    --compartment-id $COMPARTMENT_ID       \
    --display-name "fedora-coreos-network" \
    --cidr-blocks '["10.0.0.0/16"]'        \
    --dns-label "mifcos"                   \
    --wait-for-state AVAILABLE | jq -r '.data.id')

Cree una Subred.

SUBNET_ID=$(oci network subnet create     \
    --compartment-id $COMPARTMENT_ID      \
    --display-name "fedora-coreos-subnet" \
    --cidr-block "10.0.0.0/24"            \
    --vcn-id $NETWORK_ID                  \
    --dns-label "subred1"                 \
    --wait-for-state AVAILABLE | jq -r '.data.id')

Cree una Puerta de enlace a Internet.

GATEWAY_ID=$(oci network internet-gateway create \
    --compartment-id $COMPARTMENT_ID             \
    --display-name "fedora-coreos-gateway"       \
    --vcn-id $NETWORK_ID                         \
    --is-enabled true | jq -r '.data.id')

Añada una Regla para la Tabla de Ruta.

ROUTE_TABLE_ID=$(oci network route-table list \
    --compartment-id $COMPARTMENT_ID          \
    --vcn-id $NETWORK_ID | jq -r '.data[0].id')

oci network route-table update \
    --rt-id $ROUTE_TABLE_ID    \
    --force --route-rules      \
    '[{"cidrBlock":"0.0.0.0/0","networkEntityId":"'"${GATEWAY_ID}"'"}]'

Ahora puede elegir un dominio disponible o tan solo póngalo para ser el primero en la región.

Tomar un dominio disponible.

AVAILABILITY_DOMAIN=$(oci iam availability-domain list | jq -r '.data[0].name')

Vea todos los dominios posibles con oci iam availability-domain list.

Ahora puede lanzar una instancia. Si tan solo desea acceso por SSH puede omitir la proporcionar una configuración de Ignition para la instancia.

Lanzar una instancia sin una configuración de Ignition.

NAME=fedora-coreos
SHAPE=VM.Standard.E5.Flex # or VM.Standard.A1.Flex for aarch64
SSHKEYS="/ruta/para/authorized_keys" # ruta para el archivo authorized_keys

INSTANCE_ID=$(oci compute instance launch               \
    --compartment-id $COMPARTMENT_ID                    \
    --availability-domain $AVAILABILITY_DOMAIN          \
    --display-name $NAME                                \
    --image-id $IMAGE_ID                                \
    --shape $SHAPE                                      \
    --shape-config '{"ocpus": '2', "memoryInGBs": '4'}' \
    --subnet-id $SUBNET_ID                              \
    --assign-public-ip true                             \
    --ssh-authorized-keys-file $SSHKEYS                 \
    --wait-for-state TERMINATED                         \
    --wait-for-state RUNNING | jq -r '.data.id')

La forma VM.Standard.E2.1.Micro, que cumple con los requisitos de nivel gratuito, tiene menos memoria que la recomendada para ejecutar Fedora CoreOS. Para una instancia que cumple con los requisitos de nivel gratuito, se recomienda usar la forma VM.Standard.A1.Flex basada en ARM.

Lanzamiento de una instancia con personalizaciones y una configuración de Ignition.

NAME=fedora-coreos
SHAPE=VM.Standard.E5.Flex      # o VM.Standard.A1.Flex for aarch64
DISK=50                        # tamaño del volumen de arranque en GBs
OCPUS=2                        # número de las OCPU asignadas
MEMORY=4                       # tamaño de memoria en GB
INSTANCE_HOSTNAME=mycoreos     # nombre de host para la instancia
USERDATA="/ruta/para/config.ign" # ruta para su config de Ignition
                               # que establece una llave ssh

INSTANCE_ID=$(oci compute instance launch               \
    --compartment-id $COMPARTMENT_ID                    \
    --availability-domain $AVAILABILITY_DOMAIN          \
    --display-name $NAME                                \
    --image-id $IMAGE_ID                                \
    --shape $SHAPE                                      \
    --shape-config                                      \
    '{"ocpus": '${OCPUS}', "memoryInGBs": '${MEMORY}'}' \
    --subnet-id $SUBNET_ID                              \
    --assign-public-ip true                             \
    --hostname-label $INSTANCE_HOSTNAME                 \
    --boot-volume-size-in-gbs $DISK                     \
    --user-data-file $USERDATA                          \
    --wait-for-state TERMINATED                         \
    --wait-for-state RUNNING | jq -r '.data.id')

Aunque la documentación de Oracle Cloud Infrastructure menciona cloud-init, Fedora CoreOS no es compatible con cloud-init. Solo acepta archivos de configuración de Ignition. Al usar la Consola Nube, se puede colocar una configuración de Ignition en el campo "Script de Cloud-init".

Para habilitar SecureBoot, puede pasar una configuración adicional a través de --platform-config '{"type": "AMD_VM", "isSecureBootEnabled": true}' o --platform-config '{"type": "INTEL_VM", "isSecureBootEnabled": true}' o dependiendo del tipo de procesador de su instancia. Actualmente, no es posible habilitar Secureboot en instancias ARM.

Obtener la dirección IP pública de la instancia.

PUBLIC_IP=$(oci compute instance list-vnics --instance-id $INSTANCE_ID |
            jq -r '.data[0]."public-ip"')
echo "La instancia de la UPv4 pública es: $PUBLIC_IP"

Ahora serías capaz de acceder por SSH a la instancia usando la dirección IP asociada.

Acceda por SSH a la instancia en ejecución.

ssh "core@${PUBLIC_IP}"

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