Pour des fonctionnalités similaires à celles d'Amazon Timestream pour, pensez à Amazon Timestream LiveAnalytics pour InfluxDB. Il permet une ingestion simplifiée des données et des temps de réponse aux requêtes à un chiffre en millisecondes pour des analyses en temps réel. Pour en savoir plus, [cliquez ici](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html).
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.
# Fonctionnalité de série chronologique intégrée
Timestream for LiveAnalytics fournit une fonctionnalité de série chronologique intégrée qui traite les données de séries chronologiques comme un concept de premier ordre.
La fonctionnalité de série chronologique intégrée peut être divisée en deux catégories : les vues et les fonctions.
Vous pouvez en savoir plus sur chaque construction ci-dessous.
**Topics**
+ [Vues des séries chronologiques](timeseries-specific-constructs.views.md)
+ [Fonctions de séries chronologiques](timeseries-specific-constructs.functions.md)
# Vues des séries chronologiques
Timestream for LiveAnalytics prend en charge les fonctions suivantes pour transformer vos données en type de `timeseries` données :
**Topics**
+ [CREATE\$1TIME\$1SERIES](#timeseries-specific-constructs.views.CREATE_TIME_SERIES)
+ [UNNEST](#timeseries-specific-constructs.views.UNNEST)
## CREATE\$1TIME\$1SERIES
**CREATE\$1TIME\$1SERIES** est une fonction d'agrégation qui prend toutes les mesures brutes d'une série chronologique (valeurs temporelles et valeurs de mesure) et renvoie un type de données de série chronologique. La syntaxe de cette fonction est la suivante :
```
CREATE_TIME_SERIES(time, measure_value::)
```
où `` est le type de données de la valeur de mesure et peut être bigint, boolean, double ou varchar. Le second paramètre ne peut pas être nul.
Tenez compte de l'utilisation du processeur des instances EC2 stockées dans une table nommée **metrics**, comme indiqué ci-dessous :
| Heure | region | az | vpc | instance\$1id | nom\$1mesure | valeur\$1mesure : double |
| --- | --- | --- | --- | --- | --- | --- |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | utilisation du processeur | 35,0 |
| 2019-12-04 19:00:01 000 000000 | us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | utilisation du processeur | 38,2 |
| 2019-12-04 19:00:02 000 000000 | us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | utilisation du processeur | 45,3 |
| 2019-12-04 19:00:00.000 000000 | us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | utilisation du processeur | 54,1 |
| 2019-12-04 19:00:01 000 000000 | us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | utilisation du processeur | 42,5 |
| 2019-12-04 19:00:02 000 000000 | us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | utilisation du processeur | 33,7 |
Exécution de la requête :
```
SELECT region, az, vpc, instance_id, CREATE_TIME_SERIES(time, measure_value::double) as cpu_utilization FROM metrics
WHERE measure_name=’cpu_utilization’
GROUP BY region, az, vpc, instance_id
```
renverra toutes les séries qui ont `cpu_utilization` comme valeur de mesure. Dans ce cas, nous avons deux séries :
| region | az | vpc | instance\$1id | utilisation du processeur |
| --- | --- | --- | --- | --- |
| us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef0 | [\$1time : 2019-12-04 19:00:00.000 000000, measure\$1value : :double : 35.0\$1, \$1time : 2019-12-04 19:00:01.000 000000, measure\$1value : :double : 38.2\$1, \$1time : 2019-12-04 19:00:02.000 000000, measure\$1value : :double : 45,3\$1] |
| us-east-1 | us-east-1d | vpc-1a2b3c4d | i-1234567890abcdef1 | [\$1time : 2019-12-04 19:00:00.000 000000, measure\$1value : :double : 35.1\$1, \$1time : 2019-12-04 19:00:01.000 000000, measure\$1value : :double : 38.5\$1, \$1time : 2019-12-04 19:00:02.000 000000, measure\$1value : :double : 45,7\$1] |
## UNNEST
`UNNEST`est une fonction de table qui vous permet de transformer `timeseries` les données en modèle plat. La syntaxe est la suivante :
`UNNEST``timeseries`transforme a en deux colonnes, à savoir, `time` et`value`. Vous pouvez également utiliser des alias avec UNNEST, comme indiqué ci-dessous :
```
UNNEST(timeseries) AS (time_alias, value_alias)
```
où `` est l'alias de la table plate, `time_alias` l'alias de la `time` colonne et `value_alias` l'alias de la `value` colonne.
Par exemple, imaginez le scénario dans lequel certaines instances EC2 de votre parc sont configurées pour émettre des métriques à un intervalle de 5 secondes, d'autres à un intervalle de 15 secondes, et vous avez besoin des métriques moyennes pour toutes les instances avec une granularité de 10 secondes au cours des 6 dernières heures. Pour obtenir ces données, vous transformez vos métriques en un modèle de série chronologique à l'aide de **CREATE\$1TIME\$1SERIES**. Vous pouvez ensuite utiliser **INTERPOLATE\$1LINEAR** pour obtenir les valeurs manquantes avec une granularité de 10 secondes. Ensuite, vous retransformez les données en modèle plat à l'aide d'**UNNEST**, puis vous utilisez **AVG** pour obtenir les mesures moyennes sur toutes les instances.
```
WITH interpolated_timeseries AS (
SELECT region, az, vpc, instance_id,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(ago(6h), now(), 10s)) AS interpolated_cpu_utilization
FROM timestreamdb.metrics
WHERE measure_name= ‘cpu_utilization’ AND time >= ago(6h)
GROUP BY region, az, vpc, instance_id
)
SELECT region, az, vpc, instance_id, avg(t.cpu_util)
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_cpu_utilization) AS t (time, cpu_util)
GROUP BY region, az, vpc, instance_id
```
La requête ci-dessus illustre l'utilisation d'**UNNEST** avec un alias. Vous trouverez ci-dessous un exemple de la même requête sans utiliser d'alias pour **UNNEST** :
```
WITH interpolated_timeseries AS (
SELECT region, az, vpc, instance_id,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(ago(6h), now(), 10s)) AS interpolated_cpu_utilization
FROM timestreamdb.metrics
WHERE measure_name= ‘cpu_utilization’ AND time >= ago(6h)
GROUP BY region, az, vpc, instance_id
)
SELECT region, az, vpc, instance_id, avg(value)
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_cpu_utilization)
GROUP BY region, az, vpc, instance_id
```
# Fonctions de séries chronologiques
Amazon Timestream LiveAnalytics for prend en charge les fonctions de séries chronologiques, telles que les dérivées, les intégrales et les corrélations, entre autres, afin d'obtenir des informations plus approfondies à partir de vos données de séries chronologiques. Cette section fournit des informations d'utilisation pour chacune de ces fonctions, ainsi que des exemples de requêtes. Sélectionnez un sujet ci-dessous pour en savoir plus.
**Topics**
+ [Fonctions d'interpolation](timeseries-specific-constructs.functions.interpolation.md)
+ [Fonctions dérivées](timeseries-specific-constructs.functions.derivatives.md)
+ [Fonctions intégrales](timeseries-specific-constructs.functions.integrals.md)
+ [Fonctions de corrélation](timeseries-specific-constructs.functions.correlation.md)
+ [Fonctions de filtrage et de réduction](timeseries-specific-constructs.functions.filter-reduce.md)
# Fonctions d'interpolation
Si les données de votre série chronologique ne contiennent pas de valeurs pour des événements à certains moments, vous pouvez estimer les valeurs de ces événements manquants à l'aide d'une interpolation. Amazon Timestream prend en charge quatre variantes d'interpolation : l'interpolation linéaire, l'interpolation par spline cubique, l'interpolation de la dernière observation reportée (locf) et l'interpolation constante. Cette section fournit des informations d'utilisation du Timestream pour les fonctions LiveAnalytics d'interpolation, ainsi que des exemples de requêtes.
## Informations d'utilisation
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| `interpolate_linear(timeseries, array[timestamp])` | séries chronologiques | Complète les données manquantes à l'aide d'[une interpolation linéaire](https://wikipedia.org/wiki/Linear_interpolation). |
| `interpolate_linear(timeseries, timestamp)` | double | Complète les données manquantes à l'aide d'[une interpolation linéaire](https://wikipedia.org/wiki/Linear_interpolation). |
| `interpolate_spline_cubic(timeseries, array[timestamp])` | séries chronologiques | Complète les données manquantes à l'aide d'une [interpolation par splines cubiques](https://wikiversity.org/wiki/Cubic_Spline_Interpolation#:~:text=Cubic%20spline%20interpolation%20is%20a,Lagrange%20polynomial%20and%20Newton%20polynomial.). |
| `interpolate_spline_cubic(timeseries, timestamp)` | double | Complète les données manquantes à l'aide d'une [interpolation par splines cubiques](https://wikiversity.org/wiki/Cubic_Spline_Interpolation#:~:text=Cubic%20spline%20interpolation%20is%20a,Lagrange%20polynomial%20and%20Newton%20polynomial.). |
| `interpolate_locf(timeseries, array[timestamp])` | séries chronologiques | Complète les données manquantes en utilisant la dernière valeur échantillonnée. |
| `interpolate_locf(timeseries, timestamp)` | double | Complète les données manquantes en utilisant la dernière valeur échantillonnée. |
| `interpolate_fill(timeseries, array[timestamp], double)` | séries chronologiques | Complète les données manquantes à l'aide d'une valeur constante. |
| `interpolate_fill(timeseries, timestamp, double)` | double | Complète les données manquantes à l'aide d'une valeur constante. |
## Exemples de requêtes
**Example**
Trouvez l'utilisation moyenne du processeur regroupée à intervalles de 30 secondes pour un hôte EC2 spécifique au cours des 2 dernières heures, en remplissant les valeurs manquantes à l'aide d'une interpolation linéaire :
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
**Example**
Trouvez l'utilisation moyenne du processeur regroupée à intervalles de 30 secondes pour un hôte EC2 spécifique au cours des 2 dernières heures, en remplissant les valeurs manquantes à l'aide d'une interpolation basée sur la dernière observation reportée :
```
WITH binned_timeseries AS (
SELECT hostname, BIN(time, 30s) AS binned_timestamp, ROUND(AVG(measure_value::double), 2) AS avg_cpu_utilization
FROM "sampleDB".DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv'
AND time > ago(2h)
GROUP BY hostname, BIN(time, 30s)
), interpolated_timeseries AS (
SELECT hostname,
INTERPOLATE_LOCF(
CREATE_TIME_SERIES(binned_timestamp, avg_cpu_utilization),
SEQUENCE(min(binned_timestamp), max(binned_timestamp), 15s)) AS interpolated_avg_cpu_utilization
FROM binned_timeseries
GROUP BY hostname
)
SELECT time, ROUND(value, 2) AS interpolated_cpu
FROM interpolated_timeseries
CROSS JOIN UNNEST(interpolated_avg_cpu_utilization)
```
# Fonctions dérivées
Les dérivés sont utilisés pour calculer le taux de variation d'une métrique donnée et peuvent être utilisés pour répondre de manière proactive à un événement. Supposons, par exemple, que vous calculiez la dérivée de l'utilisation du processeur des instances EC2 au cours des 5 dernières minutes et que vous remarquiez une dérivée positive significative. Cela peut indiquer une augmentation de la charge de travail. Vous pouvez donc décider de créer davantage d'instances EC2 pour mieux gérer votre charge de travail.
Amazon Timestream prend en charge deux variantes de fonctions dérivées. Cette section fournit des informations d'utilisation du Timestream pour les fonctions LiveAnalytics dérivées, ainsi que des exemples de requêtes.
## Informations d'utilisation
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| `derivative_linear(timeseries, interval)` | séries chronologiques | Calcule la [dérivée](https://wikipedia.org/wiki/Derivative) de chaque point du `timeseries` pour le spécifié`interval`. |
| `non_negative_derivative_linear(timeseries, interval)` | séries chronologiques | Identique`derivative_linear(timeseries, interval)`, mais ne renvoie que des valeurs positives. |
## Exemples de requêtes
**Example**
Trouvez le taux de variation de l'utilisation du processeur toutes les 5 minutes au cours de la dernière heure :
```
SELECT DERIVATIVE_LINEAR(CREATE_TIME_SERIES(time, measure_value::double), 5m) AS result
FROM “sampleDB”.DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv' and time > ago(1h)
GROUP BY hostname, measure_name
```
**Example**
Calculez le taux d'augmentation des erreurs générées par un ou plusieurs microservices :
```
WITH binned_view as (
SELECT bin(time, 5m) as binned_timestamp, ROUND(AVG(measure_value::double), 2) as value
FROM “sampleDB”.DevOps
WHERE micro_service = 'jwt'
AND time > ago(1h)
AND measure_name = 'service_error'
GROUP BY bin(time, 5m)
)
SELECT non_negative_derivative_linear(CREATE_TIME_SERIES(binned_timestamp, value), 1m) as rateOfErrorIncrease
FROM binned_view
```
# Fonctions intégrales
Vous pouvez utiliser des intégrales pour déterminer l'aire sous la courbe par unité de temps pour les événements de votre série chronologique. Supposons par exemple que vous suiviez le volume de demandes reçues par votre application par unité de temps. Dans ce scénario, vous pouvez utiliser la fonction intégrale pour déterminer le volume total de demandes traitées par intervalle spécifié sur une période donnée.
Amazon Timestream prend en charge une variante des fonctions intégrales. Cette section fournit des informations d'utilisation du Timestream pour la fonction LiveAnalytics intégrale, ainsi que des exemples de requêtes.
## Informations d'utilisation
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| `integral_trapezoidal(timeseries(double))` `integral_trapezoidal(timeseries(double), interval day to second)` `integral_trapezoidal(timeseries(bigint))` `integral_trapezoidal(timeseries(bigint), interval day to second)` `integral_trapezoidal(timeseries(integer), interval day to second)` `integral_trapezoidal(timeseries(integer))` | double | Correspond approximativement à l'[intégrale](https://wikipedia.org/wiki/Integral) spécifiée `interval day to second` pour la valeur `timeseries` fournie, en utilisant la règle du [trapèze](https://wikipedia.org/wiki/Trapezoidal_rule). Le paramètre d'intervalle entre le jour et la seconde est facultatif et la valeur par défaut est`1s`. Pour plus d'informations sur les intervalles, consultez[Intervalle et durée](date-time-functions.md#date-time-functions-interval-duration). |
## Exemples de requêtes
**Example**
Calculez le volume total de demandes traitées toutes les cinq minutes au cours de la dernière heure par un hôte spécifique :
```
SELECT INTEGRAL_TRAPEZOIDAL(CREATE_TIME_SERIES(time, measure_value::double), 5m) AS result FROM sample.DevOps
WHERE measure_name = 'request'
AND hostname = 'host-Hovjv'
AND time > ago (1h)
GROUP BY hostname, measure_name
```
# Fonctions de corrélation
Pour deux séries chronologiques de longueur similaire, les fonctions de corrélation fournissent un coefficient de corrélation, qui explique l'évolution des deux séries chronologiques dans le temps. Le coefficient de corrélation est compris entre `-1.0` et`1.0`. `-1.0`indique que les deux séries chronologiques évoluent dans des directions opposées au même rythme, alors qu'`1.0`indique que les deux séries chronologiques évoluent dans la même direction au même rythme. La valeur de `0` indique l'absence de corrélation entre les deux séries chronologiques. Par exemple, si le prix du pétrole augmente et que le cours de l'action d'une société pétrolière augmente, la tendance de la hausse du prix du pétrole et celle de la société pétrolière auront un coefficient de corrélation positif. Un coefficient de corrélation positif élevé indiquerait que les deux prix évoluent au même rythme. De même, le coefficient de corrélation entre les cours des obligations et les rendements obligataires est négatif, ce qui indique que ces deux valeurs évoluent dans le sens inverse au fil du temps.
Amazon Timestream prend en charge deux variantes de fonctions de corrélation. Cette section fournit des informations d'utilisation du Timestream pour les fonctions de LiveAnalytics corrélation, ainsi que des exemples de requêtes.
## Informations d'utilisation
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| `correlate_pearson(timeseries, timeseries)` | double | Calcule le [coefficient de corrélation de Pearson](https://wikipedia.org/wiki/Pearson_correlation_coefficient) pour les deux. `timeseries` Les séries temporelles doivent avoir les mêmes horodatages. |
| `correlate_spearman(timeseries, timeseries)` | double | Calcule le [coefficient de corrélation de Spearman](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient) pour les deux. `timeseries` Les séries temporelles doivent avoir les mêmes horodatages. |
## Exemples de requêtes
**Example**
```
WITH cte_1 AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(min(time), max(time), 10m)) AS result
FROM sample.DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv' AND time > ago(1h)
GROUP BY hostname, measure_name
),
cte_2 AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, measure_value::double),
SEQUENCE(min(time), max(time), 10m)) AS result
FROM sample.DevOps
WHERE measure_name = 'cpu_utilization'
AND hostname = 'host-Hovjv' AND time > ago(1h)
GROUP BY hostname, measure_name
)
SELECT correlate_pearson(cte_1.result, cte_2.result) AS result
FROM cte_1, cte_2
```
# Fonctions de filtrage et de réduction
Amazon Timestream prend en charge des fonctions permettant de filtrer et de réduire les opérations sur les données de séries chronologiques. Cette section fournit des informations d'utilisation du Timestream pour les fonctions de LiveAnalytics filtrage et de réduction, ainsi que des exemples de requêtes.
## Informations d'utilisation
| Fonction | Type de données de sortie | Description |
| --- | --- | --- |
| `filter(timeseries(T), function(T, Boolean))` | série chronologique (T) | Construit une série chronologique à partir d'une série chronologique en entrée, en utilisant les valeurs pour lesquelles le passé `function` renvoie`true`. |
| `reduce(timeseries(T), initialState S, inputFunction(S, T, S), outputFunction(S, R))` | R | Renvoie une valeur unique, réduite par rapport à la série chronologique. Le `inputFunction` sera invoqué sur chaque élément des séries temporelles dans l'ordre. En plus de prendre l'élément actuel, InputFunction prend l'état actuel (initialement`initialState`) et renvoie le nouvel état. Le `outputFunction` sera invoqué pour transformer l'état final en valeur de résultat. Il `outputFunction` peut s'agir d'une fonction d'identité. |
## Exemples de requêtes
**Example**
Construisez une série chronologique de l'utilisation du processeur par un hôte et des points de filtrage avec une mesure supérieure à 70 :
```
WITH time_series_view AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)),
SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
FROM sample.DevOps
WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
AND time > ago(30m)
GROUP BY hostname
)
SELECT FILTER(cpu_user, x -> x.value > 70.0) AS cpu_above_threshold
from time_series_view
```
**Example**
Construisez une série chronologique de l'utilisation du processeur d'un hôte et déterminez la somme au carré des mesures :
```
WITH time_series_view AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)),
SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
FROM sample.DevOps
WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
AND time > ago(30m)
GROUP BY hostname
)
SELECT REDUCE(cpu_user,
DOUBLE '0.0',
(s, x) -> x.value * x.value + s,
s -> s)
from time_series_view
```
**Example**
Construisez une série chronologique de l'utilisation du processeur d'un hôte et déterminez la fraction d'échantillons qui se situent au-dessus du seuil du processeur :
```
WITH time_series_view AS (
SELECT INTERPOLATE_LINEAR(
CREATE_TIME_SERIES(time, ROUND(measure_value::double,2)),
SEQUENCE(ago(15m), ago(1m), 10s)) AS cpu_user
FROM sample.DevOps
WHERE hostname = 'host-Hovjv' and measure_name = 'cpu_utilization'
AND time > ago(30m)
GROUP BY hostname
)
SELECT ROUND(
REDUCE(cpu_user,
-- initial state
CAST(ROW(0, 0) AS ROW(count_high BIGINT, count_total BIGINT)),
-- function to count the total points and points above a certain threshold
(s, x) -> CAST(ROW(s.count_high + IF(x.value > 70.0, 1, 0), s.count_total + 1) AS ROW(count_high BIGINT, count_total BIGINT)),
-- output function converting the counts to fraction above threshold
s -> IF(s.count_total = 0, NULL, CAST(s.count_high AS DOUBLE) / s.count_total)),
4) AS fraction_cpu_above_threshold
from time_series_view
```