Libral fournit une API de gestion unifiée pour les ressources et services système !

Présentation

En tant que système d'exploitation Linux traditionnel héritant d'Unix, il ne dispose pas d'une interface API de gestion de système complète. Au contraire, les opérations de gestion sont mises en œuvre via une variété d'outils et d'API spécifiques, chacun ayant ses propres conventions et. Style unique. Cela rend difficile et fragile l’écriture de scripts, même pour des tâches d’administration système simples.

Par exemple, pour modifier le shell de connexion de l'utilisateur « app », exécutez usermod -s /sbin/nologin app. Cette commande fonctionne généralement correctement, sauf lorsqu'il n'y a pas d'utilisateur « app » sur le système. Pour résoudre cette erreur d'exception, un scénariste innovant pourrait écrire :

grep -q app /etc/passwd \
&& usermod -s /sbin/nologin app \
|| useradd ... -s /sbin/nologin app

De cette façon, lorsque l'utilisateur « app » existe dans le système, l'opération de changement du shell de connexion sera effectuée et lorsque cet utilisateur n'existe pas, cet utilisateur sera créé ; Malheureusement, cette façon de scripter les tâches d'administration du système est inadéquate : pour chaque ressource, il y aura un ensemble d'outils différent, et chacun a ses propres conventions d'utilisation ; des incohérences fréquentes surviennent en outre, cela rendra la gestion des erreurs difficile ; peut également conduire à un échec d’exécution en raison de défauts causés par les caractéristiques de l’outil lui-même.

En fait, l'exemple ci-dessus est également incorrect : grep n'est pas utilisé pour trouver l'utilisateur "app". Il peut simplement trouver s'il y a la chaîne "app" dans certaines lignes du fichier /etc/passwd. la plupart du temps, mais cela peut mal tourner aux moments les plus critiques.

De toute évidence, ces outils de gestion de scripts qui effectuent des tâches simples peuvent difficilement devenir la base d'un système de gestion à grande échelle. Conscient de cela, il serait sage que les systèmes de gestion de configuration existants, tels que Puppet, Chef et Ansible, fassent de grands efforts pour construire leurs API internes autour de la gestion des ressources de base du système d'exploitation. Ces abstractions de ressources sont des API internes étroitement liées aux outils correspondants requis. Mais cela entraîne non seulement une grande duplication du travail, mais crée également un obstacle important à l’essai d’un outil de gestion nouveau et innovant.

Dans le domaine de la création d'images de machines virtuelles ou de conteneurs, cet obstacle devient très évident : par exemple, dans le processus de création d'images, vous devez soit répondre à des questions simples à leur sujet, soit y apporter de simples modifications. Mais les outils nécessitent tous une manipulation particulière, et les problèmes et modifications rencontrés doivent être traités un à un à l'aide de scripts. Par conséquent, la création d’images repose soit sur des scripts spécifiques, soit nécessite l’utilisation (et l’installation) d’un système de gestion de configuration assez puissant.

Libral fournira une garantie fiable pour les outils et les tâches de gestion en fournissant une API de gestion commune pour les ressources système et en la rendant disponible via l'outil de ligne de commande ralsh. Il permet aux utilisateurs d'interroger et de modifier les ressources système de la même manière, et elles sont prévisibles. rapports d'erreurs. Pour l'exemple ci-dessus, vous pouvez utiliser la commande ralsh -aq user app pour vérifier si l'utilisateur « app » existe ; utilisez la commande ralsh -aq package foo pour vérifier si le progiciel « foo » a été installé en général ; peut utiliser la commande ralsh -aq TYPE NAME Vérifiez si "NAME" est une ressource de type "TYPE". De même, pour créer ou modifier un utilisateur existant, exécutez :

ralsh user app home=/srv/app shell=/sbin/nologin

Aussi, pour créer et modifier des entrées dans le fichier /etc/hosts, vous pouvez exécuter la commande :

