Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Scrive

È possibile raccogliere dati di serie temporali da dispositivi connessi, sistemi IT e apparecchiature industriali e scriverli in Timestream for Live Analytics. Timestream for Live Analytics consente di scrivere punti dati da una singola serie temporale e/o punti dati da più serie in un'unica richiesta di scrittura quando le serie temporali appartengono alla stessa tabella. Per comodità, Timestream for Live Analytics offre uno schema flessibile che rileva automaticamente i nomi delle colonne e i tipi di dati per le tabelle Timestream for Live Analytics in base ai nomi delle dimensioni e ai tipi di dati dei valori di misura specificati quando richiami le scritture nel database. Puoi anche scrivere batch di dati in Timestream for Live Analytics.

È possibile scrivere dati utilizzando AWS SDKsAWS CLI, o tramiteAWS Lambda,AWS IoT Core,Servizio gestito da Amazon per Apache Flink, Amazon KinesisAmazon MSK, eTelegraf open source.

Tipi di dati

Timestream for Live Analytics supporta i seguenti tipi di dati per le scritture.

Nessuna definizione iniziale dello schema

Prima di inviare dati in Amazon Timestream for Live Analytics, devi creare un database e una tabella utilizzando AWS Management Console le operazioni Timestream for Live Analytics o Timestream for Live SDKs Analytics. API Per ulteriori informazioni, consulta Creazione di un database e Creare una tabella. Durante la creazione della tabella, non è necessario definire lo schema in anticipo. Amazon Timestream for Live Analytics rileva automaticamente lo schema in base alle misure e alle dimensioni dei punti dati inviati, quindi non è più necessario modificare lo schema offline per adattarlo ai dati delle serie temporali in rapida evoluzione.

Scrittura di dati (inserti e sconvolgimenti)

L'operazione di scrittura in Amazon Timestream for Live Analytics consente di inserire e modificare dati. Per impostazione predefinita, le scritture in Amazon Timestream for Live Analytics seguono la semantica del primo scrittore vince, in cui i dati vengono archiviati solo come aggiunta e i record duplicati vengono rifiutati. Sebbene il primo scrittore vinca la semantica soddisfi i requisiti di molte applicazioni di serie temporali, ci sono scenari in cui le applicazioni devono aggiornare i record esistenti in modo idempotente e/o scrivere dati con l'ultimo scrittore vince la semantica, in cui il record con la versione più alta viene archiviato nel servizio. Per affrontare questi scenari, Amazon Timestream for Live Analytics offre la possibilità di modificare i dati. Upsert è un'operazione che inserisce un record nel sistema quando il record non esiste o aggiorna il record quando ne esiste uno. Quando il record viene aggiornato, viene aggiornato in modo idempotente.

Non esiste un'operazione a livello di record per l'eliminazione. Ma le tabelle e i database possono essere eliminati.

Scrittura di dati nell'archivio di memoria e nell'archivio magnetico

Amazon Timestream for Live Analytics offre la possibilità di scrivere direttamente i dati nell'archivio di memoria e nell'archivio magnetico. L'archivio di memoria è ottimizzato per le scritture di dati ad alto throughput e l'archivio magnetico è ottimizzato per scritture con throughput inferiore di dati in arrivo tardivo.

I dati in arrivo tardivo sono dati con un timestamp precedente all'ora corrente e al di fuori del periodo di conservazione dell'archivio di memoria. È necessario abilitare esplicitamente la capacità di scrivere dati in arrivo tardivo nell'archivio magnetico abilitando le scritture nell'archivio magnetico per la tabella. Inoltre, MagneticStoreRejectedDataLocation viene definito quando viene creata una tabella. Per scrivere nell'archivio magnetico, i chiamanti WriteRecords devono disporre delle S3:PutObject autorizzazioni per il bucket S3 specificate durante la creazione della tabella. MagneticStoreRejectedDataLocation Per ulteriori informazioni, vedere CreateTable, e. WriteRecordsPutObject

Scrittura di dati con record a misura singola e record a più misure

