Wie kann ich Anwendungen (in .tar.gz) mit Puppet bereitstellen?

Ich bin ein Anfänger mit Puppet und würde gerne wissen, ob ich auf dem richtigen Weg bin, Anwendungen mit Puppet bereitzustellen.

Die Anwendungen befinden sich in einer tar.gz-Datei, die eine Datei mit der Versionsnummer enthält. Also mache ich dies, um es bereitzustellen (ich gehe auf den Server und starte einen Client neu, um den neuen Tarball aufzunehmen):

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

Aber wenn ich ein Upgrade durchführen möchte, kann ich nicht Puppet sagen, um das alte Verzeichnis zu löschen? Beispiel: Wenn ich Version 56 auf 57 aktualisieren möchte: Ich muss das Versionsverzeichnis des 56 löschen.

Ich habe von Capristrano gehört und es scheint besser zu sein, Puppet zum Verwalten von Paketen, Konfigurationsdateien und zum Bereitstellen von Apps mit Capristrano zu verwenden, nicht wahr?

Vielen Dank.

Ich würde gerne wissen, ob ich auf dem richtigen Weg bin, Anwendungen mit Puppet bereitzustellen.

Nein, bist du nicht.

Sie sollten die auf Ihrem Betriebssystem verfügbare Paketverwaltung verwenden. Wenn Ihre Software in ist tar.gzFormat, sollten Sie es neu verpacken lokal wie .deb, .rpmoder was auch immer.

Wenn die Software lokal entwickelt wurde, sollten Sie alle dafür verfügbaren Build / Deploy-Tools verwenden.

Vielleicht möchten Sie versuchen, mit fpm RPMs oder DEBs Ihrer Tarballs zu erstellen. Es ist wirklich einfach zu bedienen und Sie müssen nichts über die Paketformate verstehen, die Sie nicht möchten.

Um Ihre ursprüngliche Frage zu beantworten, müssen Sie Anwendungen mit Puppet richtig bereitstellen, indem Sie Puppet so wenig Arbeit wie möglich erledigen lassen. execAlle komplizierten Ressourcen, die Tarballs herunterladen und extrahieren, müssen sehr, sehr spröde sein, und Puppet nur zu yum installeinem Paket zu machen, ist auf lange Sicht viel gesünder.

Ich würde mich sehr bemühen, die App als RPM- oder .deb-Paket zu bündeln und ein yum- oder apt-Repository für die Pakete zu erstellen. Das Verpacken eines Tarballs oder einer Zip-Datei, die Sie gerade in einem Verzeichnis öffnen, ist ziemlich einfach (sollte aber eine separate Frage sein). Die Verpackung, die auf diese Weise erhältlich ist, verfolgt Versionen gut und handhabt alle möglichen Dinge, die nur beim Öffnen eines Tarballs nicht gut funktionieren.

Wenn ich wirklich wirklich kein richtiges Paket erstellen könnte, würde ich so etwas tun:

node.pp:

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

init.pp (Module):

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

Eine andere Alternative besteht darin, einfach eine rekursive Marionettenressource zu verwenden, wie:

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

(Wenn Sie die Dinge auf dem Puppet Master bereits korrekt entkernt haben. Möglicherweise benötigen Sie auch das Paket, auf dem der Dienst ausgeführt wird, und benachrichtigen Sie den Dienst, auf dem der Dienst ausgeführt wird.)

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

Abgesehen davon ist es ein bisschen hässlich, alles als Execs zu tun, und es kann schwierig sein, Fehler zu beheben, wenn die Dinge anfangen zu brechen. Wenn Sie können, behalten Sie möglicherweise extrahierte Versionen der App-Dateien auf dem Puppet-Server und verwenden Sie eine rekursive fileRessource zum Abrufen?

Ich bevorzuge sicherlich das Verpacken des Tarballs (U / min oder was auch immer), aber ein paar Hinweise:

Um die alte Version zu löschen, können Sie einfach alle Versionen außer der, die Sie installieren, löschen. Mit einer ausreichend aktuellen Bash und Extglob können Sie rm -r /usr/local/apps/path/apps-version-!(${version}). Achten Sie darauf, Konfigurationsdateien und dergleichen nicht zu löschen. Sie können das exec refreshonly => trueund dann notifyaus der Installation ausführen.

Sie können das createsAttribut anstelle von verwenden unless => 'test -f ...'. A aber verständlicher.