Posts tagged ‘puppet’

Puppet: настройка Puppet fileserver для отдачи файлов и директорий

Что такое Puppet fileserver?

Puppet fileserver – сервис позволяющий забирать с Puppetmaster`a файлы и папки, используемые в вашей конфигурации. С помощью файлсервера, к примеру, вы можете передавать на сервера файл /etc/resolv.conf содержимое которого будет зависеть от $hostname. Лично я использую fileserver для кастомного софта, который не могу установить из репозитория или собирать пакет слишком долго.

Более подробно о возможностях file server можно почитать в официальной документации к Puppet http://projects.puppetlabs.com/projects/puppet/wiki/File_Serving_Configuration

Настройка

Для настройки файлсервер нужно открыть/создать файл fileserver.conf в папке конфигурации Puppet (по умолчанию /etc/puppet/fileserver.conf) и вбить в него следующие данные:

[files1]
path /var/puppet/files1
allow *.domain.com
 
[files2]
path /var/puppet/files2
# needed to allow local puppetd
allow 127.0.0.1
allow 192.168.1.0/24

Мы объявили две секции «files1″ и «files2″, параметр path указывает в какой папке нужно искать нужные файлы, параметры allow и deny отвечают за настройки безопасности файл серрвера.

Безопасность

Доступ к секции, по умолчанию, запрещен со всех серверов. Для того чтобы разрешить серверу доступ к секции нужно добавить опцию allow с именем, IP или подсетью. Параметр deny всегда весомее чем параметр allow, т.е. если у вас есть сервер с IP 192.168.0.1 и именем myhost.com то такая конфигурация не позволит вам забрать файлы из файлсервера:

[files3]
path /var/puppet/files/
allow 192.168.0.0/24
deny myhost.com

Использование

Для использования file server вам нужно использовать тип file:

        # Smartfox license
        file{"smartfox_license":
                path => "/opt/Smartfox/Server/licence.sfl",
                source => "puppet://puppet/files/smartfox/licenses/$fqdn/licence.sfl",
        }

Так я передаю файлы лицензий для сокет-сервера Smartfox на целевые машины. Т.е. у меня объявлена секция [files], локальный путь /var/puppet/files. По этому пути я создал папку «smartfox/licenses», внутри сделал папки с именами хостов (переменная $fqdn содержит полное имя целевого сервера, к примеру smartfox.domain.com), в каждой папке лежит файл с лицензией licence.sfl. Т.е. на целевой сервер smartfox.domain.com в папку /opt/Smartfox/Server/ попадает файл licence.sfl с puppetmaster сервера из папки /var/puppet/files/smartfox/licenses/$fqdn/

Пример выше позволяет передавать только один файл, вот так можно передавать целую папку:

        # Smartfox server bins
        file{"smartfox_bin":
                path => "/opt/Smartfox/Server/",
                source => "puppet://puppet/files/smartfox/Server/",
                ensure => directory,
                recurse => true,
                sourceselect => all,
        }

Главное здесь параметры recurse – говорит о том что мы передает всю папку и подпапки и sourceselect – говорит о том что мы передаем все файлы

                recurse => true,
                sourceselect => all,

Все, можно пользоваться, но помните – если вы используете стандартный Puppetmaster (т.е. он работает не через nginx или Apache а через написанный на Ruby веб сервер Webrick) передача папки большого размера может вызвать подъем LA на сервере.

Puppet: в шкуре кукловода. Часть 2

В прошлой статье я рассказал что такое Puppet, как установить puppetmaster и проверить его работоспособность. В этой я расскажу как подключать ноды, опишу используемую мной организацию манифестов и дам небольшой пример конфигурирования ресурсов на примере описанной в недавней статье утилиты Fail2Ban.

В тексте будут встречаться термины «классы», «ноды», «ресурсы» и т.д., для тех кому смысл этих терминов очень важен советую почитать книгу по Puppet Pulling Strings with Puppet: Configuration Management Made Easy, я рассказывал про нее в промежутке между статьями цикла.

В дальнейшем я буду исходить из того что вы используете CentOS, но иногда буду давать ремарки для других ОС.

Добавление puppet ноды

Из соображений безопасности, а также для гарантированной авторизации хостов(нод) Puppet использует самоподписанные SSL сертификаты. Такой сертификат генерируется при первом запуске puppetd (клиента) на сервере, поэтому перед запуском убедитесь что ваш hostname корректен. Далее с помощью этого сертификата puppet пытается соединиться с хостом puppet. или просто puppet. Т.к. SSL сертификаты чувствительны ко времени, возможно вам придется синхронизировать время между серверами при помощи ntp или другого сервиса. Далее описана процедура установки puppet на сервер под управлением CentOS, если вы используете другой тип установки вы можете перейти сразу к самому концу раздела.

Для добавления puppet ноды нужно установить puppet клиент на сервер-ноду, для этого в систему нужно добавить репозиторий EPEL
Создаем файл /etc/yum.repos.d/epel.repo:

[epel]
name=Extra Packages for Enterprise Linux 5 - $basearch
mirrorlist=http://mirrors.fedoraproject.org/mirrorlist?repo=epel-5&arch=$basearch
failovermethod=priority
enabled=1
gpgcheck=1
gpgkey=http://download.fedora.redhat.com/pub/epel/RPM-GPG-KEY-EPEL
includepkgs=ruby*,puppet*,facter*,augeas*

Далее ставим пакет puppet:

yum install puppet.noarch

Теперь прописываем в файле /etc/hosts наш puppetmaster(возможно вы захотите воспользоваться DNS, тогда вам нужно создать домен puppet.):

# <PUPPETMASTER_IP> puppet
1.1.1.1 puppet

Затем включаем автозапуск puppet и запускаем его:

chkconfig puppet on
service puppet start

Переходим на сервер с puppetmaster`ом и выполняем проверяем соединился ли puppet с сервером:

