Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemple 8 : Gestion des services
**Important**
Le AWS OpsWorks Stacks service a pris fin le 26 mai 2024 et a été désactivé tant pour les nouveaux clients que pour les clients existants. Nous recommandons vivement aux clients de migrer leurs charges de travail vers d'autres solutions dès que possible. Si vous avez des questions sur la migration, contactez l' AWS Support équipe sur [AWS Re:Post](https://repost.aws/) ou via le [AWS Support](https://aws.amazon.com/support) Premium.
Les packages tels que les serveurs d'application ont généralement un service associé qui doit être démarré, arrêtée, redémarré, etc. Par exemple, vous devez commencer le service Tomcat après avoir installé le package ou une fois que l'instance a terminé le démarrage, puis redémarrer le service chaque fois que vous modifiez le fichier de configuration. Cette rubrique présente les bases de la gestion d'un service sur une instance Linux, à l'aide d'un serveur d'application Tomcat à titre d'exemple. La ressource de service fonctionne de la même manière sur les instances Windows, bien qu'il existe quelques différences dans le détail. Pour de plus amples informations, veuillez consulter [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service).
**Note**
L'exemple est une installation de Tomcat très minimale, juste suffisante pour montrer les bases de l'utilisation d'une ressource `service`. Pour obtenir un exemple de l'implémentation des recettes afin d'obtenir un serveur Tomcat plus fonctionnel, consultez [Création d'une couche serveur Tomcat personnalisée](create-custom.md).
**Topics**
+ [Définition et démarrage d'un service](#cookbooks-101-basics-services-service)
+ [Utilisation de notifies pour démarrer ou redémarrer un service](#cookbooks-101-basics-services-notifies)
## Définition et démarrage d'un service
Cette section montre les bases de la définition et du démarrage d'un service.
**Mise en route**
1. Dans le répertoire `opsworks_cookbooks`, créez un répertoire nommé `tomcat` et accédez à celui-ci.
1. Ajoutez un fichier `metadata.rb` à `tomcat` avec le contenu suivant.
```
name "tomcat"
version "0.1.0"
```
1. Initialisez et configurez Test Kitchen, comme décrit dans [Exemple 1 : Installation des packages](cookbooks-101-basics-packages.md)et supprimez CentOS de la liste `platforms`.
1. Ajoutez un sous-répertoire `recipes` à `tomcat`.
Vous utilisez une ressource [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service) pour gérer un service. La recette par défaut suivante installe Tomcat et démarre le service.
```
execute "install_updates" do
command "apt-get update"
end
package "tomcat7" do
action :install
end
include_recipe 'tomcat::service'
service 'tomcat' do
action :start
end
```
La recette exécute les tâches suivantes :
+ La ressource `execute` exécute `apt-get update` pour installer les mises à jour actuelles du système.
Pour l'instance Ubuntu utilisée dans cet exemple, vous devez installer les mises à jour avant d'installer Tomcat. D'autres systèmes peuvent avoir des exigences différentes.
+ La ressource `package` installe Tomcat 7.
+ La recette `tomcat::service` incluse définit le service et nous reviendrons sur ce point plus tard.
+ La ressource `service` démarre le service Tomcat.
Vous pouvez également utiliser cette ressource afin d'émettre d'autres commandes, telles que l'arrêt et le redémarrage du service.
L'exemple suivant montre la recette `tomcat::service`.
```
service 'tomcat' do
service_name "tomcat7"
supports :restart => true, :reload => false, :status => true
action :nothing
end
```
Cette recette crée la définition du service Tomcat comme suit :
+ Le nom de la ressource, `tomcat`, est utilisé par d'autres recettes pour référencer le service.
Par exemple, `default.rb` référence `tomcat` pour démarrer le service.
+ La ressource `service_name` spécifie le nom du service.
Lorsque vous listez les services sur l'instance, le service Tomcat est nommé tomcat7.
+ `supports` spécifie la façon dont Chef gère les commandes `restart`, `reload` et `status` du service.
+ `true` indique que Chef peut utiliser le script init ou un autre fournisseur de services pour exécuter la commande.
+ `false` indique que le Chef doit tenter d'exécuter la commande par d'autres moyens.
Notez qu'`action` est définie sur `:nothing`, une valeur qui indique à la ressource de ne rien faire. La ressource de service prend en charge les actions telles que `start` et `restart`. Toutefois, ce livre de recettes suit une pratique standard d'utilisation d'une définition de service qui ne réalise aucune action et de démarrage ou de redémarrage du service ailleurs. Chaque recette qui démarre ou redémarre un service doit d'abord le définir, ce qui signifie que l'approche la plus simple consiste à mettre la définition de service dans une recette distincte et à l'inclure dans les autres recettes en fonction des besoins.
**Note**
A des fins de simplicité, la recette par défaut pour cet exemple utilise une ressource `service` pour démarrer le service après l'exécution de la définition de service. Une implémentation de production démarre ou redémarre généralement un service à l'aide de `notifies`, comme indiqué plus tard.
**Pour exécuter la recette**
1. Créez un fichier `default.rb` qui contient l'exemple de recette par défaut et enregistrez-le dans `recipes`.
1. Créez un fichier `service.rb` qui contient l'exemple de définition de service et enregistrez-le dans `recipes`.
1. Exécutez `kitchen converge`, puis connectez-vous à l'instance et exécutez la commande suivante pour vérifier si le service est en cours d'exécution.
```
sudo service tomcat7 status
```
**Note**
Si vous exécutiez `service.rb` séparément de `default.rb`, vous devrez modifier `.kitchen.yml` de façon à ajouter `tomcat::service` à la liste d'exécution. Toutefois, lorsque vous incluez une recette, son code est intégré dans la recette parent avant l'exécution de la recette. `service.rb` fait donc globalement partie de `default.rb` et n'a pas besoin d'une entrée de liste d'exécution distincte.
## Utilisation de notifies pour démarrer ou redémarrer un service
En règle générale, l'implémentation de production n'utilise pas `service` pour démarrer ou redémarrer un service. En revanche, elle ajoute `notifies` à une ressource. Par exemple, si vous souhaitez redémarrer le service après avoir modifié un fichier de configuration, vous incluez `notifies` dans la ressource `template` associée. L'utilisation de `notifies` a les avantages suivants par rapport à l'utilisation d'une ressource `service` pour redémarrer explicitement le service.
+ L'élément `notifies` redémarre le service si le fichier de configuration associé a changé, il n'y a donc aucun risque de provoquer un redémarrage inutile du service.
+ Chef redémarre le service au plus une fois à la fin de chaque exécution, quel que soit le nombre de `notifies` dans l'exécution.
Par exemple, l'exécution de Chef peut inclure plusieurs ressources de modèle, chacune modifiant un fichier de configuration différent et nécessitant un redémarrage du service si le fichier a été modifié. Cependant, vous souhaitez généralement redémarrer le service une seule fois, à la fin de l'exécution de Chef. Sinon, vous pourriez tenter de redémarrer un service qui n'est pas encore entièrement opérationnel et fait partie d'un redémarrage antérieur, ce qui peut entraîner des erreurs.
Cet exemple modifie `tomcat::default` de façon à inclure une ressource `template` qui utilise `notifies` pour redémarrer le service. Un exemple réaliste utiliserait une ressource de modèle qui crée une version personnalisée de l'un des fichiers de configuration Tomcat, mais celles-ci sont assez longues et complexes. A des fins de simplicité, l'exemple utilise uniquement le modèle de ressource de [Création d'un fichier à partir d'un modèle](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template). Il n'a rien à voir avec Tomcat, mais il offre un moyen simple de montrer comment utiliser `notifies`. Pour obtenir un exemple de l'utilisation des modèles pour créer des fichiers de configuration Tomcat, consultez [Recettes Setup](create-custom-setup.md).
**Pour configurer le livre de recettes**
1. Ajoutez un sous-répertoire `templates` à `tomcat` et un sous-répertoire `default` à `templates`.
1. Copiez le modèle `example_data.json.erb` du livre de recettes `createfile` dans le répertoire `templates/default`.
1. Ajoutez un sous-répertoire `attributes` à `tomcat`.
1. Copiez le fichier d'attribut `default.rb` du livre de recettes `createfile` dans le répertoire `attributes`.
La recette suivante utilise `notifies` pour redémarrer le service Tomcat.
```
execute "install_updates" do
command "apt-get update"
end
package "tomcat7" do
action :install
end
include_recipe 'tomcat::service'
service 'tomcat' do
action :enable
end
directory "/srv/www/shared" do
mode 0755
owner 'root'
group 'root'
recursive true
action :create
end
template "/srv/www/shared/example_data.json" do
source "example_data.json.erb"
mode 0644
variables(
:a_boolean_var => true,
:a_string_var => "some string"
)
only_if {node['createfile']['install_file']}
notifies :restart, resources(:service => 'tomcat')
end
```
L'exemple fusionne la recette de [Création d'un fichier à partir d'un modèle](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template) dans la recette de la section précédente, avec deux modifications importantes :
+ La ressource `service` est toujours là, mais elle a désormais une utilité légèrement différente.
L'action `:enable` active le service Tomcat au moment du démarrage.
+ Le modèle de ressource inclut maintenant `notifies`, qui redémarre le service Tomcat si `example_data.json` a changé.
De cette façon, le service est démarré lorsque Tomcat est installé pour la première fois et redémarré après chaque changement de configuration.
**Pour exécuter la recette**
1. Exécutez `kitchen destroy` pour commencer avec une instance propre.
1. Remplacez le code de `default.rb` par l'exemple précédent.
1. Exécutez `kitchen converge`, puis connectez-vous à l'instance et vérifiez que le service est en cours d'exécution.
**Note**
Si vous voulez redémarrer un service, mais que la recette n'inclut pas de ressource telle que `template` qui prend en charge `notifies`, vous pouvez utiliser une ressource `execute` factice à la place. Par exemple
```
execute 'trigger tomcat service restart' do
command 'bin/true'
notifies :restart, resources(:service => 'tomcat')
end
```
La ressource `execute` doit avoir un attribut `command`, même si vous utilisez la ressource uniquement pour exécuter `notifies`. Cet exemple contourne cette exigence en exécutant `/bin/true`, une commande shell qui retourne simplement un code de réussite.