Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esempio 8: gestione dei servizi
**Importante**
Il AWS OpsWorks Stacks servizio ha raggiunto la fine del ciclo di vita il 26 maggio 2024 ed è stato disattivato sia per i clienti nuovi che per quelli esistenti. Consigliamo vivamente ai clienti di migrare i propri carichi di lavoro verso altre soluzioni il prima possibile. Se hai domande sulla migrazione, contatta il Supporto AWS Team su [AWS re:post](https://repost.aws/) o tramite Premium [AWS Support](https://aws.amazon.com/support).
I pacchetti, ad esempio i server delle applicazioni, in genere hanno associato un servizio che deve essere avviato, arrestato, riavviato e così via. Ad esempio, è necessario avviare il servizio Tomcat dopo l'installazione del pacchetto o dopo il termine del processo di avvio dell'istanza e riavviare il servizio a ogni modifica del file di configurazione. In questo argomento vengono illustrati i concetti di base per la gestione di un servizio su un'istanza Linux, utilizzando un server delle applicazioni Tomcat come esempio. La risorsa service funziona quasi nello stesso modo sulle istanze Windows, anche se vi sono alcune differenze nei dettagli. Per ulteriori informazioni, consulta [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service).
**Nota**
L'esempio prevede un'installazione minima di Tomcat, quanto basta per illustrare le procedure fondamentali per l'utilizzo di una risorsa `service`. Per un esempio di come implementare ricette per un server Tomcat più funzionale, consulta [Creazione di un livello server Tomcat personalizzato](create-custom.md).
**Topics**
+ [Definizione e avvio di un servizio](#cookbooks-101-basics-services-service)
+ [Utilizzo di notifies per avviare o riavviare un servizio](#cookbooks-101-basics-services-notifies)
## Definizione e avvio di un servizio
Questa sezione mostra i concetti di base per definire e avviare un servizio.
**Per iniziare**
1. Nella directory `opsworks_cookbooks`, creare una directory denominata `tomcat` e aprirla.
1. Aggiungere un file `metadata.rb` a `tomcat` con il contenuto seguente.
```
name "tomcat"
version "0.1.0"
```
1. Inizializzare e configurare Test Kitchen come descritto in [Esempio 1: installazione di pacchetti](cookbooks-101-basics-packages.md), quindi rimuovere CentOS dall'elenco `platforms`.
1. Aggiungere la sottodirectory `recipes` a `tomcat`.
La gestione del servizio avviene tramite una risorsa [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service). La seguente ricetta di default installa Tomcat e avvia il servizio.
```
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 ricetta effettua le seguenti operazioni:
+ La risorsa `execute` esegue `apt-get update` per installare gli aggiornamenti correnti del sistema.
Per l'istanza di Ubuntu utilizzata in questo esempio, è necessario installare gli aggiornamenti prima di installare Tomcat. Altri sistemi possono avere requisiti diversi.
+ La risorsa `package` installa Tomcat 7.
+ La ricetta `tomcat::service` inclusa definisce il servizio e verrà discussa più avanti.
+ La risorsa `service` avvia il servizio Tomcat.
È anche possibile usare questa risorsa per l'esecuzione di altri comandi, ad esempio per interrompere e riavviare il servizio.
L'esempio seguente illustra la ricetta `tomcat::service`.
```
service 'tomcat' do
service_name "tomcat7"
supports :restart => true, :reload => false, :status => true
action :nothing
end
```
Questa ricetta crea la definizione del servizio Tomcat come segue:
+ Il nome della risorsa, `tomcat`, viene utilizzato da altre ricette per fare riferimento al servizio.
Ad esempio, `default.rb` fa riferimento a `tomcat` per avviare il servizio.
+ La risorsa `service_name` specifica il nome del servizio.
Nell'elenco dei servizi per l'istanza, il servizio Tomcat sarà denominato tomcat7.
+ `supports` specifica come Chef gestisce i comandi `restart`, `reload` e `status` del servizio.
+ `true` indica che Chef può utilizzare lo script init o un altro provider di servizi per eseguire il comando.
+ `false` indica che Chef deve tentare di eseguire il comando con altri mezzi.
Osserva che `action` è impostato su `:nothing`, che indica alla risorsa di non eseguire alcuna operazione. La risorsa service supporta azioni quali `start` e `restart`. Tuttavia, questo libro di ricette segue una pratica standard: l'utilizzo della definizione di un servizio che non richiede alcun intervento con avvio o riavvio del servizio altrove. Ogni ricetta che avvia o riavvia un servizio deve prima definirlo, perciò l'approccio più semplice è indicare in una ricetta separata la definizione del servizio e includerla in altre ricette in base alle esigenze.
**Nota**
Per semplicità, la ricetta di default per questo esempio utilizza una risorsa `service` per avviare il servizio dopo aver eseguito la definizione del servizio. Un'implementazione di produzione in genere avvia o riavvia un servizio utilizzando `notifies`, come illustrato più avanti.
**Per eseguire la ricetta**
1. Creare un file `default.rb` che contiene l'esempio di ricetta predefinita e salvarlo in `recipes`.
1. Creare un file `service.rb` che contiene l'esempio di definizione del servizio e salvarlo in `recipes`.
1. Eseguire `kitchen converge`, quindi effettuare l'accesso all'istanza ed eseguire il comando seguente per verificare che il servizio sia in esecuzione.
```
sudo service tomcat7 status
```
**Nota**
Se `service.rb` era in esecuzione separatamente da `default.rb`, è necessario modificare `.kitchen.yml` per aggiungere `tomcat::service` all'elenco di esecuzione. Tuttavia, quando si include una ricetta, il relativo codice viene incorporato nella ricetta padre prima che la ricetta viene eseguita. `service.rb` è quindi fondamentalmente una parte di `default.rb` e non richiede un elenco di esecuzione separato.
## Utilizzo di notifies per avviare o riavviare un servizio
Di solito, le implementazioni di produzione non utilizzano `service` per avviare o riavviare un servizio. Al contrario, aggiungono `notifies` a una qualsiasi delle diverse risorse. Ad esempio, se vuoi riavviare il servizio dopo la modifica di un file di configurazione, includi `notifies` nella risorsa `template` associata. L'utilizzo di `notifies` presenta i seguenti vantaggi rispetto all'utilizzo di una risorsa `service` per il riavvio esplicito del servizio.
+ L'elemento `notifies` riavvia il servizio solo se il file di configurazione associato è stato modificato, eliminando ogni rischio di riavvii superflui del servizio.
+ Chef riavvia il servizio al massimo una volta al termine di ogni sessione, indipendentemente dal numero di `notifies` contenuti nell'esecuzione.
Ad esempio, un'esecuzione Chef può includere più risorse di modelli, ciascuna delle quali modifica un file di configurazione differente e richiede il riavvio del servizio se il file è stato modificato. Tuttavia, in genere è preferibile riavviare il servizio solo una volta, alla fine dell'esecuzione Chef. In caso contrario, può succedere che si tenti di riavviare un servizio non ancora completamente operativo da un riavvio precedente, il che può causare errori.
In questo esempio viene modificato `tomcat::default` per includere una risorsa `template` che utilizza `notifies` per riavviare il servizio. Un esempio realistico potrebbe utilizzare una risorsa template che crea una versione personalizzata di uno dei file di configurazione Tomcat, che sono però alquanto lunghi e complessi. Per semplicità, l'esempio usa soltanto la risorsa template da [Creazione di un file da un modello](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template). Non ha niente a che fare con Tomcat, ma consente di illustrare in modo semplice come utilizzare `notifies`. Per un esempio che illustri come utilizzare i modelli per creare file di configurazione Tomcat, consulta [Ricette di impostazione](create-custom-setup.md).
**Per configurare il libro di ricette**
1. Aggiungere la sottodirectory `templates` a `tomcat` e la sottodirectory `default` a `templates`.
1. Copiare il modello `example_data.json.erb` dal libro di ricette `createfile` nella directory `templates/default`.
1. Aggiungere la sottodirectory `attributes` a `tomcat`.
1. Copiare il file attributo `default.rb` dal libro di ricette `createfile` nella directory `attributes`.
La seguente ricetta utilizza `notifies` per riavviare il servizio 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'esempio unisce la ricetta di [Creazione di un file da un modello](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template) e la ricetta della sezione precedente, con due modifiche rilevanti:
+ La risorsa `service` è ancora presente, ma con uno scopo leggermente diverso.
L'operazione `:enable` abilita il servizio Tomcat all'avvio.
+ La risorsa template ora include `notifies`, che riavvia il servizio Tomcat se `example_data.json` è stato modificato.
Questo garantisce che il servizio venga avviato quando alla prima installazione di Tomcat e riavviato dopo ogni modifica alla configurazione.
**Per eseguire la ricetta**
1. Eseguire `kitchen destroy` per iniziare con un'istanza pulita.
1. Sostituire il codice in `default.rb` con l'esempio precedente.
1. Eseguire `kitchen converge`, quindi accedere all'istanza e verificare che il servizio sia in esecuzione.
**Nota**
Se si desidera riavviare un servizio ma la ricetta non include una risorsa, ad esempio `template` che supporta `notifies`, è possibile utilizzare una risorsa fittizia `execute`. Ad esempio
```
execute 'trigger tomcat service restart' do
command 'bin/true'
notifies :restart, resources(:service => 'tomcat')
end
```
La risorsa `execute` deve avere un attributo `command`, anche se viene utilizzata solo come modo per eseguire `notifies`. Questo esempio aggira quel requisito eseguendo `/bin/true`, un comando shell che restituisce semplicemente un codice di riuscita.