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. # AWS CloudHSM SSL/TLS décharger sur Linux à l'aide de NGINX ou HAProxy avec le fournisseur OpenSSL Cette rubrique fournit des instructions détaillées pour configurer le déchargement de l'identité SSL/TLS du serveur AWS CloudHSM sur un serveur Web Linux à l'aide de NGINX ou de HAProxy avec le fournisseur OpenSSL. **Topics** + [Présentation de](#ssl-offload-linux-openssl-provider-overview) + [Étape 1 : Configurer les prérequis](#ssl-offload-provider-prerequisites) + [Étape 2 : Générez ou importez une clé privée et obtenez un certificat](#ssl-offload-provider-generate-key-and-certificate) + [Étape 3 : Configurer le serveur web](#ssl-offload-provider-configure-web-server) + [Étape 4 : Activer le trafic HTTPS et vérifier le certificat](#ssl-offload-enable-traffic-and-verify-certificate-provider) ## Présentation de Sous Linux, les logiciels de serveur [ Web [ NGINX ](https://nginx.org/en/) et ](https://www.haproxy.org/) HAProxy s'intègrent à [https://www.openssl.org/](https://www.openssl.org/) OpenSSL pour prendre en charge le protocole HTTPS. Le fournisseur [AWS CloudHSM OpenSSL ](openssl-provider-library.md) fournit une interface qui permet au logiciel du serveur Web d'utiliser les HSM de votre cluster pour le déchargement cryptographique et le stockage des clés. Le fournisseur OpenSSL est le pont qui connecte le serveur Web à votre AWS CloudHSM cluster. Pour terminer ce didacticiel, vous allez configurer NGINX ou HAProxy pour utiliser le AWS CloudHSM fournisseur OpenSSL. Le didacticiel vous montre comment procéder comme suit : + Installez le logiciel du serveur web sur une instance Amazon EC2. + Configurez le logiciel du serveur Web pour qu'il prenne en charge le protocole HTTPS avec une clé privée stockée dans votre cluster AWS CloudHSM . + (Facultatif) Utilisez Amazon EC2 pour créer une deuxième instance de serveur Web et Elastic Load Balancing pour créer un équilibreur de charge. L'utilisation d'un équilibreur de charge peut accroître les performances en répartissant la charge sur plusieurs serveurs. Elle peut également assurer la redondance et une meilleure disponibilité en cas de défaillance d'un ou plusieurs serveurs. Lorsque vous êtes prêt à commencer, consultez [Étape 1 : Configurer les prérequis](#ssl-offload-provider-prerequisites). ## Étape 1 : Configurer les prérequis Les différentes plateformes ont des prérequis différents. Utilisez la section des prérequis ci-dessous qui correspond à votre plateforme. ### Prérequis pour AWS CloudHSM Fournisseur OpenSSL Pour configurer le déchargement de l'identité SSL/TLS du serveur Web avec AWS CloudHSM OpenSSL Provider for Client SDK 5, vous devez disposer des éléments suivants : + Un AWS CloudHSM cluster actif avec au moins deux modules de sécurité matériels (HSM) **Note** Vous pouvez utiliser un seul cluster HSM, mais vous devez d'abord désactiver la durabilité des clés client. Pour plus d'informations, voir [Gérer les paramètres de durabilité des clés client](working-client-sync.md#client-sync-sdk8) et [Outil de configuration du SDK client 5](configure-sdk-5.md). + Une instance Amazon EC2 exécutant un système d'exploitation Linux avec les logiciels suivants installés : + Un serveur Web (NGINX ou HAProxy) + Le fournisseur AWS CloudHSM OpenSSL pour le SDK client 5 + Un [utilisateur de chiffrement](understanding-users.md#crypto-user-chsm-cli) (CU) propriétaire et gestionnaire de la clé privée du serveur web sur le HSM. **Pour configurer une instance de serveur web Linux et créer un utilisateur de chiffrement sur le HSM** **Note** La plupart des commandes de cette procédure nécessitent des privilèges élevés. Selon la configuration de votre système, vous devrez peut-être exécuter des commandes avec `sudo` ou en tant qu'utilisateur root. 1. Installez et configurez le fournisseur AWS CloudHSM OpenSSL pour le SDK client 5. Pour plus d'informations sur l'installation du fournisseur OpenSSL, consultez la section [AWS CloudHSM OpenSSL Provider for Client SDK 5. ](openssl-provider-install.md) 1. Sur une instance Linux EC2 ayant accès à votre cluster, installez le serveur Web NGINX ou HAProxy : ------ #### [ Amazon Linux 2023 ] + NGINX ``` $ yum install nginx ``` + HAProxy ``` $ yum install haproxy ``` ------ #### [ RHEL 9 (9.2\+) ] + NGINX ``` $ yum install nginx ``` + HAProxy ``` $ yum install haproxy ``` ------ #### [ RHEL 10 (10.0\+) ] + NGINX ``` $ yum install nginx ``` + HAProxy ``` $ yum install haproxy ``` ------ #### [ Ubuntu 26.04 LTS ] + NGINX ``` $ apt install nginx ``` + HAProxy ``` $ apt install haproxy ``` ------ 1. Utilisez l'interface de ligne de commande CloudHSM pour créer un utilisateur de [ chiffrement. ](understanding-users.md#crypto-user-chsm-cli) Pour plus d'informations sur la gestion des utilisateurs HSM, consultez la section [Gestion des utilisateurs HSM avec la CLI CloudHSM](manage-hsm-users-chsm-cli.md). **Astuce** Conservez le nom d'utilisateur et le mot de passe du CU. Vous en aurez besoin plus tard pour générer ou importer la clé privée HTTPS et le certificat de votre serveur web. Une fois que vous avez terminé ces étapes, consultez [Étape 2 : Générez ou importez une clé privée et obtenez un certificat](#ssl-offload-provider-generate-key-and-certificate). #### Remarques + Pour utiliser Security-Enhanced Linux (SELinux) et des serveurs Web, vous devez autoriser les connexions TCP sortantes sur le port 2223, qui est le port que Client SDK 5 utilise pour communiquer avec le HSM. + Pour créer et activer un cluster et donner à une instance EC2 l'accès au cluster, suivez les étapes décrites dans [Démarrer avec AWS CloudHSM](getting-started.md). Le guide de démarrage propose des instructions étape par étape pour créer un cluster actif avec un HSM et une instance client Amazon EC2. Vous pouvez utiliser cette instance client comme serveur web. + Pour éviter de désactiver la durabilité des clés client, ajoutez plusieurs HSM à votre cluster. Pour de plus amples informations, veuillez consulter [Ajouter un HSM à un AWS CloudHSM cluster](add-hsm.md). + Vous pouvez utiliser un SSH ou PuTTY pour vous connecter à votre instance client. Pour plus d'informations, consultez [Connexion à votre instance Linux à l'aide de SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) ou [Connexion à votre instance Linux à partir de Windows à l'aide de PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) dans la documentation Amazon EC2. ## Étape 2 : Générez ou importez une clé privée et obtenez un certificat Pour activer le protocole HTTPS, votre application de serveur Web (NGINX ou HAProxy) a besoin d'une clé privée et d'un certificat correspondant. SSL/TLS Pour utiliser le déchargement de l'identité SSL/TLS du serveur Web avec AWS CloudHSM, vous devez stocker la clé privée dans un HSM de votre AWS CloudHSM cluster. Vous allez d'abord générer une clé privée et l'utiliser pour créer une demande de signature de certificat (CSR). Vous exportez ensuite une * fausse clé privée PEM * depuis le HSM, qui est un fichier de clé privée au format PEM contenant une référence à la clé privée stockée sur le HSM (il ne s'agit pas de la véritable clé privée). Votre serveur Web utilise le faux fichier de clé privée PEM pour identifier la clé privée sur le HSM lors du déchargement de l'identité SSL/TLS du serveur. ### Générer une clé privée Cette section explique comment générer une paire de clés à l'aide de l'interface de ligne de commande [ CloudHSM. ](cloudhsm_cli.md) Une fois qu'une paire de clés est générée dans le HSM, vous pouvez l'exporter sous forme de faux fichier PEM et générer le certificat correspondant. **Installation et configuration de la CLI CloudHSM** 1. [Installez et configurez ](cloudhsm_cli-getting-started.md) la CLI CloudHSM. 1. Utilisez la commande suivante pour démarrer l'interface de ligne de commande CloudHSM. ``` $ /opt/cloudhsm/bin/cloudhsm-cli interactive ``` 1. Exécutez la commande suivante pour vous connecter au HSM. {{}}Remplacez-le par le nom d'utilisateur de votre cryptographe ``` aws-cloudhsm>login --username {{}} --role crypto-user ``` **Générer une clé privée** En fonction de votre cas d'utilisation, vous pouvez générer une paire de clés RSA ou EC. Vous pouvez également générer un Ed25519 ou une paire de ML-DSA clés à utiliser avec TLS 1.3. Effectuez l’une des actions suivantes : + Pour générer une clé privée RSA sur un HSM Utilisez la commande [`key generate-asymmetric-pair rsa`](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) pour générer une paire de clés RSA. Cet exemple génère une paire de clés RSA avec un module de 2048, un exposant public de 65537, une étiquette de clé publique de et une étiquette de clé privée de{{tls\_rsa\_pub}}. {{tls\_rsa\_private}} ``` aws-cloudhsm > key generate-asymmetric-pair rsa \ --public-exponent 65537 \ --modulus-size-bits 2048 \ --public-label tls_rsa_pub \ --private-label tls_rsa_private \ --private-attributes sign=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x0000000000280cc8", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "rsa", "label": "tls_rsa_pub", "id": "", "check-value": "0x01fe6e", "class": "public-key", "encrypt": true, "decrypt": false, "token": true, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 512, "public-exponent": "0x010001", "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7", "modulus-size-bits": 2048 } }, "private_key": { "key-reference": "0x0000000000280cc7", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "rsa", "label": "tls_rsa_private", "id": "", "check-value": "0x01fe6e", "class": "private-key", "encrypt": false, "decrypt": true, "token": true, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 1217, "public-exponent": "0x010001", "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7", "modulus-size-bits": 2048 } } } } ``` + Pour générer une clé privée EC sur un HSM Utilisez la commande [`key generate-asymmetric-pair ec`](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) pour générer une paire de clés EC. Cet exemple génère une paire de clés EC avec la `prime256v1` courbe (correspondant à la `NID_X9_62_prime256v1` courbe), une étiquette de clé publique de {{tls\_ec\_pub}} et une étiquette de clé privée de{{tls\_ec\_private}}. ``` aws-cloudhsm > key generate-asymmetric-pair ec \ --curve prime256v1 \ --public-label tls_ec_pub \ --private-label tls_ec_private \ --private-attributes sign=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x000000000012000b", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "session" }, "attributes": { "key-type": "ec", "label": "tls_ec_pub", "id": "", "check-value": "0xd7c1a7", "class": "public-key", "encrypt": false, "decrypt": false, "token": false, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 57, "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c", "curve": "secp224r1" } }, "private_key": { "key-reference": "0x000000000012000c", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "session" }, "attributes": { "key-type": "ec", "label": "tls_ec_private", "id": "", "check-value": "0xd7c1a7", "class": "private-key", "encrypt": false, "decrypt": false, "token": false, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 122, "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c", "curve": "secp224r1" } } } } ``` + Pour générer une clé privée Ed25519 sur un HSM **Disponibilité de Ed25519** Ed25519 n'est disponible que sur les clusters non FIPS. Ed25519 prend en charge TLS 1.3 uniquement. Utilisez la [`key generate-asymmetric-pair ec`](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) commande pour générer une paire de clés Ed25519. Cet exemple génère une paire de clés Ed25519 avec une étiquette de clé publique de {{tls\_ed25519\_pub}} et une étiquette de clé privée de. {{tls\_ed25519\_private}} ``` aws-cloudhsm > key generate-asymmetric-pair ec \ --curve ed25519 \ --public-label tls_ed25519_pub \ --private-label tls_ed25519_private \ --private-attributes sign=true \ --public-attributes verify=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x0000000000383931", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "key-quorum-values": { "manage-key-quorum-value": 0, "use-key-quorum-value": 0 }, "cluster-coverage": "full" }, "attributes": { "key-type": "ec", "label": "tls_ed25519_pub", "id": "0x", "check-value": "0x4cb1b1", "class": "public-key", "encrypt": false, "decrypt": false, "token": true, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": true, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 32, "ec-point": "0x302a300506032b6570032100c31f8a3695f571dda1658bc98e0591ab088c1a657b3199dd50c3956046ebbe75", "curve": "ed25519" } }, "private_key": { "key-reference": "0x0000000000382e60", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "key-quorum-values": { "manage-key-quorum-value": 0, "use-key-quorum-value": 0 }, "cluster-coverage": "full" }, "attributes": { "key-type": "ec", "label": "tls_ed25519_private", "id": "0x", "check-value": "0x4cb1b1", "class": "private-key", "encrypt": false, "decrypt": false, "token": true, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 48, "ec-point": "0x302a300506032b6570032100c31f8a3695f571dda1658bc98e0591ab088c1a657b3199dd50c3956046ebbe75", "curve": "ed25519" } } } } ``` + Pour générer une clé ML-DSA privée sur un HSM **ML-DSA disponibilité et exigences** ML-DSA est uniquement disponible sur les clusters non FIPS et nécessite OpenSSL 3.5 ou version ultérieure pour la création de CSR, la création de certificats et le déchargement TLS. ML-DSA prend en charge TLS 1.3 uniquement. Pour le déchargement ML-DSA TLS sur les plateformes Amazon Linux 2023 et RHEL, vous devrez peut-être activer la sous-politique de chiffrement post-quantique (PQ). Pour de plus amples informations, veuillez consulter [Problème : échec de la ML-DSA prise de contact TLS sur Amazon Linux 2023 et RHEL avec « aucun algorithme de signature partagé »](ki-openssl-provider-sdk.md#ki-openssl-provider-5). Utilisez la `key generate-asymmetric-pair ml-dsa` commande pour générer une paire de ML-DSA clés. Cet exemple génère une paire de ML-DSA-44 clés avec une étiquette de clé publique de {{tls\_mldsa44\_pub}} et une étiquette de clé privée de{{tls\_mldsa44\_private}}. Vous pouvez également utiliser `ML-DSA-65` ou `ML-DSA-87` pour des niveaux de sécurité plus élevés. ``` aws-cloudhsm > key generate-asymmetric-pair ml-dsa \ --mldsa-algorithm ML-DSA-44 \ --public-label tls_mldsa44_pub \ --private-label tls_mldsa44_private \ --private-attributes sign=true \ --public-attributes verify=true { "error_code": 0, "data": { "public_key": { "key-reference": "0x0000000000280cd2", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "ml-dsa", "label": "tls_mldsa44_pub", "id": "", "check-value": "0xd4e5f6", "class": "public-key", "encrypt": false, "decrypt": false, "token": true, "always-sensitive": false, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": false, "sign": false, "trusted": false, "unwrap": false, "verify": true, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 1312, "mldsa-algorithm": "ML-DSA-44" } }, "private_key": { "key-reference": "0x0000000000280cd3", "key-info": { "key-owners": [ { "username": "cu1", "key-coverage": "full" } ], "shared-users": [], "cluster-coverage": "full" }, "attributes": { "key-type": "ml-dsa", "label": "tls_mldsa44_private", "id": "", "check-value": "0xd4e5f6", "class": "private-key", "encrypt": false, "decrypt": false, "token": true, "always-sensitive": true, "derive": false, "destroyable": true, "extractable": true, "local": true, "modifiable": true, "never-extractable": false, "private": true, "sensitive": true, "sign": true, "trusted": false, "unwrap": false, "verify": false, "wrap": false, "wrap-with-trusted": false, "key-length-bytes": 2560, "mldsa-algorithm": "ML-DSA-44" } } } } ``` **Exporter un faux fichier de clé privée PEM** Une fois que vous avez une clé privée sur le HSM, vous devez exporter un faux fichier de clé privée PEM. Ce fichier ne contient pas les données de clé réelles, mais il permet au fournisseur OpenSSL d'identifier la clé privée sur le HSM. Vous pouvez ensuite utiliser la clé privée pour créer une demande de signature de certificat (CSR) et signer la CSR pour créer le certificat. Utilisez la [`key generate-file`](cloudhsm_cli-key-generate-file.md) commande pour exporter la clé privée au faux format PEM et l'enregistrer dans un fichier. Remplacez les valeurs suivantes par vos propres valeurs : + {{}}— Libellé de la clé privée que vous avez générée à l'étape précédente. + {{}}— Nom du fichier dans lequel votre fausse clé PEM sera écrite. Utilisez l'`reference-pem`encodage : ``` aws-cloudhsm > key generate-file --encoding reference-pem --path {{}} --filter attr.label={{}} { "error_code": 0, "data": { "message": "Successfully generated key file" } } ``` Utilisez l'`cloudhsm-reference-pem`encodage : ``` aws-cloudhsm > key generate-file --encoding cloudhsm-reference-pem --path {{}} --filter attr.label={{}} { "error_code": 0, "data": { "message": "Successfully generated key file" } } ``` **Quittez la CLI CloudHSM ** Exécutez la commande suivante pour arrêter la CLI CloudHSM. ``` aws-cloudhsm > quit ``` Vous devriez maintenant avoir un nouveau fichier sur votre système, situé au chemin indiqué {{}} dans la commande précédente. Ce fichier est le faux fichier de clé privée PEM. ### Générer un certificat signé automatiquement. Une fois que vous avez généré une fausse clé privée PEM, vous pouvez utiliser ce fichier pour générer une demande de signature de certificat (CSR) et un certificat. Dans un environnement de production, vous utilisez généralement une autorité de certification (CA) pour créer un certificat émis par une demande de signature de certificat (CSR). L'autorité de certification n'est pas nécessaire pour un environnement de test. Si vous utilisez une autorité de certification, envoyez-lui le fichier CSR et utilisez le SSL/TLS certificat signé qu'elle vous fournit sur votre serveur Web pour HTTPS. Au lieu d'utiliser une autorité de certification, vous pouvez utiliser le fournisseur AWS CloudHSM OpenSSL pour créer un certificat auto-signé. Self-signed les navigateurs ne font pas confiance aux certificats et ne doivent pas être utilisés dans les environnements de production. Ils peuvent cependant être utilisés dans les environnements de test. **Avertissement** Self-signed les certificats ne doivent être utilisés que dans un environnement de test. Pour un environnement de production, utilisez une méthode plus sécurisée telle qu'une autorité de certification pour créer un certificat. **Installation et configuration du fournisseur OpenSSL** 1. Connectez-vous à votre instance client . 1. [Installez le fournisseur OpenSSL pour AWS CloudHSM SDK client 5](openssl-provider-install.md) **Générez un certificat** 1. Obtenez une copie de votre faux fichier PEM généré lors d'une étape précédente. 1. Création d'une CSR Exécutez la commande suivante pour utiliser le fournisseur AWS CloudHSM OpenSSL afin de créer une demande de signature de certificat (CSR). {{}}Remplacez-le par le nom du fichier contenant votre fausse clé privée PEM. {{}}Remplacez-le par le nom du fichier contenant votre CSR. La commande `req` est interactive. Renseignez chaque champ. Les informations du champ sont copiées dans votre SSL/TLS certificat. **ML-DSA Configuration requise pour la version d'OpenSSL** ML-DSA nécessite OpenSSL 3.5 ou version ultérieure. Sur les plateformes dotées d'un ancien système OpenSSL, vous devez utiliser un binaire OpenSSL 3.5\+ personnalisé. **Algorithme Digest requis pour les clés RSA et EC** Pour les clés RSA et EC, vous devez spécifier un algorithme de synthèse (par exemple,`-sha256`). Ed25519 et ne nécessitent ML-DSA pas d'indicateur de résumé. ``` $ openssl req -provider cloudhsm -provider default -new -sha256 -key {{}} -out {{}} ``` 1. Créer un certificat auto-signé Exécutez la commande suivante pour utiliser le fournisseur AWS CloudHSM OpenSSL afin de signer votre CSR avec votre clé privée sur votre HSM. Cette opération crée un certificat auto-signé. Remplacez les valeurs suivantes par vos propres valeurs dans la commande : + {{}}— Nom du fichier contenant le CSR. + {{}}— Nom du fichier contenant la fausse clé privée PEM. + {{}}— Nom du fichier qui contiendra votre certificat de serveur Web. ``` $ openssl x509 -provider cloudhsm -provider default -req -sha256 -days 365 -in {{}} -signkey {{}} -out {{}} ``` Une fois que vous avez une clé privée et un certificat, accédez à[Étape 3 : Configurer le serveur web](#ssl-offload-provider-configure-web-server). ## Étape 3 : Configurer le serveur web Mettez à jour votre configuration de logiciel serveur web pour utiliser le certificat HTTPS et la fausse clé privée PEM correspondante que vous avez créée à l'[étape précédente](#ssl-offload-provider-generate-key-and-certificate). N'oubliez pas de sauvegarder vos certificats et clés existants avant de commencer. Cela terminera la configuration du logiciel de votre serveur Web Linux pour le déchargement de l'identité SSL/TLS du serveur avec AWS CloudHSM. Complétez les étapes de l'une des sections suivantes. **Topics** + [Configuration du serveur Web NGINX](#ssl-offload-provider-configure-nginx) + [Configuration du serveur Web HAProxy](#ssl-offload-provider-configure-haproxy) ### Configuration du serveur Web NGINX Utilisez cette section pour configurer NGINX avec le fournisseur OpenSSL. **Pour configurer NGINX pour le fournisseur OpenSSL** 1. Connectez-vous à votre instance client . 1. Exécutez la commande suivante pour créer les répertoires requis pour le certificat de serveur web et la fausse clé privée PEM. ``` $ mkdir -p /etc/pki/nginx/private ``` 1. Exécutez la commande suivante pour copier votre certificat de serveur web à l'emplacement requis. {{}}Remplacez-le par le nom de votre certificat de serveur Web. ``` $ cp {{}} /etc/pki/nginx/server.crt ``` 1. Exécutez la commande suivante pour copier votre fausse clé privée PEM à l'emplacement requis. {{}}Remplacez-le par le nom du fichier contenant votre fausse clé privée PEM. ``` $ cp {{}} /etc/pki/nginx/private/server.key ``` 1. Exécutez la commande suivante pour modifier la propriété des fichiers afin que l'utilisateur nommé *nginx* puisse les lire. ``` $ chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key ``` 1. Configurez OpenSSL pour utiliser le AWS CloudHSM fournisseur. Pour plus d'informations sur la configuration du fournisseur OpenSSL, consultez la section [AWS CloudHSM OpenSSL Provider for Client SDK 5. ](openssl-provider-install.md) 1. Localisez votre fichier de configuration OpenSSL : ``` $ openssl version -d ``` Vous devriez voir une sortie similaire à : ``` OPENSSLDIR: "/etc/pki/tls" ``` Le fichier de configuration se trouve `openssl.cnf` dans ce répertoire. 1. **Note** Ne modifiez pas directement le fichier openssl.cnf par défaut de votre système. Cela empêche les opérations OpenSSL à l'échelle du système (connexions SSH, TLS et autres services) d'être acheminées involontairement via le fournisseur CloudHSM. L'utilisation d'un fichier de configuration distinct vous permet de limiter l'utilisation du fournisseur CloudHSM à des applications spécifiques nécessitant des opérations HSM-backed cryptographiques uniquement. Créez un nouveau fichier de configuration OpenSSL avec le contenu suivant : ``` $ cat > {{}} << 'EOF' ## NOTE: This should point to the system default openssl config file. # Replace /etc/pki/tls with the path to your OpenSSL configuration directory .include {{}}/openssl.cnf # Override the existing provider_section to include AWS CloudHSM OpenSSL Provider as a 3rd party OpenSSL provider [provider_sect] default = default_sect # Include AWS CloudHSM CloudHSM OpenSSL provider cloudhsm = cloudhsm_sect [default_sect] activate = 1 [cloudhsm_sect] activate = 1 EOF ``` 1. Assurez-vous que la variable d'`CLOUDHSM_PIN`environnement est définie avec vos informations d'identification d'utilisateur crypté (CU) : ``` $ export CLOUDHSM_PIN={{}}:{{}} ``` 1. Définissez la variable d'`OPENSSL_CONF`environnement pour qu'elle pointe vers votre fichier de configuration mis à jour et vérifiez que le fournisseur est chargé : ``` $ OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers ``` Le fournisseur par défaut et le fournisseur CloudHSM devraient apparaître dans la liste : ``` OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers Providers: default name: OpenSSL Default Provider version: 3.2.2 status: active cloudhsm name: AWS CloudHSM OpenSSL Provider version: 5.17.0 status: active ``` 1. Exécutez la commande suivante pour sauvegarder le fichier `/etc/nginx/nginx.conf`. ``` $ cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup ``` 1. Mise à jour de la configuration pour NGINX. **Note** Chaque cluster peut prendre en charge un maximum de 1 000 processus de travail NGINX sur tous les serveurs Web NGINX. ------ #### [ Amazon Linux 2023 ] Utilisez un éditeur de texte pour modifier le fichier `/etc/nginx/nginx.conf`. Cela peut nécessiter des autorisations root sur Linux. En haut du fichier, ajoutez les lignes suivantes : ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Ensuite, ajoutez ce qui suit à la section TLS du fichier : ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 # ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ RHEL 9 (9.2\+) ] Utilisez un éditeur de texte pour modifier le fichier `/etc/nginx/nginx.conf`. Cela peut nécessiter des autorisations root sur Linux. En haut du fichier, ajoutez les lignes suivantes : ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Ensuite, ajoutez ce qui suit à la section TLS du fichier : ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 # ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ RHEL 10 (10.0\+) ] Utilisez un éditeur de texte pour modifier le fichier `/etc/nginx/nginx.conf`. Cela peut nécessiter des autorisations root sur Linux. En haut du fichier, ajoutez les lignes suivantes : ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Ensuite, ajoutez ce qui suit à la section TLS du fichier : ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /usr/share/nginx/html; ssl_certificate "/etc/pki/nginx/server.crt"; ssl_certificate_key "/etc/pki/nginx/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/pki/nginx/dhparams.pem 2048 # ssl_dhparam "/etc/pki/nginx/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ #### [ Ubuntu 26.04 LTS ] Utilisez un éditeur de texte pour modifier le fichier `/etc/nginx/nginx.conf`. Cela peut nécessiter des autorisations root sur Linux. En haut du fichier, ajoutez les lignes suivantes : ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Ensuite, ajoutez ce qui suit à la section TLS du fichier : ``` # Settings for a TLS enabled server. server { listen 443 ssl http2 default_server; listen [::]:443 ssl http2 default_server; server_name _; root /var/www/html; ssl_certificate "/etc/ssl/certs/server.crt"; ssl_certificate_key "/etc/ssl/private/server.key"; # It is *strongly* recommended to generate unique DH parameters for DHE ciphers # Generate them with: openssl dhparam -out /etc/ssl/certs/dhparams.pem 2048 # ssl_dhparam "/etc/ssl/certs/dhparams.pem"; ssl_session_cache shared:SSL:1m; ssl_session_timeout 10m; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256"; ssl_prefer_server_ciphers off; # Load configuration files for the default server block. include /etc/nginx/default.d/*.conf; location / { } error_page 404 /404.html; location = /40x.html { } error_page 500 502 503 504 /50x.html; location = /50x.html { } } ``` ------ Enregistrez le fichier. 1. Sauvegardez le fichier de configuration `systemd`, puis définissez le chemin d'accès à `EnvironmentFile`. ------ #### [ Amazon Linux 2023 ] 1. Sauvegardez le `nginx.service` fichier : ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Ouvrez `/lib/systemd/system/nginx.service` dans un éditeur de texte. Dans la section [Service], ajoutez : ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ RHEL 9 (9.2\+) ] 1. Sauvegardez le `nginx.service` fichier : ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Ouvrez `/lib/systemd/system/nginx.service` dans un éditeur de texte. Dans la section [Service], ajoutez : ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ RHEL 10 (10.0\+) ] 1. Sauvegardez le `nginx.service` fichier : ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Ouvrez `/lib/systemd/system/nginx.service` dans un éditeur de texte. Dans la section [Service], ajoutez : ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Ubuntu 26.04 LTS ] 1. Sauvegardez le `nginx.service` fichier : ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Ouvrez `/lib/systemd/system/nginx.service` dans un éditeur de texte. Dans la section [Service], ajoutez : ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ 1. Vérifiez si le fichier `/etc/sysconfig/nginx` existe, puis effectuez l'une des actions suivantes : + Si le fichier existe, sauvegardez le fichier en exécutant la commande suivante : ``` $ cp /etc/sysconfig/nginx /etc/sysconfig/nginx.backup ``` + Si le fichier n'existe pas, ouvrez un éditeur de texte et créez un fichier nommé `nginx` dans le dossier `/etc/sysconfig/`. 1. Configurez l'environnement NGINX. ------ #### [ Amazon Linux 2023 ] En tant qu'utilisateur root de Linux, ouvrez `/etc/sysconfig/nginx` le fichier dans un éditeur de texte. Par exemple, ``` vi /etc/sysconfig/nginx ``` Ajoutez les informations d'identification de l'utilisateur de chiffrement (CU) et le chemin d'accès à votre fichier de configuration OpenSSL : ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Remplacez {{}} et {{}} par les informations d'identification CU. {{}}Remplacez-le par le chemin complet du fichier de configuration que vous avez créé dans[Pour configurer NGINX pour le fournisseur OpenSSL](#configure-nginx-provider). Enregistrez le fichier. ------ #### [ RHEL 9 (9.2\+) ] Ouvrez le fichier `/etc/sysconfig/nginx` dans un éditeur de texte. Cela peut nécessiter des autorisations root sur Linux. Ajoutez les informations d'identification de l'utilisateur de chiffrement (CU) et le chemin d'accès à votre fichier de configuration OpenSSL : ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Remplacez {{}} et {{}} par les informations d'identification CU. {{}}Remplacez-le par le chemin complet du fichier de configuration que vous avez créé dans[Pour configurer NGINX pour le fournisseur OpenSSL](#configure-nginx-provider). Enregistrez le fichier. ------ #### [ RHEL 10 (10.0\+) ] Ouvrez le fichier `/etc/sysconfig/nginx` dans un éditeur de texte. Cela peut nécessiter des autorisations root sur Linux. Ajoutez les informations d'identification de l'utilisateur de chiffrement (CU) et le chemin d'accès à votre fichier de configuration OpenSSL : ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Remplacez {{}} et {{}} par les informations d'identification CU. {{}}Remplacez-le par le chemin complet du fichier de configuration que vous avez créé dans[Pour configurer NGINX pour le fournisseur OpenSSL](#configure-nginx-provider). Enregistrez le fichier. ------ #### [ Ubuntu 26.04 LTS ] Ouvrez le fichier `/etc/sysconfig/nginx` dans un éditeur de texte. Cela peut nécessiter des autorisations root sur Linux. Ajoutez les informations d'identification de l'utilisateur de chiffrement (CU) et le chemin d'accès à votre fichier de configuration OpenSSL : ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Remplacez {{}} et {{}} par les informations d'identification CU. {{}}Remplacez-le par le chemin complet du fichier de configuration que vous avez créé dans[Pour configurer NGINX pour le fournisseur OpenSSL](#configure-nginx-provider). Enregistrez le fichier. ------ 1. Démarrez le serveur web NGINX. ------ #### [ Amazon Linux 2023 ] Arrêtez tous les processus NGINX ``` $ systemctl stop nginx ``` Rechargez la configuration `systemd` pour récupérer les dernières modifications ``` $ systemctl daemon-reload ``` Démarrez NGINX ``` $ systemctl start nginx ``` ------ #### [ RHEL 9 (9.2\+) ] Arrêtez tout processus NGINX en cours d'exécution ``` $ systemctl stop nginx ``` Rechargez la configuration `systemd` pour récupérer les dernières modifications ``` $ systemctl daemon-reload ``` Démarrez le processus NGINX ``` $ systemctl start nginx ``` ------ #### [ RHEL 10 (10.0\+) ] Arrêtez tout processus NGINX en cours d'exécution ``` $ systemctl stop nginx ``` Rechargez la configuration `systemd` pour récupérer les dernières modifications ``` $ systemctl daemon-reload ``` Démarrez le processus NGINX ``` $ systemctl start nginx ``` ------ #### [ Ubuntu 26.04 LTS ] Arrêtez tout processus NGINX en cours d'exécution ``` $ systemctl stop nginx ``` Rechargez la configuration `systemd` pour récupérer les dernières modifications ``` $ systemctl daemon-reload ``` Démarrez le processus NGINX ``` $ systemctl start nginx ``` ------ Après avoir configuré NGINX, accédez à. [Vérification que le protocole HTTPS utilise le certificat que vous avez configuré](#ssl-offload-verify-https-connection-linux) ### Configuration du serveur Web HAProxy Utilisez cette section pour configurer HAProxy avec le fournisseur OpenSSL. Les exemples suivants montrent comment configurer HAProxy avec vos certificats et clés CloudHSM. **Pour configurer HAProxy pour le fournisseur OpenSSL** 1. Sauvegardez le fichier de certificat combiné existant s'il existe : ``` $ cp server-combined.pem server-combined.pem.backup ``` 1. Créez un fichier de certificat combiné pour HAProxy à l'aide de votre certificat et de la fausse clé PEM CloudHSM : ``` $ cat server.crt server.key > server-combined.pem ``` 1. Sauvegardez la configuration HAProxy existante : ``` $ cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.backup ``` 1. Créez une nouvelle configuration de déchargement CloudHSM TLS à l'adresse suivante : `/etc/haproxy/haproxy.cfg` ``` global daemon ssl-provider cloudhsm # It is *strongly* recommended to generate unique DH parameters # Generate them with: openssl dhparam -out /etc/haproxy/dhparams.pem 2048 # ssl-dh-param-file /etc/haproxy/dhparams.pem ssl-default-bind-ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305 ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256 ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets defaults mode http timeout connect 5000ms timeout client 50000ms timeout server 50000ms frontend haproxy_frontend bind *:443 ssl crt /path/to/server-combined.pem default_backend web_servers backend web_servers server web1 127.0.0.1:8080 check ``` Mettez à jour le chemin du certificat pour qu'il corresponde à l'emplacement de votre fichier. 1. Configurez systemd pour utiliser un fichier d'environnement pour HAProxy. L'emplacement dépend de votre distribution Linux. ------ #### [ Amazon Linux and RHEL ] Sauvegardez et modifiez le fichier de service HAProxy : ``` $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup ``` Modifiez `/lib/systemd/system/haproxy.service` et ajoutez la ligne suivante dans la section [Service] : ``` EnvironmentFile=/etc/sysconfig/haproxy ``` ------ #### [ Ubuntu ] Sauvegardez et modifiez le fichier de service HAProxy : ``` $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup ``` Modifiez `/lib/systemd/system/haproxy.service` et ajoutez la ligne suivante dans la section [Service] : ``` EnvironmentFile=/etc/default/haproxy ``` ------ 1. Créez le fichier d'environnement à l'emplacement approprié pour votre système. ------ #### [ Amazon Linux and RHEL ] Sauvegardez le fichier d'environnement HAProxy s'il existe : ``` $ cp /etc/sysconfig/haproxy /etc/sysconfig/haproxy.backup ``` Créez le fichier d'environnement HAProxy `/etc/sysconfig/haproxy` avec le contenu suivant : ``` CLOUDHSM_PIN={{}}:{{}} ``` ------ #### [ Ubuntu ] Sauvegardez le fichier d'environnement HAProxy s'il existe : ``` $ cp /etc/default/haproxy /etc/default/haproxy.backup ``` Créez le fichier d'environnement HAProxy `/etc/default/haproxy` avec le contenu suivant : ``` CLOUDHSM_PIN={{}}:{{}} ``` ------ Remplacez {{}} et {{}} par vos informations d'identification CU. 1. Rechargez la configuration de systemd : ``` $ systemctl daemon-reload ``` 1. Démarrez HAProxy avec la configuration de déchargement TLS de CloudHSM : ``` $ systemctl start haproxy ``` Vous pouvez également exécuter HAProxy directement à l'aide d'un fichier de configuration personnalisé : ``` $ haproxy -f /path/to/haproxy-cloudhsm.cfg ``` Après avoir configuré HAProxy, accédez à. [Vérification que le protocole HTTPS utilise le certificat que vous avez configuré](#ssl-offload-verify-https-connection-linux) ## Étape 4 : Activer le trafic HTTPS et vérifier le certificat Après avoir configuré votre serveur Web pour le SSL/TLS déchargement avec AWS CloudHSM, ajoutez votre instance de serveur Web à un groupe de sécurité qui autorise le trafic HTTPS entrant. Cela permet aux clients, tels que les navigateurs Web, d'établir une connexion HTTPS avec votre serveur Web. Établissez ensuite une connexion HTTPS à votre serveur Web et vérifiez qu'il utilise le certificat que vous avez configuré pour le SSL/TLS déchargement. AWS CloudHSM **Topics** + [Activation des connexions HTTPS entrantes](#ssl-offload-add-security-group-linux) + [Vérification que le protocole HTTPS utilise le certificat que vous avez configuré](#ssl-offload-verify-https-connection-linux) ### Activation des connexions HTTPS entrantes Pour vous connecter à votre serveur web à partir d'un client (par exemple, un navigateur web), créez un groupe de sécurité qui autorise les connexions HTTPS entrantes. En particulier, il doit autoriser les connexions TCP entrantes sur le port 443. Affectez ce groupe de sécurité à votre serveur web. **Pour créer un groupe de sécurité pour le protocole HTTPS et l'affecter à votre serveur web** 1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Choisissez **Groupes de sécurité** dans le panneau de navigation. 1. Sélectionnez **Create security group** (Créer un groupe de sécurité). 1. Pour **Créer un groupe de sécurité**, procédez comme suit : 1. Pour **Nom du groupe de sécurité**, tapez un nom pour le groupe de sécurité que vous créez. 1. (Facultatif) Tapez une description du groupe de sécurité que vous créez. 1. Pour **VPC**, choisissez le VPC qui contient votre instance de serveur web Amazon EC2. 1. Sélectionnez **Ajouter une règle**. 1. Pour **Type**, sélectionnez **HTTPS** dans la fenêtre déroulante. 1. Pour **Source**, entrez l'emplacement de la source. 1. Sélectionnez **Create security group** (Créer un groupe de sécurité). 1. Dans le panneau de navigation, choisissez **Instances**. 1. Cochez la case située en regard de votre instance de serveur web. 1. Choisissez le menu déroulant **Actions** en haut de la page. Sélectionnez **Sécurité**, puis **Modifier les groupes de sécurité**. 1. Pour **Groupes de sécurité associés**, veuillez consulter la zone de recherche, puis choisissez le groupe de sécurité que vous avez créé pour HTTPS. Ensuite, choisissez **Ajouter des groupes de sécurité**. 1. Cliquez sur **Enregistrer**. ### Vérification que le protocole HTTPS utilise le certificat que vous avez configuré Après avoir ajouté le serveur Web à un groupe de sécurité, vous pouvez vérifier que le SSL/TLS déchargement utilise votre certificat auto-signé. Vous pouvez faire cela à l'aide d'un navigateur web ou avec un outil tel qu'[OpenSSL s\_client](https://www.openssl.org/docs/manmaster/man1/s_client.html). **Pour vérifier le SSL/TLS déchargement à l'aide d'un navigateur Web** 1. Utilisez un navigateur web pour vous connecter à votre serveur web à l'aide du nom DNS public ou de l'adresse IP du serveur. Assurez-vous que l'URL de la barre d'adresse commence par https://. Par exemple,**https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/**. **Astuce** Vous pouvez utiliser un service DNS tel qu'Amazon Route 53 pour acheminer le nom de domaine de votre site Web (par exemplehttps://www.example.com/) vers votre serveur Web. Pour plus d'informations, consultez [Routage du trafic vers une instance Amazon EC2](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html)* dans le Guide du Développeur Amazon Route 53* ou dans la documentation de votre service DNS. 1. Utilisez votre navigateur web pour afficher le certificat de serveur web. Pour plus d’informations, consultez les ressources suivantes : + Pour Mozilla Firefox, consultez [View a Certificate](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) sur le site web de support Mozilla. + Pour Google Chrome, consultez [Understand Security Issues](https://developers.google.com/web/tools/chrome-devtools/security) sur les Outils Google pour site web des développeurs Google. D'autres navigateurs web peuvent avoir des fonctions similaires que vous pouvez utiliser pour afficher le certificat de serveur web. 1. Assurez-vous que le SSL/TLS certificat est celui que vous avez configuré pour utiliser votre serveur Web. **Pour vérifier le SSL/TLS déchargement avec OpenSSL s\_client** 1. Exécutez la commande OpenSSL suivante pour vous connecter à votre serveur web en utilisant le protocole HTTPS. {{}}Remplacez-le par le nom DNS public ou l'adresse IP de votre serveur Web. ``` openssl s_client -connect {{}}:443 ``` **Astuce** Vous pouvez utiliser un service DNS tel qu'Amazon Route 53 pour acheminer le nom de domaine de votre site Web (par exemplehttps://www.example.com/) vers votre serveur Web. Pour plus d'informations, consultez [Routage du trafic vers une instance Amazon EC2](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html)* dans le Guide du Développeur Amazon Route 53* ou dans la documentation de votre service DNS. 1. Assurez-vous que le SSL/TLS certificat est celui que vous avez configuré pour utiliser votre serveur Web. Vous disposez maintenant d'un site web sécurisé avec HTTPS. La clé privée du serveur Web est stockée dans un HSM de votre AWS CloudHSM cluster. Pour ajouter un équilibreur de charge, veuillez consulter [Ajoutez un équilibreur de charge avec Elastic Load Balancing pour AWS CloudHSM(facultatif)](third-offload-add-lb.md).