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à.

# Migliora la sicurezza del tuo server web con SSL/TLS offload in AWS CloudHSM
<a name="ssl-offload"></a>

I server Web e i relativi client (browser Web) possono utilizzare i protocolli Secure Sockets Layer (SSL) o Transport Layer Security (TLS) per confermare l'identità del server Web e stabilire una connessione sicura che invia e riceve pagine Web o altri dati su Internet. Questo protocollo è comunemente noto come HTTPS. Il server Web utilizza una coppia di chiavi pubblica-privata e un certificato di chiave SSL/TLS pubblica per stabilire una sessione HTTPS con ciascun client. Questo processo comporta molte operazioni di calcolo per i server Web, ma è possibile trasferirle in parte al AWS CloudHSM cluster, operazione denominata accelerazione SSL. L'offloading riduce il carico di calcolo sui server Web e offre una maggiore sicurezza archiviando le chiavi private dei server. HSMs

I seguenti argomenti forniscono una panoramica del AWS CloudHSM funzionamento di SSL/TLS offload with e dei tutorial per la configurazione SSL/TLS di offload with sulle seguenti piattaforme. AWS CloudHSM 

Per **Linux**, utilizza OpenSSL Dynamic Engine sul software dei server Web [NGINX](https://nginx.org/en/) o [Apache HTTP Server](https://httpd.apache.org/)

Per **Windows**, utilizza il software del server Web [Internet Information Services (IIS) for Windows Server](https://www.iis.net/)

**Topics**
+ [Come funziona SSL/TLS offload with AWS CloudHSM](ssl-offload-overview.md)
+ [AWS CloudHSM Offload SSL/TLS su Linux usando NGINX o Apache con OpenSSL](third-offload-linux-openssl.md)
+ [AWS CloudHSM Offload SSL/TLS su Linux utilizzando NGINX o con OpenSSL Provider HAProxy](third-offload-linux-openssl-provider.md)
+ [AWS CloudHSM Offload SSL/TLS su Linux utilizzando Tomcat con JSSE](third-offload-linux-jsse.md)
+ [AWS CloudHSM Offload SSL/TLS su Windows tramite IIS con KSP](ssl-offload-windows.md)
+ [Aggiungi un sistema di bilanciamento del carico con Elastic Load Balancing AWS CloudHSM per (opzionale)](third-offload-add-lb.md)

# Come funziona SSL/TLS offload with AWS CloudHSM
<a name="ssl-offload-overview"></a>

Per stabilire una connessione HTTPS, il server Web esegue un processo di handshake con i client. Come parte di questo processo, il server trasferisce parte dell'elaborazione crittografica all'HSMs interno del AWS CloudHSM cluster, come illustrato nella figura seguente. I singoli passaggi del processo sono illustrati sotto la figura. 

**Nota**  
L'immagine e il processo seguenti presuppongono l'uso dello standard RSA per la verifica del server e lo scambio delle chiavi. Il processo è leggermente diverso quando si usa il protocollo Diffie-Hellman anziché RSA. 

![\[Illustrazione del processo di handshake TLS tra client e server, incluso l'offload crittografico in un modulo HSM.\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/images/ssl-offload-handshake-process.png)


1. Il client invia una messaggio di saluto al server.

1. Il server risponde con un messaggio di saluto e invia il certificato del server.

1. Il client effettua le azioni seguenti:

   1. Verifica che il certificato del SSL/TLS server sia firmato da un certificato radice considerato attendibile dal client. 

   1. Estrae la chiave pubblica dal certificato del server.

   1. Genera un segreto pre-master e lo crittografa con la chiave pubblica del server.

   1. Invia il segreto pre-master crittografato al server.

1. Per decrittografare il segreto pre-master del client, il server lo invia all'HSM. L'HSM utilizza la chiave privata dell'HSM per decrittografare il segreto pre-master e quindi invia il segreto pre-master al server. Indipendentemente, il client e il server utilizzano ciascuno il segreto premaster e alcune informazioni contenute nei messaggi di benvenuto per calcolare un segreto principale. 

1. Il processo di handshake termina. Per il resto della sessione, tutti i messaggi inviati tra il client e il server vengono crittografati con derivati del segreto master. 

Per informazioni su come configurare SSL/TLS offload con AWS CloudHSM, consulta uno dei seguenti argomenti:
+ [AWS CloudHSM Offload SSL/TLS su Linux usando NGINX o Apache con OpenSSL](third-offload-linux-openssl.md)
+ [AWS CloudHSM Offload SSL/TLS su Linux utilizzando Tomcat con JSSE](third-offload-linux-jsse.md)
+ [AWS CloudHSM Offload SSL/TLS su Windows tramite IIS con KSP](ssl-offload-windows.md)

# AWS CloudHSM Offload SSL/TLS su Linux usando NGINX o Apache con OpenSSL
<a name="third-offload-linux-openssl"></a>

Questo argomento fornisce step-by-step istruzioni per configurare l' SSL/TLS offload con AWS CloudHSM su un server Web Linux.

**Topics**
+ [Panoramica di](#ssl-offload-linux-openssl-overview)
+ [Fase 1: configurazione dei prerequisiti](#ssl-offload-prerequisites)
+ [Fase 2: Generazione della chiave privata e del certificato SSL/TLS](#ssl-offload-import-or-generate-private-key-and-certificate)
+ [Fase 3: configurazione del server Web](#ssl-offload-configure-web-server)
+ [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#ssl-offload-enable-traffic-and-verify-certificate)

## Panoramica di
<a name="ssl-offload-linux-openssl-overview"></a>

In Linux il software per server Web [NGINX](https://nginx.org/en/) e [Apache HTTP Server](https://httpd.apache.org/) si integra con [OpenSSL](https://www.openssl.org/) per supportare HTTPS. Il [motore AWS CloudHSM dinamico per OpenSSL](openssl-library.md) fornisce un'interfaccia che consente al software del server Web di utilizzarlo nel cluster per HSMs l'offload crittografico e l'archiviazione delle chiavi. Il motore OpenSSL connette il server Web al cluster AWS CloudHSM .

Per completare questo tutorial, è necessario prima scegliere se utilizzare il software del server Web NGINX o Apache su Linux. Vengono quindi illustrate 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-prerequisites).

## Fase 1: configurazione dei prerequisiti
<a name="ssl-offload-prerequisites"></a>

Piattaforme diverse richiedono prerequisiti diversi. Utilizza la sezione sui prerequisiti riportata di seguito corrispondente alla tua piattaforma.

### Prerequisiti per Client SDK 5
<a name="new-versions"></a>

Per configurare l' SSL/TLS offload del server Web con 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 Apache)
  + OpenSSL Dynamic Engine 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**

1. Installa e configura OpenSSL Dynamic Engine per. AWS CloudHSM Per ulteriori informazioni sull'installazione di OpenSSL Dynamic Engine, consulta la pagina [OpenSSL Dynamic Engine per Client SDK 5](openssl5-install.md).

1. Su un'istanza Linux EC2 che ha accesso al tuo cluster, installa il server Web NGINX o Apache:

------
#### [ Amazon Linux 2 ]
   + Per le informazioni su come scaricare l'ultima versione di NGINX su Amazon Linux 2, consulta il [sito Web di NGINX](https://nginx.org/en/linux_packages.html).

     L'ultima versione di NGINX disponibile per Amazon Linux 2 utilizza una versione di OpenSSL più recente rispetto alla versione di sistema di OpenSSL. Dopo aver installato NGINX, è necessario creare un collegamento simbolico dalla libreria OpenSSL Dynamic Engine alla posizione prevista da questa versione di AWS CloudHSM OpenSSL 

     ```
     $ sudo ln -sf /opt/cloudhsm/lib/libcloudhsm_openssl_engine.so /usr/lib64/engines-1.1/cloudhsm.so
     ```
   + Apache

     ```
     $ sudo yum install httpd mod_ssl
     ```

------
#### [ Amazon Linux 2023 ]
   + NGINX

     ```
     $ sudo yum install nginx
     ```
   + Apache

     ```
     $ sudo yum install httpd mod_ssl
     ```

------
#### [ Red Hat 8 ]
   + NGINX

     ```
     $ sudo yum install nginx
     ```
   + Apache

     ```
     $ sudo yum install httpd mod_ssl
     ```

------
#### [ Red Hat 9 ]
   + NGINX

     ```
     $ sudo yum install nginx
     ```
   + Apache

     ```
     $ sudo yum install httpd mod_ssl
     ```

------
#### [ Ubuntu 22.04 ]
   + NGINX

     ```
     $ sudo apt install nginx
     ```
   + Apache

     ```
     $ sudo apt install apache2
     ```

------
#### [ Ubuntu 24.04 ]
   + NGINX

     ```
     $ sudo apt install nginx
     ```
   + Apache

     ```
     $ sudo apt install apache2
     ```

------

1. [Usa la CLI di CloudhSM per creare un utente crittografico.](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: Generazione della chiave privata e del certificato SSL/TLS](#ssl-offload-import-or-generate-private-key-and-certificate).

#### Note
<a name="note-ssl5-pre"></a>
+ 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 introduttiva offre step-by-step istruzioni per creare 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 cluster AWS CloudHSM](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: Generazione della chiave privata e del certificato SSL/TLS
<a name="ssl-offload-import-or-generate-private-key-and-certificate"></a>

Per abilitare HTTPS, l'applicazione del server web (NGINX o Apache) necessita di una chiave privata e di un certificato corrispondente. SSL/TLS Per utilizzare l' SSL/TLS offload del server Web con AWS CloudHSM, è necessario archiviare la chiave privata in un HSM del cluster. AWS CloudHSM Per prima cosa genererai una chiave privata e la utilizzerai per creare una richiesta di firma del certificato (CSR). Quindi esporti 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. SSL/TLS 

### Generazione di una chiave privata e di un certificato
<a name="ssl-offload-generate-private-key-and-certificate"></a>

#### Generazione di una chiave privata
<a name="ssl-offload-generate-private-key"></a>

Questa sezione mostra come generare una coppia di chiavi utilizzando la CLI di [CloudHSM](cloudhsm_cli.md). Una volta generata una key pair all'interno dell'HSM, è possibile esportarla come file PEM falso e generare il certificato corrispondente. <a name="ssl-offload-generate-private-key-prerequisites"></a>

**Installa e configura la CLI CloudHSM**

1. [Installa e configura](cloudhsm_cli-getting-started.md) la CLI CloudHSM.

1. Usa il comando seguente per avviare la CLI CloudHSM.

   ```
   $ /opt/cloudhsm/bin/cloudhsm-cli interactive
   ```

1. Eseguire il comando seguente per accedere all'HSM. Sostituiscilo *<user name>* con il nome utente del tuo cripto-utente

   ```
   Command: login --username <user name> --role crypto-user
   ```

**Generazione di una chiave privata**

A seconda del caso d'uso, è possibile generare una coppia di chiavi RSA o EC. 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, etichetta di chiave pubblica e etichetta chiave privata di*tls\$1rsa\$1pub*. *tls\$1rsa\$1private*

  ```
  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": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c
  73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634d
  f6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc
  133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0ac
  ac3160f0ca9725d38318b7",
          "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 a chiave pubblica di *tls\$1ec\$1pub* e un'etichetta a chiave privata di*tls\$1ec\$1private*.

  ```
  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"
        }
      }
    }
  }
  ```

**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 della chiave effettivi, ma consente a OpenSSL Dynamic Engine di identificare la chiave privata nell'HSM, che potrà quindi essere utilizzata per creare una richiesta di firma del certificato (CSR) e firmare la CSR per creare il certificato. 

Utilizzate il [`key generate-file`](cloudhsm_cli-key-generate-file.md)comando per esportare la chiave privata in formato PEM falso e salvarla in un file. Sostituire i valori seguenti con i propri valori. 
+ *<private\$1key\$1label>*— Etichetta della chiave privata generata nel passaggio precedente. 
+ *<web\$1server\$1fake\$1pem.key>*— Nome del file su cui verrà scritta la tua falsa chiave PEM.

```
aws-cloudhsm > key generate-file --encoding reference-pem --path <web_server_fake_pem.key> --filter attr.label=<private_key_label>
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}
```

**Uscire dalla CLI di CloudHSM**

Esegui il comando seguente per arrestare la CLI CloudHSM.

```
aws-cloudhsm > quit
```

Ora dovresti avere un nuovo file sul tuo sistema, situato nel percorso specificato *<web\$1server\$1fake\$1pem.key>* nel comando precedente. Questo file è il file della chiave privata PEM falsa.

#### Generazione di un certificato auto-firmato
<a name="ssl-offload-generate-certificate"></a>

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 utilizzi una CA, invia loro il file CSR e usa il SSL/TLS certificato firmato che ti forniscono nel tuo server web per HTTPS. 

In alternativa all'utilizzo di una CA, puoi utilizzare AWS CloudHSM OpenSSL Dynamic Engine per creare un certificato autofirmato. I certificati autofirmati non sono considerati attendibili dai browser e non devono essere utilizzati negli ambienti di produzione, ma solo negli ambienti di test. 

**avvertimento**  
È consigliabile utilizzare i certificati autofirmati 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. <a name="ssl-offload-generate-certificate-prerequisites"></a>

**Installa e configura OpenSSL Dynamic Engine**

1. Effettuare la connessione all'istanza del client.

1. [Installa il motore AWS CloudHSM dinamico OpenSSL per Client SDK 5](openssl5-install.md)<a name="ssl-offload-generate-certificate-steps"></a>

**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 AWS CloudHSM OpenSSL Dynamic Engine per creare una richiesta di firma del certificato (CSR). *<web\$1server\$1fake\$1pem.key>*Sostituiscilo con il nome del file che contiene la tua falsa chiave privata PEM. Sostituiscilo *<web\$1server.csr>* 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 SSL/TLS nel certificato. 

   ```
   $ openssl req -engine cloudhsm -new -key <web_server_fake_pem.key> -out <web_server.csr>
   ```

1. Crea un certificato auto-firmato

   Esegui il seguente comando per utilizzare AWS CloudHSM OpenSSL Dynamic Engine per firmare la tua 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. 
   + *<web\$1server.csr>*— Nome del file che contiene la CSR.
   + *<web\$1server\$1fake\$1pem.key>*— Nome del file che contiene la falsa chiave privata PEM.
   + *<web\$1server.crt>*— Nome del file che conterrà il certificato del server web.

   ```
   $ openssl x509 -engine cloudhsm -req -days 365 -in <web_server.csr> -signkey <web_server_fake_pem.key> -out <web_server.crt>
   ```

Dopo aver completato queste operazioni, andare su [Fase 3: configurazione del server Web](#ssl-offload-configure-web-server).

## Fase 3: configurazione del server Web
<a name="ssl-offload-configure-web-server"></a>

È 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-import-or-generate-private-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 con cui eseguire l' SSL/TLS offload. AWS CloudHSM

Completa la procedura delineata in una delle seguenti sezioni. 

**Topics**
+ [Configurazione del server Web NGINX](#ssl-offload-nginx)
+ [Configurazione del server Web Apache](#ssl-offload-apache)

### Configurazione del server Web NGINX
<a name="ssl-offload-nginx"></a>

Fai riferimento a questa sezione per configurare NGINX sulle piattaforme supportate.<a name="update-web-server-config-nginx"></a>

**Per aggiornare la configurazione del server Web per NGINX**

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. 

   ```
   $ sudo mkdir -p /etc/pki/nginx/private
   ```

1. Eseguire il comando seguente per copiare il certificato del server Web nella posizione richiesta. Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web.

   ```
   $ sudo cp <web_server.crt> /etc/pki/nginx/server.crt
   ```

1. Eseguire il comando seguente per copiare la falsa chiave privata PEM nella posizione richiesta. Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

   ```
   $ sudo cp <web_server_fake_pem.key> /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. 

   ```
   $ sudo chown nginx /etc/pki/nginx/server.crt /etc/pki/nginx/private/server.key
   ```

1. Eseguire il comando seguente per effettuare il backup del file `/etc/nginx/nginx.conf`.

   ```
   $ sudo 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 2 ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Per farlo sono necessarie le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

   ```
   ssl_engine cloudhsm;
   env CLOUDHSM_PIN;
   ```

   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
       # 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;
       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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA";
       ssl_prefer_server_ciphers on;
   
       # 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 {
       }
   }
   ```

------
#### [ Amazon Linux 2023 ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Per farlo sono necessarie le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

   ```
   ssl_engine cloudhsm;
   env CLOUDHSM_PIN;
   ```

   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
       # 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;
       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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA";
       ssl_prefer_server_ciphers on;
   
       # 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 {
       }
   }
   ```

------
#### [ Red Hat 8 ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Per farlo sono necessarie le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

   ```
   ssl_engine cloudhsm;
   env CLOUDHSM_PIN;
   ```

   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
       # 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA";
       ssl_prefer_server_ciphers on;
   
       # 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 {
       }
   }
   ```

------
#### [ Red Hat 9 ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Per farlo sono necessarie le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

   ```
   ssl_engine cloudhsm;
   env CLOUDHSM_PIN;
   ```

   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
       # 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA";
       ssl_prefer_server_ciphers on;
   
       # 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 22.04 LTS ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Per farlo sono necessarie le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

   ```
   ssl_engine cloudhsm;
   env CLOUDHSM_PIN;
   ```

   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
       # 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA";
       ssl_prefer_server_ciphers on;
   
       # 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 24.04 LTS ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Per farlo sono necessarie le autorizzazioni root di Linux. All'inizio del file, aggiungi le seguenti righe: 

   ```
   ssl_engine cloudhsm;
   env CLOUDHSM_PIN;
   ```

   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
       # 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA";
       ssl_prefer_server_ciphers on;
   
       # 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 2 ]

   1.  Effettuare il backup del file `nginx.service`. 

      ```
      $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup
      ```

   1.  Aprire il file `/lib/systemd/system/nginx.service` in un editor di testo, quindi nella sezione [Service], aggiungere il percorso seguente: 

      ```
      EnvironmentFile=/etc/sysconfig/nginx
      ```

------
#### [ Amazon Linux 2023 ]

   1.  Effettuare il backup del file `nginx.service`. 

      ```
      $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup
      ```

   1.  Apri il `/lib/systemd/system/nginx.service` file in un editor di testo, quindi nella sezione [Servizio], aggiungi il seguente percorso: 

      ```
      EnvironmentFile=/etc/sysconfig/nginx
      ```

------
#### [ Red Hat 8 ]

   1.  Effettuare il backup del file `nginx.service`. 

      ```
      $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup
      ```

   1.  Aprire il file `/lib/systemd/system/nginx.service` in un editor di testo, quindi nella sezione [Service], aggiungere il percorso seguente: 

      ```
      EnvironmentFile=/etc/sysconfig/nginx
      ```

------
#### [ Red Hat 9 ]

   1.  Effettuare il backup del file `nginx.service`. 

      ```
      $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup
      ```

   1.  Aprire il file `/lib/systemd/system/nginx.service` in un editor di testo, quindi nella sezione [Service], aggiungere il percorso seguente: 

      ```
      EnvironmentFile=/etc/sysconfig/nginx
      ```

------
#### [ Ubuntu 22.04 LTS ]

   1.  Effettuare il backup del file `nginx.service`. 

      ```
      $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup
      ```

   1.  Aprire il file `/lib/systemd/system/nginx.service` in un editor di testo, quindi nella sezione [Service], aggiungere il percorso seguente: 

      ```
      EnvironmentFile=/etc/sysconfig/nginx
      ```

------
#### [ Ubuntu 24.04 LTS ]

   1.  Effettuare il backup del file `nginx.service`. 

      ```
      $ sudo cp /lib/systemd/system/nginx.service /lib/systemd/system/nginx.service.backup
      ```

   1.  Aprire il file `/lib/systemd/system/nginx.service` in un editor di testo, quindi nella sezione [Service], aggiungere il percorso seguente: 

      ```
      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:

     ```
     $ sudo 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.
**Nota**  
Client SDK 5 introduce la variabile di ambiente `CLOUDHSM_PIN` per l'archiviazione delle credenziali del CU.

------
#### [ Amazon Linux 2 ]

   Apri il file `/etc/sysconfig/nginx` in un editor di testo. Per farlo sono necessarie le autorizzazioni root di Linux. Aggiungi le credenziali del crypto user (CU):

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. 

    Salvare il file.

------
#### [ Amazon Linux 2023 ]

   Apri il file `/etc/sysconfig/nginx` in un editor di testo. Per farlo sono necessarie le autorizzazioni root di Linux. Aggiungi le credenziali del crypto user (CU):

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. 

    Salvare il file.

------
#### [ Red Hat 8 ]

   Apri il file `/etc/sysconfig/nginx` in un editor di testo. Per farlo sono necessarie le autorizzazioni root di Linux. Aggiungi le credenziali del crypto user (CU):

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. 

    Salvare il file.

------
#### [ Red Hat 9 ]

   Apri il file `/etc/sysconfig/nginx` in un editor di testo. Per farlo sono necessarie le autorizzazioni root di Linux. Aggiungi le credenziali del crypto user (CU):

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. 

    Salvare il file.

------
#### [ Ubuntu 22.04 LTS ]

   Apri il file `/etc/sysconfig/nginx` in un editor di testo. Per farlo sono necessarie le autorizzazioni root di Linux. Aggiungi le credenziali del crypto user (CU):

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. 

    Salvare il file.

------
#### [ Ubuntu 24.04 LTS ]

   Apri il file `/etc/sysconfig/nginx` in un editor di testo. Per farlo sono necessarie le autorizzazioni root di Linux. Aggiungi le credenziali del crypto user (CU):

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. 

    Salvare il file.

------

1. Avviare il server Web NGINX.

------
#### [ Amazon Linux 2 ]

   Interrompi qualsiasi processo NGINX in esecuzione

   ```
   $ sudo systemctl stop nginx
   ```

   Ricarica la configurazione `systemd` per implementare le modifiche più recenti

   ```
   $ sudo systemctl daemon-reload
   ```

   Avvia il processo NGINX

   ```
   $ sudo systemctl start nginx
   ```

------
#### [ Amazon Linux 2023 ]

   Arresta tutti i processi NGINX

   ```
   $ sudo systemctl stop nginx
   ```

   Ricarica la configurazione `systemd` per implementare le modifiche più recenti

   ```
   $ sudo systemctl daemon-reload
   ```

   Avvia NGINX

   ```
   $ sudo systemctl start nginx
   ```

------
#### [ Red Hat 8 ]

   Interrompi qualsiasi processo NGINX in esecuzione

   ```
   $ sudo systemctl stop nginx
   ```

   Ricarica la configurazione `systemd` per implementare le modifiche più recenti

   ```
   $ sudo systemctl daemon-reload
   ```

   Avvia il processo NGINX

   ```
   $ sudo systemctl start nginx
   ```

------
#### [ Red Hat 9 ]

   Interrompi qualsiasi processo NGINX in esecuzione

   ```
   $ sudo systemctl stop nginx
   ```

   Ricarica la configurazione `systemd` per implementare le modifiche più recenti

   ```
   $ sudo systemctl daemon-reload
   ```

   Avvia il processo NGINX

   ```
   $ sudo systemctl start nginx
   ```

------
#### [ Ubuntu 22.04 LTS ]

   Interrompi qualsiasi processo NGINX in esecuzione

   ```
   $ sudo systemctl stop nginx
   ```

   Ricarica la configurazione `systemd` per implementare le modifiche più recenti

   ```
   $ sudo systemctl daemon-reload
   ```

   Avvia il processo NGINX

   ```
   $ sudo systemctl start nginx
   ```

------
#### [ Ubuntu 24.04 LTS ]

   Interrompi qualsiasi processo NGINX in esecuzione

   ```
   $ sudo systemctl stop nginx
   ```

   Ricarica la configurazione `systemd` per implementare le modifiche più recenti

   ```
   $ sudo systemctl daemon-reload
   ```

   Avvia il processo NGINX

   ```
   $ sudo systemctl start nginx
   ```

------

1. (Facoltativo) Configura la piattaforma per avviare NGINX all'avvio.

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo systemctl enable nginx
   ```

------
#### [ Amazon Linux 2023 ]

   ```
   $ sudo systemctl enable nginx
   ```

------
#### [ Red Hat 8 ]

   ```
   $ sudo systemctl enable nginx
   ```

------
#### [ Red Hat 9 ]

   ```
   $ sudo systemctl enable nginx
   ```

------
#### [ Ubuntu 22.04 LTS ]

   ```
   $ sudo systemctl enable nginx
   ```

------
#### [ Ubuntu 24.04 LTS ]

   ```
   $ sudo systemctl enable nginx
   ```

------

Dopo avere aggiornato la configurazione del server Web, vai alla [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#ssl-offload-enable-traffic-and-verify-certificate).

### Configurazione del server Web Apache
<a name="ssl-offload-apache"></a>

 Fai riferimento a questa sezione per configurare Apache sulle piattaforme supportate. <a name="update-web-server-config-apache"></a>

**Per aggiornare la configurazione del server Web per Apache**

1. Esegui la connessione all'istanza del client Amazon EC2.

1. Definisci le posizioni predefinite per i certificati e le chiavi private per la piattaforma.

------
#### [ Amazon Linux 2 ]

   Assicurati che nel file `/etc/httpd/conf.d/ssl.conf` siano presenti questi valori:

   ```
   SSLCertificateFile      /etc/pki/tls/certs/localhost.crt
   SSLCertificateKeyFile   /etc/pki/tls/private/localhost.key
   ```

------
#### [ Amazon Linux 2023 ]

   Nel `/etc/httpd/conf.d/ssl.conf` file, assicurati che esistano questi valori:

   ```
   SSLCertificateFile      /etc/pki/tls/certs/localhost.crt
   SSLCertificateKeyFile   /etc/pki/tls/private/localhost.key
   ```

------
#### [ Red Hat 8 ]

   Assicurati che nel file `/etc/httpd/conf.d/ssl.conf` siano presenti questi valori:

   ```
   SSLCertificateFile      /etc/pki/tls/certs/localhost.crt
   SSLCertificateKeyFile   /etc/pki/tls/private/localhost.key
   ```

------
#### [ Red Hat 9 ]

   Assicurati che nel file `/etc/httpd/conf.d/ssl.conf` siano presenti questi valori:

   ```
   SSLCertificateFile      /etc/pki/tls/certs/localhost.crt
   SSLCertificateKeyFile   /etc/pki/tls/private/localhost.key
   ```

------
#### [ Ubuntu 22.04 LTS ]

   Assicurati che nel file `/etc/apache2/sites-available/default-ssl.conf` siano presenti questi valori:

   ```
   SSLCertificateFile      /etc/ssl/certs/localhost.crt
   SSLCertificateKeyFile   /etc/ssl/private/localhost.key
   ```

------
#### [ Ubuntu 24.04 LTS ]

   Assicurati che nel file `/etc/apache2/sites-available/default-ssl.conf` siano presenti questi valori:

   ```
   SSLCertificateFile      /etc/ssl/certs/localhost.crt
   SSLCertificateKeyFile   /etc/ssl/private/localhost.key
   ```

------

1. Copia il certificato del server Web nella posizione richiesta per la piattaforma.

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo cp <web_server.crt> /etc/pki/tls/certs/localhost.crt
   ```

   Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web. 

------
#### [ Amazon Linux 2023 ]

   ```
   $ sudo cp <web_server.crt> /etc/pki/tls/certs/localhost.crt
   ```

   Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web. 

------
#### [ Red Hat 8 ]

   ```
   $ sudo cp <web_server.crt> /etc/pki/tls/certs/localhost.crt
   ```

   Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web. 

------
#### [ Red Hat 9 ]

   ```
   $ sudo cp <web_server.crt> /etc/pki/tls/certs/localhost.crt
   ```

   Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web. 

------
#### [ Ubuntu 22.04 LTS ]

   ```
   $ sudo cp <web_server.crt> /etc/ssl/certs/localhost.crt
   ```

   Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web. 

------
#### [ Ubuntu 24.04 LTS ]

   ```
   $ sudo cp <web_server.crt> /etc/ssl/certs/localhost.crt
   ```

   Sostituiscilo *<web\$1server.crt>* con il nome del certificato del tuo server web. 

------

1. Copia la tua chiave privata PEM falsa nella posizione richiesta per la piattaforma.

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo cp <web_server_fake_pem.key> /etc/pki/tls/private/localhost.key
   ```

   Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

------
#### [ Amazon Linux 2023 ]

   ```
   $ sudo cp <web_server_fake_pem.key> /etc/pki/tls/private/localhost.key
   ```

   Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

------
#### [ Red Hat 8 ]

   ```
   $ sudo cp <web_server_fake_pem.key> /etc/pki/tls/private/localhost.key
   ```

   Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

------
#### [ Red Hat 9 ]

   ```
   $ sudo cp <web_server_fake_pem.key> /etc/pki/tls/private/localhost.key
   ```

   Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

------
#### [ Ubuntu 22.04 LTS ]

   ```
   $ sudo cp <web_server_fake_pem.key> /etc/ssl/private/localhost.key
   ```

   Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

------
#### [ Ubuntu 24.04 LTS ]

   ```
   $ sudo cp <web_server_fake_pem.key> /etc/ssl/private/localhost.key
   ```

   Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

------

1. Cambia la proprietà di questi file se richiesto dalla piattaforma.

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key
   ```

   Fornisce il permesso di lettura all'utente denominato *apache*.

------
#### [ Amazon Linux 2023 ]

   ```
   $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key
   ```

   Fornisce il permesso di lettura all'utente denominato *apache*.

------
#### [ Red Hat 8 ]

   ```
   $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key
   ```

   Fornisce il permesso di lettura all'utente denominato *apache*.

------
#### [ Red Hat 9 ]

   ```
   $ sudo chown apache /etc/pki/tls/certs/localhost.crt /etc/pki/tls/private/localhost.key
   ```

   Fornisce il permesso di lettura all'utente denominato *apache*.

------
#### [ Ubuntu 22.04 LTS ]

   Nessuna operazione necessaria.

------
#### [ Ubuntu 24.04 LTS ]

   Nessuna operazione necessaria.

------

1. Configura le direttive Apache per la piattaforma.

------
#### [ Amazon Linux 2 ]

   Individua il file SSL per questa piattaforma:

   ```
   /etc/httpd/conf.d/ssl.conf
   ```

   Questo file contiene le direttive Apache che definiscono la modalità di esecuzione del server. Le direttive vengono visualizzate a sinistra, seguite da un valore. Utilizza un editor di testo per modificare il file. Per farlo sono necessarie le autorizzazioni root di Linux.

   Aggiorna o inserisci le seguenti direttive con questi valori:

   ```
   SSLCryptoDevice cloudhsm
   SSLCipherSuite 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA
   ```

   Salvare il file.

------
#### [ Amazon Linux 2023 ]

   Individua il file SSL per questa piattaforma:

   ```
   /etc/httpd/conf.d/ssl.conf
   ```

   Questo file contiene le direttive Apache che definiscono la modalità di esecuzione del server. Le direttive vengono visualizzate a sinistra, seguite da un valore. Utilizza un editor di testo per modificare il file. Per farlo sono necessarie le autorizzazioni root di Linux.

   Aggiorna o inserisci le seguenti direttive con questi valori:

   ```
   SSLCryptoDevice cloudhsm
   SSLCipherSuite 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA
   ```

   Salvare il file.

------
#### [ Red Hat 8 ]

   Individua il file SSL per questa piattaforma:

   ```
   /etc/httpd/conf.d/ssl.conf
   ```

   Questo file contiene le direttive Apache che definiscono la modalità di esecuzione del server. Le direttive vengono visualizzate a sinistra, seguite da un valore. Utilizza un editor di testo per modificare il file. Per farlo sono necessarie le autorizzazioni root di Linux.

   Aggiorna o inserisci le seguenti direttive con questi valori:

   ```
   SSLCryptoDevice cloudhsm
   SSLProtocol TLSv1.2 TLSv1.3
   SSLCipherSuite 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA
   SSLProxyCipherSuite HIGH:!aNULL
   ```

   Salvare il file.

------
#### [ Red Hat 9 ]

   Individua il file SSL per questa piattaforma:

   ```
   /etc/httpd/conf.d/ssl.conf
   ```

   Questo file contiene le direttive Apache che definiscono la modalità di esecuzione del server. Le direttive vengono visualizzate a sinistra, seguite da un valore. Utilizza un editor di testo per modificare il file. Per farlo sono necessarie le autorizzazioni root di Linux.

   Aggiorna o inserisci le seguenti direttive con questi valori:

   ```
   SSLCryptoDevice cloudhsm
   SSLProtocol TLSv1.2 TLSv1.3
   SSLCipherSuite 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA
   SSLProxyCipherSuite HIGH:!aNULL
   ```

   Salvare il file.

------
#### [ Ubuntu 22.04 LTS ]

   Individua il file SSL per questa piattaforma:

   ```
   /etc/apache2/mods-available/ssl.conf
   ```

   Questo file contiene le direttive Apache che definiscono la modalità di esecuzione del server. Le direttive vengono visualizzate a sinistra, seguite da un valore. Utilizza un editor di testo per modificare il file. Per farlo sono necessarie le autorizzazioni root di Linux.

   Aggiorna o inserisci le seguenti direttive con questi valori:

   ```
   SSLCryptoDevice cloudhsm
   SSLCipherSuite 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA
   SSLProtocol TLSv1.2 TLSv1.3
   ```

   Salvare il file.

   Abilita il modulo SSL e la configurazione predefinita del sito SSL:

   ```
   $ sudo a2enmod ssl
   $ sudo a2ensite default-ssl
   ```

------
#### [ Ubuntu 24.04 LTS ]

   Individua il file SSL per questa piattaforma:

   ```
   /etc/apache2/mods-available/ssl.conf
   ```

   Questo file contiene le direttive Apache che definiscono la modalità di esecuzione del server. Le direttive vengono visualizzate a sinistra, seguite da un valore. Utilizza un editor di testo per modificare il file. Per farlo sono necessarie le autorizzazioni root di Linux.

   Aggiorna o inserisci le seguenti direttive con questi valori:

   ```
   SSLCryptoDevice cloudhsm
   SSLCipherSuite 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:ECDHE-RSA-AES256-SHA384:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA
   SSLProtocol TLSv1.2 TLSv1.3
   ```

   Salvare il file.

   Abilita il modulo SSL e la configurazione predefinita del sito SSL:

   ```
   $ sudo a2enmod ssl
   $ sudo a2ensite default-ssl
   ```

------

1. Configura un file environment-values per la piattaforma.

------
#### [ Amazon Linux 2 ]

    Apri il file di servizio httpd: 

   ```
   /lib/systemd/system/httpd.service
   ```

    Aggiungi quanto segue alla sezione `[Service]`: 

   ```
   EnvironmentFile=/etc/sysconfig/httpd
   ```

------
#### [ Amazon Linux 2023 ]

    Apri il file di servizio httpd: 

   ```
   /lib/systemd/system/httpd.service
   ```

    Aggiungi quanto segue alla sezione `[Service]`: 

   ```
   EnvironmentFile=/etc/sysconfig/httpd
   ```

------
#### [ Red Hat 8 ]

    Apri il file di servizio httpd: 

   ```
   /lib/systemd/system/httpd.service
   ```

    Aggiungi quanto segue alla sezione `[Service]`: 

   ```
   EnvironmentFile=/etc/sysconfig/httpd
   ```

------
#### [ Red Hat 9 ]

    Apri il file di servizio httpd: 

   ```
   /lib/systemd/system/httpd.service
   ```

    Aggiungi quanto segue alla sezione `[Service]`: 

   ```
   EnvironmentFile=/etc/sysconfig/httpd
   ```

------
#### [ Ubuntu 22.04 LTS ]

   Nessuna operazione necessaria. I valori dell'ambiente vanno in `/etc/sysconfig/httpd`

------
#### [ Ubuntu 24.04 LTS ]

   Nessuna operazione necessaria. I valori dell'ambiente vanno in `/etc/sysconfig/httpd`

------

1. Imposta una variabile di ambiente contenente le credenziali del crypto user (CU) nel file in cui vengono archiviate le variabili di ambiente per la piattaforma:

------
#### [ Amazon Linux 2 ]

   Utilizza un editor di testo per modificare `/etc/sysconfig/httpd`.

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU.

------
#### [ Amazon Linux 2023 ]

   Utilizza un editor di testo per modificare `/etc/sysconfig/httpd`.

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU.

------
#### [ Red Hat 8 ]

   Utilizza un editor di testo per modificare `/etc/sysconfig/httpd`.

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU.

**Nota**  
Client SDK 5 introduce la variabile di ambiente `CLOUDHSM_PIN` per l'archiviazione delle credenziali del CU.

------
#### [ Red Hat 9 ]

   Utilizza un editor di testo per modificare `/etc/sysconfig/httpd`.

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU.

**Nota**  
Client SDK 5 introduce la variabile di ambiente `CLOUDHSM_PIN` per l'archiviazione delle credenziali del CU.

------
#### [ Ubuntu 22.04 LTS ]

   Utilizza un editor di testo per modificare `/etc/apache2/envvars`.

   ```
   export CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU.

**Nota**  
Client SDK 5 introduce la variabile di ambiente `CLOUDHSM_PIN` per l'archiviazione delle credenziali del CU. In Client SDK 3 le credenziali del CU sono archiviate nella variabile di ambiente `n3fips_password`. Client SDK 5 supporta entrambe le variabili di ambiente, ma si consiglia di utilizzare `CLOUDHSM_PIN`.

------
#### [ Ubuntu 24.04 LTS ]

   Utilizza un editor di testo per modificare `/etc/apache2/envvars`.

   ```
   export CLOUDHSM_PIN=<CU user name>:<password>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU.

**Nota**  
Client SDK 5 introduce la variabile di ambiente `CLOUDHSM_PIN` per l'archiviazione delle credenziali del CU. In Client SDK 3 le credenziali del CU sono archiviate nella variabile di ambiente `n3fips_password`. Client SDK 5 supporta entrambe le variabili di ambiente, ma si consiglia di utilizzare `CLOUDHSM_PIN`.

------

1. Avviare il server Web Apache.

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo systemctl daemon-reload
   $ sudo service httpd start
   ```

------
#### [ Amazon Linux 2023 ]

   ```
   $ sudo systemctl daemon-reload
   $ sudo service httpd start
   ```

------
#### [ Red Hat 8 ]

   ```
   $ sudo systemctl daemon-reload
   $ sudo service httpd start
   ```

------
#### [ Red Hat 9 ]

   ```
   $ sudo systemctl daemon-reload
   $ sudo service httpd start
   ```

------
#### [ Ubuntu 22.04 LTS ]

   ```
   $ sudo service apache2 start
   ```

------
#### [ Ubuntu 24.04 LTS ]

   ```
   $ sudo service apache2 start
   ```

------

1. (Facoltativo) Configura la tua piattaforma per avviare Apache all'avvio.

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo chkconfig httpd on
   ```

------
#### [ Amazon Linux 2023 ]

   ```
   $ sudo chkconfig httpd on
   ```

------
#### [ Red Hat 8 ]

   ```
   $ systemctl enable httpd
   ```

------
#### [ Red Hat 9 ]

   ```
   $ systemctl enable httpd
   ```

------
#### [ Ubuntu 22.04 LTS ]

   ```
   $ sudo systemctl enable apache2
   ```

------
#### [ Ubuntu 24.04 LTS ]

   ```
   $ sudo systemctl enable apache2
   ```

------

Dopo avere aggiornato la configurazione del server Web, vai alla [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#ssl-offload-enable-traffic-and-verify-certificate).

## Fase 4: abilitazione del traffico HTTPS e verifica del certificato
<a name="ssl-offload-enable-traffic-and-verify-certificate"></a>

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 consente il traffico HTTPS in entrata. Ciò consente ai client, come i browser Web, di stabilire una connessione HTTPS con il server Web. Quindi stabilisci una connessione HTTPS al tuo server web e verifica che stia utilizzando il certificato con cui hai configurato per 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-enable)

### Abilitazione delle connessioni HTTPS in entrata
<a name="ssl-offload-add-security-group-linux"></a>

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
<a name="ssl-offload-verify-https-connection-linux-enable"></a>

Dopo aver aggiunto il server Web a un gruppo di sicurezza, puoi verificare che SSL/TLS offload utilizzi il tuo certificato autofirmato. Per farlo, puoi utilizzare un browser Web o uno strumento come [OpenSSL s\$1client](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. Accertarsi 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 esempio, https://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 che hai configurato per l'uso sul tuo server web.

**Per verificare l' SSL/TLS offload con OpenSSL s\$1client**

1. Esegui il seguente comando OpenSSL per connetterti al server Web tramite HTTPS. *<server name>*Sostituiscilo con il nome DNS pubblico o l'indirizzo IP del tuo server web. 

   ```
   openssl s_client -connect <server name>:443
   ```
**Suggerimento**  
Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://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 che hai configurato per l'uso sul 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).

# AWS CloudHSM Offload SSL/TLS su Linux utilizzando NGINX o con OpenSSL Provider HAProxy
<a name="third-offload-linux-openssl-provider"></a>

Questo argomento fornisce step-by-step istruzioni per configurare l'offload dell'identità SSL/TLS del server AWS CloudHSM su un server Web Linux utilizzando NGINX o con HAProxy il provider OpenSSL.

**Topics**
+ [Panoramica di](#ssl-offload-linux-openssl-provider-overview)
+ [Fase 1: configurazione dei prerequisiti](#ssl-offload-provider-prerequisites)
+ [Passaggio 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
<a name="ssl-offload-linux-openssl-provider-overview"></a>

Su Linux, il software [NGINX](https://nginx.org/en/) e il software del server [HAProxy](https://www.haproxy.org/)web si integrano con [OpenSSL](https://www.openssl.org/) per supportare HTTPS. Il provider [AWS CloudHSM OpenSSL](openssl-provider-library.md) fornisce un'interfaccia che consente al software del server Web di utilizzare il server Web nel cluster per HSMs 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 utilizzerai il HAProxy provider OpenSSL AWS CloudHSM . Il tutorial mostra come fare quanto segue:
+ 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
<a name="ssl-offload-provider-prerequisites"></a>

Piattaforme diverse richiedono prerequisiti diversi. Utilizza la sezione sui prerequisiti riportata di seguito corrispondente alla tua piattaforma.

### Prerequisiti per AWS CloudHSM OpenSSL Provider
<a name="provider-new-versions"></a>

Per configurare l'offload dell'identità SSL/TLS del 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 i 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 di OpenSSL Provider, consulta [AWS CloudHSM OpenSSL Provider for Client SDK](openssl-provider-install.md) 5.

1. Su un'istanza Linux EC2 che ha accesso al tuo cluster, installa NGINX o il server web: HAProxy 

------
#### [ Amazon Linux 2023 ]
   + NGINX

     ```
     $ yum install nginx
     ```
   + HAProxy

     ```
     $ yum install haproxy
     ```

------
#### [ RHEL 9 (9.2\$1) ]
   + NGINX

     ```
     $ yum install nginx
     ```
   + HAProxy

     ```
     $ yum install haproxy
     ```

------
#### [ RHEL 10 (10.0\$1) ]
   + NGINX

     ```
     $ yum install nginx
     ```
   + HAProxy

     ```
     $ yum install haproxy
     ```

------
#### [ Ubuntu 24.04 ]
   + NGINX

     ```
     $ apt install nginx
     ```
   + HAProxy

     ```
     $ apt install haproxy
     ```

------

1. [Usa la CLI di CloudhSM per creare un utente crittografico.](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 [Passaggio 2: generare o importare una chiave privata e ottenere un certificato](#ssl-offload-provider-generate-key-and-certificate).

#### Note
<a name="note-ssl5-provider-pre"></a>
+ 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 introduttiva offre step-by-step istruzioni per creare 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 cluster AWS CloudHSM](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. 

## Passaggio 2: generare o importare una chiave privata e ottenere un certificato
<a name="ssl-offload-provider-generate-key-and-certificate"></a>

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'identità del SSL/TLS server Web con AWS CloudHSM, è necessario archiviare la chiave privata in un HSM del cluster. AWS CloudHSM Per prima cosa genererai una chiave privata e la utilizzerai per creare una richiesta di firma del certificato (CSR). Quindi esporti 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
<a name="ssl-offload-provider-generate-private-key"></a>

Questa sezione mostra come generare una coppia di chiavi utilizzando la CLI di [CloudHSM](cloudhsm_cli.md). Una volta generata una key pair all'interno dell'HSM, è possibile esportarla come file PEM falso e generare il certificato corrispondente. <a name="ssl-offload-provider-generate-private-key-prerequisites"></a>

**Installa e configura la CLI CloudHSM**

1. [Installa e configura](cloudhsm_cli-getting-started.md) la CLI CloudHSM.

1. Usa il comando seguente per avviare la CLI CloudHSM.

   ```
   $ /opt/cloudhsm/bin/cloudhsm-cli interactive
   ```

1. Eseguire il comando seguente per accedere all'HSM. Sostituiscilo *<user name>* con il nome utente del tuo cripto-utente

   ```
   aws-cloudhsm>login --username <user name> --role crypto-user
   ```

**Generazione di una chiave privata**

A seconda del caso d'uso, è possibile generare una coppia di chiavi RSA o EC. 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, etichetta di chiave pubblica e etichetta chiave privata di*tls\$1rsa\$1pub*. *tls\$1rsa\$1private*

  ```
  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 a chiave pubblica di *tls\$1ec\$1pub* e un'etichetta a chiave privata di*tls\$1ec\$1private*.

  ```
  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"
        }
      }
    }
  }
  ```

**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 della chiave effettivi, ma consente a OpenSSL Dynamic Engine di identificare la chiave privata nell'HSM, che potrà quindi essere utilizzata per creare una richiesta di firma del certificato (CSR) e firmare la CSR per creare il certificato. 

Utilizzate il [`key generate-file`](cloudhsm_cli-key-generate-file.md)comando per esportare la chiave privata in formato PEM falso e salvarla in un file. Sostituire i valori seguenti con i propri valori. 
+ *<private\$1key\$1label>*— Etichetta della chiave privata generata nel passaggio precedente. 
+ *<web\$1server\$1fake\$1pem.key>*— Nome del file su cui verrà scritta la tua falsa chiave PEM.

```
aws-cloudhsm > key generate-file --encoding reference-pem --path <web_server_fake_pem.key> --filter attr.label=<private_key_label>
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}
```

**Uscire dalla CLI CloudhSM**

Esegui il comando seguente per arrestare la CLI CloudHSM.

```
aws-cloudhsm > quit
```

Ora dovresti avere un nuovo file sul tuo sistema, che si trova nel percorso specificato *<web\$1server\$1fake\$1pem.key>* nel comando precedente. Questo file è il file della chiave privata PEM falsa.

### Generazione di un certificato auto-firmato
<a name="ssl-offload-provider-generate-certificate"></a>

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 utilizzi una CA, invia loro il file CSR e usa il SSL/TLS certificato firmato che ti forniscono nel tuo server web per HTTPS. 

In alternativa all'utilizzo di una CA, puoi utilizzare AWS CloudHSM OpenSSL Dynamic Engine per creare un certificato autofirmato. I certificati autofirmati non sono considerati attendibili dai browser e non devono essere utilizzati negli ambienti di produzione, ma solo negli ambienti di test. 

**avvertimento**  
È consigliabile utilizzare i certificati autofirmati 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. <a name="ssl-offload-provider-generate-certificate-prerequisites"></a>

**Installa e configura OpenSSL Dynamic Engine**

1. Effettuare la connessione all'istanza del client.

1. [Installa il motore AWS CloudHSM dinamico OpenSSL per Client SDK 5](openssl5-install.md)<a name="ssl-offload-provider-generate-certificate-steps"></a>

**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 AWS CloudHSM OpenSSL Dynamic Engine per creare una richiesta di firma del certificato (CSR). *<web\$1server\$1fake\$1pem.key>*Sostituiscilo con il nome del file che contiene la tua falsa chiave privata PEM. Sostituiscilo *<web\$1server.csr>* 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 SSL/TLS nel certificato. 
**Nota**  
La creazione di CSR non è attualmente supportata con OpenSSL Provider. È necessario utilizzare il motore OpenSSL per questo passaggio, ma le operazioni di crittografia TLS funzioneranno con il provider.

   ```
   $ openssl req -engine cloudhsm -new -key <web_server_fake_pem.key> -out <web_server.csr>
   ```

1. Crea un certificato auto-firmato

   Esegui il seguente comando per utilizzare AWS CloudHSM OpenSSL Dynamic Engine per firmare la tua 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. 
   + *<web\$1server.csr>*— Nome del file che contiene la CSR.
   + *<web\$1server\$1fake\$1pem.key>*— Nome del file che contiene la falsa chiave privata PEM.
   + *<web\$1server.crt>*— Nome del file che conterrà il certificato del server web.

   ```
   $ openssl x509 -engine cloudhsm -req -days 365 -in <web_server.csr> -signkey <web_server_fake_pem.key> -out <web_server.crt>
   ```

Dopo aver ottenuto una chiave privata e un certificato, vai a[Fase 3: configurazione del server Web](#ssl-offload-provider-configure-web-server).

## Fase 3: configurazione del server Web
<a name="ssl-offload-provider-configure-web-server"></a>

È 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
<a name="ssl-offload-provider-configure-nginx"></a>

Usa questa sezione per configurare NGINX con il provider OpenSSL.<a name="configure-nginx-provider"></a>

**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. *<web\$1server.crt>*Sostituiscilo con il nome del certificato del tuo server web.

   ```
   $ cp <web_server.crt> /etc/pki/nginx/server.crt
   ```

1. Eseguire il comando seguente per copiare la falsa chiave privata PEM nella posizione richiesta. Sostituiscilo *<web\$1server\$1fake\$1pem.key>* con il nome del file che contiene la tua falsa chiave privata PEM.

   ```
   $ cp <web_server_fake_pem.key> /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, consulta [AWS CloudHSM OpenSSL](openssl-provider-install.md) Provider for Client SDK 5.

   1. Individua il tuo file di configurazione OpenSSL:

      ```
      $ openssl version -d
      ```

      Dovresti vedere un output 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 (connessioni SSH, TLS e altri servizi) vengano instradate involontariamente attraverso il provider CloudHSM.  
L'utilizzo di un file di configurazione separato consente di estendere l'utilizzo di CloudHSM Provider solo ad applicazioni specifiche che richiedono operazioni crittografiche supportate da HSM.

      Crea un nuovo file di configurazione OpenSSL con i seguenti contenuti:

      ```
      $ cat > <example-cloudhsm-openssl.cnf> << '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 </etc/pki/tls>/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 credenziali del tuo utente crittografico (CU):

      ```
      $ export CLOUDHSM_PIN=<username>:<password>
      ```

   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 sia il provider predefinito che il provider CloudHSM elencati:

      ```
      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 le autorizzazioni 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\$1) ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò può 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 10 (10.0\$1) ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò può 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 {
       }
   }
   ```

------
#### [ Ubuntu 24.04 ]

   Usare un editor di testo per modificare il file `/etc/nginx/nginx.conf`. Ciò può 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         /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. 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 9 (9.2\$1) ]

   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) ]

   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 24.04 ]

   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 il `/etc/sysconfig/nginx` 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=<CU user name>:<password>
   OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. Sostituisci *<path to example-cloudhsm-openssl.cnf>* 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\$1) ]

   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=<CU user name>:<password>
   OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. Sostituisci *<path to example-cloudhsm-openssl.cnf>* 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\$1) ]

   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=<CU user name>:<password>
   OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. Sostituisci *<path to example-cloudhsm-openssl.cnf>* 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 24.04 ]

   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=<CU user name>:<password>
   OPENSSL_CONF=<path to example-cloudhsm-openssl.cnf>
   ```

   Sostituisci *<CU user name>* e *<password>* con le credenziali CU. Sostituisci *<path to example-cloudhsm-openssl.cnf>* 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\$1) ]

   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\$1) ]

   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 24.04 ]

   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
