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

# Inizializza il cluster in AWS CloudHSM
<a name="initialize-cluster"></a>

Dopo aver creato il cluster e aggiunto il modulo di sicurezza hardware (HSM) AWS CloudHSM, è possibile inizializzare il cluster. Completa le fasi descritte negli argomenti seguenti per inizializzare il cluster .

**Nota**  
Prima di inizializzare il cluster, esamina il processo mediante il quale è possibile [verificare l'identità e l'autenticità](verify-hsm-identity.md) del. HSMs Questa procedura è facoltativa e puoi seguirla solo finché non inizializzi il cluster. Dopo l'inizializzazione del cluster, non è possibile utilizzare questo processo per ottenere i certificati o verificare il. HSMs 

**Topics**
+ [Panoramica di](#initialize-cluster-overview)
+ [Passaggio 1. Ottenere la CSR del cluster](#get-csr)
+ [Passaggio 2. Crea una chiave privata per la tua Root CA](#sign-csr-create-key)
+ [Fase 3. Firma la CSR](#sign-csr)
+ [Passaggio 4. Inizializzazione del cluster](#initialize)

## Panoramica di
<a name="initialize-cluster-overview"></a>

 Il processo di inizializzazione del cluster stabilisce la proprietà e il controllo del cluster e dell'utente HSMs tramite un sistema di autenticazione basato su certificati. Questo processo dimostra crittograficamente che sei l'unico proprietario del HSMs cluster e crea le basi di fiducia che saranno necessarie per tutte le future connessioni al tuo. HSMs 

 Questa pagina ti mostrerà come fare quanto segue: 
+ Recupera la richiesta di firma del certificato (CSR) del tuo cluster.
+ Genera e usa le chiavi private per creare un certificato radice autofirmato o una catena di certificati.
+ Firma la CSR del tuo cluster per produrre un certificato HSM firmato.
+ Inizializza il cluster utilizzando il certificato HSM firmato e il certificato o la catena di certificati autofirmati.

Quando sei pronto per iniziare, vai a [Passaggio 1. Ottenere la CSR del cluster](#get-csr).

## Passaggio 1. Ottenere la CSR del cluster
<a name="get-csr"></a>

Prima di inizializzare il cluster, occorre scaricare e firmare una richiesta di firma del certificato (CSR) generata dal primo HSM del cluster. Se hai seguito le fasi per [verificare l'identità dell'HSM del cluster](verify-hsm-identity.md), disponi già della CSR e puoi quindi firmarla. Altrimenti, ottieni subito la CSR utilizzando la [AWS CloudHSM console](https://console.aws.amazon.com/cloudhsm/), il [AWS Command Line Interface (AWS CLI)](https://aws.amazon.com/cli/) o l'API. AWS CloudHSM 

------
#### [ Console ]

**Per ottenere la CSR (console)**

1. Apri la AWS CloudHSM console a [https://console.aws.amazon.com/cloudhsm/casa](https://console.aws.amazon.com/cloudhsm/home).

1. Seleziona il pulsante di opzione accanto all'ID del cluster con l'HSM che desideri verificare.

1. Seleziona **Azioni**. Dal menu a tendina, scegli **Inizializza**.

1. Se non hai completato il [passaggio precedente](create-hsm.md) per creare un HSM, scegli una zona di disponibilità (AZ) per l'HSM che stai creando. Quindi seleziona **Crea**.

1. Quando la CSR è pronta, verrà visualizzato un collegamento per scaricarla.  
![\[Scarica la pagina di richiesta di firma del certificato nella AWS CloudHSM console.\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/images/download-csr-hsm-cert.png)

1. Sceglie **CSR del cluster** per scaricare e salvare la CSR.

------
#### [ AWS CLI ]

**Per ottenere la CSR ([AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/))**
+ Al prompt dei comandi, esegui il seguente comando **[describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/cloudhsmv2/describe-clusters.html)**, che estrae la CSR e la salva in un file. Sostituisci *<cluster ID>* con l'ID del cluster [creato in precedenza](create-cluster.md). 

  ```
  $ aws cloudhsmv2 describe-clusters --filters clusterIds=<cluster ID> \
                                     --output text \
                                     --query 'Clusters[].Certificates.ClusterCsr' \
                                     > <cluster ID>_ClusterCsr.csr
  ```

------
#### [ AWS CloudHSM API ]

**Per ottenere la CSR (AWS CloudHSM API)**

1. Inviare una richiesta [https://docs.aws.amazon.com/cloudhsm/latest/APIReference/API_DescribeClusters.html](https://docs.aws.amazon.com/cloudhsm/latest/APIReference/API_DescribeClusters.html).

1. Estrai e salva la CSR dalla risposta.

------

## Passaggio 2. Crea una chiave privata per la tua Root CA
<a name="sign-csr-create-key"></a>

**Nota**  
Per i cluster di produzione, la chiave deve essere creata in modo sicuro tramite una fonte attendibile di casualità. Ti consigliamo di utilizzare un HSM offline e fuori sede protetto o un equivalente. Archivia la chiave in modo sicuro. La chiave stabilisce l'identità del cluster e il controllo esclusivo dell'utente su HSMs ciò che contiene.  
Durante le fasi di sviluppo e di testing, puoi utilizzare qualsiasi strumento adatto (come OpenSSL) per creare e firmare il certificato del cluster. Nell'esempio seguente viene illustrato come creare una chiave. Dopo aver creato un certificato autofirmato usando la chiave (vedi sotto), archivialo in modo sicuro. Per accedere all' AWS CloudHSM istanza, è necessario che il certificato sia presente, ma la chiave privata no.

La tabella seguente riporta gli algoritmi, le dimensioni delle chiavi e le curve supportati per la generazione dei certificati.


| Algoritmi | Dimensioni/curve | 
| --- | --- | 
| **RSA 5. PKCSv1** |  2048, 3072, 4096  | 
| **RSA-PSS** |  2048, 3072, 4096  | 
| **ECDSA** |  primo 256v1, secp 384r1, secp 521r1  | 
| **Digest** |  SHA-224, SHA-256, SHA-384 e SHA-512  | 

Utilizzate il seguente comando di esempio per creare una chiave privata per la vostra Root CA autofirmata.

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

## Fase 3. Firma la CSR
<a name="sign-csr"></a>

Nei passaggi precedenti, hai recuperato la CSR del cluster e creato una chiave privata per la tua CA principale. In questo passaggio, utilizzerai la tua chiave privata per generare un certificato di firma per firmare la CSR del cluster. Gli argomenti seguenti ti guideranno attraverso il processo di creazione di un singolo certificato autofirmato, o di una catena di certificati, utilizzando OpenSSL. Non ne hai bisogno AWS CLI per questo passaggio e non è necessario che la shell sia associata al tuo account. AWS 

**Importante**  
Per inizializzare il cluster, l'ancora di fiducia deve essere conforme alla [RFC 5280](https://datatracker.ietf.org/doc/html/rfc5280) e soddisfare i seguenti requisiti:   
Se si utilizzano estensioni X509v3, deve essere presente l'estensione X509v3 Basic Constraints.
L'ancora di fiducia deve essere un certificato autofirmato.
I valori delle estensioni non devono essere in conflitto tra loro.

Scegli uno dei seguenti approcci per firmare la CSR del tuo cluster:

### Scegli il tuo approccio basato sui certificati
<a name="certificate-approach-choice"></a>

È necessario scegliere uno dei due approcci seguenti. Non completare entrambi gli approcci.

**Opzione A: certificato singolo autofirmato**  
Crea un unico certificato radice autofirmato per firmare la CSR del tuo cluster. Questo è il metodo più semplice e diretto per stabilire la fiducia.  
**Consigliato per:**  
+ Ambienti in cui non è richiesta una PKI esterna
+ Ambienti di test e sviluppo in cui è preferibile la semplicità
Vai a: [Crea un unico certificato autofirmato](#self-signed-certificate)

**Opzione B: catena di certificati con CA intermedia**  
Crea una catena di certificati utilizzando un'autorità di certificazione intermedia. Una catena di certificati intermedia offre maggiore sicurezza, scalabilità e flessibilità, poiché consente alle autorità di certificazione principali (CAs) di rimanere offline mentre delegano l'emissione dei certificati a quelle intermedie CAs, riducendo così il rischio di compromettere la CA principale.  
**Consigliato per:**  
+ Ambienti in cui è richiesta una PKI esterna
+ Integrazione con AWS Private Certificate Authority (PCA)
**Esempio di integrazione con AWS PCA:** puoi usare AWS Private Certificate Authority per creare e gestire i tuoi certificati CA intermedi. Ciò fornisce una gestione automatizzata del ciclo di vita dei certificati, compresi il rinnovo e la revoca, mantenendo al contempo i vantaggi in termini di sicurezza derivanti dal mantenere offline la CA root. Per ulteriori informazioni sulla AWS PCA, consulta la [AWS Private Certificate Authority User Guide](https://docs.aws.amazon.com/privateca/latest/userguide/PcaWelcome.html).  
Vai a: [Crea una catena di autorità di certificazione intermedia (ICA)](#certificate-chain)

### Crea un unico certificato autofirmato
<a name="self-signed-certificate"></a>

L'hardware attendibile che usi per creare la chiave privata per il cluster di produzione deve fornire inoltre uno strumento software per la generazione di un certificato autofirmato tramite tale chiave. L'esempio seguente utilizza OpenSSL e la chiave privata creata nel passaggio precedente per creare un certificato di firma CA root autofirmato. Il certificato è valido per 10 anni (3652 giorni). Leggi le istruzioni a video e segui i prompt. 

```
$ openssl req -new -x509 -days 3652 -key customerRootCA.key -out customerRootCA.crt
Enter pass phrase for customerRootCA.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 []:
```

Questo comando crea un file di certificato denominato `customerRootCA.crt`. Inserisci questo certificato su ogni host da cui ti connetterai al tuo cluster. AWS CloudHSM Se dai un nome diverso al file o se lo archivi in un percorso diverso dalla radice dell'host, devi modificare il file di configurazione del client di conseguenza. Utilizza il certificato e la chiave privata appena creati per firmare la richiesta di firma del certificato (CSR) del cluster nella fase successiva. 

#### Firma la CSR del cluster con la tua Root CA autofirmata
<a name="sign-csr-sign-cluster-csr-with-root-ca"></a>

L'hardware attendibile che hai utilizzato per creare la chiave privata per il cluster di produzione deve fornire inoltre uno strumento software per la firma della CSR tramite tale chiave. Nell'esempio seguente viene utilizzato OpenSSL per la firma della CSR del cluster. Il comando di esempio seguente firma la CSR con la firma autofirmata `customerRootCA.crt`

```
$ openssl x509 -req -days 3652 -in <cluster ID>_ClusterCsr.csr \
		-CA <customerRootCA>.crt \
		-CAkey <customerRootCA>.key \
		-CAcreateserial \
		-out <cluster ID>_CustomerHsmCertificate.crt
Signature ok
subject=/C=US/ST=CA/O=Cavium/OU=N3FIPS/L=SanJose/CN=HSM:<HSM identifier>:PARTN:<partition number>, for FIPS mode
Getting CA Private Key
Enter pass phrase for <customerRootCA>.key:
```

Questo comando crea un file denominato `<cluster ID>_CustomerHsmCertificate.crt`. Utilizzalo come certificato firmato durante l'inizializzazione del cluster. 

Verifica il certificato firmato confrontandolo con la CA principale (opzionale):

```
$ openssl verify -purpose sslserver -CAfile customerRootCA.crt <cluster ID>_CustomerHsmCertificate.crt
<cluster ID>_CustomerHsmCertificate.crt: OK
```

Dopo aver prodotto il certificato HSM firmato con la tua Root CA autofirmata, vai a. [Passaggio 4. Inizializzazione del cluster](#initialize)

### Crea una catena di autorità di certificazione intermedia (ICA)
<a name="certificate-chain"></a>

Gli esempi seguenti illustreranno la creazione di una catena di certificati di lunghezza 2, composta da un'autorità di certificazione (CA) principale e una CA intermedia. Per prima cosa creerai un certificato CA radice autofirmato, quindi genererai una CA intermedia firmata dalla CA principale. Infine, utilizzerai la CA intermedia per firmare la CSR del cluster, creando una catena di fiducia completa dal certificato HSM alla CA principale. Questo approccio offre una maggiore sicurezza mantenendo offline la CA principale mentre si utilizza la CA intermedia per le operazioni di certificazione. day-to-day

**Importante**  
Per inizializzare il cluster con una catena di certificati, la catena deve soddisfare i seguenti requisiti:   
La catena deve essere ordinata, a partire dalla CA intermedia che firma la CSR del cluster. In quest'ordine, la prima ICA dovrebbe avere un emittente che corrisponda all'oggetto dell'ICA successiva della catena, e così via.
Solo la Root CA deve essere autofirmata, il che significa che l'emittente e l'oggetto devono essere identici.
La catena non deve essere composta da più di 4 certificati (inclusa la Root CA alla fine) e la dimensione totale della catena non deve superare i 16 kb (kilobyte).
Tutte le autorità di certificazione (CAs) devono essere conformi alle linee guida [RFC](https://datatracker.ietf.org/doc/html/rfc5280) 5280.

Questa sezione fornisce esempi per creare una catena di autorità di certificazione intermedia utilizzando due approcci diversi: OpenSSL per la generazione di certificati locali e AWS Private Certificate Authority (PCA) per i servizi di certificazione gestiti. Scegli l'approccio più adatto al tuo ambiente e ai tuoi requisiti di sicurezza.

**Nota**  
Gli esempi seguenti sono casi d'uso generici e sono entrambi semplificati, utilizzando la configurazione di base. Per gli ambienti di produzione, esamina le opzioni di configurazione aggiuntive e i requisiti di sicurezza specifici per il tuo caso d'uso.

------
#### [ OpenSSL ]

Crea il file di configurazione OpenSSL con le estensioni v3 comuni per CA:

```
$ cat > ca-extensions.conf <<EOF
[req]
distinguished_name = req_distinguished_name
[req_distinguished_name]
C = Country Name (2 letter code)
ST = State or Province Name (full name)
L = Locality Name (eg, city)
O = Organization Name (eg, company)
OU = Organizational Unit Name (eg, section)
CN = Common Name (e.g. server FQDN or YOUR name)
[v3_ca]
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer
basicConstraints = critical,CA:true
keyUsage = critical, keyCertSign, cRLSign, digitalSignature
EOF
```

Genera una CA root autofirmata utilizzando OpenSSL:

```
$ openssl req -new -x509 -days 3652 -key customerRootCA.key -out customerRootCA.crt -extensions v3_ca -config ca-extensions.conf
Enter pass phrase for customerRootCA.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 []:
```

Genera una chiave CA intermedia:

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

Crea la richiesta di firma del certificato CA intermedia (CSR):

```
$ openssl req -new -key intermediateCA.key -out intermediateCA.csr
Enter pass phrase for intermediateCA.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 []:
```

Utilizzando la CA root autofirmata, crea il certificato CA intermedio:

```
$ openssl x509 -req -in intermediateCA.csr \
		-CA customerRootCA.crt \
		-CAkey customerRootCA.key \
		-CAcreateserial \
		-days 3652 \
		-extensions v3_ca \
		-extfile ca-extensions.conf \
		-out intermediateCA.crt

Certificate request self-signature ok
subject=C= , ST= , L= , O= , OU=
```

Combina i certificati in un file a catena:

```
$ cat intermediateCA.crt customerRootCA.crt > chainCA.crt

-----BEGIN CERTIFICATE-----
[Intermediate CA]
-----END CERTIFICATE-----
...
...
-----BEGIN CERTIFICATE-----
[Root CA]
-----END CERTIFICATE-----
```

Firma la CSR del cluster con la tua CA intermedia:

```
$ openssl x509 -req -days 3652 -in <cluster ID>_ClusterCsr.csr \
			-CA intermediateCA.crt \
			-CAkey intermediateCA.key \
			-CAcreateserial \
			-out <cluster ID>_CustomerHsmCertificate.crt
Signature ok
subject=/C=US/ST=CA/O=Cavium/OU=N3FIPS/L=SanJose/CN=HSM:<HSM identifier>:PARTN:<partition number>, for FIPS mode
Getting CA Private Key
Enter pass phrase for intermediateCA.key:
```

------
#### [ AWS PCA ]

Crea e attiva una CA root utilizzando AWS Private Certificate Authority:

```
$ # 1. Create Root CA
aws acm-pca create-certificate-authority \
    --certificate-authority-configuration \
        "KeyAlgorithm=RSA_4096,
        SigningAlgorithm=SHA256WITHRSA,
        Subject={Country=US,Organization=MyOrg,OrganizationalUnit=IT,CommonName=RootCA}" \
    --certificate-authority-type ROOT

# Store the Root CA Authority ARN from the previous output
ROOT_CA_AUTHORITY_ARN="arn:aws:acm-pca:<region>:<account-id>:certificate-authority/<ca-authority-id>"

# 2. Generate Root CA CSR
aws acm-pca get-certificate-authority-csr \
    --certificate-authority-arn $ROOT_CA_AUTHORITY_ARN \
    --output text > customerRootCA.csr

# 3. Self-sign Root CA Certificate
aws acm-pca issue-certificate \
    --certificate-authority-arn $ROOT_CA_AUTHORITY_ARN \
    --csr fileb://customerRootCA.csr \
    --signing-algorithm SHA256WITHRSA \
	--template-arn arn:aws:acm-pca:::template/RootCACertificate/V1 \
    --validity Value=3652,Type=DAYS

# Store the Root CA certificate ARN from the previous output
ROOT_CA_ARN="arn:aws:acm-pca:<region>:<account-id>:certificate-authority/<ca-authority-id>/certificate/<cert-id>"

# 4. Retrieve the Root CA certificate
aws acm-pca get-certificate \
    --certificate-authority-arn $ROOT_CA_AUTHORITY_ARN \
    --certificate-arn $ROOT_CA_ARN \
    --output text > customerRootCA.crt

# 5. Import the Root CA Certificate
aws acm-pca import-certificate-authority-certificate \
    --certificate-authority-arn $ROOT_CA_AUTHORITY_ARN \
    --certificate fileb://customerRootCA.crt
```

Crea e attiva una CA subordinata (nota anche come CA intermedia):

```
$ # 6. Create Subordinate CA
aws acm-pca create-certificate-authority \
    --certificate-authority-configuration \
        "KeyAlgorithm=RSA_4096,
        SigningAlgorithm=SHA256WITHRSA,
        Subject={Country=US,Organization=MyOrg,OrganizationalUnit=IT,CommonName=SubordinateCA}" \
    --certificate-authority-type SUBORDINATE

# Store the Subordinate CA Authority ARN from the previous output
SUB_CA_AUTHORITY_ARN="arn:aws:acm-pca:<region>:<account-id>:certificate-authority/<sub-ca-authority-id>"

# 7. Generate Subordinate CA CSR
aws acm-pca get-certificate-authority-csr \
    --certificate-authority-arn $SUB_CA_AUTHORITY_ARN \
    --output text > intermediateCA.csr

# 8. Issue Subordinate CA Certificate using Root CA
aws acm-pca issue-certificate \
    --certificate-authority-arn $ROOT_CA_AUTHORITY_ARN \
    --csr fileb://intermediateCA.csr \
    --signing-algorithm SHA256WITHRSA \
    --template-arn arn:aws:acm-pca:::template/SubordinateCACertificate_PathLen0/V1 \
    --validity Value=3651,Type=DAYS

# Store the Subordinate CA certificate ARN from the previous output
SUB_CA_ARN="arn:aws:acm-pca:<region>:<account-id>:certificate-authority/<sub-ca-authority-id>"

# 9. Retrieve Subordinate CA Certificate
aws acm-pca get-certificate \
    --certificate-authority-arn $ROOT_CA_AUTHORITY_ARN \
    --certificate-arn $SUB_CA_ARN \
    --query 'Certificate' \
    --output text > intermediateCA.crt

# 10. Import the Subordinate CA Certificate
aws acm-pca import-certificate-authority-certificate \
    --certificate-authority-arn $SUB_CA_AUTHORITY_ARN \
    --certificate fileb://intermediateCA.crt \
    --certificate-chain fileb://customerRootCA.crt
```

Combina i certificati in un file a catena:

```
$ cat intermediateCA.crt customerRootCA.crt > chainCA.crt

-----BEGIN CERTIFICATE-----
[Intermediate CA]
-----END CERTIFICATE-----
...
...
-----BEGIN CERTIFICATE-----
[Root CA]
-----END CERTIFICATE-----
```

Firma la CSR del cluster utilizzando AWS PCA:

```
$ aws acm-pca issue-certificate \
    --certificate-authority-arn $SUB_CA_AUTHORITY_ARN \
    --csr fileb://<cluster ID>_ClusterCsr.csr \
    --signing-algorithm SHA256WITHRSA \
    --template-arn arn:aws:acm-pca:::template/EndEntityCertificate/V1 \
    --validity Value=3650,Type=DAYS

# Store your cluster's cert ARN from the previous output
CLUSTER_CERT_ARN="arn:aws:acm-pca:<region>:<account-id>:certificate-authority/<cluster-cert-arn>"
```

Scarica il certificato del cluster firmato:

```
$ aws acm-pca get-certificate \
    --certificate-authority-arn $SUB_CA_AUTHORITY_ARN \
    --certificate-arn $CLUSTER_CERT_ARN \
    --output text --query Certificate > <cluster ID>_CustomerHsmCertificate.crt
```

------

Questo comando crea un file denominato `<cluster ID>_CustomerHsmCertificate.crt`. Utilizzalo come certificato firmato durante l'inizializzazione del cluster. 

Verifica il certificato firmato rispetto alla catena di certificati (opzionale):

```
$ openssl verify -purpose sslserver -CAfile chainCA.crt <cluster ID>_CustomerHsmCertificate.crt
<cluster ID>_CustomerHsmCertificate.crt: OK
```

Dopo aver prodotto il certificato HSM firmato con la tua CA intermedia, vai a. [Passaggio 4. Inizializzazione del cluster](#initialize)

## Passaggio 4. Inizializzazione del cluster
<a name="initialize"></a>

Utilizza il certificato firmato dell'HSM e il certificato di firma per inizializzare il cluster. Puoi usare la [AWS CloudHSM console [AWS CLI](https://aws.amazon.com/cli/)](https://console.aws.amazon.com/cloudhsm/), l'o l' AWS CloudHSM API. 

------
#### [ Console ]

**Per inizializzare un cluster (console)**

1. Apri la AWS CloudHSM console a [https://console.aws.amazon.com/cloudhsm/casa](https://console.aws.amazon.com/cloudhsm/home).

1. Seleziona il pulsante di opzione accanto all'ID del cluster con l'HSM che desideri verificare.

1. Seleziona **Azioni**. Dal menu a tendina, scegli **Inizializza**.

1. Se non hai completato il [passaggio precedente](create-hsm.md) per creare un HSM, scegli una zona di disponibilità (AZ) per l'HSM che stai creando. Quindi seleziona **Crea**.

1. Nella pagina **Scarica richiesta di firma del certificato**, scegli **Successivo**. Se l'opzione **Successivo** non è disponibile, scegli innanzitutto uno dei collegamenti alla CSR o al certificato. Quindi scegli **Successivo**.

1. Nella pagina **Firma richiesta di firma del certificato (CSR)**, scegli **Successivo**.

1. Nella pagina **Carica certificati**, procedi come segue:

   1. Accanto a **Certificato cluster**, scegli **Carica file**. Quindi, individua e seleziona il certificato dell'HSM firmato in precedenza. Se sono state effettuate le fasi riportate nella sezione precedente, seleziona il file denominato `<cluster ID>_CustomerHsmCertificate.crt`.

   1. Accanto a **Certificazione**, scegli **Carica file**. Quindi seleziona il tuo certificato di firma in base all'approccio che hai scelto:
      + **Se hai scelto l'opzione A (certificato autofirmato singolo):** seleziona il file denominato `<customerRootCA>.crt`
      + **Se hai scelto l'opzione B (catena di certificati):** seleziona il file denominato `<chainCA>.crt`

   1. Scegli **Carica e inizializza**.

------
#### [ AWS CLI ]

**Per inizializzare un cluster ([AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/))**
+ Al prompt dei comandi, esegui il comando **[initialize-cluster](https://docs.aws.amazon.com/cli/latest/reference/cloudhsmv2/initialize-cluster.html)**. Specifica quanto segue: 
  + L'ID del cluster creato in precedenza.
  + Il certificato dell'HSM che hai firmato in precedenza. Se sono state effettuate le fasi riportate nella sezione precedente, quest'ultimo è salvato in un file denominato `<cluster ID>_CustomerHsmCertificate.crt`. 
  + Il tuo certificato di firma in base all'approccio che hai scelto:
    + **Se hai scelto l'opzione A (certificato autofirmato singolo):** utilizza il file denominato `<customerRootCA>.crt`
    + **Se hai scelto l'opzione B (catena di certificati):** usa il file denominato `<chainCA>.crt`

  ```
  $ aws cloudhsmv2 initialize-cluster --cluster-id <cluster ID> \
                                      --signed-cert file://<cluster ID>_CustomerHsmCertificate.crt \
                                      --trust-anchor file://<customerRootCA.crt OR chainCA.crt>
  {
      "State": "INITIALIZE_IN_PROGRESS",
      "StateMessage": "Cluster is initializing. State will change to INITIALIZED upon completion."
  }
  ```

------
#### [ AWS CloudHSM API ]

**Per inizializzare un cluster (AWS CloudHSM API)**
+ Invia una richiesta [https://docs.aws.amazon.com/cloudhsm/latest/APIReference/API_InitializeCluster.html](https://docs.aws.amazon.com/cloudhsm/latest/APIReference/API_InitializeCluster.html) con quanto segue:
  + L'ID del cluster creato in precedenza.
  + Il certificato dell'HSM che hai firmato in precedenza. Se sono state effettuate le fasi riportate nella sezione precedente, quest'ultimo è salvato in un file denominato `<cluster ID>_CustomerHsmCertificate.crt`. 
  + Il tuo certificato di firma in base all'approccio che hai scelto:
    + **Se hai scelto l'opzione A (certificato autofirmato singolo):** utilizza il file denominato `<customerRootCA>.crt`
    + **Se hai scelto l'opzione B (catena di certificati):** usa il file denominato `<chainCA>.crt`

------