Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # AWS CloudHSM SSL/TLS offload su Linux utilizzando NGINX o HAProxy con OpenSSL Provider Questo argomento fornisce istruzioni dettagliate per configurare l'offload dell'identità del server AWS CloudHSM su un SSL/TLS server Web Linux utilizzando NGINX o HAProxy con il provider OpenSSL. **Topics** + [Panoramica di](#ssl-offload-linux-openssl-provider-overview) + [Fase 1: configurazione dei prerequisiti](#ssl-offload-provider-prerequisites) + [Fase 2: Generare o importare una chiave privata e ottenere un certificato](#ssl-offload-provider-generate-key-and-certificate) + [Fase 3: configurazione del server Web](#ssl-offload-provider-configure-web-server) + [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#ssl-offload-enable-traffic-and-verify-certificate-provider) ## Panoramica di Su Linux, il software del server web [ NGINX ](https://nginx.org/en/) e [ HAProxy si integra con OpenSSL per supportare HTTPS. ](https://www.haproxy.org/) [https://www.openssl.org/](https://www.openssl.org/) Il provider [AWS CloudHSM OpenSSL ](openssl-provider-library.md) fornisce un'interfaccia che consente al software del server Web di utilizzare gli HSM del cluster per l'offload crittografico e l'archiviazione delle chiavi. L'OpenSSL Provider è il bridge che collega il server web al cluster. AWS CloudHSM Per completare questo tutorial, configurerai NGINX o HAProxy per utilizzare il provider OpenSSL. AWS CloudHSM Il tutorial mostra come eseguire le seguenti operazioni: + Installa il software del server Web in un'istanza Amazon EC2. + Configura il software del server Web in modo tale che supporti HTTPS con una chiave privata archiviata nel cluster AWS CloudHSM . + (Facoltativo) Utilizza Amazon EC2 per creare una seconda istanza del server Web ed Elastic Load Balancing per creare un sistema di bilanciamento del carico. L'uso di un sistema di bilanciamento del carico può migliorare le prestazioni grazie alla distribuzione del carico in più server. Offre anche ridondanza e una disponibilità più elevata in caso di errore di uno o più server. Quando sei pronto per iniziare, vai a [Fase 1: configurazione dei prerequisiti](#ssl-offload-provider-prerequisites). ## Fase 1: configurazione dei prerequisiti Piattaforme diverse richiedono prerequisiti diversi. Utilizza la sezione sui prerequisiti riportata di seguito corrispondente alla tua piattaforma. ### Prerequisiti per AWS CloudHSM Provider OpenSSL Per configurare l'offload dell'identità del SSL/TLS server Web con AWS CloudHSM OpenSSL Provider for Client SDK 5, è necessario quanto segue: + Un AWS CloudHSM cluster attivo con almeno due moduli di sicurezza hardware (HSM) **Nota** È possibile utilizzare un singolo cluster HSM, ma bisogna prima disabilitare la durabilità delle chiavi del client. Per ulteriori informazioni, consulta la pagina sulla [gestione delle impostazioni di durabilità delle chiavi del client](working-client-sync.md#client-sync-sdk8) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md). + Un'istanza Amazon EC2 che esegue un sistema operativo Linux con il seguente software installato: + Un server web (NGINX o HAProxy) + Il provider AWS CloudHSM OpenSSL per Client SDK 5 + Un [utente di crittografia](understanding-users.md#crypto-user-chsm-cli) (CU) che sia proprietario e che gestisca la chiave privata del server Web sull'HSM. **Per configurare un'istanza del server Web Linux e creare un CU sull'HSM** **Nota** Molti dei comandi di questa procedura richiedono privilegi elevati. Potrebbe essere necessario eseguire comandi con `sudo` o come utente root a seconda della configurazione del sistema. 1. Installa e configura AWS CloudHSM OpenSSL Provider for Client SDK 5. Per ulteriori informazioni sull'installazione del provider OpenSSL, vedere [AWS CloudHSM OpenSSL Provider for Client SDK 5. ](openssl-provider-install.md) 1. Su un'istanza Linux EC2 che ha accesso al tuo cluster, installa il server web NGINX o 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. Usa CloudHSM CLI per creare un utente crittografico. [Crypto user (CU)](understanding-users.md#crypto-user-chsm-cli) Per ulteriori informazioni sulla gestione degli utenti HSM, consulta la pagina sulla [gestione degli utenti HSM con la CLI di CloudHSM](manage-hsm-users-chsm-cli.md). **Suggerimento** Prendere nota del nome utente e della password del CU, perché saranno necessari più avanti per creare o importare il certificato e la chiava privata HTTPS per il server Web. Dopo aver completato queste operazioni, andare su [Fase 2: Generare o importare una chiave privata e ottenere un certificato](#ssl-offload-provider-generate-key-and-certificate). #### Note + Per utilizzare Security-Enhanced Linux (SELinux) e i server web, è necessario consentire le connessioni TCP in uscita sulla porta 2223, che è la porta utilizzata da Client SDK 5 per comunicare con l'HSM. + Per creare e attivare un cluster e consentire a un'istanza EC2 di accedervi, completa la procedura descritta nella pagina [Nozioni di base su AWS CloudHSM](getting-started.md). La guida offre istruzioni dettagliate per la creazione di un cluster attivo con un HSM e un'istanza client Amazon EC2. È possibile utilizzare questa istanza client come server Web. + Per evitare di disabilitare la durabilità delle chiavi del client, aggiungi più di un HSM al cluster. Per ulteriori informazioni, consulta [Aggiungere un HSM a un AWS CloudHSM cluster](add-hsm.md). + È possibile utilizzare SSH o PuTTY per connettersi all'istanza del client. Per ulteriori informazioni, consulta le pagine [Connessione all'istanza Linux tramite SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) o [Connessione all'istanza Linux da Windows tramite PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html) nella documentazione Amazon EC2. ## Fase 2: Generare o importare una chiave privata e ottenere un certificato Per abilitare HTTPS, l'applicazione del server web (NGINX o HAProxy) necessita di una chiave privata e di un certificato corrispondente. SSL/TLS Per utilizzare l'offload dell'identità SSL/TLS del server Web con AWS CloudHSM, è necessario archiviare la chiave privata in un HSM nel cluster. AWS CloudHSM Dovrai prima generare una chiave privata e utilizzarla per creare una richiesta di firma del certificato (CSR). Quindi si esporta una chiave privata PEM * falsa * dall'HSM, che è un file di chiave privata in formato PEM che contiene un riferimento alla chiave privata memorizzata nell'HSM (non è la chiave privata effettiva). Il server web utilizza il file di chiave privata PEM falso per identificare la chiave privata sull'HSM durante l'offload dell'identità del server. SSL/TLS ### Generazione di una chiave privata Questa sezione mostra come generare una coppia di chiavi utilizzando l'interfaccia a riga di comando di CloudHSM. [AWS CloudHSM Interfaccia a riga di comando (CLI)](cloudhsm_cli.md) Una volta generata una coppia di chiavi all'interno dell'HSM, è possibile esportarla come file PEM falso e generare il certificato corrispondente. **Installa e configura l'interfaccia a riga di comando di CloudHSM** 1. [Installa e configura l'interfaccia a riga di comando di ](cloudhsm_cli-getting-started.md) CloudHSM. 1. Usa il seguente comando per avviare la CLI di CloudHSM. ``` $ /opt/cloudhsm/bin/cloudhsm-cli interactive ``` 1. Eseguire il comando seguente per accedere all'HSM. Sostituiscilo {{}} con il nome utente del tuo cripto-utente ``` aws-cloudhsm>login --username {{}} --role crypto-user ``` **Generazione di una chiave privata** A seconda del caso d'uso, è possibile generare una coppia di chiavi RSA o EC. Puoi anche generare un Ed25519 o una coppia di ML-DSA chiavi da utilizzare con TLS 1.3. Esegui una delle seguenti operazioni: + Come generare una chiave privata RSA su un HSM Utilizza il comando [`key generate-asymmetric-pair rsa`](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) per generare una coppia di chiavi RSA. Questo esempio genera una coppia di chiavi RSA con un modulo di 2048, un esponente pubblico di 65537, un'etichetta di chiave pubblica di e un'etichetta di chiave privata di. {{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 } } } } ``` + Come generare una chiave privata EC su un HSM Utilizza il comando [`key generate-asymmetric-pair ec`](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) per generare una coppia di chiavi EC. Questo esempio genera una coppia di chiavi EC con la `prime256v1` curva (corrispondente alla `NID_X9_62_prime256v1` curva), un'etichetta di chiave pubblica di e un'etichetta di {{tls\_ec\_pub}} chiave privata di. {{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" } } } } ``` + Per generare una chiave privata Ed25519 su un HSM **Disponibilità di Ed25519** Ed25519 è disponibile solo su cluster non FIPS. Ed25519 supporta solo TLS 1.3. Usa il [`key generate-asymmetric-pair ec`](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) comando per generare una coppia di chiavi Ed25519. Questo esempio genera una coppia di chiavi Ed25519 con un'etichetta di chiave pubblica {{tls\_ed25519\_pub}} e un'etichetta di chiave privata di. {{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" } } } } ``` + Per generare una chiave ML-DSA privata su un HSM **ML-DSA disponibilità e requisiti** ML-DSA è disponibile solo su cluster non FIPS e richiede OpenSSL 3.5 o successivo per la creazione di CSR, la creazione di certificati e l'offload TLS. ML-DSA supporta solo TLS 1.3. Per l'offload ML-DSA TLS sulle piattaforme Amazon Linux 2023 e RHEL, potrebbe essere necessario abilitare la sub-policy crittografica post-quantum (PQ). Per ulteriori informazioni, consulta [Problema: l'handshake ML-DSA TLS non riesce su Amazon Linux 2023 e RHEL senza «algoritmi di firma condivisi»](ki-openssl-provider-sdk.md#ki-openssl-provider-5). Usa il comando per generare una coppia di `key generate-asymmetric-pair ml-dsa` chiavi. ML-DSA Questo esempio genera una coppia di ML-DSA-44 chiavi con un'etichetta di chiave pubblica {{tls\_mldsa44\_pub}} e un'etichetta di chiave privata di{{tls\_mldsa44\_private}}. Puoi anche usare `ML-DSA-65` or `ML-DSA-87` per livelli di sicurezza più elevati. ``` 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" } } } } ``` **Esportazione di un file di chiave privata PEM falso** Una volta che disponi di una chiave privata nell'HSM, devi esportare un file di chiave privata PEM falso. Questo file non contiene i dati chiave effettivi, ma consente al provider OpenSSL di identificare la chiave privata sull'HSM. È quindi possibile utilizzare la chiave privata per creare una richiesta di firma del certificato (CSR) e firmare la CSR per creare il certificato. Usa il [`key generate-file`](cloudhsm_cli-key-generate-file.md) comando per esportare la chiave privata in un falso formato PEM e salvarla in un file. Sostituire i valori seguenti con i propri valori. + {{}}— Etichetta della chiave privata generata nel passaggio precedente. + {{}}— Nome del file in cui verrà scritta la tua chiave PEM falsa. Usa la `reference-pem` codifica: ``` aws-cloudhsm > key generate-file --encoding reference-pem --path {{}} --filter attr.label={{}} { "error_code": 0, "data": { "message": "Successfully generated key file" } } ``` Usa la codifica: `cloudhsm-reference-pem` ``` aws-cloudhsm > key generate-file --encoding cloudhsm-reference-pem --path {{}} --filter attr.label={{}} { "error_code": 0, "data": { "message": "Successfully generated key file" } } ``` **Uscire dalla CLI di CloudHSM ** Esegui il comando seguente per interrompere la CLI di CloudHSM. ``` aws-cloudhsm > quit ``` Ora dovresti avere un nuovo file sul tuo sistema, situato {{}} nel percorso specificato dal comando precedente. Questo file è il file della chiave privata PEM falsa. ### Generazione di un certificato auto-firmato Dopo aver generato una chiave privata PEM falsa, puoi utilizzare questo file per generare una richiesta di firma del certificato (CSR) e un certificato. In un ambiente di produzione, per creare un certificato da una CSR in genere ci si avvale di un'autorità di certificazione, che non è invece necessaria per un ambiente di test. Se utilizzate una CA, inviate loro il file CSR e utilizzate il SSL/TLS certificato firmato che vi forniscono nel vostro server web per HTTPS. In alternativa all'utilizzo di una CA, puoi utilizzare il provider AWS CloudHSM OpenSSL per creare un certificato autofirmato. Self-signed i certificati non sono considerati attendibili dai browser e non devono essere utilizzati negli ambienti di produzione. ma solo negli ambienti di test. **avvertimento** Self-signed i certificati devono essere utilizzati solo in un ambiente di test. Per un ambiente di produzione, è consigliabile utilizzare un metodo più sicuro, ad esempio un'autorità di certificazione per creare un certificato. **Installa e configura il provider OpenSSL** 1. Effettuare la connessione all'istanza del client. 1. [Installa il provider OpenSSL per AWS CloudHSM Client SDK 5](openssl-provider-install.md) **Generazione di un certificato** 1. Ottieni una copia del file PEM falso generato in un passaggio precedente. 1. Crea un CSR Esegui il comando seguente per utilizzare il provider AWS CloudHSM OpenSSL per creare una richiesta di firma del certificato (CSR). Sostituisci {{}} con il nome del file che contiene la tua falsa chiave privata PEM. Sostituisci {{}} con il nome del file che contiene la tua CSR. Il comando `req` è interattivo. Ogni campo deve essere compilato Le informazioni sul campo vengono copiate nel certificato. SSL/TLS **ML-DSA Requisito della versione di OpenSSL** ML-DSA richiede OpenSSL 3.5 o successivo. Sulle piattaforme con un sistema OpenSSL precedente, è necessario utilizzare un binario OpenSSL 3.5\+ personalizzato. **Algoritmo Digest richiesto per le chiavi RSA ed EC** Per le chiavi RSA ed EC, è necessario specificare un algoritmo di digest (ad esempio,). `-sha256` Ed25519 e non ML-DSA richiedono un flag digest. ``` $ openssl req -provider cloudhsm -provider default -new -sha256 -key {{}} -out {{}} ``` 1. Crea un certificato auto-firmato Esegui il seguente comando per utilizzare il provider AWS CloudHSM OpenSSL per firmare il tuo CSR con la tua chiave privata sul tuo HSM. In questo modo viene creato un certificato autofirmato. Sostituire i valori seguenti nel comando con i propri valori. + {{}}— Nome del file che contiene il CSR. + {{}}— Nome del file che contiene la falsa chiave privata PEM. + {{}}— Nome del file che conterrà il certificato del server web. ``` $ openssl x509 -provider cloudhsm -provider default -req -sha256 -days 365 -in {{}} -signkey {{}} -out {{}} ``` Dopo aver ottenuto la chiave privata e il certificato, vai a[Fase 3: configurazione del server Web](#ssl-offload-provider-configure-web-server). ## Fase 3: configurazione del server Web È possibile aggiornare la configurazione del software del server Web per utilizzare il certificato HTTPS e la chiave privata PEM fittizia corrispondente creata nella [fase precedente](#ssl-offload-provider-generate-key-and-certificate). Ricorda di eseguire il backup dei certificati e delle chiavi esistenti prima di iniziare. Questo completerà la configurazione del software del server Web Linux per l'offload dell'identità SSL/TLS del server con. AWS CloudHSM Completa la procedura delineata in una delle seguenti sezioni. **Topics** + [Configurazione del server Web NGINX](#ssl-offload-provider-configure-nginx) + [Configura il server web HAProxy](#ssl-offload-provider-configure-haproxy) ### Configurazione del server Web NGINX Usa questa sezione per configurare NGINX con il provider OpenSSL. **Per configurare NGINX per OpenSSL Provider** 1. Effettuare la connessione all'istanza del client. 1. Eseguire il comando seguente per creare le directory necessarie per il certificato del server Web e la falsa chiave privata PEM. ``` $ mkdir -p /etc/pki/nginx/private ``` 1. Eseguire il comando seguente per copiare il certificato del server Web nella posizione richiesta. Sostituiscilo {{}} con il nome del certificato del tuo server web. ``` $ cp {{}} /etc/pki/nginx/server.crt ``` 1. Eseguire il comando seguente per copiare la falsa chiave privata PEM nella posizione richiesta. Sostituiscilo {{}} con il nome del file che contiene la tua falsa chiave privata PEM. ``` $ cp {{}} /etc/pki/nginx/private/server.key ``` 1. Eseguire il comando seguente per modificare la proprietà dei file in modo che l'utente denominato *nginx* possa leggerli. ``` $ chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key ``` 1. Configura OpenSSL per utilizzare il provider. AWS CloudHSM Per ulteriori informazioni sulla configurazione del provider OpenSSL, vedere [AWS CloudHSM OpenSSL Provider for Client SDK 5. ](openssl-provider-install.md) 1. Individua il tuo file di configurazione OpenSSL: ``` $ openssl version -d ``` Dovresti vedere un risultato simile a: ``` OPENSSLDIR: "/etc/pki/tls" ``` Il file di configurazione si trova `openssl.cnf` in questa directory. 1. **Nota** Non modificate direttamente il file openssl.cnf predefinito del sistema. Ciò impedisce che le operazioni OpenSSL a livello di sistema (SSH, connessioni TLS e altri servizi) vengano instradate involontariamente attraverso il provider CloudHSM. L'utilizzo di un file di configurazione separato consente di limitare l'utilizzo del provider CloudHSM solo ad applicazioni specifiche che richiedono operazioni di crittografia. HSM-backed Crea un nuovo file di configurazione OpenSSL con i seguenti contenuti: ``` $ 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. Assicurati che la variabile di `CLOUDHSM_PIN` ambiente sia impostata con le tue credenziali di utente crittografico (CU): ``` $ export CLOUDHSM_PIN={{}}:{{}} ``` 1. Imposta la variabile di `OPENSSL_CONF` ambiente in modo che punti al file di configurazione aggiornato e verifica che il provider sia caricato: ``` $ OPENSSL_CONF=/path/to/example-cloudhsm-openssl.cnf openssl list -providers ``` Dovresti vedere elencati sia il provider predefinito che il provider CloudHSM: ``` 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. Eseguire il comando seguente per effettuare il backup del file `/etc/nginx/nginx.conf`. ``` $ cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.backup ``` 1. Aggiornamento della configurazione per NGINX. **Nota** Ciascun cluster può supportare un massimo di 1000 processi di lavoro NGINX su tutti i server web NGINX. ------ #### [ Amazon Linux 2023 ] Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò potrebbe richiedere i permessi di root di Linux. All'inizio del file, aggiungi le seguenti righe: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Quindi aggiungi quanto segue alla sezione TLS del file: ``` # 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\+) ] Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò potrebbe richiedere i permessi di root per Linux. All'inizio del file, aggiungi le seguenti righe: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Quindi aggiungi quanto segue alla sezione TLS del file: ``` # 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\+) ] Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò potrebbe richiedere i permessi di root per Linux. All'inizio del file, aggiungi le seguenti righe: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Quindi aggiungi quanto segue alla sezione TLS del file: ``` # 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 ] Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò potrebbe richiedere i permessi di root per Linux. All'inizio del file, aggiungi le seguenti righe: ``` env CLOUDHSM_PIN; env OPENSSL_CONF; ``` Quindi aggiungi quanto segue alla sezione TLS del file: ``` # 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 { } } ``` ------ Salvare il file. 1. Eseguire il backup del file di configurazione `systemd`, quindi impostare il percorso `EnvironmentFile`. ------ #### [ Amazon Linux 2023 ] 1. Effettua il backup del `nginx.service` file: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Aprire `/lib/systemd/system/nginx.service` in un editor di testo. Nella sezione [Servizio], aggiungi: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ RHEL 9 (9.2\+) ] 1. Esegui il backup del `nginx.service` file: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Aprire `/lib/systemd/system/nginx.service` in un editor di testo. Nella sezione [Servizio], aggiungi: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ RHEL 10 (10.0\+) ] 1. Esegui il backup del `nginx.service` file: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Aprire `/lib/systemd/system/nginx.service` in un editor di testo. Nella sezione [Servizio], aggiungi: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ #### [ Ubuntu 26.04 LTS ] 1. Esegui il backup del `nginx.service` file: ``` $ cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup ``` 1. Aprire `/lib/systemd/system/nginx.service` in un editor di testo. Nella sezione [Servizio], aggiungi: ``` EnvironmentFile=/etc/sysconfig/nginx ``` ------ 1. Controllare se il file `/etc/sysconfig/nginx` esiste, quindi eseguire una delle operazioni seguenti: + Se il file esiste, effettuare il backup del file eseguendo il seguente comando: ``` $ cp /etc/sysconfig/nginx /etc/sysconfig/nginx.backup ``` + In caso contrario, aprire un editor di testo, quindi creare un file denominato `nginx` nella cartella `/etc/sysconfig/`. 1. Configura l'ambiente NGINX. ------ #### [ Amazon Linux 2023 ] Come utente root di Linux, apri `/etc/sysconfig/nginx` il file in un editor di testo. Ad esempio, ``` vi /etc/sysconfig/nginx ``` Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL: ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Sostituisci {{}} e {{}} con le credenziali CU. Sostituisci {{}} con il percorso completo del file di configurazione in cui hai creato. [Per configurare NGINX per OpenSSL Provider](#configure-nginx-provider) Salvare il file. ------ #### [ RHEL 9 (9.2\+) ] Apri il file `/etc/sysconfig/nginx` in un editor di testo. Ciò potrebbe richiedere i permessi di root di Linux. Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL: ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Sostituisci {{}} e {{}} con le credenziali CU. Sostituisci {{}} con il percorso completo del file di configurazione in cui hai creato. [Per configurare NGINX per OpenSSL Provider](#configure-nginx-provider) Salvare il file. ------ #### [ RHEL 10 (10.0\+) ] Apri il file `/etc/sysconfig/nginx` in un editor di testo. Ciò potrebbe richiedere i permessi di root di Linux. Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL: ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Sostituisci {{}} e {{}} con le credenziali CU. Sostituisci {{}} con il percorso completo del file di configurazione in cui hai creato. [Per configurare NGINX per OpenSSL Provider](#configure-nginx-provider) Salvare il file. ------ #### [ Ubuntu 26.04 LTS ] Apri il file `/etc/sysconfig/nginx` in un editor di testo. Ciò potrebbe richiedere i permessi di root di Linux. Aggiungi le credenziali Cryptography User (CU) e il percorso del tuo file di configurazione OpenSSL: ``` CLOUDHSM_PIN={{}}:{{}} OPENSSL_CONF={{}} ``` Sostituisci {{}} e {{}} con le credenziali CU. Sostituisci {{}} con il percorso completo del file di configurazione in cui hai creato. [Per configurare NGINX per OpenSSL Provider](#configure-nginx-provider) Salvare il file. ------ 1. Avviare il server Web NGINX. ------ #### [ Amazon Linux 2023 ] Arresta tutti i processi NGINX ``` $ systemctl stop nginx ``` Ricarica la configurazione `systemd` per implementare le modifiche più recenti ``` $ systemctl daemon-reload ``` Avvia NGINX ``` $ systemctl start nginx ``` ------ #### [ RHEL 9 (9.2\+) ] Interrompi qualsiasi processo NGINX in esecuzione ``` $ systemctl stop nginx ``` Ricarica la configurazione `systemd` per implementare le modifiche più recenti ``` $ systemctl daemon-reload ``` Avvia il processo NGINX ``` $ systemctl start nginx ``` ------ #### [ RHEL 10 (10.0\+) ] Interrompi qualsiasi processo NGINX in esecuzione ``` $ systemctl stop nginx ``` Ricarica la configurazione `systemd` per implementare le modifiche più recenti ``` $ systemctl daemon-reload ``` Avvia il processo NGINX ``` $ systemctl start nginx ``` ------ #### [ Ubuntu 26.04 LTS ] Interrompi qualsiasi processo NGINX in esecuzione ``` $ systemctl stop nginx ``` Ricarica la configurazione `systemd` per implementare le modifiche più recenti ``` $ systemctl daemon-reload ``` Avvia il processo NGINX ``` $ systemctl start nginx ``` ------ Dopo aver configurato NGINX, vai a. [Verifica dell'utilizzo da parte di HTTPS del certificato configurato](#ssl-offload-verify-https-connection-linux) ### Configura il server web HAProxy Usa questa sezione per configurare HAProxy con il provider OpenSSL. Gli esempi seguenti mostrano come configurare HAProxy con i certificati e le chiavi CloudHSM. **Per configurare HAProxy per OpenSSL Provider** 1. Esegui il backup del file di certificato combinato esistente, se esiste: ``` $ cp server-combined.pem server-combined.pem.backup ``` 1. Crea un file di certificato combinato per HAProxy utilizzando il certificato e la chiave PEM falsa di CloudHSM: ``` $ cat server.crt server.key > server-combined.pem ``` 1. Esegui il backup della configurazione HAProxy esistente: ``` $ cp /etc/haproxy/haproxy.cfg /etc/haproxy/haproxy.cfg.backup ``` 1. Crea una nuova configurazione di offload TLS di CloudHSM all'indirizzo: `/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 ``` Aggiorna il percorso del certificato in modo che corrisponda alla posizione del file. 1. Configura systemd per utilizzare un file di ambiente per HAProxy. La posizione dipende dalla tua distribuzione Linux. ------ #### [ Amazon Linux and RHEL ] Eseguire il backup e modificare il file di servizio HAProxy: ``` $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup ``` Modifica `/lib/systemd/system/haproxy.service` e aggiungi la riga seguente nella sezione [Servizio]: ``` EnvironmentFile=/etc/sysconfig/haproxy ``` ------ #### [ Ubuntu ] Eseguire il backup e modificare il file di servizio HAProxy: ``` $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup ``` Modifica `/lib/systemd/system/haproxy.service` e aggiungi la riga seguente nella sezione [Servizio]: ``` EnvironmentFile=/etc/default/haproxy ``` ------ 1. Crea il file di ambiente nella posizione appropriata per il tuo sistema. ------ #### [ Amazon Linux and RHEL ] Eseguite il backup del file di ambiente HAProxy, se presente: ``` $ cp /etc/sysconfig/haproxy /etc/sysconfig/haproxy.backup ``` Crea il file di ambiente HAProxy `/etc/sysconfig/haproxy` con i seguenti contenuti: ``` CLOUDHSM_PIN={{}}:{{}} ``` ------ #### [ Ubuntu ] Effettuare il backup del file di ambiente HAProxy, se presente: ``` $ cp /etc/default/haproxy /etc/default/haproxy.backup ``` Crea il file di ambiente HAProxy `/etc/default/haproxy` con i seguenti contenuti: ``` CLOUDHSM_PIN={{}}:{{}} ``` ------ Sostituisci {{}} e {{}} con le tue credenziali CU. 1. Ricarica la configurazione di systemd: ``` $ systemctl daemon-reload ``` 1. Avvia HAProxy con la configurazione di offload TLS di CloudHSM: ``` $ systemctl start haproxy ``` Puoi anche eseguire HAProxy direttamente con un file di configurazione personalizzato: ``` $ haproxy -f /path/to/haproxy-cloudhsm.cfg ``` Dopo aver configurato HAProxy, vai a. [Verifica dell'utilizzo da parte di HTTPS del certificato configurato](#ssl-offload-verify-https-connection-linux) ## Fase 4: abilitazione del traffico HTTPS e verifica del certificato Dopo aver configurato il server Web per l' SSL/TLS offload con AWS CloudHSM, aggiungete l'istanza del server Web a un gruppo di sicurezza che consenta il traffico HTTPS in entrata. Ciò consente ai client, come i browser Web, di stabilire una connessione HTTPS con il server Web. Quindi crea una connessione HTTPS al tuo server web e verifica che stia utilizzando il certificato con cui hai configurato l' SSL/TLS offload. AWS CloudHSM **Topics** + [Abilitazione delle connessioni HTTPS in entrata](#ssl-offload-add-security-group-linux) + [Verifica dell'utilizzo da parte di HTTPS del certificato configurato](#ssl-offload-verify-https-connection-linux) ### Abilitazione delle connessioni HTTPS in entrata Per connetterti al server Web da un client (ad esempio un browser Web), crea un gruppo di sicurezza che consenta le connessioni HTTPS in entrata. Nello specifico, deve consentire le connessioni TCP in entrata sulla porta 443. Assegna questo gruppo di sicurezza al tuo server Web. **Per creare un gruppo di sicurezza per HTTPS e assegnarlo al server Web** 1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/). 1. Seleziona **Gruppi di sicurezza** nel riquadro di navigazione. 1. Scegliere **Create Security Group** (Crea gruppo di sicurezza). 1. Per **Create Security Group (Crea un gruppo di sicurezza)**, procedere come segue: 1. Per **Security group name (Nome del gruppo di sicurezza)**, digitare un nome per il gruppo di sicurezza che si sta creando. 1. (Facoltativo) Digitare una descrizione del gruppo di sicurezza in fase di creazione. 1. Per **VPC**, scegli il VPC contenente l'istanza Amazon EC2 del server Web. 1. Seleziona **Aggiungi regola**. 1. Per **Tipo**, seleziona **HTTPS** dalla finestra a discesa. 1. Per **Origine**, inserisci una posizione di origine. 1. Scegliere **Create Security Group** (Crea gruppo di sicurezza). 1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**. 1. Seleziona la casella di controllo accanto all'istanza del server Web. 1. Seleziona il menu a discesa **Operazioni** nella parte superiore della pagina. Seleziona **Sicurezza**, quindi **Modifica gruppi di sicurezza**. 1. Per **Gruppi di sicurezza associati**, seleziona la casella di ricerca e scegli il gruppo di sicurezza creato per HTTPS. Quindi, scegli **Aggiungi i gruppi di sicurezza**. 1. Seleziona **Salva**. ### Verifica dell'utilizzo da parte di HTTPS del certificato configurato Dopo aver aggiunto il server web a un gruppo di sicurezza, puoi verificare che SSL/TLS offload stia utilizzando il tuo certificato autofirmato. Per farlo, puoi utilizzare un browser Web o uno strumento come [OpenSSL s\_client](https://www.openssl.org/docs/manmaster/man1/s_client.html). **Per verificare l' SSL/TLS offload con un browser web** 1. Utilizza un browser Web per connetterti al server Web utilizzando il nome DNS pubblico o l'indirizzo IP del server. Assicurati che l'URL nella barra degli indirizzi inizi con https://. Ad esempio,**https://ec2-52-14-212-67.us-east-2.compute.amazonaws.com/**. **Suggerimento** Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempiohttps://www.example.com/) al tuo server web. Per ulteriori informazioni, consulta la sezione [Routing del traffico a un'istanza Amazon EC2](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) nella *Guida per gli sviluppatori di Amazon Route 53* oppure nella documentazione del servizio DNS in uso. 1. Utilizza il browser Web per visualizzare il certificato del server Web. Per ulteriori informazioni, consulta gli argomenti seguenti: + Per Mozilla Firefox, consultare [ Visualizzare un certificato ](https://support.mozilla.org/en-US/kb/secure-website-certificate#w_view-a-certificate) sul sito Web di supporto di Mozilla. + Per Google Chrome, consulta la pagina [Understand Security Issues](https://developers.google.com/web/tools/chrome-devtools/security) sul sito Web di Google per sviluppatori. Altri browser Web potrebbero avere caratteristiche simili da utilizzare per visualizzare il certificato del server Web. 1. Assicurati che il SSL/TLS certificato sia quello per cui hai configurato il tuo server web. **Per verificare l' SSL/TLS offload con OpenSSL s\_client** 1. Esegui il seguente comando OpenSSL per connetterti al server Web tramite HTTPS. Sostituiscilo {{}} con il nome DNS pubblico o l'indirizzo IP del tuo server web. ``` openssl s_client -connect {{}}:443 ``` **Suggerimento** Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempiohttps://www.example.com/) al tuo server web. Per ulteriori informazioni, consulta la sezione [Routing del traffico a un'istanza Amazon EC2](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-ec2-instance.html) nella *Guida per gli sviluppatori di Amazon Route 53* oppure nella documentazione del servizio DNS in uso. 1. Assicurati che il SSL/TLS certificato sia quello per cui hai configurato il tuo server web. A questo punto disponi di un sito Web protetto con HTTPS. La chiave privata per il server Web è archiviata in un HSM nel AWS CloudHSM cluster. Per aggiungere un sistema di bilanciamento del carico, consulta la pagina [Aggiungi un sistema di bilanciamento del carico con Elastic Load Balancing AWS CloudHSM per (opzionale)](third-offload-add-lb.md).