Checkmk
DeutschEnglish
master2.3.0
to checkmk.com
Important

This is a machine translation based on the English version of the article. It might or might not have already been subject to text preparation. If you find errors, please file a GitHub issue that states the paragraph that has to be improved.

1. Introducción

CEE En las ediciones comerciales puedes usar la API de Bakery para escribir tus propios complementos de Bakery, que incluyen funciones en los paquetes de agentes de Agent Bakery. En la mayoría de los casos, estas funciones son complementos de agente, es decir, scripts adicionales que ejecuta el agente de Checkmk, y los archivos de configuración de los complementos. Sin embargo, también pueden afectar a las funciones del gestor de paquetes si se pueden asignar mediante la inclusión de archivos, la ejecución de scriptlets de paquetes (para los formatos de paquete RPM, DEB y Solaris PKG), o si definen entradas de configuración específicas para el agente de Windows (en YAML). Todos estos «artefactos» se pueden describir en la API de Bakery utilizando una sintaxis uniforme.

Por ejemplo, un escenario de aplicación real es el siguiente: Has leído la introducción al desarrollo de extensiones para Checkmk y, inspirado por ella, has escrito tu propio complemento de comprobación basado en agente con su complemento de agente asociado. A continuación, has combinado estos dos en un único paquete de extensión de Checkmk (MKP).

Ahora quieres que el complemento de agente sea configurable (por ejemplo, permitir que solo lo ejecuten determinados usuarios o en determinados hosts) y, además, realizar acciones al instalar o desinstalar el paquete del agente. Para ello, puedes utilizar la API de Bakery —como ayuda para el empaquetado y la distribución—, tal y como mostraremos en este artículo con un escenario de ejemplo. Esto crea dos archivos nuevos, que luego se pueden empaquetar junto con los archivos del complemento existentes para crear un nuevo MKP. También puedes encontrar un ejemplo muy bien comentado de este procedimiento en Checkmk Exchange: el MKP «Hello world!» (desempaquetado en GitHub), que se basa en gran medida en el escenario de ejemplo presentado en este artículo.

Ten en cuenta que la API de Bakery no ofrece funciones para configurar el complemento de Bakery, es decir, para crear el conjunto de reglas asociado, ni para el contenido de los archivos que se incluyen con el complemento, como los complementos de agente.

Tip

Aunque Agent Bakery solo está incluido en las ediciones comerciales, la API de Bakery existe en todas las ediciones desde Checkmk 2.3.0. Esto permite a los usuarios de Checkmk Community crear paquetes de extensión que se pueden instalar en todas las ediciones. Si los paquetes creados con la API de Bakery se instalan en una Checkmk Community, la funcionalidad adicional simplemente se ignora.

2. Documentación y control de versiones de la API

El software y la documentación de la API de Bakery provienen de la misma fuente. Esto garantiza que la documentación de la API siempre coincida con el software y describa exactamente lo que la API puede hacer, por lo que no es necesario describir la parte de referencia de las funciones, clases, parámetros, etc. disponibles en la Guía del usuario de Checkmk. Por lo tanto, puedes encontrar la documentación de la API directamente en tu sitio de Checkmk. Si actualmente no tienes un sitio de Checkmk en funcionamiento, puedes ver una copia de la documentación de la API de Bakery en docs.checkmk.com/plugin-api.

2.1. Control de versiones

La API y su documentación se versionan mediante un sistema de numeración de dos niveles basado en los principios básicos de la especificación Semantic Versioning 2.x, con el formato X.Y, donde X representa una versión mayor y Y una versión menor. Una nueva versión menor contiene nuevas funciones compatibles con versiones anteriores. Por otro lado, una nueva versión mayor puede contener cambios que hagan que la API sea incompatible con la versión mayor anterior.

2.2. Historial de versiones y perspectivas

