

Para recursos semelhantes aos do Amazon Timestream para, considere o Amazon Timestream LiveAnalytics para InfluxDB. Ele oferece ingestão de dados simplificada e tempos de resposta de consulta de um dígito em milissegundos para análises em tempo real. Saiba mais [aqui](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando o carregamento em lote com o AWS CLI
<a name="batch-load-using-cli"></a>

**Configuração**

Para começar a usar o carregamento em lote, siga estas etapas.

1. Instale o AWS CLI usando as instruções em[Acessando o Amazon LiveAnalytics Timestream para usar o AWS CLI](Tools.CLI.md).

1. Execute o comando a seguir para verificar se os comandos CLI do Timestream foram atualizados. Verifique se create-batch-load-task está na lista.

   `aws timestream-write help`

1. Prepare uma fonte de dados usando as instruções em [Preparando um arquivo de dados de carregamento em lote](batch-load-preparing-data-file.md).

1. Para criar banco de dados e tabela usando as instruções em [Acessando o Amazon LiveAnalytics Timestream para usar o AWS CLI](Tools.CLI.md).

1. Criar um bucket do S3 para a saída do relatório. O bucket deve estar na mesma Região. Para ter informações sobre os buckets, consulte [Criar, configurar e trabalhar com buckets do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html).

1. Crie uma tarefa de carregamento em lote. Para obter as etapas, consulte [Criar uma tarefa de carregamento em lote](#batch-load-using-cli-create-task).

1. Confirmar o status da tarefa. Para obter as etapas, consulte [Descrever a tarefa de carregamento em lote](#batch-load-using-cli-describe-task).

## Criar uma tarefa de carregamento em lote
<a name="batch-load-using-cli-create-task"></a>

Você pode criar uma tarefa de carregamento em lote com o comando `create-batch-load-task`. Ao criar uma tarefa de carregamento em lote usando a CLI, você pode usar um parâmetro JSON, `cli-input-json`, que permite agregar os parâmetros em um único fragmento JSON. Você também pode separar esses detalhes usando vários outros parâmetros, inclusive `data-model-configuration`, `data-source-configuration`, `report-configuration`, `target-database-name` e `target-table-name`.

Para obter um exemplo, consulte [Criar exemplo de tarefa de carregamento em lote](#batch-load-using-cli-example)

## Descrever a tarefa de carregamento em lote
<a name="batch-load-using-cli-describe-task"></a>

Você pode recuperar uma descrição da tarefa de carregamento em lote da seguinte forma.

```
aws timestream-write describe-batch-load-task --task-id <value>
```

Veja a seguir uma resposta de exemplo.

```
{
    "BatchLoadTaskDescription": {
        "TaskId": "<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": "<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
    }
}
```

## Listar tarefas de carregamento em lote
<a name="batch-load-using-cli-list-tasks"></a>

Você pode listar as tarefas de carregamento em lote da seguinte forma.

```
aws timestream-write list-batch-load-tasks
```

Uma saída é exibida da seguinte forma.

```
{
    "BatchLoadTasks": [
        {
            "TaskId": "<TaskId>",
            "TaskStatus": "FAILED",
            "DatabaseName": "BatchLoadExampleDatabase",
            "TableName": "BatchLoadExampleTable",
            "CreationTime": 1677167593.266,
            "LastUpdatedTime": 1677167602.38
        }
    ]
}
```

## Retomar a tarefa de carregamento em lote
<a name="batch-load-using-cli-resume-task"></a>

Você pode retomar uma tarefa de carregamento em lote da seguinte forma.

```
aws timestream-write resume-batch-load-task --task-id <value>
```

Uma resposta pode indicar sucesso ou conter informações de erro.

## Criar exemplo de tarefa de carregamento em lote
<a name="batch-load-using-cli-example"></a>

**Example**  

1. Crie um Timestream para o LiveAnalytics banco de dados nomeado `BatchLoad` e uma tabela chamada. `BatchLoadTest` Verifique e, se necessário, ajuste os valores para `MemoryStoreRetentionPeriodInHours` e `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. Usando o console, crie um bucket S3 e copie o arquivo `sample.csv` para esse local. Você pode baixar um exemplo de CSV em [Amostra CSV](samples/batch-load-sample-file.csv.zip).

1. Usando o console, crie um bucket S3 para o Timestream LiveAnalytics para escrever um relatório se a tarefa de carregamento em lote for concluída com erros.

1. Crie uma tarefa de carregamento em lote. Certifique-se de substituir *\$1INPUT\$1BUCKET* e *\$1REPORT\$1BUCKET* com os buckets que você criou nas etapas anteriores.

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

   O comando anterior retorna a seguinte saída.

   ```
   {
       "TaskId": "TaskId "
   }
   ```

1. Verifique o progresso da tarefa. Certifique-se de *\$1TASK\$1ID* substituir pela ID da tarefa que foi retornada na etapa anterior.

   ```
   aws timestream-write describe-batch-load-task --task-id $TASK_ID 
   ```
**Exemplo de saída de**  

```
{
    "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
    }
}
```