ralsh hostmyhost.example.com ip=10.0.0.1 \
host_aliases=myhost,apphost

En l'exécutant de cette façon, l'utilisateur de "ralsh" est en fait complètement isolé des différents mécanismes de fonctionnement à l'intérieur de ces deux commandes : la première commande nécessite l'appel approprié à la commande useradd ou usermod, tandis que la seconde commande nécessite la commande appropriée useradd ou usermod. Modifiez le fichier /etc/hosts. Pour cet utilisateur, ils semblent tous adopter le même modèle : "Assurez-vous que la ressource est dans l'état dont j'ai besoin

." Comment obtenir et utiliser Libral ?

Libral peut être trouvé et téléchargé dans ce référentiel git. Le noyau est écrit en C++ et les instructions pour le construire peuvent être trouvées dans ce référentiel, mais vous n'avez qu'à le consulter si vous souhaitez contribuer au noyau C++ de Libral. Le site Web de Libral comprend une archive tar prédéfinie qui peut être utilisée sur n'importe quelle machine Linux utilisant la « glibc 2.12 » ou une version ultérieure. Le contenu de cette « archive tar » peut être utilisé pour explorer davantage ralsh et développer de nouveaux fournisseurs permettant à Libral de gérer de nouveaux types de ressources.

Après avoir téléchargé et décompressé l'archive tar, vous pouvez trouver la commande ralsh dans le répertoire ral/bin. L'exécution de la commande ralsh sans aucun paramètre répertoriera tous les types de ressources Libral. Utilisez l'option --help pour imprimer plus d'informations sur ralsh.

Relation avec le système de gestion de configuration

Les systèmes de gestion de configuration bien connus, tels que Puppet, Chef et Ansible, résolvent certains des mêmes problèmes que Libral résout. Ce qui différencie Libral de ses homologues, c'est avant tout qu'ils font un travail différent de celui de Libral. Les systèmes de gestion de configuration sont conçus pour gérer la variété et la complexité de la gestion d'une variété de choses sur un grand nombre de nœuds. Libral, quant à lui, vise à fournir une API de gestion système de bas niveau bien définie, indépendante de tout outil spécifique et pouvant être utilisée dans une variété de langages de programmation.

通过消除大型配置管理系统中包含的应用程序逻辑，Libral 从前面介绍里提及的简单的脚本任务，到作为构建复杂的管理应用的构建块，它在如何使用方面是非常灵活的。专注与这些基础层面也使其保持很小，目前不到 2.5 MB，这对于资源严重受限的环境，如容器和小型设备来说是一个重要考虑因素。

Libral API

在过去的十年里，Libral API 是在实现配置管理系统的经验下指导设计的，虽然它并没有直接绑定到它们其中任何一个应用上，但它考虑到了这些问题，并规避了它们的缺点。

在 API 设计中四个重要的原则：

• 期望的状态
• 双向性
• 轻量级抽象
• 易于扩展

基于期望状态的管理 API，举个例子来说，用户表示当操作执行后希望系统看起来是什么状态，而不是怎样进入这个状态，这一点什么争议。双向性使得使用（读、写）相同的 API 成为可能，更重要的是，相同的资源可以抽象成读取现有状态和强制修改成这种状态。轻量级抽象行为确保能容易的学习 API 并能快速的使用；过去在管理 API 上的尝试过度加重了学习建模框架的使用者的负担，其中一个重要的因素是他们的接受力缺乏。

最后，它必须易于扩展 Libral 的管理功能，这样用户可以教给 Libral 如何管理新类型的资源。这很重要，因为人们也许要管理的资源可能很多（而且 Libral 需要在适当时间进行管理），再者，因为即使是完全成熟的 Libral 也总是存在达不到用户自定义的管理需求。

目前与 Libral API 进行交互的主要方式是通过 ralsh 命令行工具。它也提供了底层的 C++ API ，不过其仍处在不断的演变当中，主要的还是为简单的脚本任务做准备。该项目也提供了为 CRuby 提供语言绑定，其它语言也在陆续跟进。

