Comment déployer des applications (en .tar.gz) avec Puppet?

Je suis un débutant avec Puppet et je voudrais savoir si je suis sur la bonne voie pour déployer des applications avec Puppet.

Les applciations sont dans un fichier tar.gz qui contient un fichier avec le numéro de version. Donc, je fais cela pour déployer (je vais sur le serveur et je redémarre le client pour récupérer la nouvelle archive tar):

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"] ],
    }

Mais, quand je veux mettre à jour, je ne sais pas dire Puppet pour supprimer l'ancien répertoire? Par exemple, si je souhaite mettre à niveau la version 56 à 57: je dois supprimer le répertoire de version du 56.

J'ai entendu parler de Capristrano et il semble préférable d'utiliser Puppet pour gérer des packages, configurer des fichiers et utiliser Capristrano pour déployer des applications, n'est-ce pas?

Merci.

Je voudrais savoir si je suis sur la bonne voie pour déployer des applications avec Puppet.

Non tu ne l'es pas.

Vous devez utiliser la gestion des packages disponible sur votre système d'exploitation. Si votre logiciel est au tar.gzformat, vous devez le reconditionner localement en tant que .deb, .rpmou autre chose.

Si le logiciel est développé localement, vous devez utiliser tous les outils de création / déploiement disponibles.

Vous voudrez peut-être essayer d'utiliser fpm pour créer des RPM ou DEB de vos tarballs; c'est vraiment simple à utiliser, et vous n'avez rien à comprendre sur les formats de package que vous ne voulez pas.

Pour répondre à votre question initiale, la bonne façon de déployer des applications avec Puppet est de faire en sorte que Puppet fasse le moins de travail possible; toutes les execressources compliquées qui téléchargent et extraient des archives tar sont très, très fragiles, et faire de Puppet yum installun package est beaucoup plus sain à long terme.

J'essaierais très fort de regrouper l'application en tant que package RPM ou .deb et de créer un référentiel yum ou apt pour contenir les packages. L'empaquetage d'une archive tar ou d'un zip que vous venez d'ouvrir dans un répertoire est assez facile (mais devrait être une question distincte). L'emballage disponible de cette façon suit bien les versions et gère toutes sortes de choses que l'ouverture d'une archive tar ne fonctionnera pas bien.

Si je ne pouvais vraiment pas vraiment construire un bon package, je ferais quelque chose comme ceci:

nodes.pp:

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

init.pp (modules):

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}] ];
}

Une autre alternative consiste à simplement utiliser une ressource marionnette récursive comme:

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

(où vous avez déjà correctement effacé les choses sur le maître de marionnettes. Vous aurez probablement besoin également du package qui exécute le service et notifiez le service dont il est à court).

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

Soit dit en passant, tout faire en tant qu'exécutifs est un peu moche et peut être difficile à résoudre lorsque les choses commencent à se casser; si vous le pouvez, peut-être conserver les versions extraites des fichiers d'application sur le serveur de marionnettes et utiliser une fileressource récursive pour récupérer?

Je préfère certainement empaqueter l'archive tar (RPM ou autre), mais quelques conseils:

Pour supprimer l'ancienne version, vous pouvez simplement supprimer toutes les versions sauf celle que vous installez. Avec un bash assez récent et extglob activé, vous pouvez rm -r /usr/local/apps/path/apps-version-!(${version}). Méfiez-vous d'effacer les fichiers de configuration et autres. Vous pouvez faire le exec refreshonly => truepuis l'exécuter notifydepuis l'exec d'installation.

Vous pouvez utiliser l' createsattribut au lieu de unless => 'test -f ...'. Un mais plus compréhensible.