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.

# Ejemplo: Detección de puntos calientes en una secuencia (función HOTSPOSTS)
<a name="app-hotspots-detection"></a>

Amazon Kinesis Data Analytics dispone de la función `HOTSPOTS` que localiza y devuelve información sobre las regiones relativamente densas en los datos. Para obtener más información, consulte [HOTSPOTS](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-hotspots.html) en la *Referencia de SQL de Amazon Managed Service para Apache Flink*. 

En este ejercicio, puede escribir código de la aplicación para localizar puntos calientes en el origen de streaming de su aplicación. Realice los pasos siguientes para configurar la aplicación:

1. **Configure un origen de streaming**: configure una secuencia de Kinesis y escriba datos coordinados de muestra, tal y como se muestra a continuación:

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

   El ejemplo proporciona un script de Python para que pueda rellenar la secuencia. Los valores `x` e `y` se generan de forma aleatoria. Algunos registros se agrupan en torno a determinadas ubicaciones.

   El campo `is_hot` se suministra como indicador si el script ha generado el valor de forma intencionada como parte de un punto caliente. Esto puede ayudarle a evaluar si la función de detección de puntos calientes funciona correctamente.

1. **Cree la aplicación**: utilice la Consola de administración de AWS para crear la aplicación de análisis de datos de Kinesis Data Analytics. Configure la entrada de la aplicación mapeando el origen de streaming a una secuencia en la aplicación (`SOURCE_SQL_STREAM_001`). Cuando se inicia la aplicación, Kinesis Data Analytics lee continuamente el origen de streaming e introduce los registros en la secuencia en la aplicación.

   En este ejercicio, utilizará el siguiente código para la aplicación:

   ```
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
       "x" DOUBLE, 
       "y" DOUBLE, 
       "is_hot" VARCHAR(4),
       HOTSPOTS_RESULT VARCHAR(10000)
   ); 
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
       INSERT INTO "DESTINATION_SQL_STREAM" 
       SELECT "x", "y", "is_hot", "HOTSPOTS_RESULT" 
       FROM TABLE (
           HOTSPOTS(   
               CURSOR(SELECT STREAM "x", "y", "is_hot" FROM "SOURCE_SQL_STREAM_001"), 
               1000, 
               0.2, 
               17)
       );
   ```

   El código lee filas en `SOURCE_SQL_STREAM_001`, las analiza en busca de puntos calientes relevantes y escribe los datos resultantes en otra secuencia en la aplicación (`DESTINATION_SQL_STREAM`). Utilice bombas para insertar filas en secuencias en la aplicación. Para obtener más información, consulte [Secuencias y bombeos en la aplicación](streams-pumps.md).

1. **Configure la salida**: configure la salida de la aplicación para que envíe los datos desde la aplicación a un destino externo, que es otro flujo de datos de Kinesis. Revise las puntuaciones de los puntos calientes y determine qué puntuaciones indican que se ha producido un punto caliente (del cual desea que se le avise). Puede utilizar una AWS Lambda función para seguir procesando la información de los puntos de acceso y configurar las alertas. 

1. **Verifique el resultado**: el ejemplo incluye una JavaScript aplicación que lee los datos del flujo de salida y los muestra gráficamente, de modo que pueda ver los puntos de acceso que genera la aplicación en tiempo real. 



El ejercicio utiliza la región de Oeste de EE. UU. (Oregón) (`us-west-2`) para crear estas secuencias y su aplicación. Si utiliza otra región, deberá actualizar el código en consecuencia.

**Topics**
+ [Paso 1: Crear las secuencias de entrada y de salida](app-hotspots-prepare.md)
+ [Paso 2: creación de una aplicación de Kinesis Data Analytics](app-hotspot-create-app.md)
+ [Paso 3: Configurar la salida de la aplicación](app-hotspots-create-ka-app-config-destination.md)
+ [Paso 4: Verificar la salida de la aplicación](app-hotspots-verify-output.md)