Amazon Timestream for Live Analytics offre la possibilità di scrivere dati utilizzando due tipi di record, vale a dire record a singola misura e record multimisura.

Record a misura singola

I record a misura singola consentono di inviare una singola misura per record. Quando i dati vengono inviati a Timestream for Live Analytics utilizzando questo formato, Timestream for Live Analytics crea una riga di tabella per record. Ciò significa che se un dispositivo emette 4 metriche e ciascuna metrica viene inviata come record a misura singola, Timestream for Live Analytics creerà 4 righe nella tabella per memorizzare questi dati e gli attributi del dispositivo verranno ripetuti per ogni riga. Questo formato è consigliato nei casi in cui si desidera monitorare una singola metrica da un'applicazione o quando l'applicazione non emette più metriche contemporaneamente.

Record multimisura

Con i record con più misure, è possibile memorizzare più misure in una singola riga della tabella, anziché archiviare una misura per riga della tabella. I record multimisura consentono quindi di migrare i dati esistenti dai database relazionali ad Amazon Timestream for Live Analytics con modifiche minime.

Puoi anche raggruppare più dati in una singola richiesta di scrittura rispetto ai record a misura singola. Ciò aumenta la velocità di scrittura e le prestazioni dei dati e riduce anche il costo delle scritture dei dati. Questo perché raggruppare più dati in una richiesta di scrittura consente ad Amazon Timestream for Live Analytics di identificare più dati ripetibili in una singola richiesta di scrittura (ove applicabile) e di addebitare una sola volta per i dati ripetuti.

Record multimisura

Con i record multimisura, è possibile archiviare i dati delle serie temporali in un formato più compatto nella memoria e nell'archivio magnetico, il che aiuta a ridurre i costi di archiviazione dei dati. Inoltre, l'archiviazione compatta dei dati si presta alla scrittura di query più semplici per il recupero dei dati, migliora le prestazioni delle query e riduce il costo delle query.

Inoltre, i record multimisura supportano anche il tipo di TIMESTAMP dati per l'archiviazione di più di un timestamp in un record di serie temporali. TIMESTAMPgli attributi in un record multimisura supportano timestamp futuri o passati. I record multimisura aiutano quindi a migliorare le prestazioni, i costi e la semplicità delle query e offrono una maggiore flessibilità per l'archiviazione di diversi tipi di misure correlate.

Esempio: monitoraggio delle prestazioni e dello stato di un'applicazione di streaming video

Prendiamo in considerazione un'applicazione di streaming video in esecuzione su 200 EC2 istanze. Vuoi utilizzare Amazon Timestream for Live Analytics per archiviare e analizzare le metriche emesse dall'applicazione, in modo da poter comprendere le prestazioni e lo stato della tua applicazione, identificare rapidamente anomalie, risolvere problemi e scoprire opportunità di ottimizzazione.

Modelleremo questo scenario con record a singola misura e record a più misure, quindi confronteremo o contrapporremo entrambi gli approcci. Per ogni approccio, facciamo le seguenti ipotesi.

Utilizzo di record a misura singola

Modellazione dei dati: con i record a singola misura, creeremo un record per ciascuna delle quattro misure (tempo di avvio del video, rapporto di rebuffering, errori di riproduzione video e frame rate medio). Ogni record avrà le quattro dimensioni (device_id, device_type, os_version e region) e un timestamp.

Scrive: quando scrivi dati in Amazon Timestream for Live Analytics, i record vengono costruiti come segue.

