Question

我曾经经常使用Puppet，从0.x到1.0版本左右，然后改变了工作，但现在我又回来了。 Puppet中的Hiera对我来说是新的（还有很多其他东西）。

我是否理解基本上不可能根据与Hiera匹配的主机名（或证书名称）模式将类分配给节点组？

例如，如果主机类似于“ntp1.foo.com”，我以前就会分配ntp服务器类。在

#ifndef LISTTYPE__H
#define LISTTYPE__H

#include <cstddef>
#include "Nodetype.h"
#include <iostream>

template <class T>

class ListType {

 public:
ListType();
ListType(const ListType<T>&);
virtual ~ListType();
bool operator=(const ListType<T>& right) const;
virtual bool insert(const T&) = 0;
virtual bool eraseAll();
virtual bool erase(const T&) = 0;
bool find(const T&) const;
size_t size() const;
bool empty() const;
friend std::ostream& operator<< (std::ostream&, const ListType&);

 protected:
int count;
NodeType<T> *first;
NodeType<T> *last; 
private:
void destroy();
void copy(const ListType<T>&);


};

 template <class T>
 ListType<T>::ListType()
{
first = nullptr;
last = nullptr;
count = 0;
 }

 template <class T>
 ListType<T>::ListType(const ListType<T>& otherList) {
first = nullptr;
copyList(otherList);
 }

 template <class T>
  ListType<T>::~ListType() {
destroy();
  }

 template<class T>
 bool ListType<T>::operator=(const ListType<T>& right) const  
 {
return (current = right.current);
 } 



 template <class T>
bool ListType<T>::eraseAll() {
head = 0;
return true;
}
 template <class T>
 bool ListType<T>::erase(const T& it) {
if (head == 0)
{
    return false;
}
else
{
    struct NodeType<T> *u = head->next, *p = head;
    if (head->item == it)
    {
        head = head->next;
        return true;
    }
    while (u != 0 && u->next != 0)
    {
        if (u->item == it)
        {
            p->next = u->next;
            return true;
        }
        u = u->next;
        p = p->next;
    }
    if (u->next == 0 && u->item == it)
    {
        p->next = 0;
        return true;
    }
    return false;
}
}
 template <class T>
 bool ListType<T>::find(const T& it) const {
 if (head == 0)
{
    return false;
}
else
{
    struct NodeType<T> *p = head;
    while (p->next != 0)
    {
        if (p->item == it)
        {
            return true;
        }
        p = p->next;
    }
    return false;
  }
  }

template <class T>
size_t ListType<T>::size() const {
return count;
}

template <class T> 
bool ListType<T>::empty() const
 {
   return (first == nullptr);
 }



 template <class T>
void ListType<T>::destroy() {
NodeType<T> *temp;
while (first != nullptr)
{
    temp = first;
    first = first->link;
    delete temp;
}

last = nullptr;
count = 0;
} 



 template <class T>
void ListType<T>::copy(const ListType<T>& otherList) {
nodeType<Type> *newNode;
nodeType<Type> *current;

if (first != nullptr)
    destroylist();
if (otherList.first = nullptr)
{
    first = nullptr;
    last = nullptr;
    count = 0;
}
else {
    current = otherList.first;
    count = otherList.count;
    first = new NodeType<T>;
    first->info = current->info;
    first->link = nullptr
    last = first;
    current = current->link;
    while (current != nullptr) {
        newNode = new NodeType<Type>;
        newNode->info = current->info;
        newNode->link = nullptr;
        last->link = newNode; 
        last = newNode;
        current = current->link; 
    }
}
 }

template <class T>
std::ostream &operator<< (std::ostream &out, const ListType<T> &list) {
if (list.head) {
    NodeType<T> *temp = list.head;
    out << list.head->item;
    temp = temp->next;
    while (temp != 0) {
        out << "," << temp->item;
        temp = temp->next;
    }
}
return out;
}
#endif

中使用直接node定义，这非常简单，我正在尝试将此概念转移到基于Hiera的世界中。我让Hiera分配其他类，并希望将所有这些作业归为一个地方。

我发现这样做的唯一方法是通过一些非Hiera方法设置一个参数，并在Hiera中使用它的值来匹配一个路径。例如，在我的site.pp脚本中，我导出了如下参数：

enc

在Hiera我会做类似的事情：

echo "parameters:"
if [ ... ]; do echo "  ntpRole: server; else echo "  ntpRole: client"; fi

我认为也可以通过自定义事实来做到这一点。

这很有效，但看起来像是一块垃圾。有没有更好/推荐的替代方案？

这样做的一个问题是每个节点必须都有一个值（所有内容都分配了一个ntp- 某些类）。这适用于NTP，因为所有机器都是NTP客户端或服务器，但对于存在的东西，它不会。

例如：Web服务器角色。有些机器不是Web服务器，所以我不想包含那个类，但是对于其他人我做了，我真的不想在每个节点文件中维护它而不是真的想要在任何地方都有空- "roles/ntp-%{ntpRole}"个角色类（例如*-none与web-none）。我希望所有名为web-server的计算机或基于其他一些标准的计算机都加载www*类。这可以用Hiera完成吗？

Answer 1

如果您的角色与服务器事实有关系，那么您可以使用自定义事实来分配角色。既然你说你以前根据服务器名称进行节点分类，我会假设这是你想去的路线。

:hierarchy:
  - "nodes/%{::trusted.certname}"
  - role/%{role}
  - "common"

然后您可以设置如下的hiera配置：

# role/web-server.yaml
classes:
  - web-server

在角色数据文件中，您可以提供一个类名数组：

$environment/manifest/site.pp

在主要清单中（通常为# if no classes array, traverse the else block if hiera('classes', false) { hiera_include('classes') } else { # logic for your 'none' situations since the classes array was not present }：

hiera_include

选中此fqdn.yaml信息：https://docs.puppet.com/hiera/3.2/puppet.html#assigning-classes-to-nodes-with-hiera-hierainclude。请注意，它也将合并到您的特定{{1}}数据文件的类中。

这将为您提供所请求的功能，并使用Hiera按节点分组/主机名包含类。

通过Hiera根据主机名为节点分配类

1 个答案: