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à.
# Autenticazione client TLS reciproca per Amazon MSK
Puoi abilitare l'autenticazione client con TLS per le connessioni dalle tue applicazioni ai broker Amazon MSK. Per utilizzare l'autenticazione client, è necessario un CA privata AWS. CA privata AWS Possono appartenere allo Account AWS stesso cluster o a un account diverso. Per informazioni su CA privata AWS s, vedere [Creazione e gestione di un CA privata AWS](https://docs.aws.amazon.com/acm-pca/latest/userguide/create-CA.html).
Amazon MSK non supporta gli elenchi di revoca dei certificati ()CRLs. Per controllare l'accesso agli argomenti del cluster o bloccare i certificati compromessi, usa Apache ACLs Kafka e i gruppi di sicurezza. AWS Per informazioni sull'uso di Apache Kafka, consulta. ACLs [Apache Kafka ACLs](msk-acls.md)
**Topics**
+ [Crea un cluster Amazon MSK che supporti l'autenticazione dei client](msk-authentication-cluster.md)
+ [Configura un client per utilizzare l'autenticazione](msk-authentication-client.md)
+ [Produci e consuma messaggi utilizzando l'autenticazione](msk-authentication-messages.md)
# Crea un cluster Amazon MSK che supporti l'autenticazione dei client
Questa procedura mostra come abilitare l'autenticazione del client utilizzando un CA privata AWS.
**Nota**
Si consiglia vivamente di utilizzare Independent CA privata AWS per ogni cluster MSK quando si utilizza il TLS reciproco per controllare l'accesso. In questo modo assicurerai che i certificati TLS firmati da si autentichino PCAs solo con un singolo cluster MSK.
1. Crea un file denominato `clientauthinfo.json` con i seguenti contenuti. Sostituisci *Private-CA-ARN* con l'ARN del tuo PCA.
```
{
"Tls": {
"CertificateAuthorityArnList": ["Private-CA-ARN"]
}
}
```
1. Crea un file denominato `brokernodegroupinfo.json` come descritto in [Crea un cluster Amazon MSK di cui è stato effettuato il provisioning utilizzando il AWS CLI](create-cluster-cli.md).
1. L'autenticazione client richiede di abilitare anche la crittografia dei dati in transito tra client e broker. Crea un file denominato `encryptioninfo.json` con i seguenti contenuti. Sostituisci *KMS-Key-ARN* con l'ARN della tua chiave KMS. Puoi impostare `ClientBroker` su `TLS` o `TLS_PLAINTEXT`.
```
{
"EncryptionAtRest": {
"DataVolumeKMSKeyId": "KMS-Key-ARN"
},
"EncryptionInTransit": {
"InCluster": true,
"ClientBroker": "TLS"
}
}
```
Per ulteriori informazioni sulla crittografia, consulta [Crittografia di Amazon MSK](msk-encryption.md).
1. Su una macchina su cui è AWS CLI installata, esegui il comando seguente per creare un cluster con l'autenticazione e la crittografia in transito abilitate. Salva l'ARN del cluster fornito nella risposta.
```
aws kafka create-cluster --cluster-name "AuthenticationTest" --broker-node-group-info file://brokernodegroupinfo.json --encryption-info file://encryptioninfo.json --client-authentication file://clientauthinfo.json --kafka-version "{YOUR KAFKA VERSION}" --number-of-broker-nodes 3
```
# Configura un client per utilizzare l'autenticazione
Questo processo descrive come configurare un'istanza Amazon EC2 da utilizzare come client per utilizzare l'autenticazione.
Questo processo descrive come produrre e utilizzare messaggi utilizzando l'autenticazione creando una macchina client, creando un argomento e configurando le impostazioni di sicurezza richieste.
1. Crea un'istanza Amazon EC2 da utilizzare come un computer client. Per semplicità, creare questa istanza nello stesso VPC utilizzato per il cluster. Consulta [Passaggio 3: creazione di un computer client](create-client-machine.md) per un esempio di come creare un computer client di questo tipo.
1. Creazione di un argomento. Per un esempio, consulta le istruzioni in [Fase 4: creare un argomento nel cluster Amazon MSK](create-topic.md).
1. Su una macchina su cui è AWS CLI installato, esegui il comando seguente per ottenere i broker bootstrap del cluster. Sostituisci *Cluster-ARN* con l'ARN del tuo cluster.
```
aws kafka get-bootstrap-brokers --cluster-arn Cluster-ARN
```
Salvare la stringa associata a `BootstrapBrokerStringTls` nella risposta.
1. Sul computer client, eseguire il comando seguente per utilizzare il truststore JVM per creare il truststore client. Se il percorso JVM è diverso, modificare il comando di conseguenza.
```
cp /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.201.b09-0.amzn2.x86_64/jre/lib/security/cacerts kafka.client.truststore.jks
```
1. Sul computer client, eseguire il comando seguente per creare una chiave privata per il client. Sostituisci *Distinguished-Name**Example-Alias*,*Your-Store-Pass*, e *Your-Key-Pass* con stringhe a tua scelta.
```
keytool -genkey -keystore kafka.client.keystore.jks -validity 300 -storepass Your-Store-Pass -keypass Your-Key-Pass -dname "CN=Distinguished-Name" -alias Example-Alias -storetype pkcs12 -keyalg rsa
```
1. Sul computer client, eseguire il comando seguente per creare una richiesta di certificato con la chiave privata creata nella fase precedente.
```
keytool -keystore kafka.client.keystore.jks -certreq -file client-cert-sign-request -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Aprire il file `client-cert-sign-request` e accertarsi che inizi con `-----BEGIN CERTIFICATE REQUEST-----` e termini con `-----END CERTIFICATE REQUEST-----`. Se inizia con `-----BEGIN NEW CERTIFICATE REQUEST-----`, eliminare la parola `NEW` (e il singolo spazio che la segue) dall'inizio e dalla fine del file.
1. Su un computer in cui è AWS CLI installato, esegui il comando seguente per firmare la richiesta di certificato. Sostituisci *Private-CA-ARN* con l'ARN del tuo PCA. Se lo si desidera, è possibile modificare il valore di validità. In questo esempio viene utilizzato 300.
```
aws acm-pca issue-certificate --certificate-authority-arn Private-CA-ARN --csr fileb://client-cert-sign-request --signing-algorithm "SHA256WITHRSA" --validity Value=300,Type="DAYS"
```
Salvare il certificato ARN fornito nella risposta.
**Nota**
Per recuperare il certificato client, utilizza il comando `acm-pca get-certificate` e specifica l'ARN del certificato. Per ulteriori informazioni, consulta la sezione [get-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/acm-pca/get-certificate.html) nella *documentazione di riferimento alla AWS CLI *.
1. Esegui il comando seguente per ottenere il certificato CA privata AWS firmato per te. Sostituisci *Certificate-ARN* con l'ARN ottenuto dalla risposta al comando precedente.
```
aws acm-pca get-certificate --certificate-authority-arn Private-CA-ARN --certificate-arn Certificate-ARN
```
1. Dal risultato JSON dell'esecuzione del comando precedente, copiare le stringhe associate a `Certificate` e `CertificateChain`. Incolla queste due stringhe in un nuovo file denominato. signed-certificate-from-acm Incollare innanzitutto la stringa associata a `Certificate`, seguita dalla stringa associata a `CertificateChain`. Sostituire i caratteri `\n` con nuove righe. Di seguito è riportata la struttura del file dopo aver incollato al suo interno il certificato e la catena di certificati.
```
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
```
1. Eseguire il comando seguente sul computer client per aggiungere questo certificato al keystore in modo da poterlo presentare quando si parla con i broker MSK.
```
keytool -keystore kafka.client.keystore.jks -import -file signed-certificate-from-acm -alias Example-Alias -storepass Your-Store-Pass -keypass Your-Key-Pass
```
1. Crea un file denominato `client.properties` con i seguenti contenuti. Regolare le posizioni del truststore e del keystore sui percorsi in cui è stato salvato `kafka.client.truststore.jks`. Sostituisci i segnaposto con la versione del tuo client Kafka. *\$1YOUR KAFKA VERSION\$1*
```
security.protocol=SSL
ssl.truststore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.truststore.jks
ssl.keystore.location=/tmp/kafka_2.12-{YOUR KAFKA VERSION}/kafka.client.keystore.jks
ssl.keystore.password=Your-Store-Pass
ssl.key.password=Your-Key-Pass
```
# Produci e consuma messaggi utilizzando l'autenticazione
Questo processo descrive come produrre e utilizzare messaggi utilizzando l'autenticazione.
1. Eseguire il comando seguente per creare un argomento. Il file denominato `client.properties` è quello creato nella procedura precedente.
```
/bin/kafka-topics.sh --create --bootstrap-server BootstrapBroker-String --replication-factor 3 --partitions 1 --topic ExampleTopic --command-config client.properties
```
1. Eseguire il comando seguente per avviare un produttore della console. Il file denominato `client.properties` è quello creato nella procedura precedente.
```
/bin/kafka-console-producer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --producer.config client.properties
```
1. In una nuova finestra di comando sul computer client, eseguire il comando seguente per avviare un consumatore della console.
```
/bin/kafka-console-consumer.sh --bootstrap-server BootstrapBroker-String --topic ExampleTopic --consumer.config client.properties
```
1. Digitare i messaggi nella finestra del produttore e guardarli apparire nella finestra del consumatore.