public void writeRecords() {
    System.out.println("Writing records");
    // Specify repeated values for all records
    List<Record> records = new ArrayList<>();
    final long time = System.currentTimeMillis();
 
    List<Dimension> dimensions = new ArrayList<>();
    
    final Dimension device_id = new Dimension().withName("device_id").withValue("12345678");
    final Dimension device_type = new Dimension().withName("device_type").withValue("iPhone 11");
    final Dimension os_version = new Dimension().withName("os_version").withValue("14.8");
    final Dimension region = new Dimension().withName("region").withValue("us-east-1");
 
    dimensions.add(device_id);
    dimensions.add(device_type);
    dimensions.add(os_version);
    dimensions.add(region);
 
    Record videoStartupTime = new Record()
        .withDimensions(dimensions)
        .withMeasureName("video_startup_time")
        .withMeasureValue("200")
        .withMeasureValueType(MeasureValueType.BIGINT)
        .withTime(String.valueOf(time));
    Record rebufferingRatio = new Record()
        .withDimensions(dimensions)
        .withMeasureName("rebuffering_ratio")
        .withMeasureValue("0.5")
        .withMeasureValueType(MeasureValueType.DOUBLE)
        .withTime(String.valueOf(time));
    Record videoPlaybackFailures = new Record()
        .withDimensions(dimensions)
        .withMeasureName("video_playback_failures")
        .withMeasureValue("0")
        .withMeasureValueType(MeasureValueType.BIGINT)
        .withTime(String.valueOf(time));
    Record averageFrameRate = new Record()
        .withDimensions(dimensions)
        .withMeasureName("average_frame_rate")
        .withMeasureValue("0.5")
        .withMeasureValueType(MeasureValueType.DOUBLE)
        .withTime(String.valueOf(time));

    records.add(videoStartupTime);
    records.add(rebufferingRatio); 
    records.add(videoPlaybackFailures);
    records.add(averageFrameRate);
 
    WriteRecordsRequest writeRecordsRequest = new WriteRecordsRequest()
        .withDatabaseName(DATABASE_NAME)
        .withTableName(TABLE_NAME)
        .withRecords(records);
 
    try {
      WriteRecordsResult writeRecordsResult = amazonTimestreamWrite.writeRecords(writeRecordsRequest);
      System.out.println("WriteRecords Status: " + writeRecordsResult.getSdkHttpMetadata().getHttpStatusCode());
    } catch (RejectedRecordsException e) {
      System.out.println("RejectedRecords: " + e);
      for (RejectedRecord rejectedRecord : e.getRejectedRecords()) {
        System.out.println("Rejected Index " + rejectedRecord.getRecordIndex() + ": "
            + rejectedRecord.getReason());
      }
      System.out.println("Other records were written successfully. ");
    } catch (Exception e) {
      System.out.println("Error: " + e);
    }
  }

Quando memorizzi record a misura singola, i dati vengono rappresentati logicamente come segue.

Interrogazioni: puoi scrivere una query che recuperi tutti i punti dati con lo stesso timestamp ricevuti negli ultimi 15 minuti come segue.

with cte_video_startup_time as ( SELECT time, device_id, device_type, os_version, region, measure_value::bigint as video_startup_time FROM table where time >= ago(15m) and measure_name=”video_startup_time”),
cte_rebuffering_ratio as ( SELECT time, device_id, device_type, os_version, region, measure_value::double as rebuffering_ratio FROM table where time >= ago(15m) and measure_name=”rebuffering_ratio”),
cte_video_playback_failures as ( SELECT time, device_id, device_type, os_version, region, measure_value::bigint as video_playback_failures FROM table where time >= ago(15m) and measure_name=”video_playback_failures”),
cte_average_frame_rate as ( SELECT time, device_id, device_type, os_version, region, measure_value::double as average_frame_rate FROM table where time >= ago(15m) and measure_name=”average_frame_rate”)
SELECT a.time, a.device_id, a.os_version, a.region, a.video_startup_time, b.rebuffering_ratio, c.video_playback_failures, d.average_frame_rate FROM cte_video_startup_time a, cte_buffering_ratio b, cte_video_playback_failures c, cte_average_frame_rate d WHERE
a.time = b.time AND a.device_id = b.device_id AND a.os_version = b.os_version AND a.region=b.region AND
a.time = c.time AND a.device_id = c.device_id AND a.os_version = c.os_version AND a.region=c.region AND
a.time = d.time AND a.device_id = d.device_id AND a.os_version = d.os_version AND a.region=d.region

Costo del carico di lavoro: il costo di questo carico di lavoro è stimato in 373,23 dollari al mese con record a misura singola

Utilizzo di record a più misure

