puppet: efficient te werk gaan

[Boudewijn]

Hoihoi


Mocht ik nou een stuk documentatie/best practice gemist hebben: vertel het me dan; dan kan ik me daar gewoon op storten. Ik heb zelf redelijk wat tutorials gelezen en kan een redelijk beetje ruby....

Goed, de casus:

1: Puppetmaster VM
2: Een zwikje clients
3: Recipes, waaronder aantal met templates, waarbij deze nog redelijk simpel zijn maari k wel facter gebruik.

Wat ik echter een beetje mis is hoe ik parametrised classes kan gebruiken, ik zie in tutorials meestal "hoe maak je een parametrised class" of "hoe zet je puppet simpel op".

Nu heb ik een manifests/nodes.pp met mijn hosts en wat setups erin:

code:

root@puppetmaster:/etc/puppet# cat manifests/nodes.pp
node basenode {
    include ntp
    include denyhosts
    include ssh
    include nrpe
    include apt
    include vim
    include mailname
    include sudo
    include motd
    include apt-get-clean-all
}


node 'colo-host' inherits basenode {
    include resolv
}

node 'www' inherits colo-host {
}
nog meer nodes....

Op zich prima. Het meest simpele recipe is dan ook (/etc/puppet/modules/motd):

[code]
root@puppetmaster:/etc/puppet/modules/motd# find
.
./manifests
./manifests/init.pp
./templates
./templates/motd.erb
[code]


En

code:

class motd {
       file { "/etc/motd":
        owner   => root,
        group   => root,
        mode    => 644,
          content => template('motd/motd.erb'),
    }
}

En een simpele motd.erb:

code:

Welkom op <%= fqdn %>

(wat voelde ik me 1337 toen dit werkte ;-) ) .


Puntje is dat de echt coole shit zie gebeuren met die parameters, waarbij gebruikers ook meer richting de modules zitten ipv de kale classes... ik weet alleen niet hoe ik dat nou goed vormgeef... de meeste tutorials bieden of heel toffe dingen aan waarbij je niet duidelijk is hoe je hosts moet declareren ermee, en er zijn tutorials waarin alles beschreven staat maar waarbij je qua niveau niet veel verder komt dan ik hierboven.


Voorbeeldje is dat ik nueen mysql-localhost heb (die skip-networking doet) en een mysql-eth0 (vies) ide luistert op eth0. Dat wil ik eigenlijk via een parameter doen dus .


Kan iemand me een beetje vertellen hoe ik dit nu wijselijk indeel/omvorm tot een goede indeling? ik ben de bomen een beetje kwijt wat dat betreft.

Het liefst zou ik zoiets hebben als:

code:

