

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

# Cos'è MSK Serverless?
<a name="serverless"></a>

**Nota**  
MSK Serverless è disponibile nelle regioni Stati Uniti orientali (Ohio), Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (Oregon), Canada (Centrale), Asia Pacifico (Mumbai), Asia Pacifico (Singapore), Asia Pacifico (Sydney), Asia Pacifico (Tokyo), Asia Pacifico (Seoul), Europa (Francoforte), Europa (Stoccolma), Europa (Irlanda), Europa (Parigi) ed Europa (Londra).

MSK Serverless è un tipo di cluster per Amazon MSK che consente di eseguire Apache Kafka senza dover gestire e dimensionare la capacità del cluster. Fornisce e dimensiona automaticamente la capacità durante la gestione delle partizioni dell'argomento, in modo da poter trasmettere i dati senza pensare all'adeguamento o al dimensionamento dei cluster. MSK Serverless offre un modello tariffario basato sulla velocità di trasmissione effettiva, perciò ti viene addebitato soltanto l'utilizzo effettivo. Se le tue applicazioni richiedono una capacità di streaming on demand con aumento e riduzione automatiche, prendi in considerazione l'utilizzo di un cluster serverless.

MSK Serverless è completamente compatibile con Apache Kafka, quindi è possibile utilizzare qualsiasi applicazione client compatibile per produrre e utilizzare dati. Inoltre, si integra con i seguenti servizi:
+ AWS PrivateLink per fornire connettività privata
+ AWS Identity and Access Management (IAM) per l'autenticazione e l'autorizzazione utilizzando linguaggi Java e non Java. Per istruzioni sulla configurazione dei client per IAM, consulta [Configurazione dei client per il Controllo degli accessi IAM](configure-clients-for-iam-access-control.md).
+ AWS Glue Registro degli schemi per la gestione degli schemi
+ Servizio gestito da Amazon per Apache Flink per l'elaborazione di flussi basata su Apache Flink
+  AWS Lambda per l'elaborazione degli eventi