puppetca --list

на выходе будет строчка с hostname нашей ноды, далее нужно подписать ее сертификат:

# puppetca --sign <NODE_HOSTNAME>
puppetca --sign node1.test.com

Структура конфигурационных файлов

В терминологии Puppet информация о том что и как нужно сделать называется манифест(manifest) или рецепт(recepe), список уже готовых рецептов вы можете найти на сайте Puppetlabs: http://projects.puppetlabs.com/projects/puppet/wiki/Puppet_Recipes. Здесь же я расскажу как начать создавать такие рецепты, покажу пример структуры рецептов.

Итак приступим. Все рецепты пляшут из одного файла site.pp(/etc/puppet/manifests/site.pp), уже оттуда при помощи директивы «import» вы можете подключать свои конфигурационные файлы. Моя структура католога /etc/puppet/manifests выглядит так:

./classes
./classes/fail2ban.pp
./classes/mail.pp
./classes/yumrepos.pp
./nodes
./nodes/default.pp
./nodes/test.com.pp
./site.pp

Т.е. я создал папку classes, куда я складываю описание классов (еще раз советую почитать книгу по Puppet) и папку «nodes» куда я складываю описание нод. В файл site.pp я вписал две строки в которых делаю импорт файлов в этих папках:

import "classes/*.pp"
import "nodes/*.pp"

Таким образом любой файл с расширением .pp (файл манифеста для Puppet) будет подгружен в систему.

Кофигурирование ресурсов

Теперь собственно можно приступить к конфигурированию, далее мы создадим рецепт которые устанавливает и настраивает утилиту для защиты от брутфорса Fail2Ban и рецепт который будет добавлять в систему mail alias для пользователя root, чтобы пересылать нам его письма.

Fail2Ban

создаем файл classes/yumrepos.pp, в нем мы опишем нужный нам репозиторий (см. подробное описание):