Cada complemento declara explícitamente la versión de la API en la que se basa al acceder a ella. A partir de Checkmk 2.0.0, la versión 1 es la versión actual de la API de Bakery, que se describe en este artículo.

Checkmk 2.5.0 introduce la versión 2 de la API de Bakery, inicialmente con el sufijo «unstable». Por lo tanto, las versiones 1 y 2 aún se pueden usar en paralelo en 2.5.0. Esto significa que los complementos creados de acuerdo con este artículo seguirán funcionando al menos en Checkmk 2.5.0, y muy probablemente también más allá de esa versión.

Tip

Dado que algunas rutas de importación de las API en las ediciones comerciales se han movido en Checkmk 2.5.0, es posible que tengas que modificar tus complementos. Este es el caso si, en contra de nuestras recomendaciones, estás utilizando importaciones absolutas en lugar de relativas. Cambia estas a importaciones relativas antes de probar tus complementos de Bakery con Checkmk 2.5.0.

La API de conjuntos de reglas utilizada para la configuración de los complementos de Bakery en la interfaz gráfica de Checkmk sigue su propio historial de versiones. Para esta parte de tus paquetes de extensión, consulta nuestro artículo sobre el desarrollo de complementos de comprobación basados en agentes.

3. Directrices de pruebas

Si estás desarrollando complementos de Bakery, te interesará probarlos con regularidad. Para que los cambios estén disponibles en Checkmk, hay que seguir dos pasos.

Primero, usa cmk-validate-plugins para asegurarte de que todos los complementos sean sintácticamente correctos y puedan ser cargados por Checkmk:

OMD[mysite]:~$ cmk-validate-plugins
Agent based plugins loading succeeded, Active checks loading succeeded, Special
agents loading succeeded, Rule specs loading succeeded, Rule specs forms
creation succeeded, Referenced rule specs validation succeeded, Loaded rule
specs usage succeeded
Copiar comando(s) al portapapeles
¡Comandos copiados correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

A continuación, reinicia tu sitio:

OMD[mysite]:~$ omd restart
Copiar comando(s) al portapapeles
¡Comandos copiados correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

En el caso de los complementos de Bakery, Checkmk ahora reconoce los nuevos archivos, pero no puede determinar los requisitos de compilación hasta que se hayan actualizado los números de versión MKP correspondientes. Dado que puede resultar muy tedioso incrementar constantemente los números de versión mientras se programa un complemento de Bakery, te recomendamos cambiar a la línea de comandos y utilizar allí el comando «cmk». El modificador «-f» fuerza la compilación del agente para «myserver123»:

OMD[mysite]:~$ cmk -fAv myserver123
Baking packages for targets myserver123:
...
Baking...linux_deb:baking...linux_rpm:baking...solaris_pkg:baking...
windows_msi:baking...linux_tgz:baking...solaris_tgz:baking...aix_tgz:baking
...
Copiar comando(s) al portapapeles
¡Comandos copiados correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Ahora puedes copiar el agente recién creado a un host e instalarlo allí para probar las extensiones que has añadido.

4. Uso de la API

4.1. Un ejemplo de escenario