Modellazione dei dati: con i record multimisura, creeremo un record che contiene tutte e quattro le misure (tempo di avvio del video, rapporto di rebuffering, errori di riproduzione video e frame rate medio), tutte e quattro le dimensioni (device_id, device_type, os_version e region) e un timestamp.

Scrive: quando scrivi dati in Amazon Timestream for Live Analytics, i record vengono costruiti come segue.

public void writeRecords() {
    System.out.println("Writing records");
    // Specify repeated values for all records
    List<Record> records = new ArrayList<>();
    final long time = System.currentTimeMillis();
 
    List<Dimension> dimensions = new ArrayList<>();
    
    final Dimension device_id = new Dimension().withName("device_id").withValue("12345678");
    final Dimension device_type = new Dimension().withName("device_type").withValue("iPhone 11");
    final Dimension os_version = new Dimension().withName("os_version").withValue("14.8");
    final Dimension region = new Dimension().withName("region").withValue("us-east-1");
 
    dimensions.add(device_id);
    dimensions.add(device_type);
    dimensions.add(os_version);
    dimensions.add(region);
 
    Record videoMetrics = new Record()
        .withDimensions(dimensions)
        .withMeasureName("video_metrics")
        .withTime(String.valueOf(time));
        .withMeasureValueType(MeasureValueType.MULTI)
        .withMeasureValues(
          new MeasureValue()
        	.withName("video_startup_time")
        	.withValue("0")
        	.withValueType(MeasureValueType.BIGINT),
        	new MeasureValue()
		.withName("rebuffering_ratio")
        	.withValue("0.5")
        	.withType(MeasureValueType.DOUBLE),
          new MeasureValue()
        	.withName("video_playback_failures")
        	.withValue("0")
        	.withValueType(MeasureValueType.BIGINT),
		 new MeasureValue()
         	.withName("average_frame_rate")
        	.withValue("0.5")
        	.withValueType(MeasureValueType.DOUBLE))
 
    records.add(videoMetrics);
 
    WriteRecordsRequest writeRecordsRequest = new WriteRecordsRequest()
        .withDatabaseName(DATABASE_NAME)
        .withTableName(TABLE_NAME)
        .withRecords(records);
 
    try {
      WriteRecordsResult writeRecordsResult = amazonTimestreamWrite.writeRecords(writeRecordsRequest);
      System.out.println("WriteRecords Status: " + writeRecordsResult.getSdkHttpMetadata().getHttpStatusCode());
    } catch (RejectedRecordsException e) {
      System.out.println("RejectedRecords: " + e);
      for (RejectedRecord rejectedRecord : e.getRejectedRecords()) {
        System.out.println("Rejected Index " + rejectedRecord.getRecordIndex() + ": "
            + rejectedRecord.getReason());
      }
      System.out.println("Other records were written successfully. ");
    } catch (Exception e) {
      System.out.println("Error: " + e);
    }
  }

Quando memorizzi record multimisura, i dati vengono rappresentati logicamente come segue.

Interrogazioni: puoi scrivere una query che recuperi tutti i punti dati con lo stesso timestamp ricevuti negli ultimi 15 minuti come segue.

SELECT time, device_id, device_type, os_version, region, video_startup_time, rebuffering_ratio, video_playback_failures, average_frame_rate FROM table where time >= ago(15m)

Costo del carico di lavoro: il costo del carico di lavoro è stimato in 127,43 dollari con record multimisura.

Scrittura di dati con un timestamp esistente nel passato o nel futuro

Timestream for Live Analytics offre la possibilità di scrivere dati con un timestamp che si trova al di fuori della finestra di conservazione dell'archivio di memoria attraverso un paio di meccanismi diversi.

Eventuale coerenza per le letture

Timestream for Live Analytics supporta l'eventuale semantica di coerenza per le letture. Ciò significa che quando si interrogano i dati immediatamente dopo aver scritto un batch di dati in Timestream for Live Analytics, i risultati della query potrebbero non riflettere i risultati di un'operazione di scrittura completata di recente. Se ripeti queste richieste di query dopo poco tempo, i risultati dovrebbero restituire i dati più recenti.