Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Conexión a un origen de datos de SAP HANA
<a name="saphana-AMG-datasource"></a>

[SAP HANA](https://www.sap.com/products/technology-platform/hana.html) es una base de datos en memoria de alto rendimiento que agiliza las decisiones y acciones en tiempo real basadas en datos. SAP se encarga de su desarrollo y comercialización. El complemento de origen de datos de SAP HANA lo ayuda a conectar su instancia de SAP HANA con Grafana.

Con el complemento de SAP HANA Grafana Enterprise, puede visualizar sus datos de SAP HANA junto con todos sus demás orígenes de datos en Grafana, así como datos de registro y métricas en contexto. Este complemento incluye un editor de consultas integrado, admite anotaciones y le permite establecer umbrales de alerta, controlar el acceso, establecer permisos y mucho más.

**nota**  
Este origen de datos es solo para Grafana Enterprise. Para obtener más información, consulte [Administración del acceso a los complementos empresariales](upgrade-to-enterprise-plugins.md).  
Además, en los espacios de trabajo compatibles con la versión 9 o posterior, es posible que se deba instalar el complemento adecuado para este origen de datos. Para obtener más información, consulte [Ampliación de su espacio de trabajo con complementos](grafana-plugins.md).

## Características
<a name="saphana-features"></a>
+ **Editor de consultas**: el complemento viene con un editor de consultas SQL integrado con resaltado de sintaxis que le permite visualizar series temporales o datos de tablas y completar automáticamente las macros básicas de Grafana.
+ **Permisos de orígenes de datos**: controle quién puede ver o consultar los datos de SAP HANA en Grafana.
+ **Anotaciones**: superponga eventos o datos de SAP HANA en cualquier gráfico de Grafana para correlacionar los eventos con otros datos del gráfico.
+ **Alertas**: configure almacenes de métricas basados en alertas en SAP HANA.
+ **Variables para consultas**: cree variables de plantilla en Grafana, que se basen en datos de SAP HANA, e incluya variables en las consultas de SAP HANA para que los paneles sean interactivos.

## Adición del origen de datos
<a name="saphana-adding-the-data-source"></a>

1.  Abra la consola de Grafana en el espacio de trabajo de Amazon Managed Grafana y asegúrese de haber iniciado sesión. 

1.  En el menú lateral, en **Configuración** (el icono con forma de engranaje), seleccione **Orígenes de datos**. 

1.  Elija **Agregar origen de datos**. 
**nota**  
 Si no ve el enlace **Orígenes de datos** en el menú lateral, su usuario actual no tiene el rol `Admin`. 

1.  Seleccione **SAP HANA** de la lista de orígenes de datos. 

1. En el editor de configuración, ingrese lo siguiente:
   + En **Dirección del servidor**, proporcione la dirección de la instancia de SAP HANA. Ejemplo: `xxxxxxx-xxxx-xxxx-xxxx-xxxxxxx.hana.trial-us10.hanacloud.ondemand.com`.
   + En **Puerto del servidor**, proporcione el puerto de la instancia de SAP HANA.
   + En **Nombre de usuario**, ingrese el nombre de usuario que se utilizará para conectarse a la instancia de SAP HANA.
   + En **Contraseña**, escriba la contraseña para este usuario.
   + (Opcional) Habilite **Omitir la verificación de TLS** si desea omitir la verificación de TLS.
   + (Opcional) Habilite **Autenticación del cliente TLS** si necesita proporcionar un certificado y una clave de cliente.
   + (Opcional) Habilite **Con un certificado de CA** si desea habilitar la verificación de los certificados TLS autofirmados.
   + (Opcional) En **Esquema predeterminado**, ingrese el esquema predeterminado que se utilizará. Si lo omite, tendrá que especificar el esquema en cada consulta. 

**Accesos y permisos**

Para conectar Grafana a SAP HANA, utilice credenciales dedicadas. Proporcione al usuario únicamente los permisos necesarios. En primer lugar, cree un usuario restringido con nombre de usuario y contraseña. La siguiente consulta es un ejemplo de creación de un usuario restringido. Esta consulta también deshabilita el cambio forzoso de la contraseña.

```
CREATE RESTRICTED USER <USER> PASSWORD <PASSWORD> NO FORCE_FIRST_PASSWORD_CHANGE;
```

A continuación, permita al usuario conectar el sistema a través de clientes como Grafana con lo siguiente:

```
ALTER USER <USER> ENABLE CLIENT CONNECT;
```

Por último, dé al usuario acceso a las vistas, tablas y esquemas necesarios.

```
ALTER USER <USER> GRANT ROLE PUBLIC;
GRANT SELECT ON SCHEMA <SCHEMA> TO <USER>;
```

**Permisos de nivel de usuario**

Limite el acceso a SAP HANA haciendo clic en la pestaña Permisos de la página de configuración del origen de datos para habilitar los permisos del origen de datos. En la página de permisos, los administradores pueden habilitar los permisos y restringir los permisos de consulta a usuarios y equipos específicos.

## Editor de consultas
<a name="saphana-queryeditor"></a>

El complemento de Grafana de SAP HANA incluye un editor de consultas SQL en el que puede ingresar cualquier consulta de HANA. Si la consulta devuelve datos de series temporales, puede formatearlos como series temporales para visualizarlos en un panel de gráficos. El editor de consultas permite completar automáticamente las macros de Grafana compatibles y resaltar la sintaxis de la consulta SQL.

## Anotaciones
<a name="saphana-annotations"></a>

Puede utilizar las consultas de SAP HANA como orígenes de las anotaciones de Grafana. La consulta de anotaciones debe devolver al menos una columna de tiempo y una columna de texto. Para obtener más información acerca de las anotaciones, consulte [Anotaciones](dashboard-annotations.md).

**Creación de anotaciones desde SAP HANA**

1.  Seleccione el icono con forma de engranaje **Configuración del panel**. 

1.  En el menú de la izquierda, seleccione **Anotaciones**, **Nuevo**. 

1.  En el menú desplegable **Origen de datos**, seleccione su instancia de origen de datos de SAP HANA. 

1.  En el campo **Consulta**, ingrese una consulta de SAP HANA que devuelva al menos un campo de tiempo y un campo de texto. 

1.  En el menú desplegable **Dar formato como**, seleccione **Serie temporal**. 

1.  Para cada anotación, configure los campos **Desde**. 

## Plantillas y variables
<a name="saphana-templates"></a>

Para agregar una nueva variable de consulta de SAP HANA, consulte [Adición de una variable de consulta](variables-types.md#add-a-query-variable). Utilice su origen de datos de SAP HANA como origen de datos.

La siguiente consulta de ejemplo devuelve la lista definida de `username` de la tabla `users`.

```
select distinct("username") from "users"
```

**nota**  
Asegúrese de seleccionar solo una columna en la consulta de variables. Si la consulta devuelve dos columnas, la primera columna se utilizará como valor de visualización y la segunda como valor real de la variable. Si la consulta devuelve más de dos columnas, se rechazarán.

### Plantillas y variables
<a name="saphana-Grafana-variables"></a>

Puede usar cualquier variable de Grafana en su consulta. En los siguientes ejemplos, se muestra cómo utilizar la variable única o múltiple en la consulta.

```
-- For example, following query
select * from "users" where "city" = ${city}
-- will be translated into
select * from "users" where "city" = 'london'
--- where you can see ${city} variable translated into actual value in the variable
```

Al igual que el texto, las variables también funcionan para los campos numéricos. En el siguiente ejemplo, `${age}` es una variable de cuadro de texto en la que acepta números y, a continuación, los compara con el campo numérico de la tabla.

```
select * from "users" where "age" > ${age}
--- wil be translated into
select * from "users" where "age" > '36'
```

Si la variable devuelve varios valores, puede utilizarla en la condición `in` de la consulta de SAP HANA, como se muestra a continuación. Tenga en cuenta los corchetes que rodean la variable para que la condición `where in` sea válida en SAP HANA.

```
select * from "users" where "city" in (${cities})
--- will be translated into
select * from "users" where "city" in ('london','perth','delhi')
--- where you can see ${cities} turned into a list of grafana variables selected.
--- You can also write the same query using shorthand notation as shown below
select * from "users" where "city" in ($cities)
```

### Macros
<a name="saphana-macros"></a>
+ `$__timeFilter(<time_column>)`: aplica el intervalo de tiempo de Grafana a la columna especificada cuando se usa en la consulta sin procesar. Aplicable a las columnas de date/timestamp/long tiempo.
+ `$__timeFilter(<time_column>, <format>)`: igual que lo mencionado anteriormente. Sin embargo, le permite especificar el formato de la columna time\$1column almacenada en la base de datos.
+ `$__timeFilter(<time_column>, "epoch", <format>)`: igual que lo mencionado anteriormente, pero se puede usar cuando la columna de tiempo está en época. El formato puede ser “s”, “ms” y “ns”.
+ `$__fromTimeFilter(<time_column>)`: igual que lo mencionado anteriormente, pero se puede usar cuando la columna de tiempo está en época. El formato puede ser “s”, “ms” y “ns”.
+ `$__fromTimeFilter(<time_column>, <comparison_predicate>)`: igual que lo mencionado anteriormente, pero se puede especificar comparison\$1predicate.
+ `$__fromTimeFilter(<time_column>, <format>)`: igual que lo mencionado anteriormente, pero se puede especificar el formato de la columna de tiempo.
+ `$__fromTimeFilter(<time_column>, <format>, <comparison_predicate>)`: igual que lo mencionado anteriormente, pero se puede especificar comparison\$1predicate.
+ `$__toTimeFilter(<time_column>)`: devuelve la condición de tiempo basada en el tiempo de Grafana sobre un campo de tiempo.
+ `$__toTimeFilter(<time_column>, <comparison_predicate>)`: igual que lo mencionado anteriormente, pero se puede especificar comparison\$1predicate.
+ `$__toTimeFilter(<time_column>, <format>)`: igual que lo mencionado anteriormente, pero se puede especificar el formato de la columna de tiempo.
+ `$__toTimeFilter(<time_column>, <comparison_predicate>)`: igual que lo mencionado anteriormente, pero se puede especificar comparison\$1predicate.
+ `$__timeGroup(<time_column>, <interval>)`: expande la columna de tiempo en grupos de intervalos. Aplicable a las columnas de date/timestamp/long tiempo.

**Macro \$1\$1\$1timeFilter(<time\$1column>)**

En el siguiente ejemplo se explica la macro `$__timeFilter(<time_column>)`:

```
- In the following example, the query
select ts, temperature from weather where $__timeFilter(ts)
--- will be translated into
select ts, temperature from weather where ts > '2021-02-24T12:52:48Z' AND ts < '2021-03-24T12:52:48Z'
--- where you can see the grafana dashboard's time range is applied to the column ts in the query.
```

**Macro \$1\$1\$1timeFilter(<time\$1column>, <format>)**

En algunos casos, las columnas de tiempo de la base de datos se almacenan en formatos personalizados. En el siguiente ejemplo se explica la macro `$__timeFilter(<time_column>, <format>)`, que ayuda a filtrar las marcas de tiempo personalizadas en función del selector de tiempo de Grafana:

```
SELECT TO_TIMESTAMP("TS",'YYYYMMDDHH24MISS') AS METRIC_TIME , "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TS","YYYYMMDDHH24MISS") -- TS is in 20210421162012 format
SELECT TO_TIMESTAMP("TS",'YYYY-MON-DD') AS METRIC_TIME , "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TS","YYYY-MON-DD") -- TS is in 2021-JAN-15 format
```

En la macro, el formato puede ser uno de los formatos de HANA válidos que coincidan con su columna de marcas de tiempo. Por ejemplo, `YYYYMMDDHH24MISS` es un formato válido cuando los datos se almacenan en formato `20210421162012`.

**Macro \$1\$1\$1timeFilter(<time\$1column>, "epoch" <format>)**

En algunos casos, las marcas de tiempo se almacenan como marcas de tiempo de época en su base de datos. En el siguiente ejemplo se explica la macro `$__timeFilter(<time_column>, "epoch" <format>)`, que ayuda a filtrar las marcas de tiempo de época en función del selector de tiempo de grafana. En la macro, el formato puede ser ms, s o ns. Si no se especifica, s se considerará el formato predeterminado.

```
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP") AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch") -- Example : TIMESTAMP field stored in epoch_second format 1257894000
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP") AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","s") -- Example : TIMESTAMP field stored in epoch_second format 1257894000
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","ms") -- Example : TIMESTAMP field stored in epoch_ms format 1257894000000
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000000000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","ns") -- Example : TIMESTAMP field stored in epoch_nanoseconds format 1257894000000000000
```

En lugar de usar el tercer argumento de \$1\$1\$1timeFilter, puede usar epoch\$1s, epoch\$1ms o epoch\$1ns como segundo argumento.

```
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch","ms")
-- is same as
SELECT ADD_SECONDS('1970-01-01', "TIMESTAMP"/1000) AS "METRIC_TIME", "VALUE" FROM "SCH"."TBL" WHERE $__timeFilter("TIMESTAMP","epoch_ms")
```

**Macros \$1\$1\$1 fromTimeFilter () y \$1\$1\$1 toTimeFilter ()**

La macro `$__fromTimeFilter()` se expande a una condición sobre un campo de tiempo basado en el tiempo del selector de tiempo de Grafana.

Esto acepta tres parámetros. El primer parámetro es el nombre del campo de tiempo. Puede pasar comparison\$1predicate o el formato de la columna de tiempo como segundo argumento. Si quiere pasar ambos, el formato es el segundo parámetro y use comparison\$1predicate como tercer parámetro.

****<format>Si no se especifica el formato, el complemento asumirá que la columna de tiempo es del timestamp/date tipo. Si su columna de tiempo está almacenada en un formato que no sea la marca de hora/fecha, pase el formato como segundo argumento. <format>puede ser epoch\$1s, epoch\$1ms, epoch\$1ns o cualquier otro formato personalizado similar. YYYY-MM-DD

**<comparison\$1predicate>**: parámetro opcional. Si no se pasa, el complemento usará > como predicado de comparación. <comparison\$1predicate> puede ser uno de los siguientes: =, \$1=, <>, <, <=, >, >=

`$__toTimeFilter()`funciona igual fromTimeFilter que \$1\$1\$1 (). En lugar de usar el tiempo de inicio de Grafana, usará el tiempo de finalización. Además, el predicado de comparación predeterminado será <.

**\$1\$1\$1timeGroup(<time\$1column>, <interval>)** 

Por ejemplo, la macro \$1\$1\$1timeGroup(timecol,1h) se expande a SERIES\$1ROUND("timecol", 'INTERVAL 1 HOUR') en la consulta.

En el siguiente ejemplo se explica `$__timeGroup(<time_column>, <interval>) macro.`

```
SELECT $__timeGroup(timestamp,1h),  "user", sum("value") as "value"
FROM "salesdata"
WHERE $__timeFilter("timestamp")
GROUP BY $__timeGroup(timestamp,1h), "user"
ORDER BY $__timeGroup(timestamp,1h) ASC
```

Esto se traduce en la siguiente consulta, donde `$__timeGroup(timestamp,1h)` se amplía a `SERIES_ROUND("timestamp", 'INTERVAL 1 HOUR')`.

```
SELECT SERIES_ROUND("timestamp", 'INTERVAL 1 HOUR') as "timestamp",  "user", sum("value") as "value"
FROM "salesdata"
WHERE "timestamp" > '2020-01-01T00:00:00Z' AND "timestamp" < '2020-01-01T23:00:00Z'
GROUP BY SERIES_ROUND("timestamp", 'INTERVAL 1 HOUR'), "user"
ORDER BY "timestamp" ASC
```

**nota**  
Cuando utilice group by con la macro \$1\$1\$1timeGroup, asegúrese de que al seleccionar y ordenar por campos se le asigne el mismo nombre que al agrupar por campo. De lo contrario, es posible que HANA no reconozca la consulta.

Si no quiere codificar de manera rígida el intervalo en la función \$1\$1\$1timeGroup(), puede dejar eso en manos de Grafana especificando \$1\$1\$1interval como su intervalo. Grafana calculará ese intervalo a partir del intervalo de tiempo del panel. Consulta de ejemplo:

```
SELECT $__timeGroup(timestamp, $__interval), sum("value") as "value"
FROM "salesdata"
WHERE $__timeFilter("timestamp")
GROUP BY $__timeGroup(timestamp, $__interval)
ORDER BY $__timeGroup(timestamp, $__interval) ASC
```

Esa consulta se traduce en la siguiente consulta en función del intervalo de tiempo del panel.

```
SELECT SERIES_ROUND("timestamp", 'INTERVAL 1 MINUTE'), sum("value") as "value"
FROM "salesdata"
WHERE "timestamp" > '2019-12-31T23:09:14Z' AND "timestamp" < '2020-01-01T23:17:54Z'
GROUP BY SERIES_ROUND("timestamp", 'INTERVAL 1 MINUTE')
ORDER BY SERIES_ROUND("timestamp", 'INTERVAL 1 MINUTE') ASC
```

### Alertas
<a name="saphana-alerting"></a>

**Configuración de una alerta de SAP HANA en Grafana**

1. Cree un panel de gráficos en su panel.

1. Cree una consulta de SAP HANA en formato de serie temporal.

1. Elija la pestaña **Alerta** y especifique los criterios de alerta.

1. Elija **Probar regla** para probar la consulta de alertas.

1. Especifique los destinatarios de la alerta, el mensaje y la gestión de errores.

1. Guarde el panel de control.

#### Alertas sobre datos que no son de series temporales
<a name="saphana-alerting-nontimeseries"></a>

Para enviar alertas sobre datos que no sean de series temporales, utilice la macro `TO_TIMESTAMP('${__to:date}')` para convertir las métricas que no son de series temporales en series temporales. Esto convertirá la métrica en una consulta de series temporales de un solo punto. El formato de la consulta se indica a continuación

```
SELECT TO_TIMESTAMP('${__to:date}'),  <METRIC> FROM <TABLE≶ WHERE <YOUR CONDITIONS>
```

En el siguiente ejemplo, una tabla tiene cuatro campos denominados username, age, city y role. Esta tabla no tiene ningún campo de tiempo. Queremos notificar cuando el número de usuarios con el rol de desarrollador sea inferior a tres.

```
SELECT  TO_TIMESTAMP('${__to:date}'), count(*) as "count" FROM (
   SELECT 'John' AS "username", 32 AS "age", 'Chennai' as "city", 'dev' as "role" FROM dummy
   UNION ALL SELECT 'Jacob' AS "username", 32 AS "age", 'London' as "city", 'accountant' as "role" FROM dummy
   UNION ALL SELECT 'Ali' AS "username", 42 AS "age", 'Delhi' as "city", 'admin' as "role" FROM dummy
   UNION ALL SELECT 'Raja' AS "username", 12 AS "age", 'New York' as "city", 'ceo' as "role" FROM dummy
   UNION ALL SELECT 'Sara' AS "username", 35 AS "age", 'Cape Town' as "city", 'dev' as "role" FROM dummy
   UNION ALL SELECT 'Ricky' AS "username", 25 AS "age", 'London' as "city", 'accountant' as "role" FROM dummy
   UNION ALL SELECT 'Angelina' AS "username", 31 AS "age", 'London' as "city", 'cxo' as "role" FROM dummy
) WHERE "role" = 'dev'
```