Per funzionalità simili a Amazon Timestream for, prendi in considerazione Amazon Timestream LiveAnalytics per InfluxDB. Offre un'acquisizione semplificata dei dati e tempi di risposta alle query di una sola cifra di millisecondi per analisi in tempo reale. [Scopri](https://docs.aws.amazon.com//timestream/latest/developerguide/timestream-for-influxdb.html) di più qui.

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à.

# Ultimo punto di ogni dispositivo
<a name="scheduledqueries-patterns-lastpointfromdevice"></a>

L'applicazione potrebbe richiedere la lettura dell'ultima misurazione emessa da un dispositivo. Esistono casi d'uso più generali per ottenere l'ultima misurazione di un dispositivo prima di una determinata date/time o la prima misurazione di un dispositivo dopo una determinata data/ora. Quando si dispone di milioni di dispositivi e anni di dati, questa ricerca potrebbe richiedere la scansione di grandi quantità di dati.

Di seguito è riportato un esempio di come è possibile utilizzare le interrogazioni pianificate per ottimizzare la ricerca dell'ultimo punto emesso da un dispositivo. È possibile utilizzare lo stesso schema per ottimizzare anche la prima query, se l'applicazione ne ha bisogno.

**Topics**
+ [Calcolato dalla tabella di origine](#scheduledqueries-patterns-lastpointfromdevice-computedfromsrctable)
+ [Tabella derivata da precalcolare con granularità giornaliera](#scheduledqueries-patterns-lastpointfromdevice-derivedttabletoprecompute)
+ [Calcolato dalla tabella derivata](#scheduledqueries-patterns-lastpointfromdevice-computedfromderivedtable)
+ [Combinazione da tabella sorgente e derivata](#scheduledqueries-patterns-lastpointfromdevice-combinesourceandderived)

## Calcolato dalla tabella di origine
<a name="scheduledqueries-patterns-lastpointfromdevice-computedfromsrctable"></a>

Di seguito è riportata una query di esempio per trovare l'ultima misurazione emessa dai servizi in una distribuzione specifica (ad esempio, server per un determinato microservizio all'interno di una determinata regione, cella, silo e availability\$1zone). Nell'applicazione di esempio, questa query restituirà l'ultima misurazione per centinaia di server. Si noti inoltre che questa query ha un predicato temporale illimitato e cerca tutti i dati più vecchi di un determinato timestamp.

**Nota**  
Per informazioni sulle funzioni and, vedere. `max` `max_by` [Funzioni di aggregazione](aggregate-functions.md)

```
SELECT instance_name, MAX(time) AS time, MAX_BY(gc_pause, time) AS last_measure
FROM "raw_data"."devops"
WHERE time < from_milliseconds(1636685271872)
    AND measure_name = 'events'
    AND region = 'us-east-1'
    AND cell = 'us-east-1-cell-10'
    AND silo = 'us-east-1-cell-10-silo-3'
    AND availability_zone = 'us-east-1-1'
    AND microservice_name = 'hercules'
GROUP BY region, cell, silo, availability_zone, microservice_name,
    instance_name, process_name, jdk_version
ORDER BY instance_name, time DESC
```

## Tabella derivata da precalcolare con granularità giornaliera
<a name="scheduledqueries-patterns-lastpointfromdevice-derivedttabletoprecompute"></a>

È possibile convertire il caso d'uso precedente in un calcolo pianificato. Se i requisiti dell'applicazione sono tali da richiedere l'ottenimento di questi valori per l'intero parco macchine in più aree, celle, silos, zone di disponibilità e microservizi, è possibile utilizzare un unico calcolo di pianificazione per precalcolare i valori per l'intero parco macchine. Questa è la potenza delle query pianificate senza server di Timestream for LiveAnalytics, che consente a queste query di adattarsi ai requisiti di scalabilità dell'applicazione.

Di seguito è riportata una query per precalcolare l'ultimo punto su tutti i server per un determinato giorno. Nota che la query ha solo un predicato temporale e non un predicato sulle dimensioni. Il predicato temporale limita la query al giorno trascorso dal momento in cui il calcolo viene attivato in base all'espressione di pianificazione specificata.

```
SELECT region, cell, silo, availability_zone, microservice_name, 
    instance_name, process_name, jdk_version, 
    MAX(time) AS time, MAX_BY(gc_pause, time) AS last_measure 
FROM raw_data.devops 
WHERE time BETWEEN bin(@scheduled_runtime, 1d) - 1d AND bin(@scheduled_runtime, 1d) 
    AND measure_name = 'events' 
GROUP BY region, cell, silo, availability_zone, microservice_name, 
    instance_name, process_name, jdk_version
```

Di seguito è riportata una configurazione per il calcolo pianificato utilizzando la query precedente, che esegue tale query alle 01:00 UTC ogni giorno per calcolare l'aggregato del giorno precedente. L'espressione di pianificazione cron (0) \$1 \$1? \$1) controlla questo comportamento e viene eseguito un'ora dopo la fine della giornata, tenendo conto dei dati che arrivano fino a un giorno di ritardo.

```
{
    "Name": "PT1DPerInstanceLastpoint",
    "QueryString": "SELECT region, cell, silo, availability_zone, microservice_name, instance_name, process_name, jdk_version, MAX(time) AS time, MAX_BY(gc_pause, time) AS last_measure FROM raw_data.devops WHERE time BETWEEN bin(@scheduled_runtime, 1d) - 1d AND bin(@scheduled_runtime, 1d) AND measure_name = 'events' GROUP BY region, cell, silo, availability_zone, microservice_name, instance_name, process_name, jdk_version",
    "ScheduleConfiguration": {
        "ScheduleExpression": "cron(0 1 * * ? *)"
    },
    "NotificationConfiguration": {
        "SnsConfiguration": {
            "TopicArn": "******"
        }
    },
    "TargetConfiguration": {
        "TimestreamConfiguration": {
            "DatabaseName": "derived",
            "TableName": "per_timeseries_lastpoint_pt1d",
            "TimeColumn": "time",
            "DimensionMappings": [
                {
                    "Name": "region",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "cell",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "silo",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "availability_zone",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "microservice_name",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "instance_name",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "process_name",
                    "DimensionValueType": "VARCHAR"
                },
                {
                    "Name": "jdk_version",
                    "DimensionValueType": "VARCHAR"
                }
            ],
            "MultiMeasureMappings": {
                "TargetMultiMeasureName": "last_measure",
                "MultiMeasureAttributeMappings": [
                    {
                        "SourceColumn": "last_measure",
                        "MeasureValueType": "DOUBLE"
                    }
                ]
            }
        }
    },
    "ErrorReportConfiguration": {
        "S3Configuration" : {
            "BucketName" : "******",
            "ObjectKeyPrefix": "errors",
            "EncryptionOption": "SSE_S3"
        }
    },
    "ScheduledQueryExecutionRoleArn": "******"
}
```

## Calcolato dalla tabella derivata
<a name="scheduledqueries-patterns-lastpointfromdevice-computedfromderivedtable"></a>

Una volta definita la tabella derivata utilizzando la configurazione precedente e dopo che almeno un'istanza della query pianificata ha materializzato i dati nella tabella derivata, è ora possibile interrogare la tabella derivata per ottenere la misurazione più recente. Di seguito è riportato un esempio di query sulla tabella derivata.

```
SELECT instance_name, MAX(time) AS time, MAX_BY(last_measure, time) AS last_measure
FROM "derived"."per_timeseries_lastpoint_pt1d"
WHERE time < from_milliseconds(1636746715649)
    AND measure_name = 'last_measure'
    AND region = 'us-east-1'
    AND cell = 'us-east-1-cell-10'
    AND silo = 'us-east-1-cell-10-silo-3'
    AND availability_zone = 'us-east-1-1'
    AND microservice_name = 'hercules'
GROUP BY region, cell, silo, availability_zone, microservice_name,
    instance_name, process_name, jdk_version
ORDER BY instance_name, time DESC
```

## Combinazione da tabella sorgente e derivata
<a name="scheduledqueries-patterns-lastpointfromdevice-combinesourceandderived"></a>

Analogamente all'esempio precedente, tutti i dati della tabella derivata non avranno le scritture più recenti. Pertanto, è possibile utilizzare nuovamente uno schema simile a quello precedente per unire i dati della tabella derivata con i dati precedenti e utilizzare i dati di origine per il suggerimento rimanente. Di seguito è riportato un esempio di tale interrogazione che utilizza l'approccio UNION simile. Poiché il requisito dell'applicazione è quello di trovare la misurazione più recente prima di un periodo di tempo e l'ora di inizio può essere passata, il modo in cui si scrive questa query consiste nell'utilizzare l'ora fornita, utilizzare i dati di origine per un massimo di un giorno a partire dall'ora specificata e quindi utilizzare la tabella derivata sui dati più vecchi. Come si può vedere dall'esempio di query riportato di seguito, il predicato temporale sui dati di origine è limitato. Ciò garantisce un'elaborazione efficiente sulla tabella di origine, che contiene un volume di dati significativamente maggiore, e quindi il predicato temporale illimitato si trova sulla tabella derivata.

```
WITH last_point_derived AS (
    SELECT instance_name, MAX(time) AS time, MAX_BY(last_measure, time) AS last_measure
    FROM "derived"."per_timeseries_lastpoint_pt1d"
    WHERE time < from_milliseconds(1636746715649)
        AND measure_name = 'last_measure'
        AND region = 'us-east-1'
        AND cell = 'us-east-1-cell-10'
        AND silo = 'us-east-1-cell-10-silo-3'
        AND availability_zone = 'us-east-1-1'
        AND microservice_name = 'hercules'
    GROUP BY region, cell, silo, availability_zone, microservice_name,
        instance_name, process_name, jdk_version
), last_point_source AS (
    SELECT instance_name, MAX(time) AS time, MAX_BY(gc_pause, time) AS last_measure
    FROM "raw_data"."devops"
    WHERE time < from_milliseconds(1636746715649) AND time > from_milliseconds(1636746715649) - 26h
        AND measure_name = 'events'
        AND region = 'us-east-1'
        AND cell = 'us-east-1-cell-10'
        AND silo = 'us-east-1-cell-10-silo-3'
        AND availability_zone = 'us-east-1-1'
        AND microservice_name = 'hercules'
    GROUP BY region, cell, silo, availability_zone, microservice_name,
        instance_name, process_name, jdk_version
)
SELECT instance_name, MAX(time) AS time, MAX_BY(last_measure, time) AS last_measure
FROM (
    SELECT * FROM last_point_derived
    UNION
    SELECT * FROM last_point_source
)
GROUP BY instance_name
ORDER BY instance_name, time DESC
```

La precedente è solo un'illustrazione di come è possibile strutturare le tabelle derivate. Se disponi di anni di dati, puoi utilizzare più livelli di aggregazioni. Ad esempio, puoi aggiungere aggregati mensili a quelli giornalieri e aggiungere aggregati orari prima di quelli giornalieri. In questo modo puoi unire i dati più recenti per inserire l'ultima ora, quelli con frequenza oraria per inserire l'ultimo giorno, quelli giornalieri per compilare l'ultimo mese e quelli mensili per inserire i dati più vecchi. Il numero di livelli impostati rispetto alla pianificazione degli aggiornamenti dipenderà dalle vostre esigenze relative alla frequenza con cui queste query vengono emesse e al numero di utenti che le emettono contemporaneamente.