Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejemplo 8: Administración de servicios
<a name="cookbooks-101-basics-services"></a>

**importante**  
El AWS OpsWorks Stacks servicio llegó al final de su vida útil el 26 de mayo de 2024 y se ha desactivado tanto para los clientes nuevos como para los actuales. Recomendamos encarecidamente a los clientes que migren sus cargas de trabajo a otras soluciones lo antes posible. Si tienes preguntas sobre la migración, ponte en contacto con el AWS Support equipo en [AWS Re:post](https://repost.aws/) o a través de Premium [AWS Support](https://aws.amazon.com/support).

Normalmente, los paquetes como servidores de aplicaciones tienen un servicio asociado que debe iniciarse, pararse, reiniciarse, etc. Por ejemplo, debe iniciar el servicio Tomcat después de instalar el paquete o después de que la instancia termine de arrancar, y reiniciar el servicio cada vez que modifique el archivo de configuración. En este tema se abordan los aspectos básicos de cómo administrar un servicio en una instancia de Linux, utilizando como ejemplo un servidor de aplicaciones Tomcat. El recurso del servicio funciona prácticamente de la misma manera en las instancias de Windows, aunque haya algunas diferencias de detalle. Para obtener más información, consulte [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service).

**nota**  
En el ejemplo se realiza una instalación de Tomcat mínima, lo suficiente para demostrar los aspectos básicos de cómo utilizar un recurso `service`. Si desea ver un ejemplo de cómo implementar recetas para tener un servidor Tomcat más funcional, consulte [Crear una capa personalizada de servidor Tomcat](create-custom.md).

**Topics**
+ [Definición e inicio de un servicio](#cookbooks-101-basics-services-service)
+ [Uso de notifies para iniciar o reiniciar un servicio](#cookbooks-101-basics-services-notifies)

## Definición e inicio de un servicio
<a name="cookbooks-101-basics-services-service"></a>

En esta sección se demuestran los aspectos básicos de cómo definir e iniciar un servicio.

**Primeros pasos**

1. En el directorio `opsworks_cookbooks`, cree un directorio llamado `tomcat` y ábralo.

1. Añada un archivo `metadata.rb` a `tomcat` con el contenido siguiente.

   ```
   name "tomcat"
   version "0.1.0"
   ```

1. Inicialice y configure Test Kitchen, tal y como se describe en [Ejemplo 1: Instalación de paquetes](cookbooks-101-basics-packages.md), y elimine CentOS de la lista `platforms`.

1. Añada un subdirectorio `recipes` a `tomcat`.

Se utiliza un recurso [https://docs.chef.io/chef/resources.html#service](https://docs.chef.io/chef/resources.html#service) para administrar un servicio. La siguiente receta predeterminada instala Tomcat e inicia el servicio.

```
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 receta hace lo siguiente:
+ El recurso `execute` ejecuta `apt-get update` para instalar las actualizaciones del sistema actuales.

  Para la instancia de Ubuntu utilizada en este ejemplo, debe instalar las actualizaciones antes de instalar Tomcat. Es posible que otros sistemas tengan requisitos diferentes.
+ El recurso `package` instala Tomcat 7.
+ La receta `tomcat::service` incluida define el servicio y se trata más adelante.
+ El recurso `service` inicia el servicio Tomcat.

  También puede utilizar este recurso para ejecutar otros comandos, como parar o reiniciar el servicio.

En el ejemplo siguiente se demuestra la receta `tomcat::service`.

```
service 'tomcat' do
  service_name "tomcat7"
  supports :restart => true, :reload => false, :status => true
  action :nothing
end
```

Esta receta crea la definición del servicio Tomcat de la siguiente manera: 
+ Otros recursos utilizan el nombre del recurso, `tomcat`, para hacer referencia el servicio.

  Por ejemplo, `default.rb` hace referencia a `tomcat` para iniciar el servicio.
+ El recurso `service_name` especifica el nombre del servicio. 

  Cuando genera una lista de los servicios de la instancia, el servicio Tomcat recibe el nombre tomcat7.
+ `supports` especifica cómo Chef administra los comandos `restart`, `reload` y `status` del servicio.
  + `true` indica que Chef puede utilizar el script init u otro proveedor de servicios para ejecutar el comando.
  + `false` indica que Chef debe intentar ejecutar el comando por otros medios.

Observe que `action` está establecido en `:nothing`, lo que indica al recurso que no debe realizar ninguna acción. El recurso de servicio es compatible con acciones como `start` y `restart`. Sin embargo, este libro de recetas sigue una práctica estándar de utilizar una definición de servicio que no tiene acción e iniciar o reiniciar el servicio en otro punto. Cada receta que empieza o reinicia un servicio primero debe definirlo, por lo que el enfoque más sencillo es poner la definición del servicio en una receta independiente e incluirla en otras recetas según las necesidades.

**nota**  
En aras a la sencillez, la receta predeterminada de este ejemplo utiliza un recurso `service` para iniciar el servicio después de ejecutar la definición del servicio. Normalmente, una implementación de producción inicia o reinicia un servicio mediante `notifies`, tal y como se explica más adelante.

**Para ejecutar la receta**

1. Cree un archivo `default.rb` que contenga el ejemplo de receta predeterminado y guárdelo en `recipes`.

1. Cree un archivo `service.rb` que contenga el ejemplo de definición del servicio y guárdelo en `recipes`.

1. Ejecute `kitchen converge` y, a continuación, inicie sesión en la instancia y ejecute el siguiente comando para verificar que el servicio se esté ejecutando.

   ```
   sudo service tomcat7 status
   ```

**nota**  
Si estaba ejecutando `service.rb` por separado de `default.rb`, tendrá que editar `.kitchen.yml` para añadir `tomcat::service` a la lista de ejecución. Sin embargo, cuando incluya una receta, su código se incorpora en la receta de matrices antes de que se ejecute la receta. Por lo tanto, `service.rb` es básicamente una parte de `default.rb` y no requiere una entrada de lista de ejecución diferente.

## Uso de notifies para iniciar o reiniciar un servicio
<a name="cookbooks-101-basics-services-notifies"></a>

Por lo general, las implementaciones de producción no utilizan `service` para iniciar o reiniciar un servicio. En su lugar, añaden `notifies` a cualquiera de varios recursos. Por ejemplo, si quiere reiniciar el servicio después de modificar un archivo de configuración, incluya `notifies` en el recurso `template` asociado. El uso de `notifies` para reiniciar explícitamente el servicio reporta las siguientes ventajas en comparación con el uso de un recurso `service`. 
+ El elemento `notifies` reinicia el servicio únicamente si el archivo de configuración asociado ha cambiado, por lo que no hay riesgo de provocar un reinicio del servicio innecesario. 
+ Chef reinicia el servicio como máximo una vez al final de cada ejecución, sea cual sea el número de `notifies` que la ejecución contenga.

  Por ejemplo, la ejecución de Chef puede incluir varios recursos de plantilla, cada uno de los cuales modifica un archivo de configuración diferente y requiere un reinicio de servicio si el archivo ha cambiado. Ahora bien, normalmente se quiere reiniciar el servicio una única vez, al final de la ejecución de Chef. De lo contrario, es posible que intente reiniciar un servicio que aún no esté totalmente operativo después de un reinicio anterior, lo que puede dar lugar a errores.

En este ejemplo se modifica `tomcat::default` para incluir un recurso `template` que utiliza `notifies` para reiniciar el servicio. Un ejemplo realista utilizaría un recurso de plantilla para crear una versión personalizada de uno de los archivos de configuración de Tomcat, pero son bastante largos y complejos. Para mayor simplicidad, el ejemplo se limita a utilizar el recurso de plantilla de [Creación de un archivo a partir de una plantilla](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template). No tiene nada que ver con Tomcat, pero es una forma sencilla de mostrar cómo utilizar `notifies`. Para ver un ejemplo de cómo utilizar plantillas para crear archivos de configuración de Tomcat, consulte [Recetas de instalación](create-custom-setup.md).

**Para configurar el libro de recetas**

1. Añada un subdirectorio `templates` a `tomcat` y un subdirectorio `default` a `templates`.

1. Copie la plantilla `example_data.json.erb` del libro de recetas `createfile` en el directorio `templates/default`.

1. Añada un subdirectorio `attributes` a `tomcat`.

1. Copie el archivo de atributos `default.rb` del libro de recetas `createfile` en el directorio `attributes`.

En la siguiente receta se utiliza `notifies` para reiniciar el servicio 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
```

El ejemplo fusiona la receta de [Creación de un archivo a partir de una plantilla](cookbooks-101-basics-files.md#cookbooks-101-basics-files-template) en la receta de la sección anterior, con dos cambios importantes:
+ El recurso `service` sigue existiendo, pero ahora su objetivo es algo diferente.

  La acción `:enable` habilita el servicio Tomcat al arrancar.
+ Ahora, el recurso de plantilla contiene `notifies`, lo que permite reiniciar el servicio Tomcat si `example_data.json` ha cambiado.

  De este modo, se garantiza que el servicio se inicie cuando Tomcat se instale por primera vez y se reinicie después de cada cambio de configuración.

**Para ejecutar la receta**

1. Ejecute `kitchen destroy` para comenzar por una instancia limpia.

1. Sustituya el código de `default.rb` por el ejemplo anterior.

1. Ejecute `kitchen converge` y, a continuación, inicie sesión en la instancia y verifique que el servicio se esté ejecutando.

**nota**  
Si quiere reiniciar un servicio, pero la receta no contiene un recurso como `template` que admita `notifies`, puede utilizar un recurso ficticio `execute` en su lugar. Por ejemplo  

```
execute 'trigger tomcat service restart' do
  command 'bin/true'
  notifies :restart, resources(:service => 'tomcat')
end
```
El recurso `execute` debe tener un atributo `command`, incluso si está utilizando el recurso únicamente como forma de ejecutar `notifies`. Este ejemplo evita este requisito al ejecutar `/bin/true`, que es un comando de shell que simplemente devuelve un código de éxito.