# 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)

# Paso 2: creación de una aplicación de Kinesis Data Analytics
<a name="app-hotspot-create-app"></a>

En esta sección del [Ejemplo de puntos de acceso](app-hotspots-detection.md), crea una aplicación de análisis de datos de Kinesis Data Analytics tal como se indica a continuación:
+ Configure la entrada de la aplicación para que utilice el flujo de datos de Kinesis que ha creado como origen de streaming en el [Paso 1](app-hotspots-prepare.md).
+ Utilice el código de la aplicación proporcionado en la Consola de administración de AWS.

**Cómo crear una aplicación de**

1. Cree una aplicación de análisis de datos de Kinesis Data Analytics; para ello, siga los pasos 1, 2 y 3 del ejercicio de [Introducción](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html) (consulte [Paso 3.1: Cree una aplicación](get-started-create-app.md)).

   En la configuración fuente, haga lo siguiente:
   + Especifique el origen de streaming que creó en [Paso 1: Crear las secuencias de entrada y de salida](app-hotspots-prepare.md).
   + Después de que la consola deduzca el esquema, edítelo. Asegúrese de que los tipos de columna `x` e `y` estén establecidos en `DOUBLE` y que el tipo de columna `IS_HOT` esté establecido en `VARCHAR`. 

1. Utilice el siguiente código de la aplicación (puede pegar este código en el editor de SQL):

   ```
   CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
       "x" DOUBLE, 
       "y" DOUBLE, 
       "is_hot" VARCHAR(4),
       HOTSPOTS_RESULT VARCHAR(10000)
   ); 
   CREATE OR REPLACE PUMP "STREAM_PUMP" AS 
       INSERT INTO "DESTINATION_SQL_STREAM" 
       SELECT "x", "y", "is_hot", "HOTSPOTS_RESULT" 
       FROM TABLE (
           HOTSPOTS(   
               CURSOR(SELECT STREAM "x", "y", "is_hot" FROM "SOURCE_SQL_STREAM_001"), 
               1000, 
               0.2, 
               17)
       );
   ```

   

