As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exemplo 8: Gerenciamento de serviços
**Importante**
O AWS OpsWorks Stacks serviço chegou ao fim da vida útil em 26 de maio de 2024 e foi desativado para clientes novos e existentes. É altamente recomendável que os clientes migrem suas cargas de trabalho para outras soluções o mais rápido possível. Se você tiver dúvidas sobre migração, entre em contato com a AWS Support equipe no [AWS re:POST](https://repost.aws/) ou por meio do Premium [AWS Support](https://aws.amazon.com/support).
Pacotes como servidores de aplicação normalmente têm um serviço associado que deve ser iniciado, parado, reiniciado etc. Por exemplo, você precisará iniciar o serviço Tomcat depois de instalar o pacote ou a instância terminar a inicialização e reiniciar o serviço sempre que modificar o arquivo de configuração. Este tópico aborda os conceitos básicos de como gerenciar um serviço em uma instância do Linux usando um servidor de aplicações Tomcat como um exemplo. O recurso de serviço funciona da mesma maneira que instâncias do Windows, embora haja algumas diferenças em detalhes. Para obter mais informações, consulte [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service).
**nota**
O exemplo faz uma instalação do Tomcat muito mínima, apenas o suficiente para demonstrar os conceitos básicos de como usar um recurso `service`. Para obter um exemplo de como implementar receitas para um servidor Tomcat mais funcional, consulte [Criação de uma camada de servidor Tomcat personalizada](create-custom.md).
**Topics**
+ [Definição e inicialização de um serviço](#cookbooks-101-basics-services-service)
+ [Uso de notifies para iniciar ou reiniciar um serviço](#cookbooks-101-basics-services-notifies)
## Definição e inicialização de um serviço
Esta seção mostra os conceitos básicos de como definir e iniciar um serviço.
**Para começar**
1. No diretório `opsworks_cookbooks`, crie um diretório com nome `tomcat` e navegue até ele.
1. Adicione um arquivo `metadata.rb` a `tomcat`, com o seguinte conteúdo.
```
name "tomcat"
version "0.1.0"
```
1. Inicialize e configure o Test Kitchen, conforme descrito em [Exemplo 1: Instalação de pacotes](cookbooks-101-basics-packages.md) e remova CentOS da lista `platforms`.
1. Adicione um subdiretório `recipes` a `tomcat`.
Você usa um recurso [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service) para gerenciar um serviço. A receita padrão a seguir instala o Tomcat e inicia o serviço.
```
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
```
A receita faz o seguinte:
+ O recurso `execute` executa `apt-get update` para instalar as atualizações do sistema atual.
Para a instância do Ubuntu usada neste exemplo, você deverá instalar as atualizações antes de instalar o Tomcat. Outros sistemas podem ter requisitos diferentes.
+ O recurso `package` instala o Tomcat 7.
+ A receita`tomcat::service` incluída define o serviço e será abordada depois.
+ O recurso `service` inicia o serviço Tomcat.
Você também pode usar esse recurso para emitir outros comandos, como parar e reiniciar o serviço.
O exemplo a seguir mostra a receita `tomcat::service`.
```
service 'tomcat' do
service_name "tomcat7"
supports :restart => true, :reload => false, :status => true
action :nothing
end
```
Essa receita cria a definição do serviço Tomcat da seguinte forma:
+ O nome do recurso, `tomcat`, é usado por outras receitas para referenciar o serviço.
Por exemplo, `default.rb` referencia `tomcat` para iniciar o serviço.
+ O recurso `service_name` especifica o nome do serviço.
Quando você listar os serviços na instância, o serviço Tomcat será chamado de tomcat7.
+ `supports` especifica como o Chef gerencia os comandos `restart`, `reload`e `status` do serviço.
+ `true` indica que o Chef pode usar o script init ou outro provedor de serviços para executar o comando.
+ `false` indica que o Chef deve tentar executar o comando por outros meios.
Observe que `action` é definido como `:nothing`, que leva o recurso a não realizar ação alguma. O recurso de serviço não dá suporte a ações como `start` e `restart`. No entanto, esse livro de receitas segue uma prática padrão de como usar uma definição de serviço que não realiza ação alguma e iniciar ou reiniciar o serviço em outro lugar. Cada receita que inicia ou reinicia um serviço deve primeiramente defini-la. Assim, a abordagem mais simples é colocar a definição de serviço em uma receita à parte e incluí-la em outras receitas, conforme necessário.
**nota**
Por uma questão de simplicidade, a receita padrão deste exemplo usa um recurso `service` para iniciar o serviço após a execução da definição do serviço. Uma implementação de produção normalmente inicia ou reinicia um serviço usando `notifies`, conforme será debatido depois.
**Para executar a receita**
1. Crie um arquivo `default.rb` que contenha o exemplo de receita padrão e o salve em `recipes`.
1. Crie um arquivo `service.rb` que contenha o exemplo de definição do serviço e o salve em `recipes`.
1. Execute `kitchen converge`, faça logon na instância e execute o comando a seguir para verificar se o serviço está em execução.
```
sudo service tomcat7 status
```
**nota**
Se estivesse executando `service.rb` separadamente de `default.rb`, você teria que editar `.kitchen.yml` para adicionar `tomcat::service` à lista de execuções. No entanto, quando você incluir uma receita, o código será incorporado à receita pai antes da receita ser executada. Por isso, `service.rb` é basicamente uma parte de `default.rb` e não exige uma entrada da lista de execuções à parte.
## Uso de notifies para iniciar ou reiniciar um serviço
As implementações de produção normalmente não usam `service` para iniciar ou reiniciar um serviço. Em vez disso, elas adicionam `notifies` a qualquer um dos vários recursos. Por exemplo, caso queira reiniciar o serviço depois de modificar um arquivo de configuração, você inclui `notifies` no recurso `template` associado. O uso de `notifies` tem as vantagens a seguir em relação ao uso de um recurso `service` para reiniciar explicitamente o serviço.
+ O elemento `notifies` só reiniciará o serviço se o arquivo de configuração associado tiver sido alterado. Assim, não há risco de causar uma reinicialização desnecessária do serviço.
+ O Chef reinicia o serviço no máximo uma vez ao final de cada execução, independentemente de quantos `notifies` a execução contenha.
Por exemplo, a execução do Chef pode incluir vários recursos do modelo, e cada um deles modifica um arquivo de configuração diferente e exige a reinicialização de um serviço caso o arquivo tenha sido alterado. No entanto, você normalmente só deseja reiniciar o serviço uma vez, ao final da execução do Chef. Do contrário, você pode tentar reiniciar um serviço que ainda não esteja totalmente operacional após uma reinicialização anterior, o que pode causar erros.
Este exemplo modifica `tomcat::default` para incluir um recurso `template` que usa `notifies` para reiniciar o serviço. Um exemplo realista usaria um recurso de modelo que cria uma versão personalizada de um dos arquivos de configuração do Tomcat, mas eles acabam sendo longos e complexos. Para simplificar, o exemplo usa apenas o recurso de modelo de [Criação de um arquivo usando um modelo](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template). Ele não tem a ver com o Tomcat, mas oferece uma maneira simples de mostrar como usar `notifies`. Para obter um exemplo sobre como usar modelos para criar arquivos de configuração do Tomcat, consulte [Receitas de instalação](create-custom-setup.md).
**Para configurar o livro de receitas**
1. Adicione um subdiretório `templates` e `tomcat` e um subdiretório `default` a `templates`.
1. Copie o modelo `example_data.json.erb` do livro de receitas `createfile` para o diretório `templates/default`.
1. Adicione um subdiretório `attributes` a `tomcat`.
1. Copie o arquivo de atributo `default.rb` do livro de receitas `createfile` para o diretório `attributes`.
A receita a seguir usa `notifies` para reiniciar o serviço 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
```
O exemplo mescla a receita de [Criação de um arquivo usando um modelo](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template) à receita da seção anterior, com duas alterações significativas:
+ O recurso `service` ainda está lá, mas agora atende a uma finalidade um pouco diferente.
A ação `:enable` habilita o serviço Tomcat na inicialização.
+ O recurso de modelo já inclui `notifies`, que reinicia o serviço Tomcat caso `example_data.json` tenha sido alterado.
Isso garante que o serviço seja iniciado quando Tomcat é instalado e reiniciado inicialmente após cada alteração feita na configuração.
**Para executar a receita**
1. Execute `kitchen destroy` para começar com uma instância limpa.
1. Substitua o código em `default.rb` pelo exemplo anterior.
1. Execute `kitchen converge`, faça logon na instância e verifique se o serviço está em execução.
**nota**
Caso queira reiniciar um serviço, mas a receita não inclua um recurso, como `template` que dê suporte a `notifies`, você pode usar um recurso `execute` fictício em seu lugar. Por exemplo
```
execute 'trigger tomcat service restart' do
command 'bin/true'
notifies :restart, resources(:service => 'tomcat')
end
```
O recurso `execute` deve ter um atributo `command`, mesmo que você só esteja usando o recurso como uma maneira de executar `notifies`. Esse exemplo contorna esse requisito executando `/bin/true`, que é um comando do shell que simplesmente retorna um código de êxito.