Après mûre réflexion, nous avons décidé de mettre fin à Amazon Kinesis Data Analytics pour les applications SQL :

1. À compter du **1er septembre 2025,** nous ne fournirons aucune correction de bogue pour les applications Amazon Kinesis Data Analytics for SQL, car leur support sera limité, compte tenu de l'arrêt prochain.

2. À compter du **15 octobre 2025,** vous ne pourrez plus créer de nouvelles applications Kinesis Data Analytics for SQL.

3. Nous supprimerons vos candidatures à compter **du 27 janvier 2026**. Vous ne serez pas en mesure de démarrer ou d'utiliser vos applications Amazon Kinesis Data Analytics for SQL. Support ne sera plus disponible pour Amazon Kinesis Data Analytics for SQL à partir de cette date. Pour de plus amples informations, veuillez consulter [Arrêt d'Amazon Kinesis Data Analytics pour les applications SQL](discontinuation.md).

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Exemple : Détection des points chauds sur un flux (fonction HOTSPOTS)
<a name="app-hotspots-detection"></a>

Amazon Kinesis Data Analytics fournit la fonction `HOTSPOTS` qui peut rechercher et renvoyer des informations sur les régions relativement denses de vos données. Pour plus d’informations, consultez [HOTSPOTS](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sqlrf-hotspots.html) dans le manuel *Référence SQL du service géré Amazon pour Apache Flink*. 

Dans cet exercice, vous allez écrire du code d'application pour localiser les points chauds sur la source de streaming de votre application. Pour configurer l'application, exécutez les étapes suivantes :

1. **Configurer une source de streaming** : vous configurez un flux Kinesis et écrivez des exemples de données de coordonnées, comme illustré ci-après :

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

   L'exemple fournit un script Python qui vous permet de remplir le flux. Les valeurs `x` et `y` sont générées de façon aléatoire, avec des enregistrements regroupés autour de certains emplacements.

   Le champ `is_hot` est fourni en tant qu'indicateur si le script a généré intentionnellement la valeur dans le cadre d'un point chaud. Cela peut vous aider à évaluer si la fonction de détection des points chauds fonctionne correctement.

1. **Créer l’application** : avec AWS Management Console, vous pouvez alors créer une application Kinesis Data Analytics. Configurez l'entrée d'application en mappant la source de streaming sur un flux intégré à l'application (`SOURCE_SQL_STREAM_001`). Lorsque l’application démarre, Kinesis Data Analytics lit en continu la source de streaming et insère des enregistrements dans le flux intégré à l’application.

   Dans cet exercice, vous utilisez le code suivant pour l'application :

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

   Le code lit les lignes dans le flux `SOURCE_SQL_STREAM_001`, l'analyse pour rechercher les points chauds significatifs et écrit les données résultantes dans une autre flux intégré à l'application (`DESTINATION_SQL_STREAM`). Vous utilisez des pompes pour insérer des lignes dans les flux intégrés à l'application. Pour de plus amples informations, veuillez consulter [Flux et pompes intégrés à l'application](streams-pumps.md).

1. **Configurer la sortie** : vous configurez la sortie de l’application pour envoyer des données depuis l’application vers une destination externe qui est un autre flux de données Kinesis. Vérifiez les scores de point chaud et identifiez ceux qui indiquent qu'un point chaud a eu lieu (et que vous devez être alerté). Vous pouvez utiliser une AWS Lambda fonction pour traiter plus en détail les informations du hotspot et configurer les alertes. 

1. **Vérifier le résultat** — L'exemple inclut une JavaScript application qui lit les données du flux de sortie et les affiche graphiquement, afin que vous puissiez visualiser les points chauds générés par l'application en temps réel. 



L’exercice utilise la région USA Ouest (Oregon) (`us-west-2`) pour créer ces flux et votre application. Si vous utilisez une autre région, mettez à jour le code en conséquence.

