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à.
# Fase 4: creare un argomento nel cluster Amazon MSK
In questa fase di [Guida introduttiva all'uso di Amazon MSK](getting-started.md), puoi creare un argomento utilizzando uno dei due approcci: utilizzando AWS strumenti nativi con l' CreateTopic API o utilizzando gli strumenti Apache Kafka su un computer AdminClient client.
**avvertimento**
Quando utilizzi AWS strumenti con l' CreateTopic API, verifica che il cluster soddisfi i requisiti. Per i dettagli, consulta l'[argomento Requisiti per l'utilizzo APIs](https://docs.aws.amazon.com/msk/latest/developerguide/msk-topic-operations-information.html#topic-operations-requirements).
**avvertimento**
Quando si utilizza l' AdminClient approccio, i numeri di versione di Apache Kafka utilizzati in questo tutorial sono solo esempi. Ti consigliamo di utilizzare la stessa versione del client della versione del cluster MSK. In una versione precedente del client potrebbero mancare alcune funzionalità e correzioni di bug critici.
**Topics**
+ [Creazione di un argomento utilizzando AWS gli strumenti](#create-topic-aws-tools)
+ [Determinazione della versione del cluster MSK](#find-msk-cluster-version)
+ [Creazione di un argomento sul computer client](#create-topic-client-machine)
## Creazione di un argomento utilizzando AWS gli strumenti
È possibile creare argomenti nel cluster MSK utilizzando AWS strumenti come la AWS CLI o AWS la AWS SDKs console di gestione. Questo approccio offre un modo semplificato per gestire gli argomenti senza richiedere l'accesso diretto agli strumenti client Kafka.
Per informazioni dettagliate sulla creazione di argomenti utilizzando gli AWS strumenti, consulta la guida per sviluppatori di [CreateTopic API](https://docs.aws.amazon.com/msk/latest/developerguide/msk-create-topic.html).
## Determinazione della versione del cluster MSK
1. Apri la console Amazon MSK all'indirizzo [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Nella barra di navigazione, scegli la regione in cui hai creato il cluster MSK.
1. Scegliete il cluster MSK.
1. Prendi nota della versione di Apache Kafka utilizzata nel cluster.
1. Sostituisci le istanze dei numeri di versione di Amazon MSK in questo tutorial con la versione ottenuta nel passaggio 3.
## Creazione di un argomento sul computer client
1. **Connect al computer client.**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**. Quindi, seleziona la casella di controllo accanto al nome del computer client in cui hai creato[Passaggio 3: creazione di un computer client](create-client-machine.md).
1. Scegliere **Actions (Operazioni)**, quindi selezionare **Connect (Connetti)**. Segui le istruzioni riportate nella console per connetterti al computer client.
1. **Installa Java e configura la variabile di ambiente della versione Kafka.**
1. Installa Java sul computer client eseguendo il comando seguente.
```
sudo yum -y install java-11
```
1. Memorizza la [versione Kafka](#find-msk-cluster-version) del tuo cluster MSK nella variabile di ambiente`KAFKA_VERSION`, come mostrato nel comando seguente. Avrai bisogno di queste informazioni durante tutta la configurazione.
```
export KAFKA_VERSION={KAFKA VERSION}
```
Ad esempio, se utilizzi la versione 3.6.0, usa il comando seguente.
```
export KAFKA_VERSION=3.6.0
```
1. **Scarica ed estrai Apache Kafka.**
1. Eseguire il seguente comando per scaricare Apache Kafka.
```
wget https://archive.apache.org/dist/kafka/$KAFKA_VERSION/kafka_2.13-$KAFKA_VERSION.tgz
```
**Nota**
L'elenco seguente presenta alcune informazioni alternative per il download di Kafka che è possibile utilizzare in caso di problemi.
Se riscontri problemi di connettività o desideri utilizzare un sito mirror, prova a utilizzare il selettore dei mirror Apache, come mostrato nel comando seguente.
```
wget https://www.apache.org/dyn/closer.cgi?path=/kafka/$KAFKA_VERSION/kafka_2.13-$KAFKA_VERSION.tgz
```
Scaricate una versione appropriata direttamente dal sito Web di [Apache Kafka](https://kafka.apache.org/downloads).
1. Eseguire il comando seguente nella directory in cui è stato scaricato il file TAR nella fase precedente.
```
tar -xzf kafka_2.13-$KAFKA_VERSION.tgz
```
1. Memorizza il percorso completo della directory appena creata all'interno della `KAFKA_ROOT` variabile di ambiente.
```
export KAFKA_ROOT=$(pwd)/kafka_2.13-$KAFKA_VERSION
```
1. **Configura l'autenticazione per il tuo cluster MSK.**
1. [Trova la versione più recente](https://github.com/aws/aws-msk-iam-auth/releases/latest) della libreria client Amazon MSK IAM. Questa libreria consente alla macchina client di accedere al cluster MSK utilizzando l'autenticazione IAM.
1. Utilizzando i seguenti comandi, accedi alla `$KAFKA_ROOT/libs` directory e scarica il JAR Amazon MSK IAM associato che hai trovato nel passaggio precedente. Assicurati di sostituirlo *\$1LATEST VERSION\$1* con il numero di versione effettivo che stai scaricando.
```
cd $KAFKA_ROOT/libs
```
```
wget https://github.com/aws/aws-msk-iam-auth/releases/latest/download/aws-msk-iam-auth-{LATEST VERSION}-all.jar
```
**Nota**
Prima di eseguire qualsiasi comando Kafka che interagisca con il tuo cluster MSK, potresti dover aggiungere il file JAR Amazon MSK IAM al tuo classpath Java. Imposta la variabile di `CLASSPATH` ambiente, come mostrato nell'esempio seguente.
```
export CLASSPATH=$KAFKA_ROOT/libs/aws-msk-iam-auth-{LATEST VERSION}-all.jar
```
Questo imposta la `CLASSPATH` per l'intera sessione, rendendo il JAR disponibile per tutti i comandi Kafka successivi.
1. Vai alla `$KAFKA_ROOT/config` directory per creare il file di configurazione del client.
```
cd $KAFKA_ROOT/config
```
1. Copia le impostazioni delle proprietà seguenti e incollale in un nuovo file. Salva il file con nome **client.properties**.
```
security.protocol=SASL_SSL
sasl.mechanism=AWS_MSK_IAM
sasl.jaas.config=software.amazon.msk.auth.iam.IAMLoginModule required;
sasl.client.callback.handler.class=software.amazon.msk.auth.iam.IAMClientCallbackHandler
```
1. **(Facoltativo) Regola la dimensione dell'heap Java per gli strumenti Kafka.**
Se riscontrate problemi relativi alla memoria o state lavorando con un gran numero di argomenti o partizioni, potete modificare la dimensione dell'heap Java. Per fare ciò, imposta la variabile di `KAFKA_HEAP_OPTS` ambiente prima di eseguire i comandi di Kafka.
L'esempio seguente imposta la dimensione massima e iniziale dell'heap su 512 megabyte. Regola questi valori in base ai requisiti specifici e alle risorse di sistema disponibili.
```
export KAFKA_HEAP_OPTS="-Xmx512M -Xms512M"
```
1. **Ottieni le informazioni sulla connessione al cluster.**
1. Apri la console Amazon MSK all'indirizzo [https://console.aws.amazon.com/msk/](https://console.aws.amazon.com/msk/).
1. Attendi che lo stato del cluster diventi **Attivo**. Questo processo potrebbe richiedere diversi minuti. Dopo che lo stato diventa **Attivo**, scegli il nome del cluster. Verrà visualizzata una pagina contenente il riepilogo del cluster.
1. Scegli **Visualizza le informazioni sul client**.
1. Copia la stringa di connessione per l'endpoint privato.
Otterrai tre endpoint per ciascuno dei broker. Memorizza una di queste stringhe di connessione nella variabile di ambiente`BOOTSTRAP_SERVER`, come illustrato nel comando seguente. Sostituire ** con il valore effettivo della stringa di connessione.
```
export BOOTSTRAP_SERVER=
```
1. **Eseguite il comando seguente per creare l'argomento.**
```
$KAFKA_ROOT/bin/kafka-topics.sh --create --bootstrap-server $BOOTSTRAP_SERVER --command-config $KAFKA_ROOT/config/client.properties --replication-factor 3 --partitions 1 --topic MSKTutorialTopic
```
Se ottenete un `NoSuchFileException` `client.properties` file, assicuratevi che questo file esista nella directory di lavoro corrente all'interno della cartella bin di Kafka.
**Nota**
Se preferite non impostare la variabile di `CLASSPATH` ambiente per l'intera sessione, potete in alternativa aggiungere la variabile come prefisso a ogni comando di Kafka. `CLASSPATH` Questo approccio applica il classpath solo a quel comando specifico.
```
CLASSPATH=$KAFKA_ROOT/libs/aws-msk-iam-auth-{LATEST VERSION}-all.jar \
$KAFKA_ROOT/bin/kafka-topics.sh --create \
--bootstrap-server $BOOTSTRAP_SERVER \
--command-config $KAFKA_ROOT/config/client.properties \
--replication-factor 3 \
--partitions 1 \
--topic MSKTutorialTopic
```
1. **(Facoltativo) Verificate che l'argomento sia stato creato correttamente.**
1. Se il comando ha esito positivo, dovrebbe apparire il seguente messaggio: `Created topic MSKTutorialTopic.`
1. Elenca tutti gli argomenti per confermare l'esistenza dell'argomento.
```
$KAFKA_ROOT/bin/kafka-topics.sh --list --bootstrap-server $BOOTSTRAP_SERVER --command-config $KAFKA_ROOT/config/client.properties
```
Se il comando ha esito negativo o si verifica un errore, consulta [Risolvi i problemi del tuo cluster Amazon MSK](troubleshooting.md) per informazioni sulla risoluzione dei problemi.
1. **(Facoltativo) Eliminate le variabili di ambiente utilizzate in questo tutorial.**
Se desideri mantenere le variabili di ambiente per i passaggi successivi di questo tutorial, salta questo passaggio. Altrimenti, potete annullare l'impostazione di queste variabili, come illustrato nell'esempio seguente.
```
unset KAFKA_VERSION KAFKA_ROOT BOOTSTRAP_SERVER CLASSPATH KAFKA_HEAP_OPTS
```
**Fase successiva**
[Passaggio 5: produzione e utilizzo di dati](produce-consume.md)