# RPMForge repo
yumrepo { 'rpmforge':
    descr => 'Red Hat enterprise $releasever - RPMforge.net - dag',
    mirrorlist => 'http://apt.sw.be/redhat/el5/en/mirrors-rpmforge',
    enabled => '1',
    gpgcheck => '0',
    protect => '0',
    gpgkey => 'http://dag.wieers.com/rpm/packages/RPM-GPG-KEY.dag.txt'
}

Думаю здесь излишние описания не нужны.

Теперь описываем класс fail2ban (за подробностями по типам ресурсов сюда):

class fail2ban{
        package { "fail2ban":
                ensure => latest,
        }
 
        service { "fail2ban":
                ensure => running,
                enable => true,
                hasrestart => true,
                require => Package["fail2ban"],
        }
 
        file {"fail2ban-conf":
                path => "/etc/fail2ban/jail.conf",
                owner => root,
                group => root,
                mode => 644,
                content => template("fail2ban/jail.conf.erb"),
                notify => Service["fail2ban"],
                require => Package["fail2ban"],
        }
}

Итак мы убеждаемся что у нас установлен пакет fail2ban последней версии. Затем мы описываем сервис fail2ban, указываем что он должен быть запущен и включен по умолчанию на автозагрузку, также указываем что сервис имеет команду restart (иначе puppet будет сначала останавливать сервис а потом стартовать). Далее описывается конфигурационный файл для fail2ban, первые четыре строки вроде понятны, в пятой используется функция «template», эта функция по файлу в формате ERB генерирует выходной файл, его то мы и помещаем в наш конфиг. Опция notify означает что нам нужно оповестить сервис о том что файл изменился, т.е. выполнить ему restart.
Теперь подробнее про функцию template, она берет указанный нами файл из папки /var/puppet/templates/ и прогоняет его через ERB (чуть подробнее можно почитать в документации). Т.е. в папке templates я создал папку fail2ban и положил туда подготовленный для него конфиг(см. статью про fail2ban), ERB я в нем не использовал, но для «единобезобразия» всех интерфейса получения конфигов решил использовать именно функцию template.

Mail alias

Теперь создадим еще один ресурс, но уже для управления mail alias`ами в системе. Для этого в папке classes создаем файл mail.pp и записываем в него сл. данные:

class mail{
 
exec{ "newaliases":
    command => "/usr/bin/newaliases",
    refreshonly => true,
}
 
#####################################################
#
#  mail_alias - mail aliases in local system 
#
#  recipient - e-mail of recipient
#
#  Example:
#
#  mail_alias{"root":
#       recipient => "sysadmin@test.com"
#  }
#
#####################################################
define mail_alias($recipient){
        mailalias { $name:
                ensure => present,
                recipient => $recipient,
                target => '/etc/aliases',
                notify => Exec['newaliases'],
        }
}
}

Мы объявляем новый класс mail, в него я планирую помещать ресурсы связанные с локальной почтовой системой сервера. Внутри класса мы определяем новый ресурс (при помощи ключевого слова «define») mail_alias. Ресурсу мы передаем email получателя. Для создания алиаса используется стандартный тип Puppet mailalias. Строка «notify => Exec['newaliases']» служит для того чтобы после добавления алиасов выполнялась команда newaliases, описанная выше, параметр refreshonly означает что команда не будет выполнятся при каждом запуске Puppet, а только если ему придет событие notify.

Конфигурирование нод

Вернемся к нашей ноде «node1.test.com», пришло время применить наши рецепты, для этого в папке nodes создаем файл node1.test.com и записываем туда:

node node1.test.com{
        include "fail2ban"
        mail::mail_alias { 'root':
                recipient => ['sysadmin@test.com'],
        }
}

Итак мы описали ноду, в ее описание мы включили описание класса fail2ban и определили mailalias для пользователя root. Теперь нужно проверить как это все работает, для этого на главном сервере останавливаем puppetmaster и запускаем его руками с параметрами «–verbose –nodaemonize»:

service puppetmaster stop
puppetmasterd --verbose --no-daemonize

Теперь переходим на ноду и выполняем ту же операцию но уже с puppet:

service puppet stop
puppetd --verbose --no-daemonize

Если все правильно сделано, должен вывестись лог выполняемых действий, если будут обнаружены ошибки, они будут подсвечены красным.

Конец

На этот раз все, в следующей статье постараюсь рассказать более подробно про язык (DSL) Puppet`а и возможно про утилиты входящие в состав пакета. Всем очень советую почитать доку к утилите ralsh http://docs.puppetlabs.com/guides/tools.html#ralsh а лучше ralsh –help

