

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# ¿Qué es MSK sin servidor?
<a name="serverless"></a>

**nota**  
MSK sin servidor está disponible en las regiones de Este de EE. UU. (Ohio), Este de EE. UU. (Norte de Virginia), Oeste de EE. UU. (Oregón), Canadá (centro), Asia-Pacífico (Bombay), Asia-Pacífico (Singapur), Asia-Pacífico (Sídney), Asia-Pacífico (Tokio), Asia-Pacífico (Seúl), Europa (Fráncfort), Europa (Estocolmo), Europa (Irlanda), Europa (París) y Europa (Londres).

MSK sin servidor es un tipo de clúster para Amazon MSK que le permite ejecutar Apache Kafka sin tener que administrar ni escalar la capacidad del clúster. Aprovisiona y escala automáticamente la capacidad y, al mismo tiempo, administra las particiones de su tema, de modo que pueda transmitir datos sin tener que pensar en dimensionar o escalar los clústeres correctamente. MSK sin servidor ofrece un modelo de precios basado en el rendimiento, por lo que solo paga por lo que usa. Considere la posibilidad de utilizar un clúster sin servidor si sus aplicaciones necesitan una capacidad de streaming bajo demanda que se escale y reduzca verticalmente de forma automática.

MSK sin servidor es totalmente compatible con Apache Kafka, por lo que puede usar cualquier aplicación cliente compatible para producir y consumir datos. También se integra con los siguientes servicios:
+ AWS PrivateLink para proporcionar conectividad privada
+ AWS Identity and Access Management (IAM) para la autenticación y la autorización mediante lenguajes Java y no Java. Para obtener instrucciones sobre la configuración de clientes para IAM, consulte [Configuración de clientes para el control de acceso de IAM](configure-clients-for-iam-access-control.md).
+ AWS Glue Registro de esquemas para la administración de esquemas
+ Amazon Managed Service para Apache Flink para el procesamiento de flujos basados en Apache Flink
+  AWS Lambda para el procesamiento de eventos