**Nota**  
MSK Serverless richiede il Controllo degli accessi IAM per tutti i cluster. Le liste di controllo degli accessi di Apache Kafka (ACLs) non sono supportate. Per ulteriori informazioni, consulta [Controllo degli accessi IAM](iam-access-control.md).  
Per informazioni sulle quote di servizio applicabili a MSK Serverless, consulta la sezione [Quota di MSK Serverless](limits.md#serverless-quota).

Per iniziare a utilizzare i cluster serverless e per ulteriori informazioni sulle opzioni di configurazione e monitoraggio per i cluster serverless, consulta le seguenti risorse.

**Topics**
+ [

# Usa i cluster MSK Serverless
](serverless-getting-started.md)
+ [

# Proprietà di configurazione per i cluster MSK Serverless
](serverless-config.md)
+ [

# Configura il tipo di rete dual-stack
](serverless-config-dual-stack.md)
+ [

# Monitora i cluster MSK Serverless
](serverless-monitoring.md)

# Usa i cluster MSK Serverless
<a name="serverless-getting-started"></a>

Questo tutorial mostra un esempio di come creare un cluster MSK Serverless, creare un computer client in grado di accedervi e utilizzare il client per creare argomenti sul cluster e scrivere dati su tali argomenti. Questo esempio non rappresenta tutte le opzioni che è possibile scegliere quando si crea un cluster serverless. In diverse parti di questo esercizio verranno scelte opzioni predefinite per semplicità. Ciò non significa che siano le uniche opzioni che funzionano per la configurazione del cluster serverless. Puoi anche utilizzare l'API AWS CLI o Amazon MSK. Per ulteriori informazioni, consulta la [documentazione di riferimento all'API di Amazon MSK 2.0](https://docs.aws.amazon.com/MSK/2.0/APIReference/what-is-msk.html).

**Topics**
+ [

# Crea un cluster MSK Serverless
](create-serverless-cluster.md)
+ [

# Crea un ruolo IAM per gli argomenti sul cluster MSK Serverless
](create-iam-role.md)
+ [

# Creare una macchina client per accedere al cluster MSK Serverless
](create-serverless-cluster-client.md)
+ [

# Crea un argomento di Apache Kafka
](msk-serverless-create-topic.md)
+ [

# Produci e consuma dati in MSK Serverless
](msk-serverless-produce-consume.md)
+ [

# Eliminare le risorse create per MSK Serverless
](delete-resources.md)

# Crea un cluster MSK Serverless
<a name="create-serverless-cluster"></a>

In questo passaggio, eseguirai due attività. Innanzitutto, si crea un cluster MSK Serverless con le impostazioni predefinite. In secondo luogo, si raccolgono informazioni sul cluster. Si tratta di informazioni che ti occorreranno nei passaggi successivi, quando creerai un client in grado di inviare dati al cluster.

**Creazione di un cluster serverless**

1. Accedi a e apri la console Amazon MSK da [https://console.aws.amazon.com/msk/casa](https://console.aws.amazon.com/msk/home). Console di gestione AWS

1. Scegli **Crea cluster**.

1. Per **Metodo di creazione**, lascia selezionata l'opzione **Creazione rapida**. L'opzione **Creazione rapida** consente di creare un cluster serverless con le impostazioni predefinite.

1. In **Nome del cluster**, inserisci un nome descrittivo, ad esempio **msk-serverless-tutorial-cluster**.

1. In **Proprietà generali del cluster**, scegli **Serverless** come **Tipo di cluster**. Utilizza i valori predefiniti per le **Proprietà generali del cluster** rimanenti.

1. Nota la tabella in **Tutte le impostazioni del cluster**. Questa tabella elenca i valori predefiniti per impostazioni importanti come rete e disponibilità e indica se è possibile modificare ogni impostazione dopo aver creato il cluster. Per modificare un'impostazione prima di creare il cluster, è necessario scegliere l'opzione **Creazione personalizzata** in **Metodo di creazione**.
**Nota**  
Puoi connettere client da un massimo di cinque diversi VPCs con i cluster MSK Serverless. Per aiutare le applicazioni client a passare a un'altra zona di disponibilità in caso di interruzione, è necessario specificare almeno due sottoreti in ogni VPC.

1. Scegli **Crea cluster**.

**Raccolta delle informazioni sul cluster**

1. Nella pagina **Riepilogo del cluster**, scegli **Visualizza informazioni sul client**. Questo pulsante rimane disattivato fino al termine della creazione del cluster da parte di Amazon MSK. Potrebbe essere necessario attendere qualche minuto prima che il pulsante diventi attivo e possa essere selezionato.

1. Copia la stringa sotto l'etichetta **Endpoint**. Questa è la stringa del tuo server di bootstrap.

1. Scegliere la scheda **Properties (Proprietà)**.

1. Nella sezione **Impostazioni di rete**, copia le sottoreti e il gruppo IDs di sicurezza e salvali perché queste informazioni saranno necessarie in seguito per creare una macchina client.

1. Scegli una delle sottoreti. Si apre la console Amazon VPC. Cerca l'ID dell'Amazon VPC associato al VPC della sottorete. Salva questo ID dell'Amazon VPC per utilizzarlo in futuro.

**Fase successiva**

[Crea un ruolo IAM per gli argomenti sul cluster MSK Serverless](create-iam-role.md)

# Crea un ruolo IAM per gli argomenti sul cluster MSK Serverless
<a name="create-iam-role"></a>

In questo passaggio, eseguirai due attività. La prima attività consiste nel creare una policy IAM che consenta l'accesso alla creazione di argomenti nel cluster e all'invio di dati a tali argomenti. La seconda attività consiste nel creare un ruolo IAM e associarvi questa policy. In un passaggio successivo, si crea un computer client che assume questo ruolo e lo utilizza per creare un argomento nel cluster e per inviare dati a quell'argomento.

**Creazione di una policy IAM che consenta di creare argomenti e scrivere su di essi**

1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Nel riquadro di navigazione, seleziona **Policy**.

1. Scegli **Crea policy**.

1. Scegli la scheda **JSON**, quindi sostituisci il JSON nella finestra dell'editor con il seguente JSON. 

   Nell'esempio seguente, sostituisci quanto segue:
   + *region*con il codice del Regione AWS luogo in cui hai creato il cluster.
   + Esempio di ID dell'account*123456789012*, con il tuo Account AWS ID.
   + *msk-serverless-tutorial-cluster*/*c07c74ea-5146-4a03-add1-9baa787a5b14-s3*e *msk-serverless-tutorial-cluster* con l'ID del cluster serverless e il nome dell'argomento.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "kafka-cluster:Connect",
                   "kafka-cluster:DescribeCluster"
               ],
               "Resource": [
                   "arn:aws:kafka:us-east-1:123456789012:cluster/msk-serverless-tutorial-cluster/c07c74ea-5146-4a03-add1-9baa787a5b14-s3"
               ]
           },
           {
               "Effect": "Allow",
               "Action": [
                   "kafka-cluster:CreateTopic",
                   "kafka-cluster:WriteData",
                   "kafka-cluster:DescribeTopic"
               ],
               "Resource": [
               "arn:aws:kafka:us-east-1:123456789012:topic/msk-serverless-tutorial-cluster/*"
               ]
           }
       ]
   }
   ```

------

   Per istruzioni su come scrivere policy sicure, vedi[Controllo degli accessi IAM](iam-access-control.md).

1. Scegliere **Next: Tags (Successivo: Tag)**.

1. Scegliere **Next:Review (Successivo: Rivedi)**.

1. Per il nome della policy, inserisci un nome descrittivo, ad esempio **msk-serverless-tutorial-policy**.

1. Scegli **Crea policy**.

**Creazione di un ruolo IAM e collegamento della policy al ruolo**

1. Nel riquadro di navigazione, seleziona **Ruoli**.

1. Scegli **Crea ruolo**.

1. In **Casi di utilizzo comuni**, scegli **EC2**, quindi scegli **Successivo: autorizzazioni**.

1. Nella casella di ricerca, inserisci il nome della policy creata in precedenza per questo tutorial. Seleziona quindi la casella a sinistra della policy.

1. Scegliere **Next: Tags (Successivo: Tag)**.

1. Scegliere **Next:Review (Successivo: Rivedi)**.

1. Per il nome del ruolo, inserisci un nome descrittivo, ad esempio **msk-serverless-tutorial-role**.

1. Scegli **Crea ruolo**.

**Fase successiva**

[Creare una macchina client per accedere al cluster MSK Serverless](create-serverless-cluster-client.md)

# Creare una macchina client per accedere al cluster MSK Serverless
<a name="create-serverless-cluster-client"></a>

In questo passaggio, eseguirai due attività. La prima operazione consiste nel creare un'istanza Amazon EC2 da utilizzare come computer client Apache Kafka. La seconda attività consiste nell'installare gli strumenti Java e Apache Kafka sul computer.

**Per creare un computer client**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Scegliere **Launch Instance (Avvia istanza)**.

1. Inserisci un **Nome** descrittivo per il computer client, ad esempio **msk-serverless-tutorial-client**.

1. Lascia **Amazon Linux 2 AMI (HVM) - Kernel 5.10, tipo di volume SSD** selezionato per **Tipo di Amazon Machine Image (AMI)**.

1. Lascia selezionato il tipo di istanza **t2.micro**.

1. In **Coppia di chiavi (accesso)**, scegli **Crea una nuova coppia di chiavi**. Inserisci **MSKServerlessKeyPair** per **Nome coppia di chiavi**. Quindi scegli **Scarica coppia di chiavi**. In alternativa, è possibile utilizzare una coppia di chiavi esistente.

1. Per **Impostazioni di rete**, scegli **Modifica**.

1. In **VPC**, inserisci l'ID del cloud privato virtuale (VPC) per il cluster serverless. Si tratta del VPC basato sul servizio Amazon VPC il cui ID è stato salvato dopo la creazione del cluster.

1. Per **Sottorete**, scegli la sottorete di cui hai salvato l'ID dopo aver creato il cluster.

1. Per **Firewall (gruppi di sicurezza)**, seleziona il gruppo di sicurezza associato al cluster. Questo valore funziona se il gruppo di sicurezza ha una regola in entrata che consente il traffico dal gruppo di sicurezza verso sé stesso. Con questa regola, i membri dello stesso gruppo di sicurezza possono comunicare tra loro. Per ulteriori informazioni, consulta la pagina [Security group rules](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SecurityGroupRules) nella Guida per gli sviluppatori di Amazon VPC.

1. Espandi la sezione **Dettagli avanzati** e scegli il ruolo IAM che hai creato nel [Crea un ruolo IAM per gli argomenti sul cluster MSK Serverless](create-iam-role.md).

1. Scegli **Avvia**.

1. Nel riquadro di navigazione a sinistra, scegli **Istanze**. Quindi scegli la casella di controllo nella riga che rappresenta l'istanza Amazon EC2 appena creata. D'ora in avanti, chiameremo questa istanza *computer client*.

1. Scegli **Connetti** e segui le istruzioni per connetterti al computer client.

**Configurazione degli strumenti client Apache Kafka sul computer client**

1. Per installare Java, esegui il comando seguente sul computer client:

   ```
   sudo yum -y install java-11
   ```

1. Per recuperare gli strumenti di Apache Kafka necessari per creare argomenti e inviare dati, esegui i seguenti comandi:

   ```
   wget https://archive.apache.org/dist/kafka/2.8.1/kafka_2.12-2.8.1.tgz
   ```

   ```
   tar -xzf kafka_2.12-2.8.1.tgz
   ```
**Nota**  
Dopo aver estratto l'archivio Kafka, assicurati che gli script nella `bin` directory abbiano i permessi di esecuzione appropriati. Per farlo, esegui il comando seguente.  

   ```
   chmod +x kafka_2.12-2.8.1/bin/*.sh
   ```

1. Vai alla directory `kafka_2.12-2.8.1/libs`, quindi esegui il comando per scaricare il file JAR IAM di Amazon MSK. Il file JAR IAM di Amazon MSK consente al computer client di accedere al cluster.

   ```
   wget https://github.com/aws/aws-msk-iam-auth/releases/download/v2.3.0/aws-msk-iam-auth-2.3.0-all.jar
   ```

   Utilizzando questo comando, puoi anche [scaricare versioni diverse o più recenti](https://github.com/aws/aws-msk-iam-auth/releases) del file JAR Amazon MSK IAM.

1. Vai alla directory `kafka_2.12-2.8.1/bin`. Copia le impostazioni delle proprietà seguenti e incollale in un nuovo file. Assegna al file il nome `client.properties` e salvalo.

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

**Fase successiva**

[Crea un argomento di Apache Kafka](msk-serverless-create-topic.md)

# Crea un argomento di Apache Kafka
<a name="msk-serverless-create-topic"></a>

In questo passaggio, si utilizza il computer client creato in precedenza per creare un argomento sul cluster serverless.

**Topics**
+ [

## Configurazione dell'ambiente per la creazione di argomenti
](#msk-serverless-create-topic-prerequisites)
+ [

## Creazione di un argomento e scrittura di dati su di esso
](#msk-serverless-create-topic-procedure)

## Configurazione dell'ambiente per la creazione di argomenti
<a name="msk-serverless-create-topic-prerequisites"></a>
+ Prima di creare un argomento, assicuratevi di aver scaricato il file JAR AWS MSK IAM nella directory di installazione di Kafka. `libs/` Se non l'hai ancora fatto, esegui il seguente comando nella directory di Kafka. `libs/`

  ```
  wget https://github.com/aws/aws-msk-iam-auth/releases/download/v2.3.0/aws-msk-iam-auth-2.3.0-all.jar
  ```

  Questo file JAR è necessario per l'autenticazione IAM con il cluster MSK Serverless.
+ Quando si eseguono i comandi Kafka, potrebbe essere necessario assicurarsi che `classpath` includano il file JAR AWS MSK IAM. Per ottenere ciò, procedi in uno dei seguenti modi:
  + Imposta la variabile di `CLASSPATH` ambiente per includere le tue librerie Kafka, come mostrato nell'esempio seguente.

    ```
    export CLASSPATH=<path-to-your-kafka-installation>/libs/*:<path-to-your-kafka-installation>/libs/aws-msk-iam-auth-2.3.0-all.jar
    ```
  + Esegui i comandi Kafka utilizzando il comando Java completo con explicit`classpath`, come mostrato nell'esempio seguente.

    ```
    java -cp "<path-to-your-kafka-installation>/libs/*:<path-to-your-kafka-installation>/libs/aws-msk-iam-auth-2.3.0-all.jar" org.apache.kafka.tools.TopicCommand --bootstrap-server $BS --command-config client.properties --create --topic msk-serverless-tutorial --partitions 6
    ```

## Creazione di un argomento e scrittura di dati su di esso
<a name="msk-serverless-create-topic-procedure"></a>

1. Nel `export` comando seguente, sostituisci *my-endpoint* con la stringa bootstrap-server che hai salvato dopo aver creato il cluster. Quindi, vai alla directory `kafka_2.12-2.8.1/bin` sul computer client ed esegui il comando `export`.

   ```
   export BS=my-endpoint
   ```

1. Esegui il comando seguente per creare un argomento chiamato `msk-serverless-tutorial`.

   ```
   <path-to-your-kafka-installation>/bin/kafka-topics.sh --bootstrap-server $BS --command-config client.properties --create --topic msk-serverless-tutorial --partitions 6
   ```

**Fase successiva**

[Produci e consuma dati in MSK Serverless](msk-serverless-produce-consume.md)

# Produci e consuma dati in MSK Serverless
<a name="msk-serverless-produce-consume"></a>

In questo passaggio, si producono e si utilizzano dati utilizzando l'argomento creato nel passaggio precedente.

**Per produrre e consumare messaggi**

1. Esegui il comando seguente per creare un produttore della console.

   ```
   <path-to-your-kafka-installation>/bin/kafka-console-producer.sh --broker-list $BS --producer.config client.properties --topic msk-serverless-tutorial
   ```

1. Immettere qualsiasi messaggio desiderato e premere **Enter (Invio)**. Ripetere questa fase due o tre volte. Ogni volta che immetti una riga e premi **Invio**, tale riga viene inviata al cluster Apache Kafka come un messaggio separato.

1. Mantenere aperta la connessione al computer client, quindi aprire una seconda connessione separata al computer in una nuova finestra.

1. Utilizza la tua seconda connessione al computer client per creare un utente della console eseguendo il comando seguente. Sostituisci *my-endpoint* con la stringa del server di bootstrap che hai salvato dopo aver creato il cluster.

   ```
   <path-to-your-kafka-installation>/bin/kafka-console-consumer.sh --bootstrap-server my-endpoint --consumer.config client.properties --topic msk-serverless-tutorial --from-beginning
   ```

   Si iniziano a vedere i messaggi immessi in precedenza quando è stato utilizzato il comando produttore della console.

1. Immettere altri messaggi nella finestra del produttore e guardali apparire nella finestra del consumatore.

Se riscontri `classpath` problemi durante l'esecuzione di questi comandi, assicurati di eseguirli dalla directory corretta. Inoltre, assicuratevi che il file JAR AWS MSK IAM sia nella `libs` directory. In alternativa, è possibile eseguire i comandi Kafka utilizzando il comando Java completo con explicit`classpath`, come illustrato nell'esempio seguente.

```
java -cp "kafka_2.12-2.8.1/libs/*:kafka_2.12-2.8.1/libs/aws-msk-iam-auth-2.3.0-all.jar" org.apache.kafka.tools.ConsoleProducer —broker-list $BS —producer.config client.properties —topic msk-serverless-tutorial
```

**Fase successiva**

[Eliminare le risorse create per MSK Serverless](delete-resources.md)

# Eliminare le risorse create per MSK Serverless
<a name="delete-resources"></a>

In questo passaggio, elimini le risorse che hai creato in questo tutorial.

**Eliminazione del cluster**

1. Apri la console Amazon MSK a [https://console.aws.amazon.com/msk/casa](https://console.aws.amazon.com/msk/home).

1. Nell'elenco dei cluster, scegli il cluster che hai creato per questo tutorial.

1. In **Operazioni**, scegli **Elimina cluster**.

1. Inserisci `delete` nel campo e scegli **Elimina**.

**Arresto del computer client**

1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Nell'elenco delle istanze Amazon EC2, scegli il computer client creato per questo tutorial.

1. Scegli **Stato istanza**, quindi scegli **Termina istanza**.

1. Scegliere **Terminate (Termina)**.

**Eliminazione del ruolo e della policy IAM**

1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Nel riquadro di navigazione, seleziona **Ruoli**.

1. Nella casella di ricerca, inserisci il nome del ruolo IAM creato per questo tutorial.

1. Seleziona il ruolo. Quindi scegli **Elimina ruolo** e conferma l'eliminazione.

1. Nel riquadro di navigazione, seleziona **Policy**.

1. Nella casella di ricerca, inserisci il nome della policy creata per questo tutorial.

1. Scegli la policy per aprirne la pagina di riepilogo. Nella pagina di **Riepilogo** della policy, seleziona **Elimina policy**.

1. Scegli **Elimina**.

# Proprietà di configurazione per i cluster MSK Serverless
<a name="serverless-config"></a>

Amazon MSK imposta le proprietà di configurazione del broker per i cluster serverless. Non è possibile modificare queste impostazioni delle proprietà di configurazione del broker. Tuttavia, è possibile impostare o modificare le seguenti proprietà di configurazione a livello di argomento. Tutte le altre proprietà di configurazione a livello di argomento non sono configurabili.


****  

| Proprietà di configurazione | Predefinita | Modificabile | Valore massimo consentito | 
| --- | --- | --- | --- | 
| [cleanup.policy](https://kafka.apache.org/documentation/#topicconfigs_cleanup.policy) | Elimina | Sì, ma solo al momento della creazione dell'argomento |  | 
|  [compression.type](https://kafka.apache.org/documentation/#topicconfigs_compression.type)  | Producer | Sì |  | 
|  [max.message.bytes](https://kafka.apache.org/documentation/#topicconfigs_max.message.bytes)  | 1048588 | Sì | 8388608 (8 MiB) | 
|  [message.timestamp.difference.max.ms](https://kafka.apache.org/documentation/#topicconfigs_message.timestamp.difference.max.ms)  | long.max | Sì |  | 
|  [message.timestamp.type](https://kafka.apache.org/documentation/#topicconfigs_message.timestamp.type)  | CreateTime | Sì |  | 
|  [retention.bytes](https://kafka.apache.org/documentation/#topicconfigs_retention.bytes)  | 250 GiB | Sì | Illimitato; impostalo su -1 per una conservazione illimitata | 
|  [retention.ms](https://kafka.apache.org/documentation/#topicconfigs_retention.ms)  | 7 giorni | Sì | Illimitato; impostalo su -1 per una conservazione illimitata | 

Per impostare o modificare queste proprietà di configurazione a livello di argomento, puoi utilizzare gli strumenti da riga di comando di Apache Kafka. Vedi [3.2 Configurazioni a livello di argomento](https://kafka.apache.org/documentation/#topicconfigs) nella documentazione ufficiale di Apache Kafka per ulteriori informazioni ed esempi su come impostarle.

**Nota**  
Non è possibile modificare la configurazione segment.bytes per gli argomenti in MSK Serverless. Tuttavia, un'applicazione Kafka Streams potrebbe tentare di creare un argomento interno con un valore di configurazione segment.bytes, che è diverso da quello consentito da MSK Serverless. Per informazioni sulla configurazione di Kafka Streams con MSK Serverless, vedere. [Utilizzo di Kafka Streams con i broker MSK Express e MSK Serverless](use-kafka-streams-express-brokers-msk-serverless.md)

[Quando utilizzi gli strumenti da riga di comando di Apache Kafka con Amazon MSK Serverless, assicurati di aver completato i passaggi 1-4 nella *sezione Configurare gli strumenti client Apache Kafka sulla macchina client* della documentazione Getting Started di Amazon MSK Serverless.](https://docs.aws.amazon.com/msk/latest/developerguide/create-serverless-cluster-client.html) Inoltre, è necessario includere il parametro nei comandi. `--command-config client.properties`

Ad esempio, il comando seguente può essere utilizzato per modificare la proprietà di configurazione dell'argomento retention.bytes per impostare una conservazione illimitata:

```
<path-to-your-kafka-client-installation>/bin/kafka-configs.sh —bootstrap-server <bootstrap_server_string> —command-config client.properties --entity-type topics --entity-name <topic_name> --alter --add-config retention.bytes=-1
```

In questo esempio, *<bootstrap server string>* sostituiscilo con l'endpoint del server bootstrap per il tuo cluster Amazon MSK Serverless e *<topic\$1name>* con il nome dell'argomento che desideri modificare.

Il `--command-config client.properties` parametro garantisce che lo strumento a riga di comando Kafka utilizzi le impostazioni di configurazione appropriate per comunicare con il cluster Amazon MSK Serverless.

# Configura il tipo di rete dual-stack
<a name="serverless-config-dual-stack"></a>

 Amazon MSK supporta il tipo di rete dual-stack per i cluster MSK Serverless esistenti che utilizzano Kafka versione 3.6.0 o successiva senza costi aggiuntivi. Con la rete dual-stack, i cluster possono utilizzare sia gli indirizzi che gli indirizzi. IPv4 IPv6 Gli endpoint dual-stack supportano inoltre il mantenimento della compatibilità con le versioni precedenti. IPv4 Amazon MSK fornisce IPv6 supporto tramite un tipo di rete dual-stack, non solo come -only. IPv6

 Per impostazione predefinita, i client si connettono ai cluster Amazon MSK utilizzando il tipo di IPv4 rete. Tutti i nuovi cluster che crei vengono utilizzati IPv4 anche per impostazione predefinita. Per aggiornare il tipo di rete di un cluster al dual-stack, assicurati di aver soddisfatto i prerequisiti descritti nella sezione seguente. Quindi, utilizza l'[UpdateConnectivity](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-connectivity.html#UpdateConnectivity)API per aggiornare la connettività al dual-stack. 

**Nota**  
Dopo aver aggiornato il cluster per utilizzare il tipo di rete dual-stack, non puoi tornare al tipo di rete. IPv4 

**Topics**
+ [

## Prerequisiti per l'utilizzo del tipo di rete dual-stack
](#msks-ipv6-prerequisites)
+ [

## Autorizzazioni IAM per MSK Serverless
](#msks-ipv6-iam-permissions)
+ [

## Usa un tipo di rete dual-stack per un cluster
](#update-msks-network-type)
+ [

## Considerazioni sull'utilizzo del tipo di rete dual-stack
](#msks-dual-stack-considerations)

## Prerequisiti per l'utilizzo del tipo di rete dual-stack
<a name="msks-ipv6-prerequisites"></a>

Prima di configurare il tipo di rete dual-stack per i cluster, assicurati che tutte le sottoreti fornite durante la creazione del cluster supportino il tipo di rete dual-stack. Se anche una sola sottorete del cluster non supporta il dual-stack, non sarà possibile aggiornare il tipo di rete del cluster a dual-stack.

## Autorizzazioni IAM per MSK Serverless
<a name="msks-ipv6-iam-permissions"></a>

Bisogna possedere le seguenti autorizzazioni IAM:
+  `ec2:DescribeSubnets` 
+  `ec2:ModifyVpcEndpoint` 

Per un elenco completo delle autorizzazioni necessarie per eseguire tutte le azioni di Amazon MSK, consulta la policy AWS gestita: [Amazon MSKFull](https://docs.aws.amazon.com/msk/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonMSKFullAccess) Access.

## Usa un tipo di rete dual-stack per un cluster
<a name="update-msks-network-type"></a>

È possibile aggiornare il tipo di rete per un cluster MSK Serverless utilizzando, o SDK. Console di gestione AWS AWS CLI AWS 

------
#### [ Using Console di gestione AWS ]

1. Aprire la console Amazon MSK a [https://console.aws.amazon.com/msk/casa? region=us-east-1\$1/home/.](https://console.aws.amazon.com/msk/home?region=us-east-1#/home/)

1. Scegliete il cluster MSK Serverless per il quale desiderate configurare il tipo di rete dual-stack.

1. **Nella pagina dei dettagli del cluster, scegli Proprietà.**

1. In **Impostazioni di rete**, scegli **Modifica tipo di rete**.

1. Per **Tipo di rete**, scegli **Dual stack**.

1. Scegli **Save changes** (Salva modifiche).

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

È possibile utilizzare l'API [update-connectivity](https://docs.aws.amazon.com/cli/latest/reference/kafka/update-connectivity.html) per aggiornare il tipo di rete del cluster MSK Serverless esistente a dual-stack. L'esempio seguente utilizza il ` update-connectivity` comando per impostare il tipo di rete del cluster su dual-stack.

Nell'esempio seguente, sostituite l'ARN del cluster di esempio, arn:aws:kafka: ::cluster/, con l'ARN effettivo del *us-east-1* cluster * 123456789012* MSK. *myCluster* *12345678-1234-1234-1234-123456789012 -1* [Per ottenere la versione corrente del cluster, utilizzare il comando describe-cluster.](https://docs.aws.amazon.com/cli/latest/reference/kafka/describe-cluster.html)

```
aws kafka update-connectivity \
    --cluster-arn "arn:aws:kafka:us-east-1:123456789012:cluster/myCluster/12345678-1234-1234-1234-123456789012-1" \
    --current-version "KTVPDKIKX0DER" \
    --connectivity-info '{
        "networkType": "DUAL"
    }
```

------
#### [ Using AWS SDK ]

L'esempio seguente utilizza l'[UpdateConnectivity](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-connectivity.html#UpdateConnectivity)API per impostare il tipo di rete del cluster su dual-stack.

Nell'esempio seguente, sostituite l'ARN del cluster di esempio, arn:aws:kafka: ::cluster/, con l'ARN effettivo del *us-east-1* cluster *123456789012* MSK. *myCluster* *12345678-1234-1234-1234-123456789012-1* Per ottenere la [DescribeCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)versione corrente del cluster, usa l'API.

```
import boto3

client = boto3.client("kafka")

response = client.update_connectivity(
    ClusterArn="arn:aws:kafka:us-east-1:123456789012:cluster/myCluster/12345678-1234-1234-1234-123456789012-1",
    CurrentVersion="KTVPDKIKX0DER",
    ConnectivityInfo={
        "NetworkType": "DUAL"
    }
)
print("Connectivity update initiated:", response)
```

------

## Considerazioni sull'utilizzo del tipo di rete dual-stack
<a name="msks-dual-stack-considerations"></a>
+ IPv6 il supporto è attualmente disponibile solo in modalità dual-stack (IPv4 \$1), non come -only. IPv6 IPv6
+ Il tipo di rete dual-stack non è disponibile per la connettività privata multi-VPC.
+ È possibile modificare il tipo di rete da dual-stack IPv4 per un cluster esistente solo se tutte le relative sottoreti supportano il tipo di rete dual-stack.
+ Non è possibile tornare al tipo di rete dopo aver abilitato il dual-stack. IPv4 Per tornare indietro, è necessario eliminare e ricreare il cluster.
+ Bisogna possedere le seguenti autorizzazioni IAM:
  + `ec2:DescribeSubnets` e ` ec2:ModifyVpcEndpoint`

# Monitora i cluster MSK Serverless
<a name="serverless-monitoring"></a>

Amazon MSK si integra con Amazon per CloudWatch consentirti di raccogliere, visualizzare e analizzare i parametri per il tuo cluster MSK Serverless. I parametri mostrati nella tabella seguente sono disponibili per tutti i cluster serverless. Poiché questi parametri sono pubblicati come punti di dati individuali per ogni partizione dell'argomento, consigliamo di visualizzarle come statistiche "SUM" per ottenere una visualizzazione a livello di argomento.

Amazon MSK pubblica i `PerSec` parametri con una frequenza di una volta CloudWatch al minuto. Ciò significa che la statistica "SUM" per un periodo di un minuto rappresenta accuratamente i dati al secondo per i parametri `PerSec`. Per raccogliere dati al secondo per un periodo superiore a un minuto, usa la seguente espressione matematica:. CloudWatch `m1 * 60/PERIOD(m1)`


**Parametri disponibili al livello di monitoraggio DEFAULT**  

| Nome | Quando visibile | Dimensioni | Description | 
| --- | --- | --- | --- | 
| BytesInPerSec | Dopo che un produttore ha scritto su un argomento | Nome del cluster, argomento |  Il numero di byte al secondo ricevuti dai client. Questo parametro è disponibile per ogni argomento.  | 
| BytesOutPerSec | Dopo che un gruppo di consumatori ha utilizzato un argomento | Nome del cluster, argomento |  Il numero di byte al secondo inviati ai client. Questo parametro è disponibile per ogni argomento.  | 
| FetchMessageConversionsPerSec | Dopo che un gruppo di consumatori ha utilizzato un argomento | Nome del cluster, argomento |  Il numero di conversioni dei messaggi di recupero al secondo per l'argomento.  | 
| EstimatedMaxTimeLag | Dopo che un gruppo di consumatori ha utilizzato un argomento | Nome del cluster, gruppo di consumatori, argomento  | Una stima temporale della metrica. MaxOffsetLag  | 
| MaxOffsetLag | Dopo che un gruppo di consumatori ha utilizzato un argomento | Nome del cluster, gruppo di consumatori, argomento  | Il ritardo massimo di offset su tutte le partizioni di un argomento. | 
| MessagesInPerSec | Dopo che un produttore ha scritto su un argomento | Nome del cluster, argomento | Il numero di messaggi in entrata al secondo per l'argomento. | 
| ProduceMessageConversionsPerSec | Dopo che un produttore ha scritto su un argomento | Nome del cluster, argomento | Il numero di conversioni di messaggi di produzione al secondo per l'argomento. | 
| SumOffsetLag | Dopo che un gruppo di consumatori ha utilizzato un argomento | Nome del cluster, gruppo di consumatori, argomento  | Il ritardo di offset aggregato per tutte le partizioni di un argomento. | 

**Visualizzazione dei parametri di MSK Serverless**

1. Accedi a Console di gestione AWS e apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. Nel riquadro di navigazione, in **Parametri**, scegli **Tutti i parametri**.

1. Nei parametri, cerca il termine **kafka**.

1. Per visualizzare parametri diversi, scegli **AWS/Kafka / Nome del cluster, argomento** oppure **AWS/Kafka / Nome del cluster, gruppo di consumatori, argomento**.