Книга о системе управления конфигурацией Puppet

Pulling Strings with Puppet: Configuration Management Made Easy

Pulling Strings with Puppet: Configuration Management Made Easy

Книга рассказывает о ситеме управления конфигурацией Puppet. В ней ОЧЕНЬ подробно описан процесс установки puppet практически на все платформы и в любых конфигурациях. Сделан краткий (в книге всего 200 страниц) обзор возможностей Puppet на момент написания (2007 год), в книге рассматривается версии Puppet 0.22.4 и 0.23.2. Подробно рассмотрена утилита Facter, которая позволяет получать данные о сервере и операционной системе, эта утилита используется в Puppet повсеместно. Также достаточно полно освещены вопросы масштабирования Puppet, генерации отчетов и оповещений о внесении изменений или ошибках.
Также можно найти советы по стилю создания манифестов, ресурсов, классов, нод и прочих элементов конфигурации.

Скачать «Pulling Strings with Puppet: Configuration Management Made Easy» (если ссылка перестанет работать пишите в комментариях, обновлю или вышлю на почту)

Оглавление

About the Author.----------------------------------------------------- ix
About the Technical Reviewer.----------------------------------------- xi
Acknowledgments------------------------------------------------------- xiii
Introduction.--------------------------------------------------------- xv
■ CHAPTER 1            Introducing Puppet----------------------------- 1
                       What Is Puppet?.------------------------------- 3
                       What Makes Puppet Different?------------------- 3
                       How Does Puppet work?-------------------------- 4
                               A Declarative Language----------------- 5
                               A Transactional Layer.----------------- 7
                               A Resource Abstraction Layer----------- 7
                       Puppet Performance and Hardware.--------------- 7
                       The Future for Puppet.------------------------- 8
                       Resources.------------------------------------- 8
                               Web.----------------------------------- 9
                               Mailing Lists.------------------------- 9
                               IRC.----------------------------------- 9
