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.
# Uso de clústeres sin servidor de MSK
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
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
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
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
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
+ 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=/libs/*:/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 "/libs/*:/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
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`.
```
/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
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.
```
/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.
```
/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
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**.