Aggiungere un repo yum al burattino prima di fare qualsiasi altra cosa

C'è un modo per forzare il burattino a fare prima certe cose? Ad esempio, ne ho bisogno per installare un RPM su tutti i server per aggiungere un repository yum (IUS Community) prima di installare uno dei pacchetti.

Se vuoi assicurarti che un repository sia installato su tutto il tuo server, suggerirei qualcosa del genere

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

Quindi, per qualsiasi nodo che si estende basepuoi dire

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

Questo assicurerà questo

• Il pacchetto barnon verrà installato a meno che non sia definito il repository IUS
• Il pacchetto non tenterà di installare prima della definizione del repository IUS

Sebbene le fasi siano in grado di gestirlo e così anche le dipendenze specifiche di repo yum, è meglio dichiarare la relazione genericamente.

Basta mettere Yumrepo <| |> -> Package <| provider != 'rpm' |>nel vostro manifesto di marionette.

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

Questo fa sì che tutti i tipi di yumrepo vengano elaborati prima di qualsiasi pacchetto che non abbia "rpm" come provider. Quest'ultima esclusione è tale che posso usare il pacchetto (ad esempio) RPM di epel-release per aiutare a installare il repository yum.

(Ho trovato questa domanda dopo aver risposto quasi allo stesso modo .. quindi ho pensato che la mia risposta si applichi anche qui e vale la pena ripeterla (è più sicuro avere una risposta in due punti ..)

Per quanto ho capito, questo è esattamente ciò che serve per le fasi : ti permettono di raggruppare e ordinare esecuzioni di classe. Uso "stages" per aggiornare e configurare APT sui server Debian, che dovrebbe essere molto simile a quello che farai con YUM.

Prima di tutto, dichiari lo stadio "yum" al livello più alto (sopra i "nodi"), in modo che le classi nello stadio "yum" vengano eseguite prima di quelle "principali":

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

Quindi, assegni stage alle classi. Puoi farlo bene nella definizione del tuo nodo:

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

  include packages
}

Puoi usare i tag . Ciò consentirebbe di taggare il programma di installazione del repository con firstruno qualcosa del genere,

quindi corri

 puppetd --tags firstrun

e eseguirà solo i moduli / istruzioni corrispondenti al tag.

La cosa fondamentale è necessario utilizzare è la richiedono parola chiave - "Valutare una o più classi, aggiungendo la classe richiesta come dipendenza"

Un esempio che utilizza un repository apt potrebbe essere:

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

(Adattato da questo esempio di bootstrap delle marionette ).

Quindi puoi vedere come ogni fase richiede che la precedente sia eseguita per prima. Ti lascerò per capire come applicare questo a Yum poiché non ho familiarità con dove memorizza i suoi file.

Puppet legge la configurazione dall'alto verso il basso, quindi se includi una classe con il repository yum per primo in quella classe, questo repository verrà aggiunto prima di ogni altra cosa.

Se si utilizzano le impostazioni richieste su un pacchetto, assicurarsi che sia presente il tipo di risorsa richiesto prima di aggiungere il pacchetto, in quanto tale:

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

Questo codice sopra aggiungerà il repository prima di aggiungere il pacchetto.

Qualcosa del genere ha funzionato per me:

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

Ho incluso qualcosa di simile su mysite.pp. In questo modo, i tuoi moduli fantoccio sono privi di riferimenti a repository yum.