Hinzufügen eines Yum Repo zur Puppe, bevor Sie etwas anderes tun

Gibt es eine Möglichkeit, Marionetten dazu zu zwingen, bestimmte Dinge zuerst zu tun? Zum Beispiel muss es ein RPM auf allen Servern installieren, um ein YUM-Repository (IUS-Community) hinzuzufügen, bevor ich eines der Pakete installiere.

Wenn Sie sicherstellen möchten, dass auf allen Servern ein Repository installiert ist, empfehle ich Folgendes

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
   }
}

Dann können Sie für jeden Knoten, der erweitert wird base, sagen

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

Dies wird sicherstellen, dass

• Das Paket barwird nur installiert, wenn das IUS-Repository definiert ist
• Das Paket versucht nicht, es zu installieren, bevor das IUS-Repository definiert ist

Obwohl die Phasen damit umgehen können und auch bestimmte YUM-Repo-Abhängigkeiten, ist es besser, die Beziehung generisch zu deklarieren.

Legen Yumrepo <| |> -> Package <| provider != 'rpm' |>Sie einfach Ihr Puppenmanifest ein.

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

Dies bewirkt, dass alle yumrepo-Typen vor Paketen verarbeitet werden, deren Provider nicht 'rpm' ist. Dieser letztere Ausschluss dient dazu, dass ich das (zum Beispiel) RPM-Paket für die Epel-Veröffentlichung verwenden kann, um das Yum-Repo zu installieren.

(Ich habe diese Frage gefunden, nachdem ich fast gleich geantwortet habe. Ich dachte, meine Antwort gilt auch hier und es lohnt sich, sie zu wiederholen. Es ist sicherer, eine Antwort an zwei Stellen zu haben.)

Soweit ich weiß, ist dies genau das, wofür Stufen vorgesehen sind - Sie können Klassenausführungen gruppieren und anordnen. Ich verwende "Stufen", um APT auf Debian-Servern zu aktualisieren und zu konfigurieren, was dem, was Sie mit YUM tun werden, sehr ähnlich sein sollte.

Zunächst deklarieren Sie die Stufe "yum" auf der obersten Ebene (über "node"), sodass Klassen in der Stufe "yum" vor "main" ausgeführt werden:

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

Anschließend weisen Sie den Klassen eine Bühne zu. Sie können dies direkt in Ihrer Knotendefinition tun:

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

  include packages
}

Sie könnten Tags verwenden . Dies würde Ihnen erlauben, das Repo-Installationsprogramm mit firstrunoder etwas zu markieren ,

dann renne

 puppetd --tags firstrun

und es würde nur die Module / Anweisungen ausführen, die mit dem Tag übereinstimmen.

Der Schlüssel, den Sie verwenden müssen, ist das Schlüsselwort require - "Bewerten Sie eine oder mehrere Klassen und fügen Sie die erforderliche Klasse als Abhängigkeit hinzu."

Ein Beispiel für die Verwendung eines Apt-Repositorys könnte sein:

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

(Angepasst an dieses Beispiel für Puppen-Bootstrapping ).

Sie können also sehen, wie für jede Stufe die vorherige zuerst ausgeführt werden muss. Ich überlasse es Ihnen, herauszufinden, wie Sie dies auf yum anwenden können, da ich nicht weiß, wo die Dateien gespeichert werden.

Puppet liest die Konfiguration von oben nach unten. Wenn Sie also eine Klasse mit dem Yum-Repo als Erstes in diese Klasse aufnehmen, wird dieses Repo vor allen anderen hinzugefügt.

Wenn Sie die erforderlichen Einstellungen für ein Paket verwenden, stellen Sie sicher, dass der erforderliche Ressourcentyp vorhanden ist, bevor Sie das Paket als solchen hinzufügen:

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
   }
}

Mit dem obigen Code wird das Repo hinzugefügt, bevor das Paket hinzugefügt wird.

So etwas hat bei mir funktioniert:

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]]
}

Ich habe so etwas auf mysite.pp aufgenommen. Auf diese Weise sind Ihre Puppenmodule frei von Verweisen auf Yum-Repos.