> For the complete documentation index, see [llms.txt](https://docs.realmjoin.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.realmjoin.com/es/automatizacion/runbooks/runbook-customization.md).

# Personalización de Runbook

Adapta los runbooks genéricos de RealmJoin a las necesidades de tus entornos.

## Resumen

La implementación de runbooks de RealmJoin ofrece capacidades de personalización al autor de un runbook o al administrador de un entorno, de modo que puedan:

* Alojar parámetros y plantillas específicos del cliente/Tenant
* Ofrecer elementos de UI como selectores de usuario o selecciones desplegables
* Presentar explicaciones legibles para humanos de los parámetros
* Ocultar elementos de UI innecesarios

<figure><img src="https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2FmVmZrDFgG1ShkZlo1Fbe%2Fimage.png?alt=media&amp;token=39876732-3578-41d2-acf1-8571bb941e68" alt=""><figcaption></figcaption></figure>

Las personalizaciones pueden incluirse en el propio runbook y/o almacenarse en la instancia del Portal RealmJoin del cliente. Por defecto, intentaremos ofrecer valores predeterminados sensatos en los runbooks ofrecidos en [GitHub](https://github.com/realmjoin/realmjoin-runbooks).

Algunos runbooks vendrán con ejemplos de cómo configurar plantillas específicas del cliente, como especificar ubicaciones de Office para la incorporación del usuario.

### Formato

La personalización puede definirse (en orden descendente de prioridad)

* Bloque de JSON en [configuración del Portal RealmJoin](https://portal.realmjoin.com/settings/runbooks-customizations), sobrescribiendo el comportamiento predeterminado del runbook
* Bloque de JSON en el encabezado de un runbook

Además (con la menor prioridad)

* por parámetro en el encabezado del runbook
* por parámetro en el bloque de parámetros del runbook (usando el módulo auxiliar RJRb)

Algunas funciones (como las plantillas) solo están disponibles en formato JSON. Algunas funciones (como crear un selector de usuario) solo están disponibles especificando un tipo de dato en el bloque de parámetros. Puedes combinar varios tipos de personalizaciones para obtener los mejores resultados.

## Bloque de parámetros del runbook

El Portal RealmJoin analiza el bloque de parámetros PowerShell de un runbook para determinar qué campos de entrada mostrar. Cuando sea posible, también validará las entradas según el tipo .NET dado para una variable.

Actualmente se entienden los siguientes tipos de datos:

* `[bool]`, `[boolean]` - presentará un interruptor binario
* `[string]` - presentará un cuadro de texto para escribir cualquier entrada alfanumérica
* `[int]` - presentará un cuadro de texto, permitiendo solo entradas numéricas
* `[DateTime]`, `[DateTimeOffset]` - mostrará un selector de fecha/hora

Puedes aplicar modificadores estándar de PowerShell a los parámetros. RealmJoin Portal, en particular, entenderá si especificas `[Parameter(Mandatory = $true)]` para indicar un parámetro obligatorio y exigir que estos parámetros se rellenen.

Cuando sea posible, RealmJoin Portal también leerá y presentará los valores predeterminados dados en la UI.

Ten en cuenta que los valores predeterminados del runbook pueden ser sobrescritos por las personalizaciones. Además, los parámetros pueden ocultarse por completo mediante personalizaciones.

### Personalización de parámetros

Para poder personalizar parámetros, asegúrate de incluir el módulo PS auxiliar de Runbook de RealmJoin en tu runbook:

`#Requires -Modules @{ModuleName = "RealmJoin.RunbookHelper"; ModuleVersion = "0.6.0" }`

Entonces puedes incluir `[ValidateScript( { Use-RJInterface ... } )]` instrucciones en las definiciones de parámetros. Por ejemplo, lo siguiente creará un selector de usuario, permitiendo elegir un usuario de Entra ID y pasará su object id como cadena al runbook.

```powershell
param(
    [ValidateScript( { Use-RJInterface -DisplayName "Asignar este dispositivo a este usuario (opcional)" -Type Graph -Entity User } )]
    [string] $AssignedUserId = ""
)
```

Vamos a desglosarlo paso a paso. `[ValidateScript...]` es un modificador del siguiente parámetro definido en el bloque param. En este caso la variable `$AssignedUserId`.

`Use-RJInterface` forma parte de nuestro [RealmJoin Runbook Helper](https://github.com/realmjoin/RealmJoin.RunbookHelper) módulo de PowerShell. Te permite especificar qué tipo de entrada esperas usando `-Type` y `-Entity`, si eso no está ya completamente definido por el tipo de variable.

`-DisplayName` te permite pasar a RealmJoin Portal una indicación / descripción legible para humanos de este parámetro.

#### Recursos de Graph

En el ejemplo anterior, la fuente de información es MS Graph, como se describe mediante `-Type Graph`. Para MS Graph, usa `-Entity` para especificar qué tipo de recurso esperas. Las entidades disponibles son `User`, `Grupo`, `Dispositivo`. Esto producirá un selector para usuarios, grupos o dispositivos en el Tenant de Entra ID dado.

El selector incluye una búsqueda rápida, para localizar fácilmente el recurso requerido.

![Ejemplo de selector](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-0c393c4ea73a77b34da2c678b0712a6556ed3bc2%2Frunbook-customization-img2.png?alt=media)

Actualmente, no es posible hacer multiselección usando un selector.

Por defecto, un selector de MS Graph devolverá el ID del objeto. Si necesitas, por ejemplo, el nombre principal de usuario en su lugar, asegúrate de incluir "name" como sufijo en el nombre de tu variable. Así que, básicamente, para obtener el id de un usuario, nombra el parámetro `$userid`. Si quieres un UPN, nómbralo `$username`.

#### Filtrado de Graph

Si estás usando un selector basado en MS Graph, también puedes especificar `-Filter` y usar un [filtro ODATA](https://docs.microsoft.com/en-us/graph/query-parameters?context=graph%2Fapi%2F1.0\&view=graph-rest-1.0#filter-parameter) para limitar los objetos ofrecidos en el selector.

El siguiente ejemplo listará solo grupos de Entra ID que comiencen con "LIC\_".

```powershell
param(
    [Parameter(Mandatory = $true)]
    [ValidateScript( { Use-RJInterface -Type Graph -Entity Group -Filter "startswith(DisplayName, 'LIC_')" -DisplayName "Grupo de licencias" } )]
    [String] $GroupID_License
)
```

Puedes preparar filtros y reutilizarlos en varios scripts usando el [almacén de datos central](#graph-filters). En este caso, solo referencia el filtro por nombre usando `-Filter "ref:LicenseGroup"`, donde `ref:` indica que se debe buscar un filtro almacenado.

```powershell
param(
    [Parameter(Mandatory = $true)]
    [ValidateScript( { Use-RJInterface -Type Graph -Entity Group -Filter "ref:LicenseGroup" } )]
    [String] $GroupID_License
)
```

Este ejemplo específico `ref:LicenseGroup` está disponible por defecto sin configuración adicional.

![filtro ODATA](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-4913ddfbc3324fc7a3522de2bc6887e8d2745e35%2Frunbook-customization-img3.png?alt=media)

## Encabezado del runbook

El Portal puede analizar la sección de [ayuda basada en comentarios](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_comment_based_help?view=powershell-5.1) , si existe.

Aquí hay un ejemplo:

```powershell
<#
  .SINOPSIS
  (Des)asignar una licencia a un usuario mediante la pertenencia a un grupo.

  .DESCRIPTION
  (Des)asignar una licencia a un usuario mediante la pertenencia a un grupo. Descripción más detallada...

  .PARAMETER DefaultGroups
  Lista de grupos separada por comas para asignar. p. ej. "DL Sales,LIC Internal Product"

  .NOTAS
  Permisos:
  MS Graph (API):
  - User.Read.All
  - GroupMember.ReadWrite.All 
  - Group.ReadWrite.All

  .INPUTS
  RunbookCustomization: {
        "Parameters": {
            "UserName": {
                "Hide": true
            },
            "Remove": {
                "DisplayName": "Asignar o quitar licencia",
                "SelectSimple": {
                    "Assign License to User": false,
                    "Remove License from User": true
                }
            }
        }
    }
#>
```

`.SINOPSIS` - Da una descripción muy breve de la función de tu runbook. Se mostrará en la lista de runbooks disponibles.

`.DESCRIPTION` - Da una descripción de la función de tu runbook. Puede contener un poco más de detalle, ya que se mostrará dentro del diálogo de ejecución/parámetros de los runbooks.

`.PARAMETER` - Debe ir seguido del nombre de un parámetro. Te permite dar una explicación detallada de la entrada esperada para el parámetro en cuestión.

`.INPUTS` - Puede contener un bloque de personalización de runbook basado en JSON.

`.NOTAS` - No se analiza / renderiza. Usa este espacio para anotar qué permisos y requisitos existen para tu runbook.

`.EXAMPLE` - No se analiza / renderiza. Puede contener un ejemplo de una personalización basada en JSON para usar en el almacén de datos RealmJoin de tu Tenant. Estos pueden ser ejemplos de cómo crear plantillas, por ejemplo para distintos flujos de trabajo o clases de usuario.

## Personalización basada en JSON

### Almacén de datos central

Cada tenant de Azure puede alojar un almacén de datos de "Runbook Customizations", que se encuentra en <https://portal.realmjoin.com/settings/runbooks-customizations> .

El formato es JSON con comentarios, permitiendo comas finales. Actualmente, hay tres secciones relevantes, `bloque Settings`, `Plantillas`, `Runbooks`.

```json
{
    "Settings": {
    },
    "Templates": {
    },
    "Runbooks": {
    }
}
```

### sección de runbooks

`Runbooks` es analizada por el portal al iniciar un runbook. Si existe una sección con el nombre del actual runbook de Azure Automation, su contenido se usará para personalizar el frontend mostrado al usuario.

Supón el siguiente runbook de demostración simple, llamado `rjgit-device_demo-runbook-customizing`.

```powershell
<#
  .SINOPSIS
  Demostrar personalización de runbooks

  .DESCRIPTION
  Demostrar personalización de runbooks, como desplegable/selección
#>

#Requires -Modules @{ModuleName = "RealmJoin.RunbookHelper"; ModuleVersion = "0.6.0" }

param(
    [string] $DeviceId,
    [bool] $ExtraWorkflow = $true,
    [int] $ExtraWorkflowTime = 15
)

"## Haciendo cosas al dispositivo '$DeviceID'"

# Flujo de trabajo altamente opcional y complicado
if ($ExtraWorkflow) {
    "## Ejecutando meditación..."
    Start-Sleep -Seconds $ExtraWorkflowTime
}
```

Si no se personaliza, se mostrará así en el frontend:

![Demo - antes](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-931b958f4b949268736f6ff3f174913cf56adcf7%2Frunbook-customization-img4.png?alt=media)

Reflexiones:

* Como este runbook se inicia desde el contexto de un dispositivo en el portal, el `$DeviceId` es información redundante para un usuario. Ya sé en qué dispositivo estoy trabajando.
* ¿Qué pasa si activo o desactivo el "Flujo de trabajo adicional"? ¿Necesito pensar en el "Tiempo del flujo de trabajo adicional" si desactivo el "Flujo de trabajo adicional"?

Mejorémoslo. El siguiente JSON de ejemplo en el almacén de datos central modificará la UI para el runbook.

```json
{
    "Runbooks": {
        "rjgit-device_demo-runbook-customizing": {
            "ParameterList": [
                {
                    "Name": "DeviceId",
                    "Hide": true
                }, 
                {
                    "Name": "ExtraWorkflow",
                    "Hide": true
                },
                {
                    "Name": "ExtraWorkflowTime",
                    "DisplayName": "¿Cuánto tiempo meditar?",
                },
                {
                    "DisplayName": "Ejecutar flujo de trabajo adicional",
                    "DisplayBefore": "ExtraWorkflowTime",
                    "Select": {
                        "Options": [
                            {
                                "Display": "Ejecutar meditación (opcional)",
                                "Customization": {
                                    "Default": {
                                        "ExtraWorkflow": true
                                    }
                                }
                            },
                            {
                                "Display": "Saltar la atención plena del dispositivo",
                                "Customization": {
                                    "Default": {
                                        "ExtraWorkflow": false
                                    },
                                    "Hide": [
                                        "ExtraWorkflowTime"
                                    ]
                                }
                            }
                        ],
                        
                    },
                    "Default": "Saltar la atención plena del dispositivo"
                }
            ]
        }
    }
}
```

Puedes usar la misma notación / funciones en tu [encabezado del runbook](#runbook-header).

#### Lista de parámetros

Cada parámetro tiene su propia sección en `Lista de parámetros`. [Los modificadores](#modifiers) permiten cambiar el comportamiento de ese parámetro.

El resultado se verá así:

![Demo - después oculto](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-4ae4e681371ad29f076063c5f1925a0cb8113872%2Frunbook-customization-img5.png?alt=media)

Elegir el flujo de trabajo adicional mostrará (desocultará) más parámetros:

![Demo - después desoculto](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-7960cf8309d8bbdf12ab1539c073714211715411%2Frunbook-customization-img6.png?alt=media)

Esto muestra menos desorden en comparación con antes de aplicar la personalización. Al mismo tiempo, hay más información disponible para el usuario sobre las alternativas de "Flujo de trabajo adicional". Además, ahora el usuario solo se preocupará por "Tiempo del flujo de trabajo adicional" si es relevante.

Cambiar la visibilidad de ese campo se hizo usando un `"Personalización"` bloque dentro de una de las opciones de `"Select"` . Actualmente puedes tener como máximo un bloque de este tipo activo a la vez. `"Personalización"` Como puedes ver, el parámetro

está completamente oculto. Esto se hace estableciendo el `$DeviceId` para este parámetro. `"Hide": true` Los parámetros pueden tener un

. Ofrecimos un `DisplayName`amigable para humanos `DisplayName` para reemplazar `$ExtraWorkflowTime` en la UI. Consulta otros [modificadores](#modifiers) para más información.

Puedes insertar parámetros "sin nombre" (faltando la `Nombre` instrucción) como la sección "Ejecutar flujo de trabajo adicional", si quieres ofrecer elementos de UI sin devolver directamente un valor. Esto normalmente solo se usa junto con `Seleccione`.

#### Seleccione

Usamos `Seleccione`, para mostrar una lista de `Opciones` en un desplegable. Cada opción puede `mostrar` texto, o activar una `Personalización`, como establecer `Ocultar` o un `Predeterminado` valor en otros parámetros. En nuestro ejemplo, lo usamos para (des)ocultar `$ExtraWorkflowTime` y sobrescribir `$ExtraWorkflow`su valor.

`$ExtraWorkflowTime` por lo tanto, solo se muestra cuando es relevante y el interruptor binario `$ExtraWorkflow` ahora se reemplaza por alternativas significativas desde la perspectiva de un usuario.

En caso de un `Seleccione` para un parámetro con nombre, cada opción debe tener un `"ParameterValue": "..."` que pasar al runbook. Puedes colocar un `"ShowValue: false"` dentro del `Seleccione` bloque para mostrar solo el desplegable y no un campo para el valor resultante del parámetro.

Ejemplo de parámetro con nombre:

```json
{
    "Name": "ExtraWorkflow",
    "DefaultValue": true,
    "DisplayName": "Ejecutar flujo de trabajo adicional",
    "DisplayBefore": "ExtraWorkflowTime",
    "Select": {
        "Options": [
            {
                "Display": "Ejecutar meditación (opcional)",
                "ParameterValue": true
            },
            {
                "Display": "Saltar la atención plena del dispositivo",
                "ParameterValue": false,
                "Customization": {
                    "Hide": [
                        "ExtraWorkflowTime"
                    ]
                }
            }
        ],
        "ShowValue": false
    }
}
```

Los `Predeterminado` / `DefaultValue` instrucción en el parámetro también especifica el estado inicial del desplegable. En caso de un parámetro sin nombre, usa el `DisplayName` de la opción deseada, de lo contrario da un valor de retorno predeterminado, como "true" o "false" o alguna cadena.

#### Parámetros

Si solo tienes parámetros con nombre, puedes usar el formato ligeramente más corto `Parámetros` en lugar de `Lista de parámetros`.

Para un ejemplo, consulta SelectSimple

#### SelectSimple

Si no se necesita todo el poder de un `Seleccione` y solo quieres ofrecer una lista de valores posibles en un desplegable (sin aplicar personalización adicional), puedes usar `SelectSimple`.

`SelectSimple` solo es utilizable para parámetros con nombre.

Ejemplo:

```json
{
    "Runbooks": {
        "rjgit-device_demo-runbook-customizing": {
            "Parameters": {
                "DeviceId": {
                    "Hide": true
                }, 
                "ExtraWorkflow": {
                    "Name": "ExtraWorkflow",
                    "DisplayName": "Ejecutar flujo de trabajo adicional",
                    "Default": false,
                    "SelectSimple": {
                        "Execute Meditation (optional)": true,
                        "Skip Device Mindfulness": false
                    }
                },
                "ExtraWorkflowTime": {
                    "DisplayName": "¿Cuánto tiempo meditar?"
                }
            }
        }
    }
}
```

La mayor diferencia (aparte de ser mucho más corto) con nuestro ejemplo anterior es que `$ExtraWorkflowTime` siempre es visible.

#### Los modificadores

Cada parámetro puede tener uno o más de los siguientes modificadores:

* `"DisplayName": "texto"` - Mostrar "texto" como nombre del parámetro en la UI
* `"Hide": true / false` - Ocultar este parámetro
* `"Mandatory": true / false` - Requerir que este parámetro se rellene
* `"ReadOnly": true / false` - Proteger este parámetro para que no se cambie de su valor predeterminado
* `"DefaultValue": "..."` - Establecer un valor predeterminado para este parámetro. (También puedes usar `Predeterminado` en su lugar.)
* `"GraphFilter": "startswith(DisplayName, 'LIC_')"` - ver [Filtrado de Graph](#graph-filtering)
* `"AllowEdit": true / false` - Proteger este parámetro de la edición manual. (combínalo con plantillas)

### bloque Settings

`bloque Settings` te permite almacenar datos de configuración como nombres de Azure Storage Account en un lugar central, manteniéndolos separados de tus runbooks.

Puedes acceder a valores individuales de un bloque de parámetros de runbook usando `Use-RJInterface`.

Tomemos este ejemplo de bloque de parámetros de un runbook:

```powershell
param(
    [ValidateScript( { Use-RJInterface -Type Setting -Attribute "RJReport.StorageAccount.ResourceGroup" } )]
    [string] $ResourceGroupName,
    [ValidateScript( { Use-RJInterface -Type Setting -Attribute "RJReport.StorageAccount.StorageAccountName" } )]
    [string] $StorageAccountName,
    [ValidateScript( { Use-RJInterface -Type Setting -Attribute "RJReport.StorageAccount.LinkExpiryDays" } )]
    [int] $LinkExpiryDays = 6
)
```

El Portal intentará rellenar previamente cada parámetro con valores del almacén de datos central, si los hay. Esto también funciona si el parámetro ha sido ocultado en la UI.

Un posible JSON en el almacén de datos para este runbook sería:

```json
{
    "Settings": {
        "RJReport": {
            "StorageAccount": {
                "ResourceGroup": "rj-runbooks-01",
                "StorageAccountName": "rjrbexports01"
            }
        }
    }
}
```

El `LinkExpiryDays` elemento que falta simplemente no se rellenará previamente en la UI, por lo que el parámetro conserva su valor predeterminado de `6`.

Un bloque de runbook en la `Runbooks` sección puede contener su propio `bloque Settings`. Para cada valor, el portal mira ahí primero y solo después en el `bloque Settings`global, para que los runbooks individuales puedan usar valores diferentes. Ver [Use una Storage Account diferente para runbooks individuales](https://docs.realmjoin.com/es/automatizacion/runbooks/runbook-report-settings.md#use-a-different-storage-account-for-individual-runbooks) para un ejemplo.

### Plantillas

`Plantillas` usar referencias JSON para extraer datos - por ejemplo, una larga lista de ubicaciones de Office - cuando uses una `Seleccione` instrucción.

Esto permite mantener una personalización neutral/reutilizable/separada de los datos reales.

Tomemos el ejemplo de la incorporación de nuevos usuarios. Podrías tener múltiples opciones dadas para departamentos o ubicaciones de Office, donde asignar una ubicación de Office también exige una determinada dirección postal, país, estado, etc.

El siguiente ejemplo de personalización de un runbook usa la `$ref` dentro del `Runbooks` sección para referenciar/importar un subárbol desde la sección `Plantillas` . Observa las palabras clave `$id`/`$values` . Ten en cuenta que `$id`/`$values` tienen que definirse antes de referenciarlas usando `$ref`. Por eso `Plantillas` se define antes que `Runbooks` en este ejemplo.

En este ejemplo le decimos al portal que tome el subárbol con el `$id` llamado `LocationOptions` e incluya sus `$values`, reemplazando la `$ref` instrucción. Así, el portal renderizará un `Seleccione` tal como se describe en la sección `Runbooks` pero incluirá las opciones reales de `Plantillas`.

Una plantilla puede contener cualquier instrucción que sea compatible en la ubicación de referencia. En este ejemplo, usamos una `Personalización` instrucción para modificar otros parámetros como `StreetAddress`.

Así, podemos tener una personalización específica del runbook en `Runbooks` reutilizable entre varios entornos, manteniendo los datos reales separados.

```json
{
    "Templates": {
        "Options": [
            {
                "$id": "LocationOptions",
                "$values": [
                    {
                        "Display": "DE-OF",
                        "Customization": {
                            "Default": {
                                "StreetAddress": "Kaiserstraße 39",
                                "PostalCode": "63065",
                                "City": "Offenbach",
                                "Country": "Germany"
                            }
                        }
                    },
                    {
                        "Display": "DE-DEG",
                        "Customization": {
                            "Default": {
                                "StreetAddress": "Lateinschulgassse 24-26",
                                "PostalCode": "94469",
                                "City": "Deggendorf",
                                "Country": "Germany"
                            }
                        }
                    },
                    {
                        "Display": "DE-HH",
                        "Customization": {
                            "Default": {
                                "StreetAddress": "Hans-Henny-Jahnn-Weg 53",
                                "PostalCode": "22085",
                                "City": "Hamburg",
                                "Country": "Germany"
                            }
                        }
                    },
                    {
                        "Display": "FI-HS",
                        "Customization": {
                            "Default": {
                                "StreetAddress": "Somewhere 42",
                                "PostalCode": "12345",
                                "City": "Helsinki",
                                "Country": "Finland"
                            }
                        }
                    }
                ]
            },
            {
                "$id": "CompanyOptions",
                "$values": [
                    {
                        "Id": "gkg",
                        "Display": "glueckkanja",
                        "Value": "glueckkanja AG"
                    },
                    {
                        "Id": "pp",
                        "Display": "PRIMEPULSE",
                        "Value": "PRIMEPULSE SE"
                    }
                ]
            }
        ]
    },
    "Runbooks": {
        "rjgit-org_general_add-user": {
            "ParameterList": [
                {
                    "DisplayName": "Ubicación de Office",
                    "DisplayAfter": "CompanyName",
                    "Select": {
                        "Options": {
                            "$ref": "LocationOptions"
                        }
                    }
                },
                {
                    "Name": "CompanyName",
                    "Select": {
                        "Options": {
                            "$ref": "CompanyOptions"
                        },
                        "AllowEdit": false
                    }
                }
            ],
            "ReadOnly": [
                "StreetAddress",
                "PostalCode",
                "City",
                "Country"
            ]
        }
    }
}
```

Esto creará la siguiente UI:

![Demo - ref-location](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-93295541748dcc12dbc72208851138efd0808d51%2Frunbook-customization-img7.png?alt=media)

![Demo - ref-address](https://3832142177-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MkrcM7cKOpXKri1kVrh%2Fuploads%2Fgit-blob-11e2812670e56cf10bb03fe7588059d232a8addf%2Frunbook-customization-img8.png?alt=media)

### Filtros de Graph

Puedes preparar [filtros de Graph ODATA](https://docs.microsoft.com/en-us/graph/query-parameters?context=graph%2Fapi%2F1.0\&view=graph-rest-1.0#filter-parameter) para usarlos en varios runbooks. Almacénalos en una sección llamada `Filtros de Graph`.

El siguiente ejemplo filtra por un cierto prefijo en el `DisplayName` de un grupo, para mostrar solo los grupos relacionados con licencias en un selector de grupos.

```json
"Filtros de Graph": {
    "LicenseGroup": "startswith(DisplayName, 'LIC_')" // también incluido en el código RJ como predeterminado
  }
```

Consulta [Filtrado de Graph](#graph-filtering) sobre cómo usar esto desde un runbook.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.realmjoin.com/es/automatizacion/runbooks/runbook-customization.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
