As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Atualizando o kernel Linux no AL2023 **Topics** + [Versões do kernel Linux no AL2023](#al2023-kernels) + [Atualizando o AL2023 para uma versão mais recente do kernel](#kernelup) + [Kernels do AL2023: perguntas frequentes](#al2023-kernel-faq) ## Versões do kernel Linux no AL2023 O AL2023 inclui regularmente novas versões do kernel com base nas versões Long-Term Support (LTS) do kernel Linux. O AL2023 foi lançado originalmente em março de 2023 com o kernel 6.1. Em abril de 2025, o AL2023 adicionou suporte ao kernel do Linux 6.12. Esse kernel adicionou novos recursos, incluindo agendamento EEVDF, I/O suporte à passagem do FUSE, uma nova API Futex e melhorias no eBPF. O kernel 6.12 também permite que um programa de espaço de usuário se proteja no runtime usando pilhas de sombras do espaço de usuário e vedação de memória. Em março de 2026, o AL2023 adicionou suporte para o kernel Linux 6.18. O kernel 6.18 atualizado traz melhorias adicionais no suporte, virtualização, segurança e desempenho do processador. Os recursos notáveis incluem recursos aprimorados de IOMMU em todas as arquiteturas e controles vetoriais de ataque para gerenciar as mitigações de vulnerabilidades da CPU. Os aprimoramentos de desempenho vêm por meio de otimizações de criptografia com operações mais rápidas do FSCRYPT, melhorias no gerenciamento de memória e a introdução do Sheaves como uma nova camada de cache opcional baseada em array por CPU. ## Atualizando o AL2023 para uma versão mais recente do kernel A partir de junho de 2026, o AL2023 atualizará o kernel padrão anualmente. O [`al2023-ami-kernel-default`](ec2.md#launch-via-aws-cli)conjunto de AMIs será atualizado para o kernel LTS mais recente, para que as instâncias recém-lançadas criem automaticamente a nova versão do kernel. Essa é a maneira mais simples de se manter atualizado com as últimas correções de segurança e melhorias de desempenho. Se preferir escolher uma versão específica do kernel, você pode executar o AL2023 com o kernel 6.12 ou 6.18 selecionando uma AMI com o kernel desejado pré-instalado ou atualizando uma instância EC2 existente do AL2023. ### Executando uma AMI AL2023 com uma versão específica do kernel Você pode optar por executar uma AMI AL2023 com um kernel específico pré-instalado por meio do AWS Console ou consultando o SSM para parâmetros específicos. As chaves do SSM para consulta começam com `/aws/service/ami-amazon-linux-latest/` seguido por um dos seguintes: #### Para o kernel 6.12 + `al2023-ami-kernel-6.12-arm64` para a arquitetura arm64 + `al2023-ami-minimal-kernel-6.12-arm64` para arquitetura arm64 (AMI mínima) + `al2023-ami-kernel-6.12-x86_64` para a arquitetura x86\_64 + `al2023-ami-minimal-kernel-6.12-x86_64` para a arquitetura x86\_64 (AMI mínima) #### Para o kernel 6.18 + `al2023-ami-kernel-6.18-arm64` para a arquitetura arm64 + `al2023-ami-minimal-kernel-6.18-arm64` para arquitetura arm64 (AMI mínima) + `al2023-ami-kernel-6.18-x86_64` para a arquitetura x86\_64 + `al2023-ami-minimal-kernel-6.18-x86_64` para a arquitetura x86\_64 (AMI mínima) Consulte [Lançamento do AL2023 usando o parâmetro SSM e AWS CLI](ec2.md#launch-via-aws-cli) para obter detalhes sobre a seleção de AMIs do AL2023. ### Atualização de uma instância do AL2023 para um kernel mais novo Você pode atualizar localmente uma instância do AL2023 em execução para o kernel 6.12 ou 6.18 com as seguintes etapas: 1. Detecte o kernel atual e defina a versão 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 o pacote do kernel de destino: ``` $ sudo dnf install -y kernel${TARGET_VERSION} ``` 1. Obtenha a versão mais recente do pacote do kernel de destino: ``` $ version=$(rpm -q --qf '%{version}-%{release}.%{arch}\n' kernel${TARGET_VERSION} | sort -V | tail -1) ``` 1. Torne o novo kernel seu kernel padrão: ``` $ sudo grubby --set-default "/boot/vmlinuz-$version" ``` 1. Reinicialize o sistema: ``` $ sudo reboot ``` 1. Desinstale o kernel 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. Substitua pacotes extras de kernel por seus equivalentes de kernel 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 o kernel-devel da versão anterior do kernel: ``` $ rpm -q kernel${SOURCE_VERSION}-devel && sudo dnf remove -y kernel${SOURCE_VERSION}-devel ``` ### Fazendo o downgrade para uma versão anterior do kernel Se, em algum momento, você precisar fazer o downgrade para uma versão anterior do kernel, use as seguintes etapas: 1. Detecte o kernel atual e defina a versão 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. Substitua pacotes extras de kernel por seus equivalentes de kernel 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 o pacote do kernel de destino: ``` $ sudo dnf install -y kernel${TARGET_VERSION} ``` 1. Obtenha a versão mais recente do pacote do kernel de destino: ``` $ version=$(rpm -q --qf '%{version}-%{release}.%{arch}\n' kernel${TARGET_VERSION} | sort -V | tail -1) ``` 1. Torne o kernel de destino seu kernel padrão: ``` $ sudo grubby --set-default "/boot/vmlinuz-$version" ``` 1. Reinicialize o sistema: ``` $ sudo reboot ``` 1. Desinstale o kernel de origem: ``` # 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 do AL2023: perguntas frequentes ### 1. Preciso reinicializar após uma atualização do kernel? Toda alteração no kernel em execução requer uma reinicialização. ### 2. Como faço para manter os kernels atualizados em várias instâncias? O Amazon Linux não fornece recursos para gerenciar frotas de instâncias. Recomendamos que você aplique patches em grandes frotas usando ferramentas como o [AWS Systems Manager](https://aws.amazon.com/systems-manager/). ### 3. Como faço para verificar qual versão do kernel está em execução no momento? Execute este comando na sua instância do AL2023: ``` $ uname -r ``` ### 4. Qual kernel o AL2023 recomenda que eu use? É recomendável atualizar para o kernel 6.18 mais recente do AL2023, enquanto todos os outros kernels do AL2023 ainda são suportados. Recomenda-se que os clientes testem suas cargas de trabalho antes da atualização. ### 5. Meus aplicativos existentes funcionarão com qualquer kernel do AL2023? O AL2023 suporta um kernel mais novo (6.12 ou 6.18) da mesma forma que o kernel 6.1. Os aplicativos funcionarão e as melhorias estão acontecendo nos bastidores. Em qualquer caso, os clientes devem testar suas cargas de trabalho específicas antes de migrar para um kernel mais novo. ### 6. Como faço para instalar cabeçalhos do kernel, pacotes de desenvolvimento e módulos extras para o kernel 6.12 ou 6.18? Execute o seguinte: ``` $ 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. Por quanto tempo os kernels 6.12 e 6.18 serão suportados? Os kernel 6.12 e 6.18 terão suporte até o final planejado da vida útil do Amazon Linux 2023, que é 30/06/2029.