Ajout d'un repo miam à la marionnette avant de faire autre chose

Existe-t-il un moyen de forcer la marionnette à faire certaines choses en premier? Par exemple, j'en ai besoin pour installer un RPM sur tous les serveurs pour ajouter un référentiel yum (communauté IUS) avant d'installer l'un des packages.

Si vous voulez vous assurer qu'un référentiel est installé sur tout votre serveur, je suggérerais quelque chose comme ça

node default {
   include base
}

class base {
   yumrepo { "IUS":
      baseurl => "http://dl.iuscommunity.org/pub/ius/stable/$operatingsystem/$operatingsystemrelease/$architecture",
      descr => "IUS Community repository",
      enabled => 1,
      gpgcheck => 0
   }
}

Ensuite, pour tout nœud qui s'étend, basevous pouvez dire

class foo {
   package { "bar": ensure => installed, require => Yumrepo["IUS"] }
}

Cela garantira que

• Le package barne sera installé que si le référentiel IUS est défini
• Le package ne tentera pas l'installation avant la définition du référentiel IUS

Bien que les étapes puissent gérer cela, tout comme les dépendances spécifiques au repo yum, mieux vaut déclarer la relation de manière générique.

Mettez simplement Yumrepo <| |> -> Package <| provider != 'rpm' |>votre manifeste de marionnettes.

node default {
  Yumrepo <| |> -> Package <| provider != 'rpm' |>
}

Cela fait en sorte que tous les types yumrepo soient traités avant tous les packages qui n'ont pas «rpm» comme fournisseur. Cette dernière exclusion est pour que je puisse utiliser (par exemple) le package RPM epel-release pour aider à installer le repo yum.

(J'ai trouvé cette question après avoir répondu presque la même chose ... alors j'ai pensé que ma réponse s'applique ici aussi et cela vaut la peine de la répéter (il est plus sûr d'avoir une réponse à deux endroits ..)

D'après ce que je comprends, c'est exactement à cela que servent les étapes - elles vous permettent de grouper et d'ordonner les exécutions de classe. J'utilise des "étapes" pour mettre à jour et configurer APT sur les serveurs Debian, ce qui devrait être très similaire à ce que vous allez faire avec YUM.

Tout d'abord, vous déclarez l'étape "yum" au niveau supérieur (au-dessus des "nœuds"), afin que les classes de l'étape "yum" soient exécutées avant celles "principales":

stage { 'yum' : before => Stage['main'] }

Ensuite, vous attribuez une étape aux classes. Vous pouvez le faire directement dans votre définition de nœud:

node default {
  class { 'yumrepos' : stage => yum }

  include packages
}

Vous pouvez utiliser des balises . Cela vous permettrait de baliser l'installateur du référentiel avec firstrunou quelque chose,

puis exécutez

 puppetd --tags firstrun

et il n'exécuterait que les modules / instructions correspondant à la balise.

La clé que vous devez utiliser est le mot clé require - "Evaluer une ou plusieurs classes, en ajoutant la classe requise comme dépendance".

Un exemple d'utilisation d'un référentiel apt pourrait être:

class installcustompackages {
   # make sure we have the repository file and public key
   file { "/etc/apt/sources.list.d/myrepo.list":
      source => "puppet://puppet/files/etc/apt/sources.list.d/myrepo.list",
      ensure => present;
          "/etc/apt/trusted.gpg":
      source => "puppet://puppet/files/etc/apt/trusted.gpg",
   }

   # do an update whenever the list or trusted key file change
   exec { "/usr/bin/apt-get update":
      alias => "aptgetupdate",
      require => [ File["/etc/apt/sources.list.d/myrepo.list"], File["/etc/apt/trusted.gpg"] ],
      subscribe => [ File["/etc/apt/sources.list.d/myrepo.list"], File["/etc/apt/trusted.gpg"] ],
      refreshonly => true;
   }

   package { "mypackage":
      ensure => latest,
      require => Exec["aptgetupdate"];
             "mypackage2":
      ensure => latest,
      require => Exec["aptgetupdate"];
   }

   service { "myservice":
      enable => false,
      require => Package[mypackage];
   }
}

(Adapté de cet exemple de bootstrap de marionnettes ).

Vous pouvez donc voir comment chaque étape nécessite que la précédente soit effectuée en premier. Je vous laisse découvrir comment l'appliquer à yum car je ne sais pas où il stocke ses fichiers.

Puppet lit la configuration de haut en bas, donc si vous incluez une classe avec le repo yum en premier dans cette classe, ce repo sera ajouté avant toute autre chose.

Si vous utilisez les paramètres requis sur un package, vous vous assurerez que le type de ressource requis est présent avant d'ajouter le package, en tant que tel:

node 'yournode.domain.com' {
   package { "bar": ensure => installed, require => Yumrepo["IUS"] }
   yumrepo { "IUS":
      baseurl => "http://dl.iuscommunity.org/pub/ius/stable/$operatingsystem/$operatingsystemrelease/$architecture",
      descr => "IUS Community repository",
      enabled => 1,
      gpgcheck => 0
   }
}

Ce code ci-dessus ajoutera le dépôt avant d'ajouter le package.

Quelque chose comme ça a fonctionné pour moi:

yumrepo { A:
  descr    => "A repo",
  baseurl  => '',
  enabled  => 1,
  gpgcheck => 1,
  gpgkey   => "",
  priority => 3
}

yumrepo { B:
  descr    => "B repo",
  baseurl  => '',
  enabled  => 1,
  gpgcheck => 1,
  gpgkey   => "",
  priority => 3
}

yumrepo { C:
  descr    => "C repo",
  baseurl  => '',
  enabled  => 1,
  gpgcheck => 1,
  gpgkey   => "",
  priority => 3;
}

Package {
  require => [Yumrepo[A], Yumrepo[B], Yumrepo[C]]
}

J'ai inclus quelque chose comme ça sur mysite.pp. De cette façon, vos modules de marionnettes sont exempts de références aux dépôts yum.