Installazione di un modulo burattino da uno script manifesto

Question

Uso Puppet per eseguire il provisioning di una macchina virtuale vagabonda (basata su Ubuntu). Nel mio script ho bisogno di:

sudo apt-get build-dep python-lxml 

so di poter installare il aptpuppet module modo da poter utilizzare:

apt::builddep { 'python-lxml': } 

Ma non riesco a trovare alcun riferimento sull'installazione di un modulo dallo script e come includerlo/richiederlo. A me sembra che la documentazione fantoccio si riferiscono solo al installing from the command line puppet tool

Ho anche provato a fare qualcosa di simile:

define build_dep($pkgname){ 
    exec { 
    "builddepend_$pkgname": 
    commmand => "sudo apt-get build-dep $pkgname"; 
    } 
} 
build_dep{ 
    "python-imaging": 
    pkgname => "python-imaging"; 

    "python-lxml": 
    pkgname => "python-lxml"; 
} 

Ma fantoccio uscito con un errore su questo. E anche:

exec{"install apt module": 

    command => "puppet module install puppetlabs/apt" 
} 

class { 'apt': 
     require => Exec["install apt module"]} 
include apt 

apt::builddep { 'python-imaging': 
} 

ma ottenuto could not find declared class apt at..

tutte le idee? indicazioni? So che mi manca qualcosa di ovvio ma non riesco a capirlo.

EDIT: Se io preinstallare (con puppet module install dalla linea di comando) il apt:builddep funziona bene. Ma ho bisogno di burattino per gestire il download e l'installazione del modulo. Alcuni degli altri funzionano anche per il caso d'uso di base, ma non rispondono alla mia domanda principale.

Answer 1

Mi sono imbattuto in questo problema pure. Il trucco è scaricare i moduli usando un comando di shell vagabondo prima che il burattinaio funzioni.

ordine è importante qui, e dato che la provisioner fantoccio non è stato eseguito nella cartella/etc/burattino/moduli non esiste ancora.

La ragione per cui ho deciso, come alonisser, di installare i moduli utilizzando lo strumento modulo burattino invece di utilizzare una cartella di moduli con il burattinaio burbero vagante era perché non volevo dover scaricare tutte le dipendenze dei moduli Stavo per utilizzare e archiviare tutti quei moduli nel mio controllo sorgente. L'esecuzione di questi due comandi comporta 5 dipendenze che altrimenti si posizionerebbero nel mio repository git occupando spazio.

Answer 2