Te mostraremos cómo usar la API con el siguiente ejemplo:

  • Se proporciona un complemento llamado «hello_world» para el agente de Checkmk.

  • El complemento del agente existe en tres variantes —para Linux, Solaris y Windows— y debe incluirse también en los paquetes del agente para estos tres sistemas operativos. Los archivos correspondientes también están disponibles y se llamanhello_world (para Linux),hello_world.solaris.ksh (para Solaris) yhello_world.cmd (para Windows).
    Los scripts de Python, shell y CMD son solo ejemplos. Un complemento del agente puede ser cualquier archivo ejecutable en el sistema de destino.
    En este contexto, no nos interesa el contenido real de los archivos. La función de los complementos de agente no es objeto de la API de Bakery. Puedes obtener más información al respecto en la introducción al desarrollo de tus propios complementos de comprobación basados en agentes .

  • Debería poder configurarse si la salida del complemento debe almacenarse en caché; es decir, en este caso, el agente solo volverá a ejecutar el complemento una vez que haya transcurrido el tiempo configurado (intervalo de ejecución).

  • El complemento se configura en el menú «Setup» a través de los ajustes de Agent Bakery con las variablesuser ycontent . El complemento de Linux lee la configuración del archivo de configuraciónhello_world.json , y el de Solaris la lee del archivohello_world.cfg . El complemento de Windows lee las entradashello_world.user yhello_world.content del archivo de configuración YAML del agente de Windows.
    En cada caso, el acceso a estos recursos debe implementarse en el complemento del agente y no lo gestiona la API de Bakery.

  • Para Linux y Solaris hay un programa adicional, some_binary, que debe incluirse. Se trata, por ejemplo, de un pequeño script de shell con el que se puede iniciar un complemento mediante un comando, independientemente del agente de Checkmk.

  • En Linux y Solaris, tras instalar el agente, se debe indicar en el syslog mediante una rutina del gestor de paquetes que se ha instalado hello_world. Tras desinstalar el agente, de forma análoga, debería registrarse en el syslog que hello_world ha sido desinstalado.
    En Linux son habituales los scripts postinst y prerm: en el script postinst se crea, por ejemplo, una caché y se inicia un daemon; en el script prerm se puede detener de nuevo el daemon y borrar la caché. Para más información sobre cómo usar maintainer scripts, consulta la documentación de Debian.

4.2. Creación de un conjunto de reglas

Para un complemento de Bakery debe haber un conjunto de reglas para la configuración, con el que se pueda configurar el complemento a través de la interfaz gráfica de usuario. En el caso más sencillo, el conjunto de reglas solo activa un complemento asignándolo a determinados hosts. La creación de un conjunto de reglas no forma parte de la API de Bakery. Puedes encontrar una introducción a este tema en el artículo «Desarrollar tus propios complementos de comprobación basados en agentes». Allí también se explican las convenciones de ruta para almacenar conjuntos de reglas.

Tip

Si quieres portar conjuntos de reglas que eran compatibles hasta Checkmk 2.3.0 a las nuevas interfaces de programación, abre este artículo de la Guía del usuario para la versión 2.2.0 en una nueva pestaña o ventana. Compáralo lado a lado con la sección correspondiente de este artículo. La configuración que se lleva a cabo es tan similar que la comparación puede servir fácilmente como ayuda para la portabilidad.

Un conjunto de reglas mínimo

Un ejemplo de un conjunto de reglas mínimo de este tipo, que solo activa la distribución de un complemento, podría tener el siguiente aspecto. Las clases importadas aquí son más amplias de lo necesario para cubrir también el ejemplo ampliado. La diferencia más notable con respecto al conjunto de reglas para los complementos de comprobación basados en agentes es el uso de la clase AgentConfig en lugar de CheckParameters.

~/local/lib/python3/cmk_addons/plugins/hello_world/rulesets/ruleset_hello_world_bakery.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Shebang only needed for editor!

from cmk.rulesets.v1 import Label, Title, Help
from cmk.rulesets.v1.form_specs import (
    BooleanChoice,
    DefaultValue,
    DictElement,
    Dictionary,
    String,
    TimeSpan,
    TimeMagnitude
)
from cmk.rulesets.v1.rule_specs import AgentConfig, HostCondition, Topic

def _parameter_form_bakery():
    return Dictionary(
        elements = {}
    )

rule_spec_hello_world_bakery = AgentConfig(
    name = "hello_world",
    title = Title("Hello bakery!"),
    topic = Topic.GENERAL,
    parameter_form = _parameter_form_bakery,
)
Copiar el contenido del archivo al portapapeles
¡Se ha copiado correctamente el contenido del archivo al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Un conjunto de reglas ampliado

