Agregar un repositorio de yum a la marioneta antes de hacer cualquier otra cosa

¿Hay alguna manera de obligar a la marioneta a hacer ciertas cosas primero? Por ejemplo, necesito que instale un RPM en todos los servidores para agregar un repositorio yum (Comunidad IUS) antes de instalar cualquiera de los paquetes.

Si desea asegurarse de que hay un repositorio instalado en todo su servidor, le sugiero algo como esto

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

Luego, para cualquier nodo que se extienda base, puede decir

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

Esto asegurará que

• El paquete barno se instalará a menos que se defina el repositorio IUS
• El paquete no intentará instalarse antes de definir el repositorio de IUS

Aunque las etapas pueden manejar esto y también las dependencias específicas de repositorio de yum, es mejor declarar la relación genéricamente.

Simplemente ponga Yumrepo <| |> -> Package <| provider != 'rpm' |>en su manifiesto de marionetas.

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

Esto hace que todos los tipos de yumrepo se procesen antes que cualquier paquete que no tenga 'rpm' como proveedor. Esa última exclusión es para que pueda usar (por ejemplo) el paquete RPM epel-release para ayudar a instalar el repositorio yum.

(Encontré esta pregunta después de responder casi lo mismo ... así que pensé que mi respuesta también se aplica aquí y vale la pena repetirla (es más seguro tener una respuesta en dos lugares ...)

Según tengo entendido, esto es exactamente para lo que son las etapas : le permiten agrupar y ordenar ejecuciones de clase. Utilizo "etapas" para actualizar y configurar APT en los servidores Debian, lo que debería ser muy similar a lo que va a hacer con YUM.

En primer lugar, declara la etapa "yum" en el nivel superior (arriba de "nodos"), de modo que las clases en la etapa "yum" se ejecutarán antes que las "principales":

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

Luego, asignas escenario a las clases. Puede hacer esto directamente en su definición de nodo:

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

  include packages
}

Podrías usar etiquetas . Esto le permitiría etiquetar el instalador de repositorios con firstruno algo así,

entonces corre

 puppetd --tags firstrun

y solo ejecutaría los módulos / declaraciones que coinciden con la etiqueta.

La clave que necesita usar es la palabra clave require : "Evalúe una o más clases, agregando la clase requerida como una dependencia".

Un ejemplo usando un repositorio apt podría ser:

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

(Adaptado de este ejemplo de arranque de marionetas ).

Entonces puede ver cómo cada etapa requiere que la anterior se haga primero. Te dejaré que averigües cómo aplicar esto a yum, ya que no estoy familiarizado con dónde almacena sus archivos.

Puppet lee la configuración de arriba a abajo, por lo que si incluye una clase con el repositorio yum primero en esa clase, este repositorio se agregará antes que nada.

Si usa la configuración requerida en un paquete, se asegurará de que el tipo de recurso requerido esté presente antes de agregar el paquete, como tal:

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

Este código anterior agregará el repositorio antes de agregar el paquete.

Algo como esto funcionó para mí:

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

Incluí algo como esto en mysite.pp. De esta manera, sus módulos de títeres están libres de referencias a repositorios yum.