Write time series data using the Go SDK - Tablestore: Central de Documentação do Alibaba Cloud

Após criar uma tabela de séries temporais, chame a operação PutTimeseriesData para gravar várias linhas de dados na tabela simultaneamente.

Pré-requisitos

Tabela de séries temporais criada. Para mais informações, consulte Criar uma tabela de séries temporais.
Instância do TimeseriesClient inicializada. Para mais informações, consulte Inicializar uma instância do OTSClient.

Parâmetros

Cada linha de dados de séries temporais (timeseriesRow) consiste em um identificador de série temporal (timeseriesKey) e nos próprios dados. Estes contêm o timestamp (timeInUs) e um ou mais valores de campo (fields).

O timeseriesKey identifica o tipo de métrica (como CPU ou NETWORK), o host de origem dos dados e os rótulos de chave-valor. O fields armazena os valores medidos de cada ponto de dados.

Parâmetro	Obrigatório	Descrição
timeseriesKey	Sim	Identificador da série temporal. Inclui as seguintes informações: `measurementName`: nome da medição da série temporal. `dataSource`: source dos dados. Pode estar vazio. `tags`: tags da série temporal, expressas como pares de chave-valor de strings.
timeInUs	Sim	Timestamp do ponto de dados, em microssegundos.
fields	Sim	Pontos de dados, representados por um ou mais pares `FieldKey`–`FieldValue`.

Exemplo

O exemplo a seguir grava duas linhas de dados de séries temporais em uma tabela: uma para métricas de CPU e outra para métricas de rede, usando PutTimeseriesData.

O timeseriesKey define a identidade que agrupa pontos de dados relacionados. O timeseriesRow associa o timestamp e os valores de campo a essa identidade.

func PutTimeseriesDataSample(client *tablestore.TimeseriesClient , timeseriesTableName string) {
    fmt.Println("[Info]: Begin to PutTimeseriesDataSample !")

    // Construct the time series row timeseriesRow.
    // timeseriesKey identifies the time series — measurement name, source host, and tags.
    timeseriesKey := tablestore.NewTimeseriesKey()
    timeseriesKey.SetMeasurementName("CPU")
    timeseriesKey.SetDataSource("127.0.0.1")
    timeseriesKey.AddTag("City" , "Hangzhou")
    timeseriesKey.AddTag("Region" , "Xihu")

    // timeseriesRow attaches the timestamp and field values to the key.
    timeseriesRow := tablestore.NewTimeseriesRow(timeseriesKey)
    timeseriesRow.SetTimeInus(time.Now().UnixNano() / 1000)
    timeseriesRow.AddField("temperature" , tablestore.NewColumnValue(tablestore.ColumnType_INTEGER , 98))
    timeseriesRow.AddField("status" , tablestore.NewColumnValue(tablestore.ColumnType_STRING , "ok"))

    // Construct the time series row timeseriesRow1.
    timeseriesKey1 := tablestore.NewTimeseriesKey()
    timeseriesKey1.SetMeasurementName("NETWORK")
    timeseriesKey1.SetDataSource("127.0.0.1")
    timeseriesKey1.AddTag("City" , "Hangzhou")
    timeseriesKey1.AddTag("Region" , "Xihu")

    timeseriesRow1 := tablestore.NewTimeseriesRow(timeseriesKey1)
    timeseriesRow1.SetTimeInus(time.Now().UnixNano() / 1000)
    timeseriesRow1.AddField("in" , tablestore.NewColumnValue(tablestore.ColumnType_INTEGER , 1000))
    timeseriesRow1.AddField("data" , tablestore.NewColumnValue(tablestore.ColumnType_BINARY , []byte("tablestore")))
    timeseriesRow1.AddField("program" , tablestore.NewColumnValue(tablestore.ColumnType_STRING , "tablestore.d"))
    timeseriesRow1.AddField("status" , tablestore.NewColumnValue(tablestore.ColumnType_BOOLEAN, true))
    timeseriesRow1.AddField("lossrate" , tablestore.NewColumnValue(tablestore.ColumnType_DOUBLE , float64(1.9098)))

    // Construct a request to write time series data.
    putTimeseriesDataRequest := tablestore.NewPutTimeseriesDataRequest(timeseriesTableName)
    putTimeseriesDataRequest.AddTimeseriesRows(timeseriesRow , timeseriesRow1)

    // Call the time series client to write the time series data.
    putTimeseriesDataResponse , err := client.PutTimeseriesData(putTimeseriesDataRequest)
    if err != nil {
        fmt.Println("[Error]: Failed to put time series data. Error: " , err)
        return
    }

    // A batch write may partially succeed. Failed rows are returned with their index and
    // error message, while successfully written rows are committed immediately.
    if len(putTimeseriesDataResponse.GetFailedRowResults()) > 0 {
        fmt.Println("[Warning]: Put time series data finished. Some rows failed to be written: ")
        for i := 0; i < len(putTimeseriesDataResponse.GetFailedRowResults()); i++ {
            FailedRow := putTimeseriesDataResponse.GetFailedRowResults()[i]
            fmt.Println("[Warning]: Failed Row: Index: " , FailedRow.Index , " Error: " , FailedRow.Error)
        }
    } else {
        fmt.Println("[Info]: PutTimeseriesDataSample finished. RequestId: " , putTimeseriesDataResponse.RequestId)
    }
}

Perguntas frequentes

Referências

Para obter mais detalhes sobre a operação de API, consulte PutTimeseriesData.
Após gravar os dados, consulte-os na tabela de séries temporais. Para mais informações, veja Consultar dados de séries temporais.
Para recuperar séries temporais que atendam a condições específicas, acesse Recuperar séries temporais.
Para atualizar ou excluir metadados de séries temporais, consulte Atualizar uma série temporal e Excluir uma série temporal.

Para migrar dados de uma origem Kafka para uma tabela de séries temporais do Tablestore, use o Tablestore Sink Connector. Para mais informações, consulte Sincronizar dados do Kafka para uma tabela de séries temporais.