Sin embargo, en el escenario de ejemplo, hemos especificado que se debe elegir un intervalo de ejecución y que se deben establecer las dos variables user y content. Estas variables se definen como claves en el conjunto de reglas Dictionary, que es devuelto por la función especificada como parameter_form.

~/local/lib/python3/cmk_addons/plugins/hello_world/rulesets/ruleset_hello_world_bakery.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Shebang only needed for editor!

from cmk.rulesets.v1 import Label, Title, Help
from cmk.rulesets.v1.form_specs import (
    BooleanChoice,
    DefaultValue,
    DictElement,
    Dictionary,
    String,
    TimeSpan,
    TimeMagnitude
)
from cmk.rulesets.v1.rule_specs import AgentConfig, HostCondition, Topic

def _parameter_form_bakery():
    return Dictionary(
        elements = {
            "user": DictElement(
                parameter_form = String(
                    title = Title("User for example plugin"),
                )
            ),
            "content": DictElement(
                parameter_form = String(
                    title = Title("The actual content"),
                )
            ),
            "interval": DictElement(
                parameter_form = TimeSpan(
                    title = Title("Run asynchronously"),
                    label = Label("Interval for collecting data"),
                    displayed_magnitudes = [TimeMagnitude.SECOND, TimeMagnitude.MINUTE],
                    prefill = DefaultValue(300.0),
                )
            )
        }
    )

rule_spec_hello_world_bakery = AgentConfig(
    name = "hello_world",
    title = Title("Hello bakery!"),
    topic = Topic.GENERAL,
    parameter_form = _parameter_form_bakery,
)
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Después de guardar el conjunto de reglas, comprueba que todos los complementos sean válidos:

OMD[mysite]:~$ cmk-validate-plugins
Agent based plugins loading succeeded, Active checks loading succeeded, Special
agents loading succeeded, Rule specs loading succeeded, Rule specs forms
creation succeeded, Referenced rule specs validation succeeded, Loaded rule
specs usage succeeded
Copiar comando(s) al portapapeles
¡Comandos copiados correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

A continuación, reinicia tu sitio:

OMD[mysite]:~$ omd restart
Copiar comando(s) al portapapeles
¡Comandos copiados correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

El conjunto de reglas ahora será visible en la interfaz de Checkmk. La interfaz gráfica de usuario resultante de este conjunto de reglas se muestra en la siguiente captura de pantalla:

GUI for the rule set used to configure the plug-in.

4.3. Creación de un archivo de complemento

El archivo del complemento de hello_world.py se guarda en la parte local de la estructura de directorios del sitio, en ~/local/lib/check_mk/base/cee/plugins/bakery/s.

Un complemento de Bakery se crea en forma de un archivo que se importa como un módulo de Python 3. Por lo tanto, siguiendo la convención de Checkmk, los archivos de complementos también comienzan con las siguientes líneas:

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Como se trata de un módulo, todas las clases y funciones necesarias deben importarse al principio.

4.4. Acceso a la API

Todos los objetos de la API de Bakery están disponibles en cmk.base.cee.plugins.bakery.bakery_api.vX, donde X indica el número de versión de la API; en el ejemplo, 1. Como el archivo del complemento se encuentra en el espacio de nombres cmk.base.cee.plugins.bakery, también funcionará una importación relativa desde .bakery_api.v1:

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
from .bakery_api.v1 import (
    OS,
    DebStep,
    RpmStep,
    SolStep,
    Plugin,
    PluginConfig,
    SystemBinary,
    Scriptlet,
    WindowsConfigEntry,
    register,
    FileGenerator,
    ScriptletGenerator,
    WindowsConfigGenerator,
    quote_shell_string,
)
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

En el ejemplo anterior, solo se importan los nombres necesarios para el escenario del ejemplo.

4.5. Los objetos disponibles en la API

