Tras considerarlo detenidamente, hemos decidido dejar de utilizar Amazon Kinesis Data Analytics para aplicaciones SQL:

1. A partir del **1 de septiembre de 2025,** no proporcionaremos ninguna corrección de errores para las aplicaciones de Amazon Kinesis Data Analytics for SQL porque tendremos un soporte limitado debido a la próxima discontinuación.

2. A partir del **15 de octubre de 2025,** no podrá crear nuevas aplicaciones de Kinesis Data Analytics for SQL.

3. Eliminaremos sus aplicaciones a partir del **27 de enero de 2026**. No podrá iniciar ni utilizar sus aplicaciones de Amazon Kinesis Data Analytics para SQL. A partir de ese momento, el servicio de soporte de Amazon Kinesis Data Analytics para SQL dejará de estar disponible. Para obtener más información, consulte [Retirada de las aplicaciones de Amazon Kinesis Data Analytics para SQL](discontinuation.md).

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.

# Paso 1: Crear las secuencias de entrada y de salida
<a name="app-hotspots-prepare"></a>

Antes de crear una aplicación de análisis de datos de Amazon Kinesis Data Analytics para el [Ejemplo de puntos de acceso](app-hotspots-detection.md), deberá crear dos flujos de datos de Kinesis. Configure una de las secuencias como el origen de streaming de su aplicación y otra secuencia como el destino, donde Kinesis Data Analytics sigue siendo la salida de su aplicación. 

**Topics**
+ [Paso 1.1: crear los flujos de datos de Kinesis](#app-hotspots-create-two-streams)
+ [Paso 1.2: Escribir registros de muestra en la secuencia de entrada](#app-hotspots-write-sample-records-inputstream)

## Paso 1.1: crear los flujos de datos de Kinesis
<a name="app-hotspots-create-two-streams"></a>

En esta sección, creará dos secuencias de Kinesis: `ExampleInputStream` y `ExampleOutputStream`. 

Cree estas flujos de datos con la consola o la AWS CLI.
+ Para crear estas flujos de datos con la consola:

  1. [Inicie sesión en la consola de Kinesis Consola de administración de AWS y ábrala en https://console.aws.amazon.com /kinesis.](https://console.aws.amazon.com/kinesis)

  1. Elija **Flujos de datos** en el panel de navegación.

  1. Elija **Create Kinesis Stream (Crear secuencia de Kinesis)** y, a continuación, cree una secuencia con un fragmento denominado `ExampleInputStream`.

  1. Repita el paso anterior y cree una secuencia con un fragmento denominada `ExampleOutputStream`.
+ Para crear flujos de datos con la AWS CLI:
  + Cree transmisiones (`ExampleInputStream`y`ExampleOutputStream`) mediante el siguiente comando de Kinesis `create-stream` AWS CLI . Para crear la segunda secuencia, que la aplicación utilizará para escribir la salida, ejecute el mismo comando, cambiando el nombre de la secuencia a `ExampleOutputStream`.

    ```
    $ aws kinesis create-stream \
    --stream-name ExampleInputStream \
    --shard-count 1 \
    --region us-west-2 \
    --profile adminuser
                             
    $ aws kinesis create-stream \
    --stream-name ExampleOutputStream \
    --shard-count 1 \
    --region us-west-2 \
    --profile adminuser
    ```

## Paso 1.2: Escribir registros de muestra en la secuencia de entrada
<a name="app-hotspots-write-sample-records-inputstream"></a>

En este paso, ejecute el código de Python para generar registros de muestra y escribir en la secuencia `ExampleInputStream`.

```
{"x": 7.921782426109737, "y": 8.746265312709893, "is_hot": "N"}
{"x": 0.722248626580026, "y": 4.648868803193405, "is_hot": "Y"}
```

1. Instale Python y `pip`.

   Para obtener más información sobre la instalación de Python, consulte la página web de [Python](https://www.python.org/). 

   Puede instalar dependencias con pip. Para obtener más información sobre la instalación de pip, consulte la sección [Installation](https://pip.pypa.io/en/stable/installing/) en la página web de pip.

1. Ejecute el siguiente código de Python. Este código hace lo siguiente:
   + Genera un punto caliente potencial en algún lugar del plano (X, Y).
   + Genera un conjunto de 1000 puntos para cada punto caliente. De estos puntos, el 20 % se agrupa en torno a un punto caliente. El resto se genera de forma aleatoria en todo el espacio.
   + El comando `put-record` escribe los registros JSON en la secuencia.
**importante**  
No cargue este archivo en un servidor web, ya que contiene sus credenciales de AWS .

   ```
    
   import json
   from pprint import pprint
   import random
   import time
   import boto3
   
   STREAM_NAME = "ExampleInputStream"
   
   
   def get_hotspot(field, spot_size):
       hotspot = {
           "left": field["left"] + random.random() * (field["width"] - spot_size),
           "width": spot_size,
           "top": field["top"] + random.random() * (field["height"] - spot_size),
           "height": spot_size,
       }
       return hotspot
   
   
   def get_record(field, hotspot, hotspot_weight):
       rectangle = hotspot if random.random() < hotspot_weight else field
       point = {
           "x": rectangle["left"] + random.random() * rectangle["width"],
           "y": rectangle["top"] + random.random() * rectangle["height"],
           "is_hot": "Y" if rectangle is hotspot else "N",
       }
       return {"Data": json.dumps(point), "PartitionKey": "partition_key"}
   
   
   def generate(
       stream_name, field, hotspot_size, hotspot_weight, batch_size, kinesis_client
   ):
       """
       Generates points used as input to a hotspot detection algorithm.
       With probability hotspot_weight (20%), a point is drawn from the hotspot;
       otherwise, it is drawn from the base field. The location of the hotspot
       changes for every 1000 points generated.
       """
       points_generated = 0
       hotspot = None
       while True:
           if points_generated % 1000 == 0:
               hotspot = get_hotspot(field, hotspot_size)
           records = [
               get_record(field, hotspot, hotspot_weight) for _ in range(batch_size)
           ]
           points_generated += len(records)
           pprint(records)
           kinesis_client.put_records(StreamName=stream_name, Records=records)
   
           time.sleep(0.1)
   
   
   if __name__ == "__main__":
       generate(
           stream_name=STREAM_NAME,
           field={"left": 0, "width": 10, "top": 0, "height": 10},
           hotspot_size=1,
           hotspot_weight=0.2,
           batch_size=10,
           kinesis_client=boto3.client("kinesis"),
       )
   ```



**Paso siguiente**  
[Paso 2: creación de una aplicación de Kinesis Data Analytics](app-hotspot-create-app.md)