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.
# Utilisation du chargement par lots dans Timestream pour LiveAnalytics
Grâce au *chargement par lots* pour Amazon Timestream LiveAnalytics for, vous pouvez ingérer des fichiers CSV stockés dans Amazon S3 dans Timestream par lots. Grâce à cette nouvelle fonctionnalité, vous pouvez accéder à vos données dans Timestream LiveAnalytics sans avoir à utiliser d'autres outils ou à écrire du code personnalisé. Vous pouvez utiliser le chargement par lots pour compléter les données avec des temps d'attente flexibles, telles que les données qui ne sont pas immédiatement requises pour les requêtes ou les analyses.
Vous pouvez créer des tâches de chargement par lots à AWS CLI l'aide AWS SDKs des AWS Management Console Pour plus d’informations, consultez [Utilisation du chargement par lots avec la console](batch-load-using-console.md), [En utilisant le chargement par lots avec le AWS CLI](batch-load-using-cli.md) et [En utilisant le chargement par lots avec AWS SDKs](batch-load-using-sdk.md).
Outre le chargement par lots, vous pouvez écrire plusieurs enregistrements en même temps grâce à l'opération WriteRecords API. Pour obtenir des conseils sur les produits à utiliser, voir[Choix entre le fonctionnement de WriteRecords l'API et le chargement par lots](writes.writes-or-batch-load.md).
**Topics**
+ [Concepts de chargement par lots dans Timestream](batch-load-concepts.md)
+ [Conditions préalables au chargement par lots](batch-load-prerequisites.md)
+ [Meilleures pratiques en matière de chargement par lots](batch-load-best-practices.md)
+ [Préparation d'un fichier de données de chargement par lots](batch-load-preparing-data-file.md)
+ [Mappages de modèles de données pour le chargement par lots](batch-load-data-model-mappings.md)
+ [Utilisation du chargement par lots avec la console](batch-load-using-console.md)
+ [En utilisant le chargement par lots avec le AWS CLI](batch-load-using-cli.md)
+ [En utilisant le chargement par lots avec AWS SDKs](batch-load-using-sdk.md)
+ [Utilisation des rapports d'erreurs de chargement par lots](batch-load-using-error-reports.md)
# Concepts de chargement par lots dans Timestream
Passez en revue les concepts suivants pour mieux comprendre la fonctionnalité de chargement par lots.
Tâche de **chargement par lots : tâche** qui définit vos données source et votre destination dans Amazon Timestream. Vous spécifiez une configuration supplémentaire, telle que le modèle de données, lorsque vous créez la tâche de chargement par lots. Vous pouvez créer des tâches de chargement par lots via le AWS Management Console AWS CLI, le et le AWS SDKs.
**Destination d'importation** : base de données et table de destination dans Timestream. Pour plus d'informations sur la création de bases de données et de tables, reportez-vous [Créer une base de données](console_timestream.md#console_timestream.db.using-console) aux sections et[Création d’une table](console_timestream.md#console_timestream.table.using-console).
**Source de données** : fichier CSV source stocké dans un compartiment S3. Pour plus d'informations sur la préparation du fichier de données, consultez[Préparation d'un fichier de données de chargement par lots](batch-load-preparing-data-file.md). Pour plus d'informations sur la tarification de S3, consultez la section [Tarification d'Amazon S3](https://aws.amazon.com/s3/pricing/).
**Rapport d'erreur de chargement par lots** : rapport qui stocke des informations sur les erreurs d'une tâche de chargement par lots. Vous définissez l'emplacement S3 pour les rapports d'erreur de chargement par lots dans le cadre d'une tâche de chargement par lots. Pour plus d'informations sur les informations contenues dans les rapports, consultez[Utilisation des rapports d'erreurs de chargement par lots](batch-load-using-error-reports.md).
**Mappage du modèle de données** : mappage du chargement par lots pour le temps, les dimensions et les mesures entre une source de données située dans un emplacement S3 et un flux temporel cible pour LiveAnalytics une table. Pour de plus amples informations, veuillez consulter [Mappages de modèles de données pour le chargement par lots](batch-load-data-model-mappings.md).
# Conditions préalables au chargement par lots
Voici une liste des conditions préalables à l'utilisation du chargement par lots. Pour connaître les bonnes pratiques, consultez [Meilleures pratiques en matière de chargement par lots](batch-load-best-practices.md).
+ Les données de la source de chargement par lots sont stockées dans Amazon S3 au format CSV avec des en-têtes.
+ Pour chaque compartiment source Amazon S3, vous devez disposer des autorisations suivantes dans une politique jointe :
```
"s3:GetObject",
"s3:GetBucketAcl"
"s3:ListBucket"
```
De même, pour chaque compartiment de sortie Amazon S3 dans lequel des rapports sont rédigés, vous devez disposer des autorisations suivantes dans une politique jointe :
```
"s3:PutObject",
"s3:GetBucketAcl"
```
Par exemple :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject",
"s3:GetBucketAcl",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket1\u201d",
"arn:aws:s3:::amzn-s3-demo-source-bucket2\u201d"
],
"Effect": "Allow"
},
{
"Action": [
"s3:PutObject",
"s3:GetBucketAcl"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket\u201d"
],
"Effect": "Allow"
}
]
}
```
------
+ Timestream pour LiveAnalytics analyser le CSV en mappant les informations fournies dans le modèle de données aux en-têtes CSV. Les données doivent comporter une colonne représentant l'horodatage, au moins une colonne de dimension et au moins une colonne de mesure.
+ Les compartiments S3 utilisés pour le chargement par lots doivent se trouver dans la même région et provenir du même compte que le flux temporel de la LiveAnalytics table utilisé pour le chargement par lots.
+ La `timestamp` colonne doit être un type de données long qui représente le temps écoulé depuis l'époque Unix. Par exemple, l'horodatage `2021-03-25T08:45:21Z` serait représenté par. `1616661921` Timestream prend en charge les secondes, les millisecondes, les microsecondes et les nanosecondes pour la précision de l'horodatage. Lorsque vous utilisez le langage de requête, vous pouvez convertir entre les formats à l'aide de fonctions telles que`to_unixtime`. Pour de plus amples informations, veuillez consulter [Fonctions de date/heure](date-time-functions.md).
+ Timestream prend en charge le type de données de chaîne pour les valeurs de dimension. Il prend en charge les types de données longs, doubles, chaînes et booléens pour les colonnes de mesure.
Pour les limites de charge par lots et les quotas, voir[Chargement par lots](ts-limits.md#limits.batch-load).
# Meilleures pratiques en matière de chargement par lots
Le chargement par lots fonctionne de manière optimale (débit élevé) lorsque les conditions et recommandations suivantes sont respectées :
1. Les fichiers CSV soumis pour ingestion sont de petite taille, en particulier avec une taille de fichier comprise entre 100 Mo et 1 Go, afin d'améliorer le parallélisme et la vitesse d'ingestion.
1. Évitez d'ingérer simultanément des données dans la même table (par exemple à l'aide de l'opération WriteRecords API ou d'une requête planifiée) lorsque le chargement par lots est en cours. Cela peut entraîner des ralentissements et la tâche de chargement par lots échouera.
1. N'ajoutez, ne modifiez ou ne supprimez pas de fichiers du compartiment S3 utilisé pour le chargement par lots pendant que la tâche de chargement par lots est en cours d'exécution.
1. Ne supprimez pas ou ne révoquez pas les autorisations relatives aux tables ou à la source, et ne signalez pas les compartiments S3 contenant des tâches de chargement par lots planifiées ou en cours.
1. Lorsque vous ingérez des données avec un ensemble de valeurs de dimension à cardinalité élevée, suivez les instructions sur. [Recommandations pour le partitionnement des enregistrements à mesures multiples](data-modeling.md#data-modeling-multi-measure-partitioning)
1. Assurez-vous de vérifier l'exactitude des données en soumettant un petit fichier. Toutes les données soumises au chargement par lots vous seront facturées, qu'elles soient correctes ou non. Pour plus d'informations sur les tarifs, consultez les tarifs [d'Amazon Timestream](https://aws.amazon.com/timestream/pricing/).
1. Ne reprenez pas une tâche de chargement par lots sauf si la `ActiveMagneticStorePartitions` valeur est inférieure à 250. La tâche peut être limitée et échouer. La soumission de plusieurs tâches en même temps pour la même base de données devrait en réduire le nombre.
Les meilleures pratiques relatives à la console sont les suivantes :
1. Utilisez le [générateur](batch-load-using-console.md#batch-load-using-visual-builder) uniquement pour simplifier la modélisation des données qui utilise un seul nom de mesure pour les enregistrements de plusieurs mesures.
1. Pour une modélisation de données plus complexe, utilisez JSON. Par exemple, utilisez JSON lorsque vous utilisez plusieurs noms de mesures lorsque vous utilisez des enregistrements de plusieurs mesures.
Pour un flux temporel supplémentaire consacré aux LiveAnalytics meilleures pratiques, voir. [Bonnes pratiques](best-practices.md)
# Préparation d'un fichier de données de chargement par lots
Un fichier de données source comporte des valeurs séparées par des délimiteurs. Le terme plus spécifique, valeurs séparées par des virgules (CSV), est utilisé de manière générique. Les séparateurs de colonnes valides incluent les virgules et les tubes. Les enregistrements sont séparés par de nouvelles lignes. Les fichiers doivent être stockés dans Amazon S3. Lorsque vous créez une nouvelle tâche de chargement par lots, l'emplacement des données source est spécifié par un ARN pour le fichier. Un fichier contient des en-têtes. Une colonne représente l'horodatage. Au moins une autre colonne représente une mesure.
Les compartiments S3 utilisés pour le chargement par lots doivent se trouver dans la même région que le flux temporel de la LiveAnalytics table utilisée pour le chargement par lots. N'ajoutez ni ne supprimez de fichiers du compartiment S3 utilisé pour le chargement par lots une fois que la tâche de chargement par lots a été soumise. Pour plus d'informations sur l'utilisation des compartiments S3, consultez [Getting started with Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html).
**Note**
Les fichiers CSV générés par certaines applications telles qu'Excel peuvent contenir une marque d'ordre des octets (BOM) en conflit avec le codage attendu. Le flux temporel des tâches de chargement LiveAnalytics par lots qui font référence à un fichier CSV avec une nomenclature génère une erreur lorsqu'elles sont traitées par programmation. Pour éviter cela, vous pouvez supprimer le BOM, qui est un caractère invisible.
Par exemple, vous pouvez enregistrer le fichier à partir d'une application telle que Notepad\$1\$1 qui vous permet de spécifier un nouveau codage. Vous pouvez également utiliser une option de programmation qui lit la première ligne, supprime le caractère de la ligne et écrit la nouvelle valeur sur la première ligne du fichier.
Lorsque vous enregistrez à partir d'Excel, plusieurs options CSV sont disponibles. L'enregistrement avec une autre option CSV peut éviter le problème décrit. Mais vous devriez vérifier le résultat car une modification du codage peut affecter certains caractères.
## Paramètres du format CSV
Vous utilisez des caractères d'échappement lorsque vous représentez une valeur qui est par ailleurs réservée par les paramètres de format. Par exemple, si le guillemet est un guillemet double, pour représenter un guillemet double dans les données, placez le caractère d'échappement avant le guillemet double.
Pour savoir quand les spécifier lors de la création d'une tâche de chargement par lots, consultez[Création d'une tâche de chargement par lots](batch-load-using-console.md#console_timestream.create-batch-load.using-console).
| Paramètre | Options |
| --- | --- |
| Séparateur de colonnes | (Virgule («, ») \$1 Pipe (« \$1 ») \$1 Point-virgule (« ; ») \$1 Tabulation (« /t ») \$1 Espace vide (« »)) |
| Personnage d'évasion | Aucune |
| Caractère de citation | Console : (Guillemet double («) \$1 Guillemet simple (')) |
| Valeur nulle | Espace vide (« ») |
| Supprimer les espaces blancs | Console : (Non \$1 Oui) |
# Mappages de modèles de données pour le chargement par lots
Ce qui suit décrit le schéma des mappages de modèles de données et donne un exemple.
## Schéma de mappage des modèles de données
Syntaxe de la `CreateBatchLoadTask` demande et `BatchLoadTaskDescription` objet renvoyé par un appel pour `DescribeBatchLoadTask` inclure un `DataModelConfiguration` objet incluant le `DataModel` chargement par lots. `DataModel`définit les mappages entre les données source stockées au format CSV dans un emplacement S3 et un flux temporel cible pour la LiveAnalytics base de données et la table.
Le `TimeColumn` champ indique l'emplacement des données source pour la valeur à mapper à la `time` colonne de la table de destination dans Timestream for. LiveAnalytics `TimeUnit`Spécifie l'unité pour le`TimeColumn`, et peut être l'une des valeurs `MILLISECONDS` suivantes :`SECONDS`,`MICROSECONDS`, ou`NANOSECONDS`. Il existe également des mappages pour les dimensions et les mesures. Les mappages de dimensions sont composés de colonnes source et de champs cibles.
Pour de plus amples informations, veuillez consulter [DimensionMapping](https://docs.aws.amazon.com/timestream/latest/developerguide/API_DimensionMapping). Les mappages pour les mesures comportent deux options, `MixedMeasureMappings` et`MultiMeasureMappings`.
En résumé, a `DataModel` contient des mappages entre une source de données située dans un emplacement S3 et un flux temporel cible pour la LiveAnalytics table suivante.
+ Heure
+ Dimensions
+ Mesures
Dans la mesure du possible, nous vous recommandons de mapper les données de mesure à des enregistrements de mesures multiples dans Timestream for. LiveAnalytics Pour plus d'informations sur les avantages des enregistrements à mesures multiples, consultez[Enregistrements à mesures multiples](writes.md#writes.writing-data-multi-measure).
Si plusieurs mesures des données source sont stockées sur une seule ligne, vous pouvez mapper ces mesures à des enregistrements de plusieurs mesures dans Timestream pour les utiliser. LiveAnalytics `MultiMeasureMappings` Si certaines valeurs doivent être mappées à un enregistrement à mesure unique, vous pouvez utiliser`MixedMeasureMappings`.
`MixedMeasureMappings`et `MultiMeasureMappings` les deux incluent`MultiMeasureAttributeMappings`. Les enregistrements à mesures multiples sont pris en charge, que des enregistrements à mesure unique soient nécessaires ou non.
Si seuls des enregistrements cibles à plusieurs mesures sont nécessaires dans Timestream for LiveAnalytics, vous pouvez définir des mappages de mesures dans la structure suivante.
```
CreateBatchLoadTask
MeasureNameColumn
MultiMeasureMappings
TargetMultiMeasureName
MultiMeasureAttributeMappings array
```
**Note**
Nous vous recommandons de l'utiliser dans la `MultiMeasureMappings` mesure du possible.
Si des enregistrements cibles à mesure unique sont nécessaires dans Timestream for LiveAnalytics, vous pouvez définir des mappages de mesures dans la structure suivante.
```
CreateBatchLoadTask
MeasureNameColumn
MixedMeasureMappings array
MixedMeasureMapping
MeasureName
MeasureValueType
SourceColumn
TargetMeasureName
MultiMeasureAttributeMappings array
```
Lorsque vous l'utilisez`MultiMeasureMappings`, le `MultiMeasureAttributeMappings` tableau est toujours requis. Lorsque vous utilisez le `MixedMeasureMappings` tableau, si `MeasureValueType` c'est `MULTI` pour une donnée`MixedMeasureMapping`, `MultiMeasureAttributeMappings` c'est requis pour cela`MixedMeasureMapping`. Dans le cas contraire, `MeasureValueType` indique le type de mesure pour l'enregistrement d'une seule mesure.
Quoi qu'il en soit, il existe une gamme de `MultiMeasureAttributeMapping` produits disponibles. Vous définissez les mappages vers les enregistrements à mesures multiples dans chacun d'eux `MultiMeasureAttributeMapping` comme suit :
`SourceColumn`
La colonne des données source qui se trouve dans Amazon S3.
`TargetMultiMeasureAttributeName`
Nom du nom multi-mesures cible dans la table de destination. Cette saisie est obligatoire lorsqu'elle n'`MeasureNameColumn`est pas fournie. Si elle `MeasureNameColumn` est fournie, la valeur de cette colonne est utilisée comme nom de plusieurs mesures.
`MeasureValueType`
L'un des `DOUBLE` `BIGINT``BOOLEAN`,`VARCHAR`, ou`TIMESTAMP`.
## Mappages de modèles de données avec exemple `MultiMeasureMappings`
Cet exemple illustre le mappage vers des enregistrements à mesures multiples, l'approche préférée, qui stocke chaque valeur de mesure dans une colonne dédiée. Vous pouvez télécharger un exemple de CSV sur [Sample CSV](samples/batch-load-sample-file.csv.zip). L'exemple contient les en-têtes suivants à mapper à une colonne cible dans un tableau Timestream for. LiveAnalytics
+ `time`
+ `measure_name`
+ `region`
+ `location`
+ `hostname`
+ `memory_utilization`
+ `cpu_utilization`
Identifiez les `measure_name` colonnes `time` et dans le fichier CSV. Dans ce cas, elles sont directement associées au Timestream pour les colonnes de LiveAnalytics table portant le même nom.
+ `time`cartes pour `time`
+ `measure_name`correspond à `measure_name` (ou à la valeur que vous avez choisie)
Lorsque vous utilisez l'API, vous spécifiez `time` dans le `TimeColumn` champ une valeur d'unité de temps prise en charge, par exemple `MILLISECONDS` dans le `TimeUnit` champ. Ils correspondent au **nom de la colonne Source** et à l'**heure d'horodatage saisis** dans la console. Vous pouvez regrouper ou partitionner des enregistrements à l'aide de `measure_name` ce qui est défini par la `MeasureNameColumn` clé.
Dans l'exemple, `region``location`, et `hostname` sont des dimensions. Les dimensions sont cartographiées dans un tableau d'`DimensionMapping`objets.
Pour les mesures, la valeur `TargetMultiMeasureAttributeName` deviendra une colonne dans le tableau Timestream for LiveAnalytics . Vous pouvez conserver le même nom, comme dans cet exemple. Vous pouvez également en spécifier un nouveau. `MeasureValueType`est l'un des `DOUBLE``BIGINT`,`BOOLEAN`,`VARCHAR`, ou`TIMESTAMP`.
```
{
"TimeColumn": "time",
"TimeUnit": "MILLISECONDS",
"DimensionMappings": [
{
"SourceColumn": "region",
"DestinationColumn": "region"
},
{
"SourceColumn": "location",
"DestinationColumn": "location"
},
{
"SourceColumn": "hostname",
"DestinationColumn": "hostname"
}
],
"MeasureNameColumn": "measure_name",
"MultiMeasureMappings": {
"MultiMeasureAttributeMappings": [
{
"SourceColumn": "memory_utilization",
"TargetMultiMeasureAttributeName": "memory_utilization",
"MeasureValueType": "DOUBLE"
},
{
"SourceColumn": "cpu_utilization",
"TargetMultiMeasureAttributeName": "cpu_utilization",
"MeasureValueType": "DOUBLE"
}
]
}
}
```
![\[Visual builder interface showing column mappings for timestream data attributes and types.\]](http://docs.aws.amazon.com/fr_fr/timestream/latest/developerguide/images/column-mapping.jpg)
## Mappages de modèles de données avec exemple `MixedMeasureMappings`
Nous vous recommandons de n'utiliser cette approche que lorsque vous devez mapper des enregistrements à mesure unique dans Timestream for. LiveAnalytics
# Utilisation du chargement par lots avec la console
Voici les étapes à suivre pour utiliser le chargement par lots avec le AWS Management Console. Vous pouvez télécharger un exemple de CSV sur [Sample CSV](samples/batch-load-sample-file.csv.zip).
**Topics**
+ [Accéder au chargement par lots](#console_timestream.access-batch-load.using-console)
+ [Création d'une tâche de chargement par lots](#console_timestream.create-batch-load.using-console)
+ [Reprendre une tâche de chargement par lots](#console_timestream.resume-batch-load.using-console)
+ [Utilisation du générateur visuel](#batch-load-using-visual-builder)
## Accéder au chargement par lots
Procédez comme suit pour accéder au chargement par lots à l'aide du AWS Management Console.
1. Ouvrez la console [Amazon Timestream](https://console.aws.amazon.com/timestream).
1. Dans le volet de navigation, choisissez **Outils de gestion**, puis **Tâches de chargement par lots**.
1. À partir de là, vous pouvez consulter la liste des tâches de chargement par lots et explorer une tâche donnée pour plus de détails. Vous pouvez également créer et reprendre des tâches.
## Création d'une tâche de chargement par lots
Procédez comme suit pour créer une tâche de chargement par lots à l'aide du AWS Management Console.
1. Ouvrez la console [Amazon Timestream](https://console.aws.amazon.com/timestream).
1. Dans le volet de navigation, choisissez **Outils de gestion**, puis **Tâches de chargement par lots**.
1. Choisissez **Créer une tâche de chargement par lots**.
1. Dans **Destination de l'importation**, choisissez ce qui suit.
+ **Base de données cible** : sélectionnez le nom de la base de données créée dans[Créer une base de données](console_timestream.md#console_timestream.db.using-console).
+ **Table cible** : sélectionnez le nom de la table créée dans[Création d’une table](console_timestream.md#console_timestream.table.using-console).
Si nécessaire, vous pouvez ajouter un tableau à partir de ce panneau à l'aide du bouton **Créer un nouveau tableau**.
1. Dans **Emplacement de la source de données S3** **dans Source** de données, sélectionnez le compartiment S3 dans lequel les données sources sont stockées. Utilisez le bouton **Parcourir S3** pour afficher les ressources S3 auxquelles le AWS compte actif a accès, ou entrez l'URL de localisation S3. La source de données doit se trouver dans la même région.
1. Dans **les paramètres de format de fichier** (section extensible), vous pouvez utiliser les paramètres par défaut pour analyser les données d'entrée. Vous pouvez également choisir **les paramètres avancés**. À partir de là, vous pouvez choisir **les paramètres du format CSV** et sélectionner les paramètres pour analyser les données d'entrée. Pour plus d'informations sur ces paramètres, consultez[Paramètres du format CSV](batch-load-preparing-data-file.md#batch-load-data-file-options).
1. Dans **Configurer le mappage du modèle de données**, configurez le modèle de données. Pour des conseils supplémentaires sur les modèles de données, voir [Mappages de modèles de données pour le chargement par lots](batch-load-data-model-mappings.md)
+ Dans **Cartographie du modèle de données**, choisissez **Mapping configuration input**, puis choisissez l'une des options suivantes.
+ **Générateur visuel** : pour cartographier les données visuellement, choisissez **TargetMultiMeasureName**ou **MeasureNameColumn**. Ensuite, à partir de **Visual Builder**, mappez les colonnes.
Visual Builder détecte et charge automatiquement les en-têtes des colonnes source à partir du fichier de source de données lorsqu'un seul fichier CSV est sélectionné comme source de données. Choisissez l'attribut et le type de données pour créer votre mappage.
Pour plus d'informations sur l'utilisation du générateur visuel, consultez[Utilisation du générateur visuel](#batch-load-using-visual-builder).
+ **Éditeur JSON : éditeur** JSON de forme libre permettant de configurer votre modèle de données. Choisissez cette option si vous connaissez Timestream pour LiveAnalytics et si vous souhaitez créer des mappages de modèles de données avancés.
+ **Fichier JSON depuis S3** — Sélectionnez un fichier de modèle JSON que vous avez stocké dans S3. Choisissez cette option si vous avez déjà configuré un modèle de données et souhaitez le réutiliser pour des chargements par lots supplémentaires.
1. Dans **Emplacement S3 des journaux** **d'erreurs dans le rapport du journal** des erreurs, sélectionnez l'emplacement S3 qui sera utilisé pour signaler les erreurs. Pour plus d'informations sur l'utilisation de ce rapport, consultez[Utilisation des rapports d'erreurs de chargement par lots](batch-load-using-error-reports.md).
1. Pour **le type de clé de chiffrement**, choisissez l'une des options suivantes.
+ **Clé gérée par Amazon S3 (SSE-S3) : clé** de chiffrement qu'Amazon S3 crée, gère et utilise pour vous.
+ **AWS KMS key (SSE-KMS)** — Une clé de chiffrement protégée par AWS Key Management Service ()AWS KMS.
1. Choisissez **Suivant**.
1. Sur la **page Réviser et créer**, passez en revue les paramètres et modifiez-les si nécessaire.
**Note**
Vous ne pouvez pas modifier les paramètres de la tâche de chargement par lots une fois la tâche créée. Le temps d'exécution des tâches varie en fonction de la quantité de données importées.
1. Choisissez **Créer une tâche de chargement par lots**.
## Reprendre une tâche de chargement par lots
Lorsque vous sélectionnez une tâche de chargement par lots dont le statut est « Progression arrêtée » et qui peut toujours être reprise, vous êtes invité à reprendre la tâche. Il existe également une bannière avec un bouton **Reprendre les tâches** lorsque vous consultez les détails de ces tâches. Les tâches pouvant être reprises ont une date limite de reprise. Une fois cette date expirée, les tâches ne peuvent pas être reprises.
## Utilisation du générateur visuel
Vous pouvez utiliser le générateur visuel pour mapper les colonnes de données source, un ou plusieurs fichiers CSV stockés dans un compartiment S3 aux colonnes de destination d'une table Timestream for LiveAnalytics .
**Note**
Votre rôle aura besoin de l'`SelectObjectContent`autorisation pour le fichier. Dans le cas contraire, vous devrez ajouter et supprimer des colonnes manuellement.
### Mode de chargement automatique des colonnes sources
Timestream for LiveAnalytics peut scanner automatiquement le fichier CSV source à la recherche de noms de colonnes si vous ne spécifiez qu'un seul compartiment. Lorsqu'aucun mappage n'existe, vous pouvez choisir **Importer les colonnes source**.
1. Lorsque l'option **Visual Builder** est sélectionnée dans les **paramètres d'entrée de configuration du mappage**, définissez la saisie de l'heure d'horodatage. `Milliseconds`est le paramètre par défaut.
1. Cliquez sur le bouton **Charger les colonnes source** pour importer les en-têtes de colonne présents dans le fichier de données source. Le tableau sera renseigné avec les noms des en-têtes des colonnes source provenant du fichier de source de données.
1. Choisissez le **nom de colonne de la table cible**, le **type d'attribut Timestream** et le **type de données** pour chaque colonne source.
Pour plus de détails sur ces colonnes et les valeurs possibles, consultez[Mappage des champs](#batch-load-using-visual-builder-mapping-fields).
1. Utilisez drag-to-fill cette fonctionnalité pour définir la valeur de plusieurs colonnes à la fois.
### Ajouter manuellement des colonnes source
Si vous utilisez un bucket ou un préfixe CSV et non un seul fichier CSV, vous pouvez ajouter et supprimer des mappages de colonnes dans l'éditeur visuel à l'aide des boutons **Ajouter un mappage de colonnes et Supprimer le mappage** **de colonnes**. Il existe également un bouton pour réinitialiser les mappages.
### Mappage des champs
+ **Nom de la colonne source** : nom d'une colonne du fichier source qui représente une mesure à importer. Timestream for LiveAnalytics peut renseigner cette valeur automatiquement lorsque vous utilisez l'option **Importer** des colonnes source.
+ **Nom de colonne de la table cible** : entrée facultative indiquant le nom de colonne de la mesure dans la table cible.
+ Type d'**attribut Timestream : type** d'attribut des données de la colonne source spécifiée, par exemple. `DIMENSION`
+ **TIMESTAMP** — Spécifie le moment où une mesure a été collectée.
+ **MULTI** — Plusieurs mesures sont représentées.
+ **DIMENSION** — Métadonnées des séries chronologiques.
+ **MEASURE\$1NAME** — Pour les enregistrements d'une seule mesure, il s'agit du nom de la mesure.
+ **Type de données** : type de colonne Timestream, par exemple. `BOOLEAN`
+ **BIGINT** — Entier de 64 bits.
+ **BOOLEAN** — Les deux valeurs de vérité de la logique : vrai et faux.
+ **DOUBLE** — Numéro à précision variable de 64 bits.
+ **TIMESTAMP** — Instance temporelle qui utilise une précision de nanoseconde en UTC et qui suit le temps écoulé depuis l'époque Unix.
# En utilisant le chargement par lots avec le AWS CLI
**Configuration**
Pour commencer à utiliser le chargement par lots, suivez les étapes suivantes.
1. Installez le AWS CLI en suivant les instructions fournies à l'adresse[Accès à Amazon Timestream LiveAnalytics pour utiliser AWS CLI](Tools.CLI.md).
1. Exécutez la commande suivante pour vérifier que les commandes de la CLI Timestream ont été mises à jour. Vérifiez que cela create-batch-load-task figure dans la liste.
`aws timestream-write help`
1. Préparez une source de données en suivant les instructions de[Préparation d'un fichier de données de chargement par lots](batch-load-preparing-data-file.md).
1. Créez une base de données et une table en suivant les instructions de[Accès à Amazon Timestream LiveAnalytics pour utiliser AWS CLI](Tools.CLI.md).
1. Créez un compartiment S3 pour la sortie du rapport. Le compartiment doit se trouver dans la même région. Pour plus d'informations sur les compartiments, consultez [Création, configuration et utilisation des compartiments Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html).
1. Créez une tâche de chargement par lots. Pour les étapes, consultez [Création d'une tâche de chargement par lots](#batch-load-using-cli-create-task).
1. Confirmez le statut de la tâche. Pour les étapes, consultez [Décrire la tâche de chargement par lots](#batch-load-using-cli-describe-task).
## Création d'une tâche de chargement par lots
Vous pouvez créer une tâche de chargement par lots à l'aide de la `create-batch-load-task` commande. Lorsque vous créez une tâche de chargement par lots à l'aide de la CLI, vous pouvez utiliser un paramètre JSON qui vous permet d'agréger les paramètres en un seul fragment JSON. `cli-input-json` Vous pouvez également séparer ces détails à l'aide de plusieurs autres paramètres`data-model-configuration`, notamment`data-source-configuration`,`report-configuration`,`target-database-name`, et`target-table-name`.
Pour obtenir un exemple, veuillez consulter [Exemple de création d'une tâche de chargement par lots](#batch-load-using-cli-example).
## Décrire la tâche de chargement par lots
Vous pouvez récupérer la description d'une tâche de chargement par lots comme suit.
```
aws timestream-write describe-batch-load-task --task-id
```
Voici un exemple de réponse.
```
{
"BatchLoadTaskDescription": {
"TaskId": "",
"DataSourceConfiguration": {
"DataSourceS3Configuration": {
"BucketName": "test-batch-load-west-2",
"ObjectKeyPrefix": "sample.csv"
},
"CsvConfiguration": {},
"DataFormat": "CSV"
},
"ProgressReport": {
"RecordsProcessed": 2,
"RecordsIngested": 0,
"FileParseFailures": 0,
"RecordIngestionFailures": 2,
"FileFailures": 0,
"BytesIngested": 119
},
"ReportConfiguration": {
"ReportS3Configuration": {
"BucketName": "test-batch-load-west-2",
"ObjectKeyPrefix": "",
"EncryptionOption": "SSE_S3"
}
},
"DataModelConfiguration": {
"DataModel": {
"TimeColumn": "timestamp",
"TimeUnit": "SECONDS",
"DimensionMappings": [
{
"SourceColumn": "vehicle",
"DestinationColumn": "vehicle"
},
{
"SourceColumn": "registration",
"DestinationColumn": "license"
}
],
"MultiMeasureMappings": {
"TargetMultiMeasureName": "test",
"MultiMeasureAttributeMappings": [
{
"SourceColumn": "wgt",
"TargetMultiMeasureAttributeName": "weight",
"MeasureValueType": "DOUBLE"
},
{
"SourceColumn": "spd",
"TargetMultiMeasureAttributeName": "speed",
"MeasureValueType": "DOUBLE"
},
{
"SourceColumn": "fuel",
"TargetMultiMeasureAttributeName": "fuel",
"MeasureValueType": "DOUBLE"
},
{
"SourceColumn": "miles",
"TargetMultiMeasureAttributeName": "miles",
"MeasureValueType": "DOUBLE"
}
]
}
}
},
"TargetDatabaseName": "BatchLoadExampleDatabase",
"TargetTableName": "BatchLoadExampleTable",
"TaskStatus": "FAILED",
"RecordVersion": 1,
"CreationTime": 1677167593.266,
"LastUpdatedTime": 1677167602.38
}
}
```
## Lister les tâches de chargement par lots
Vous pouvez répertorier les tâches de chargement par lots comme suit.
```
aws timestream-write list-batch-load-tasks
```
Une sortie apparaît comme suit.
```
{
"BatchLoadTasks": [
{
"TaskId": "",
"TaskStatus": "FAILED",
"DatabaseName": "BatchLoadExampleDatabase",
"TableName": "BatchLoadExampleTable",
"CreationTime": 1677167593.266,
"LastUpdatedTime": 1677167602.38
}
]
}
```
## Reprendre la tâche de chargement par lots
Vous pouvez reprendre une tâche de chargement par lots comme suit.
```
aws timestream-write resume-batch-load-task --task-id
```
Une réponse peut indiquer un succès ou contenir des informations d'erreur.
## Exemple de création d'une tâche de chargement par lots
**Example**
1. Créez un flux temporel pour la LiveAnalytics base de données nommée `BatchLoad` et une table nommée. `BatchLoadTest` Vérifiez et, si nécessaire, ajustez les valeurs pour `MemoryStoreRetentionPeriodInHours` et`MagneticStoreRetentionPeriodInDays`.
```
aws timestream-write create-database --database-name BatchLoad \
aws timestream-write create-table --database-name BatchLoad \
--table-name BatchLoadTest \
--retention-properties "{\"MemoryStoreRetentionPeriodInHours\": 12, \"MagneticStoreRetentionPeriodInDays\": 100}"
```
1. À l'aide de la console, créez un compartiment S3 et copiez le `sample.csv` fichier à cet emplacement. Vous pouvez télécharger un exemple de CSV sur [Sample CSV](samples/batch-load-sample-file.csv.zip).
1. À l'aide de la console, créez un compartiment S3 pour que Timestream LiveAnalytics rédige un rapport si la tâche de chargement par lots aboutit à des erreurs.
1. Créez une tâche de chargement par lots. Assurez-vous de remplacer *\$1INPUT\$1BUCKET* et par *\$1REPORT\$1BUCKET* les compartiments que vous avez créés au cours des étapes précédentes.
```
aws timestream-write create-batch-load-task \
--data-model-configuration "{\
\"DataModel\": {\
\"TimeColumn\": \"timestamp\",\
\"TimeUnit\": \"SECONDS\",\
\"DimensionMappings\": [\
{\
\"SourceColumn\": \"vehicle\"\
},\
{\
\"SourceColumn\": \"registration\",\
\"DestinationColumn\": \"license\"\
}\
],
\"MultiMeasureMappings\": {\
\"TargetMultiMeasureName\": \"mva_measure_name\",\
\"MultiMeasureAttributeMappings\": [\
{\
\"SourceColumn\": \"wgt\",\
\"TargetMultiMeasureAttributeName\": \"weight\",\
\"MeasureValueType\": \"DOUBLE\"\
},\
{\
\"SourceColumn\": \"spd\",\
\"TargetMultiMeasureAttributeName\": \"speed\",\
\"MeasureValueType\": \"DOUBLE\"\
},\
{\
\"SourceColumn\": \"fuel_consumption\",\
\"TargetMultiMeasureAttributeName\": \"fuel\",\
\"MeasureValueType\": \"DOUBLE\"\
},\
{\
\"SourceColumn\": \"miles\",\
\"MeasureValueType\": \"BIGINT\"\
}\
]\
}\
}\
}" \
--data-source-configuration "{
\"DataSourceS3Configuration\": {\
\"BucketName\": \"$INPUT_BUCKET\",\
\"ObjectKeyPrefix\": \"$INPUT_OBJECT_KEY_PREFIX\"
},\
\"DataFormat\": \"CSV\"\
}" \
--report-configuration "{\
\"ReportS3Configuration\": {\
\"BucketName\": \"$REPORT_BUCKET\",\
\"EncryptionOption\": \"SSE_S3\"\
}\
}" \
--target-database-name BatchLoad \
--target-table-name BatchLoadTest
```
La commande précédente renvoie le résultat suivant.
```
{
"TaskId": "TaskId "
}
```
1. Vérifiez l'avancement de la tâche. Assurez-vous de le *\$1TASK\$1ID* remplacer par l'identifiant de tâche renvoyé à l'étape précédente.
```
aws timestream-write describe-batch-load-task --task-id $TASK_ID
```
**Exemple de sortie**
```
{
"BatchLoadTaskDescription": {
"ProgressReport": {
"BytesIngested": 1024,
"RecordsIngested": 2,
"FileFailures": 0,
"RecordIngestionFailures": 0,
"RecordsProcessed": 2,
"FileParseFailures": 0
},
"DataModelConfiguration": {
"DataModel": {
"DimensionMappings": [
{
"SourceColumn": "vehicle",
"DestinationColumn": "vehicle"
},
{
"SourceColumn": "registration",
"DestinationColumn": "license"
}
],
"TimeUnit": "SECONDS",
"TimeColumn": "timestamp",
"MultiMeasureMappings": {
"MultiMeasureAttributeMappings": [
{
"TargetMultiMeasureAttributeName": "weight",
"SourceColumn": "wgt",
"MeasureValueType": "DOUBLE"
},
{
"TargetMultiMeasureAttributeName": "speed",
"SourceColumn": "spd",
"MeasureValueType": "DOUBLE"
},
{
"TargetMultiMeasureAttributeName": "fuel",
"SourceColumn": "fuel_consumption",
"MeasureValueType": "DOUBLE"
},
{
"TargetMultiMeasureAttributeName": "miles",
"SourceColumn": "miles",
"MeasureValueType": "DOUBLE"
}
],
"TargetMultiMeasureName": "mva_measure_name"
}
}
},
"TargetDatabaseName": "BatchLoad",
"CreationTime": 1672960381.735,
"TaskStatus": "SUCCEEDED",
"RecordVersion": 1,
"TaskId": "TaskId ",
"TargetTableName": "BatchLoadTest",
"ReportConfiguration": {
"ReportS3Configuration": {
"EncryptionOption": "SSE_S3",
"ObjectKeyPrefix": "ObjectKeyPrefix ",
"BucketName": "amzn-s3-demo-bucket"
}
},
"DataSourceConfiguration": {
"DataSourceS3Configuration": {
"ObjectKeyPrefix": "sample.csv",
"BucketName": "amzn-s3-demo-source-bucket"
},
"DataFormat": "CSV",
"CsvConfiguration": {}
},
"LastUpdatedTime": 1672960387.334
}
}
```
# En utilisant le chargement par lots avec AWS SDKs
Pour des exemples de création, de description et de liste de tâches de chargement par lots à l'aide des sections AWS SDKs[Créer une tâche de chargement par lots](code-samples.create-batch-load.md), voir[Décrire la tâche de chargement par lots](code-samples.describe-batch-load.md),[Lister les tâches de chargement par lots](code-samples.list-batch-load-tasks.md), et[Reprendre la tâche de chargement par lots](code-samples.resume-batch-load-task.md).
# Utilisation des rapports d'erreurs de chargement par lots
Les tâches de chargement par lots ont l'une des valeurs d'état suivantes :
+ `CREATED`(**Créé**) — La tâche est créée.
+ `IN_PROGRESS`(**En cours**) — La tâche est en cours.
+ `FAILED`(**Échec**) — La tâche est terminée. Mais une ou plusieurs erreurs ont été détectées.
+ `SUCCEEDED`(**Terminé**) — La tâche s'est terminée sans erreur.
+ `PROGRESS_STOPPED`(**Progression arrêtée**) — La tâche s'est arrêtée mais n'est pas terminée. Vous pouvez essayer de reprendre la tâche.
+ `PENDING_RESUME`(**En attente de reprise**) — La tâche est en attente de reprise.
En cas d'erreur, un rapport de journal des erreurs est créé dans le compartiment S3 défini à cet effet. Les erreurs sont classées en tant que TaskErrors ou FileErrors dans des tableaux distincts. Voici un exemple de rapport d'erreur.
```
{
"taskId": "9367BE28418C5EF902676482220B631C",
"taskErrors": [],
"fileErrors": [
{
"fileName": "example.csv",
"errors": [
{
"reason": "The record timestamp is outside the time range of the data ingestion window.",
"lineRanges": [
[
2,
3
]
]
}
]
}
]
}
```