Los nombres disponibles en la API de Bakery se describen en detalle en la documentación de la API. En este capítulo, sin embargo, se presentan brevemente los objetos, ya que esto ayuda a entender la implementación del escenario de ejemplo.

Identificador / Enumeraciones

Para la especificación de los artefactos de los complementos individuales, hay disponibles enumeraciones (Enum), que se pueden utilizar para especificar diversas propiedades, normalmente en forma de argumento:

  • OS - El sistema operativo en el contexto de la API de Bakery.

  • DebStep - Un paso de transacción para un «script de mantenimiento» DEB

  • RpmStep - Un paso de transacción para un «scriptlet» de RPM.

  • SolStep - Un paso de transacción para un «script de instalación» PKG de Solaris.

Artefactos

Los archivos y el contenido de los archivos que constituyen los componentes reales de un complemento se denominan artefactos. Estos se describen mediante clases adecuadas, que se pueden dividir en las siguientes categorías:

  • Archivos (Plugin, SystemBinary, PluginConfig, SystemConfig) - Cada archivo que se va a proporcionar al agente de Checkmk se describe con un objeto. El tipo de archivo viene definido por la clase. Se debe definir un objeto independiente para cada sistema operativo en el que se vaya a implementar el archivo.

  • Scriptlets (Scriptlet) - Un «script de mantenimiento» DEB, un «scriptlet» RPM o un «script de instalación» Solaris PKG que se ejecutará al instalar, desinstalar o actualizar el paquete del agente en el paso de transacción especificado (p. ej., preinstall, postremove).

  • Entradas de configuración de Windows (WindowsConfigEntry, WindowsConfigItems, WindowsGlobalConfigEntry, WindowsSystemConfigEntry) - Las entradas del archivo de configuración YAML para el agente de Windows también se describen utilizando las clases adecuadas.

Cada uno de estos artefactos se describe en funciones de callback correspondientes a su categoría. Las funciones individuales se pasan a la función register con los argumentos files_function, scriptlets_function, windows_config_function. Se trata de funciones generadoras que devuelven los artefactos específicos individuales. La evaluación la realiza Agent Bakery.

Las funciones reciben varios parámetros como argumentos que se pueden evaluar para construir y determinar los artefactos devueltos. Los parámetros son, por un lado, la configuración de la interfaz gráfica de usuario del agente correspondiente que se va a «hornear» (conf) y, por otro lado, el hash de la configuración actual del agente y los archivos de complementos (aghash).

La función de registro

El registro se realiza con la función register, que se invoca al importar el complemento Bakery como módulo.

La función recibe como argumentos los componentes individuales del complemento Bakery: el nombre del complemento (name) y sus funciones (files_function, scriptlets_function, windows_config_function), cada una de las cuales devuelve una categoría de artefacto.

Anotaciones de tipo

Los nombres de las anotaciones de tipo (FileGenerator, ScriptletGenerator, WindowsConfigGenerator, WindowsConfigContent) se pueden usar opcionalmente para identificar el tipo de la función especificada, por ejemplo, así:

def get_files(conf: dict) -> FileGenerator:
    yield Plugin(...)
    yield PluginConfig(...)

def get_scriptlets(conf: dict) -> ScriptletGenerator:
    yield Scriptlet(...)

def get_windows_config(conf: dict) -> WindowsConfigGenerator:
    content: WindowsConfigContent = conf["some_entry"]
    yield WindowsGlobalConfigEntry(name="some_name",content=content)
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Funciones auxiliares

Se pueden utilizar las siguientes funciones auxiliares:

  • quote_shell_string - Esta función se puede utilizar para convertir una expresión de cadena de modo que el shell la reconozca correctamente como una expresión en el archivo resultante, sin tener que enmascarar manualmente las comillas en el código Python.

  • password_store - Este módulo permite acceder a las contraseñas almacenadas en el almacén de contraseñas de Checkmk.

4.6. Registro