Host 'www01': {
   require apache ssl #apache met ssl als parameter requiren
   
    vhost 'www.foo.bar' { 
      ip = bla
     webroot = bla2
   }

Dat idee. En ik zie atm niet echt in hoe ik dat slim kan bereiken.

[CyBeR]

Zoiets als:

$apache_ssl = true
include apache

?

[ Voor 5% gewijzigd door CyBeR op 22-11-2011 20:50 ]

[Boudewijn]

Dat is op zich een goede optie, maar hoe zou ik dat dat dan mooi met vhosts doen om even wat geks te noemen?

code:

vhost_pad = "foo"
vhost_port = "bar"
vhost_logfile = "foobar"
include apache2

vhost_pad = "foo2"
vhost_port = "bar2"
vhost_logfile = "foobar2"
include apache2

Imo niet echt heel fraai. Ook kan ik me zomaar voorstellen dat je dan typo's niet gaat merken; bij een functie-parameter ontbreekt de parameter en krijg je het voordeel van static type checking.

[CyBeR]

Ik moet bekennen zelf geen vhosts met puppet te doen, maar is dit niet werkbaar voor je https://github.com/vStone/puppet-vhosts?

[Boudewijn]

Punt is dat ik daar alsnog de niet zo fraaie methode zou moeten gebruiken als ik het goed interpreteer.
Zelf zou ik liever de structuur zien van OF een functie OF een ruby-object instantieren .


Want, even de n00bmode aan: hoe zou jij die vhost functionaliteit inzetten?

Ik lees nml in de puppet design guide als best practice dat je zoveel mogelijk in modules moet doen; dat zie ik hier weer niet gebeuren.

[ Voor 20% gewijzigd door Boudewijn op 22-11-2011 21:17 ]

[CAPSLOCK2000]

Ik heb mijn apache oplossing gebaseeerd op http://projects.puppetlab...n_Apache2_Recipe_Patterns .

Een belangrijk verschil met wat jij wil is dat ik de vhost files niet laat genereren, maar ze met de hand schrijft. Puppet zet ze alleen op de juiste plek. Deze code is toch interessant omdat het ook laat zien hoe je met argumenten kan werken. $ensure is een gewone variabele (met een default waarde), je kan er zelf meer toeveogen. $name is een variabele die ieder object automatisch heeft en erg handig kan zijn.

code:

class apache2 {
   package {
        "apache2" : ensure => latest;
   }
   define site ( $ensure = 'present' ) {
      file {
        "/etc/apache2/sites-available/$name" :
          source => "puppet:///files/etc/apache2/sites-available/$name",
          ensure => $ensure;
      }
      case $ensure {
         'present' : {
            exec { "/usr/sbin/a2ensite $name":
               unless => "/bin/readlink -e ${apache2_sites}-enabled/$name",
               notify => Exec["reload-apache2"],
               require => File["/etc/apache2/sites-available/$name"],
            }
         }
    etc

Nodes maken hier dan zo gebruik van:

code:

include apache2
apache2::site {
                "civicrm"            : ensure => absent;
                "debian6to4"      : ensure => present;
               "spotweb"           : ensure => absent;
                "proxy"              : ensure => present;
                "temp"               : ensure => present;
                "trema"              : ensure => present;
                "www"               : ensure => present;
}

[Boudewijn]

Dat ziet er goed uit, maar waar include je die onderste snippet dan in?

Zoals ik al meldde, ik heb dus nu een nodes.pp met daarin :

code:

root@puppetmaster:/etc/puppet# cat manifests/nodes.pp
node basenode {
    include ntp
    include denyhosts
    include ssh
    include nrpe
    include apt
    include vim
    include mailname
    include sudo
    include motd
    include apt-get-clean-all
}


node 'colo-host' inherits basenode {
    include resolv
}


node 'thuisnode' inherits basenode{
}

node 'www' inherits colo-host {
}
nog meer nodes....

Dit werkt, maar ik heb niet het idee dat het echt handig is, vooral ook door parameters. Zou ik jou manier van opzetten eens mogen zien?
Ik weet nml nog niet echt goed hoe ik mijn structuur zo kan maken dat het met bovenstaand soort snippets werkt.

[CAPSLOCK2000]

Dat stukje neem ik dan in de node definitie op van de webserver in kwestie.

Mijn structuur is heel eenvoudig hoor, niks ingewikelds.

code:

node 'basenode' {
    heel veel
}
node 'physical-machine' inherits base-node {
    include hdparm
   # ander hardware-gerelateerd spul
}

node 'desktop' inherits 'physical-machine' {
    include login-host; # handige progjes die ik wil hebben op machines waarop ik inlog
}
node 'virtual-machine' inherits base-node { 
    include vmtools
}
node 'dnsserver' inherits virtual-machine{
    network { net: hostname  => "dnsserver", pip => 53 } # schrijft /etc/network/interfaces en /etc/hosts
    include bind;
}
node 'webserver' inherits virtual-machine{
    network { net: hostname  => "webserver", pip => 80 } 
    include apache2
    apache2::site {
               "www"            : ensure => present;  
    }
}

en nog een hoop andere servers. Uiteraard is het in werkelijkheid allemaal wat uitgebreider.

[Boudewijn]

Ondanks dat het even wat stil was ben ik er uiteraard nog steeds mee bezig.... en bedankt voor de info CAPSLOCK!

Ik ben nu even aan het rondkijken geweest en ik wil deze klasse graag gebruiken voor mysql (bron: http://bitfieldconsulting...reate-databases-and-users)

http://bitfieldconsulting...reate-databases-and-users


Punt is dat ik twijfel of ik deze nou in een module dien te gooien of niet.
Iig heb ik nu de volgende setup, in mijn nodes.pp:

code:

node 'lsp-vp-db1.foo' inherits basenode
{
        $mysql_password = "C6dDIls49ci3GEzl1vgwRUXT"
        include mysql::server
}

(de basenode staat hierboven, maar is verder voor dit stukje casus denk ik niet relevant).


En:

code:

root@lsp-vp-mgt1:/etc/puppet/modules/mysql# find
.
./manifests
./manifests/init.pp
./templates
./files

Goed, in de init.pp heb ik netjes de klasse staan zoals hij op (http://bitfieldconsulting...reate-databases-and-users) staat.


Punt is dat er vervolgens niets gebeurt. Ook als ik de class in een module (die ook mysql::server heet) zet gebeurt er niets. Heb even met de hand zowel de agent als de master gedraaid en ik zie niets boeiends voorbij komen.

Iemand zin om mij een duwtje de goede kant op te geven?

[Boudewijn]

Goed, het werkt.
De mysql::server moet in:

/etc/puppet/modules/mysql/manifests/server.pp, en je kunt hem aan roepen met:

code:

node 'foo.bar' inherits basenode
{
        class { "mysql::server":
                mysql_password => "*",
        }
}

Erg tof dus.

heeft er iemand een aanrader voor iptables recipes?

[Kees]

CAPSLOCK2000 schreef op dinsdag 22 november 2011 @ 22:09:
Ik heb mijn apache oplossing gebaseeerd op http://projects.puppetlab...n_Apache2_Recipe_Patterns .

Een belangrijk verschil met wat jij wil is dat ik de vhost files niet laat genereren, maar ze met de hand schrijft. Puppet zet ze alleen op de juiste plek. Deze code is toch interessant omdat het ook laat zien hoe je met argumenten kan werken. $ensure is een gewone variabele (met een default waarde), je kan er zelf meer toeveogen. $name is een variabele die ieder object automatisch heeft en erg handig kan zijn.

Grappig, ik doe bijna hetzelfde; alleen heb ik minder servers met vhosts, dus ik laat puppet gewoon een dir syncen met daarin de definities. In eerste instantie had ik wel gewoon een module ervoor gemaakt, maar ik bleef maar aanpassingen maken voor uitzonderingen, waarbij in the end het makkelijker was om bijna de hele inhoud mee te geven in de definitie.. dus toen maar naar een aparte dir gegaan met daarin voor productie, alpha, beta en management verschillende configs.

Verder ga ik voor meer services het op die manier doen; niet echt modulair, maar wel makkelijker te onderhouden voor mij, en zoveel zou ik toch niet kunnen hergebruiken. Een file als my.cnf verschilt per server zoveel dat ik dan alsnog de hele my.cnf in de definitie zou moeten gooien bijvoorbeeld.