

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

# Connect a un'origine dati PostgreSQL
<a name="using-postgresql-in-AMG"></a>

 Puoi utilizzare l'origine dati PostgreSQL per interrogare e visualizzare i dati dai tuoi database Amazon Aurora PostgreSQL. 

**Importante**  
*Grafana versione 8* modifica la struttura dei dati sottostante per i frame di dati per le fonti di dati Postgres, MySQL e Microsoft SQL Server. Di conseguenza, il risultato di una query di serie temporali viene restituito in un formato ampio. Per ulteriori informazioni, consulta [Wide format](https://grafana.com/developers/plugin-tools/introduction/data-frames#wide-format) nella documentazione dei frame di dati Grafana. Per far funzionare le visualizzazioni come prima della versione 8, potrebbe essere necessario eseguire alcune migrazioni manuali. Una soluzione è documentata su Github all'indirizzo [Postgres/MySQL/MSSQL: Breaking change in v8.0 relativo alle query sulle serie temporali e all'ordinamento delle colonne di](https://github.com/grafana/grafana/issues/35534) dati.  
Nella *versione 9 di Grafana*, l'origine dati PostgreSQL imposta il certificato root per la connessione al database in modo diverso rispetto alle versioni precedenti. Se aggiorni il tuo spazio di lavoro dalla versione 8 alla 9, potresti dover cambiare il modo in cui ti connetti. Per ulteriori informazioni, consulta [Risoluzione dei problemi relativi alle aree di lavoro aggiornate](AMG-workspace-version-update-troubleshoot.md).

## Aggiungere la fonte di dati
<a name="postgresql-adding-the-data-source"></a>

1.  Apri il menu laterale selezionando l'icona Grafana nell'intestazione in alto. 

1.  Nel menu laterale sotto l'icona **Configurazione**, dovresti trovare un link **Data Sources**. 

1.  Scegli il pulsante **\$1 Aggiungi fonte di dati** nell'intestazione in alto. 

1.  **Seleziona **PostgreSQL** dall'elenco a discesa Tipo.** 

### Opzioni relative all'origine dei dati
<a name="postgresql-data-source-options"></a>


|  Nome  |  Description  | 
| --- | --- | 
|  Name  |  Il nome dell'origine dati. Ecco come viene visualizzata la fonte di dati nei pannelli e nelle query.  | 
|  Default  |  L'origine dati predefinita significa che sarà preselezionata per i nuovi pannelli.  | 
|  Host  |  L'IP address/hostname e la porta opzionale dell'istanza PostgreSQL. Non includere il nome del database. La stringa di connessione per la connessione a Postgres non sarà corretta e causerà errori.  | 
|  Database  |  Nome del database PostgreSQL.  | 
|  User  |  Login/nome utente dell'utente del database. | 
|  Password  |  Password dell'utente del database  | 
|  SSL Mode  |  Questa opzione determina se e con quale priorità verrà negoziata una TCP/IP connessione SSL sicura con il server.  | 
|  Max open  |  Il numero massimo di connessioni aperte al database, predefinito unlimited (Grafana v5.4\$1).  | 
|  Max idle  |  Il numero massimo di connessioni nel pool di connessioni inattive, predefinito 2 (Grafana v5.4\$1).  | 
|  Max lifetime  |  La quantità massima di tempo in secondi per riutilizzare una connessione, impostazione predefinita 14400 /4 ore (Grafana v5.4\$1).  | 
|  Version  |  Questa opzione determina quali funzioni sono disponibili nel generatore di query (disponibile solo in Grafana 5.3\$1).  | 
|  TimescaleDB  |  TimescaleDB è un database di serie temporali creato come estensione PostgreSQL. Se abilitato, Grafana utilizzerà time\$1bucket nella \$1\$1\$1timeGroup macro e visualizzerà le funzioni aggregate specifiche di TimeScaleDB nel generatore di query (disponibile solo in Grafana 5.3\$1).  | 

### Intervallo di tempo minimo
<a name="postgresql-min-time-interval"></a>

 Un limite inferiore per le `$_interval` `$_interval_ms` variabili. Si consiglia di impostare la frequenza di scrittura, ad esempio `1m` se i dati vengono scritti ogni minuto. Questa opzione può anche essere presente overridden/configured in un pannello di dashboard sotto le opzioni dell'origine dati. Questo valore **deve** essere formattato come un numero seguito da un identificatore temporale valido, ad esempio `1m` (1 minuto) o `30s` (30 secondi). Sono supportati i seguenti identificatori di orario.


|  Identificatore  |  Description  | 
| --- | --- | 
|  y  |  Anno  | 
|  M  |  Mese  | 
|  w  |  Settimana  | 
|  d  |  Day (Giorno)  | 
|  h  |  Ora  | 
|  m  |  Minuto  | 
|  s  |  Secondo  | 
|  ms  |  Millisecondi  | 

### Autorizzazioni utente del database
<a name="postgresql-database-user-permissions-important"></a>

**Importante**  
 All'utente del database specificato quando si aggiunge l'origine dati devono essere concesse le autorizzazioni SELECT solo per il database e le tabelle specificati su cui si desidera eseguire la query. Grafana non conferma che la query sia sicura. La query potrebbe includere qualsiasi istruzione SQL. Ad esempio, `DROP TABLE user;` verrebbero eseguite istruzioni come `DELETE FROM user;` e. Per proteggerti da ciò, ti consigliamo vivamente di creare un utente PostgreSQL specifico con autorizzazioni limitate. 

Il codice di esempio seguente mostra la creazione di un utente PostgreSQL specifico con autorizzazioni limitate. 

```
 CREATE USER grafanareader WITH PASSWORD 'password';
 GRANT USAGE ON SCHEMA schema TO grafanareader;
 GRANT SELECT ON schema.table TO grafanareader;
```

 Assicurati che l'utente non ottenga autorizzazioni indesiderate dal ruolo pubblico. 

## Editor della query
<a name="postgresql-query-editor"></a>

 Puoi trovare l'editor di query PostgreSQL nella scheda metriche nella modalità di modifica del pannello Graph o Singlestat. Si accede alla modalità di modifica scegliendo il titolo del pannello, quindi modificando. 

 L'editor di query ha un collegamento **SQL generato** che viene visualizzato dopo l'esecuzione di una query, in modalità di modifica del pannello. Sceglilo e si espanderà e mostrerà la stringa SQL interpolata non elaborata che è stata eseguita. 

### Seleziona tabella, colonna temporale e colonna metrica (FROM)
<a name="postgresql-select-table-time-column-and-metric-column-from"></a>

 Quando si accede alla modalità di modifica per la prima volta o si aggiunge una nuova query, Grafana proverà a precompilare il generatore di query con la prima tabella che ha una colonna timestamp e una colonna numerica. 

 Nel campo FROM, Grafana suggerirà le tabelle presenti nell'utente `search_path` del database. Per selezionare una tabella o una vista non presente, `search_path` è possibile inserire manualmente un nome completo (schema.table) come. `public.metrics` 

 Il campo della colonna Ora si riferisce al nome della colonna contenente i valori temporali. La selezione di un valore per il campo della colonna Metrica è facoltativa. Se viene selezionato un valore, il campo della colonna Metrica verrà utilizzato come nome della serie. 

 Le colonne metriche suggerite conterranno solo colonne con un tipo di dati testuale (char, varchar, text). Per utilizzare una colonna con un tipo di dati diverso come colonna metrica, puoi inserire il nome della colonna con un cast:. `ip::text` Puoi anche inserire espressioni SQL arbitrarie nel campo della colonna metrica che restituiscono un tipo di dati di testo come. `hostname || ' ' || container_name` 

### Colonne, finestre e funzioni di aggregazione (SELECT)
<a name="columns-window-and-aggregation-functions-select"></a>

 Nella `SELECT` riga, puoi specificare quali colonne e funzioni desideri utilizzare. Nel campo della colonna, è possibile scrivere espressioni arbitrarie anziché un nome di colonna come`column1 * column2 / column3`. 

 Le funzioni disponibili nell'editor di query dipendono dalla versione di PostgreSQL selezionata durante la configurazione dell'origine dati. Se si utilizzano funzioni aggregate, è necessario raggruppare il set di risultati. Se aggiungi una funzione aggregata, l'editor aggiungerà automaticamente una. `GROUP BY time` 

L'editor cerca di semplificare e unificare questa parte della query. 

Puoi aggiungere altre colonne di valori scegliendo il pulsante più e selezionando **Colonna** dal menu. Le colonne con valori multipli verranno tracciate come serie separate nel pannello grafico. 

### Filtraggio dei dati (WHERE)
<a name="postgresql-filter-data-where"></a>

 Per aggiungere un filtro, scegli l'icona con il segno più a destra della `WHERE` condizione. Puoi rimuovere i filtri scegliendo il filtro e selezionando **Rimuovi**. Un filtro per l'intervallo di tempo attualmente selezionato viene aggiunto automaticamente alle nuove interrogazioni.

### Raggruppa per
<a name="postgresql-group-by"></a>

 Per raggruppare in base all'ora o a qualsiasi altra colonna, scegli l'icona più alla fine della riga GROUP BY. L'elenco a discesa dei suggerimenti mostrerà solo le colonne di testo della tabella attualmente selezionata, ma puoi inserire manualmente qualsiasi colonna. **Puoi rimuovere il gruppo scegliendo l'elemento e selezionando Rimuovi.** 

 Se aggiungi un raggruppamento, a tutte le colonne selezionate deve essere applicata una funzione di aggregazione. Il generatore di query aggiungerà automaticamente funzioni di aggregazione a tutte le colonne senza funzioni di aggregazione quando si aggiungono raggruppamenti. 

#### Riempimento degli
<a name="postgresql-gap-filling"></a>

 Amazon Managed Grafana può inserire i valori mancanti quando esegui il raggruppamento per fascia oraria. La funzione time accetta due argomenti. Il primo argomento è la finestra temporale in base alla quale vuoi raggruppare e il secondo argomento è il valore con cui vuoi che Grafana riempia gli elementi mancanti. 

### Modalità editor di testo (RAW)
<a name="postgresql-text-editor-mode-raw"></a>

 Puoi passare alla modalità editor di query raw scegliendo l'icona a forma di hamburger e selezionando **Cambia modalità editor** o scegliendo **Modifica SQL** sotto la query. 

**Nota**  
 Se utilizzi l'editor di query non elaborato, assicurati che la tua query abbia `ORDER BY time` almeno un filtro sull'intervallo di tempo restituito. 

## Macro
<a name="postgresql-macros"></a>

 Le macro possono essere utilizzate all'interno di una query per semplificare la sintassi e consentire l'utilizzo di parti dinamiche. 


|  Esempio di macro  |  Description  | 
| --- | --- | 
|  \$1\$1\$1time(dateColumn)  |  Verrà sostituito da un'espressione da convertire in un timestamp UNIX e in cui rinominare la colonna. time\$1sec Ad esempio, UNIX\$1TIMESTAMP (dateColumn) come time\$1sec.  | 
|  \$1\$1\$1timeEpoch(dateColumn)  |  Verrà sostituito da un'espressione da convertire in un timestamp UNIX e rinominare la colonna in. time\$1sec Ad esempio, UNIX\$1TIMESTAMP (dateColumn) come time\$1sec. | 
|  \$1\$1\$1timeFilter(dateColumn)  |  Verrà sostituito da un filtro per intervallo di tempo che utilizza il nome di colonna specificato. Ad esempio, DateColumn BETWEEN FROM\$1UNIXTIME (1494410783) AND FROM\$1UNIXTIME (1494410983).  | 
|  \$1\$1\$1timeFrom()  |  Verrà sostituito dall'inizio della selezione temporale attualmente attiva. Ad esempio, FROM\$1UNIXTIME (1494410783). | 
|  \$1\$1\$1timeTo()  |  Verrà sostituito dalla fine della selezione temporale attualmente attiva. Ad esempio, FROM\$1UNIXTIME (1494410983).  | 
|  \$1\$1\$1timeGroup(dateColumn,'5m')  |  Verrà sostituito da un'espressione utilizzabile nella clausola GROUP BY. Ad esempio, cast (cast (UNIX\$1TIMESTAMP (DateColumn)/(300) as signed) 300 as signed), \$1  | 
|  \$1\$1\$1timeGroup(dateColumn,'5m', 0)  |  Uguale alla riga precedente, ma con un parametro fill, quindi i punti mancanti in quella serie verranno aggiunti da grafana e 0 verrà utilizzato come valore.  | 
|  \$1\$1\$1timeGroup(dateColumn,'5m', NULL)  |  Come sopra, ma NULL verrà utilizzato come valore per i punti mancanti.  | 
|  \$1\$1\$1timeGroup(dateColumn,'5m', previous)  |  Come sopra, ma il valore precedente di quella serie verrà utilizzato come valore di riempimento se non è stato ancora visualizzato alcun valore verrà utilizzato NULL (disponibile solo in Grafana 5.3\$1).  | 
|  \$1\$1\$1timeGroupAlias(dateColumn,'5m')  |  Verrà sostituito in modo identico a \$1\$1\$1TimeGroup ma con un alias di colonna aggiunto  | 
|  \$1\$1\$1unixEpochFilter(dateColumn) |  Verrà sostituito da un filtro per intervallo temporale che utilizza il nome della colonna specificato con gli orari rappresentati come timestamp Unix. Ad esempio, \$1dateColumn > 1494410783 AND dateColumn < 1494497183\$1  | 
| \$1\$1\$1unixEpochFrom()`  | \$1 Verrà sostituito dall'inizio della selezione dell'ora attualmente attiva come timestamp Unix. Ad esempio, \$11494410783\$1 | 
| \$1\$1\$1unixEpochTo() | Verrà sostituito dalla fine della selezione temporale attualmente attiva come timestamp Unix. Ad esempio, \$11494497183\$1 | 
| \$1\$1\$1unixEpochNanoFilter(dateColumn) | Verrà sostituito da un filtro per intervallo di tempo che utilizza il nome della colonna specificato con i tempi rappresentati come timestamp in nanosecondi. Ad esempio, \$1dateColumn > 1494410783152415214 AND dateColumn < 1494497183142514872\$1 | 
| \$1\$1\$1unixEpochNanoFrom() | Verrà sostituito dall'inizio della selezione temporale attualmente attiva come timestamp in nanosecondi. Ad esempio, \$11494410783152415214\$1 | 
| \$1\$1\$1unixEpochNanoTo() | Verrà sostituito dalla fine della selezione temporale attualmente attiva come timestamp in nanosecondi. Ad esempio, \$11494497183142514872\$1 | 
| \$1\$1\$1unixEpochGroup(dateColumn,"5m", [fillmode]) | Uguale a \$1\$1\$1TimeGroup ma per gli orari archiviati come timestamp Unix. | 

## Interrogazioni sulla tabella
<a name="postgresql-table-queries"></a>

 Se l'opzione di interrogazione è impostata su **Formato come tabella**, puoi praticamente eseguire qualsiasi tipo di query SQL. Il pannello della tabella mostrerà automaticamente i risultati delle colonne e delle righe restituite dalla query. 

 È possibile controllare il nome delle colonne del pannello Tabella utilizzando la normale sintassi `as` SQL per la selezione delle colonne. 

## Interrogazioni sulle serie temporali
<a name="postgresql-time-series-queries"></a>

 Se impostate **Format as** to`Time series`, per utilizzarla ad esempio in un pannello grafico, la query deve restituire una colonna denominata `time` che restituisca un datetime SQL o qualsiasi tipo di dati numerico che rappresenti l'epoca Unix. Qualsiasi colonna tranne `time` e `metric` viene trattata come una colonna di valori. È possibile restituire una colonna denominata `metric` che viene utilizzata come nome metrico per la colonna dei valori. Se restituite più colonne di valori e una colonna denominata`metric`, questa colonna viene utilizzata come prefisso per il nome della serie. 

 I set di risultati delle query sulle serie temporali devono essere ordinati in base all'ora. 

 Il codice di esempio seguente mostra una `metric` colonna. 

```
SELECT
  $__timeGroup("time_date_time",'5m'),
  min("value_double"),
  'min' as metric
FROM test_data
WHERE $__timeFilter("time_date_time")
GROUP BY time
ORDER BY time
```

 Il seguente esempio di codice mostra l'utilizzo del parametro fill nella macro \$1\$1\$1TimeGroup per convertire invece i valori null in zero. 

```
SELECT
  $__timeGroup("createdAt",'5m',0),
  sum(value) as value,
  measurement
FROM test_data
WHERE
  $__timeFilter("createdAt")
GROUP BY time, measurement
ORDER BY time
```

 Il codice di esempio seguente mostra più colonne. 

```
SELECT
  $__timeGroup("time_date_time",'5m'),
  min("value_double") as "min_value",
  max("value_double") as "max_value"
FROM test_data
WHERE $__timeFilter("time_date_time")
GROUP BY time
ORDER BY time
```

## Templating
<a name="postgresql-templating"></a>

 Invece di inserire elementi come il nome del server, dell'applicazione e del sensore nelle query metriche, puoi utilizzare variabili al loro posto. Le variabili vengono visualizzate come caselle di selezione a discesa nella parte superiore della dashboard. Puoi utilizzare queste caselle a discesa per modificare i dati visualizzati nella dashboard. 

 Per ulteriori informazioni sui modelli e sulle variabili dei modelli, consulta. [Modelli](templates-and-variables.md#templates) 

### Variabile di interrogazione
<a name="postgresql-query-variable"></a>

 Se aggiungi una variabile modello di questo tipo`Query`, puoi scrivere una query PostgreSQL in grado di restituire elementi come nomi di misurazioni, nomi di chiavi o valori chiave che vengono visualizzati come una casella di selezione a discesa. 

 *Ad esempio, puoi avere una variabile che contiene tutti i valori per la `hostname` colonna in una tabella se specifichi una query come questa nell'impostazione della variabile di modello Query.* 

```
SELECT hostname FROM host
```

 Una query può restituire più colonne e Grafana creerà automaticamente un elenco da esse. Ad esempio, la seguente query restituirà un elenco con valori da `hostname` e`hostname2`. 

```
SELECT host.hostname, other_host.hostname2 FROM host JOIN other_host ON host.city = other_host.city
```

 Per utilizzare macro dipendenti dall'intervallo di tempo, ad esempio `$__timeFilter(column)` nella query, la modalità di aggiornamento della variabile modello deve essere impostata *su On Time Range Change*. 

```
SELECT event_name FROM event_log WHERE $__timeFilter(time_column)
```

 Un'altra opzione è una query che può creare una key/value variabile. La query dovrebbe restituire due colonne denominate `__text` e`__value`. Il valore della `__text` colonna deve essere univoco (se non è univoco, viene utilizzato il primo valore). Le opzioni nell'elenco a discesa avranno un testo e un valore che ti permetteranno di avere un nome descrittivo come testo e un id come valore. Un esempio di query con `hostname` come testo e `id` come valore: 

```
SELECT hostname AS __text, id AS __value FROM host
```

 È inoltre possibile creare variabili annidate. Utilizzando una variabile denominata`region`, è possibile fare in modo che la variabile hosts mostri solo gli host della regione attualmente selezionata. Il seguente esempio di codice mostra una query come questa (se `region` è una variabile multivalore, utilizzate l'operatore di `IN` confronto anziché `=` eseguire la corrispondenza con più valori). 

```
SELECT hostname FROM host  WHERE region IN($region)
```

#### Utilizzo `__searchFilter` per filtrare i risultati in Query Variable
<a name="postgresql-using-__searchfilter-to-filter-results-in-query-variable"></a>

 L'utilizzo `__searchFilter` nel campo di interrogazione filtrerà il risultato della query in base a ciò che l'utente digita nella casella di selezione a discesa. Quando l'utente non ha inserito nulla, il valore predefinito per `__searchFilter` è`%`. 

**Nota**  
 È importante circondare l'`__searchFilter`espressione tra virgolette poiché Grafana non lo fa per te. 

 L'esempio seguente mostra come utilizzare, `__searchFilter` come parte del campo di interrogazione, la ricerca `hostname` mentre l'utente digita nella casella di selezione a discesa. 

```
SELECT hostname FROM my_host  WHERE hostname LIKE '$__searchFilter'
```

### Utilizzo delle variabili nelle interrogazioni
<a name="postgresql-using-variables-in-queries"></a>

 I valori delle variabili modello vengono citati solo quando la variabile modello è a. `multi-value` 

 Se la variabile è una variabile multivalore, utilizza l'operatore di `IN` confronto anziché `=` eseguire il confronto con più valori. 

 Esistono due sintassi: 

 `$<varname>`Esempio con una variabile modello denominata`hostname`: 

```
SELECT
  atimestamp as time,
  aint as value
FROM table
WHERE $__timeFilter(atimestamp) and hostname in($hostname)
ORDER BY atimestamp ASC
```

 `[[varname]]`Esempio con una variabile modello denominata`hostname`: 

```
SELECT
  atimestamp as time,
  aint as value
FROM table
WHERE $__timeFilter(atimestamp) and hostname in([[hostname]])
ORDER BY atimestamp ASC
```

#### Disattivazione delle virgolette per le variabili multivalore
<a name="postgresql-disabling-quoting-for-multi-value-variables"></a>

 Amazon Managed Grafana crea automaticamente una stringa tra virgole e virgole per variabili multivalore. Ad esempio: se `server02` sono selezionati `server01` e, verranno formattati come:. `'server01', 'server02'` Per disattivare le virgolette, usa l'opzione di formattazione csv per le variabili. 

 `${servers:csv}` 

 Per ulteriori informazioni sulle opzioni di formattazione delle variabili, vedere. [Modelli e variabili](templates-and-variables.md) 

## Annotazioni
<a name="postgresql-annotations"></a>

 Utilizzate le annotazioni per sovrapporre informazioni dettagliate sugli eventi ai grafici. È possibile aggiungere interrogazioni di annotazione tramite il menu Dashboard /la vista Annotazioni. Per ulteriori informazioni, consulta [Annotazioni](dashboard-annotations.md). 

 Il codice di esempio seguente mostra una query che utilizza una colonna temporale con valori epoch. 

```
SELECT
  epoch_time as time,
  metric1 as text,
  concat_ws(', ', metric1::text, metric2::text) as tags
FROM
  public.test_data
WHERE
  $__unixEpochFilter(epoch_time)
```

 Il codice di esempio seguente mostra una query regionale che utilizza le colonne time e timeend con valori epoch. 

**Nota**  
 È disponibile solo in Grafana v6.6\$1. 

```
SELECT
  epoch_time as time,
  epoch_time_end as timeend,
  metric1 as text,
  concat_ws(', ', metric1::text, metric2::text) as tags
FROM
  public.test_data
WHERE
  $__unixEpochFilter(epoch_time)
```

 Il codice di esempio seguente mostra una query che utilizza una colonna temporale del tipo di dati SQL nativo. date/time 

```
SELECT
  native_date_time as time,
  metric1 as text,
  concat_ws(', ', metric1::text, metric2::text) as tags
FROM
  public.test_data
WHERE
  $__timeFilter(native_date_time)
```


|  Nome  |  Description  | 
| --- | --- | 
|  time  |  Il nome del date/time campo. Potrebbe essere una colonna con un tipo di date/time dati SQL nativo o un valore epocale.  | 
|  timeend  |  Nome opzionale del date/time campo finale. Potrebbe essere una colonna con un tipo di date/time dati SQL nativo o un valore epoch (Grafana v6.6\$1). | 
|  text  |  Campo di descrizione dell'evento.  | 
|  tags  |  Nome di campo opzionale da utilizzare per i tag degli eventi come stringa separata da virgole.  | 

## Avviso
<a name="postgresql-alerting"></a>

 Le interrogazioni sulle serie temporali dovrebbero funzionare in condizioni di avviso. Le interrogazioni in formato tabella non sono ancora supportate nelle condizioni delle regole di avviso. 