<a name="ssl-offload-provider-configure-haproxy"></a>

Usa questa sezione per configurare HAProxy con il provider OpenSSL. Gli esempi seguenti mostrano come eseguire la configurazione HAProxy con i certificati e le chiavi CloudHSM.<a name="configure-haproxy-provider"></a>

**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 utilizzare il tuo certificato e la falsa chiave PEM di CloudHSM:

   ```
   $ cat server.crt server.key > server-combined.pem
   ```

1. Esegui il backup della configurazione esistente: HAProxy 

   ```
   $ 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 distribuzione Linux in uso.

------
#### [ Amazon Linux and RHEL ]

   Esegui il backup e modifica del file HAProxy di servizio:

   ```
   $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup
   ```

   Modifica `/lib/systemd/system/haproxy.service` e aggiungi la seguente riga nella sezione [Servizio]:

   ```
   EnvironmentFile=/etc/sysconfig/haproxy
   ```

------
#### [ Ubuntu ]

   Esegui il backup e modifica del file HAProxy di servizio:

   ```
   $ cp /lib/systemd/system/haproxy.service /lib/systemd/system/haproxy.service.backup
   ```

   Modifica `/lib/systemd/system/haproxy.service` e aggiungi la seguente riga 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 HAProxy ambiente, se esiste:

   ```
   $ cp /etc/sysconfig/haproxy /etc/sysconfig/haproxy.backup
   ```

   Crea il file di HAProxy ambiente `/etc/sysconfig/haproxy` con i seguenti contenuti:

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

------
#### [ Ubuntu ]

   Eseguite il backup del file di HAProxy ambiente, se esiste:

   ```
   $ cp /etc/default/haproxy /etc/default/haproxy.backup
   ```

   Crea il file di HAProxy ambiente `/etc/default/haproxy` con i seguenti contenuti:

   ```
   CLOUDHSM_PIN=<CU user name>:<password>
   ```

------

   Sostituisci *<CU user name>* e *<password>* con le tue credenziali CU.

1. Ricarica la configurazione di systemd:

   ```
   $ systemctl daemon-reload
   ```

1. Inizia HAProxy con la configurazione di offload TLS di CloudHSM:

   ```
   $ systemctl start haproxy
   ```

   Puoi anche eseguirlo 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
<a name="ssl-offload-enable-traffic-and-verify-certificate-provider"></a>

Dopo aver configurato il server Web per l' SSL/TLS offload con AWS CloudHSM, aggiungi l'istanza del server Web a un gruppo di sicurezza che consente il traffico HTTPS in entrata. Ciò consente ai client, come i browser Web, di stabilire una connessione HTTPS con il server Web. Quindi stabilisci una connessione HTTPS al tuo server web e verifica che stia utilizzando il certificato con cui hai configurato per 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
<a name="ssl-offload-add-security-group-linux"></a>

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
<a name="ssl-offload-verify-https-connection-linux"></a>

Dopo aver aggiunto il server Web a un gruppo di sicurezza, puoi verificare che SSL/TLS offload utilizzi il tuo certificato autofirmato. Per farlo, puoi utilizzare un browser Web o uno strumento come [OpenSSL s\$1client](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. Accertarsi 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 esempio, https://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 che hai configurato per l'uso sul tuo server web.

**Per verificare l' SSL/TLS offload con OpenSSL s\$1client**

1. Esegui il seguente comando OpenSSL per connetterti al server Web tramite HTTPS. *<server name>*Sostituiscilo con il nome DNS pubblico o l'indirizzo IP del tuo server web. 

   ```
   openssl s_client -connect <server name>:443
   ```
**Suggerimento**  
Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://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 che hai configurato per l'uso sul 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).

# AWS CloudHSM Offload SSL/TLS su Linux utilizzando Tomcat con JSSE
<a name="third-offload-linux-jsse"></a>

Questo argomento fornisce step-by-step istruzioni per configurare l' SSL/TLS offload utilizzando Java Secure Socket Extension (JSSE) con JCE SDK. AWS CloudHSM 

**Topics**
+ [Panoramica di](#third-offload-linux-jsse-overview)
+ [Fase 1: configurazione dei prerequisiti](#third-offload-linux-jsse-prereqs)
+ [Passaggio 2: generare o importare una chiave privata e un certificato SSL/TLS](#third-offload-linux-jsse-gen)
+ [Fase 3: configurazione del server Web Tomcat](#third-offload-linux-jsse-config)
+ [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#third-offload-linux-jsse-verify)

## Panoramica di
<a name="third-offload-linux-jsse-overview"></a>

 In AWS CloudHSM, i server web Tomcat funzionano su Linux per supportare HTTPS. L'SDK AWS CloudHSM JCE fornisce un'interfaccia che può essere utilizzata con JSSE (Java Secure Socket Extension) per consentire l'uso di HSMs tali server Web. AWS CloudHSM JCE è il bridge che collega JSSE al tuo cluster AWS CloudHSM. JSSE è un'API Java per i protocolli Secure Sockets Layer (SSL) e Transport Layer Security (TLS). 

## Fase 1: configurazione dei prerequisiti
<a name="third-offload-linux-jsse-prereqs"></a>

Segui questi prerequisiti per utilizzare un server Web Tomcat con AWS CloudHSM offload su Linux. SSL/TLS Questi prerequisiti devono essere soddisfatti per configurare l' SSL/TLS offload del server Web con Client SDK 5 e un server Web Tomcat.

**Nota**  
Piattaforme diverse richiedono prerequisiti diversi. Segui sempre la procedura di installazione corretta per la tua piattaforma.

### Prerequisiti
<a name="new-versions-jsse"></a>
+ Un'istanza Amazon EC2 che esegue un sistema operativo Linux su cui è installato un server Web Tomcat.
+ 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.
+ Un AWS CloudHSM cluster attivo con almeno due moduli di sicurezza hardware (HSMs) su cui è installato e configurato [JCE for Client SDK 5](java-library-install_5.md).
**Nota**  
È possibile utilizzare un singolo cluster HSM, ma bisogna prima disabilitare la durabilità delle chiavi del client. Per ulteriori informazioni, consulta la sezione 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).

#### Come soddisfare i prerequisiti
<a name="jsse-prereqs-how-to"></a>

1. Installa e configura JCE for AWS CloudHSM su un AWS CloudHSM cluster attivo con almeno due moduli di sicurezza hardware (). HSMs Per ulteriori informazioni sull'installazione, consulta la pagina su [JCE per Client SDK 5](java-library-install_5.md).

1. Su un'istanza Linux EC2 che ha accesso al tuo AWS CloudHSM cluster, segui le [istruzioni di Apache Tomcat](https://tomcat.apache.org/download-90.cgi ) per scaricare e installare il server web Tomcat.

1. Utilizza la [CLI di CloudHSM](cloudhsm_cli.md) per creare un crypto user (CU). 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.

1. Per configurare JCE con Java KeyTool, segui le istruzioni riportate nella pagina [Usa Client SDK 5 per l'integrazione AWS CloudHSM con Java Keytool e Jarsigner](keystore-third-party-tools_5.md).

Dopo aver completato queste operazioni, andare su [Passaggio 2: generare o importare una chiave privata e un certificato SSL/TLS](#third-offload-linux-jsse-gen).

#### Note
<a name="jsse-prereqs-notes"></a>
+ Per utilizzare Security-Enhanced Linux (SELinux) e i server web, devi 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). Questa sezione offre step-by-step istruzioni per creare 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 cluster AWS CloudHSM](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. 

## Passaggio 2: generare o importare una chiave privata e un certificato SSL/TLS
<a name="third-offload-linux-jsse-gen"></a>

Per abilitare HTTPS, l'applicazione del server Web Tomcat richiede una chiave privata e un certificato corrispondente. SSL/TLS Per utilizzare l' SSL/TLS offload del server Web con AWS CloudHSM, è necessario archiviare la chiave privata in un HSM del cluster. AWS CloudHSM 

**Nota**  
In mancanza di una chiave privata e di un certificato corrispondente, genera una chiave privata in un HSM, La chiave privata viene utilizzata per creare una richiesta di firma del certificato (CSR), che viene utilizzata per creare il certificato. SSL/TLS 

Si crea un AWS CloudHSM KeyStore file locale che contiene un riferimento alla chiave privata sull'HSM e al certificato associato. Il server Web utilizza il AWS CloudHSM KeyStore file per identificare la chiave privata sull'HSM durante SSL/TLS l'offload.

**Topics**
+ [Generazione di una chiave privata](#jsse-ssl-offload-generate-private-key)
+ [Generazione di un certificato auto-firmato](#jsse-ssl-offload-generate-certificate)

### Generazione di una chiave privata
<a name="jsse-ssl-offload-generate-private-key"></a>

Questa sezione mostra come generare una key pair usando il file KeyTool da JDK. Una volta generata una key pair all'interno dell'HSM, è possibile esportarla come KeyStore file e generare il certificato corrispondente.

A seconda del caso d'uso, è possibile generare una coppia di chiavi RSA o EC. La procedura riportata di seguito illustra come generare una coppia di chiavi RSA.

**Usa il `genkeypair` comando in KeyTool per generare una coppia di key pair RSA**

1. Dopo aver sostituito i *<VARIABLES>* seguenti dati con i tuoi dati specifici, usa il seguente comando per generare un file keystore denominato`jsse_keystore.keystore`, che conterrà un riferimento alla tua chiave privata sull'HSM.

   ```
   $ keytool -genkeypair -alias <UNIQUE ALIAS FOR KEYS> -keyalg <KEY ALGORITHM> -keysize <KEY SIZE> -sigalg <SIGN ALGORITHM> \
           -keystore <PATH>/<JSSE KEYSTORE NAME>.keystore -storetype CLOUDHSM \
           -dname CERT_DOMAIN_NAME \
           -J-classpath '-J'$JAVA_LIB'/*:/opt/cloudhsm/java/*:./*' \
           -provider "com.amazonaws.cloudhsm.jce.provider.CloudHsmProvider" \
           -providerpath "$CLOUDHSM_JCE_LOCATION" \
           -keypass <KEY PASSWORD> -storepass <KEYSTORE PASSWORD>
   ```
   + ***<PATH>***: Il percorso in cui desiderate generare il file keystore.
   + ***<UNIQUE ALIAS FOR KEYS>***: Viene utilizzato per identificare in modo univoco la chiave sull'HSM. Questo alias verrà impostato come attributo ETICHETTA della chiave.
   + ***<KEY PASSWORD>***: Memorizziamo il riferimento alla tua chiave nel file keystore locale e questa password protegge quel riferimento locale.
   + ***<KEYSTORE PASSWORD>***: Questa è la password per il file keystore locale.
   + ***<JSSE KEYSTORE NAME>***: nome del file Keystore.
   + ***<CERT DOMAIN NAME>***: X.500 Nome distinto.
   + ***<KEY ALGORITHM>***: algoritmo chiave per generare una coppia di chiavi (ad esempio, RSA ed EC).
   + ***<KEY SIZE>***: dimensione della chiave per generare una coppia di chiavi (ad esempio, 2048, 3072 e 4096).
   + ***<SIGN ALGORITHM>***: dimensione della chiave per generare una coppia di chiavi (ad esempio, SHA1with RSA, SHA224with RSA, SHA256with RSA e SHA384with RSA). SHA512with

1. Per assicurarti che il comando sia stato eseguito correttamente, inserisci il seguente comando e verifica di aver generato correttamente una coppia di chiavi RSA.

   ```
   $ ls <PATH>/<JSSE KEYSTORE NAME>.keystore
   ```

### Generazione di un certificato auto-firmato
<a name="jsse-ssl-offload-generate-certificate"></a>

Dopo aver generato una chiave privata insieme al file KeyStore, 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 utilizzi una CA, invia loro il file CSR e utilizza il SSL/TLS certificato firmato che ti forniscono nel tuo server web per HTTPS.

In alternativa all'utilizzo di una CA, puoi utilizzare il KeyTool per creare un certificato autofirmato. I certificati autofirmati non sono considerati attendibili dai browser e non devono essere utilizzati negli ambienti di produzione, ma solo negli ambienti di test.

**avvertimento**  
È consigliabile utilizzare i certificati autofirmati 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.

**Topics**<a name="jsse-ssl-procedure-offload-generate-certificate"></a>

**Generazione di un certificato**

1. Ottieni una copia del file KeyStore generato in un passaggio precedente.

1. Esegui il comando seguente per utilizzare per KeyTool creare una richiesta di firma del certificato (CSR).

   ```
   $ keytool -certreq -keyalg RSA -alias unique_alias_for_key -file certreq.csr \
           -keystore <JSSE KEYSTORE NAME>.keystore -storetype CLOUDHSM \
           -J-classpath '-J$JAVA_LIB/*:/opt/cloudhsm/java/*:./*' \
           -keypass <KEY PASSWORD> -storepass <KEYSTORE PASSWORD>
   ```
**Nota**  
Il file di output della richiesta di firma del certificato è `certreq.csr`.<a name="jsse-ssl-procedure-offload-sign-certificate"></a>

**Firma di un certificato**
+ Dopo aver sostituito i *<VARIABLES>* seguenti dati con i tuoi dati specifici, esegui il comando seguente per firmare la CSR con la tua chiave privata sull'HSM. In questo modo viene creato un certificato autofirmato.

  ```
  $ keytool -gencert -infile certreq.csr -outfile certificate.crt \
      -alias <UNIQUE ALIAS FOR KEYS> -keypass <KEY_PASSWORD> -storepass <KEYSTORE_PASSWORD> -sigalg SIG_ALG \
      -storetype CLOUDHSM -J-classpath '-J$JAVA_LIB/*:/opt/cloudhsm/java/*:./*' \
      -keystore jsse_keystore.keystore
  ```
**Nota**  
`certificate.crt` è il certificato firmato che utilizza la chiave privata dell'alias.<a name="jsse-ssl-procedure-offload-import-certificate"></a>

**Importazione di un certificato in KeyStore**
+ Dopo aver sostituito i *<VARIABLES>* seguenti dati con i tuoi dati specifici, esegui il comando seguente per importare un certificato firmato come certificato affidabile. Questo passaggio memorizzerà il certificato nella voce del keystore identificata da alias.

  ```
  $ keytool -import -alias <UNIQUE ALIAS FOR KEYS> -keystore jsse_keystore.keystore \
      -file certificate.crt -storetype CLOUDHSM \
      -v -J-classpath '-J$JAVA_LIB/*:/opt/cloudhsm/java/*:./*' \
      -keypass <KEY PASSWORD> -storepass <KEYSTORE_PASSWORD>
  ```<a name="jsse-ssl-procedure-offload-convert-certificate"></a>

**Conversione di un certificato in un file PEM**
+ Esegui il seguente comando per convertire il file del certificato firmato (`.crt`) in un PEM. Il file PEM verrà utilizzato per inviare la richiesta dal client http.

  ```
  $ openssl x509 -inform der -in certificate.crt -out certificate.pem
  ```

Dopo aver completato questa procedura, vai alla [Fase 3: configurazione del server Web](#third-offload-linux-jsse-config).

## Fase 3: configurazione del server Web Tomcat
<a name="third-offload-linux-jsse-config"></a>

È possibile aggiornare la configurazione del software del server Web per utilizzare il certificato HTTPS e il file PEM corrispondente creato nella fase precedente. Ricorda di eseguire il backup dei certificati e delle chiavi esistenti prima di iniziare. Questo completerà la configurazione del software del server web Linux con cui eseguire l' SSL/TLS offload. AWS CloudHSM Per ulteriori informazioni, consulta la [documentazione di riferimento relativa alla configurazione di Apache Tomcat 9](https://tomcat.apache.org/tomcat-9.0-doc/config/http.html).<a name="jsse-config-stop-server"></a>

**Arresta il server**
+ Dopo aver sostituito quanto *<VARIABLES>* segue con i tuoi dati specifici, esegui il seguente comando per arrestare Tomcat Server prima di aggiornare la configurazione

  ```
  $ /<TOMCAT DIRECTORY>/bin/shutdown.sh
  ```
  + ***<TOMCAT DIRECTORY>***: La tua directory di installazione di Tomcat.<a name="jsse-config-update-class-path"></a>

**Aggiorna il percorso di classe Tomcat**

1. Effettuare la connessione all'istanza del client.

1. Individua la cartella di installazione di Tomcat.

1. Dopo aver sostituito quanto *<VARIABLES>* segue con i tuoi dati specifici, usa il seguente comando per aggiungere la libreria Java e il percorso AWS CloudHSM Java in Tomcat**classpath**, che si trova nel file.sh. Tomcat/bin/catalina

   ```
   $ sed -i 's@CLASSPATH="$CLASSPATH""$CATALINA_HOME"\/bin\/bootstrap.jar@CLASSPATH="$CLASSPATH""$CATALINA_HOME"\/bin\/bootstrap.jar:'"
           <JAVA LIBRARY>"'\/*:\/opt\/cloudhsm\/java\/*:.\/*@' <TOMCAT PATH> /bin/catalina.sh
   ```
   + ***<JAVA LIBRARY>***: posizione della libreria Java JRE.
   + ***<TOMCAT PATH>***: cartella di installazione di Tomcat.<a name="jsse-config-add-https"></a>

**Aggiungi un connettore HTTPS nella configurazione del server.**

1. Vai alla cartella di installazione di Tomcat.

1. Dopo aver sostituito i *<VARIABLES>* seguenti dati con i tuoi dati specifici, utilizza il seguente comando per aggiungere un connettore HTTPS per utilizzare i certificati generati nei prerequisiti:

   ```
   $ sed -i '/<Connector port="8080"/i <Connector port=\"443\" maxThreads=\"200\" scheme=\"https\" secure=\"true\" SSLEnabled=\"true\" keystoreType=\"CLOUDHSM\" keystoreFile=\"
           <CUSTOM DIRECTORY>/<JSSE KEYSTORE NAME>.keystore\" keystorePass=\"<KEYSTORE PASSWORD>\" keyPass=\"<KEY PASSWORD>
           \" keyAlias=\"<UNIQUE ALIAS FOR KEYS>" clientAuth=\"false\" sslProtocol=\"TLS\"/>' <TOMCAT PATH>/conf/server.xml
   ```
   + ***<CUSTOM DIRECTORY>***: cartella in cui si trova il file keystore.
   + ***<JSSE KEYSTORE NAME>***: nome del file Keystore.
   + ***<KEYSTORE PASSWORD>***: Questa è la password per il file keystore locale.
   + ***<KEY PASSWORD>***: Memorizziamo il riferimento alla tua chiave nel file keystore locale e questa password protegge quel riferimento locale.
   + ***<UNIQUE ALIAS FOR KEYS>***: Viene utilizzato per identificare in modo univoco la chiave sull'HSM. Questo alias verrà impostato come attributo ETICHETTA della chiave.
   + ***<TOMCAT PATH>***: Il percorso della cartella Tomcat.<a name="jsse-config-start-server"></a>

**Avvio del server**
+ Dopo aver sostituito i *<VARIABLES>* seguenti dati con i tuoi dati specifici, usa il seguente comando per avviare Tomcat Server:

  ```
  $ /<TOMCAT DIRECTORY>/bin/startup.sh
  ```
**Nota**  
***<TOMCAT DIRECTORY>***è il nome della directory di installazione di Tomcat.

Dopo avere aggiornato la configurazione del server Web, vai alla [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#third-offload-linux-jsse-verify).

## Fase 4: abilitazione del traffico HTTPS e verifica del certificato
<a name="third-offload-linux-jsse-verify"></a>

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 consente il traffico HTTPS in entrata. Ciò consente ai client, come i browser Web, di stabilire una connessione HTTPS con il server Web. Quindi stabilisci una connessione HTTPS al tuo server web e verifica che stia utilizzando il certificato con cui hai configurato per l' SSL/TLS offload. AWS CloudHSM

**Topics**
+ [Abilitazione delle connessioni HTTPS in entrata](#jsse-linux-add-security-group)
+ [Verifica dell'utilizzo da parte di HTTPS del certificato configurato](#jsse-linux-verify-https-connection)

### Abilitazione delle connessioni HTTPS in entrata
<a name="jsse-linux-add-security-group"></a>

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
<a name="jsse-linux-verify-https-connection"></a>

Dopo aver aggiunto il server Web a un gruppo di sicurezza, puoi verificare che SSL/TLS offload utilizzi il tuo certificato autofirmato. Per farlo, puoi utilizzare un browser Web o uno strumento come [OpenSSL s\$1client](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. Accertarsi 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 esempio, https://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 che hai configurato per l'uso sul tuo server web.

**Per verificare l' SSL/TLS offload con OpenSSL s\$1client**

1. Esegui il seguente comando OpenSSL per connetterti al server Web tramite HTTPS. Sostituisci *<server name>* con il nome DNS pubblico o l'indirizzo IP del tuo server web. 

   ```
   openssl s_client -connect <server name>:443
   ```
**Suggerimento**  
Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://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 che hai configurato per l'uso sul 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).

# AWS CloudHSM Offload SSL/TLS su Windows tramite IIS con KSP
<a name="ssl-offload-windows"></a>

Questo tutorial fornisce step-by-step istruzioni per configurare l' SSL/TLS offload con AWS CloudHSM su un server Web Windows.

**Topics**
+ [Panoramica di](#ssl-offload-windows-overview)
+ [Fase 1: configurazione dei prerequisiti](#ssl-offload-prerequisites-windows)
+ [Fase 2: creazione di una richiesta di firma del certificato (CSR) e di un certificato](#ssl-offload-windows-create-csr-and-certificate)
+ [Fase 3: configurazione del server Web](#ssl-offload-configure-web-server-windows)
+ [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#ssl-offload-enable-traffic-and-verify-certificate-windows)

## Panoramica di
<a name="ssl-offload-windows-overview"></a>

In Windows [Internet Information Services (IIS) per l'applicazione del server Web Windows Server](https://www.iis.net/) supporta HTTPS in modo nativo. Il [provider di archiviazione delle AWS CloudHSM chiavi (KSP) per l'API di crittografia di Microsoft: Next Generation (CNG)](ksp-library.md) fornisce l'interfaccia che consente a IIS di utilizzare IIS HSMs nel cluster per l'offload crittografico e l'archiviazione delle chiavi. AWS CloudHSM KSP è il bridge che collega IIS al cluster. AWS CloudHSM 

In questo tutorial vengono illustrate 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-prerequisites-windows).

## Fase 1: configurazione dei prerequisiti
<a name="ssl-offload-prerequisites-windows"></a>

Piattaforme diverse richiedono prerequisiti diversi. Utilizza la sezione sui prerequisiti riportata di seguito corrispondente alla tua piattaforma.

**Topics**
+ [Prerequisiti per Client SDK 5](#ssl-offload-prerequisites-windows-sdk5)
+ [Prerequisiti per Client SDK 3](#ssl-offload-prerequisites-windows-sdk3)

### Prerequisiti per Client SDK 5
<a name="ssl-offload-prerequisites-windows-sdk5"></a>

Per configurare l' SSL/TLS offload del server Web con, è necessario quanto segue: AWS CloudHSM
+ Un AWS CloudHSM cluster attivo con almeno un HSM.
+ Un'istanza Amazon EC2 che esegue un sistema operativo Windows su cui sia installato il seguente software:
  + Il software AWS CloudHSM client per Windows.
  + Internet Information Services (IIS) per Windows Server.
+ 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.

**Nota**  
Questo tutorial utilizza Microsoft Windows Server 2019. Sono supportati anche Microsoft Windows Server 2016 e 2022.

**Per configurare un'istanza di Windows Server e creare un CU sull'HSM**

1. Completa le fasi descritte in [Nozioni di base](getting-started.md). Quando avvii il client Amazon EC2, scegli un'AMI Windows Server 2019. Dopo aver completato queste fasi, sarà presente un cluster attivo con almeno un HSM. Hai anche un'istanza client Amazon EC2 che esegue Windows Server con il software AWS CloudHSM client per Windows installato.

1. (Facoltativo) Aggiungine altri HSMs al cluster. Per ulteriori informazioni, consulta [Aggiungere un HSM a un cluster AWS CloudHSM](add-hsm.md).

1. Connettersi al server Windows. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Utilizza la CLI di CloudHSM per creare un crypto user (CU). Prendere nota del nome utente e della password del CU, Saranno necessari per completare la fase successiva. 
**Nota**  
Per le informazioni sulla creazione di un utente, consulta la pagina sulla [gestione degli utenti HSM con la CLI di CloudHSM](manage-hsm-users-chsm-cli.md).

1. [Impostare le credenziali di accesso per l'HSM](ksp-library-authentication.md), utilizzando il nome utente e la password CU creati nella fase precedente.

1. Nel passaggio 5, se hai utilizzato Windows Credentials Manager per impostare le credenziali HSM, scarica [https://live.sysinternals.com/psexec.exe](https://live.sysinternals.com/psexec.exe)da SysInternals per eseguire il comando seguente come *NT* Authority\$1 SYSTEM:

   ```
   psexec.exe -s "C:\Program Files\Amazon\CloudHsm\tools\set_cloudhsm_credentials.exe" --username <USERNAME> --password <PASSWORD>
   ```

   Sostituisci *<USERNAME>* e *<PASSWORD>* con le credenziali HSM.

**Per installare IIS in Windows Server**

1. Effettuare la connessione al server Windows, se non è stato ancora fatto. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Su Windows Server avviare **Server Manager**.

1. Nel pannello di controllo **Server Manager** scegliere **Add roles and features (Aggiungi ruoli e funzionalità)**.

1. Leggere le informazioni **Before you begin (Prima di iniziare)**, quindi scegliere **Next (Successivo)**.

1. Per **Installation Type (Tipo di installazione)** scegliere **Role-based or feature-based installation (Installazione basata su ruoli o su funzionalità)**. Quindi scegli **Successivo**.

1. Per **Server Selection (Selezione server)** scegliere **Select a server from the server pool (Seleziona un server dal gruppo di server)**. Quindi scegli **Successivo**.

1. Per **Server Roles (Ruoli server)** utilizzare la seguente procedura:

   1. Selezionare **Web Server (IIS)**.

   1. Per **Add features that are required for Web Server (IIS) (Aggiungi le funzionalità richieste per Web Server (IIS))** scegliere **Add Features (Aggiungi caratteristiche)**.

   1. Selezionare **Next (Successivo)** per terminare la selezione dei ruoli server.

1. Per **Caratteristiche**, accettare le impostazioni predefinite. Quindi scegli **Successivo**.

1. Leggere le informazioni su **Web Server Role (IIS) (Ruolo Web Server)**. Quindi scegli **Successivo**.

1. Per **Select server roles (Seleziona ruoli server)**, accettare le impostazioni predefinite o modificarle in base alle esigenze. Quindi scegli **Successivo**.

1. Per **Confirmation (Conferma)**, leggere le informazioni di conferma. Quindi scegliere **Install (Istalla)**.

1. Al termine dell'installazione, scegliere **Close (Chiudi)**.

Dopo aver completato queste operazioni, andare su [Fase 2: creazione di una richiesta di firma del certificato (CSR) e di un certificato](#ssl-offload-windows-create-csr-and-certificate).

### Prerequisiti per Client SDK 3
<a name="ssl-offload-prerequisites-windows-sdk3"></a>

Per configurare l' SSL/TLS offload del server Web con AWS CloudHSM, è necessario quanto segue:
+ Un AWS CloudHSM cluster attivo con almeno un HSM.
+ Un'istanza Amazon EC2 che esegue un sistema operativo Windows su cui sia installato il seguente software:
  + Il software AWS CloudHSM client per Windows.
  + Internet Information Services (IIS) per Windows Server.
+ 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.

**Nota**  
In questo tutorial viene utilizzato Microsoft Windows Server 2016. È supportato anche Microsoft Windows Server 2012, ma non è supportato Microsoft Windows Server 2012 R2.

**Per configurare un'istanza di Windows Server e creare un CU sull'HSM**

1. Completa le fasi descritte in [Nozioni di base](getting-started.md). All'avvio del client Amazon EC2, scegliere un'AMI Windows Server 2016 o Windows Server 2012. Dopo aver completato queste fasi, sarà presente un cluster attivo con almeno un HSM. Hai anche un'istanza client Amazon EC2 che esegue Windows Server con il software AWS CloudHSM client per Windows installato.

1. (Facoltativo) Aggiungine altri HSMs al cluster. Per ulteriori informazioni, consulta [Aggiungere un HSM a un cluster AWS CloudHSM](add-hsm.md).

1. Connettersi al server Windows. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Utilizza la CLI di CloudHSM per creare un crypto user (CU). Prendere nota del nome utente e della password del CU, Saranno necessari per completare la fase successiva. 
**Nota**  
Per le informazioni sulla creazione di un utente, consulta la pagina sulla [gestione degli utenti HSM con la CLI di CloudHSM](manage-hsm-users-chsm-cli.md).

1. [Impostare le credenziali di accesso per l'HSM](ksp-library-prereq.md), utilizzando il nome utente e la password CU creati nella fase precedente.

1. Nel passaggio 5, se hai utilizzato Windows Credentials Manager per impostare le credenziali HSM, scarica [https://live.sysinternals.com/psexec.exe](https://live.sysinternals.com/psexec.exe)da SysInternals per eseguire il comando seguente come *NT* Authority\$1 SYSTEM:

   ```
   psexec.exe -s "C:\Program Files\Amazon\CloudHsm\tools\set_cloudhsm_credentials.exe" --username <USERNAME> --password <PASSWORD>
   ```

   Sostituisci *<USERNAME>* e *<PASSWORD>* con le credenziali HSM.

**Per installare IIS in Windows Server**

1. Effettuare la connessione al server Windows, se non è stato ancora fatto. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Su Windows Server avviare **Server Manager**.

1. Nel pannello di controllo **Server Manager** scegliere **Add roles and features (Aggiungi ruoli e funzionalità)**.

1. Leggere le informazioni **Before you begin (Prima di iniziare)**, quindi scegliere **Next (Successivo)**.

1. Per **Installation Type (Tipo di installazione)** scegliere **Role-based or feature-based installation (Installazione basata su ruoli o su funzionalità)**. Quindi scegli **Successivo**.

1. Per **Server Selection (Selezione server)** scegliere **Select a server from the server pool (Seleziona un server dal gruppo di server)**. Quindi scegli **Successivo**.

1. Per **Server Roles (Ruoli server)** utilizzare la seguente procedura:

   1. Selezionare **Web Server (IIS)**.

   1. Per **Add features that are required for Web Server (IIS) (Aggiungi le funzionalità richieste per Web Server (IIS))** scegliere **Add Features (Aggiungi caratteristiche)**.

   1. Selezionare **Next (Successivo)** per terminare la selezione dei ruoli server.

1. Per **Caratteristiche**, accettare le impostazioni predefinite. Quindi scegli **Successivo**.

1. Leggere le informazioni su **Web Server Role (IIS) (Ruolo Web Server)**. Quindi scegli **Successivo**.

1. Per **Select server roles (Seleziona ruoli server)**, accettare le impostazioni predefinite o modificarle in base alle esigenze. Quindi scegli **Successivo**.

1. Per **Confirmation (Conferma)**, leggere le informazioni di conferma. Quindi scegliere **Install (Istalla)**.

1. Al termine dell'installazione, scegliere **Close (Chiudi)**.

Dopo aver completato queste operazioni, andare su [Fase 2: creazione di una richiesta di firma del certificato (CSR) e di un certificato](#ssl-offload-windows-create-csr-and-certificate).

## Fase 2: creazione di una richiesta di firma del certificato (CSR) e di un certificato
<a name="ssl-offload-windows-create-csr-and-certificate"></a>

Per abilitare HTTPS, il server Web necessita di un SSL/TLS certificato e della chiave privata corrispondente. Per utilizzare SSL/TLS offload con AWS CloudHSM, memorizzi la chiave privata nell'HSM del cluster. AWS CloudHSM Per eseguire questa operazione, è possibile utilizzare il [provider di archiviazione delle chiavi (KSP)AWS CloudHSM per Cryptography API: Next Generation (CNG) di Microsoft](ksp-v3-library.md) per creare una richiesta di firma del certificato (CSR). La CSR viene quindi inviata a un'autorità di certificazione (CA), che la firma per ottenere un certificato.

**Topics**
+ [Crea una CSR con Client SDK 5](#ssl-offload-windows-create-csr-new-version)
+ [Crea una CSR con Client SDK 3](#ssl-offload-windows-create-csr-old-version)
+ [Come ottenere un certificato firmato e importarlo](#ssl-offload-windows-create-certificate)

### Crea una CSR con Client SDK 5
<a name="ssl-offload-windows-create-csr-new-version"></a>

1. Nel Windows Server utilizzare un editor di testo per creare un file di richiesta di certificato denominato `IISCertRequest.inf`. Di seguito viene mostrato il contenuto di un file `IISCertRequest.inf` di esempio. Per ulteriori informazioni sulle sezioni, le chiavi e i valori che è possibile specificare nel file, vedi la [documentazione Microsoft](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1#BKMK_New). Non modificare il valore `ProviderName`.

   ```
   [Version]
   Signature = "$Windows NT$"
   [NewRequest]
   Subject = "CN=example.com,C=US,ST=Washington,L=Seattle,O=ExampleOrg,OU=WebServer"
   HashAlgorithm = SHA256
   KeyAlgorithm = RSA
   KeyLength = 2048
   ProviderName = "CloudHSM Key Storage Provider"
   KeyUsage = 0xf0
   MachineKeySet = True
   [EnhancedKeyUsageExtension]
   OID=1.3.6.1.5.5.7.3.1
   ```

1. Utilizzate il [**certreq**comando Windows](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1) per creare una CSR dal `IISCertRequest.inf` file creato nel passaggio precedente. L'esempio seguente salva la CSR in un file denominato `IISCertRequest.csr`. Se hai utilizzato un nome di file diverso per il file di richiesta del certificato, sostituiscilo *IISCertRequest.inf* con il nome file appropriato. Facoltativamente, puoi sostituirlo *IISCertRequest.csr* con un nome di file diverso per il tuo file CSR.

   ```
   C:\>certreq -new IISCertRequest.inf IISCertRequest.csr
   
   CertReq: Request Created
   ```

   Il file `IISCertRequest.csr` contene la CSR. Questa CSR è necessaria per ottenere un certificato firmato.

### Crea una CSR con Client SDK 3
<a name="ssl-offload-windows-create-csr-old-version"></a>

1. Effettuare la connessione al server Windows, se non è stato ancora fatto. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Usa il seguente comando per avviare il demone AWS CloudHSM client.

------
#### [ Amazon Linux ]

   ```
   $ sudo start cloudhsm-client
   ```

------
#### [ Amazon Linux 2 ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ CentOS 7 ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ CentOS 8 ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ RHEL 7 ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ RHEL 8 ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ Ubuntu 16.04 LTS ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ Ubuntu 18.04 LTS ]

   ```
   $ sudo service cloudhsm-client start
   ```

------
#### [ Windows ]
   + Per client Windows dalla versione 1.1.2\$1:

     ```
     C:\Program Files\Amazon\CloudHSM>net.exe start AWSCloudHSMClient
     ```
   + Per client Windows 1.1.1 e versioni precedenti:

     ```
     C:\Program Files\Amazon\CloudHSM>start "cloudhsm_client" cloudhsm_client.exe C:\ProgramData\Amazon\CloudHSM\data\cloudhsm_client.cfg
     ```

------

1. Nel Windows Server utilizzare un editor di testo per creare un file di richiesta di certificato denominato `IISCertRequest.inf`. Di seguito viene mostrato il contenuto di un file `IISCertRequest.inf` di esempio. Per ulteriori informazioni sulle sezioni, le chiavi e i valori che è possibile specificare nel file, vedi la [documentazione Microsoft](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1#BKMK_New). Non modificare il valore `ProviderName`.

   ```
   [Version]
   Signature = "$Windows NT$"
   [NewRequest]
   Subject = "CN=example.com,C=US,ST=Washington,L=Seattle,O=ExampleOrg,OU=WebServer"
   HashAlgorithm = SHA256
   KeyAlgorithm = RSA
   KeyLength = 2048
   ProviderName = "Cavium Key Storage Provider"
   KeyUsage = 0xf0
   MachineKeySet = True
   [EnhancedKeyUsageExtension]
   OID=1.3.6.1.5.5.7.3.1
   ```

1. Utilizzate il [**certreq**comando Windows](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1) per creare una CSR dal `IISCertRequest.inf` file creato nel passaggio precedente. L'esempio seguente salva la CSR in un file denominato `IISCertRequest.csr`. Se hai utilizzato un nome di file diverso per il file di richiesta del certificato, sostituiscilo *IISCertRequest.inf* con il nome file appropriato. Facoltativamente, puoi sostituirlo *IISCertRequest.csr* con un nome di file diverso per il tuo file CSR.

   ```
   C:\>certreq -new IISCertRequest.inf IISCertRequest.csr
           SDK Version: 2.03
   
   CertReq: Request Created
   ```

   Il file `IISCertRequest.csr` contene la CSR. Questa CSR è necessaria per ottenere un certificato firmato.

### Come ottenere un certificato firmato e importarlo
<a name="ssl-offload-windows-create-certificate"></a>

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 utilizzi una CA, inviagli il file CSR (`IISCertRequest.csr`) e usa la CA per creare un certificato firmato. SSL/TLS 

In alternativa all'utilizzo di una CA, è possibile utilizzare uno strumento come [OpenSSL](https://www.openssl.org/) per creare un certificato autofirmato.

**avvertimento**  
I certificati autofirmati non sono considerati attendibili dai browser e non devono essere utilizzati negli ambienti di produzione, ma solo negli ambienti di test.

Le procedure seguenti illustrano come creare un certificato autofirmato e utilizzarlo per firmare la CSR del proprio server Web.

**Per creare un certificato autofirmato**

1. Eseguire il comando OpenSSL seguente per creare una chiave privata. Facoltativamente, puoi sostituirlo *SelfSignedCA.key* con il nome del file per contenere la tua chiave privata.

   ```
   openssl genrsa -aes256 -out SelfSignedCA.key 2048
   Generating RSA private key, 2048 bit long modulus
   ......................................................................+++
   .........................................+++
   e is 65537 (0x10001)
   Enter pass phrase for SelfSignedCA.key:
   Verifying - Enter pass phrase for SelfSignedCA.key:
   ```

1. Eseguire il comando OpenSSL seguente per creare un certificato autofirmato mediante la chiave privata creata nella fase precedente. Si tratta di un comando interattivo. Leggi le istruzioni a video e segui i prompt. Sostituiscilo *SelfSignedCA.key* con il nome del file che contiene la tua chiave privata (se diverso). Facoltativamente, puoi sostituirlo *SelfSignedCA.crt* con il nome del file per contenere il tuo certificato autofirmato.

   ```
   openssl req -new -x509 -days 365 -key SelfSignedCA.key -out SelfSignedCA.crt
   Enter pass phrase for SelfSignedCA.key:
   You are about to be asked to enter information that will be incorporated
   into your certificate request.
   What you are about to enter is what is called a Distinguished Name or a DN.
   There are quite a few fields but you can leave some blank
   For some fields there will be a default value,
   If you enter '.', the field will be left blank.
   -----
   Country Name (2 letter code) [AU]:
   State or Province Name (full name) [Some-State]:
   Locality Name (eg, city) []:
   Organization Name (eg, company) [Internet Widgits Pty Ltd]:
   Organizational Unit Name (eg, section) []:
   Common Name (e.g. server FQDN or YOUR name) []:
   Email Address []:
   ```

**Per utilizzare il certificato autofirmato per firmare la CSR del server Web**
+ Eseguire il seguente comando OpenSSL per utilizzare la chiave privata e il certificato autofirmato per firmare il CSR. Sostituire gli elementi seguenti con i nomi dei file che contengono i dati corrispondenti (se diversi).
  + *IISCertRequest.csr*— Il nome del file che contiene la CSR del server web
  + *SelfSignedCA.crt*— Il nome del file che contiene il certificato autofirmato
  + *SelfSignedCA.key*— Il nome del file che contiene la chiave privata
  + *IISCert.crt*— Il nome del file che contiene il certificato firmato del server web

  ```
  openssl x509 -req -days 365 -in IISCertRequest.csr \
                              -CA SelfSignedCA.crt \
                              -CAkey SelfSignedCA.key \
                              -CAcreateserial \
                              -out IISCert.crt
  Signature ok
  subject=/ST=IIS-HSM/L=IIS-HSM/OU=IIS-HSM/O=IIS-HSM/CN=IIS-HSM/C=IIS-HSM
  Getting CA Private Key
  Enter pass phrase for SelfSignedCA.key:
  ```

Una volta completato il passaggio precedente, avrai un certificato firmato per il server Web (`IISCert.crt`) e un certificato autofirmato (`SelfSignedCA.crt`). A questo punto, vai alla sezione [Fase 3: configurazione del server Web](#ssl-offload-configure-web-server-windows).

## Fase 3: configurazione del server Web
<a name="ssl-offload-configure-web-server-windows"></a>

È possibile aggiornare la configurazione del sito Web IIS per utilizzare il certificato HTTPS creato alla fine della [fase precedente](#ssl-offload-windows-create-csr-and-certificate). Verrà completata la configurazione del software del server Web Windows (IIS) per l' SSL/TLS offload con. AWS CloudHSM

Se hai utilizzato un certificato autofirmato per firmare la CSR, devi innanzitutto importare il certificato autofirmato nelle Autorità di certificazione fonti attendibili Windows.

**Per importare il certificato autofirmato nelle Autorità di certificazione fonti attendibili Windows**

1. Effettuare la connessione al server Windows, se non è stato ancora fatto. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Copiare il certificato autofirmato nel server Windows.

1. Nel server Windows aprire il **Pannello di controllo**.

1. In **Cerca nel Pannello di controllo** digitare **certificates**. Quindi scegliere **Gestisci i certificati computer**.

1. Nella finestra **Certificati ‐ Computer locale**, fai doppio clic su **Trusted Root Certification** Authorities.

1. Fai clic con il pulsante destro del mouse su **Certificati** e quindi scegliere **Tutte le attività**, **Importa**.

1. In **Importazione guidata certificati** scegliere **Avanti**.

1. Scegliere **Sfoglia**, quindi individuare e selezionare il certificato autofirmato. Se il certificato autofirmato è stato creato seguendo le istruzioni nella [fase precedente di questo tutorial](#ssl-offload-windows-create-csr-and-certificate), il nome del certificato sarà `SelfSignedCA.crt`. Seleziona **Apri**.

1. Scegli **Next (Successivo)**.

1. Per **Archivio certificati** scegliere **Mettere tutti i certificati nel seguente archivio**. Quindi accertarsi che sia selezionata l'opzione **Autorità di certificazione radice attendibili** per **Archivio certificati**.

1. Scegliere **Avanti**, quindi scegliere **Fine**.

**Pe aggiornare la configurazione del sito Web IIS**

1. Effettuare la connessione al server Windows, se non è stato ancora fatto. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/EC2_GetStarted.html#ec2-connect-to-instance-windows) nella *Amazon EC2 User Guide*.

1. Avvia il daemon AWS CloudHSM del client.

1. Copia il certificato firmato del server Web (quello creato al termine della [fase precedente di questo tutorial](#ssl-offload-windows-create-csr-and-certificate)) nel server Windows.

1. Sul tuo Windows Server, usa il [**certreq**comando Windows](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/certreq_1) per accettare il certificato firmato, come nell'esempio seguente. Sostituiscilo *IISCert.crt* con il nome del file che contiene il certificato firmato del tuo server Web.

   ```
   C:\>certreq -accept IISCert.crt
           SDK Version: 2.03
   ```

1. Su Windows Server avviare **Server Manager**.

1. Nel pannello di controllo di **Server Manager**, nell'angolo in alto a destra, scegliere **Strumenti**, **Gestione Internet Information Services (IIS)**.

1. Nella finestra **Gestione Internet Information Services (IIS)** fare doppio clic sul nome del server. Quindi fare doppio clic su **Siti**. Selezionare il sito Web.

1. Selezionare **Impostazioni SSL**. Quindi, sulla parte destra della finestra, scegliere **Binding**.

1. Nella finestra **Binding sito Web** scegliere **Aggiungi**.

1. Per **Tipo**, scegliere **https**. Per **Certificato SSL**, scegliere il certificato HTTPS creato alla fine della [fase precedente di questo tutorial](#ssl-offload-windows-create-csr-and-certificate).
**Nota**  
Se si verifica un errore durante l'associazione del certificato, riavviare il server e riprovare l'operazione.

1. Scegli **OK**.

Dopo avere aggiornato la configurazione del sito Web, vai a [Fase 4: abilitazione del traffico HTTPS e verifica del certificato](#ssl-offload-enable-traffic-and-verify-certificate-windows).

## Fase 4: abilitazione del traffico HTTPS e verifica del certificato
<a name="ssl-offload-enable-traffic-and-verify-certificate-windows"></a>

Dopo aver configurato il server Web per l' SSL/TLS offload con AWS CloudHSM, aggiungi l'istanza del server Web a un gruppo di sicurezza che consente il traffico HTTPS in entrata. Ciò consente ai client, come i browser Web, di stabilire una connessione HTTPS con il server Web. Quindi stabilisci una connessione HTTPS al tuo server web e verifica che stia utilizzando il certificato con cui hai configurato per l' SSL/TLS offload. AWS CloudHSM

**Topics**
+ [Abilitazione delle connessioni HTTPS in entrata](#ssl-offload-add-security-group-windows)
+ [Verifica dell'utilizzo da parte di HTTPS del certificato configurato](#ssl-offload-verify-https-connection-windows)

### Abilitazione delle connessioni HTTPS in entrata
<a name="ssl-offload-add-security-group-windows"></a>

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
<a name="ssl-offload-verify-https-connection-windows"></a>

Dopo aver aggiunto il server Web a un gruppo di sicurezza, puoi verificare che SSL/TLS offload utilizzi il tuo certificato autofirmato. Per farlo, puoi utilizzare un browser Web o uno strumento come [OpenSSL s\$1client](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. Accertarsi 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 esempio, https://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 che hai configurato per l'uso sul tuo server web.

**Per verificare l' SSL/TLS offload con OpenSSL s\$1client**

1. Esegui il seguente comando OpenSSL per connetterti al server Web tramite HTTPS. Sostituisci *<server name>* con il nome DNS pubblico o l'indirizzo IP del tuo server web. 

   ```
   openssl s_client -connect <server name>:443
   ```
**Suggerimento**  
Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://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 che hai configurato per l'uso sul 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).

# Aggiungi un sistema di bilanciamento del carico con Elastic Load Balancing AWS CloudHSM per (opzionale)
<a name="third-offload-add-lb"></a>

Dopo aver SSL/TLS configurato l'offload con un server Web, puoi creare più server Web e un sistema di bilanciamento del carico Elastic Load Balancing che indirizza il traffico HTTPS verso i server Web. Un sistema di bilanciamento del carico è in grado di ridurre il carico sui singoli server Web bilanciando il traffico tra due o più server. È inoltre in grado di aumentare la disponibilità del sito Web, poiché il sistema di bilanciamento del carico monitora lo stato dei server Web e instrada solo il traffico verso i server integri. Se un server Web presenta dei problemi, il sistema di bilanciamento del carico interrompe automaticamente l'instradamento del traffico verso quel server.

**Topics**
+ [Passaggio 1. Creazione di una sottorete per un secondo server Web](#ssl-offload-load-balancer-create-new-subnet)
+ [Passaggio 2. Creazione del secondo server Web](#ssl-offload-load-balancer-create-web-server)
+ [Fase 3. Creazione del sistema di bilanciamento del carico](#ssl-offload-load-balancer-create-load-balancer)

## Passaggio 1. Creazione di una sottorete per un secondo server Web
<a name="ssl-offload-load-balancer-create-new-subnet"></a>

Prima di poter creare un altro server Web, è necessario creare una nuova sottorete nello stesso VPC che contiene il server AWS CloudHSM Web e il cluster esistenti. 

**Per creare una nuova sottorete**

1. Apri la [sezione **Sottoreti** della console Amazon VPC](https://console.aws.amazon.com/vpc/home#subnets:).

1. Seleziona **Create Subnet (Crea sottorete)**.

1. Nella finestra di dialogo **Create Subnet (Crea sottorete)**, seguire questi passaggi:

   1. In **Name tag (Assegna un nome al tag)**, digitare un nome per la sottorete.

   1. Per **VPC**, scegli il AWS CloudHSM VPC che contiene il server Web e il cluster esistenti. AWS CloudHSM 

   1. Per **Availability Zone (Zona di disponibilità)**, scegliere una zona di disponibilità diversa da quella che contiene il server Web esistente. 

   1. In **IPv4 CIDR block (Blocco CIDR)**, digitare il blocco CIDR da usare per la sottorete. Ad esempio, digita **10.0.10.0/24**.

   1. Selezionare **Yes, Create (Sì, crea)**.

1. Seleziona la casella di controllo accanto alla sottorete pubblica che contiene il server Web esistente. Si tratta di una sottorete pubblica diversa da quella creata nella fase precedente. 

1. Nel riquadro dei contenuti, scegli la scheda **Tabella di routing**. Quindi scegliere il link per la tabella di routing.   
![\[Seleziona il link della tabella di routing nella console Amazon VPC.\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/images/console-vpc-choose-route-table.png)

1. Selezionare la casella di controllo accanto alla tabella di routing.

1. Scegli la scheda **Associazioni sottoreti**. Quindi scegliere **Edit (Modifica)**.

1. Seleziona la casella di controllo accanto alla sottorete pubblica creata precedentemente in questa procedura. Quindi scegli **Save** (Salva). 

## Passaggio 2. Creazione del secondo server Web
<a name="ssl-offload-load-balancer-create-web-server"></a>

Completa le fasi seguenti per creare un secondo server Web con la stessa configurazione del tuo server Web esistente. 

**Per creare un secondo server Web**

1. Apri la sezione [https://console.aws.amazon.com/ec2/v2/home#Instances:](https://console.aws.amazon.com/ec2/v2/home#Instances:) nella console Amazon EC2.

1. Selezionare la casella di controllo accanto all'istanza del server Web esistente.

1. Scegliere **Actions (Operazioni)**, **Image (Immagine)**, quindi **Create Image (Crea immagine)**. 

1. Nella finestra di dialogo **Crea Image (Crea immagine)**, seguire questi passaggi:

   1. Per **Image name (Nome immagine)**, digitare un nome per l'immagine.

   1. Per **Image description (Descrizione immagine)**, digitare una descrizione per l'immagine.

   1. Scegliere **Create Image (Crea immagine)**. Questa operazione riavvia il server Web esistente.

   1. Scegli l'**ami- link Visualizza immagine in sospeso**. *<AMI ID>*  
![\[Seleziona il link di visualizzazione dell'immagine in sospeso nella console Amazon EC2.\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/images/console-ec2-choose-view-pending-image.png)

      Nella colonna **Stato**, prendi nota dello stato dell'immagine. Se lo stato dell'immagine è **available (disponibile)** (potrebbe essere necessario qualche minuto), passare alla fase successiva. 

1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.

1. Selezionare la casella di controllo accanto al server Web esistente.

1. Scegliere **Actions (Operazioni)**, quindi **Launch More Like This (Avvia altre come questa)**.

1. Selezionare **Edit AMI (Modifica AMI)**.  
![\[Seleziona il link di modifica dell'AMI nella console Amazon EC2.\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/images/console-ec2-choose-edit-ami.png)

1. Nel riquadro di navigazione a sinistra, scegli **Mio AMIs**. Quindi cancellare il testo nella casella di ricerca. 

1. Accanto all'immagine del server Web, scegliere **Select (Seleziona)**.

1. Scegli **Sì, voglio continuare con questo AMI (*<image name>*- ami-*<AMI ID>*)**. 

1. Scegli **Next (Successivo)**.

1. Seleziona un tipo di istanza, quindi scegli **Next: Configure Instance Details (Successivo: configura dettagli dell'istanza)**. 

1. Per **Step 3: Configure Instance Details (Fase 3: Configurare i dettagli dell'istanza)**, procedere come segue:

   1. Per **Network (Rete)**, scegliere il VPC che contiene il server Web esistente.

   1. Per **Subnet (Sottorete)**, scegliere la sottorete pubblica creata per il secondo server Web. 

   1. Per **Auto-assign Public IP (Assegna automaticamente IP pubblico)**, scegliere**Enable (Abilita)**.

   1. Modifica i dettagli rimanenti dell'istanza in base alle preferenze. Quindi, scegliere **Next: Add Storage (Fase successiva: aggiungi storage)**.

1. Modifica le impostazioni di storage come desiderato. Quindi selezionare **Next: Add Tags (Fase successiva: aggiungere tag)**.

1. Aggiungi o modifica i tag come preferito, quindi scegliere **Next: Configure Security Group (Fase successiva: configurare il gruppo di sicurezza)** .

1. Per **Step 6: Configure Security Group (Fase 6: configurare il gruppo di sicurezza)**, procedere come segue:

   1. Per **Assign a security group (Assegna un gruppo di sicurezza)**, scegliere **Select an existing security group (Seleziona un gruppo di sicurezza esistente)**. 

   1. Seleziona la casella di controllo accanto al gruppo di sicurezza denominato **cloudhsm- *<cluster ID>* -sg**. AWS CloudHSM [ha creato questo gruppo di sicurezza per tuo conto quando hai creato il cluster.](create-cluster.md) È necessario scegliere questo gruppo di sicurezza per consentire all'istanza del server Web di connettersi al gruppo presente HSMs nel cluster. 

   1. Seleziona la casella di controllo accanto al gruppo di sicurezza che consente il traffico HTTPS in entrata. Il [gruppo di sicurezza è stato creato in precedenza](ssl-offload-windows.md#ssl-offload-add-security-group-windows).

   1. (Facoltativo) Seleziona la casella di controllo accanto a un gruppo di sicurezza che consente il traffico SSH (per Linux) o RDP (per Windows) in entrata dalla rete. Ovvero, il gruppo di sicurezza deve consentire il traffico TCP in entrata sulla porta 22 (per SSH su Linux) o sulla porta 3389 (per RDP su Windows). In caso contrario, non è possibile connettersi all'istanza del client. Se non disponi di un gruppo di sicurezza come questo, è necessario crearne uno e assegnarlo all'istanza del client in un secondo momento.

   Scegli **Analizza e avvia**.

1. Consultare i dettagli dell'istanza e scegliere **Launch (Avvia)**.

1. Scegliere se avviare l'istanza con una coppia di chiavi esistente, creare una nuova coppia di chiavi o avviare l'istanza senza alcuna coppia di chiavi. 
   + Per utilizzare una coppia di chiavi esistente, eseguire quanto descritto di seguito.

     1. Scegli **Choose an existing key pair** (Scegli una coppia di chiavi esistente).

     1. Per **Select a key pair (Selezionare una coppia di chiavi)**, scegliere la coppia di chiavi da utilizzare.

     1. Seleziona la casella di controllo accanto a **Riconosco di avere accesso al file di chiave privata selezionato (*<private key file name>*.pem) e che senza questo file non sarò in grado di accedere alla mia** istanza.
   + Per creare una nuova coppia di chiavi, eseguire quanto descritto di seguito:

     1. Scegliere **Create a new key pair (Crea nuova coppia di chiavi)**.

     1. Per **Key pair name (Nome coppia di chiavi)**, digitare un nome per la coppia di chiavi.

     1. Scegliere **Download Key Pair (Scarica la coppia di chiavi)** e salvare il file della chiave privata in una posizione protetta e accessibile. 
**avvertimento**  
Non è possibile scaricare nuovamente il file della chiave privata dopo questo punto. Se il file della chiave privata non viene scaricato a questo punto, non sarà possibile accedere all'istanza del client. 
   + Per avviare l'istanza senza una coppia di chiavi, procedere nel seguente modo:

     1. Scegliere **Proceed without a key pair (Procedi senza una coppia di chiavi)**.

     1. Selezionare la casella di controllo accanto a **I acknowledge that I will not be able to connect to this instance unless I already know the password built into this AMI. (Prendo atto che non potrò collegarmi a questa istanza, a meno che io non conosca già la password integrata in questa AMI.)** 

   Scegliere **Launch Instances** (Avvia istanze).

## Fase 3. Creazione del sistema di bilanciamento del carico
<a name="ssl-offload-load-balancer-create-load-balancer"></a>

Completa la procedura seguente per creare un sistema di bilanciamento del carico Elastic Load Balancing che indirizzi il traffico HTTPS ai tuoi server Web. 

**Come creare un bilanciatore del carico**

1. Apri la sezione [ https://console.aws.amazon.com/ec2/v2/home#LoadBalancers:]( https://console.aws.amazon.com/ec2/v2/home#LoadBalancers:) nella console Amazon EC2.

1. Seleziona **Crea sistema di bilanciamento del carico**.

1. Nella sezione **Network Load Balancer (Sistema di bilanciamento del carico della rete)**, selezionare **Create (Crea)**.

1. Per **Step 1: Configure Load Balancer (Fase 1: configurare il sistema di bilanciamento del carico)**, procedere come segue:

   1. Per **Name (Nome)**, digitare un nome per il sistema di bilanciamento del carico in fase di creazione.

   1. Nella sezione **Ascoltatori**, per **Porta del sistema di bilanciamento del carico**, modifica il valore impostandolo su **443**.

   1. Nella sezione **Availability Zones (Zone di disponibilità)**, per **VPC** scegliere il VPC che contiene i server Web. 

   1. Nella sezione **Availability Zones (Zone di disponibilità)**, scegliere le sottoreti che contengono i server Web. 

   1. Seleziona **Successivo: Configurazione del routing**.

1. Per **Step 2: Configure Routing (Fase 2: configurare l'instradamento)**, procedere come segue:

   1. Per **Name (Nome)**, digitare un nome per il gruppo target in fase di creazione.

   1. Per **Porta**, modifica il valore impostandolo su **443**.

   1. Seleziona **Next: Register Targets** (Fase successiva: registrazione delle destinazioni).

1. Per **Step 3: Register Targets (Fase 3: registrare i target)**, procedere come segue:

   1. Nella sezione **Istanze**, seleziona le caselle di controllo accanto alle istanze del server Web. Quindi scegliere **Add to registered (Aggiungi a elementi registrati)**. 

   1. Scegli **Prossimo: Rivedi**.

1. Esaminare i dettagli del sistema di bilanciamento del carico, quindi scegliere **Create (Crea)**.

1. Se il sistema di bilanciamento del carico è stato creato correttamente, scegliere **Close (Chiudi)**.

Dopo aver completato i passaggi precedenti, la console Amazon EC2 mostra il sistema di bilanciamento del carico Elastic Load Balancing.

Quando lo stato del sistema di bilanciamento del carico è attivo, puoi verificare se il sistema è in funzione. Cioè, puoi verificare che stia inviando traffico HTTPS ai tuoi server web con SSL/TLS offload with. AWS CloudHSM Per farlo, puoi utilizzare un browser Web o uno strumento come [OpenSSL s\$1client](https://www.openssl.org/docs/manmaster/man1/s_client.html). 

**Per verificare se il tuo sistema di bilanciamento del carico funziona con un browser Web**

1. Nella console Amazon EC2, individua il **nome DNS** del sistema di bilanciamento del carico appena creato. quindi selezionare il nome DNS e copiarlo. 

1. Utilizza un browser Web, ad esempio Mozilla Firefox o Google Chrome, per connetterti al sistema di bilanciamento del carico utilizzando il relativo nome DNS. Accertarsi che l'URL nella barra degli indirizzi inizi con https://. 
**Suggerimento**  
Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://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 certificato corrisponda a quello configurato per l'uso da parte del server Web.

**Per verificare se il sistema di bilanciamento del carico funziona con OpenSSL s\$1client**

1. Utilizza il seguente comando OpenSSL per connetterti al sistema di bilanciamento del carico tramite HTTPS. *<DNS name>*Sostituiscilo con il nome DNS del tuo sistema di bilanciamento del carico. 

   ```
   openssl s_client -connect <DNS name>:443
   ```
**Suggerimento**  
Puoi utilizzare un servizio DNS come Amazon Route 53 per indirizzare il nome di dominio del tuo sito Web (ad esempio, https://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 certificato corrisponda a quello configurato per l'uso da parte del server Web.

Ora hai un sito Web protetto con HTTPS, con la chiave privata del server Web archiviata in un HSM del tuo cluster. AWS CloudHSM Il tuo sito Web ha due server Web e un sistema di bilanciamento del carico per aiutare a migliorare l'efficienza e la disponibilità.