¿Cómo implementar aplicaciones (en .tar.gz) con Puppet?

Soy un principiante con Puppet y me gustaría saber si estoy en el camino correcto para implementar aplicaciones con Puppet.

Las aplicaciones están en un archivo tar.gz que contiene un archivo con el número de versión. Entonces, hago esto para implementar (voy al servidor y hago un reinicio del cliente para recoger el nuevo tarball):

nodes.pp

node 'server1.domain.com' inherits basenode {
    apps { apps:
            version => 56,
            apps_name => "apps_tarball.tgz",
    }


init.pp (modules)

exec {"apps_wget":
            command => "/usr/bin/wget http://web_server/${version}-${apps_name} -O /tmp/${container_zip_name}",
            unless  => "test -f /tmp/${version}-${apps_name}",
            require => [ Package["wget"] ],
    }

exec {"apps_unzip":
            cwd     => "/usr/local/apps/path",
            command => "/usr/bin/unzip /tmp/${version}-${apps_name}",
            unless  => "test -f /usr/local/apps/path/apps-version-${version}",
            require => [ Package["unzip"], Exec["container_wget"] ],
    }

Pero, cuando quiero actualizar, no sé decir Puppet para eliminar el directorio anterior. Por ejemplo, si quiero actualizar la versión 56 a 57: debo eliminar el directorio de la versión 56.

Escuché sobre Capristrano y parece mejor usar Puppet para administrar paquetes, configurar archivos y usar Capristrano para implementar aplicaciones, ¿no es así?

Gracias.

Me gustaría saber si estoy en el camino correcto para implementar aplicaciones con Puppet.

No, no lo eres.

Debe usar la administración de paquetes disponible en su sistema operativo. Si su software está en tar.gzformato, debe volver a empaquetarlo localmente como .deb, .rpmo lo que sea.

Si el software es algo desarrollado localmente, debe utilizar las herramientas de compilación / implementación disponibles.

Es posible que desee intentar usar fpm para hacer RPM o DEB de sus tarballs; es realmente fácil de usar y no tiene que entender nada sobre los formatos de paquete que no desea.

Para responder a su pregunta original, la forma correcta de implementar aplicaciones con Puppet es hacer que Puppet haga el menor trabajo posible; cualquier execrecurso complicado que descargue y extraiga tarballs será muy, muy frágil, y hacer de Puppet yum installun paquete es mucho más saludable a largo plazo.

Me esforzaría mucho para agrupar la aplicación como un paquete RPM o .deb y construir un repositorio yum o apt para guardar los paquetes. El empaquetado de un tarball o zip que acaba de abrir en un directorio es bastante fácil (pero debería ser una pregunta por separado). El empaque disponible de esa manera rastrea las versiones muy bien y maneja todo tipo de cosas que simplemente abriendo un tarball no se manejarán bien.

Si realmente no pudiera construir un paquete adecuado, haría algo como esto:

node.pp:

node 'server1.domain.com' inherits basenode {
    apps { apps:
            version    => 56,
            oldversion => 55,
            apps_name  => "apps_tarball.tgz",
    }

init.pp (módulos):

file {
   [ "/usr/local/apps/path/apps-version-${oldversion}", "/tmp/${oldversion}-${apps_name}" ]:
            recurse => true,
            ensure  => absent;
}
exec {
      "apps_wget_${apps_name}":
            command   => "/usr/bin/wget http://web_server/${version}-${apps_name} -O /tmp/${container_zip_name}",
            logoutput => on_failure,
            creates   => "/tmp/${version}-${apps_name}",
            require   => [ Package["wget"] ];

      "apps_unzip_${apps_name}":
            cwd     => "/usr/local/apps/path",
            command => "/usr/bin/unzip /tmp/${version}-${apps_name}",
            creates => "/usr/local/apps/path/apps-version-${version}",
            require => [ Package["unzip"], Exec["container_wget"], Exec["apps_wget_${apps_name}] ];
}

Otra alternativa es simplemente usar un recurso títere recursivo como:

file {
    "/usr/local/apps/path/":
      source => "puppet:///modules/modulename/apps/path",
      ensure => directory,
      replace => true,
      purge   => true,
      recurse => true;
}

(donde ya ha descomprimido correctamente las cosas en el titiritero. Probablemente también requiera cualquier paquete que esté ejecutando el servicio y notifique el servicio del que se está ejecutando).

file { "/usr/local/apps/path/apps-version-${old-version}":
    ensure => absent
}

Por otro lado, hacer todo como ejecutivo es un poco feo y puede ser difícil de solucionar cuando las cosas comienzan a romperse; si puede, ¿puede mantener versiones extraídas de los archivos de la aplicación en el servidor de marionetas y utilizar un filerecurso recursivo para recuperar?

Ciertamente estoy a favor de empaquetar el tarball (RPM o lo que sea), pero algunos consejos:

Para eliminar la versión anterior, simplemente puede eliminar todas las versiones excepto la que está instalando. Con un bash y extglob suficientemente reciente habilitado, puedes hacerlo rm -r /usr/local/apps/path/apps-version-!(${version}). Tenga cuidado de borrar los archivos de configuración y demás. Puede hacer el exec refreshonly => truey luego notifydesde el archivo de instalación.

Puede usar el createsatributo en lugar de unless => 'test -f ...'. Un pero más comprensible.