Marionnette - Style de codage
Dans Puppet, le style de codage définit toutes les normes à suivre en essayant de convertir l'infrastructure sur la configuration de la machine en un code. Puppet fonctionne et exécute toutes ses tâches définies en utilisant des ressources.
La définition du langage de Puppet aide à spécifier toutes les ressources de manière structurée, ce qui est nécessaire pour gérer toute machine cible qui doit être gérée. Puppet utilise Ruby comme langage d'encodage, qui possède plusieurs fonctionnalités intégrées qui permettent de faire très facilement les choses avec une configuration simple côté code.
Unités fondamentales
Puppet utilise plusieurs styles de codage fondamentaux qui sont faciles à comprendre et à gérer. Voici une liste de quelques-uns.
Ressources
Dans Puppet, les ressources sont appelées unités de modélisation fondamentales utilisées pour gérer ou modifier n'importe quel système cible. Les ressources couvrent tous les aspects d'un système tels que les fichiers, les services et les packages. Puppet est livré avec une capacité intégrée dans laquelle il permet aux utilisateurs ou aux développeurs de développer des ressources personnalisées, qui aident à gérer toute unité particulière d'une machine
Dans Puppet, toutes les ressources sont agrégées soit en utilisant “define” ou “classes”. Ces fonctionnalités d'agrégation aident à organiser un module. Voici un exemple de ressource qui se compose de plusieurs types, un titre et une liste d'attributs avec lesquels Puppet peut prendre en charge plusieurs attributs. Chaque ressource de Puppet a sa propre valeur par défaut, qui peut être remplacée si nécessaire.
Exemple de ressource Puppet pour fichier
Dans la commande suivante, nous essayons de spécifier une autorisation pour un fichier particulier.
file {
'/etc/passwd':
owner => superuser,
group => superuser,
mode => 644,
}Chaque fois que la commande ci-dessus est exécutée sur n'importe quelle machine, elle vérifie que le fichier passwd dans le système est configuré comme décrit. Le fichier avant: deux points est le titre de la ressource, qui peut être appelé ressource dans d'autres parties de la configuration de Puppet.
Spécification du nom local en plus du titre
file { 'sshdconfig':
name => $operaSystem ? {
solaris => '/usr/local/etc/ssh/sshd_config',
default => '/etc/ssh/sshd_config',
},
owner => superuser,
group => superuser,
mode => 644,
}En utilisant le titre, qui est toujours le même, il est très facile de référencer la ressource de fichier dans la configuration sans avoir à répéter la logique liée au système d'exploitation.
Un autre exemple pourrait être l'utilisation d'un service qui dépend d'un fichier.
service { 'sshd':
subscribe => File[sshdconfig],
}Avec cette dépendance, le sshd le service redémarrera toujours une fois sshdconfigchangements de fichiers. Le point à retenir ici estFile[sshdconfig] est une déclaration en tant que fichier comme en minuscules mais si nous la modifions en FILE[sshdconfig] alors ça aurait été une référence.
Un point fondamental qu'il faut garder à l'esprit lors de la déclaration d'une ressource est qu'elle ne peut être déclarée qu'une seule fois par fichier de configuration. Répéter la déclaration de la même ressource plus d'une fois provoquera une erreur. Grâce à ce concept fondamental, Puppet s'assure que la configuration est bien modélisée.
Nous avons même la capacité de gérer la dépendance aux ressources, ce qui aide à gérer plusieurs relations.
service { 'sshd':
require => File['sshdconfig', 'sshconfig', 'authorized_keys']
}Métaparamètres
Les métaparamètres sont appelés paramètres globaux dans Puppet. L'une des principales caractéristiques du métaparamètre est qu'il fonctionne avec tout type de ressource dans Puppet.
Valeur par défaut de la ressource
Quand on a besoin de définir une valeur d'attribut de ressource par défaut, Puppet fournit un ensemble de syntaxe pour l'archiver, en utilisant une spécification de ressource en majuscule qui n'a pas de titre.
Par exemple, si nous voulons définir le chemin par défaut de tous les exécutables, cela peut être fait avec la commande suivante.
Exec { path => '/usr/bin:/bin:/usr/sbin:/sbin' }
exec { 'echo Testing mataparamaters.': }Dans la commande ci-dessus, la première instruction Exec définira la valeur par défaut de la ressource exec. La ressource Exec nécessite un chemin complet ou un chemin qui ressemble à un exécutable. Avec cela, on peut définir un seul chemin par défaut pour toute la configuration. Les valeurs par défaut fonctionnent avec n'importe quel type de ressource dans Puppet.
Les valeurs par défaut ne sont pas des valeurs globales, cependant, elles n'affectent que la portée dans laquelle elles sont définies ou la variable suivante. Si l'on veut définirdefault pour une configuration complète, nous définissons le default et la classe dans la section suivante.
Collections de ressources
L'agrégation est une méthode pour rassembler des choses. Puppet prend en charge un concept d'agrégation très puissant. Dans Puppet, l'agrégation est utilisée pour regrouper la ressource qui est l'unité fondamentale de Puppet. Ce concept d'agrégation dans Puppet est réalisé en utilisant deux méthodes puissantes appeléesclasses et definition.
Classes et définition
Les classes sont responsables de la modélisation des aspects fondamentaux du nœud. Ils peuvent dire que le nœud est un serveur Web et que ce nœud particulier est l'un d'entre eux. Dans Puppet, les classes de programmation sont uniques et peuvent être évaluées une fois par nœud.
La définition d'autre part peut être utilisée plusieurs fois sur un seul nœud. Ils fonctionnent de la même manière que l'on a créé son propre type de marionnette en utilisant la langue. Ils sont créés pour être utilisés plusieurs fois avec des entrées différentes à chaque fois. Cela signifie que l'on peut passer des valeurs de variable dans la définition.
Différence entre classe et définition
La seule différence clé entre une classe et une définition est que lors de la définition de la structure du bâtiment et de l'allocation des ressources, la classe n'est évaluée qu'une seule fois par nœud, dans lequel, d'autre part, une définition est utilisée plusieurs fois sur le même nœud unique.
Des classes
Les classes dans Puppet sont introduites à l'aide du mot clé class et le contenu de cette classe particulière est enveloppé entre accolades, comme illustré dans l'exemple suivant.
class unix {
file {
'/etc/passwd':
owner => 'superuser',
group => 'superuser',
mode => 644;
'/etc/shadow':
owner => 'vipin',
group => 'vipin',
mode => 440;
}
}Dans l'exemple suivant, nous avons utilisé une main courte similaire à celle ci-dessus.
class unix {
file {
'/etc/passwd':
owner => 'superuser',
group => 'superuser',
mode => 644;
}
file {'/etc/shadow':
owner => 'vipin',
group => 'vipin',
mode => 440;
}
}Héritage dans les classes de marionnettes
Dans Puppet, le concept d'héritage de la POO est pris en charge par défaut dans lequel les classes peuvent étendre les fonctionnalités du précédent sans copier et coller à nouveau le bit de code complet dans la classe nouvellement créée. L'héritage permet à la sous-classe de remplacer les paramètres de ressource définis dans la classe parent. Une chose clé à garder à l'esprit lors de l'utilisation de l'héritage est qu'une classe ne peut hériter des fonctionnalités que d'une seule classe parente, pas plus d'une.
class superclass inherits testsubclass {
File['/etc/passwd'] { group => wheel }
File['/etc/shadow'] { group => wheel }
}S'il est nécessaire d'annuler une logique spécifiée dans une classe parente, nous pouvons utiliser undef command.
class superclass inherits testsubcalss {
File['/etc/passwd'] { group => undef }
}Autre manière d'utiliser l'héritage
class tomcat {
service { 'tomcat': require => Package['httpd'] }
}
class open-ssl inherits tomcat {
Service[tomcat] { require +> File['tomcat.pem'] }
}Classe imbriquée dans la marionnette
Puppet prend en charge le concept d'imbrication des classes dans lequel il permet d'utiliser des classes imbriquées ce qui signifie une classe dans l'autre. Cela aide à atteindre la modularité et la portée.
class testclass {
class nested {
file {
'/etc/passwd':
owner => 'superuser',
group => 'superuser',
mode => 644;
}
}
}
class anotherclass {
include myclass::nested
}Classes paramétrées
Dans Puppet, les classes peuvent étendre leurs fonctionnalités pour permettre le passage de paramètres dans une classe.
Pour passer un paramètre dans une classe, on peut utiliser la construction suivante -
class tomcat($version) {
... class contents ...
}Un point clé à retenir dans Puppet est que les classes avec des paramètres ne sont pas ajoutées à l'aide de la fonction include, mais la classe résultante peut être ajoutée en tant que définition.
node webserver {
class { tomcat: version => "1.2.12" }
}Valeurs par défaut en tant que paramètres dans la classe
class tomcat($version = "1.2.12",$home = "/var/www") {
... class contents ...
}Étapes d'exécution
Puppet prend en charge le concept d'étape d'exécution, ce qui signifie que l'utilisateur peut ajouter plusieurs étapes selon l'exigence afin de gérer une ressource particulière ou plusieurs ressources. Cette fonctionnalité est très utile lorsque l'utilisateur souhaite développer un catalogue complexe. Dans un catalogue complexe, on a un grand nombre de ressources qui doivent être compilées tout en gardant à l'esprit que les dépendances entre les ressources définies ne doivent pas être affectées.
Run Stage est très utile pour gérer les dépendances des ressources. Cela peut être fait en ajoutant des classes dans des étapes définies dans lesquelles une classe particulière contient une collection de ressources. Avec l'étape d'exécution, Puppet garantit que les étapes définies s'exécuteront dans un ordre prévisible spécifié à chaque fois que le catalogue s'exécute et est appliqué sur n'importe quel nœud Puppet.
Pour l'utiliser, il faut déclarer des étapes supplémentaires au-delà des étapes déjà présentes, puis Puppet peut être configuré pour gérer chaque étape dans un ordre spécifié en utilisant la même syntaxe de relation de ressources avant d'exiger “->” et “+>”. La relation garantira alors l'ordre des classes associées à chaque étape.
Déclaration d'étapes supplémentaires avec la syntaxe déclarative Puppet
stage { "first": before => Stage[main] }
stage { "last": require => Stage[main] }Une fois les étapes déclarées, une classe peut être associée à la scène autre que la principale utilisant la scène.
class {
"apt-keys": stage => first;
"sendmail": stage => main;
"apache": stage => last;
}Toutes les ressources associées à la classe apt-key s'exécuteront en premier. Toutes les ressources de Sendmail seront la classe principale et les ressources associées à Apache seront la dernière étape.
Définitions
Dans Puppet, la collecte des ressources dans n'importe quel fichier manifeste est effectuée par classes ou définitions. Les définitions sont très similaires à une classe dans Puppet, mais elles sont introduites avec undefine keyword (not class)et ils soutiennent l'argument pas l'héritage. Ils peuvent fonctionner plusieurs fois sur le même système avec des paramètres différents.
Par exemple, si l'on veut créer une définition qui contrôle les référentiels de code source où l'on essaie de créer plusieurs référentiels sur le même système, alors on peut utiliser la définition et non la classe.
define perforce_repo($path) {
exec {
"/usr/bin/svnadmin create $path/$title":
unless => "/bin/test -d $path",
}
}
svn_repo { puppet_repo: path => '/var/svn_puppet' }
svn_repo { other_repo: path => '/var/svn_other' }Le point clé à noter ici est de savoir comment une variable peut être utilisée avec une définition. Nous utilisons ($) variable de signe dollar. Dans ce qui précède, nous avons utilisé $ title. Les définitions peuvent avoir à la fois un $ title et un $ name avec lesquels le nom et le titre peuvent être représentés. Par défaut, $ title et $ name ont la même valeur, mais on peut définir un attribut title et passer un nom différent en tant que paramètre. $ title et $ name ne fonctionnent que dans la définition, pas dans la classe ou dans une autre ressource.
Modules
Un module peut être défini comme une collection de toutes les configurations qui seraient utilisées par le maître Puppet pour appliquer des changements de configuration sur n'importe quel nœud Puppet particulier (agent). Ils sont également connus sous le nom de collection portable de différents types de configurations, qui sont nécessaires pour effectuer une tâche spécifique. Par exemple, un module peut contenir toutes les ressources nécessaires pour configurer Postfix et Apache.
Nœuds
Les nœuds sont une étape restante très simple qui consiste à faire correspondre ce que nous avons défini («c'est à quoi ressemble un serveur Web») à quelles machines sont choisies pour remplir ces instructions.
La définition de nœud ressemble exactement à des classes, y compris l'héritage de prise en charge, mais elles sont spéciales telles que lorsqu'un nœud (un ordinateur géré exécutant un client marionnette) se connecte au démon maître Puppet, son nom sera recherché dans la liste de nœuds définie. Les informations définies seront évaluées pour le nœud, puis le nœud enverra cette configuration.
Le nom de nœud peut être un nom d'hôte court ou le nom de domaine complet (FQDN).
node 'www.vipin.com' {
include common
include apache, squid
}La définition ci-dessus crée un nœud appelé www.vipin.com et inclut la classe commune, Apache et Squid
Nous pouvons envoyer la même configuration à différents nœuds en séparant chacun par une virgule.
node 'www.testing.com', 'www.testing2.com', 'www3.testing.com' {
include testing
include tomcat, squid
}Expression régulière pour les nœuds correspondants
node /^www\d+$/ {
include testing
}Héritage de nœud
Node prend en charge un modèle d'héritage limité. Comme les classes, les nœuds ne peuvent hériter que d'un autre nœud.
node 'www.testing2.com' inherits 'www.testing.com' {
include loadbalancer
}Dans le code ci-dessus, www.testing2.com hérite de toutes les fonctionnalités de www.testing.com en plus d'une classe d'équilibrage de charge supplémentaire.
Fonctionnalités avancées prises en charge
Quoting- Dans la plupart des cas, nous n'avons pas besoin de citer une chaîne dans Puppet. Toute chaîne alphanumérique commençant par une lettre doit être laissée sans guillemets. Cependant, il est toujours recommandé de citer une chaîne pour toutes les valeurs non négatives.
Interpolation variable avec citations
Jusqu'à présent, nous avons mentionné la variable en termes de définition. Si vous devez utiliser ces variables avec une chaîne, utilisez des guillemets doubles et non des guillemets simples. La chaîne de guillemets simples ne fera aucune interpolation de variable, la chaîne de guillemets doubles fera l'affaire. La variable peut être entre crochets{} ce qui les rend plus faciles à utiliser ensemble et à comprendre.
$value = "${one}${two}"Il est recommandé d'utiliser des guillemets simples pour toutes les chaînes qui ne nécessitent pas d'interpolation de chaîne.
Capitalisation
La capitalisation est un processus utilisé pour le référencement, l'héritage et la définition des attributs par défaut d'une ressource particulière. Il existe essentiellement deux manières fondamentales de l'utiliser.
Referencing- C'est la manière de référencer une ressource déjà créée. Il est principalement utilisé à des fins de dépendance, il faut mettre en majuscule le nom de la ressource. Exemple, require => file [sshdconfig]
Inheritance- Lorsque vous remplacez le paramètre de la classe parente de la sous-classe, utilisez la version majuscule du nom de la ressource. L'utilisation de la version minuscule entraînera une erreur.
Setting Default Attribute Value - L'utilisation de la ressource en majuscule sans titre permet de définir la valeur par défaut de la ressource.
Tableaux
Puppet permet l'utilisation de tableaux dans plusieurs zones [Un, deux, trois].
Plusieurs membres de type, tels que l'alias dans la définition d'hôte, acceptent les tableaux dans leurs valeurs. Une ressource hôte avec plusieurs alias ressemblera à quelque chose comme suit.
host { 'one.vipin.com':
alias => [ 'satu', 'dua', 'tiga' ],
ip => '192.168.100.1',
ensure => present,
}Le code ci-dessus ajoutera un hôte ‘one.brcletest.com’ à la liste d'hôtes avec trois alias ‘satu’ ‘dua’ ‘tiga’. Si l'on souhaite ajouter plusieurs ressources à une ressource, cela peut être fait comme indiqué dans l'exemple suivant.
resource { 'baz':
require => [ Package['rpm'], File['testfile'] ],
}Variables
Puppet prend en charge plusieurs variables comme la plupart des autres langages de programmation. Les variables de marionnettes sont désignées par$.
$content = 'some content\n'
file { '/tmp/testing': content => $content }Comme indiqué précédemment, Puppet est un langage déclaratif, ce qui signifie que sa portée et ses règles d'attribution sont différentes du langage impératif. La principale différence est que l'on ne peut pas modifier la variable dans une seule portée, car ils dépendent de l'ordre dans le fichier pour déterminer la valeur d'une variable. L'ordre n'a pas d'importance dans le langage déclaratif.
$user = root
file {
'/etc/passwd':
owner => $user,
}
$user = bin
file {
'/bin':
owner => $user,
recurse => true,
}Portée variable
La portée de la variable définit si toutes les variables définies sont valides. Comme pour les dernières fonctionnalités, Puppet est actuellement à portée dynamique, ce qui, en termes Puppet, signifie que toutes les variables qui sont définies sont évaluées sur leur portée plutôt que sur l'emplacement où elles sont définies.
$test = 'top'
class Testclass {
exec { "/bin/echo $test": logoutput => true }
}
class Secondtestclass {
$test = 'other'
include myclass
}
include SecondtestclassVariable qualifiée
Puppet prend en charge l'utilisation de variables qualifiées dans une classe ou une définition. Ceci est très utile lorsque l'utilisateur souhaite utiliser la même variable dans d'autres classes, qu'il a définies ou va définir.
class testclass {
$test = 'content'
}
class secondtestclass {
$other = $myclass::test
}Dans le code ci-dessus, la valeur de $ other variable évalue le contenu.
Conditionnels
Les conditions sont des situations dans lesquelles l'utilisateur souhaite exécuter un ensemble d'instructions ou de codes lorsque la condition définie ou la condition requise est satisfaite. Puppet prend en charge deux types de conditions.
La condition de sélecteur qui ne peut être utilisée que dans les ressources définies pour sélectionner la valeur correcte de la machine.
Les conditions de déclaration sont des conditions plus largement utilisées dans le manifeste, ce qui aide à inclure des classes supplémentaires que l'utilisateur souhaite inclure dans le même fichier manifeste. Définissez un ensemble distinct de ressources au sein d'une classe ou prenez d'autres décisions structurelles.
Sélecteurs
Les sélecteurs sont utiles lorsque l'utilisateur souhaite spécifier un attribut de ressource et des variables qui sont différents des valeurs par défaut en fonction des faits ou d'autres variables. Dans Puppet, l'index du sélecteur fonctionne comme un opérateur à trois valeurs à plusieurs valeurs. Les sélecteurs sont également capables de définir les valeurs par défaut personnalisées sans aucune valeur, qui sont définies dans le manifeste et correspondent à la condition.
$owner = $Sysoperenv ? {
sunos => 'adm',
redhat => 'bin',
default => undef,
}Dans les versions ultérieures de Puppet 0.25.0, les sélecteurs peuvent être utilisés comme expressions régulières.
$owner = $Sysoperenv ? {
/(Linux|Ubuntu)/ => 'bin',
default => undef,
}Dans l'exemple ci-dessus, le sélecteur $Sysoperenv La valeur correspond à Linux ou Ubuntu, alors le bac sera le résultat sélectionné, sinon l'utilisateur sera défini comme indéfini.
Condition de déclaration
La condition d'instruction est un autre type d'instruction conditionnelle dans Puppet qui est très similaire à la condition de changement de casse dans le script Shell. Dans ce cas, un ensemble multiple d'instructions de cas est défini et les valeurs d'entrée données sont comparées à chaque condition.
L'instruction case qui correspond à la condition d'entrée donnée est exécutée. Cette condition d'instruction case n'a aucune valeur de retour. Dans Puppet, un cas d'utilisation très courant de l'instruction de condition consiste à exécuter un ensemble de bits de code basé sur le système d'exploitation sous-jacent.
case $ Sysoperenv {
sunos: { include solaris }
redhat: { include redhat }
default: { include generic}
}Case Statement peut également spécifier plusieurs conditions en les séparant par une virgule.
case $Sysoperenv {
development,testing: { include development } testing,production: { include production }
default: { include generic }
}Instruction If-Else
Puppet prend en charge le concept de fonctionnement basé sur des conditions. Pour y parvenir, l'instruction If / else fournit des options de branchement basées sur la valeur de retour de la condition. Comme indiqué dans l'exemple suivant -
if $Filename {
file { '/some/file': ensure => present }
} else {
file { '/some/other/file': ensure => present }
}La dernière version de Puppet prend en charge les expressions variables dans lesquelles l'instruction if peut également créer une branche en fonction de la valeur d'une expression.
if $machine == 'production' {
include ssl
} else {
include nginx
}Afin d'obtenir plus de diversité dans le code et d'effectuer des opérations conditionnelles complexes, Puppet prend en charge l'instruction if / else imbriquée, comme indiqué dans le code suivant.
if $ machine == 'production' {
include ssl
} elsif $ machine == 'testing' {
include nginx
} else {
include openssl
}Ressource virtuelle
Les ressources virtuelles sont celles qui ne sont pas envoyées au client à moins qu'elles ne soient réalisées.
Voici la syntaxe d'utilisation de la ressource virtuelle dans Puppet.
@user { vipin: ensure => present }Dans l'exemple ci-dessus, l'utilisateur vipin est défini virtuellement pour réaliser la définition que l'on peut utiliser dans la collection.
User <| title == vipin |>commentaires
Les commentaires sont utilisés dans n'importe quel bit de code pour créer un nœud supplémentaire sur un ensemble de lignes de code et ses fonctionnalités. Dans Puppet, il existe actuellement deux types de commentaires pris en charge.
- Commentaires de style shell Unix. Ils peuvent être sur leur propre ligne ou sur la ligne suivante.
- Commentaires de style C sur plusieurs lignes.
Voici un exemple de commentaire de style shell.
# this is a commentVoici un exemple de commentaire multiligne.
/*
This is a comment
*/Priorité de l'opérateur
La priorité des opérateurs Puppet est conforme à la priorité standard de la plupart des systèmes, du plus élevé au plus bas.
Voici la liste des expressions
- ! = pas
- / = fois et diviser
- - + = moins, plus
- << >> = décalage gauche et décalage droit
- ==! = = différent, égal
- > = <=> <= supérieur égal, inférieur ou égal, supérieur à, inférieur à
Expression de comparaison
Les expressions de comparaison sont utilisées lorsque l'utilisateur souhaite exécuter un ensemble d'instructions lorsque la condition donnée est satisfaite. Les expressions de comparaison incluent des tests d'égalité à l'aide de l'expression ==.
if $environment == 'development' {
include openssl
} else {
include ssl
}Exemple pas égal
if $environment != 'development' {
$otherenvironment = 'testing'
} else {
$otherenvironment = 'production'
}Expression arithmétique
$one = 1
$one_thirty = 1.30
$two = 2.034e-2 $result = ((( $two + 2) / $one_thirty) + 4 * 5.45) -
(6 << ($two + 4)) + (0×800 + -9)Expression booléenne
Les expressions booléennes sont possibles en utilisant ou, et, & non.
$one = 1
$two = 2
$var = ( $one < $two ) and ( $one + 1 == $two )Expression régulière
Puppet prend en charge la correspondance d'expressions régulières en utilisant = ~ (match) et! ~ (Not-match).
if $website =~ /^www(\d+)\./ {
notice('Welcome web server #$1')
}Comme la correspondance de cas et de regex de sélecteur crée une variable de portée limitée pour chaque expression régulière.
exec { "Test":
command => "/bin/echo now we don’t have openssl installed on machine > /tmp/test.txt",
unless => "/bin/which php"
}De même, nous pouvons utiliser à moins que, à moins d'exécuter la commande tout le temps, à l'exception de la commande ci-dessous à moins qu'elle ne se termine avec succès.
exec { "Test":
command => "/bin/echo now we don’t have openssl installed on machine > /tmp/test.txt",
unless => "/bin/which php"
}Travailler avec des modèles
Les modèles sont utilisés lorsque l'on souhaite avoir une structure prédéfinie qui sera utilisée sur plusieurs modules dans Puppet et que ces modules seront distribués sur plusieurs machines. La première étape pour utiliser un modèle consiste à en créer un qui rend le contenu du modèle avec des méthodes de modèle.
file { "/etc/tomcat/sites-available/default.conf":
ensure => "present",
content => template("tomcat/vhost.erb")
}Puppet fait peu d'hypothèses lorsqu'il s'agit de fichiers locaux afin de renforcer l'organisation et la modularité. Puppet recherche le modèle vhost.erb dans le dossier apache / templates, dans le répertoire modules.
Définition et déclenchement des services
Dans Puppet, il dispose d'une ressource appelée service qui est capable de gérer le cycle de vie de tous les services exécutés sur une machine ou un environnement particulier. Les ressources de service sont utilisées pour s'assurer que les services sont initialisés et activés. Ils sont également utilisés pour le redémarrage du service.
Par exemple, dans le modèle précédent de tomcat, nous avons défini l'hôte virtuel apache. Si l'on veut s'assurer qu'apache est redémarré après un changement d'hôte virtuel, nous devons créer une ressource de service pour le service apache à l'aide de la commande suivante.
service { 'tomcat':
ensure => running,
enable => true
}Lors de la définition des ressources, nous devons inclure l'option de notification afin de déclencher le redémarrage.
file { "/etc/tomcat/sites-available/default.conf":
ensure => "present",
content => template("vhost.erb"),
notify => Service['tomcat']
}