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.
# Adición y administración de variables de panel de control
****
Este tema de documentación está diseñado para los espacios de trabajo de Grafana que admiten la **versión 9.x de Grafana**.
Para los espacios de trabajo de Grafana que admiten la versión 10.x de Grafana, consulte [Uso de la versión 10 de Grafana](using-grafana-v10.md).
Para los espacios de trabajo de Grafana que admiten la versión 8.x de Grafana, consulte [Uso de la versión 8 de Grafana](using-grafana-v8.md).
Una variable es un marcador de posición para un valor. Puede utilizar variables en las consultas de métricas y en los títulos de los paneles. Al cambiar el valor mediante la lista desplegable situada en la parte superior del panel de control, las consultas de métricas del panel reflejarán el nuevo valor.
Las variables le permiten crear paneles de control más interactivos y dinámicos. En lugar de codificar de forma rígida elementos como los nombres de servidores, aplicaciones y sensores en las consultas de métricas, puede utilizar variables en su lugar. Las variables se muestran como listas desplegables en la parte superior del panel de control. Estos menús desplegables facilitan el cambio de datos que se muestran en el panel de control.
Pueden resultar especialmente útiles para los administradores que quieren permitir a los visualizadores de Grafana ajustar las visualizaciones rápidamente, pero no quieren concederles permisos de edición completos. Los visualizadores de Grafana pueden utilizar variables.
Las variables y plantillas también le permiten gestionar paneles de control de un único origen. Si tiene varios orígenes de datos o servidores idénticos, puede crear un panel de control y utilizar variables para cambiar lo que está viendo. Esto simplifica considerablemente el mantenimiento y la conservación.
**Plantillas**
Una plantilla es cualquier consulta que contiene una variable. Por ejemplo, si administrara un panel de control para supervisar varios servidores, podría crear un panel de control para cada servidor o podría crear un panel de control y utilizar paneles con consultas de plantilla, como las siguientes.
```
wmi_system_threads{instance=~"$server"}
```
Los valores de las variables siempre se sincronizan con la URL mediante la sintaxis var-=value.
**Ejemplos**
Las variables se muestran en listas desplegables en la parte superior de la pantalla. Seleccione diferentes variables para ver cómo cambian las visualizaciones.
Para ver la configuración de las variables, vaya a **Configuración del panel > Variables**. Haga clic en una variable de la lista para ver su configuración.
Las variables se pueden usar en los títulos, descripciones, paneles de texto y consultas. Las consultas cuyo texto comienza por `$` son plantillas. No todos los paneles tendrán consultas de plantilla.
**Prácticas recomendadas de variables**
+ Las listas desplegables de variables se muestran en el orden en que aparecen en la lista de variables de **Configuración del panel**.
+ Coloque las variables que cambiará con frecuencia en la parte superior, de modo que se muestren primero (en el extremo izquierdo del panel de control).
# Adición y administración de variables
****
Este tema de documentación está diseñado para los espacios de trabajo de Grafana que admiten la **versión 9.x de Grafana**.
Para los espacios de trabajo de Grafana que admiten la versión 10.x de Grafana, consulte [Uso de la versión 10 de Grafana](using-grafana-v10.md).
Para los espacios de trabajo de Grafana que admiten la versión 8.x de Grafana, consulte [Uso de la versión 8 de Grafana](using-grafana-v8.md).
En la siguiente tabla se muestran los tipos de variables que se envían con Grafana.
| Tipo de variable | Description (Descripción) |
| --- | --- |
| Consultar | Lista de valores generada por consultas, como nombres de métricas, nombres de servidores, sensores IDs, centros de datos, etc. Agregue una variable de consulta. |
| Personalizada | Define las opciones de la variable de forma manual mediante una lista separada por comas. Agregue una variable personalizada. |
| Text box (Cuadro de texto) | Muestre un campo de entrada de texto libre con un valor predeterminado opcional. Agregue una variable de cuadro de texto. |
| Constant | Define una constante oculta. Agregue una variable de constante. |
| Origen de datos | Cambie rápidamente el origen de datos de un panel de control completo. Agregue una variable de origen de datos. |
| Interval | Las variables de intervalo representan intervalos de tiempo. Agregue una variable de intervalo. |
| Filtros ad hoc | Filtros de valores clave que se agregan automáticamente a todas las consultas de métricas de un origen de datos (solo Prometheus, Loki, InfluxDB y Elasticsearch). Agregue filtros ad hoc. |
| Variables globales | Variables integradas que se pueden utilizar en expresiones del editor de consultas. Consulte Variables globales. |
| Variables encadenadas | Las consultas de variables pueden contener otras variables. Consulte Variables encadenadas. |
## Introducción de opciones generales
Debe ingresar opciones generales para cualquier tipo de variable que cree.
**Introducción de opciones generales**
1. Vaya al panel de control para el que desee crear una variable y seleccione el icono (de engranaje) **Configuración del panel** situado en la parte superior de la página.
1. En la pestaña **Variables**, seleccione **Nuevo**.
1. Ingrese un **Nombre** para la variable.
1. En la lista **Tipo**, seleccione **Consulta**.
1. (Opcional) En **Etiqueta**, ingrese el nombre de visualización del menú desplegable de variables.
Si no ingresa ningún nombre de visualización, la etiqueta desplegable es el nombre de la variable.
1. Elija una opción de **Ocultar**:
+ **Sin selección (en blanco):** el menú desplegable de variables muestra el valor de **Nombre** o **Etiqueta** de la variable.
+ **Etiqueta**: el menú desplegable de variables solo muestra el valor de la variable seleccionada y una flecha hacia abajo.
+ **Variable**: no se muestra ningún menú desplegable de variables en el panel de control.
## Adición de una variable de consulta
Las variables de consulta permiten escribir una consulta de origen de datos que puede devolver una lista de nombres de métricas, valores de etiquetas o claves. Por ejemplo, una variable de consulta puede devolver una lista de nombres de servidores IDs, sensores o centros de datos. Los valores de las variables cambian a medida que buscan opciones de forma dinámica con una consulta a un origen de datos.
Por lo general, las variables de consulta solo se admiten para cadenas. Si la consulta devuelve números o cualquier otro tipo de datos, es posible que deba convertirlos en cadenas para poder utilizarlos como variables. Para el origen de datos de Azure, por ejemplo, puede usar la función [tostring](https://docs.microsoft.com/en-us/azure/data-explorer/kusto/query/tostringfunction) para este propósito.
Las expresiones de consulta pueden contener referencias a otras variables y, de hecho, crear variables vinculadas. Grafana lo detecta y actualiza automáticamente una variable cuando cambia una de sus variables vinculadas.
**nota**
Las expresiones de consulta son diferentes para cada origen de datos. Para obtener más información, consulte la documentación del [origen de datos](AMG-data-sources.md).
**Adición de una variable de consulta**
1. Ingrese las opciones generales, como se indica arriba.
1. En la lista **Origen de datos**, seleccione el origen de datos de destino para la consulta.
1. En la lista **Actualizar**, seleccione cuándo debe actualizar las opciones la variable.
+ **Al cargar el panel de control**: consulta el origen de datos cada vez que se carga el panel de control. Esto ralentiza la carga del panel de control, ya que la consulta de variables debe completarse antes de inicializar el panel de control.
+ **Al cambiar el intervalo de tiempo**: consulta el origen de datos cuando cambia el intervalo de tiempo del panel de control. Utilice esta opción únicamente si la consulta de opciones de variables contiene un filtro de intervalo de tiempo o depende del intervalo de tiempo del panel de control.
1. En el campo **Consulta**, ingrese una consulta.
+ El campo de consulta varía en función del origen de datos. Algunos orígenes de datos tienen editores de consultas personalizados.
+ Si necesita más espacio en un editor de consultas de un solo campo de entrada, coloque el cursor sobre las líneas de la esquina inferior derecha del campo y arrástrelo hacia abajo para ampliarlo.
1. (Opcional) En el campo **Expresión regular**, escriba una expresión regular para filtrar o capturar partes específicas de los nombres devueltos por la consulta del origen de datos. Para ver ejemplos, consulte [Filtrado de variables con expresiones regulares](#v9-dash-variable-add-filter).
1. En la lista **Ordenar**, seleccione el orden de clasificación de los valores que se mostrarán en la lista desplegable. La opción predeterminada, **Deshabilitado**, significa que se utilizará el orden de las opciones devuelto por la consulta del origen de datos.
1. (Opcional) Ingrese [Opciones de selección](#v9-dash-variable-add-selection).
1. En **Vista previa de valores**, Grafana muestra una lista de los valores de las variables actuales. Revíselos para asegurarse de que coincidan con lo que espera.
1. Seleccione **Agregar** para agregar la variable al panel de control.
## Adición de una variable personalizada
Utilice una variable *personalizada* para un valor que no cambie, como un número o una cadena.
Por ejemplo, si tiene nombres de servidores o nombres de regiones que nunca cambian, es posible que desee crearlos como variables personalizadas en lugar de como variables de consulta. Como no cambian, puede utilizarlos en [variables encadenadas](#v9-dash-variable-add-chained) en lugar de en otras variables de consulta. Eso reduciría la cantidad de consultas que Grafana debe enviar cuando se actualizan las variables encadenadas.
**Adición de una variable personalizada**
1. Ingrese las opciones generales, como se indica arriba.
1. En la
lista **Valores separados por comas**, ingrese los valores de esta variable en una lista separada por comas. Puede incluir números, cadenas o pares clave-valor separados por un espacio y dos puntos. Por ejemplo, `key1 : value1,key2 : value2`.
1. (Opcional) Ingrese [Opciones de selección](#v9-dash-variable-add-selection).
1. En **Vista previa de valores**, Grafana muestra una lista de los valores de las variables actuales. Revíselos para asegurarse de que coincidan con lo que espera.
1. Seleccione **Agregar** para agregar la variable al panel de control.
## Adición de una variable de cuadro de texto
Las variables de *cuadro de texto* muestran un campo de entrada de texto libre con un valor predeterminado opcional. Es la variable más flexible, ya que puede ingresar cualquier valor. Utilice este tipo de variable si tiene métricas con una cardinalidad alta o si desea actualizar varios paneles de un panel de control al mismo tiempo.
**Adición de una variable de cuadro de texto**
1. Ingrese las opciones generales, como se indica arriba.
1. (Opcional) En el campo **Valor predeterminado**, seleccione el valor predeterminado de la variable. Si no ingresa nada en este campo, Grafana mostrará un cuadro de texto vacío para que los usuarios escriban texto.
1. En **Vista previa de valores**, Grafana muestra una lista de los valores de las variables actuales. Revíselos para asegurarse de que coincidan con lo que espera.
1. Seleccione **Agregar** para agregar la variable al panel de control.
## Adición de una variable constante
Las variables *constantes* permiten definir una constante oculta. Esto resulta útil para los prefijos de las rutas métricas de los paneles de control que desee compartir. Al exportar un panel de control, las variables constantes se convierten en opciones de importación.
Las variables constantes *no* son flexibles. Cada variable constante solo contiene un valor y no se puede actualizar a menos que actualice la configuración de la variable.
Las variables constantes son útiles cuando tiene valores complejos que debe incluir en las consultas, pero no desea volver a escribirlos en todas las consultas. Por ejemplo, si tuviera una ruta de servidor llamada `i-0b6a61efe2ab843gg`, podría reemplazarla por una variable llamada `$path_gg`.
**Adición de una variable constante**
1. Ingrese las opciones generales, como se indica arriba.
1. En el campo **Valor**, escriba el valor de la variable. Puede ingresar letras, números y símbolos. Incluso puede utilizar caracteres comodín si utiliza el [formato RAW](https://grafana.com/docs/grafana/latest/dashboards/variables/variable-syntax/#raw).
1. En **Vista previa de valores**, Grafana muestra una lista de los valores de las variables actuales. Revíselos para asegurarse de que coincidan con lo que espera.
1. Seleccione **Agregar** para agregar la variable al panel de control.
## Adición de una variable de origen de datos
Las variables de *Origen de datos* le permiten cambiar rápidamente el origen de datos de un panel de control completo. Son útiles si tiene varias instancias de un origen de datos, quizás en entornos diferentes.
**Adición de una variable de origen de datos**
1. Ingrese las opciones generales, como se indica arriba.
1. En la lista **Tipo**, seleccione el origen de datos de destino para la variable.
1. (Opcional) En **Filtro de nombres de instancias**, ingrese un filtro de expresiones regulares para seleccionar las instancias del origen de datos en la lista desplegable de valores variables. Deje este campo vacío para mostrar todas las instancias.
1. (Opcional) Ingrese [Opciones de selección](#v9-dash-variable-add-selection).
1. En **Vista previa de valores**, Grafana muestra una lista de los valores de las variables actuales. Revíselos para asegurarse de que coincidan con lo que espera.
1. Seleccione **Agregar** para agregar la variable al panel de control.
## Adición de una variable de intervalo
Utilice una variable de *intervalo* para representar intervalos de tiempo, como `1m`, `1h` o `1d`. Puede considerarlos como un comando *agrupar por tiempo* que abarca todo el panel de control. Las variables de intervalo cambian la forma en que se agrupan los datos en la visualización. También puede utilizar la opción automática para devolver un número determinado de puntos de datos por intervalo de tiempo.
Puede usar una variable de intervalo como parámetro para agruparla por hora (para InfluxDB), intervalo de histograma de fecha (para Elasticsearch) o como parámetro de función de resumen (para Graphite).
**Adición de una variable de intervalo**
1. Ingrese las opciones generales, como se indica arriba.
1. En el campo **Valores**, ingrese los intervalos de periodo de tiempo que desee que aparezcan en la lista desplegable de variables. Se admiten las siguientes unidades de tiempo: `s (seconds)`, `m (minutes)`, `h (hours)`, `d (days)`, `w (weeks)`, `M (months)` y `y (years)`. También puede aceptar o editar los valores predeterminados: `1m,10m,30m,1h,6h,12h,1d,7d,14d,30d`.
1. (Opcional) Active la **opción automática** si desea agregar la opción `auto` a la lista. Esta opción le permite especificar cuántas veces debe dividirse el intervalo de tiempo actual para calcular el intervalo de tiempo `auto` actual. Si la activa, aparecerán dos opciones más:
+ **Recuento de pasos:** seleccione el número de veces que se dividirá el intervalo de tiempo actual para calcular el valor, de forma similar a la opción de consulta **Máximo de puntos de datos**. Por ejemplo, si el intervalo de tiempo visible actual es de 30 minutos, el intervalo `auto` agrupa los datos en 30 incrementos de un minuto. El valor predeterminado es 30 pasos.
+ **Intervalo mínimo**: el umbral mínimo por debajo del cual los intervalos del recuento de pasos no dividirán el tiempo. Para continuar con el ejemplo de 30 minutos, si el intervalo mínimo se establece en 2 min, Grafana agruparía los datos en 15 incrementos de dos minutos.
1. En **Vista previa de valores**, Grafana muestra una lista de los valores de las variables actuales. Revíselos para asegurarse de que coincidan con lo que espera.
1. Seleccione **Agregar** para agregar la variable al panel de control.
**Ejemplos de variables de intervalo**
En el ejemplo siguiente se muestra una variable de plantilla `myinterval` en una función de Graphite:
```
summarize($myinterval, sum, false)
```
## Adición de filtros ad hoc
Los *filtros ad hoc* permiten agregar filtros clave-valor que se agregan automáticamente a todas las consultas de métricas que utilizan el origen de datos especificado. A diferencia de otras variables, no se utilizan filtros ad hoc en las consultas. En su lugar, se utilizan filtros ad hoc para escribir filtros para las consultas existentes.
**nota**
Las variables de filtro ad hoc solo funcionan con los orígenes de datos de Prometheus, Loki, InfluxDB y Elasticsearch.
1. Ingrese las opciones generales, como se indica arriba.
1. En la lista **Origen de datos**, seleccione el origen de datos de destino.
1. Seleccione **Agregar** para agregar la variable al panel de control.
**Creación de filtros ad hoc**
Los filtros ad hoc son una de las opciones de variables más complejas y flexibles disponibles. En lugar de una lista normal de opciones de variables, esta variable le permite crear una consulta ad hoc que abarque todo el panel de control. Los filtros que aplique de esta manera se aplican a todos los paneles del panel de control.
## Configuración de las opciones de selección de variables
**Opciones de selección** son una característica que puede utilizar para administrar las selecciones de opciones de variables. Todas las opciones de selección son opcionales y están desactivadas de forma predeterminada.
### Variables de varios valores
Interpolar una variable con varios valores seleccionados es complicado, ya que no es fácil formatear los múltiples valores en una cadena que sea válida en el contexto dado en el que se usa la variable. Para intentar resolverlo, Grafana permite que cada complemento de origen de datos informe al motor de interpolación de plantillas qué formato usar para varios valores.
**nota**
La opción **Valor Personalizar todo** de la variable debe estar en blanco para que Grafana formatee todos los valores en una sola cadena. Si se deja en blanco, Grafana concatena (suma) todos los valores de la consulta. Por ejemplo, `value1,value2,value3`. Si se utiliza un valor `all` personalizado, en su lugar el valor será `*` o `all`.
**Variables de valores múltiples con un origen de datos de Graphite**
Graphite usa expresiones globales. En este caso, una variable con varios valores se interpolaría como `{host1,host2,host3}` si el valor de la variable actual fuera *host1*, *host2* y *host3*.
**Variables de valores múltiples con un origen de datos de Prometheus o InfluxDB**
InfluxDB y Prometheus utilizan expresiones regulares, por lo que se interpolaría la misma variable que `(host1|host2|host3)`. También se aplicaría escape de expresiones regulares a cada valor. De lo contrario, un valor con un carácter de control de expresión regular rompería la expresión regular.
**Variables de varios valores con un origen de datos elástico**
Elasticsearch usa la sintaxis de consulta de Lucene, por lo que se formatearía la misma variable que `("host1" OR "host2" OR "host3")`. En este caso, se debe aplicar escape a todos los valores para que el valor solo contenga comillas y palabras de control de Lucene.
**Solución de problemas de las variables con varios valores**
El escape y el formateo automáticos pueden causar problemas y puede resultar complicado entender la lógica que hay detrás de esto. Especialmente para InfluxDB y Prometheus, donde el uso de la sintaxis de expresiones regulares requiere que la variable se use en el contexto del operador de expresiones regulares.
Si no desea que Grafana escape y formatee expresiones regulares de forma automática, debe llevar a cabo una de estas acciones:
+ Desactive las opciones **Varios valores** o **Incluir todo**.
+ Utilice el [formato de variable sin procesar](https://grafana.com/docs/grafana/latest/dashboards/variables/variable-syntax/#raw).
### Opción Incluir todo
Grafana agrega una opción `All` a la lista desplegable de variables. Si un usuario selecciona esta opción, se seleccionan todas las opciones de variables.
### Valor Personalizar todo
Esta opción solo está visible si se selecciona **Opción Incluir todo**.
Ingrese la sintaxis de expresiones regulares, globales o Lucene en el campo **Valor Personalizar todo** para definir el valor de la opción `All`.
De forma predeterminada, el valor `All` incluye todas las opciones de una expresión combinada. Puede llegar a ser muy largo y provocar problemas de rendimiento. A veces puede ser mejor especificar un valor único personalizado, como una expresión regular comodín.
Para tener una sintaxis personalizada de expresiones regulares, globales o Lucene en la opción **Valor Personalizar todo**, nunca se escapa, por lo que tendrá que pensar en cuál es un valor válido para el origen de datos.
## Variables globales
Grafana tiene variables integradas que se pueden utilizar en expresiones del editor de consultas. En este tema se enumeran en orden alfabético y se definen. Estas variables son útiles en consultas, enlaces de panel de control y enlaces de datos.
**\$1\$1\$1dashboard**
Esta variable es el nombre del panel de control actual.
**\$1\$1\$1from y \$1\$1\$1to**
Grafana tiene dos variables de intervalo de tiempo integradas: `$__from` y `$__to`. Actualmente, siempre se interpolan como milisegundos de Epoch de forma predeterminada, pero puede controlar el formato de la fecha.
| Sintaxis | Ejemplo de resultado | Description (Descripción) |
| --- | --- | --- |
| `${__from}` | 1594671549254 | Epoch en milisegundos de Unix |
| `${__from:date}` | 2020-07-13T20:19:09.254Z | Sin argumentos, el valor predeterminado es ISO 8601/RFC 3339 |
| `${__from:date:iso}` | 2020-07-13T20:19:09.254Z | ISO 8601/RFC 3339 |
| `${__from:date:seconds}` | 1594671549 | Epoch en segundos de Unix |
| `${__from:date:YYYY-MM}` | 2020-07 | Cualquier formato de fecha personalizado que no incluya el carácter : |
La sintaxis anterior también funciona con `${__to}`.
**\$1\$1\$1interval**
Puede usar la variable `$__interval` como parámetro para agruparla por hora (para InfluxDB, MySQL, Postgres y MSSQL), intervalo de histograma de fecha (para Elasticsearch) o como parámetro de función de *resumen* (para Graphite).
Grafana calcula automáticamente un intervalo que se puede utilizar para agrupar por tiempo en las consultas. Cuando hay más puntos de datos de los que se pueden mostrar en un gráfico, las consultas se pueden hacer más eficientes al agruparlas por un intervalo mayor. Por ejemplo, si está viendo un gráfico de datos de 3 meses, es posible que no pueda ver los detalles a nivel de minutos. Agrupar por hora o día hace que la consulta sea más eficiente sin afectar a lo que muestra el gráfico. `$__interval` se calcula con el intervalo de tiempo y el ancho del gráfico (el número de píxeles).
Cálculo aproximado: `(to - from) / resolution`
Por ejemplo, si el intervalo de tiempo es de 1 hora y el gráfico está en pantalla completa, el intervalo podría calcularse en `2m`: los puntos se agrupan en intervalos de 2 minutos. Si el intervalo de tiempo es de 6 meses y el gráfico es de pantalla completa, el intervalo puede ser `1d` (1 día): los puntos se agrupan por día.
En el origen de datos de InfluxDB, la variable heredada `$interval` es la misma variable. `$__interval` debería usarse en su lugar.
Los orígenes de datos de InfluxDB y Elasticsearch tienen campos `Group by time interval` que se utilizan para hacer una codificación rígida del intervalo o para establecer el límite mínimo de la variable `$__interval` (mediante la sintaxis `>` -> `>10m`).
**\$1\$1\$1interval\$1ms**
Esta variable es la variable `$__interval` en milisegundos, no una cadena con formato de intervalo de tiempo. Por ejemplo, si `$__interval` es `20m`, `$__interval_ms` es `1200000`.
**\$1\$1\$1org**
Esta variable es el ID de la organización actual. `${__org.name}` es el nombre de la organización actual.
**\$1\$1\$1user**
`${__user.id}` es el ID del usuario actual. `${__user.login}` es el identificador de inicio de sesión del usuario actual. `${__user.email}` es el correo electrónico del usuario actual.
**\$1\$1\$1range**
Actualmente solo es compatible con los orígenes de datos de Prometheus y Loki. Esta variable representa el intervalo del panel de control actual. Se calcula mediante `to - from`. Tiene una representación de milisegundos y una segunda llamada `$__range_ms` y `$__range_s`.
**\$1\$1\$1rate\$1interval**
Actualmente solo es compatible con los orígenes de datos de Prometheus y Loki. La variable `$__rate_interval` está destinada a usarse en la función de tasa.
**\$1timeFilter o \$1\$1\$1timeFilter**
La variable `$timeFilter` devuelve el intervalo de tiempo seleccionado actualmente como una expresión. Por ejemplo, la expresión `Last 7 days` del intervalo de tiempo es `time > now() - 7d`.
Se usa en varios lugares, entre ellos:
+ La cláusula WHERE para el origen de datos de InfluxDB. Grafana la agrega automáticamente a las consultas de InfluxDB cuando está en el modo Editor de consultas. Puede agregarla manualmente en el modo Editor de texto: `WHERE $timeFilter`.
+ Registre las consultas de análisis en el origen de datos de Azure Monitor.
+ Consultas SQL en MySQL, Postgres y MSSQL.
+ La variable `$__timeFilter` se utiliza en el origen de datos de MySQL.
## Variables encadenadas
Las *variables encadenadas*, también denominadas *variables enlazadas* o *variables anidadas*, son variables de consulta con una o más variables adicionales en su consulta de variables. En esta sección se explica cómo funcionan las variables encadenadas y se proporcionan enlaces a ejemplos de paneles de control que las utilizan.
Las consultas de variables encadenadas son diferentes para cada origen de datos, pero la premisa es la misma para todas. Puede utilizar consultas de variables encadenadas en cualquier origen de datos que las permita.
Es posible utilizar paneles de control con plantillas vinculadas extremadamente complejos, de 5 o 10 niveles de profundidad. Técnicamente, no hay límite en cuanto a la profundidad o complejidad que pueda tener, pero cuantos más enlaces tenga, mayor será la carga de consultas.
**Prácticas recomendadas y consejos**
Las siguientes prácticas harán que los paneles de control y las variables sean más fáciles de usar.
**Creación de nuevas variables vinculadas**
+ El encadenamiento de variables crea dependencias. parent/child Puede imaginarlos como una escalera o un árbol.
+ La forma más sencilla de crear una nueva variable encadenada consiste en copiar la variable en la que desea basar la nueva. En la lista de variables, haga clic en el icono **Duplicar variable** situado a la derecha de la entrada de la variable para crear una copia. A continuación, puede agregar a la consulta la variable principal.
+ Las variables nuevas creadas de esta forma aparecen al final de la lista. Puede que tenga que arrastrarlas a una posición diferente de la lista para colocarlas en un orden lógico.
**Orden de las variables**
Para cambiar el orden de las variables en la lista de variables del panel de control, haga clic en las flechas arriba y abajo situadas a la derecha de cada entrada. Grafana muestra los menús desplegables de variables de izquierda a derecha según esta lista, con la variable de la parte superior en el extremo izquierdo.
+ Enumere las variables que no tienen dependencias en la parte superior, antes de sus variables secundarias.
+ Cada variable debe seguir a la variable de la que depende.
+ Recuerde que en la interfaz de usuario no se indica qué variables tienen relaciones de dependencia. Enumere las variables en un orden lógico para facilitar la tarea a otros usuarios (y a usted).
**Consideraciones sobre la complejidad**
Cuantos más niveles de dependencia haya en las variables, más tiempo tardará en actualizar los paneles de control después de cambiar las variables.
Por ejemplo, si tiene una serie de cuatro variables vinculadas (país, región, servidor y métrica) y cambia el valor de una variable raíz (país), Grafana debe ejecutar consultas para todas las variables dependientes antes de actualizar las visualizaciones en el panel de control.
## Administración de variables
La página de variables le permite [agregar](https://grafana.com/docs/grafana/latest/dashboards/variables/add-template-variables/) variables y administrar las variables existentes. También le permite [inspeccionar](https://grafana.com/docs/grafana/latest/dashboards/variables/inspect-variable/) las variables e identificar si una variable se utiliza o se hace referencia a ella en otras variables o en el panel de control.
**Mover**: para mover una variable hacia arriba o hacia abajo en la lista, arrástrela y suéltela.
**Clonar**: para clonar una variable, haga clic en el icono de clonación del conjunto de iconos de la derecha. Esto crea una copia de la variable con el nombre de la variable original con el prefijo `copy_of_`.
**Eliminar**: para eliminar una variable, haga clic en el icono de la papelera del conjunto de iconos de la derecha.
## Filtrado de variables con expresiones regulares
Con la opción Consulta de expresiones regulares, se filtra la lista de opciones devuelta por la consulta de variables o se modifican las opciones devueltas.
En esta página, se muestra cómo usar expresiones regulares para filter/modify los valores del menú desplegable de variables.
Con la opción Consulta de expresiones regulares, se filtra la lista de opciones devuelta por la consulta de variables o se modifican las opciones devueltas. Para obtener más información, consulte la guía de Mozilla sobre [expresiones regulares](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions).
Los siguientes ejemplos muestran el filtrado en la siguiente lista de opciones:
```
backend_01
backend_02
backend_03
backend_04
```
**Filtrado para que solo se devuelvan las opciones que terminan en `01` o `02`**
Expresión regular:
```
/
(
01|02
)
$/
```
Resultado:
```
backend_01
backend_02
```
**Filtrado y modificación de las opciones mediante un grupo de captura de expresiones regulares para devolver parte del texto**
Expresión regular:
```
/.*
(
01|02
)
/
```
Resultado:
```
01
02
```
**Filtrado y modificación: ejemplo de Prometheus**
Lista de opciones:
```
up{instance="demo.robustperception.io:9090",job="prometheus"} 1 1521630638000
up{instance="demo.robustperception.io:9093",job="alertmanager"} 1 1521630638000
up{instance="demo.robustperception.io:9100",job="node"} 1 1521630638000
```
Expresión regular:
```
/. *instance="
(
[^"]*
)
.*/
```
Resultado:
```
demo.robustperception.io:9090
demo.robustperception.io:9093
demo.robustperception.io:9100
```
**Filtrado y modificación mediante grupos de captura de valores y texto con nombre asignado**
Al usar grupos de captura con nombre, puede capturar partes separadas de “texto” y “valor” de las opciones devueltas por la consulta de variables. Esto permite que la lista desplegable de variables contenga un nombre descriptivo para cada valor que se pueda seleccionar.
Por ejemplo, al consultar la métrica `node_hwmon_chip_names` de Prometheus, `chip_name` es mucho más fácil de recordar que el valor `chip`. Por lo tanto, el siguiente resultado de la consulta variable:
```
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_0",chip_name="enp216s0f0np0"} 1
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_1",chip_name="enp216s0f0np1"} 1
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_2",chip_name="enp216s0f0np2"} 1
node_hwmon_chip_names{chip="0000:d7:00_0_0000:d8:00_3",chip_name="enp216s0f0np3"} 1
```
Pasó por la siguiente expresión regular:
```
/chip_name="(?[ ^ " ] + ) |chip=" (?[ ^ " ] + )/g
```
Produciría la siguiente lista desplegable:
```
Display Name Value
------------ -------------------------
enp216s0f0np0 0000:d7:00_0_0000:d8:00_0
enp216s0f0np1 0000:d7:00_0_0000:d8:00_1
enp216s0f0np2 0000:d7:00_0_0000:d8:00_2
enp216s0f0np3 0000:d7:00_0_0000:d8:00_3
```
Solo se admiten los nombres de los grupos de captura `text` y `value`.
##
La página de variables le permite identificar fácilmente si una variable se utiliza o se hace referencia a ella en otras variables o en el panel de control.
Todas las variables a las que se hace referencia o se utilizan tienen una marca de verificación verde junto a ellas, mientras que las variables no referenciadas tienen un icono de precaución naranja junto a ellas. Además, todas las variables a las que se hace referencia tienen un icono de dependencia junto a la marca de verificación verde. Puede seleccionar el icono para ver el mapa de dependencia. El mapa de dependencia se puede mover. Puede acercar o alejar la imagen con la rueda del ratón o una herramienta similar.
# Sintaxis de variable
****
Este tema de documentación está diseñado para los espacios de trabajo de Grafana que admiten la **versión 9.x de Grafana**.
Para los espacios de trabajo de Grafana que admiten la versión 10.x de Grafana, consulte [Uso de la versión 10 de Grafana](using-grafana-v10.md).
Para los espacios de trabajo de Grafana que admiten la versión 8.x de Grafana, consulte [Uso de la versión 8 de Grafana](using-grafana-v8.md).
Los títulos de los paneles y las consultas de las métricas pueden ver las variables mediante dos sintaxis distintas.
+ `$varname`: esta sintaxis es más fácil de leer, pero no permite utilizar una variable en medio de una palabra.
**Ejemplo**: `apps.frontend.$server.requests.count`
+ `${var_name}`: utilice esta sintaxis cuando desee usar una variable en medio de una expresión.
+ `${var_name:}`: este formato le da más control sobre cómo Grafana interpreta los valores. Para obtener más información, consulte *Opciones avanzadas de formato de variables*.
+ `[[varname]]`: no la utilice. Esta sintaxis es antigua y no está disponible. Se habilitará en una versión futura.
Antes de enviar las consultas al origen de datos, la consulta se *interpola*, lo que significa que la variable se reemplaza por su valor actual. Durante la interpolación, es posible que el valor de la variable se *escape* para ajustarlo a la sintaxis del lenguaje de consulta y al lugar en el que se utiliza. Por ejemplo, una variable que se utilice en una expresión regular en una consulta de InfluxDB o Prometheus tendrá un escape de expresiones regulares.
**Opciones avanzadas de formato de variables**
El formato de la interpolación de variables depende del origen de datos, pero hay algunas situaciones en las que es posible que quiera cambiar el formato predeterminado.
Por ejemplo, el valor predeterminado del origen de datos de MySQL es unir varios valores separados por comas entre comillas: `'server01','server02'`. En algunos casos, es posible que quiera que haya una cadena separada por comas sin comillas: `server01,server02`. Puede hacer que eso suceda con las opciones avanzadas de formato de variables que se enumeran a continuación.
**Sintaxis general**
Sintaxis: `${var_name:option}`
Si se especifica alguna opción de formato no válida, entonces `glob` es la default/fallback opción.
**CSV**
Formatea las variables con varios valores como una cadena separada por comas.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:csv}'
Interpolation result: 'test1,test2'
```
**Distribuida: OpenTSDB**
Formatea las variables con varios valores en un formato personalizado para OpenTSDB.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:distributed}'
Interpolation result: 'test1,servers=test2'
```
**Doublequote**
Formatea las variables de uno o varios valores en una cadena separada por comas, escapa `"` en cada valor por `\"` y cita cada valor con `"`.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:doublequote}'
Interpolation result: '"test1","test2"'
```
**Glob: Graphite**
Formatea las variables con varios valores en un patrón glob (para consultas de Graphite).
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:glob}'
Interpolation result: '{test1,test2}'
```
**JSON**
Formatea las variables con varios valores como una cadena separada por comas.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:json}'
Interpolation result: '["test1", "test2"]'
```
**Lucene: Elasticsearch**
Formatea variables con varios valores en formato Lucene para Elasticsearch.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:lucene}'
Interpolation result: '("test1" OR "test2")'
```
**Percentencode**
Formatea las variables de un solo valor y de varios valores para utilizarlas en los parámetros de URL.
```
servers = [ 'foo()bar BAZ', 'test2' ]
String to interpolate: '${servers:percentencode}'
Interpolation result: 'foo%28%29bar%20BAZ%2Ctest2'
```
**Pipe**
Formatea las variables con varios valores en una cadena separada por canalizaciones.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:pipe}'
Interpolation result: 'test1.|test2'
```
**Raw**
Desactiva el formato específico del origen de datos, como las comillas simples en una consulta SQL.
```
servers = [ 'test.1', 'test2' ]
String to interpolate: '${var_name:raw}'
Interpolation result: 'test.1,test2'
```
**Regex**
Formatea las variables con varios valores en una cadena de expresiones regulares.
```
servers = [ 'test1.', 'test2' ]
String to interpolate: '${servers:regex}'
Interpolation result: '(test1\.|test2)'
```
**Singlequote**
Formatea las variables de uno o varios valores en una cadena separada por comas, escapa `'` en cada valor por `\'` y cita cada valor con `'`.
```
servers = [ 'test1', 'test2' ]
String to interpolate: '${servers:singlequote}'
Interpolation result: "'test1','test2'"
```
**Sqlstring**
Formatea las variables de uno o varios valores en una cadena separada por comas, escapa `'` en cada valor por `''` y cita cada valor con `'`.
```
servers = [ "test'1", "test2" ]
String to interpolate: '${servers:sqlstring}'
Interpolation result: "'test''1','test2'"
```
**Text**
Formatea las variables de un solo valor y de varios valores para incluirlas en su representación textual. Para una sola variable, simplemente devolverá la representación de texto. Para las variables con varios valores, devolverá la representación de texto combinada con `+`.
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:text}'
Interpolation result: "test1 + test2"
```
**Parámetros de consulta**
Formatea las variables de un solo valor y de varios valores para incluirlas en su representación de parámetro de consulta. Ejemplo: `var-foo=value1&var-foo=value2`
```
servers = [ "test1", "test2" ]
String to interpolate: '${servers:queryparam}'
Interpolation result: "var-servers=test1&var-servers=test2"
```