Entités, partages de packages et utilisateurs
S’applique à : Medulla – Entités
Version : Toutes
Environnement : On-Premise
Catégorie : Entités / partages de packages
Entités, partages de packages et utilisateurs
Comprendre les notions
1. Qu'est-ce qu'un partage de packages ?
Un partage est un dossier de packages partagé entre utilisateurs. Les packages sont séparés les uns des autres par les partages.
2. Qu'est-ce qu'une entité ?
Une entité est une organisation logique des machines. Les machines sont séparées les unes des autres par les entités.
3. Que peut faire un utilisateur avec un package ?
Un utilisateur peut déployer n'importe quel package qu'il voit sur n'importe quelle machine qu'il voit.
| Ce que l'utilisateur voit | Ce qu'il peut faire |
|---|---|
| Un package + une machine | Déployer ce package sur cette machine |
| Un package, mais pas la machine | Rien |
| Une machine, mais pas le package | Rien |
4. Y a-t-il un lien entre les entités et les partages ?
Non, aucun. Les entités organisent les machines, les partages organisent les packages : ce sont deux axes indépendants.
Un utilisateur qui voit les machines d'une entité peut donc voir des packages contenus dans un partage lié à plusieurs entités.
5. Quelle est la configuration par défaut ?
Medulla est livré avec un partage global. Tous les utilisateurs qui y ont accès voient les mêmes packages.
6. Peut-on séparer les packages par équipe ?
Oui. Si besoin, on peut créer des partages spécifiques par équipe d'utilisateurs, en plus du partage global.
7. Un technicien crée un package pour son entité : les autres entités le verront-elles ?
Si le serveur n'a que le partage par défaut, oui. Le package est créé dans le partage global, donc il est visible par les autres entités qui ont accès à ce partage.
Procédures
8. Comment ajouter un partage ?
Un partage se crée en ajoutant une ligne dans la table pkgs_shares de la base pkgs.
| Champ | Obligatoire | Rôle | Exemple |
|---|---|---|---|
name |
Oui | Nom du partage | global |
comments |
Oui | Description | Global Packages |
uri |
Oui | URI du service Medulla | pulse |
ars_name |
Oui | Nom du serveur relais (ARS) | pulse |
ars_id |
Oui | Identifiant du serveur relais | 1 |
share_path |
Oui | Dossier du partage sur le serveur | /var/lib/pulse2/packages/sharing/global |
id |
Non | Identifiant du partage | 1 |
type |
Non | Type de partage | global |
Exemple : création du partage global.
INSERT IGNORE INTO pkgs.pkgs_shares
(id, name, comments, type, uri, ars_name, ars_id, share_path)
VALUES
(1, 'global', 'Global Packages', 'global', 'pulse', 'pulse', 1,
'/var/lib/pulse2/packages/sharing/global')
9. Comment associer des utilisateurs à un partage ?
Les droits des utilisateurs sur un partage sont définis par des règles, ajoutées dans la table pkgs_rules_local de la base pkgs. Chaque règle indique qui a quel droit sur quel partage.
| Champ | Rôle | Exemple |
|---|---|---|
subject |
Qui est concerné : un nom d'utilisateur ou une expression régulière | root ou .* |
permission |
Type de permission : r ou rw |
rw |
pkgs_shares_id |
Partage concerné (l'id du partage dans pkgs_shares) |
1 |
Les champs pkgs_rules_algos_id et order sont repris tels quels dans les exemples ci-dessous.
Exemple 1 : l'utilisateur root a les droits d'écriture sur le partage global
INSERT IGNORE INTO pkgs.pkgs_rules_local
(pkgs_rules_algos_id, `order`, subject, permission, pkgs_shares_id)
VALUES (1, 10, 'root', 'rw', 1)
Exemple 2 : tous les utilisateurs ont les droits d'écriture sur le partage global
INSERT IGNORE INTO pkgs.pkgs_rules_local
(pkgs_rules_algos_id, `order`, subject, permission, pkgs_shares_id)
VALUES (1, 20, '.*', 'rw', 1)
Ces deux règles sont celles de la configuration par défaut : c'est pourquoi tous les utilisateurs ont accès au partage global.
Résumé
| Notion | Sépare | Défini dans |
|---|---|---|
| Entité | Les machines | Organisation logique des machines |
| Partage | Les packages | Table pkgs_shares |
| Droits des utilisateurs | Qui a quel droit sur quel partage | Table pkgs_rules_local |
Les entités et les partages sont indépendants : un utilisateur déploie un package sur une machine seulement s'il voit à la fois le package (via un partage) et la machine (via une entité).