Como implantar aplicativos (em .tar.gz) com o Puppet?

Sou iniciante no Puppet e gostaria de saber se estou no caminho certo para implantar aplicativos com o Puppet.

Os aplicativos estão em um arquivo tar.gz que contém um arquivo com o número da versão. Então, eu faço isso para implantar (eu vou no servidor e reinicio o cliente para pegar o novo 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"] ],
    }

Mas, quando eu quero atualizar, não sei dizer Puppet para excluir o diretório antigo? Por exemplo, se eu quiser atualizar a versão 56 para 57: devo excluir o diretório de versão da 56.

Ouvi falar de Capristrano e parece ser melhor usar o Puppet para gerenciar pacotes, arquivos de configuração e usar o Capristrano para implantar aplicativos, não é?

Obrigado.

Gostaria de saber se estou no caminho certo para implantar aplicativos com o Puppet.

Não, você não é.

Você deve usar o gerenciamento de pacotes disponível em seu sistema operacional. Se o seu software está em tar.gzformato, você deve re-empacotá-lo localmente como .deb, .rpmou o que quer.

Se o software for desenvolvido localmente, você deve usar as ferramentas de compilação / implantação disponíveis.

Você pode tentar usar o fpm para criar RPMs ou DEBs com seus tarballs; é realmente simples de usar e você não precisa entender nada sobre os formatos de pacote que não deseja.

Para responder à sua pergunta original, a maneira correta de implantar aplicativos com o Puppet é fazer com que o Puppet faça o mínimo possível de trabalho; todos os execrecursos complicados que baixam e extraem tarballs tendem a ser muito, muito quebradiços, e tornar o Puppet apenas yum installum pacote é muito mais saudável a longo prazo.

Eu tentaria arduamente agrupar o aplicativo como um pacote RPM ou .deb e criar um repositório yum ou apt para armazenar os pacotes. Empacotar um tarball ou zip que você está abrindo em um diretório é bastante fácil (mas deve ser uma pergunta separada). A embalagem disponível dessa maneira rastreia bem as versões e lida com todo tipo de coisa que apenas abrir um tarball não funcionará bem.

Se eu realmente não conseguisse criar um pacote adequado, faria algo assim:

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

Outra alternativa é simplesmente usar um recurso de fantoche recursivo como:

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

(onde você já desempenhou as coisas corretamente no mestre de marionetes. Provavelmente também exija qualquer pacote que esteja executando o serviço e notifique qualquer serviço que esteja executando).

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

Como um aparte, fazer tudo como executivos é meio feio e pode ser difícil solucionar problemas quando as coisas começam a quebrar; se puder, talvez mantenha versões extraídas dos arquivos do aplicativo no servidor fantoche e use um filerecurso recursivo para recuperar?

Eu certamente sou a favor de empacotar o tarball (RPM ou o que for), mas algumas dicas:

Para excluir a versão antiga, você pode simplesmente excluir todas as versões, exceto a que você está instalando. Com um bash e extglob recentes o suficiente, você pode rm -r /usr/local/apps/path/apps-version-!(${version}). Cuidado com a eliminação de arquivos de configuração e outros. Você pode fazer o exec refreshonly => truee depois notifyexecutá-lo a partir do exec de instalação.

Você pode usar o createsatributo em vez de unless => 'test -f ...'. Um, mas mais compreensível.