未来 Libral 还将提供一个提供远程 API 的守护进程，它可以做为管理系统的基础服务，而不需要在管理节点上安装额外的代理。这一点，加上对 Libral 管理功能的定制能力，可以严格控制系统的哪些方面可以管理，哪些方面要避免干扰。

举个例子来说，一个仅限于管理用户和服务的 Libral 配置会避免干扰到在节点上安装的包。当前任何现有的配置管理系统都不可能控制以这种方式管理的内容；尤其是，需要对受控节点进行任意的 SSH 访问也会将该系统暴露不必要的意外和恶意干扰。

Libral API 的基础是由两个非常简单的操作构成的：“get” 用来检索当前资源的状态，“set” 用来设置当前资源的状态。理想化地实现是这样的，通过以下步骤：

provider.get(names) -> List[resource]
provider.set(List[update]) -> List[change]

“provider” 是要知道怎样管理的一种资源的对象，就像用户、服务、软件包等等，Libral API 提供了一种查找特定资源的管理器provider的方法。

“get” 操作能够接收资源名称列表（如用户名），然后产生一个资源列表，其本质来说是利用散列的方式列出每种资源的属性。这个列表必须包含所提供名称的资源，但是可以包含更多内容，因此一个简单的 “get” 的实现可以忽略名称并列出所有它知道的资源。

“set” 操作被用来设置所要求的状态，并接受一个更新列表。每个更新可以包含 “update.is”，其表示当前状态的资源，“update.should” 表示被资源所期望的状态。调用 “set” 方法将会让更新列表中所提到的资源成为 “update.should” 中指示的状态，并列出对每个资源所做的更改。

在 ralsh 下，利用 ralsh user root 能够重新获得 “root” 用户的当前状态；默认情况下，这个命令会产生一个用户可读的输出，就像 Puppet 中一样，但是 ralsh 支持 --json 选项，可以生成脚本可以使用的 JSON 输出。用户可读的输出是：

# ralsh user root
user::useradd { 'root':
ensure => 'present',
comment => 'root',
gid => '0',
groups => ['root'],
home => '/root',
shell => '/bin/bash',
uid => '0',
}

类似的，用户也可以用下面的形式修改：

# ralsh user root comment='The superuser'
user::useradd { 'root':
ensure => 'present',
comment => 'The superuser',
gid => '0',
groups => ['root'],
home => '/root',
shell => '/bin/bash',
uid => '0',
}
comment(root->The superuser)

ralsh 的输出列出了 “root” 用户的新状态和被改变的 comment 属性，以及修改了什么内容（在这种情形下单指 comment 属性）。下一秒运行相同的命令将产生同样的输出，但是不会提示修改，因为没有需要修改的内容。

Responsable de la rédaction

Écrire un nouveau fournisseur pour ralsh est facile et demande peu d'efforts, mais cette étape est cruciale. De ce fait, ralsh fournit un grand nombre de conventions d'appel qui permettent d'ajuster la complexité d'implémentation du gestionnaire en fonction des capacités qu'il peut apporter. Le gestionnaire peut utiliser un script externe qui suit une convention d'appel spécifique, ou il peut être implémenté en C++ et intégré à Libral. Jusqu'à présent, il existe trois conventions d'appel :

