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.
# Creación de un cuaderno de Studio con Amazon MSK
En este tutorial se describe cómo crear un cuaderno de Studio que utilice un clúster de Amazon MSK como fuente.
**Topics**
+ [Configurar un clúster de Amazon MSK](#example-notebook-msk-setup)
+ [Añada una puerta de enlace NAT a su VPC](#example-notebook-msk-nat)
+ [Cree una AWS Glue conexión y una tabla](#example-notebook-msk-glue)
+ [Creación de un cuaderno de Studio con Amazon MSK](#example-notebook-msk-create)
+ [Envío de datos a su clúster de Amazon MSK](#example-notebook-msk-send)
+ [Prueba de su cuaderno de Studio](#example-notebook-msk-test)
## Configurar un clúster de Amazon MSK
Para este tutorial, necesita un clúster de Amazon MSK que permita el acceso a texto sin formato. Si aún no ha configurado un clúster de Amazon MSK, siga el tutorial [Cómo empezar a utilizar Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html) para crear una VPC de Amazon, un clúster de Amazon MSK, un tema y una instancia de cliente de Amazon. EC2
Al seguir el tutorial, haga lo siguiente:
+ En el [paso 3: cree un clúster de Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/create-cluster.html), en el paso 4, cambie el `ClientBroker` valor de `TLS` a**PLAINTEXT**.
## Añada una puerta de enlace NAT a su VPC
Si ha creado un clúster de Amazon MSK siguiendo el tutorial [Cómo empezar a utilizar Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/getting-started.html), o si su Amazon VPC existente aún no tiene una puerta de enlace NAT para sus subredes privadas, debe añadir una puerta de enlace NAT a su Amazon VPC. En el siguiente diagrama se muestra la arquitectura.
![\[AWS VPC architecture with public and private subnets, NAT gateway, and Glue Data Catalog integration.\]](http://docs.aws.amazon.com/es_es/managed-flink/latest/java/images/vpc_05.png)
Para crear una puerta de enlace NAT para su Amazon VPC, haga lo siguiente:
1. Abra la consola de Amazon VPC en [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/).
1. En la barra de navegación izquierda, elija **puertas de enlace NAT**.
1. En la página **puertas de enlace NAT**, seleccione **Crear puerta de enlace NAT**.
1. En la página **Crear puerta de enlace NAT**, especifique los valores siguientes:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/managed-flink/latest/java/example-notebook-msk.html)
Elija **Create a NAT Gateway** (Crear una puerta de enlace NAT).
1. En la de navegación izquierda, elija **Tablas de ruteo**.
1. Elija **Create Route Table (Crear tabla de ruteo)**.
1. En la página **Crear tabla de enrutamiento**, proporcione la siguiente información:
+ **Name tag:** **ZeppelinRouteTable**
+ **VPC****: elija su VPC (p. ej., VPC).AWS KafkaTutorial**
Seleccione **Crear**.
1. En la lista de tablas de rutas, elija. **ZeppelinRouteTable** Elija la pestaña **Rutas** y, a continuación, **Editar rutas**.
1. En la pestaña **Editar rutas**, elija **Añadir rutas**.
1. En ****Para **Destino**, escriba **0.0.0.0/0**. Para **Target**, elija **NAT Gateway**, **ZeppelinGateway**. Elija **Guardar rutas**. Seleccione **Cerrar**.
1. En la página de tablas de rutas, con la **ZeppelinRouteTable**opción seleccionada, elija la pestaña **Asociaciones de subredes**. Elija **Editar asociaciones de subredes.**
1. **En la página **Editar asociaciones de subredes**, elija **AWS KafkaTutorialSubnet2 y AWS KafkaTutorialSubnet 3**.** Seleccione **Guardar**.
## Cree una AWS Glue conexión y una tabla
Su cuaderno de Studio utiliza una base de datos [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) para los metadatos sobre su origen de datos de Amazon MSK. En esta sección, crea una AWS Glue conexión que describe cómo acceder a su clúster de Amazon MSK y una AWS Glue tabla que describe cómo presentar los datos de su fuente de datos a clientes como su bloc de notas Studio.
**Creación de una conexión**
1. Inicie sesión en Consola de administración de AWS y abra la AWS Glue consola en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Si aún no tiene una AWS Glue base de datos, elija **Bases de datos** en la barra de navegación izquierda. Elija **Agregar una base de datos**. En la ventana **Añadir base de datos**, introduzca **default** en el **nombre de la base de datos**. Seleccione **Crear**.
1. En la barra de navegación de la izquierda, seleccione **Conexiones**. Elija **Añadir conexión**.
1. En la ventana **Añadir conexión**, introduzca los siguientes valores:
+ En **Nombre de conexión**, ingrese **ZeppelinConnection**.
+ En **Tipo de conexión**, elija **Kafka**.
+ En el **caso del servidor bootstrap de Kafka URLs**, proporcione la cadena del agente de arranque de su clúster. Puede obtener los agentes de arranque desde la consola MSK o ingresando el siguiente comando de la CLI:
```
aws kafka get-bootstrap-brokers --region us-east-1 --cluster-arn ClusterArn
```
+ Desactive la casilla de verificación **Exigir conexión SSL**.
Elija **Next** (Siguiente).
1. En la página **VPC**, especifique los valores siguientes:
+ **Para **VPC**, elija el nombre de su VPC (por ejemplo, VPC). AWS KafkaTutorial**
+ **Para **Subnet**, elija 2.AWS KafkaTutorialSubnet**
+ Para los **grupos de seguridad**, elija todos los grupos disponibles.
Elija **Next** (Siguiente).
1. En la página **Propiedades de la conexión** o **Acceso a la conexión**, seleccione **Finalizar**.
**Crear una tabla**
**nota**
Puede crear la tabla manualmente tal y como se describe en los pasos siguientes, o puede usar el código conector de creación de tablas para Managed Service para Apache Flink en su cuaderno en Apache Zeppelin para crear la tabla mediante una instrucción DDL. A continuación, puede comprobar AWS Glue que la tabla se ha creado correctamente.
1. En la barra de navegación izquierda, seleccione **Tablas**. En la página **Tablas**, seleccione **Añadir tablas** y **Añadir tabla manualmente**.
1. En la página **Configurar las propiedades de la tabla**, introduzca **stock** como **Nombre de la tabla**. Asegúrese de seleccionar la base de datos que creó anteriormente. Elija **Next** (Siguiente).
1. En la página **Añadir almacén de datos**, elija **Kafka**. Para el **nombre del tema**, introduce el nombre del tema (por ejemplo **AWS KafkaTutorialTopic**). En **Conexión**, elija **ZeppelinConnection**.
1. En la página de **Clasificación**, seleccione **JSON.** Elija **Siguiente**.
1. En la página **Definir un esquema**, elija Añadir columna para añadir una. Añada columnas con las siguientes propiedades:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/managed-flink/latest/java/example-notebook-msk.html)
Elija **Next** (Siguiente).
1. En la página siguiente, verifique su configuración y seleccione **Finalizar.**
1. Elija la tabla recién creada de la lista de tablas.
1. Elija **Editar tabla** y añada las siguientes propiedades:
+ clave: `managed-flink.proctime`, valor: `proctime`
+ clave: `flink.properties.group.id`, valor: `test-consumer-group`
+ clave: `flink.properties.auto.offset.reset`, valor: `latest`
+ clave: `classification`, valor: `json`
Sin estos pares clave/valor, se produce un error en el cuaderno Flink.
1. Seleccione **Aplicar**.
## Creación de un cuaderno de Studio con Amazon MSK
Ahora que ha creado los recursos que utiliza su aplicación, cree su cuaderno de Studio.
**Topics**
+ [Cree un cuaderno de Studio con el Consola de administración de AWS](#example-notebook-create-msk-console)
+ [Cree un bloc de notas de Studio con AWS CLI](#example-notebook-msk-create-api)
**nota**
También puede crear un cuaderno de Studio desde la consola Amazon MSK seleccionando un clúster existente y, a continuación, seleccionando **Procesar datos en tiempo real**.
### Cree un cuaderno de Studio con el Consola de administración de AWS
1. ¿Abrir la consola Managed Service for Apache Flink en [ https://console.aws.amazon.com/managed-flink/casa? region=us-east-1\$1/applications/panel](https://console.aws.amazon.com/managed-flink/home?region=us-east-1#/applications/dashboard) de control.
1. En la página de **Aplicaciones de Managed Service para Apache Flink**, seleccione la pestaña **Studio**. Seleccione **Crear cuaderno de Studio**.
**nota**
Para crear un cuaderno de Studio desde las consolas Amazon MSK o Kinesis Data Streams, seleccione el clúster Amazon MSK o el flujo de datos de Kinesis de entrada y, a continuación, elija **Procesar datos en tiempo real**.
1. En la página **Crear cuaderno de Studio**, proporcione la siguiente información:
+ Introduzca **MyNotebook** como **Nombre del cuaderno de Studio.**
+ Elija el **valor predeterminado** para la **Base de datos de Glue de AWS **.
Seleccione **Crear cuaderno de Studio**.
1. **En la página, seleccione la pestaña Configuración. **MyNotebook**** En la sección **Redes**, elija **Editar**.
1. En la MyNotebook página **Editar red para**, selecciona la **configuración de VPC basada en el clúster de Amazon MSK**. Elija su clúster de Amazon MSK para el **Clúster de Amazon MSK.** Elija **Guardar cambios**.
1. **En la **MyNotebook**página, selecciona Ejecutar.** Espere a que el **Estado** muestre **En ejecución**.
### Cree un bloc de notas de Studio con AWS CLI
Para crear tu bloc de notas de Studio mediante el AWS CLI, haz lo siguiente:
1. Verifique que disponga de la siguiente información. Necesita estos valores para crear su aplicación.
+ Su ID de cuenta de .
+ El ID de subred IDs y grupo de seguridad de la VPC de Amazon que contiene el clúster de Amazon MSK.
1. Cree un archivo denominado `create.json` con el siguiente contenido. Reemplace los valores de marcador de posición con su información.
```
{
"ApplicationName": "MyNotebook",
"RuntimeEnvironment": "ZEPPELIN-FLINK-3_0",
"ApplicationMode": "INTERACTIVE",
"ServiceExecutionRole": "arn:aws:iam::AccountID:role/ZeppelinRole",
"ApplicationConfiguration": {
"ApplicationSnapshotConfiguration": {
"SnapshotsEnabled": false
},
"VpcConfigurations": [
{
"SubnetIds": [
"SubnetID 1",
"SubnetID 2",
"SubnetID 3"
],
"SecurityGroupIds": [
"VPC Security Group ID"
]
}
],
"ZeppelinApplicationConfiguration": {
"CatalogConfiguration": {
"GlueDataCatalogConfiguration": {
"DatabaseARN": "arn:aws:glue:us-east-1:AccountID:database/default"
}
}
}
}
}
```
1. Para crear su aplicación, ejecute el siguiente comando:
```
aws kinesisanalyticsv2 create-application --cli-input-json file://create.json
```
1. Una vez completado el comando, debería ver un resultado similar al siguiente, con los detalles de su nuevo cuaderno de Studio:
```
{
"ApplicationDetail": {
"ApplicationARN": "arn:aws:kinesisanalyticsus-east-1:012345678901:application/MyNotebook",
"ApplicationName": "MyNotebook",
"RuntimeEnvironment": "ZEPPELIN-FLINK-3_0",
"ApplicationMode": "INTERACTIVE",
"ServiceExecutionRole": "arn:aws:iam::012345678901:role/ZeppelinRole",
...
```
1. Para iniciar su aplicación, ejecute el siguiente comando. Sustituya los valores de muestra por su ID de la cuenta.
```
aws kinesisanalyticsv2 start-application --application-arn arn:aws:kinesisanalyticsus-east-1:012345678901:application/MyNotebook\
```
## Envío de datos a su clúster de Amazon MSK
En esta sección, ejecuta un script de Python en su EC2 cliente de Amazon para enviar datos a su fuente de datos de Amazon MSK.
1. Conéctate con tu EC2 cliente de Amazon.
1. Ejecute los siguientes comandos para instalar la versión 3 de Python, Pip y el paquete Kafka para Python, y confirme las acciones:
```
sudo yum install python37
curl -O https://bootstrap.pypa.io/get-pip.py
python3 get-pip.py --user
pip install kafka-python
```
1. Configure AWS CLI en su máquina cliente introduciendo el siguiente comando:
```
aws configure
```
Proporcione las credenciales de su cuenta y **us-east-1** para `region`.
1. Cree un archivo denominado `stock.py` con el siguiente contenido. Sustituya el valor de muestra por la cadena Bootstrap Brokers de su clúster de Amazon MSK y actualice el nombre del tema si su tema no es: **AWS KafkaTutorialTopic**
```
from kafka import KafkaProducer
import json
import random
from datetime import datetime
BROKERS = "<>"
producer = KafkaProducer(
bootstrap_servers=BROKERS,
value_serializer=lambda v: json.dumps(v).encode('utf-8'),
retry_backoff_ms=500,
request_timeout_ms=20000,
security_protocol='PLAINTEXT')
def getStock():
data = {}
now = datetime.now()
str_now = now.strftime("%Y-%m-%d %H:%M:%S")
data['event_time'] = str_now
data['ticker'] = random.choice(['AAPL', 'AMZN', 'MSFT', 'INTC', 'TBV'])
price = random.random() * 100
data['price'] = round(price, 2)
return data
while True:
data =getStock()
# print(data)
try:
future = producer.send("AWSKafkaTutorialTopic", value=data)
producer.flush()
record_metadata = future.get(timeout=10)
print("sent event to Kafka! topic {} partition {} offset {}".format(record_metadata.topic, record_metadata.partition, record_metadata.offset))
except Exception as e:
print(e.with_traceback())
```
1. Ejecute el script con el siguiente comando:
```
$ python3 stock.py
```
1. Deje el script en ejecución mientras completa la siguiente sección.
## Prueba de su cuaderno de Studio
En esta sección, utilizará su cuaderno de Studio para consultar datos de su clúster de Amazon MSK.
1. [¿Abrir la consola Managed Service for Apache Flink en casa? https://console.aws.amazon.com/managed-flink/ region=us-east-1\$1/applications/panel](https://console.aws.amazon.com/managed-flink/home?region=us-east-1#/applications/dashboard) de control.
1. En la página de **Aplicaciones de Managed Service para Apache Flink**, seleccione la pestaña **Cuaderno de Studio**. Elija **MyNotebook**.
1. **En la página, selecciona Abrir en Apache Zeppelin. **MyNotebook****
La interfaz de Apache Zeppelin se abre en una pestaña nueva.
1. En la página **¡Bienvenido a Zeppelin\$1**, elija la **nueva nota de Zeppelin**.
1. En la página **Zeppelin Note**, introduzca la siguiente consulta en una nota nueva:
```
%flink.ssql(type=update)
select * from stock
```
Seleccione el icono de reproducción.
La aplicación muestra los datos del clúster de Amazon MSK.
Para abrir el Panel de control de Apache Flink de su aplicación y ver los aspectos operativos, elija **TRABAJO DE FLINK**. Para obtener más información sobre el Panel de control de Flink, consulte [Apache Flink Dashboard](https://docs.aws.amazon.com/managed-flink/latest/java/how-dashboard.html) en la Guía para desarrolladores de [Managed Service para Apache Flink](https://docs.aws.amazon.com/).
Para ver más ejemplos de consultas SQL de Flink Streaming, consulte [Queries](https://nightlies.apache.org/flink/flink-docs-release-1.15/dev/table/sql/queries.html) en la [documentación de Apache Flink.](https://nightlies.apache.org/flink/flink-docs-release-1.15/)