**Topics**
+ [Étape 1 : Créer les flux d'entrée et de sortie](app-hotspots-prepare.md)
+ [Étape 2 : Création d’une application Kinesis Data Analytics](app-hotspot-create-app.md)
+ [Étape 3 : Configurer la sortie de l'application](app-hotspots-create-ka-app-config-destination.md)
+ [Étape 4 : Vérifier la sortie de l'application](app-hotspots-verify-output.md)

# Étape 1 : Créer les flux d'entrée et de sortie
<a name="app-hotspots-prepare"></a>

Avant de créer une application Amazon Kinesis Data Analytics pour l’[exemple pour les points chauds](app-hotspots-detection.md), vous créez deux flux de données Kinesis. Configurez l’un des flux en tant que source de streaming pour votre application et l’autre flux en tant que destination où Kinesis Data Analytics conserve la sortie de votre application. 

**Topics**
+ [Étape 1.1 : Création des flux de données Kinesis](#app-hotspots-create-two-streams)
+ [Étape 1.2 : Ecriture d'exemples d'enregistrements dans le flux d'entrée](#app-hotspots-write-sample-records-inputstream)

## Étape 1.1 : Création des flux de données Kinesis
<a name="app-hotspots-create-two-streams"></a>

Dans cette section, vous créez deux flux de données Kinesis : `ExampleInputStream` et `ExampleOutputStream`. 

Créez ces flux de données à l'aide de la console ou de l' AWS CLI.
+ Pour créer les flux de données à l'aide de la console :

  1. [Connectez-vous à la console Kinesis AWS Management Console et ouvrez-la à https://console.aws.amazon.com l'adresse /kinesis.](https://console.aws.amazon.com/kinesis)

  1. Choisissez **Data Streams (Flux de données)** dans le volet de navigation.

  1. Choisissez **Create Kinesis stream (Créer un flux Kinesis)**, puis créez un flux avec une partition nommée `ExampleInputStream`.

  1. Répétez l'étape précédente, en créant un flux avec une seule partition nommée `ExampleOutputStream`.
+ Pour créer des flux de données à l'aide de l' AWS CLI :
  + Créez des flux (`ExampleInputStream`et`ExampleOutputStream`) à l'aide de la commande Kinesis `create-stream` AWS CLI suivante. Pour créer le deuxième flux que l'application utilisera pour écrire la sortie, exécutez la même commande en remplaçant le nom du flux par `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
    ```

## Étape 1.2 : Ecriture d'exemples d'enregistrements dans le flux d'entrée
<a name="app-hotspots-write-sample-records-inputstream"></a>

Dans cette étape, vous exécutez du code Python pour générer en continu des exemples d'enregistrements et les écrire dans le flux `ExampleInputStream`.

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

1. Installez Python et `pip`.

   Pour plus d'informations sur l'installation de Python, consultez le site web [Python](https://www.python.org/). 

   Vous pouvez installer des dépendances à l'aide de pip. Pour plus d'informations sur l'installation de pip, consultez [Installation](https://pip.pypa.io/en/stable/installing/) sur le site web de pip.

1. Exécutez le code Python suivant. Ce code effectue les opérations suivantes :
   + Génère un point chaud potentiel quelque part dans le plan (X, Y).
   + Génère un ensemble de 1 000 points pour chaque point chaud. Parmi ces points, 20 % sont regroupés autour du point chaud. Les autres sont générés de façon aléatoire dans l'ensemble de l'espace.
   + La commande `put-record` écrit les enregistrements JSON dans le flux.
**Important**  
Ne chargez pas ce fichier sur un serveur web, car il contient vos informations d’identification 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"),
       )
   ```



**Étape suivante**  
[Étape 2 : Création d’une application Kinesis Data Analytics](app-hotspot-create-app.md)

# Étape 2 : Création d’une application Kinesis Data Analytics
<a name="app-hotspot-create-app"></a>

Dans cette section de l’[exemple pour les points chauds](app-hotspots-detection.md), vous créez une application Kinesis Data Analytics en procédant comme suit :
+ Configurez l’entrée de l’application pour utiliser le flux de données Kinesis que vous avez créé comme source de streaming à l’[étape 1](app-hotspots-prepare.md).
+ Utilisez le code d'application fourni dans l' AWS Management Console.

**Pour créer une application**

1. Créez une application Kinesis Data Analytics en suivant les étapes 1, 2 et 3 de l’exercice [Mise en route](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html) (voir [Étape 3.1 : Créer une application](get-started-create-app.md)).

   Dans la configuration de la source, procédez de la façon suivante :
   + Spécifiez la source de streaming que vous avez créée dans [Étape 1 : Créer les flux d'entrée et de sortie](app-hotspots-prepare.md).
   + Une fois que la console a déduit le schéma, modifiez celui-ci. Assurez-vous que les types de colonne `x` et `y``DOUBLE` sont définis sur , et que le type de colonne `IS_HOT` est défini sur `VARCHAR`. 

1. Utilisez le code d'application suivant (vous pouvez coller ce code dans l'éditeur 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. Exécutez le code SQL et vérifiez les résultats.  
![\[Résultats de code SQL affichant rowtime, hotspot et hotspot_heat.\]](http://docs.aws.amazon.com/fr_fr/kinesisanalytics/latest/dev/images/hotspot-v2-40.png)





**Étape suivante**  
[Étape 3 : Configurer la sortie de l'application](app-hotspots-create-ka-app-config-destination.md)

# Étape 3 : Configurer la sortie de l'application
<a name="app-hotspots-create-ka-app-config-destination"></a>

À ce stade de l’[exemple pour les points chauds](app-hotspots-detection.md), vous avez un code d’application Amazon Kinesis Data Analytics qui identifie des points chauds significatifs d’une source de streaming et qui attribue un score de chaleur à chacun. 

Vous pouvez maintenant envoyer les résultats de l’application depuis le flux intégré à l’application vers une destination externe, qui est un autre flux de données Kinesis (`ExampleOutputStream`). Vous pouvez ensuite analyser les scores de points chauds et déterminer un seuil approprié pour la chaleur des points chauds. Vous pouvez étendre encore cette application pour générer des alertes. 

**Pour configurer la sortie de l'application**

1. [Ouvrez la console Kinesis Data Analytics à l'adresse https://console.aws.amazon.com /kinesisanalytics.](https://console.aws.amazon.com/kinesisanalytics)

1. Dans l'éditeur SQL, choisissez **Destination** ou **Add a destination** dans le tableau de bord d'application. 

1. Sur la page **Add a destination (Ajouter une destination)**, choisissez **Select from your streams (Choisissez parmi vos flux)**. Choisissez ensuite le flux `ExampleOutputStream` que vous avez créé dans la section précédente.

   Maintenant, vous disposez d’une destination externe où Amazon Kinesis Data Analytics conserve tous les enregistrements que votre application écrit dans le flux intégré à l’application `DESTINATION_SQL_STREAM`. 

1. Vous pouvez éventuellement configurer AWS Lambda pour surveiller le `ExampleOutputStream` flux et vous envoyer des alertes. Pour de plus amples informations, veuillez consulter [Utilisation d'une fonction Lambda en tant que sortie](how-it-works-output-lambda.md). Vous pouvez également vérifier les enregistrements écrits par Kinesis Data Analytics dans la destination externe, qui est le flux Kinesis `ExampleOutputStream`, comme décrit dans [Étape 4 : Vérifier la sortie de l'application](app-hotspots-verify-output.md).

**Étape suivante**  
[Étape 4 : Vérifier la sortie de l'application](app-hotspots-verify-output.md)

# Étape 4 : Vérifier la sortie de l'application
<a name="app-hotspots-verify-output"></a>

Dans cette section de l'[exemple pour les points chauds](app-hotspots-detection.md), vous configurez une application web qui affiche des informations sur les points chauds dans un contrôle SVG (Scalable Vector Graphics).

1. Créez un fichier nommé `index.html` avec le contenu suivant :

   ```
   <!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. Créez un fichier dans le même répertoire, nommé `hotspots_viewer.js` avec le contenu suivant. Fournissez votre , les informations d’identification et le nom du flux de sortie dans les variables fournies.

   ```
   // 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. Avec le code Python de l'exécution de la première section, ouvrez `index.html` dans un navigateur web. Les informations sur le point chaud s'affichent sur la page, comme illustré ci-après.

     
![\[Image vectorielle affichant les informations relatives aux points chauds.\]](http://docs.aws.amazon.com/fr_fr/kinesisanalytics/latest/dev/images/hotspots_visualizer.png)