1. Ejecute el código SQL y revise los resultados.  
![\[Resultados del código SQL que muestran los valores de rowtime, hotspot y hotspot_heat.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/hotspot-v2-40.png)





**Paso siguiente**  
[Paso 3: Configurar la salida de la aplicación](app-hotspots-create-ka-app-config-destination.md)

# Paso 3: Configurar la salida de la aplicación
<a name="app-hotspots-create-ka-app-config-destination"></a>

Llegados a este punto del [Ejemplo de puntos de acceso](app-hotspots-detection.md), el código de la aplicación de Amazon Kinesis Data Analytics ha descubierto ya numerosos puntos de acceso de un origen de streaming y les ha asignado una puntuación a cada uno. 

Ahora puede enviar el resultado de la aplicación desde la secuencia en la aplicación hasta un destino externo, que es otro flujo de datos de Kinesis (`ExampleOutputStream`). A continuación, puede analizar las puntuaciones de los puntos calientes y determinar cuál podría ser un umbral adecuado de calor de los puntos calientes. Puede ampliar esta aplicación más para generar alertas. 

**Para configurar la salida de la aplicación**

1. Abra la consola de Kinesis Data Analytics [ https://console---aws.amazon.com.rproxy.govskope.caen](https://console.aws.amazon.com/kinesisanalytics) /kinesisanalytics.

1. En el editor de SQL, puede elegir tanto **Destination** como **Add a destination** en el panel de la aplicación. 

1. En la página **Add a destination (Añadir un destino)**, seleccione **Select from your streams (Seleccionar de sus secuencias)**. A continuación, elija la secuencia `ExampleOutputStream` que ha creado en la sección anterior.

   Ahora tiene un destino externo, donde Amazon Kinesis Data Analytics persiste en cualquier registro que escriba su aplicación en la secuencia en la aplicación `DESTINATION_SQL_STREAM`. 

1. Si lo desea, puede configurarla para AWS Lambda que supervise la transmisión y le envíe alertas`ExampleOutputStream`. Para obtener más información, consulte [Uso de una función de Lambda como salida](how-it-works-output-lambda.md). También puede revisar los registros que escribe Kinesis Data Analytics en el destino externo, que es la secuencia `ExampleOutputStream` de Kinesis, tal como se describe en [Paso 4: Verificar la salida de la aplicación](app-hotspots-verify-output.md).

**Paso siguiente**  
[Paso 4: Verificar la salida de la aplicación](app-hotspots-verify-output.md)

# Paso 4: Verificar la salida de la aplicación
<a name="app-hotspots-verify-output"></a>

En esta sección del [ejemplo de puntos calientes](app-hotspots-detection.md), debe configurar una aplicación web que muestre la información de puntos calientes en un control de gráficos vectoriales escalables (SVG).

1. Cree un archivo denominado `index.html` con el siguiente contenido:

   ```
   <!doctype html>
   <html lang=en>
   <head>
       <meta charset=utf-8>
       <title>hotspots viewer</title>
   
       <style>
       #visualization {
         display: block;
         margin: auto;
       }
   
       .point {
         opacity: 0.2;
       }
   
       .hot {
         fill: red;
       }
   
       .cold {
         fill: blue;
       }
   
       .hotspot {
         stroke: black;
         stroke-opacity: 0.8;
         stroke-width: 1;
         fill: none;
       }
       </style>
       <script src="https://sdk.amazonaws.com/js/aws-sdk-2.202.0.min.js"></script>
       <script src="https://d3js.org/d3.v4.min.js"></script>
   </head>
   <body>
   <svg id="visualization" width="600" height="600"></svg>
   <script src="hotspots_viewer.js"></script>
   </body>
   </html>
   ```

1. Cree un archivo en el mismo directorio denominado `hotspots_viewer.js` con el siguiente contenido. Proporcione su región, las credenciales y el nombre de la secuencia de salida en las variables suministradas.

   ```
   // Visualize example output from the Kinesis Analytics hotspot detection algorithm.
   // This script assumes that the output stream has a single shard.
   
   // Modify this section to reflect your AWS configuration
   var awsRegion = "",        // The  where your Kinesis Analytics application is configured.
       accessKeyId = "",      // Your Access Key ID
       secretAccessKey = "",  // Your Secret Access Key
       outputStream = "";     // The name of the Kinesis Stream where the output from the HOTSPOTS function is being written
   
   // The variables in this section should reflect way input data was generated and the parameters that the HOTSPOTS
   // function was called with.
   var windowSize = 1000, // The window size used for hotspot detection
       minimumDensity = 40,  // A filter applied to returned hotspots before visualization
       xRange = [0, 10],  // The range of values to display on the x-axis
       yRange = [0, 10];  // The range of values to display on the y-axis
   
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   // D3 setup
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
   var svg = d3.select("svg"),
       margin = {"top": 20, "right": 20, "bottom": 20, "left": 20},
       graphWidth = +svg.attr("width") - margin.left - margin.right,
       graphHeight = +svg.attr("height") - margin.top - margin.bottom;
   
   // Return the linear function that maps the segment [a, b] to the segment [c, d].
   function linearScale(a, b, c, d) {
       var m = (d - c) / (b - a);
       return function(x) {
           return c + m * (x - a);
       };
   }
   
   // helper functions to extract the x-value from a stream record and scale it for output
   var xValue = function(r) { return r.x; },
       xScale = linearScale(xRange[0], xRange[1], 0, graphWidth),
       xMap = function(r) { return xScale(xValue(r)); };
   
   // helper functions to extract the y-value from a stream record and scale it for output
   var yValue = function(r) { return r.y; },
       yScale = linearScale(yRange[0], yRange[1], 0, graphHeight),
       yMap = function(r) { return yScale(yValue(r)); };
   
   // a helper function that assigns a CSS class to a point based on whether it was generated as part of a hotspot
   var classMap = function(r) { return r.is_hot == "Y" ? "point hot" : "point cold"; };
   
   var g = svg.append("g")
       .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
   
   function update(records, hotspots) {
   
       var points = g.selectAll("circle")
           .data(records, function(r) { return r.dataIndex; });
   
       points.enter().append("circle")
           .attr("class", classMap)
           .attr("r", 3)
           .attr("cx", xMap)
           .attr("cy", yMap);
   
       points.exit().remove();
   
       if (hotspots) {
           var boxes = g.selectAll("rect").data(hotspots);
   
           boxes.enter().append("rect")
               .merge(boxes)
               .attr("class", "hotspot")
               .attr("x", function(h) { return xScale(h.minValues[0]); })
               .attr("y", function(h) { return yScale(h.minValues[1]); })
               .attr("width", function(h) { return xScale(h.maxValues[0]) - xScale(h.minValues[0]); })
               .attr("height", function(h) { return yScale(h.maxValues[1]) - yScale(h.minValues[1]); });
   
           boxes.exit().remove();
       }
   }
   
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   // Use the AWS SDK to pull output records from Kinesis and update the visualization
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
   var kinesis = new AWS.Kinesis({
       "region": awsRegion,
       "accessKeyId": accessKeyId,
       "secretAccessKey": secretAccessKey
   });
   
   var textDecoder = new TextDecoder("utf-8");
   
   // Decode an output record into an object and assign it an index value
   function decodeRecord(record, recordIndex) {
       var record = JSON.parse(textDecoder.decode(record.Data));
       var hotspots_result = JSON.parse(record.HOTSPOTS_RESULT);
       record.hotspots = hotspots_result.hotspots
           .filter(function(hotspot) { return hotspot.density >= minimumDensity});
       record.index = recordIndex
       return record;
   }
   
   // Fetch a new records from the shard iterator, append them to records, and update the visualization
   function getRecordsAndUpdateVisualization(shardIterator, records, lastRecordIndex) {
       kinesis.getRecords({
           "ShardIterator": shardIterator
       }, function(err, data) {
           if (err) {
               console.log(err, err.stack);
               return;
           }
   
           var newRecords = data.Records.map(function(raw) { return decodeRecord(raw, ++lastRecordIndex); });
           newRecords.forEach(function(record) { records.push(record); });
   
           var hotspots = null;
           if (newRecords.length > 0) {
               hotspots = newRecords[newRecords.length - 1].hotspots;
           }
   
           while (records.length > windowSize) {
               records.shift();
           }
   
           update(records, hotspots);
   
           getRecordsAndUpdateVisualization(data.NextShardIterator, records, lastRecordIndex);
       });
   }
   
   // Get a shard iterator for the output stream and begin updating the visualization. Note that this script will only
   // read records from the first shard in the stream.
   function init() {
       kinesis.describeStream({
           "StreamName": outputStream
       }, function(err, data) {
           if (err) {
               console.log(err, err.stack);
               return;
           }
   
           var shardId = data.StreamDescription.Shards[0].ShardId;
   
           kinesis.getShardIterator({
               "StreamName": outputStream,
               "ShardId": shardId,
               "ShardIteratorType": "LATEST"
           }, function(err, data) {
               if (err) {
                   console.log(err, err.stack);
                   return;
               }
               getRecordsAndUpdateVisualization(data.ShardIterator, [], 0);
           })
       });
   }
   
   // Start the visualization
   init();
   ```

1. Cuando el código de Python de la primera sección se esté ejecutando, abra `index.html` en un navegador web. La información de punto caliente aparece en la página, como se muestra a continuación.

     
![\[Diagrama de gráficos vectoriales escalables que muestra información de los puntos calientes.\]](http://docs.aws.amazon.com/es_es/kinesisanalytics/latest/dev/images/hotspots_visualizer.png)