Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Comportement au lancement de l’instance en fonction des modes de démarrage Amazon EC2
Lorsqu’un ordinateur démarre, le premier logiciel qu’il exécute est responsable d’initialiser la plateforme et de fournir une interface permettant au système d’exploitation d’effectuer des opérations spécifiques à la plateforme.
Dans Amazon EC2, deux variantes du logiciel de mode de démarrage sont prises en charge : l’interface UEFI (Unified Extensible Firmware Interface) et le BIOS hérité.
**Paramètres de mode de démarrage possible sur une AMI**
Une AMI peut avoir l’une des valeurs de paramètre de mode de démarrage suivantes : `uefi`, `legacy-bios` ou `uefi-preferred`. Le paramètre de mode d’amorçage de l’AMI est facultatif. En l'absence AMIs de paramètre de mode de démarrage, les instances lancées à partir de ces derniers AMIs utilisent la valeur du mode de démarrage par défaut du type d'instance.
**Objectif du paramètre de mode d’amorçage de l’AMI**
Le paramètre de mode de démarrage de l’AMI signale à Amazon EC2 le mode de démarrage à utiliser lors du lancement d’une instance. Lorsque le paramètre de mode de démarrage est défini sur `uefi`, EC2 tente de lancer l’instance sur l’UEFI. Si le système d’exploitation n’est pas configuré pour prendre en charge l’UEFI, le lancement de l’instance échoue.
**Paramètre de mode de démarrage d’UEFI préféré**
Vous pouvez créer un système AMIs qui supporte à la fois l'UEFI et le BIOS Legacy en utilisant le paramètre de mode de `uefi-preferred` démarrage. Lorsque le paramètre de mode de démarrage est défini sur `uefi-preferred` et si le type d’instance prend en charge l’UEFI, l’instance est lancée sur l’UEFI. Si le type d’instance ne prend pas en charge l’UEFI, l’instance est lancée sur le BIOS hérité.
**Avertissement**
Certaines fonctionnalités, comme UEFI Secure Boot, ne sont disponibles que sur les instances qui démarrent sur l’UEFI. Lorsque vous utilisez le paramètre de mode de démarrage d’AMI `uefi-preferred` avec un type d’instance qui ne prend pas en charge l’UEFI, l’instance est lancée en tant que BIOS hérité et la fonctionnalité dépendante de l’UEFI est désactivée. Si vous vous appuyez sur la disponibilité d’une fonctionnalité dépendante de l’UEFI, définissez le paramètre du mode de démarrage de votre AMI sur `uefi`.
**Modes de démarrage par défaut pour les types d’instance**
+ Types d’instances Graviton : UEFI
+ Types d’instances Intel et AMD : BIOS hérité
**Soutien à la zone**
Le démarrage UEFI n’est pas pris en charge dans les zones Wavelength.
**Topics**
+ [Conditions requises pour lancer une instance EC2 en mode de démarrage UEFI](launch-instance-boot-mode.md)
+ [Déterminer le paramètre du mode de démarrage d’une AMI Amazon EC2](ami-boot-mode.md)
+ [Déterminer les modes de démarrage pris en charge par un type d’instance EC2](instance-type-boot-mode.md)
+ [Déterminer le mode de démarrage d’une instance EC2](instance-boot-mode.md)
+ [Déterminer le mode de démarrage du système d’exploitation de votre instance EC2](os-boot-mode.md)
+ [Définir le mode de démarrage d’une AMI Amazon EC2](set-ami-boot-mode.md)
+ [Variables UEFI pour les instances Amazon EC2](uefi-variables.md)
+ [Démarrage sécurisé de l’UEFI pour les instances Amazon EC2](uefi-secure-boot.md)
# Conditions requises pour lancer une instance EC2 en mode de démarrage UEFI
Le mode de démarrage d’une instance est déterminé par la configuration de l’AMI, le système d’exploitation qu’elle contient et le type d’instance. Pour lancer une instance en mode de démarrage UEFI, vous devez satisfaire aux exigences suivantes.
**AMI**
L’AMI doit être configurée pour l’UEFI comme suit :
+ **Système d’exploitation** : le système d’exploitation contenu dans l’AMI doit être configuré pour utiliser UEFI sinon, le lancement de l’instance échouera. Pour de plus amples informations, veuillez consulter [Déterminer le mode de démarrage du système d’exploitation de votre instance EC2](os-boot-mode.md).
+ **Paramètre du mode de démarrage de l’AMI** : le paramètre de mode de démarrage de l’AMI doit être défini sur `uefi` ou `uefi-preferred`. Pour de plus amples informations, veuillez consulter [Déterminer le paramètre du mode de démarrage d’une AMI Amazon EC2](ami-boot-mode.md).
**Linux** — Les systèmes Linux suivants AMIs prennent en charge l'UEFI :
+ Amazon Linux 2023
+ Amazon Linux 2 (types d’instances de Graviton uniquement)
Pour les autres systèmes Linux AMIs, vous devez [configurer l'AMI](set-ami-boot-mode.md), importer l'AMI via [VM Import/Export](https://docs.aws.amazon.com/vm-import/latest/userguide/) ou importer l'AMI via. [CloudEndure](https://docs.cloudendure.com/)
**Windows** : les systèmes Windows suivants AMIs prennent en charge l'UEFI :
+ Windows\$1Server-2025-\$1 (sauf avec le préfixe de nom) AMIs `BIOS-`
+ TPM-Windows\$1Server-2022-English-Full-Base
+ TPM-Windows\$1Server-2022-English-Core-Base
+ TPM-Windows\$1Server-2019-English-Full-Base
+ TPM-Windows\$1Server-2019-English-Core-Base
+ TPM-Windows\$1Server-2016-English-Full-Base
+ TPM-Windows\$1Server-2016-English-Core-Base
**Type d’instance**
Toutes les instances basées sur le système AWS Nitro sont compatibles avec UEFI et Legacy BIOS, à l'exception des suivantes : instances bare metal, G4ad, P4, u-3tb1, u-6tb1 DL1, u-9tb1, u-9tb1, u-12tb1, u-18tb1, u-24tb1 et. VT1 Pour de plus amples informations, veuillez consulter [Déterminer les modes de démarrage pris en charge par un type d’instance EC2](instance-type-boot-mode.md).
Le tableau suivant montre que le mode de démarrage d’une instance (indiqué par la colonne **Mode de démarrage de l’instance résultante**) est déterminé par une combinaison du paramètre de mode de démarrage de l’AMI (colonne 1), de la configuration du mode de démarrage du système d’exploitation contenu dans l’AMI (colonne 2) et de la prise en charge du mode de démarrage du type d’instance (colonne 3).
| Paramètre de mode de démarrage AMI | Configuration du mode de démarrage du système d’exploitation | Prise en charge du mode de démarrage du type d’instance | Mode de démarrage de l’instance résultante |
| --- | --- | --- | --- |
| UEFI | UEFI | UEFI | UEFI |
| BIOS hérité | BIOS hérité | BIOS hérité | BIOS hérité |
| UEFI préférée | UEFI | UEFI | UEFI |
| UEFI préférée | UEFI | UEFI et BIOS hérité | UEFI |
| UEFI préférée | BIOS hérité | BIOS hérité | BIOS hérité |
| UEFI préférée | BIOS hérité | UEFI et BIOS hérité | BIOS hérité |
| Aucun mode de démarrage spécifié – ARM | UEFI | UEFI | UEFI |
| Aucun mode de démarrage spécifié – x86 | BIOS hérité | UEFI et BIOS hérité | BIOS hérité |
# Déterminer le paramètre du mode de démarrage d’une AMI Amazon EC2
Le paramètre de mode d’amorçage de l’AMI est facultatif. Une AMI peut avoir l’une des valeurs de paramètre de mode de démarrage suivantes : `uefi`, `legacy-bios` ou `uefi-preferred`.
Certains AMIs n'ont pas de paramètre de mode de démarrage. Lorsqu’une AMI n’a pas de paramètre de mode de démarrage, les instances lancées à partir de l’AMI utilisent la valeur par défaut du type d’instance, qui est `uefi` sur Graviton et `legacy-bios` sur les types d’instance Intel et AMD.
------
#### [ Console ]
**Pour déterminer le paramètre de mode de démarrage d’une AMI**
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le volet de navigation **AMIs**, choisissez, puis sélectionnez l'AMI.
1. Vérifiez le champ **Mode de démarrage**.
+ Une valeur **uefi** indique que l’AMI prend en charge UEFI.
+ Une valeur **uefi-preferred** indique que l’AMI prend en charge l’UEFI et le BIOS hérité.
+ S’il n’existe aucune valeur, les instances lancées à partir de l’AMI utilisent la valeur par défaut du type d’instance.
**Pour déterminer le paramètre de mode de démarrage d’une AMI au lancement d’une instance**
Lors du lancement d’une instance à l’aide de l’assistant de lancement d’instance, à l’étape de sélection d’une AMI, vérifiez le champ **Mode de démarrage**. Pour de plus amples informations, veuillez consulter [Images d’applications et de systèmes d’exploitation (Amazon Machine Image)](ec2-instance-launch-parameters.md#liw-ami).
------
#### [ AWS CLI ]
**Pour déterminer le paramètre de mode de démarrage d’une AMI**
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html) pour déterminer le mode de démarrage d'une AMI.
```
aws ec2 describe-images \
--region us-east-1 \
--image-id ami-0abcdef1234567890 \
--query Images[].BootMode \
--output text
```
Voici un exemple de sortie.
```
uefi
```
Dans la sortie, une valeur `uefi` indique que l’AMI prend en charge l’UEFI. Une valeur de `uefi-preferred` indique que l’AMI prend en charge l’UEFI et le BIOS hérité. S’il n’existe aucune valeur, les instances lancées à partir de l’AMI utilisent la valeur par défaut du type d’instance.
------
#### [ PowerShell ]
**Pour déterminer le paramètre de mode de démarrage d’une AMI**
Utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html) pour déterminer le mode de démarrage d’une AMI.
```
Get-EC2Image -Region us-east-1 `
-ImageId ami-0abcdef1234567890 | Format-List Name, BootMode, TpmSupport
```
Voici un exemple de sortie.
```
Name : TPM-Windows_Server-2016-English-Full-Base-2023.05.10
BootMode : uefi
TpmSupport : v2.0
```
Dans la sortie, une valeur `BootMode` indique le mode de démarrage de l’AMI. Une valeur de `uefi` indique que l’AMI prend en charge UEFI. Une valeur de `uefi-preferred` indique que l’AMI prend en charge l’UEFI et le BIOS hérité. S’il n’existe aucune valeur, les instances lancées à partir de l’AMI utilisent la valeur par défaut du type d’instance.
------
# Déterminer les modes de démarrage pris en charge par un type d’instance EC2
Vous pouvez déterminer les modes de démarrage pris en charge par un type d’instance.
La console Amazon EC2 n’affiche pas les modes de démarrage pris en charge par un type d’instance.
------
#### [ AWS CLI ]
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-types.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-types.html) pour déterminer les modes de démarrage pris en charge d’un type d’instance. Le paramètre `--query` filtre la sortie pour ne renvoyer que les modes de démarrage pris en charge.
L’exemple suivant montre que le type d’instance spécifié prend en charge les modes de démarrage UEFI et BIOS hérité.
```
aws ec2 describe-instance-types \
--instance-types m5.2xlarge \
--query "InstanceTypes[*].SupportedBootModes"
```
Voici un exemple de sortie.
```
[
[
"legacy-bios",
"uefi"
]
]
```
L’exemple suivant montre que `t2.xlarge` ne prend en charge que le BIOS hérité.
```
aws ec2 describe-instance-types \
--instance-types t2.xlarge \
--query "InstanceTypes[*].SupportedBootModes"
```
Voici un exemple de sortie.
```
[
[
"legacy-bios"
]
]
```
------
#### [ PowerShell ]
Utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2InstanceType.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2InstanceType.html) pour déterminer les modes de démarrage pris en charge par un type d’instance.
L’exemple suivant montre que `m5.2xlarge` prend en charge les modes de démarrage de l’UEFI et du BIOS hérité.
```
Get-EC2InstanceType -InstanceType m5.2xlarge | Format-List InstanceType, SupportedBootModes
```
Voici un exemple de sortie.
```
InstanceType : m5.2xlarge
SupportedBootModes : {legacy-bios, uefi}
```
L’exemple suivant montre que `t2.xlarge` ne prend en charge que le BIOS hérité.
```
Get-EC2InstanceType -InstanceType t2.xlarge | Format-List InstanceType, SupportedBootModes
```
Voici un exemple de sortie.
```
InstanceType : t2.xlarge
SupportedBootModes : {legacy-bios}
```
------
**Pour déterminer les types d’instances qui prennent en charge l’UEFI**
Vous pouvez déterminer les types d’instance qui prennent en charge l’UEFI. La console Amazon EC2 n’affiche pas la prise en charge UEFI par un type d’instance.
------
#### [ AWS CLI ]
Les types d’instance disponibles varient selon l’ Région AWS. Pour voir les types d'instances disponibles qui prennent en charge l'UEFI dans une région, utilisez la [describe-instance-types](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-types.html)commande. Incluez le paramètre `--filters` pour étendre les résultats aux types d’instance qui prennent en charge lUEFI et le paramètre `--query` pour étendre la sortie à la valeur de `InstanceType`.
```
aws ec2 describe-instance-types \
--filters Name=supported-boot-mode,Values=uefi \
--query "InstanceTypes[*].[InstanceType]" --output text | sort
```
------
#### [ PowerShell ]
Les types d’instance disponibles varient selon l’ Région AWS. Pour voir les types d'instances disponibles qui prennent en charge l'UEFI dans une région, utilisez l'[Get-EC2InstanceType](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2InstanceType.html)applet de commande.
```
Get-EC2InstanceType | `
Where-Object {$_.SupportedBootModes -Contains "uefi"} | `
Sort-Object InstanceType | `
Format-Table InstanceType -GroupBy CurrentGeneration
```
------
**Pour déterminer les types d’instance qui prennent en charge le démarrage sécurisé de l’UEFI et qui conservent les variables non volatiles**
Les instances du matériel nu ne prennent pas en charge le démarrage sécurisé de l’UEFI et les variables non volatiles, de sorte que ces exemples les excluent de la sortie. Pour plus d’informations sur UEFI Secure Boot, consultez [Démarrage sécurisé de l’UEFI pour les instances Amazon EC2](uefi-secure-boot.md).
------
#### [ AWS CLI ]
Utilisez la [describe-instance-types](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-types.html)commande et excluez les instances bare metal de la sortie.
```
aws ec2 describe-instance-types \
--filters Name=supported-boot-mode,Values=uefi Name=bare-metal,Values=false \
--query "InstanceTypes[*].[InstanceType]" \
--output text | sort
```
------
#### [ PowerShell ]
Utilisez l'[Get-EC2InstanceType](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2InstanceType.html)applet de commande et excluez les instances bare metal de la sortie.
```
Get-EC2InstanceType | `
Where-Object { `
$_.SupportedBootModes -Contains "uefi" -and `
$_.BareMetal -eq $False
} | `
Sort-Object InstanceType | `
Format-Table InstanceType, SupportedBootModes, BareMetal, `
@{Name="SupportedArchitectures"; Expression={$_.ProcessorInfo.SupportedArchitectures}}
```
------
# Déterminer le mode de démarrage d’une instance EC2
Le mode de démarrage d’une instance est affiché dans le champ **Mode de démarrage** de la console Amazon EC2, et par le paramètre `currentInstanceBootMode` de l’ AWS CLI.
Lorsqu’une instance est lancée, la valeur de son paramètre de mode de démarrage est déterminée par la valeur du paramètre de mode de démarrage de l’AMI utilisée pour la lancer, comme suit :
+ Une AMI avec un paramètre de mode de démarrage défini sur `uefi` crée une instance avec un paramètre `currentInstanceBootMode` de `uefi`.
+ Une AMI avec un paramètre de mode de démarrage défini sur `legacy-bios` crée une instance avec un paramètre `currentInstanceBootMode` de ` legacy-bios`.
+ Une AMI dont le paramètre de mode de démarrage est `uefi-preferred` crée une instance avec un paramètre `currentInstanceBootMode` de `uefi` si le type d’instance prend en charge l’UEFI ; sinon, elle crée une instance avec un paramètre `currentInstanceBootMode` de `legacy-bios`.
+ Une AMI sans valeur de paramètre de mode de démarrage crée une instance avec une valeur de paramètre de `currentInstanceBootMode` qui dépend du fait que l’architecture de l’AMI est ARM ou x86 et du mode de démarrage pris en charge du type d’instance. Le mode de démarrage par défaut est `uefi` sur les types d’instance Graviton et `legacy-bios` sur les types d’instance Intel et AMD.
------
#### [ Console ]
**Pour déterminer le mode de démarrage d’une instance**
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le panneau de navigation, choisissez **instances**, puis sélectionnez votre instance.
1. Sous l’onglet **Détails**, vérifiez le champ **Mode de démarrage**.
------
#### [ AWS CLI ]
**Pour déterminer le mode de démarrage d’une instance**
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html) pour déterminer le mode de démarrage d’une instance. Vous pouvez également déterminer le mode de démarrage de l'AMI qui a été utilisée pour créer l'instance.
```
aws ec2 describe-instances \
--region us-east-1 \
--instance-ids i-1234567890abcdef0 \
--query Reservations[].Instances[].BootMode \
--output text
```
Voici un exemple de sortie.
```
uefi
```
------
#### [ PowerShell ]
**Pour déterminer le mode de démarrage d’une instance**
Utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html) pour déterminer le mode de démarrage d’une instance. Vous pouvez également déterminer le mode de démarrage de l’AMI qui a été utilisée pour créer l’instance.
```
(Get-EC2Instance `
-InstanceId i-1234567890abcdef0).Instances | Format-List BootMode, CurrentInstanceBootMode, InstanceType, ImageId
```
Voici un exemple de sortie.
```
BootMode : uefi
CurrentInstanceBootMode : uefi
InstanceType : c5a.large
ImageId : ami-0abcdef1234567890
```
------
# Déterminer le mode de démarrage du système d’exploitation de votre instance EC2
Le mode de démarrage de l’AMI guide Amazon EC2 vers le mode de démarrage à utiliser pour démarrer une instance. Pour savoir si le système d’exploitation de votre instance est configuré pour l’UEFI, vous devez vous connecter à votre instance en utilisant SSH (instances Linux) ou RDP (instances Windows).
Utilisez les instructions fournies pour le système d’exploitation de votre instance.
## Linux
**Pour déterminer le mode de démarrage du système d’exploitation de l’instance**
1. [Connectez-vous à votre instance Linux à l’aide de SSH](connect-linux-inst-ssh.md).
1. Pour afficher le mode de démarrage du système d’exploitation, essayez l’une des méthodes suivantes :
+ Exécutez la commande suivante.
```
[ec2-user ~]$ sudo /usr/sbin/efibootmgr
```
Sortie attendue d’une instance démarrée en mode de démarrage UEFI
```
BootCurrent: 0001
Timeout: 0 seconds
BootOrder: 0000,0001
Boot0000* UiApp
Boot0001* UEFI Amazon Elastic Block Store vol-xyz
```
+ Exécutez la commande suivante pour vérifier l’existence du répertoire `/sys/firmware/efi`. Ce répertoire n’existe que si l’instance démarre à l’aide de l’UEFI. Si le répertoire n’existe pas, la commande renvoie `Legacy BIOS Boot Detected`.
```
[ec2-user ~]$ [ -d /sys/firmware/efi ] && echo "UEFI Boot Detected" || echo "Legacy BIOS Boot Detected"
```
Sortie attendue d’une instance démarrée en mode de démarrage UEFI
```
UEFI Boot Detected
```
Sortie attendue d’une instance démarrée en mode de démarrage BIOS hérité
```
Legacy BIOS Boot Detected
```
+ Exécutez la commande suivante pour vérifier qu’EFI apparaît dans la sortie `dmesg`.
```
[ec2-user ~]$ dmesg | grep -i "EFI"
```
Sortie attendue d’une instance démarrée en mode de démarrage UEFI
```
[ 0.000000] efi: Getting EFI parameters from FDT:
[ 0.000000] efi: EFI v2.70 by EDK II
```
## Windows
**Pour déterminer le mode de démarrage du système d’exploitation de l’instance**
1. [Connectez-vous à votre instance Windows à l’aide de RDP](connecting_to_windows_instance.md).
1. Accédez à **Informations système** et vérifiez la ligne **Mode BIOS**.
![\[Fenêtre d’informations système affichant la ligne du mode BIOS sélectionnée. La valeur du mode BIOS est « hérité ».\]](http://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/images/BIOS-mode-win.png)
# Définir le mode de démarrage d’une AMI Amazon EC2
Par défaut, une AMI hérite du mode de démarrage de l’instance EC2 utilisée pour créer l’AMI. Par exemple, si vous créez une AMI à partir d’une instance EC2 fonctionnant sur un BIOS hérité, le mode de démarrage de la nouvelle AMI est `legacy-bios`. Si vous créez une AMI à partir d’une instance EC2 avec un mode de démarrage `uefi-preferred`, le mode de démarrage de la nouvelle AMI sera `uefi-preferred`.
Lorsque vous enregistrez une AMI, vous pouvez définir le mode de démarrage de l’AMI sur `uefi`, `legacy-bios` ou `uefi-preferred`.
Lorsque le mode de démarrage de l’AMI est défini sur `uefi-preferred`, l’instance démarre comme suit :
+ Pour les types d’instance qui prennent en charge à la fois l’UEFI et le BIOS hérité (par exemple, `m5.large`), l’instance démarre à l’aide de l’UEFI.
+ Pour les types d’instance qui prennent en charge uniquement le BIOS hérité (par exemple, `m4.large`), l’instance démarre à l’aide du BIOS hérité.
Si vous définissez le mode de démarrage de l’AMI sur `uefi-preferred`, le système d’exploitation doit prendre en charge le démarrage de l’UEFI et du BIOS hérité.
Pour convertir une instance existante basée sur le BIOS hérité en UEFI, ou une instance existante basée sur UEFI en BIOS hérité, vous devez d’abord modifier le volume et le système d’exploitation de l’instance afin qu’ils prennent en charge le mode de démarrage sélectionné. Créez ensuite un instantané du volume. Et pour finir, créez une AMI à partir de l’instantané
**Considérations**
+ La définition du paramètre de mode de démarrage de l’AMI ne configure pas automatiquement le système d’exploitation pour le mode de démarrage spécifié. Vous devez d’abord apporter les modifications appropriées au volume et au système d’exploitation de l’instance afin de prendre en charge le démarrage à l’aide du mode de démarrage sélectionné. Sinon, l’AMI résultante ne sera pas utilisable. Par exemple, si vous convertissez une instance Windows basée sur le BIOS Legacy en UEFI, vous pouvez utiliser l'[MBR2outil GPT](https://learn.microsoft.com/en-us/windows/deployment/mbr-to-gpt) de Microsoft pour convertir le disque système de MBR en GPT. Les modifications requises sont spécifiques au système d’exploitation. Pour plus d’informations, consultez le manuel de votre système d’exploitation.
+ Vous ne pouvez pas utiliser la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) ou l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html) pour créer une AMI prenant en charge à la fois [NitroTPM](nitrotpm.md) et UEFI préférée.
+ Certaines fonctionnalités, comme UEFI Secure Boot, ne sont disponibles que sur les instances qui démarrent sur l’UEFI. Lorsque vous utilisez le paramètre de mode de démarrage de l’AMI `uefi-preferred` avec un type d’instance qui ne prend pas en charge l’UEFI, l’instance démarre en mode BIOS hérité et la fonctionnalité dépendante de l’UEFI est désactivée. Si vous vous appuyez sur la disponibilité d’une fonctionnalité dépendante de l’UEFI, définissez le paramètre du mode de démarrage de votre AMI sur `uefi`.
------
#### [ AWS CLI ]
**Pour définir le mode de démarrage d’une AMI**
1. Apporter des modifications appropriées au volume et au système d’exploitation de l’instance pour prendre en charge le démarrage via le mode de démarrage sélectionné. Les modifications requises sont spécifiques au système d’exploitation. Pour plus d’informations, consultez le manuel de votre système d’exploitation.
**Avertissement**
Si vous n’effectuez pas cette étape, l’AMI ne sera pas utilisable.
1. Pour trouver l’ID de volume de l’instance, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html). Vous allez créer un instantané de ce volume à l’étape suivante.
```
aws ec2 describe-instances \
--instance-ids i-1234567890abcdef0 \
--query Reservations[].Instances[].BlockDeviceMappings
```
Voici un exemple de sortie.
```
[
[
{
"DeviceName": "/dev/xvda",
"Ebs": {
"AttachTime": "2024-07-11T01:05:51+00:00",
"DeleteOnTermination": true,
"Status": "attached",
"VolumeId": "vol-1234567890abcdef0"
}
}
]
]
```
1. Pour créer un instantané du volume, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/create-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-snapshot.html). Utilisez l’ID de volume de l’étape précédente.
```
aws ec2 create-snapshot \
--volume-id vol-01234567890abcdef \
--description "my snapshot"
```
Voici un exemple de sortie.
```
{
"Description": "my snapshot",
"Encrypted": false,
"OwnerId": "123456789012",
"Progress": "",
"SnapshotId": "snap-0abcdef1234567890",
"StartTime": "",
"State": "pending",
"VolumeId": "vol-01234567890abcdef",
"VolumeSize": 30,
"Tags": []
}
```
1. Attendez que l’état de l’instantané soit `completed` avant de passer à l’étape suivante. Pour obtenir l’état de l’instantané, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-snapshots.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-snapshots.html) avec l’ID d’instantané obtenu à l’étape précédente.
```
aws ec2 describe-snapshots \
--snapshot-ids snap-0abcdef1234567890 \
--query Snapshots[].State \
--output text
```
Voici un exemple de sortie.
```
completed
```
1. Pour créer une AMI, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html). Utilisez la valeur `SnapshotId` de la sortie de **CreateSnapshot**.
+ Pour définir le mode de démarrage sur UEFI, ajoutez le paramètre `--boot-mode` avec une valeur de `uefi`.
```
aws ec2 register-image \
--description "my image" \
--name "my-image" \
--block-device-mappings "DeviceName=/dev/sda1,Ebs={SnapshotId=snap-0abcdef1234567890,DeleteOnTermination=true}" \
--root-device-name /dev/sda1 \
--virtualization-type hvm \
--ena-support \
--boot-mode uefi
```
+ Pour définir le mode de démarrage sur `uefi-preferred`, définissez la valeur de `--boot-mode` sur `uefi-preferred`
```
aws ec2 register-image \
--description "my description" \
--name "my-image" \
--block-device-mappings "DeviceName=/dev/sda1,Ebs={SnapshotId=snap-0abcdef1234567890,DeleteOnTermination=true}" \
--root-device-name /dev/sda1 \
--virtualization-type hvm \
--ena-support \
--boot-mode uefi-preferred
```
1. (Facultatif) Pour vérifier que l’AMI nouvellement créée possède le mode de démarrage que vous avez spécifié, utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html).
```
aws ec2 describe-images \
--image-id ami-1234567890abcdef0 \
--query Images[].BootMode \
--output text
```
Voici un exemple de sortie.
```
uefi
```
------
#### [ PowerShell ]
**Pour définir le mode de démarrage d’une AMI**
1. Apporter des modifications appropriées au volume et au système d’exploitation de l’instance pour prendre en charge le démarrage via le mode de démarrage sélectionné. Les modifications requises sont spécifiques au système d’exploitation. Pour plus d’informations, consultez le manuel de votre système d’exploitation.
**Avertissement**
Si vous n’effectuez pas cette étape, l’AMI ne sera pas utilisable.
1. Pour rechercher l’ID de volume de l’instance, utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Instance.html).
```
(Get-EC2Instance `
-InstanceId i-1234567890abcdef0).Instances.BlockDeviceMappings.Ebs
```
Voici un exemple de sortie.
```
AssociatedResource :
AttachTime : 7/11/2024 1:05:51 AM
DeleteOnTermination : True
Operator :
Status : attached
VolumeId : vol-01234567890abcdef
```
1. Pour créer un instantané du volume, utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2Snapshot.html](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2Snapshot.html). Utilisez l’ID de volume de l’étape précédente.
```
New-EC2Snapshot `
-VolumeId vol-01234567890abcdef `
-Description "my snapshot"
```
Voici un exemple de sortie.
```
AvailabilityZone :
Description : my snapshot
Encrypted : False
FullSnapshotSizeInBytes : 0
KmsKeyId :
OwnerId : 123456789012
RestoreExpiryTime :
SnapshotId : snap-0abcdef1234567890
SseType :
StartTime : 4/25/2025 6:08:59 PM
State : pending
StateMessage :
VolumeId : vol-01234567890abcdef
VolumeSize : 30
```
1. Attendez que l’état de l’instantané soit `completed` avant de passer à l’étape suivante. Pour connaître l’état de l’instantané, utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Snapshot.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Snapshot.html) avec l’ID d’instantané obtenu à l’étape précédente.
```
(Get-EC2Snapshot `
-SnapshotId snap-0abcdef1234567890).State.Value
```
Voici un exemple de sortie.
```
completed
```
1. Pour créer une AMI, utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html). Utilisez la valeur `SnapshotId` de la sortie de **New-EC2Snapshot**.
+ Pour définir le mode de démarrage sur UEFI, ajoutez le paramètre `-BootMode` avec une valeur de `uefi`.
```
$block = @{SnapshotId=snap-0abcdef1234567890}
Register-EC2Image `
-Description "my image" `
-Name "my-image" `
-BlockDeviceMapping @{DeviceName="/dev/xvda";Ebs=$block} `
-RootDeviceName /dev/xvda `
-EnaSupport $true `
-BootMode uefi
```
+ Pour définir le mode de démarrage sur `uefi-preferred`, définissez la valeur de `-BootMode` sur `uefi-preferred`
```
$block = @{SnapshotId=snap-0abcdef1234567890}
Register-EC2Image `
-Description "my image" `
-Name "my-image" `
-BlockDeviceMapping @{DeviceName="/dev/xvda";Ebs=$block} `
-RootDeviceName /dev/xvda `
-EnaSupport $true `
-BootMode uefi-preferred
```
1. (Facultatif) Pour vérifier que l’AMI nouvellement créée dispose du mode de démarrage que vous avez spécifié, utilisez l’applet de commande [https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html).
```
(Get-EC2Image `
-ImageId ami-1234567890abcdef0).BootMode.Value
```
Voici un exemple de sortie.
```
uefi
```
------
# Variables UEFI pour les instances Amazon EC2
Lorsque vous lancez une instance pour laquelle le mode de démarrage est défini sur UEFI, un magasin clé-valeur pour les variables est créé. Le magasin peut être utilisé par UEFI et le système d’exploitation d’instances pour stocker des variables UEFI.
Les variables UEFI sont utilisées par le chargeur de démarrage et le système d’exploitation pour configurer le démarrage précoce du système. Ils permettent au système d’exploitation de gérer certains paramètres du processus de démarrage, tels que l’ordre de démarrage ou la gestion des clés de UEFI Secure Boot.
**Avertissement**
Toute personne pouvant se connecter à l'instance (et potentiellement à tout logiciel exécuté sur l'instance), ou toute personne autorisée à utiliser l'[GetInstanceUefiData](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetInstanceUefiData.html)API sur l'instance, peut lire les variables. Vous ne devez jamais stocker de données sensibles, telles que des mots de passe ou des informations personnelles identifiables, dans le magasin de variables UEFI.
**Persistance des variables UEFI**
+ Pour les instances lancées le 10 mai 2022 ou avant, les variables UEFI sont effacées au redémarrage ou à l’arrêt.
+ Pour les instances lancées le 11 mai 2022 ou après, les variables UEFI marquées comme non volatiles sont conservées au redémarrage et à l’arrêt/démarrage.
+ Les instances matériel nu ne préservent pas les variables non volatiles UEFI dans les opérations d’arrêt/démarrage de l’instance.
# Démarrage sécurisé de l’UEFI pour les instances Amazon EC2
UEFI Secure Boot s'appuie sur le processus de démarrage sécurisé de longue date d'Amazon EC2 et fournit des fonctionnalités defense-in-depth supplémentaires qui aident les clients à protéger leurs logiciels contre les menaces persistantes après les redémarrages. Il garantit que l’instance démarre uniquement le logiciel signé avec des clés de chiffrement. Les clés sont stockées dans la base de données de clés du [Magasin de variables non volatiles UEFI](uefi-variables.md). UEFI Secure Boot empêche la modification non autorisée du flux de démarrage de l’instance.
**Topics**
+ [Comment fonctionne le démarrage sécurisé de l’UEFI avec les instances Amazon EC2](how-uefi-secure-boot-works.md)
+ [Exigences relatives au démarrage sécurisé UEFI sur Amazon EC2](launch-instance-with-uefi-sb.md)
+ [Vérifiez si une instance Amazon EC2 est activée pour le démarrage sécurisé de l’UEFI](verify-uefi-secure-boot.md)
+ [Créer une AMI Linux avec des clés de démarrage sécurisé de l’UEFI personnalisées](create-ami-with-uefi-secure-boot.md)
+ [Créez le blob AWS binaire pour UEFI Secure Boot](aws-binary-blob-creation.md)
# Comment fonctionne le démarrage sécurisé de l’UEFI avec les instances Amazon EC2
UEFI Secure Boot est une fonction spécifiée dans UEFI, qui permet de vérifier l’état de la chaîne de démarrage. Elle est conçue pour garantir que seuls les binaires UEFI vérifiés cryptographiquement sont exécutés après l’auto-initialisation du microprogramme. Ces binaires incluent les pilotes UEFI et le chargeur de démarrage principal, ainsi que des composants chargés en série.
UEFI Secure Boot spécifie quatre bases de données clés, qui sont utilisées dans une chaîne de confiance. Les bases de données sont stockées dans le magasin de variables UEFI.
La chaîne de confiance est la suivante :
**Base de données de clés de plateforme (PK, Platform Key)**
La base de données PK est la source de la confiance. Elle contient une clé PK publique unique utilisée dans la chaîne de confiance pour mettre à jour la base de données KEK (Key Exchange Key).
Pour modifier la base de données PK, vous devez disposer de la clé privée PK pour signer une demande de mise à jour. Cela inclut la suppression de la base de données PK en écrivant une clé PK vide.
**Base de données de clés d’échange de clés (KEK)**
La base de données KEK est une liste de clés KEK publiques utilisées dans la chaîne de confiance pour mettre à jour les bases de données de signature (db) et de liste d’exclusion (dbx).
Pour modifier la base de données publique KEK, vous devez disposer de la clé privée PK pour signer une demande de mise à jour.
**Base de données de signature (db)**
La base de données est une liste de clés publiques et de hachages utilisés dans la chaîne de confiance pour valider tous les binaires de démarrage UEFI.
Pour modifier la base de données db, vous devez disposer de la clé privée PK ou de l’une des clés privées KEK pour signer une demande de mise à jour.
**Base de données de liste d’exclusion de signature (dbx)**
La base de données dbx est une liste de clés publiques et de hachages binaires qui ne sont pas fiables et sont utilisés dans la chaîne de confiance comme fichier de révocation.
La base de données dbx est toujours prioritaire sur toutes les autres bases de données clés.
Pour modifier la base de données dbx, vous devez disposer de la clé privée PK ou de l’une des clés privées KEK pour signer une demande de mise à jour.
Le Forum de UEFI maintient une dbx accessible au public pour de nombreux binaires et certificats connus pour être mauvais à l’adresse [https://uefi.org/revocationlistfile](https://uefi.org/revocationlistfile).
**Important**
UEFI Secure Boot impose la validation des signatures sur tous les binaires UEFI. Pour permettre l’exécution d’un binaire UEFI dans UEFI Secure Boot, vous le signez avec l’une des clés privées db décrites ci-dessus.
Par défaut, UEFI Secure Boot est désactivé et le système est en mode `SetupMode`. Lorsque le système est en mode `SetupMode`, toutes les variables clés peuvent être mises à jour sans signature cryptographique. Lorsque le PK est défini, le démarrage sécurisé UEFI est activé et est quitté. SetupMode
# Exigences relatives au démarrage sécurisé UEFI sur Amazon EC2
Lorsque vous [lancez une instance Amazon EC2](LaunchingAndUsingInstances.md) avec une AMI et un type d’instance pris en charge, cette instance validera automatiquement les binaires de démarrage de l’UEFI par rapport à sa base de données de démarrage sécurisé de l’UEFI. Aucune configuration supplémentaire n’est requise. Vous pouvez également configurer UEFI Secure Boot sur une instance après le lancement.
**Note**
UEFI Secure Boot protège votre instance et son système d’exploitation contre les modifications du flux de démarrage. Si vous créez une nouvelle AMI à partir d’une AMI source pour laquelle le démarrage sécurisé de l’UEFI est activé et que vous modifiez certains paramètres au cours du processus de copie, par exemple en modifiant `UefiData` dans l’AMI, vous pouvez désactiver le démarrage sécurisé de l’UEFI.
**Topics**
+ [Soutenu AMIs](#uefi-amis)
+ [Types d’instance pris en charge](#uefi-instance)
## Soutenu AMIs
**Linux AMIs**
Pour lancer une instance Linux, l’AMI Linux doit avoir activée le démarrage sécurisé de l’UEFI.
Amazon Linux prend en charge le démarrage sécurisé UEFI à partir de la AL2023 version 2023.1. Toutefois, le démarrage sécurisé UEFI n'est pas activé par défaut. AMIs Pour plus d'informations, consultez la section [UEFI Secure Boot](https://docs.aws.amazon.com/linux/al2023/ug/uefi-secure-boot.html) dans le guide de l'*AL2023 utilisateur*. Les anciennes versions d'Amazon Linux AMIs ne sont pas activées pour le démarrage sécurisé UEFI. Pour utiliser une AMI supportée, vous devez effectuer plusieurs étapes de configuration sur votre propre AMI Linux. Pour de plus amples informations, veuillez consulter [Créer une AMI Linux avec des clés de démarrage sécurisé de l’UEFI personnalisées](create-ami-with-uefi-secure-boot.md).
**Fenêtres AMIs**
Pour lancer une instance Windows, l’AMI Windows doit avoir activée le démarrage sécurisé de l’UEFI. *Pour trouver une AMI AWS Windows préconfigurée pour le démarrage sécurisé UEFI à l'aide de clés Microsoft, voir [Rechercher un serveur Windows AMIs configuré avec NitroTPM et UEFI Secure Boot](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/ami-windows-tpm.html#ami-windows-tpm-find) dans le manuel Windows Reference.AWS AMIs *
Actuellement, l'importation sur Windows avec UEFI Secure Boot à l'aide de la commande [import-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/import-image.html) n'est pas prise en charge.
## Types d’instance pris en charge
Tous les types d’instances virtualisées qui prennent en charge l’UEFI prennent également en charge le démarrage sécurisé de l’UEFI. Pour connaître les types d’instances prenant en charge UEFI Secure Boot, consultez [Conditions requises pour le mode de démarrage UEFI](launch-instance-boot-mode.md).
**Note**
Les types d’instance matériel nu ne prennent pas en charge UEFI Secure Boot.
# Vérifiez si une instance Amazon EC2 est activée pour le démarrage sécurisé de l’UEFI
Vous pouvez utiliser les procédures suivantes pour déterminer si un Amazon EC2 est activé pour le démarrage sécurisé de l’UEFI.
## Instances Linux
Vous pouvez utiliser l’utilitaire `mokutil` pour vérifier si une instance Linux est activée pour UEFI Secure Boot. Si `mokutil` n’est pas installé sur votre instance, vous devez l’installer. Pour les instructions d’installation d’Amazon Linux 2, consultez la section [Rechercher et installer des suites logicielles sur une instance Amazon Linux 2](https://docs.aws.amazon.com/linux/al2/ug/find-install-software.html). Pour les autres distributions Linux, consultez leur documentation spécifique.
**Pour vérifier si une instance Linux est activée pour UEFI Secure Boot**
Connectez-vous à votre instance et exécutez la commande suivante en tant que `root` dans une fenêtre de terminal.
```
mokutil --sb-state
```
Voici un exemple de sortie.
+ Si UEFI Secure Boot est activé, la sortie contient `SecureBoot enabled`.
+ Si UEFI Secure Boot n’est pas activé, la sortie contient `SecureBoot disabled` ou `Failed to read SecureBoot`.
## instances Windows
**Pour vérifier si une instance Windows est activée pour UEFI Secure Boot**
1. Connectez-vous à votre instance.
1. Ouvrez l’outil msinfo32.
1. Vérifiez le champ **Secure Boot State** (État du démarrage sécurisé). Si le démarrage sécurisé de l’UEFI est activé, la valeur est **Prise en charge**, comme le montre l’image suivante.
![\[État de démarrage sécurisé dans Informations système.\]](http://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/images/secure-boot-state-win.png)
Vous pouvez également utiliser l' PowerShell applet de commande Windows `Confirm-SecureBootUEFI` pour vérifier l'état du démarrage sécurisé. Pour plus d'informations sur l'applet de commande, consultez la section [Confirm- SecureBoot UEFI dans la documentation Microsoft](https://learn.microsoft.com/en-us/powershell/module/secureboot/confirm-securebootuefi).
# Créer une AMI Linux avec des clés de démarrage sécurisé de l’UEFI personnalisées
Ces instructions vous montrent comment créer une AMI Linux avec démarrage sécurisé de l’UEFI et clés privées personnalisées. Amazon Linux prend en charge le démarrage sécurisé UEFI à partir de la AL2023 version 2023.1. Pour plus d'informations, consultez [UEFI Secure Boot on AL2023 dans le](https://docs.aws.amazon.com/linux/al2023/ug/uefi-secure-boot.html) guide de l'*utilisateur Amazon Linux 2023*.
**Important**
La procédure suivante est destinée **uniquement aux utilisateurs avancés**. Vous devez posséder une connaissance suffisante de SSL et du flux de démarrage de distribution Linux pour utiliser ces procédures.
**Conditions préalables**
+ Les outils suivants seront utilisés :
+ OpenSSL : [https://www.openssl.org/](https://www.openssl.org/)
+ [éfivar — éfivar https://github.com/rhboot/](https://github.com/rhboot/efivar)
+ [efitools — https://git.kernel. org/pub/scm/linux/kernel/git/jejb/efitools.git/](https://git.kernel.org/pub/scm/linux/kernel/git/jejb/efitools.git/)
+ Commande [get-instance-uefi-data](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html)
+ Votre instance Linux doit avoir été lancée avec une AMI Linux qui prend en charge le mode de démarrage UEFI et contient des données non volatiles.
Les instances nouvellement créées sans clés UEFI Secure Boot sont créées dans `SetupMode`, ce qui vous permet d’inscrire vos propres clés. Certaines AMIs sont préconfigurées avec UEFI Secure Boot et vous ne pouvez pas modifier les clés existantes. Si vous souhaitez modifier les clés, vous devez créer une nouvelle AMI basée sur l’AMI d’origine.
Vous pouvez propager les clés dans le magasin de variables de deux manières, décrites dans les options A et B suivantes. L’option A décrit comment le faire depuis l’instance, en imitant le flux de matériel réel. L’option B décrit comment créer un blob binaire, qui est ensuite transmis en tant que fichier codé en base64 lorsque vous créez l’AMI. Pour les deux options, vous devez d’abord créer les trois paires de clés utilisées pour la chaîne de confiance.
**Topics**
+ [Tâche 1 : création d’une paire de clés](#uefi-secure-boot-create-three-key-pairs)
+ [Tâche 2 – Option A : ajout de clés au magasin de variables depuis l’instance](#uefi-secure-boot-optionA)
+ [Tâche 2 – Option B : création d’un blob binaire contenant un magasin de variables prérempli](#uefi-secure-boot-optionB)
## Tâche 1 : création d’une paire de clés
UEFI Secure Boot repose sur les trois bases de données de clés suivantes, qui sont utilisées dans une chaîne de confiance : la clé de plateforme (PK), la clé d’échange de clés (KEK) et la base de données de signatures (db).¹
Vous créez chaque clé sur l’instance. Pour préparer les clés publiques dans un format valide pour la norme UEFI Secure Boot, vous créez un certificat pour chaque clé. `DER` définit le format SSL (codage binaire d’un format). Vous convertissez ensuite chaque certificat en liste de signatures UEFI, qui est le format binaire compris par UEFI Secure Boot. Enfin, vous signez chaque certificat avec la clé correspondante.
**Topics**
+ [Préparez-vous à créer les paires de clés](#uefisb-prepare-to-create-key-pairs)
+ [Paire de clés 1 : créer la clé de plateforme (PK)](#uefisb-create-key-pair-1)
+ [Paire de clés 2 : créer la clé d’échange de clés (KEK)](#uefisb-create-key-pair-2)
+ [Paire de clés 3 : créez la base de données de signatures (db)](#uefisb-create-key-pair-3)
+ [Signez l’image de démarrage (noyau) avec la clé privée](#uefi-secure-boot-sign-kernel)
### Préparez-vous à créer les paires de clés
Avant de créer les paires de clés, créez un identifiant unique global (GUID) à utiliser lors de la génération de clés.
1. [Connectez-vous à l’instance.](connect.md)
1. Exécutez la commande suivante dans un shell.
```
uuidgen --random > GUID.txt
```
### Paire de clés 1 : créer la clé de plateforme (PK)
La PK est la fondation de la confiance pour les instances UEFI Secure Boot. La PK privée est utilisée pour mettre à jour la KEK, qui peut à son tour être utilisée pour ajouter des clés autorisées à la base de données de signatures (db).
La norme X.509 est utilisée pour créer la paire de clés. Pour plus d’informations sur la norme, veuillez consulter [X.509](https://en.wikipedia.org/wiki/X.509) sur *Wikipédia*.
**Pour créer la PK**
1. Créez la clé. Vous devez nommer la variable `PK`.
```
openssl req -newkey rsa:4096 -nodes -keyout PK.key -new -x509 -sha256 -days 3650 -subj "/CN=Platform key/" -out PK.crt
```
Les paramètres suivants sont spécifiés :
+ `-keyout PK.key` : le fichier de clé privée.
+ `-days 3650` : le nombre de jours de validité du certificat.
+ `-out PK.crt` : le certificat utilisé pour créer la variable UEFI.
+ `CN=Platform key` : le nom commun (CN) de la clé. Vous pouvez saisir le nom de votre propre organisation à la place de*Platform key*.
1. Créez le certificat.
```
openssl x509 -outform DER -in PK.crt -out PK.cer
```
1. Convertissez le certificat en liste de signatures UEFI.
```
cert-to-efi-sig-list -g "$(< GUID.txt)" PK.crt PK.esl
```
1. Signez la liste de signatures UEFI avec la PK privée (auto-signée).
```
sign-efi-sig-list -g "$(< GUID.txt)" -k PK.key -c PK.crt PK PK.esl PK.auth
```
### Paire de clés 2 : créer la clé d’échange de clés (KEK)
La KEK privée est utilisée pour ajouter des clés à la base de données, qui est la liste des signatures autorisées à démarrer sur le système.
**Pour créer la KEK**
1. Créez la clé.
```
openssl req -newkey rsa:4096 -nodes -keyout KEK.key -new -x509 -sha256 -days 3650 -subj "/CN=Key Exchange Key/" -out KEK.crt
```
1. Créez le certificat.
```
openssl x509 -outform DER -in KEK.crt -out KEK.cer
```
1. Convertissez le certificat en liste de signatures UEFI.
```
cert-to-efi-sig-list -g "$(< GUID.txt)" KEK.crt KEK.esl
```
1. Signez la liste de signatures avec la PK privée.
```
sign-efi-sig-list -g "$(< GUID.txt)" -k PK.key -c PK.crt KEK KEK.esl KEK.auth
```
### Paire de clés 3 : créez la base de données de signatures (db)
La liste db contient des clés autorisées qui sont habilitées à être démarrées sur le système. Pour modifier la liste, la KEK privée est nécessaire. Les images de démarrage seront signées avec la clé privée créée au cours de cette étape.
**Pour créer la db**
1. Créez la clé.
```
openssl req -newkey rsa:4096 -nodes -keyout db.key -new -x509 -sha256 -days 3650 -subj "/CN=Signature Database key/" -out db.crt
```
1. Créez le certificat.
```
openssl x509 -outform DER -in db.crt -out db.cer
```
1. Convertissez le certificat en liste de signatures UEFI.
```
cert-to-efi-sig-list -g "$(< GUID.txt)" db.crt db.esl
```
1. Signez la liste de signatures avec la KEK privée.
```
sign-efi-sig-list -g "$(< GUID.txt)" -k KEK.key -c KEK.crt db db.esl db.auth
```
### Signez l’image de démarrage (noyau) avec la clé privée
Pour Ubuntu 22.04, les images suivantes nécessitent des signatures.
```
/boot/efi/EFI/ubuntu/shimx64.efi
/boot/efi/EFI/ubuntu/mmx64.efi
/boot/efi/EFI/ubuntu/grubx64.efi
/boot/vmlinuz
```
**Pour signer une image**
Utilisez la syntaxe suivante pour signer une image.
```
sbsign --key db.key --cert db.crt --output /boot/vmlinuz /boot/vmlinuz
```
**Note**
Vous devez signer tous les nouveaux noyaux. *`/boot/vmlinuz`* sera généralement un lien symbolique vers le dernier noyau installé.
Reportez-vous à la documentation de votre distribution pour connaître votre chaîne de démarrage et les images requises.
¹ Merci à la ArchWiki communauté pour tout le travail qu'elle a accompli. Les commandes permettant de créer le PK, de créer le KEK, de créer la base de données et de signer l'image proviennent de la section [Création de clés](https://wiki.archlinux.org/title/Unified_Extensible_Firmware_Interface/Secure_Boot#Creating_keys), rédigée par l'équipe de ArchWiki maintenance et and/or les ArchWiki contributeurs.
## Tâche 2 – Option A : ajout de clés au magasin de variables depuis l’instance
Une fois que vous avez créé les [trois paires de clés](#uefi-secure-boot-create-three-key-pairs), vous pouvez vous connecter à votre instance et ajouter les clés au magasin de variables depuis l’instance en effectuant les étapes suivantes. Vous pouvez également suivre les étapes décrites dans [Tâche 2 – Option B : création d’un blob binaire contenant un magasin de variables prérempli](#uefi-secure-boot-optionB).
**Topics**
+ [Étape 1 : lancer une instance qui prend en charge le démarrage sécurisé de UEFI](#step1-launch-uefi-sb)
+ [Étape 2 : configurer une instance pour prendre en charge UEFI Secure Boot](#step2-launch-uefi-sb)
+ [Étape 3 : créer une AMI à partir de l’instance](#step3-launch-uefi-sb)
### Étape 1 : lancer une instance qui prend en charge le démarrage sécurisé de UEFI
Lorsque vous [lancez une instance](LaunchingAndUsingInstances.md) avec les conditions préalables suivantes, l’instance sera alors prête à être configurée pour prendre en charge UEFI Secure Boot. Vous pouvez uniquement activer la prise en charge de UEFI Secure Boot sur une instance au lancement. Vous ne pouvez pas l’activer ultérieurement.
**Conditions préalables**
+ **AMI** : l’AMI Linux doit prendre en charge le mode de démarrage UEFI. Pour vérifier que l’AMI prend en charge le mode de démarrage UEFI, le paramètre du mode de démarrage de l’AMI doit être **uefi**. Pour de plus amples informations, veuillez consulter [Déterminer le paramètre du mode de démarrage d’une AMI Amazon EC2](ami-boot-mode.md).
Notez que AWS seul Linux est AMIs configuré pour prendre en charge l'UEFI pour les types d'instances basés sur Graviton. AWS ne fournit actuellement pas de système Linux x86\$164 prenant en charge le mode de AMIs démarrage UEFI. Vous pouvez configurer votre propre AMI afin de prendre en charge le mode de démarrage UEFI pour toutes les architectures. Pour configurer votre propre AMI afin de prendre en charge le mode de démarrage UEFI, vous devez effectuer plusieurs étapes de configuration sur votre propre AMI Linux. Pour de plus amples informations, veuillez consulter [Définir le mode de démarrage d’une AMI Amazon EC2](set-ami-boot-mode.md).
+ **Type d’instance** : tous les types d’instances virtualisées prenant en charge UEFI prennent également en charge UEFI Secure Boot. Les types d’instance matériel nu ne prennent pas en charge UEFI Secure Boot. Pour connaître les types d’instances prenant en charge UEFI Secure Boot, consultez [Conditions requises pour le mode de démarrage UEFI](launch-instance-boot-mode.md).
+ Lancez votre instance après la sortie d’UEFI Secure Boot. Seules les instances lancées après le 10 mai 2022 (lorsque UEFI Secure Boot a été publié) peuvent prendre en charge UEFI Secure Boot.
Une fois que vous avez lancé votre instance, vous pouvez vérifier qu’elle est prête à être configurée pour prendre en charge UEFI Secure Boot (en d’autres termes, vous pouvez passer à l’[étape 2](#step2-launch-uefi-sb)) en vérifiant si les données UEFI sont présentes. La présence de données UEFI indique que les données non volatiles sont persistantes.
**Pour vérifier si votre instance est prête pour l’étape 2**
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html) et spécifiez l’ID de l’instance.
```
aws ec2 get-instance-uefi-data --instance-id i-1234567890abcdef0
```
L’instance est prête pour l’étape 2 si des données UEFI sont présentes dans la sortie. Si la sortie est vide, l’instance ne peut pas être configurée pour prendre en charge UEFI Secure Boot. Cela peut se produire si votre instance a été lancée avant que la prise en charge UEFI Secure Boot soit disponible. Lancez une nouvelle instance et réessayez.
### Étape 2 : configurer une instance pour prendre en charge UEFI Secure Boot
#### Inscrivez les paires de clés dans votre magasin de variables UEFI sur l’instance
**Avertissement**
Vous devez signer vos images de démarrage *après* avoir inscrit les clés, sinon vous ne pourrez pas démarrer votre instance.
Après avoir créé les listes de signatures UEFI signées (`PK`, `KEK` et `db`), elles doivent être inscrites dans le microprogramme UEFI.
Écriture dans la variable `PK` n’est possible que si :
+ Aucune PK n’est encore inscrite, ce qui est indiqué si la variable `SetupMode` est `1`. Pour vérifier cela, utilisez la commande suivante. La sortie est soit `1`, soit `0`.
```
efivar -d -n 8be4df61-93ca-11d2-aa0d-00e098032b8c-SetupMode
```
+ La nouvelle PK est signée par la clé privée de la PK existante.
**Pour inscrire les clés dans votre magasin de variables UEFI**
Les commandes suivantes doivent être exécutées sur l’instance.
Si cette option SetupMode est activée (la valeur est`1`), les clés peuvent être inscrites en exécutant les commandes suivantes sur l'instance :
```
[ec2-user ~]$ efi-updatevar -f db.auth db
```
```
[ec2-user ~]$ efi-updatevar -f KEK.auth KEK
```
```
[ec2-user ~]$ efi-updatevar -f PK.auth PK
```
**Pour vérifier que UEFI Secure Boot est activé**
Pour vérifier que le démarrage sécurisé de UEFI est activé, suivez les étapes de la section [Vérifiez si une instance Amazon EC2 est activée pour le démarrage sécurisé de l’UEFI](verify-uefi-secure-boot.md).
Vous pouvez désormais exporter votre magasin de variables UEFI avec la commande CLI [https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html), ou vous pouvez passer à l’étape suivante et signez vos images de démarrage pour redémarrer dans une instance compatible avec UEFI Secure Boot.
### Étape 3 : créer une AMI à partir de l’instance
Pour créer une AMI à partir de l'instance, vous pouvez utiliser la console ou l'`CreateImage`API, la CLI ou SDKs. Pour des instructions sur l’utilisation de la console, consultez [Créer une AMI basée sur Amazon EBS](creating-an-ami-ebs.md). Pour les instructions relatives à l'API, consultez [CreateImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateImage.html).
**Note**
L’API `CreateImage` copie automatiquement le magasin de variables UEFI de l’instance vers l’AMI. La console utilise l’API `CreateImage`. Une fois que vous lancez des instances à l’aide de cette AMI, elles auront le même magasin de variables UEFI.
## Tâche 2 – Option B : création d’un blob binaire contenant un magasin de variables prérempli
Une fois que vous avez créé les [trois paires de clés](#uefi-secure-boot-create-three-key-pairs), vous pouvez créer un blob binaire contenant un magasin de variables prérempli contenant les clés Secure Boot UEFI. Vous pouvez également suivre les étapes décrites dans [Tâche 2 – Option A : ajout de clés au magasin de variables depuis l’instance](#uefi-secure-boot-optionA).
**Avertissement**
Vous devez signer vos images de démarrage *avant* d’inscrire les clés, sinon vous ne pourrez pas démarrer votre instance.
**Topics**
+ [Étape 1 : créer un nouveau magasin de variables ou mettre à jour un stockage existant](#uefi-secure-boot-create-or-update-variable)
+ [Étape 2 : charger le blob binaire lors de la création d’AMI](#uefi-secure-boot-upload-binary-blob-on-ami-creation)
### Étape 1 : créer un nouveau magasin de variables ou mettre à jour un stockage existant
Vous pouvez créer le magasin de variables *hors ligne* sans instance en cours d’exécution à l’aide de l’outil python-uefivars. L’outil peut créer un nouveau magasin de variables à partir de vos clés. Le script prend actuellement en charge le EDK2 format, le AWS format et une représentation JSON qui est plus facile à modifier avec des outils de niveau supérieur.
**Pour créer le magasin de variables hors ligne sans instance en cours d’exécution**
1. Téléchargez l’outil en cliquant sur le lien suivant.
```
https://github.com/awslabs/python-uefivars
```
1. Créez un nouveau magasin de variables à partir de vos clés en exécutant la commande suivante. Cela créera un blob binaire codé en base64 dans .bin. *your\$1binary\$1blob* L’outil prend également en charge la mise à jour d’un blob binaire via le paramètre `-I`.
```
./uefivars.py -i none -o aws -O your_binary_blob.bin -P PK.esl -K KEK.esl --db db.esl --dbx dbx.esl
```
### Étape 2 : charger le blob binaire lors de la création d’AMI
Utilisez [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) pour transmettre vos données de magasin de variables UEFI. Pour le paramètre `--uefi-data`, spécifiez votre blob binaire et pour le paramètre `--boot-mode`, spécifiez `uefi`.
```
aws ec2 register-image \
--name uefi_sb_tpm_register_image_test \
--uefi-data $(cat your_binary_blob.bin) \
--block-device-mappings "DeviceName=/dev/sda1,Ebs= {SnapshotId=snap-0123456789example,DeleteOnTermination=true}" \
--architecture x86_64 \
--root-device-name /dev/sda1 \
--virtualization-type hvm \
--ena-support \
--boot-mode uefi
```
# Créez le blob AWS binaire pour UEFI Secure Boot
Vous pouvez utiliser les étapes suivantes pour personnaliser les variables Secure Boot UEFI lors de la création de l’AMI. La KEK utilisée dans ces étapes est en date de septembre 2021. Si Microsoft met à jour la KEK, vous devez utiliser la KEK la plus récente.
**Pour créer le AWS blob binaire**
1. Créez une liste de signatures PK vide.
```
touch empty_key.crt
cert-to-efi-sig-list empty_key.crt PK.esl
```
1. Téléchargez les certificats KEK.
```
https://go.microsoft.com/fwlink/?LinkId=321185
```
1. Enveloppez les certificats KEK dans une liste de signatures UEFI (`siglist`).
```
sbsiglist --owner 77fa9abd-0359-4d32-bd60-28f4e78f784b --type x509 --output MS_Win_KEK.esl MicCorKEKCA2011_2011-06-24.crt
```
1. Téléchargez les certificats db de Microsoft.
```
https://www.microsoft.com/pkiops/certs/MicWinProPCA2011_2011-10-19.crt
https://www.microsoft.com/pkiops/certs/MicCorUEFCA2011_2011-06-27.crt
```
1. Générez la liste de signatures db.
```
sbsiglist --owner 77fa9abd-0359-4d32-bd60-28f4e78f784b --type x509 --output MS_Win_db.esl MicWinProPCA2011_2011-10-19.crt
sbsiglist --owner 77fa9abd-0359-4d32-bd60-28f4e78f784b --type x509 --output MS_UEFI_db.esl MicCorUEFCA2011_2011-06-27.crt
cat MS_Win_db.esl MS_UEFI_db.esl > MS_db.esl
```
1. Le forum Unified Extensible Firmware Interface ne fournit plus les fichiers DBX. Ils sont désormais fournis par Microsoft le GitHub. Téléchargez la dernière mise à jour DBX depuis le référentiel de mises à jour Microsoft Secure Boot à l'adresse [https://github.com/microsoft/secureboot\$1objects](https://github.com/microsoft/secureboot_objects).
1. Décompressez le binaire de mise à jour signé.
Créez `SplitDbxContent.ps1` à l’aide du contenu du script ci-dessous. Vous pouvez également installer le script depuis [PowerShell Gallery](https://www.powershellgallery.com/packages/SplitDbxContent/1.0) à l'aide de`Install-Script -Name SplitDbxContent`.
```
<#PSScriptInfo
.VERSION 1.0
.GUID ec45a3fc-5e87-4d90-b55e-bdea083f732d
.AUTHOR Microsoft Secure Boot Team
.COMPANYNAME Microsoft
.COPYRIGHT Microsoft
.TAGS Windows Security
.LICENSEURI
.PROJECTURI
.ICONURI
.EXTERNALMODULEDEPENDENCIES
.REQUIREDSCRIPTS
.EXTERNALSCRIPTDEPENDENCIES
.RELEASENOTES
Version 1.0: Original published version.
#>
<#
.DESCRIPTION
Splits a DBX update package into the new DBX variable contents and the signature authorizing the change.
To apply an update using the output files of this script, try:
Set-SecureBootUefi -Name dbx -ContentFilePath .\content.bin -SignedFilePath .\signature.p7 -Time 2010-03-06T19:17:21Z -AppendWrite'
.EXAMPLE
.\SplitDbxAuthInfo.ps1 DbxUpdate_x64.bin
#>
# Get file from script input
$file = Get-Content -Encoding Byte $args[0]
# Identify file signature
$chop = $file[40..($file.Length - 1)]
if (($chop[0] -ne 0x30) -or ($chop[1] -ne 0x82 )) {
Write-Error "Cannot find signature"
exit 1
}
# Signature is known to be ASN size plus header of 4 bytes
$sig_length = ($chop[2] * 256) + $chop[3] + 4
$sig = $chop[0..($sig_length - 1)]
if ($sig_length -gt ($file.Length + 40)) {
Write-Error "Signature longer than file size!"
exit 1
}
# Content is everything else
$content = $file[0..39] + $chop[$sig_length..($chop.Length - 1)]
# Write signature and content to files
Set-Content -Encoding Byte signature.p7 $sig
Set-Content -Encoding Byte content.bin $content
```
Utilisez le script pour décompresser les fichiers DBX signés.
```
PS C:\Windows\system32> SplitDbxContent.ps1 .\dbx.bin
```
Cela produit deux fichiers : `signature.p7` et `content.bin`. Utilisez `content.bin` à l’étape suivante.
1. Créez un magasin de variables UEFI à l’aide du script `uefivars.py`.
```
./uefivars.py -i none -o aws -O uefiblob-microsoft-keys-empty-pk.bin -P ~/PK.esl -K ~/MS_Win_KEK.esl --db ~/MS_db.esl --dbx ~/content.bin
```
1. Vérifiez le blob binaire et le magasin de variables UEFI.
```
./uefivars.py -i aws -I uefiblob-microsoft-keys-empty-pk.bin -o json | less
```
1. Vous pouvez mettre à jour le blob en le transmettant à nouveau au même outil.
```
./uefivars.py -i aws -I uefiblob-microsoft-keys-empty-pk.bin -o aws -O uefiblob-microsoft-keys-empty-pk.bin -P ~/PK.esl -K ~/MS_Win_KEK.esl --db ~/MS_db.esl --dbx ~/content.bin
```
Sortie attendue
```
Replacing PK
Replacing KEK
Replacing db
Replacing dbx
```