El registro del complemento en Checkmk con un nombre de complemento y sus funciones se realiza con la función `register.bakery_plugin`:

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
register.bakery_plugin(
    name = "hello_world",
    files_function = get_hello_world_plugin_files,
    scriptlets_function = get_hello_world_scriptlets,
    windows_config_function = get_hello_world_windows_config,
)
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Las funciones get_hello_world_windows_config, get_hello_world_scriptlets y get_hello_world_plugin_files especificadas aquí se explican con más detalle en los siguientes capítulos.

4.7. Configuración del agente de Windows

En nuestro ejemplo, hay que definir el intervalo de ejecución, y la configuración del complemento debería poder realizarse mediante dos variables. Asegúrate de definir las claves y los tipos de datos tal y como se definieron en el conjunto de reglas creado anteriormente.

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
class HelloWorldConfig(TypedDict, total=False):
    interval: float
    user: str
    content: str

def get_hello_world_windows_config(conf: HelloWorldConfig) -> WindowsConfigGenerator:
    yield WindowsConfigEntry(path=["hello_world", "user"], content=conf["user"])
    yield WindowsConfigEntry(path=["hello_world", "content"], content=conf["content"])
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

En la función `get_hello_world_windows_config`, usamos el argumento `conf` para acceder a la configuración establecida a través del conjunto de reglas en la interfaz gráfica de configuración: El intervalo de tiempo para la reejecución de la salida almacenada en caché (`interval`) y las dos variables que se pueden usar para configurar el complemento (`user`, `content`). Aquí asumimos que la configuración del conjunto de reglas se proporciona como un `dict`. Usando el método `TypedDict` de la clase `HelloWorldConfig`, podemos configurar un acceso estandarizado a ella.

A continuación, se utiliza WindowsConfigEntry para especificar las entradas en el archivo de configuración del agente YAML-Windows, del que se leen los valores de user y content.

4.8. Script de instalación para Linux

En Linux y Solaris, se deben escribir mensajes de syslog al instalar y desinstalar el agente. Aquí solo mostramos una implementación de la distribución Debian Linux:

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
def get_hello_world_scriptlets(conf: Any) -> ScriptletGenerator:
    installed_lines = ['logger "Installed hello_world"']
    uninstalled_lines = ['logger "Uninstalled hello_world"']

    yield Scriptlet(step=DebStep.POSTINST, lines=installed_lines)
    yield Scriptlet(step=DebStep.POSTRM, lines=uninstalled_lines)
    # yield Scriptlet(step=RpmStep.POST, lines=installed_lines)
    # yield Scriptlet(step=RpmStep.POSTUN, lines=uninstalled_lines)
    # yield Scriptlet(step=SolStep.POSTINSTALL, lines=installed_lines)
    # yield Scriptlet(step=SolStep.POSTREMOVE, lines=uninstalled_lines)
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

Primero se definen los comandos para los mensajes de syslog y luego los scripts de instalación para Debian (DebStep), que deben ejecutarse tras la instalación (POSTINST) y tras la desinstalación (POSTRM). En los comentarios a continuación también encontrarás las líneas correspondientes para distribuciones que usan RPM y para Solaris.

Nota: Siguiendo las líneas de comando que has incluido, Checkmk carga los scripts de instalación con comandos adicionales. Por lo tanto, para asegurarte de que se ejecuten todos los comandos de los scripts, no termines tu conjunto de comandos con un exit 0.

4.9. El complemento de agente para Linux

La configuración del complemento del agente para Linux tiene este aspecto. Asegúrate de convertir el intervalo pasado a Integer, ya que el conjunto de reglas y Bakery utilizan tipos de datos diferentes.

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
def get_hello_world_plugin_files(conf: HelloWorldConfig) -> FileGenerator:
    interval = conf.get('interval')

    yield Plugin(
        base_os = OS.LINUX,
        source = Path('hello_world'),
        target = Path('hello_world'),
        interval = int(interval),
    )

    yield PluginConfig(
        base_os = OS.LINUX,
        lines = _get_linux_cfg_lines(conf['user'], conf['content']),
        target = Path('hello_world.json'),
        include_header = False)

    for base_os in [OS.LINUX]:
        yield SystemBinary(
            base_os = base_os,
            source = Path('some_binary'),
        )