È possibile creare una directory per moduli e aggiungere il modulo apt scaricato dalla fucina. Quindi sarà modules/apt/*. Poi si può specificare questa directory modulo Vagrantfile (module_path è relativo a Vagrantfile):

Vagrant.configure("2") do |config| 
    config.vm.provision :puppet do |puppet| 
    puppet.module_path = "modules" 
    end 
end 

Per ulteriori informazioni consultare il documentation.

Answer 3

Io uso un approccio simile a @brain_bacon - l'ulteriore complicazione che ho avuto è che oltre ai moduli preconfezionati come puppetlabs/nodejs avevo bisogno di moduli locali relativi al mio Vagrantfile. Non volevo controllare i moduli preconfezionati come parte del mio repository, né usare i sottomoduli git a causa dei problemi indicati da @Igor Popov.

Infine, la soluzione che ho scelto era quella di utilizzare uno script di shell per scaricare i moduli, ma forzandone il percorso nella directory condivisa tra Vagrant VM e l'host e l'utilizzo.gitignore per evitare che quel percorso si trovi sotto il controllo del codice sorgente.

Per essere chiari, con questo albero:

jcmendez$ tree 
. 
├── README.md 
├── Vagrantfile 
├── files 
├── puppet 
│   ├── manifests 
│   │   └── init.pp 
│   └── modules 
│    ├── misc 
│    │   └── manifests 
│    │    └── init.pp 
│    ├── mysql 
    ... 
│    └── wordpress 
│     ├── files 
│     │   ├── wordpress-db.sql 
│     │   ├── wp-config.php 
│     │   └── wp-tests-config.php 
│     └── manifests 
│      └── init.pp 
└── wordpress 

Su .gitignore ho aggiunto

/puppet/modules/mysql 

Su Vagrantfile

config.vm.provision :shell do |shell| 
    shell.inline = "puppet module install puppetlabs/mysql --force --modulepath '/vagrant/puppet/modules'" 
    end 

    config.vm.provision :puppet do |puppet| 
    puppet.manifests_path = 'puppet/manifests' 
    puppet.module_path = 'puppet/modules' 
    puppet.manifest_file = "init.pp" 
    puppet.options="--verbose --debug" 
    end 

Answer 4

Ecco che cosa ho fatto per far funzionare puppet module install comando più di una volta:

$script = <<EOF 
mkdir -p /etc/puppet/modules 
(puppet module list | grep puppetlabs-mysql) || 
    puppet module install -v 2.1.0 puppetlabs/mysql 
EOF 

Vagrant::Config.run do |config| 
    config.vm.provision :shell, :inline => $script 

Answer 5

È possibile installare moduli fantoccio sulla macchina host all'interno vagrantdir:

puppet module --modulepath=./puppet/modules/ install puppetlabs/mysql 

Vagrant si prende cura di montare questa directory al posto giusto. Quindi non è necessario eseguire script diversi da puppet sul nodo.

Answer 6

Ispirato dalla risposta di wtanaka.com, ho implementato una soluzione come la seguente, che ritengo sia molto più leggibile.

1) creare un nuovo file rubino chiamato 'puppet_deps.rb' sotto la stessa cartella Vagrantfile con un codice simile di seguito:

def install_dep(name, version, install_dir = nil) 
    install_dir ||= '/etc/puppet/modules' 
    "mkdir -p #{install_dir} && (puppet module list | grep #{name}) || puppet module install -v #{version} #{name}" 
end 

2) Nella tua Vagrantfile, è possibile caricare questo file ruby ​​e utilizzarlo per specificare la dipendenza burattino:

# on top of your Vagrantfile 
require './puppet_deps' 
... 
... 
# in your vm definition, use a shell provisioning this: 
config.vm.provision :shell, :inline => install_dep('puppetlabs-firewall', '1.1.3') 
config.vm.provision :shell, :inline => install_dep('puppetlabs-stdlib', '4.3.2') 

Answer 7

@ strategia di brain_bacon ha funzionato quasi perfettamente per me, con un piccolo avvertimento - se il modulo esiste già, lo script di provisioning non riesce, arrestare il processo di provisioning. La seguente regolazione risolto questo:

config.vm.provision :shell, :run => "always" do |shell| 
    shell.inline = %{ 
    mkdir -p /etc/puppet/modules; 
    function install_module { 
     folder=`echo $1 | sed s/.*-//` 
     if [ ! -d /etc/puppet/modules/$folder ]; then 
     puppet module install $1 
     fi 
    } 
    install_module stdlib 
    install_module apt 
    install_module ruby 
    } 
end 

Answer 8

Utilizzando le risposte da questa domanda ho creato questo script:

#!/bin/bash 

function install_module { 
    IFS=':' read module version <<< "$1" 
    if (puppet module list | grep $module) >/dev/null; then 
    echo "Module $module is already installed" 
    else 
     if [ -z "$version" ]; then 
      puppet module install $module 
     else 
     puppet module install -v $version $module 
    fi 
    fi 
} 

if dpkg --compare-versions `puppet --version` "lt" 3.8.7; then 
    sudo apt-get remove --purge -y puppet 
    sudo apt-get -y autoremove 
fi 

if which puppet >/dev/null; then 
    echo "Puppet is already installed" 
else 
    echo "Installing puppet" 
    wget https://apt.puppetlabs.com/puppetlabs-release-trusty.deb 
    sudo dpkg -i puppetlabs-release-trusty.deb 
    sudo apt-get update 
    sudo apt-get install -y puppet=3.8.7* 
    mkdir -p /etc/puppet/modules 
fi 

for var in "$@" 
do 
    install_module "$var" 
done 

quindi è possibile utilizzare dal vostro Vagrantfile in questo modo:

puppet_modules = [ 
    'puppetlabs-stdlib:4.16.0', 
    'puppetlabs-apt:2.3.0', 
    'puppet-nodejs:2.3.0' 
    ] 

config.vm.provision "shell", path: "puppet/scripts/puppet.sh", args: puppet_modules.join(" ") 

rimuove burattino da vm se la versione è inferiore a 3.8.7, quindi installa puppet 3.8.7 e quindi installa tutti i moduli.

Probabilmente funzionerebbe solo su scatole debian/ubuntu.