**nota**  
MSK sin servidor requiere el control de acceso de IAM para todos los clústeres. No se admiten las listas de control de acceso de Apache Kafka (ACLs). Para obtener más información, consulte [Control de acceso de IAM](iam-access-control.md).  
Para obtener información sobre las cuotas de servicio que se aplican a MSK sin servidor, consulte [Cuota de MSK sin servidor](limits.md#serverless-quota).

Para ayudarle a empezar con los clústeres sin servidor y para obtener más información sobre las opciones de configuración y supervisión de los clústeres sin servidor, consulte lo siguiente.

**Topics**
+ [Uso de clústeres sin servidor de MSK](serverless-getting-started.md)
+ [Propiedades de configuración para los clústeres sin servidor de MSK](serverless-config.md)
+ [Configure el tipo de red de doble pila](serverless-config-dual-stack.md)
+ [Supervisión de los clústeres sin servidor de MSK](serverless-monitoring.md)

# Uso de clústeres sin servidor de MSK
<a name="serverless-getting-started"></a>

En este tutorial, se muestra un ejemplo de cómo puede crear un clúster sin servidor de MSK, crear un equipo cliente al que pueda acceder y utilizar el cliente para crear temas en el clúster y escribir datos en esos temas. Este ejercicio no representa todas las opciones que puede elegir al crear un clúster sin servidor. En diferentes partes de este ejercicio, elegimos opciones predeterminadas por motivos de simplicidad. Esto no significa que sean las únicas opciones que funcionan para configurar un clúster sin servidor. También puedes usar la API AWS CLI o la API de Amazon MSK. Para más información, consulte la [referencia de la API de Amazon MSK 2.0](https://docs.aws.amazon.com/MSK/2.0/APIReference/what-is-msk.html).

**Topics**
+ [Creación de un clúster sin servidor de MSK](create-serverless-cluster.md)
+ [Creación de un rol de IAM para los temas del clúster sin servidor de MSK](create-iam-role.md)
+ [Creación de un equipo cliente para acceder al clúster sin servidor de MSK](create-serverless-cluster-client.md)
+ [Creación de un tema de Apache Kafka](msk-serverless-create-topic.md)
+ [Producción y consumo de datos en MSK sin servidor](msk-serverless-produce-consume.md)
+ [Eliminación de los recursos que creó para MSK sin servidor](delete-resources.md)

# Creación de un clúster sin servidor de MSK
<a name="create-serverless-cluster"></a>

En este paso, se realizan dos tareas. En primer lugar, debe crear un clúster sin servidor de MSK con la configuración predeterminada. En segundo lugar, debe recopilar información sobre el clúster. Esta es la información que necesitará en los pasos posteriores al crear un cliente que pueda enviar datos al clúster.

**Creación de un clúster sin servidor**

1. Inicia sesión en la Consola de administración de AWS consola Amazon MSK y ábrela en [https://console.aws.amazon.com/msk/casa](https://console.aws.amazon.com/msk/home).

1. Elija **Create cluster**.

1. En **Método de creación**, deje seleccionada la opción **Creación rápida**. La opción **Creación rápida** le permite crear un clúster sin servidor con la configuración predeterminada.

1. En **Nombre de clúster**, escriba un nombre descriptivo, como **msk-serverless-tutorial-cluster**.

1. En **Propiedades generales del clúster**, elija **Sin servidor** como **Tipo de clúster**. Utilice los valores predeterminados para el resto de las **propiedades generales del clúster**.

1. Observe la tabla que figura bajo **Todas las configuraciones del clúster**. En esta tabla se muestran los valores predeterminados de las configuraciones importantes, como las redes y la disponibilidad, e indica si puede cambiar cada configuración después de crear el clúster. Para cambiar una configuración antes de crear el clúster, debe elegir la opción **Creación personalizada** en **Método de creación**.
**nota**  
Puede conectar clientes de hasta cinco tipos diferentes VPCs con clústeres de MSK Serverless. Para ayudar a las aplicaciones cliente a cambiar a otra zona de disponibilidad en caso de una interrupción, debe especificar al menos dos subredes en cada VPC.

1. Elija **Create cluster**.

**Recopilación de información sobre el clúster**

1. En la sección **Resumen del clúster**, elija **Ver información del cliente**. Este botón permanece atenuado hasta que Amazon MSK termina de crear el clúster. Es posible que tenga que esperar unos minutos hasta que el botón se active para poder utilizarlo.

1. Copie la cadena bajo la etiqueta **Punto de conexión**. Esta es la cadena del servidor de arranque.

1. Elija la pestaña **Propiedades**.

1. En la sección **Configuración de red**, copie las subredes y el grupo IDs de seguridad y guárdelos, ya que necesitará esta información más adelante para crear una máquina cliente.

1. Elija cualquiera de las subredes. Esto abre la consola de Amazon VPC. Encuentre el ID de la VPC de Amazon VPC asociada a la subred. Guarde este ID de la VPC de Amazon VPC para un uso posterior.

**Paso siguiente**

[Creación de un rol de IAM para los temas del clúster sin servidor de MSK](create-iam-role.md)

# Creación de un rol de IAM para los temas del clúster sin servidor de MSK
<a name="create-iam-role"></a>

En este paso, se realizan dos tareas. La primera tarea consiste en crear una política de IAM que conceda acceso para crear temas en el clúster y enviarles datos. La segunda tarea consiste en crear un rol de IAM y asociarle esta política. En un paso posterior, se crea un equipo cliente que asume este rol y lo utiliza para crear un tema en el clúster y enviarle datos.

**Creación de una política de IAM que permita crear temas y escribir en ellos**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación, seleccione **Políticas**.

1. Seleccione **Crear política**.

1. Seleccione la pestaña **JSON** y, a continuación, sustituya el JSON de la ventana del editor por el siguiente JSON. 

   En el ejemplo siguiente, sustituya:
   + *region*con el código del Región de AWS lugar en el que creó el clúster.
   + Ejemplo de ID de cuenta*123456789012*, con tu Cuenta de AWS ID.
   + *msk-serverless-tutorial-cluster*/*c07c74ea-5146-4a03-add1-9baa787a5b14-s3*y *msk-serverless-tutorial-cluster* con su ID de clúster sin servidor y el nombre del tema.

------
#### [ 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/*"
               ]
           }
       ]
   }
   ```

------

   Para obtener instrucciones sobre cómo escribir políticas seguras, consulte [Control de acceso de IAM](iam-access-control.md).

1. Elija **Siguiente: Etiquetas**.

1. Elija **Siguiente: Revisar**.

1. En Nombre de política, escriba un nombre descriptivo, como **msk-serverless-tutorial-policy**.

1. Elija **Crear política**.

**Creación de un rol de IAM y asociarle la política**

1. En el panel de navegación, seleccione **Roles**.

1. Elija **Crear rol**.

1. En **Casos de uso comunes**, elija **EC2**, y, a continuación, elija **Siguiente: permisos**.

1. En el cuadro de búsqueda, escriba el nombre de la política que creó anteriormente para este tutorial. A continuación, seleccione la casilla situada a la izquierda de la política.

1. Elija **Siguiente: Etiquetas**.

1. Elija **Siguiente: Revisar**.

1. En Nombre de rol, escriba un nombre descriptivo, como **msk-serverless-tutorial-role**.

1. Elija **Crear rol**.

**Paso siguiente**

[Creación de un equipo cliente para acceder al clúster sin servidor de MSK](create-serverless-cluster-client.md)

# Creación de un equipo cliente para acceder al clúster sin servidor de MSK
<a name="create-serverless-cluster-client"></a>

En este paso, se realizan dos tareas. La primera tarea consiste en crear una instancia de Amazon EC2 para utilizarla como equipo cliente de Apache Kafka. La segunda tarea consiste en instalar las herramientas de Java y Apache Kafka en el equipo.

**Creación de un equipo cliente**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Seleccione **Iniciar instancia**.

1. Escriba un **Nombre** descriptivo para el equipo cliente, como **msk-serverless-tutorial-client**.

1. Deje seleccionado **Amazon Linux 2 AMI (HVM): Kernel 5.10, tipo de volumen SSD** en **Tipo de imagen de máquina de Amazon (AMI)**.

1. Deje seleccionado el tipo de instancia **t2.micro**.

1. En **Par de claves (inicio de sesión)**, seleccione **Crear un nuevo par de claves**. Introduzca **MSKServerlessKeyPair** en **Nombre de par de claves**. Luego, elija **Descargar par de claves**. También puede utilizar un par de claves existente.

1. En **Configuración de red**, elija **Editar**.

1. En **VPC**, escriba el ID de la nube privada virtual (VPC) del clúster sin servidor. Esta es la VPC según el servicio de Amazon VPC, cuyo ID guardó después de crear el clúster.

1. En **Subred**, elija la subred cuyo ID guardó después de crear el clúster.

1. En **Firewall (grupos de seguridad)**, seleccione el grupo de seguridad asociado al clúster. Este valor funciona si ese grupo de seguridad tiene una regla de entrada que permite el tráfico desde el grupo de seguridad hacia sí mismo. Con esta regla, los miembros del mismo grupo de seguridad se pueden comunicar entre sí. Para más información, consulte [Reglas del grupo de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SecurityGroupRules) en la Guía para desarrolladores de Amazon VPC.

1. Amplíe la sección **Detalles avanzados** y elija el rol de IAM que creó en [Creación de un rol de IAM para los temas del clúster sin servidor de MSK](create-iam-role.md).

1. Elija **Iniciar**.

1. En el panel de navegación izquierdo, elija **instancias**. A continuación, seleccione la casilla de la fila que representa la instancia de Amazon EC2 recién creada. A partir de ahora, esta instancia se denominará *equipo cliente*.

1. Elija **Conectar** y siga las instrucciones para conectarse al equipo cliente.

**Configuración de las herramientas de cliente de Apache Kafka en el equipo cliente**

1. Para instalar Java, ejecute el siguiente comando en el equipo cliente:

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

1. Para obtener las herramientas de Apache Kafka que se necesitan para crear temas y enviar datos, ejecute los siguientes comandos:

   ```
   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**  
Después de extraer el archivo de Kafka, asegúrese de que los scripts del directorio `bin` tengan los permisos de ejecución adecuados. Para ello, ejecute el siguiente comando.  

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

1. Vaya al directorio `kafka_2.12-2.8.1/libs` y ejecute el siguiente comando para descargar el archivo JAR de IAM de Amazon MSK. El JAR de IAM de Amazon MSK permite que el equipo cliente acceda al clúster.

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

   Con este comando, también puede [descargar otras versiones o versiones más recientes](https://github.com/aws/aws-msk-iam-auth/releases) del archivo JAR de IAM de Amazon MSK.

1. Vaya al directorio `kafka_2.12-2.8.1/bin`. Copie las siguientes configuraciones de propiedades y péguelas en un archivo nuevo. Asigne el nombre `client.properties` al archivo y guárdelo.

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

**Paso siguiente**

[Creación de un tema de Apache Kafka](msk-serverless-create-topic.md)

# Creación de un tema de Apache Kafka
<a name="msk-serverless-create-topic"></a>

En este paso, utilizará el equipo cliente creado anteriormente para crear un tema en el clúster sin servidor.

**Topics**
+ [Configuración del entorno para crear temas](#msk-serverless-create-topic-prerequisites)
+ [Creación de un tema y escritura de datos en este](#msk-serverless-create-topic-procedure)

## Configuración del entorno para crear temas
<a name="msk-serverless-create-topic-prerequisites"></a>
+ Antes de crear un tema, asegúrese de haber descargado el archivo JAR de AWS MSK IAM en el directorio de la instalación de Kafka. `libs/` Si aún no ha realizado este paso, ejecute el siguiente comando en el directorio `libs/` de Kafka.

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

  Este archivo JAR es necesario para la autenticación de IAM con el clúster de MSK sin servidor.
+ Al ejecutar los comandos de Kafka, es posible que tengas que asegurarte de que `classpath` incluyen el archivo JAR de IAM de AWS MSK. Para ello, siga uno de estos pasos:
  + Configure la variable de entorno `CLASSPATH` para incluir las bibliotecas de Kafka, como se muestra en el siguiente ejemplo.

    ```
    export CLASSPATH=<path-to-your-kafka-installation>/libs/*:<path-to-your-kafka-installation>/libs/aws-msk-iam-auth-2.3.0-all.jar
    ```
  + Ejecute los comandos de Kafka mediante el comando completo de Java con `classpath` explícito, como se muestra en el siguiente ejemplo.

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

## Creación de un tema y escritura de datos en este
<a name="msk-serverless-create-topic-procedure"></a>

1. En el siguiente `export` comando, *my-endpoint* sustitúyalo por la cadena bootstrap-server que guardó después de crear el clúster. A continuación, vaya al directorio `kafka_2.12-2.8.1/bin` del equipo cliente y ejecute el comando `export`.

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

1. Ejecute el siguiente comando para crear un tema denominado `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
   ```

**Paso siguiente**

[Producción y consumo de datos en MSK sin servidor](msk-serverless-produce-consume.md)

# Producción y consumo de datos en MSK sin servidor
<a name="msk-serverless-produce-consume"></a>

En este paso, se producirán y consumirán datos mediante el tema que creó en el paso anterior.

**Producción y consumo de mensajes**

1. Ejecute el siguiente comando para crear un productor de la consola.

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

1. Escriba el mensaje que desee y pulse **Enter (Entrar)**. Repita este paso dos o tres veces. Cada vez que introduzca una línea y pulse **Entrar**, dicha línea se enviará al clúster como un mensaje separado.

1. Mantenga abierta la conexión al equipo cliente y, a continuación, abra una segunda conexión independiente a dicho equipo en una nueva ventana.

1. Utilice la segunda conexión a la máquina cliente para crear un consumidor de consola con el siguiente comando. *my-endpoint*Sustitúyala por la cadena del servidor de arranque que guardaste después de crear el clúster.

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

   Comenzará a ver los mensajes que introdujo anteriormente cuando utilizó el comando del productor de la consola.

1. Escriba más mensajes en la ventana del productor y observe cómo aparecen en la ventana del consumidor.

Si experimenta problemas `classpath` al ejecutar estos comandos, asegúrese de ejecutarlos desde el directorio correcto. Además, asegúrese de que el JAR de IAM de AWS MSK esté en el directorio. `libs` Como alternativa, puede ejecutar los comandos de Kafka mediante el comando completo de Java con `classpath` explícito, como se muestra en el siguiente ejemplo.

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

**Paso siguiente**

[Eliminación de los recursos que creó para MSK sin servidor](delete-resources.md)

# Eliminación de los recursos que creó para MSK sin servidor
<a name="delete-resources"></a>

En este paso, eliminará los recursos que creó en este tutorial.

**Eliminación del clúster**

1. Abre la consola Amazon MSK en [https://console.aws.amazon.com/msk/casa.](https://console.aws.amazon.com/msk/home)

1. En la lista de clústeres, elija el clúster que creó para este tutorial.

1. En **Acciones**, elija **Eliminar clúster**.

1. Introduzca `delete` en el campo y, luego, elija **Eliminar**.

**Detención del equipo cliente**

1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. En la lista de instancias de Amazon EC2, elija el equipo cliente que creó para este tutorial.

1. Elija **Estado de la instancia** y, luego, **Terminar instancia**.

1. Elija **Finalizar**.

**Eliminación de la política y el rol de IAM**

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. En el panel de navegación, seleccione **Roles**.

1. En el cuadro de búsqueda, escriba el nombre del rol de IAM que creó para este tutorial.

1. Elija el rol. A continuación, elija **Eliminar rol** para confirmar la eliminación.

1. En el panel de navegación, seleccione **Políticas**.

1. En el cuadro de búsqueda, escriba el nombre de la política que creó para este tutorial.

1. Elija la política para abrir su página de resumen. En la página **Resumen** de la política, elija **Eliminar política**.

1. Elija **Eliminar**.

# Propiedades de configuración para los clústeres sin servidor de MSK
<a name="serverless-config"></a>

Amazon MSK establece las propiedades de configuración de los agentes para los clústeres sin servidor. No puede cambiar los ajustes de las propiedades de configuración de estos agentes. Sin embargo, puede establecer o modificar las siguientes propiedades de configuración a nivel del tema. El resto de las propiedades de configuración a nivel del tema no son configurables.


****  

| Propiedad de configuración | Predeterminado | Editable | Valor máximo permitido | 
| --- | --- | --- | --- | 
| [cleanup.policy](https://kafka.apache.org/documentation/#topicconfigs_cleanup.policy) | Eliminar | Sí, pero solo en el momento de crear el tema |  | 
|  [compression.type](https://kafka.apache.org/documentation/#topicconfigs_compression.type)  | Productor | 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í | Ilimitado; configúrelo en -1 para una retención ilimitada | 
|  [retention.ms](https://kafka.apache.org/documentation/#topicconfigs_retention.ms)  | 7 días | Sí | Ilimitado; configúrelo en -1 para una retención ilimitada | 

Para configurar o modificar estas propiedades de configuración a nivel del tema, puede utilizar herramientas de línea de comandos de Apache Kafka. Consulte [3.2 Topic-level Configs](https://kafka.apache.org/documentation/#topicconfigs) en la documentación oficial de Apache Kafka para obtener más información y ejemplos de cómo establecerlas.

**nota**  
No puede modificar la configuración segment.bytes para los temas en MSK sin servidor. Sin embargo, una aplicación de Kafka Streams puede intentar crear un tema interno con un valor de configuración segment.bytes distinto del que MSK sin servidor permite. Para obtener información sobre cómo configurar Kafka Streams con MSK sin servidor, consulte [Uso de Kafka Streams con agentes Express de MSK y Amazon MSK sin servidor](use-kafka-streams-express-brokers-msk-serverless.md).

Cuando utilice las herramientas de línea de comandos de Apache Kafka con Amazon MSK sin servidor, asegúrese de haber completado los pasos 1 a 4 de la sección *To set up Apache Kafka client tools on the client machine* de la [documentación de introducción a Amazon MSK sin servidor](https://docs.aws.amazon.com/msk/latest/developerguide/create-serverless-cluster-client.html). Además, debe incluir el parámetro `--command-config client.properties` en sus comandos.

Por ejemplo, se puede utilizar el siguiente comando para modificar la propiedad de configuración del tema retention.bytes y establecer una retención ilimitada:

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

En este ejemplo, *<bootstrap server string>* sustitúyalo por el punto final del servidor bootstrap de tu clúster Amazon MSK Serverless y *<topic\$1name>* por el nombre del tema que deseas modificar.

El parámetro `--command-config client.properties` garantiza que la herramienta de línea de comandos de Kafka utilice los ajustes de configuración adecuados para comunicarse con el clúster de Amazon MSK sin servidor.

# Configure el tipo de red de doble pila
<a name="serverless-config-dual-stack"></a>

 Amazon MSK admite el tipo de red de doble pila para los clústeres MSK Serverless existentes que utilizan la versión 3.6.0 o posterior de Kafka sin coste adicional. Con las redes de doble pila, sus clústeres pueden utilizar ambas direcciones. IPv4 IPv6 Los puntos finales de doble pila también son compatibles, IPv4 por lo que mantienen la compatibilidad con versiones anteriores. Amazon MSK proporciona IPv6 soporte a través del tipo de red de doble pila, no solo como IPv6.

 De forma predeterminada, los clientes se conectan a los clústeres de Amazon MSK mediante el tipo IPv4 de red. Todos los clústeres nuevos que cree también se utilizan de forma IPv4 predeterminada. Para actualizar el tipo de red de un clúster a uno de doble pila, asegúrese de cumplir los requisitos previos que se describen en la siguiente sección. A continuación, utilice la [UpdateConnectivity](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-connectivity.html#UpdateConnectivity)API para actualizar la conectividad a la doble pila. 

**nota**  
Una vez que actualice el clúster para usar el tipo de red de doble pila, no podrá volver a cambiarlo al tipo de IPv4 red.

**Topics**
+ [Requisitos previos para usar un tipo de red de doble pila](#msks-ipv6-prerequisites)
+ [Permisos de IAM para MSK Serverless](#msks-ipv6-iam-permissions)
+ [Utilice un tipo de red de doble pila para un clúster](#update-msks-network-type)
+ [Consideraciones sobre el uso de un tipo de red de doble pila](#msks-dual-stack-considerations)

## Requisitos previos para usar un tipo de red de doble pila
<a name="msks-ipv6-prerequisites"></a>

Antes de configurar el tipo de red de doble pila para los clústeres, asegúrese de que todas las subredes que proporcione durante la creación del clúster sean compatibles con el tipo de red de doble pila. Si ni siquiera una subred de tu clúster admite la doble pila, no podrás actualizar el tipo de red del clúster a la de doble pila.

## Permisos de IAM para MSK Serverless
<a name="msks-ipv6-iam-permissions"></a>

Debe tener los siguientes permisos de IAM:
+  `ec2:DescribeSubnets` 
+  `ec2:ModifyVpcEndpoint` 

Para obtener una lista completa de los permisos necesarios para realizar todas las acciones de Amazon MSK, consulte la política AWS gestionada: [Amazon MSKFull Access](https://docs.aws.amazon.com/msk/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonMSKFullAccess).

## Utilice un tipo de red de doble pila para un clúster
<a name="update-msks-network-type"></a>

Puede actualizar el tipo de red de un clúster sin servidor de MSK mediante el Consola de administración de AWS AWS CLI, o el SDK. AWS 

------
#### [ Using Consola de administración de AWS ]

1. ¿Abrir la consola Amazon MSK en [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. Elija el clúster MSK Serverless para el que desee configurar el tipo de red de doble pila.

1. **En la página de detalles del clúster, elija Propiedades.**

1. En **Configuración de red**, selecciona **Editar tipo de red**.

1. En **Tipo de red**, selecciona **Doble pila**.

1. Seleccione **Save changes (Guardar cambios)**.

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

Puedes usar la API de [actualización y conectividad para](https://docs.aws.amazon.com/cli/latest/reference/kafka/update-connectivity.html) actualizar el tipo de red de tu clúster MSK Serverless existente a un clúster de doble pila. En el siguiente ejemplo, se usa el ` update-connectivity` comando para establecer el tipo de red del clúster como de doble pila.

En el siguiente ejemplo, sustituya el ARN del clúster de muestra, arn:aws:kafka: *us-east-1* ::cluster//, por el ARN del clúster de MSK * 123456789012* actual. *myCluster* *12345678-1234-1234-1234-123456789012 -1* [Para obtener la versión actual del clúster, usa el 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 ]

En el siguiente ejemplo, se usa la [UpdateConnectivity](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn-connectivity.html#UpdateConnectivity)API para establecer el tipo de red del clúster como de doble pila.

En el siguiente ejemplo, sustituya el ARN del clúster de muestra, arn:aws:kafka: *us-east-1* ::cluster//, por el ARN del clúster de MSK *123456789012* actual. *myCluster* *12345678-1234-1234-1234-123456789012-1* Para obtener la versión actual del [DescribeCluster](https://docs.aws.amazon.com/msk/1.0/apireference/clusters-clusterarn.html#DescribeCluster)clúster, usa la 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)
```

------

## Consideraciones sobre el uso de un tipo de red de doble pila
<a name="msks-dual-stack-considerations"></a>
+ IPv6 Actualmente, el soporte solo está disponible en el modo de doble pila (IPv4 \$1 IPv6), no solo como IPv6 -.
+ El tipo de red de doble pila no está disponible para la conectividad privada de varias VPC.
+ Puede cambiar el tipo de red de doble pila IPv4 para un clúster existente solo si todas sus subredes admiten el tipo de red de doble pila.
+ No puedes volver al tipo de IPv4 red después de habilitar la doble pila. Para volver a la versión anterior, debe eliminar y volver a crear el clúster.
+ Debe tener los siguientes permisos de IAM:
  + `ec2:DescribeSubnets` y ` ec2:ModifyVpcEndpoint`

# Supervisión de los clústeres sin servidor de MSK
<a name="serverless-monitoring"></a>

Amazon MSK se integra con Amazon CloudWatch para que pueda recopilar, ver y analizar las métricas de su clúster MSK Serverless. Las métricas que se muestran en la tabla siguiente están disponibles para todos los clústeres sin servidor. Como estas métricas se publican como puntos de datos individuales para cada partición del tema, recomendamos visualizarlas como una estadística “SUM” para obtener una vista por tema.

Amazon MSK publica `PerSec` las métricas con CloudWatch una frecuencia de una vez por minuto. Esto significa que la estadística “SUM” de un periodo de un minuto representa con precisión los datos por segundo de las métricas `PerSec`. Para recopilar datos por segundo durante un período superior a un minuto, utilice la siguiente expresión CloudWatch matemática:. `m1 * 60/PERIOD(m1)`


**Métricas disponibles en el nivel de supervisión DEFAULT**  

| Name | Cuando está visible | Dimensiones | Description (Descripción) | 
| --- | --- | --- | --- | 
| BytesInPerSec | Después de que un productor escribe en un tema | Nombre del clúster, tema |  El número de bytes por segundo recibidos de los clientes. Esta métrica está disponible para cada tema.  | 
| BytesOutPerSec | Después de que un grupo de consumidores consume de un tema | Nombre del clúster, tema |  El número de bytes por segundo enviados a los clientes. Esta métrica está disponible para cada tema.  | 
| FetchMessageConversionsPerSec | Después de que un grupo de consumidores consume de un tema | Nombre del clúster, tema |  El número de conversiones de mensajes de recuperación por segundo para el tema.  | 
| EstimatedMaxTimeLag | Después de que un grupo de consumidores consume de un tema | Nombre del clúster, grupo de consumidores, tema  | Una estimación temporal de la MaxOffsetLag métrica. | 
| MaxOffsetLag | Después de que un grupo de consumidores consume de un tema | Nombre del clúster, grupo de consumidores, tema  | El retraso máximo de desplazamiento en todas las particiones de un tema. | 
| MessagesInPerSec | Después de que un productor escribe en un tema | Nombre del clúster, tema | El número de mensajes entrantes por segundo para el tema. | 
| ProduceMessageConversionsPerSec | Después de que un productor escribe en un tema | Nombre del clúster, tema | El número de conversiones de mensajes de producción por segundo para el tema. | 
| SumOffsetLag | Después de que un grupo de consumidores consume de un tema | Nombre del clúster, grupo de consumidores, tema  | El retraso de desplazamiento agregado de todas las particiones de un tema. | 

**Visualización de las métricas de MSK sin servidor**

1. Inicie sesión en Consola de administración de AWS y abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1. En el panel de navegación, en **Métricas** y, luego, **Todas las métricas**.

1. En las métricas, busque el término **kafka**.

1. Elija **AWS, Kafka, Nombre del clúster o Tema** o **AWS, Kafka, Nombre del clúster, Grupo de consumidores o Tema** para ver diferentes métricas.