def _get_linux_cfg_lines(user: str, content: str) -> List[str]:
    config = json.dumps({'user': user, 'content': content})
    return config.split('\n')
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

En la función get_hello_world_plugin_files, primero se define el archivo Python hello_world como un plugin, es decir, como un archivo ejecutable que el agente de Checkmk ejecutará como un complemento de agente. A continuación, se utiliza PluginConfig para especificar el archivo de configuración hello_world.json que se generará para el complemento de agente de Linux con las entradas user y content.

Con la segunda función _get_linux_cfg_lines, estas líneas se escriben en formato JSON. Aquí, el diccionario de Python conf contiene los valores establecidos con el conjunto de reglas de la GUI de configuración, que luego se empaquetan en un archivo JSON mediante un pequeño desvío.

Por último, el script de shell adicional some_binary que se va a entregar debe colocarse como SystemBinary en el sistema de destino, en el directorio de programas de usuario (por defecto, /usr/bin).

4.10. El archivo del complemento para nuestro escenario de ejemplo

Si juntamos todas las partes presentadas hasta ahora —y las completamos—, un complemento para nuestro escenario de ejemplo podría tener este aspecto una vez terminado:

~/local/lib/check_mk/base/cee/plugins/bakery/hello_world.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Shebang only needed for editor!

import json
from pathlib import Path
from typing import Iterable, TypedDict, List

from .bakery_api.v1 import (
    OS,
    DebStep,
    RpmStep,
    SolStep,
    Plugin,
    PluginConfig,
    SystemBinary,
    Scriptlet,
    WindowsConfigEntry,
    register,
    FileGenerator,
    ScriptletGenerator,
    WindowsConfigGenerator,
    quote_shell_string,
)

class HelloWorldConfig(TypedDict, total=False):
    interval: float
    user: str
    content: str

def get_hello_world_plugin_files(conf: HelloWorldConfig) -> FileGenerator:
    interval = conf.get('interval')

    yield Plugin(
        base_os = OS.LINUX,
        source = Path('hello_world'),
        target = Path('hello_world'),
        interval = int(interval),
    )
    yield Plugin(
        base_os  =OS.SOLARIS,
        source = Path('hello_world.solaris.ksh'),
        target = Path('hello_world'),
        interval = int(interval),
    )
    yield Plugin(
        base_os = OS.WINDOWS,
        source = Path('hello_world.cmd'),
        target = Path('hello_world.bat'),
        interval = int(interval),
    )

    yield PluginConfig(
        base_os = OS.LINUX,
        lines = _get_linux_cfg_lines(conf['user'], conf['content']),
        target = Path('hello_world.json'),
        include_header = False
    )
    yield PluginConfig(
        base_os = OS.SOLARIS,
        lines = _get_solaris_cfg_lines(conf['user'], conf['content']),
        target = Path('hello_world.cfg'),
        include_header = True
    )

    for base_os in [OS.LINUX, OS.SOLARIS]:
        yield SystemBinary(
            base_os = base_os,
            source = Path('some_binary'),
        )

def _get_linux_cfg_lines(user: str, content: str) -> List[str]:
    config = json.dumps({'user': user, 'content': content})
    return config.split('\n')

def _get_solaris_cfg_lines(user: str, content: str) -> List[str]:
    # To be loaded with 'source' in Solaris shell script
    return [
        f'USER={quote_shell_string(user)}',
        f'CONTENT={quote_shell_string(user)}',
    ]

def get_hello_world_scriptlets(conf: HelloWorldConfig) -> ScriptletGenerator:
    installed_lines = ['logger -p local3.info "Installed hello_world"']
    uninstalled_lines = ['logger -p local3.info "Uninstalled hello_world"']

    yield Scriptlet(step=DebStep.POSTINST, lines=installed_lines)
    yield Scriptlet(step=DebStep.POSTRM, lines=uninstalled_lines)
    yield Scriptlet(step=RpmStep.POST, lines=installed_lines)
    yield Scriptlet(step=RpmStep.POSTUN, lines=uninstalled_lines)
    yield Scriptlet(step=SolStep.POSTINSTALL, lines=installed_lines)
    yield Scriptlet(step=SolStep.POSTREMOVE, lines=uninstalled_lines)

def get_hello_world_windows_config(conf: HelloWorldConfig) -> WindowsConfigGenerator:
    yield WindowsConfigEntry(path=["hello_world", "user"], content=conf["user"])
    yield WindowsConfigEntry(path=["hello_world", "content"], content=conf["content"])

register.bakery_plugin(
    name = "hello_world",
    files_function = get_hello_world_plugin_files,
    scriptlets_function = get_hello_world_scriptlets,
    windows_config_function = get_hello_world_windows_config,
)
Copiar el contenido del archivo al portapapeles
¡Contenido del archivo copiado correctamente al portapapeles!
¡Se ha denegado el acceso de escritura al portapapeles!

4.11. Hacer que los archivos estén disponibles

Para que un complemento de Bakery funcione correctamente, todos los archivos implicados deben colocarse o escribirse en la ubicación correcta dentro de la estructura local del directorio del sitio.

Se trata, por un lado, del propio archivo del complemento y, por otro, de los objetos devueltos por el método files_function. Estos objetos describen archivos de configuración creados directamente por el complemento Bakery o hacen referencia a archivos que deben almacenarse correctamente para que puedan encontrarse al empaquetar los paquetes del agente.

Los objetos de las clases Plugin y SystemBinary indican archivos existentes que deben almacenarse. Los archivos descritos como PluginConfig y SystemConfig aún deben generarse en función del argumento lines, por lo que no es necesario almacenar ningún archivo aquí.

Por último, el conjunto de archivos también incluye el archivo de conjunto de reglas para el complemento.

En el siguiente y último capítulo encontrarás la recopilación de todos los directorios.

5. Archivos y directorios

Los archivos para implementar un complemento de Bakery deben colocarse en los siguientes directorios. Como siempre, todas las especificaciones aquí son relativas al directorio del sitio (por ejemplo, /omd/sites/mysite).

Ruta del archivo Descripción

~/local/lib/check_mk/base/cee/plugins/bakery/

Directorio del complemento de Bakery (en nuestro ejemplo, hello_world.py).

~/local/share/check_mk/agents/plugins/

Directorio para almacenar los complementos de agente tipo Unix.

~/local/share/check_mk/agents/windows/plugins/

Directorio para almacenar los complementos de agente de Windows.

~/local/share/check_mk/agents/

Directorio para los programas incluidos o scripts de shell para sistemas operativos tipo Unix (some_binary en el ejemplo).

~/local/share/check_mk/agents/windows/

Directorio para los programas o scripts de shell suministrados para Windows.

~/local/lib/python3/cmk_addons/plugins/<family_name>/rulesets/

Directorio para los archivos de conjuntos de reglas para configurar el complemento de agente (en el ejemplo, ruleset_hello_world_bakery.py) y también el complemento de comprobación asociado (por ejemplo, para establecer umbrales). Por lo tanto, elige nombres significativos para poder distinguir los archivos. Los nombres de los archivos almacenados aquí deben empezar por ruleset_; de lo contrario, Checkmk los ignorará.
Last modified: Wed, 25 Mar 2026 10:13:52 GMT via commit d7fa87218
En esta página