Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Actualización del kernel de Linux en el AL2023 **Topics** + [Versiones del kernel de Linux en el AL2023](#al2023-kernels) + [Actualización del AL2023 a una versión más reciente del núcleo](#kernelup) + [Kernels de AL2023: preguntas frecuentes](#al2023-kernel-faq) ## Versiones del kernel de Linux en el AL2023 El AL2023 incluye regularmente nuevas versiones del núcleo basadas en las versiones Long-Term Support (LTS) del núcleo de Linux. AL2023 se lanzó originalmente en marzo de 2023 con el kernel 6.1. En abril de 2025, AL2023 agregó soporte para el kernel 6.12 de Linux. Este núcleo agregó nuevas funciones, como la programación del EEVDF, el I/O soporte de transferencia de FUSE, una nueva API de Futex y mejoras en el eBPF. El kernel 6.12 también permite que un programa del espacio de usuario se proteja en tiempo de ejecución mediante el uso de columnas ocultas del espacio de usuario y el sellado de memoria. En marzo de 2026, el AL2023 agregó soporte para el kernel 6.18 de Linux. El kernel 6.18 actualizado aporta mejoras adicionales en cuanto a la compatibilidad del procesador, la virtualización, la seguridad y el rendimiento. Entre sus características más destacables se incluyen las capacidades de IOMMU mejoradas en todas las arquitecturas y los controles vectoriales de ataque para gestionar las mitigaciones de vulnerabilidades de la CPU. Las mejoras en el rendimiento se obtienen mediante la optimización de la criptografía, con operaciones FSCRYPT más rápidas, las mejoras en la administración de la memoria y la introducción de Sheaves como una nueva capa de almacenamiento en caché opcional basada en matrices de CPU. ## Actualización del AL2023 a una versión más reciente del núcleo A partir de junio de 2026, AL2023 actualizará el núcleo predeterminado una vez al año. El [`al2023-ami-kernel-default`](ec2.md#launch-via-aws-cli)conjunto de AMI se actualizará a la versión más reciente del núcleo LTS, de modo que las instancias recién lanzadas incorporarán automáticamente la nueva versión del núcleo. Esta es la forma más sencilla de mantenerse al día con las últimas correcciones de seguridad y mejoras de rendimiento. Si prefiere elegir una versión de núcleo específica, puede ejecutar AL2023 con el núcleo 6.12 o 6.18 seleccionando una AMI con el núcleo deseado preinstalado o actualizando una instancia EC2 de AL2023 existente. ### Ejecución de una AMI AL2023 con una versión de núcleo específica Puede optar por ejecutar una AMI del AL2023 con un núcleo específico preinstalado a través de la consola de AWS o consultando SSM para obtener parámetros específicos. Las claves SSM que se van a consultar empiezan por `/aws/service/ami-amazon-linux-latest/`, seguido de una de estas opciones: #### Para el kernel 6.12 + `al2023-ami-kernel-6.12-arm64` para la arquitectura arm64 + `al2023-ami-minimal-kernel-6.12-arm64` para la arquitectura arm64 (AMI mínima) + `al2023-ami-kernel-6.12-x86_64` para la arquitectura x86\_64 + `al2023-ami-minimal-kernel-6.12-x86_64` para la arquitectura x86\_64 (AMI mínima) #### Para el kernel 6.18 + `al2023-ami-kernel-6.18-arm64` para la arquitectura arm64 + `al2023-ami-minimal-kernel-6.18-arm64` para la arquitectura arm64 (AMI mínima) + `al2023-ami-kernel-6.18-x86_64` para la arquitectura x86\_64 + `al2023-ami-minimal-kernel-6.18-x86_64` para la arquitectura x86\_64 (AMI mínima) Consulte [Lanzamiento del AL2023 mediante el parámetro SSM y AWS CLI](ec2.md#launch-via-aws-cli) para obtener más información sobre la selección de las AMI de AL2023. ### Actualización de una instancia AL2023 a un núcleo más nuevo Puede actualizar in situ una instancia AL2023 en ejecución al núcleo 6.12 o 6.18 siguiendo estos pasos: 1. Detecta el núcleo actual y establece la versión de destino: ``` # Automatically detect current kernel version BEFORE upgrade $ CURRENT_KERNEL=$(uname -r) $ SOURCE_VERSION="" $ if [[ $CURRENT_KERNEL == *"6.12"* ]]; then SOURCE_VERSION="6.12" else SOURCE_VERSION="" fi # Save the source version to a persistent location for use after reboot $ echo "${SOURCE_VERSION}" | sudo tee /var/lib/source_kernel_version > /dev/null ``` ``` # Set your target version (change this to your desired kernel: 6.12 or 6.18) $ TARGET_VERSION="6.12" ``` ``` $ echo "Current kernel: ${SOURCE_VERSION:-6.1}" $ echo "Upgrading to kernel ${TARGET_VERSION}" ``` 1. Instale el paquete del núcleo de destino: ``` $ sudo dnf install -y kernel${TARGET_VERSION} ``` 1. Obtenga la última versión del paquete del núcleo de destino: ``` $ version=$(rpm -q --qf '%{version}-%{release}.%{arch}\n' kernel${TARGET_VERSION} | sort -V | tail -1) ``` 1. Convierta el nuevo núcleo en su núcleo predeterminado: ``` $ sudo grubby --set-default "/boot/vmlinuz-$version" ``` 1. Reinicie su sistema: ``` $ sudo reboot ``` 1. Desinstale el núcleo anterior: ``` # Read the source kernel version from the saved file $ SOURCE_VERSION=$(sudo cat /var/lib/source_kernel_version) # Uninstall the source kernel $ sudo dnf remove -y kernel${SOURCE_VERSION} ``` 1. Sustituya los paquetes de núcleo adicionales por sus equivalentes de núcleo de destino: ``` # Set your target version (change this to your desired kernel: 6.12 or 6.18) $ TARGET_VERSION="6.12" ``` ``` $ for pkg in bpftool kernel-debuginfo kernel-debuginfo-common kernel-headers \ kernel-modules-extra-common perf python3-perf; do case "$pkg" in kernel-*) src="kernel${SOURCE_VERSION}${pkg#kernel}" tgt="kernel${TARGET_VERSION}${pkg#kernel}" ;; *) src="${pkg}${SOURCE_VERSION}" tgt="${pkg}${TARGET_VERSION}" ;; esac rpm -q "$src" && sudo dnf -y swap "$src" "$tgt" done # kernel-tools and kernel-tools-devel must be removed and reinstalled # together due to version dependency requirements $ if rpm -q "kernel${SOURCE_VERSION}-tools"; then sudo dnf -y remove kernel${SOURCE_VERSION}-tools kernel${SOURCE_VERSION}-tools-devel sudo dnf -y install kernel${TARGET_VERSION}-tools kernel${TARGET_VERSION}-tools-devel fi ``` 1. (Opcional) Desinstale kernel-devel para la versión anterior del núcleo: ``` $ rpm -q kernel${SOURCE_VERSION}-devel && sudo dnf remove -y kernel${SOURCE_VERSION}-devel ``` ### Bajar a una versión anterior del núcleo Si en algún momento necesita volver a una versión anterior del núcleo, siga los siguientes pasos: 1. Detecte el núcleo actual y establezca la versión de destino: ``` # Automatically detect current kernel version BEFORE downgrade $ CURRENT_KERNEL=$(uname -r) $ SOURCE_VERSION="" $ if [[ $CURRENT_KERNEL == *"6.12"* ]]; then SOURCE_VERSION="6.12" elif [[ $CURRENT_KERNEL == *"6.18"* ]]; then SOURCE_VERSION="6.18" fi # Save the source version to a persistent location for use after reboot $ echo "${SOURCE_VERSION}" | sudo tee /var/lib/source_kernel_version > /dev/null ``` ``` # Set your target version (change this to your desired kernel) # Use "" for kernel 6.1, "6.12" for kernel 6.12 $ TARGET_VERSION="" ``` ``` $ echo "Downgrading from kernel ${SOURCE_VERSION:-6.1} to kernel ${TARGET_VERSION:-6.1}" ``` 1. Sustituya los paquetes adicionales del núcleo por sus equivalentes del núcleo de destino: ``` $ for pkg in bpftool kernel-debuginfo kernel-debuginfo-common kernel-headers \ kernel-modules-extra-common python3-perf; do case "$pkg" in kernel-*) src="kernel${SOURCE_VERSION}${pkg#kernel}" tgt="kernel${TARGET_VERSION}${pkg#kernel}" ;; *) src="${pkg}${SOURCE_VERSION}" tgt="${pkg}${TARGET_VERSION}" ;; esac rpm -q "$src" && sudo dnf -y swap "$src" "$tgt" done # perf requires --allowerasing due to libtraceevent conflicts $ rpm -q "perf${SOURCE_VERSION}" && sudo dnf -y swap "perf${SOURCE_VERSION}" "perf${TARGET_VERSION}" --allowerasing # kernel-tools and kernel-tools-devel must be removed and reinstalled # together due to version dependency requirements $ if rpm -q "kernel${SOURCE_VERSION}-tools"; then sudo dnf -y remove kernel${SOURCE_VERSION}-tools kernel${SOURCE_VERSION}-tools-devel sudo dnf -y install kernel${TARGET_VERSION}-tools kernel${TARGET_VERSION}-tools-devel fi ``` 1. Instale el paquete del núcleo de destino: ``` $ sudo dnf install -y kernel${TARGET_VERSION} ``` 1. Obtenga la última versión del paquete del núcleo de destino: ``` $ version=$(rpm -q --qf '%{version}-%{release}.%{arch}\n' kernel${TARGET_VERSION} | sort -V | tail -1) ``` 1. Haga que el núcleo de destino sea el núcleo predeterminado: ``` $ sudo grubby --set-default "/boot/vmlinuz-$version" ``` 1. Reinicie su sistema: ``` $ sudo reboot ``` 1. Desinstale el núcleo de origen: ``` # Read the source kernel version from the saved file $ SOURCE_VERSION=$(sudo cat /var/lib/source_kernel_version) # Uninstall the source kernel $ sudo dnf remove -y kernel${SOURCE_VERSION} ``` ## Kernels de AL2023: preguntas frecuentes ### 1. ¿Debo reiniciar después de una actualización del kernel? Cada cambio en el kernel en ejecución requiere un reinicio. ### 2. ¿Cómo puedo mantener los kernels actualizados en varias instancias? Amazon Linux no ofrece funciones para administrar flotas de instancias. Le recomendamos que parchee grandes flotas con herramientas como [AWS Systems Manager](https://aws.amazon.com/systems-manager/). ### 3. ¿Cómo compruebo qué versión del kernel estoy ejecutando en este momento? Ejecute este comando en su instancia de AL2023: ``` $ uname -r ``` ### 4. ¿Qué núcleo me recomienda usar en AL2023? Se recomienda actualizar a la versión más reciente del núcleo AL2023 6.18 mientras se sigan admitiendo todos los demás núcleos de AL2023. Se recomienda a los clientes que prueben sus cargas de trabajo antes de realizar la actualización. ### 5. ¿Funcionarán mis aplicaciones actuales con cualquier núcleo AL2023? El AL2023 admite un núcleo más nuevo (6.12 o 6.18) de la misma manera que el kernel 6.1. Las aplicaciones funcionarán y las mejoras se están produciendo de forma clandestina. En cualquier caso, los clientes deberían probar sus cargas de trabajo específicas antes de cambiar a un núcleo más nuevo. ### 6. ¿Cómo instalo los encabezados del núcleo, los paquetes de desarrollo y los módulos adicionales para el núcleo 6.12 o 6.18? Por favor, ejecute: ``` $ version=$(uname -r | grep -oP '^\d+\.\d+') $ sudo dnf install -y kernel${version}-modules-extra-$(uname -r) kernel${version}-headers-$(uname -r) kernel${version}-devel-$(uname -r) ``` ### 7. ¿Durante cuánto tiempo se admitirá la compatibilidad con los núcleos 6.12 y 6.18? Los núcleos 6.12 y 6.18 se admitirán hasta el final previsto de la vida útil de Amazon Linux en 2023, es decir, el 30 de junio de 2029.