• La convention d'appel simple consiste à écrire des scripts shell en tant que gestionnaires.
• La convention d'appel JSON signifie que les gestionnaires peuvent être écrits à l'aide des langages de script Ruby ou Python.
• [L'API8 C++ interne peut être utilisée pour implémenter des gestionnaires natifs.

Il est fortement recommandé d'utiliser la convention d'appel « simple » ou « JSON » pour commencer à développer des managers. Le fichier simple.prov sur GitHub contient un framework de gestionnaire de shell simple qui devrait être facile à remplacer par votre propre gestionnaire. Le fichier python.prov contient le framework du gestionnaire JSON écrit en Python.

Un problème avec les gestionnaires écrits dans des langages de script de haut niveau est que pour ces langages, l'environnement d'exécution doit inclure toutes les bibliothèques de support sur le système exécutant actuellement Libral. Dans certains cas, cela ne constitue pas un obstacle ; par exemple, le gestionnaire de packages basé sur « yum » nécessite que Python soit installé sur le système actuel, puisque « yum » est développé en Python.

Cependant, dans de nombreux cas, il n'est pas prévu qu'un langage de conception autre que le shell Bourne (Bash) puisse être installé sur tous les systèmes de gestion. Souvent, un environnement de compilation de scripts plus puissant constitue une nécessité pratique pour les rédacteurs de gestionnaires. Cependant, contrairement aux attentes, lier un Ruby ou un Python complet pour qu'il s'exécute en tant qu'interpréteur augmentera la taille de Libral au-delà de la limite de ressources de l'environnement d'utilisation réel. D'autre part, le choix habituel de Lua ou JavaScript comme langage d'édition de script intégrable n'est pas adapté à cet environnement, car la plupart des rédacteurs des managers ne les connaissent pas et nécessitent généralement beaucoup de travail pour répondre aux exigences de gestion du système. . Demande réelle.

Libral est fourni avec une version de mruby, une petite version intégrée de Ruby qui fournit aux rédacteurs de gestionnaires une base stable et un puissant langage de programmation implémentable. mruby est une implémentation complète du langage Ruby, bien qu'avec un support de bibliothèque standard très réduit. Les liaisons mruby avec Libral contiennent la plupart des bibliothèques standards importantes de Ruby pour les tâches de gestion de scripts, qui seront améliorées au fil du temps en fonction des besoins des rédacteurs de gestionnaires. Le mruby de Libral regroupe des adaptateurs API pour rendre le gestionnaire d'écriture plus adapté aux conventions JSON. Par exemple, il inclut des outils simples (tels que Augeas qui compilent et modifient les fichiers de structure) pour résoudre la convention d'analyse et de sortie JSON. Le fichier mruby.prov contient une instance du framework de gestionnaire JSON écrit en mruby.

Prochaine étape

La prochaine étape la plus critique pour Libral est de la rendre largement disponible - l'archive tar précompilée est un bon moyen de démarrer et d'approfondir le gestionnaire de développement, mais Libral doit également être packagé sur les distributions grand public et utilisé dans Il peut être trouvé ci-dessus. De même, la puissance de Libral dépend de l’ensemble des gestionnaires qui l’accompagnent et doit être étendue pour couvrir un ensemble de fonctions de gestion de base. Le site Web de Libral comprend une liste de tâches répertoriant les besoins les plus urgents des gestionnaires.

Il existe désormais de nombreuses façons d'améliorer la convivialité de Libra à différentes fins : depuis l'écriture de liaisons pour davantage de langages de programmation, par exemple Python ou Go, jusqu'à rendre ralsh plus facile à utiliser dans les scripts shell, en plus du In existant lisible par l'homme ; En plus de la sortie et de la sortie JSON, la sortie peut être facilement formatée dans un script shell. L'utilisation de Libral dans la gestion à grande échelle peut également être améliorée en ajoutant l'API distante décrite ci-dessus. Libral exploite des outils de transport tels que SSH pour mieux prendre en charge les exigences d'installation par lots. Fournir des archives tar précompilées pour diverses architectures et des scripts pour sélectionner le package approprié. sur l'architecture du système cible découverte.

Libral, son API et ses capacités peuvent continuer à évoluer ; une possibilité intéressante consiste à ajouter des capacités d'alerte à l'API, qui peuvent signaler au système les modifications apportées aux ressources en dehors de son champ d'application. Le défi chez Libral est de maintenir des outils petits, légers et bien définis pour lutter contre des cas d'utilisation toujours croissants et gérer les performances. J'espère que chaque lecteur pourra faire partie de ce voyage.

---

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!