■ CHAPTER 2            Installing and Running Puppet.----------------- 11
                       Installation Prerequisites--------------------- 11
                               Installing Ruby.----------------------- 12
                               Installing Ruby from Source.----------- 12
                               Installing Ruby and Ruby Libraries from Packages-- 13
                               Installing Facter---------------------- 15
                               Installing Facter from Source---------- 15
                               Installing Facter from Package.-------- 16
                               Installing RDoc.----------------------- 17
                       Installing Puppet------------------------------ 18
                               Installing from Source----------------- 18
                               Installing Puppet by Package----------- 20
                               Installing Puppet from a Ruby Gem------ 21
                       Getting Started with Puppet-------------------- 23
                               Starting the Puppet Master------------- 23
                               Starting the Puppet Client------------- 25
                    Signing Your Client Certificate------------------- 26
              Running the Puppet Daemons------------------------------ 28
              Configuring Puppet-------------------------------------- 28
                    The [main] Configuration Namespace---------------- 32
                    Configuring puppetmasterd------------------------- 33
                    Configuring puppetd------------------------------- 35
                    Configuring puppetca------------------------------ 38
              Resources----------------------------------------------- 40
                    Web.---------------------------------------------- 40
                    Mailing Lists------------------------------------- 40
   ■CHAPTER 3 Speaking Puppet----------------------------------------- 41
              Defining Configuration Resources------------------------ 42
                    Resource Titling.--------------------------------- 42
                    Resource Attributes------------------------------- 44
                    Resource Style.----------------------------------- 45
                    Resource Defaults--------------------------------- 46
                    Collections of Resources-------------------------- 47
                    Classes and Subclasses.--------------------------- 47
                    Classes Relationships----------------------------- 48
                    Class Inheritance--------------------------------- 49
                    Definitions--------------------------------------- 50
                    Qualifying Definitions.--------------------------- 53
                    Variables----------------------------------------- 53
                    Variable Scoping---------------------------------- 54
                    Variables and Class Inheritance------------------- 55
                    Qualified Variables------------------------------- 56
                    Variables and Metaparameters---------------------- 57
                    Arrays-------------------------------------------- 58
                    Conditionals.------------------------------------- 59
              Creating Nodes------------------------------------------ 62
                    Node Inheritance---------------------------------- 64
                    Node Inheritance and Variable Scope--------------- 66
                    Default Nodes------------------------------------- 68
                    Node Conditionals--------------------------------- 69
              Virtual Resources--------------------------------------- 69
                    Realizing with a Collection----------------------- 69
                    Realizing with the realize Function.-------------- 70
              Facts--------------------------------------------------- 71
              Resource Types------------------------------------------ 74
                    Managing Cron Jobs-------------------------------- 75
                 Using a Filebucket----------------------------------- 76
                 Managing Host Files---------------------------------- 77
                 Managing SSH Host Keys.------------------------------ 78
                 Tidy Unwanted Files.--------------------------------- 78
           Functions.------------------------------------------------- 79
                 Logging Functions------------------------------------ 81
                 Checking for Existence with defined------------------ 81
                 Generating Errors with fail-------------------------- 82
                 Adding External Data with file----------------------- 82
                 Using generate--------------------------------------- 83
                 Qualifying Definitions Using search------------------ 84
                 Using tag and tagged.-------------------------------- 85
                 Using Templating------------------------------------- 86
           Resources-------------------------------------------------- 88
                 Web.------------------------------------------------- 88
■CHAPTER 4 Using Puppet----------------------------------------------- 89
           Our Example Environment------------------------------------ 89
           Manifest Organization-------------------------------------- 91
                 Importing Manifests.--------------------------------- 91
                 Managing Manifests with Subversion.------------------ 93
           Defining Nodes--------------------------------------------- 95
           Our First Classes------------------------------------------ 98
           Managing Users and Groups---------------------------------- 101
           Managing Users.-------------------------------------------- 102
           File Serving----------------------------------------------- 106
           Modularizing Our Configuration----------------------------- 109
                 MySQL Module----------------------------------------- 112
                 Postfix Module--------------------------------------- 113
                 Apache Module---------------------------------------- 115
           Resources-------------------------------------------------- 119
■CHAPTER 5 Reporting on Puppet.--------------------------------------- 121
           Getting Started.------------------------------------------- 121
           Configuring Reporting-------------------------------------- 124
           Report Processors------------------------------------------ 125
                 log.------------------------------------------------- 125
                 tagmail---------------------------------------------- 126
                 rrdgraph--------------------------------------------- 127
           Custom Reporting------------------------------------------- 129
           Resources-------------------------------------------------- 130
     ■CHAPTER 6 Advanced Puppet--------------------------------------- 131
                External Node Classification-------------------------- 131
                Storing Node Configuration in LDAP-------------------- 136
                Puppet Scalability------------------------------------ 142
                      Installing Mongrel------------------------------ 144
                      Installing Apache------------------------------- 145
                      Configuring Apache As a Proxy.------------------ 146
                      Configuring Puppet for Mongrel------------------ 150
                      How Far Will Puppet Scale?---------------------- 151
                Resources--------------------------------------------- 151
     ■CHAPTER 7 Extending Puppet-------------------------------------- 153
                Extending Facter-------------------------------------- 153
                      Configuring Puppet for Custom Facts------------- 154
                      Writing Custom Facts.--------------------------- 155
                      Testing Your Facts------------------------------ 157
                Extending Puppet-------------------------------------- 158
                      Creating the Type.------------------------------ 159
                      Properties-------------------------------------- 161
                      Parameters-------------------------------------- 161
                      Creating Our Provider--------------------------- 162
                      Distributing Our New Type----------------------- 165
                Resources--------------------------------------------- 168

