Puppet: compartilhando informações entre as classes

Question

Eu não acho que haja uma maneira certa de fazer o seguinte (ainda) em Puppet, mas isso me parece desejável.

Eu quero que minhas aulas possam influenciar o conteúdo de um arquivo modelo de outra classe, para que possamos evitar a duplicação de informações e colocar as informações onde elas pertencem.

Por exemplo, temos uma classe "iptables" e várias classes de serviço, como "postfix", "webappfoo", etc.

class webappfoo {
     $myfwrules +> [ "-A INPUT -p tcp --state NEW -m tcp --dport 80 -j ACCEPT" ]
     include apache
}

node webappserver {
     include webappfoo
     include iptables
}

Mas isso não funciona; o array $ myfwrules contém apenas essa linha dentro do webappfoo.

Observe que uma turma pode ler em outra; por exemplo, aqui o iptables poderia apenas ler $ iptables :: myfwrules; mas eu não quero que o iptables precise saber sobre o webappfoo.

    

Answer 1

Esta é uma questão de escopo. Do tutorial de idiomas :

Classes, components, and nodes introduce a new scope. Puppet is currently dynamically scoped, which means that scope hierarchies are created based on where the code is evaluated instead of where the code is defined.

Portanto, $myfwrules está no escopo da classe em que está definido. No seu caso, você está definindo o escopo na classe webappfoo , onde não tem conhecimento de qualquer $myfwrules definido anteriormente. Você pode contornar isso , mas uma abordagem melhor pode ser usar definições . Algo parecido com isto (não testado, YMMV, etc):

class iptables {
  define rule($rule) {
    # $title is the 'name' of the resource, like ntpd in service { "ntpd": }
    exec { "rule-$title":
      command => "/sbin/iptables $rule"
    }
  }
}

class webappfoo {
  include iptables
  iptables::rule { "webappfoo":
    rule => "-A INPUT -p tcp --state NEW -m tcp --dport 80 -j ACCEPT"
  }
}

class postfix {
  include iptables
  iptables::rule { "postfix":
    rule => "-A INPUT -p tcp --state NEW -m tcp --dport 25 -j ACCEPT"
  }
}

node foo {
  include webappfoo
  include postfix
}

Dessa forma, você tem uma maneira reutilizável de adicionar regras às suas classes sem precisar definir variáveis e se preocupar com o escopo. Você acabará com um monte de Exec resources ( Exec["rule-webappfoo"] , Exec["rule-postfix"] ) representando o conjunto de regras do nó foo .

Veja também os módulos iptables prontos .

Editar : este é apenas um exemplo para demonstrar como as definições podem ser usadas. Não é para ser uma solução sem problemas. Para começar, há problemas em torno da ordem em que as regras podem ser aplicadas (pode usar before / after , talvez) e a eficiência de chamar /sbin/iptables todas as vezes.

    

Answer 2

Eu decidi usar modelos e várias concatenações para criar regras de iptables. por exemplo.

define iptables::rules {
  file { "$local_rules_file":
    ensure  => "file",
    content => template($iptables_start, "iptables/iptables.$name.erb", $iptables_stop)
  }
}

Não é bonito e requer um arquivo iptables.hostname.erb dedicado para cada computador. Mas é estúpido simples.

Leia também as configurações da loja do Puppet e a concatenação de vários arquivos.

    

Answer 3

Eu não toquei em marionetes por algum tempo, então minha sintaxe pode estar um pouco enferrujada. Deve "+ >" ser "+="? Enfim, você já tentou isso?

class webappfoo {
    include apache
}
class webappfoo::myfwrules {
    $webappfoo_myfwrules = [ "-A INPUT -p tcp --state NEW -m tcp --dport 80 -j ACCEPT" ]
}
node webappserver {
    include iptables

    $webapplist = ["webappfoo", "webappbar" ]
    $webappserver_myfwrules => $iptables::iptables_myfwrules

    $webappserver_myfwrules += $webapplist ? {
         webappfoo => $webappfoo::myfwrules::webappfoo_myfwrules,
         webappbar => $webappbar::myfwrules::webappfoo_myfwrules,
    }
}

    

Answer 4

Este módulo iptables parece ser a única maneira de fazer o que eu quero; é basicamente um script que pega arquivos em um diretório iptables.d / e constrói o / etc / sysconfig / iptables a partir dele. Isso é provavelmente o que vou usar; mas sinto que esse tipo de padrão deveria ser possível no próprio Puppet.