Заключение

Для меня намного удобнее читать о новых технологиях именно с бумаги, т.е. я могу не особенно напрягаясь сейчас писать скрипты на Ruby и Perl и в случае необходимости все данные почерпну из Google, но в начале мне нужна книга. Так вышло и с Puppet, одной из причин по которым я выбрал Puppet было то, что сообщество собрало отличнейшую документацию описывающую буквально каждую мелочь, к тому же о Puppet была издана книга. Т.к. книга написана на английском и перевода по всей видимости не предвидеться, найти ее на прилавке просто не реально. Вот и решил я воспользоваться интересной статьей на Хабре (Печать книг по программированию в домашних условиях) и распечатать эту книгу. Вышло просто превосходно! Если кому-то интересно могу описать тех. процесс во всех подробностях.

Резаультаты:

Напечатаная книга Puppet

Напечатаная книга Puppet1

Качество фотографий оставляет желать лучшего, но это все чего я добился от своего телефона.

Puppet: в шкуре кукловода. Часть 1

К моему глубочайшему удивлению, такая отличная и полезная система как Puppet, практически не описана в русскоязычном Интернете. Те статьи что имеются(см. в конце поста) не заходят дальше поверхностного описания установки Puppet и настройки прав на файлы /etc/passwd, /etc/sudoers. Я вижу, что с помощью Puppet я и мои коллеги смогут сэкономить себе кучу времени при установке софта или переносе инфраструктуры на новое железо, поэтому хочу поделиться опытом и описать КАК я это сделаю :) .

Что это?

Puppet

Puppet – это система управления конфигурациями, инструмент который позволяет автоматизировать настройку и управление большим парком машин, систем, сервисов. Его магия состоит в том что вам достаточно один раз написать «рецепт» по настройке какого-то ПО или опции системы, и вы уже можете тиражировать эти изменения на сколь угодно большое количество серверов, для этого достаточно установить на целевой машине Puppet и произвести маленькую настройку.

Как это работает?

Pupet - system diagram

Есть центральный демон, так называемый pupetmaster(кукловод), у него хранятся данные о настройке сервисов, файлах, шаблонах конфигурации и т.д.
На сервера и рабочие станции под управлением Linux, *BSD, MacOS ставиться puppet(марионетка/кукла), раз в 30 минут этот сервис забирает данные о конфигурации ПО и системы у puppetmaster`а.
Конфигурировать можно практически все: установленные программы, репозитории ПО, права на файлы и папки, пользователей системы, файлы конфигурации, сервисы в системе и т.д. Также функциональность puppet`а можно расширять при помощи модулей или достаточно легко подключаемых плагинов к Facter и самому Puppet.

Устанновка PuppetMaster из репозитория (CentOS/Fedora)

Этот способ установки наиболее предпочтителен, т.к. позволяет в дальнейшем достаточно просто обновляться до новых версий.
Для установки puppetmaster в систему нужно добавить репозиторий EPEL
Создаем файл /etc/yum.repos.d/epel.repo*:

[epel]
name=Extra Packages for Enterprise Linux 5 - $basearch
mirrorlist=http://mirrors.fedoraproject.org/mirrorlist?repo=epel-5&arch=$basearch
failovermethod=priority
enabled=1
gpgcheck=1
gpgkey=http://download.fedora.redhat.com/pub/epel/RPM-GPG-KEY-EPEL
includepkgs=ruby*,puppet*,facter*,augeas*

Далее ставим пакет puppet-server.noarch:

yum install 'puppet*'

Вот и все, просто как палка :) . Далее можно переходить к конфигурированию и проверке работы puppet (см. ниже)

Установка PuppetMaster через Gem

Для установки Puppet нужно установить Ruby и Ruby gems (здесь уже на ваш выбор как :) ).

Для установки Puppet и Puppetmaster`а нужно установить gem puppet:

gem install puppet

Вместе с puppet будет установлено еще несколько gem`ов по зависимостям.
Теперь нужно прописать puppet в системе, для этого заходим в папку с gem`ом puppet(по идее /opt/ruby-enterprise-1.8.7-2010.01/lib/ruby/gems/1.8/gems/puppet-0.25.5, точное расположение папки ruby может быть другим, ставил из сорцов) и выполняем следующие команды по интеграции в систему:

confdir='conf/redhat/'
cp $confdir/client.sysconfig /etc/sysconfig/puppet
cp $confdir/client.init /etc/init.d/puppet
cp $confdir/server.sysconfig /etc/sysconfig/puppetmaster
cp $confdir/server.init /etc/init.d/puppetmaster
cp $confdir/fileserver.conf /etc/puppet/fileserver.conf
cp $confdir/puppet.conf /etc/puppet/puppet.conf
cp $confdir/logrotate /etc/logrotate.d/puppet

Редактируем файл /etc/init.d/puppetmaster:

...
PUPPETMASTER=/opt/ruby-enterprise-1.8.7-2010.01/bin/$prog
...

Редактируем файл /etc/init.d/puppet:

...
puppetd='/opt/ruby-enterprise-1.8.7-2010.01/bin/puppetd'
...

Как видите этот способ установки более длинный и муторный.

Первоначальное конфигурирование puppetmaster (проверка работоспособности)

Создаем тестовый манифест для проверки работоспособности Puppet:

# Создаем файл для проверки
touch /tmp/tmp
chown ftp:ftp /tmp/tmp
chmod 777 /tmp/tmp
# Создаем файл манифест
vim /etc/puppet/manifests/site.pp

Забиваем в site.pp следующие данные:

file { "/tmp/tmp":
    owner => root, group => root, mode => 440
}

Далее запускаем команду:

puppetmaster --verbose --no-daemonize

Мы запускам puppet не как демон, а в полу-интерактивном режиме, с выводом всех происходящих действий в терминал. Должна появиться строчка:

notice: Starting Puppet server version 0.25.5

И на этом все. Теперь открываем еще один терминал к серверу (терминал с puppetmaster`ом не закрываем) и набираем команду

puppetd --verbose --waitforcert 60 --no-daemonize

Таким образом мы запускаем puppet на нашем сервере, в интерактивном режиме как и puppetmaster.
После запуска должны появиться следующие строчки:

notice: Starting Puppet client version 0.25.5
info: Caching catalog for mail.rulimony.ru
info: Applying configuration version '1274869753'
notice: //File[/tmp/tmp]/owner: owner changed 'ftp' to 'root'
notice: //File[/tmp/tmp]/group: group changed 'ftp' to 'root'
notice: //File[/tmp/tmp]/mode: mode changed '777' to '440'
notice: Finished catalog run in 0.02 seconds

Это говорит о том что конфигурация удачно передалась с puppetmaster`а клиенту.

Останавливаем puppetmaster и puppet через Ctrl+c.

Все, puppetmaster и puppet можно запускать:

chkconfig puppetmaster on
chkconfig puppet on
service puppetmaster start
service puppet start

Что это было?


Мы установили Puppet и Puppetmaster на один сервер, создали тестовый манифест (site.pp) который изменяет владельца и права на файл /tmp/tmp.
Дальше нужно ставить puppet на другие сервера (ноды) и создавать настройки конфигурации.
Об этом постараюсь написать в течении недели. А пока советую приглядеться к следующим ресурсам:

Puppet, система управления конфигурациями. Часть I
Puppet, система управления конфигурациями. Часть II
Puppet против Chef: 10 причин, из-за которых выигрывает Puppet
Puppet Docs