puppet全方位學習之總結

puppet總結

1、基礎知識

    1. Puppet是開源的基於Ruby的系統配置管理工具，依賴於C/S的部署架構。Puppet這樣的自動化配置管理工具能夠幫助系統管理員更加方便的完成多臺服務器的升級軟件包、管理配置文件、系統服務、cron任務、添加新的配置、修復錯誤等重複工做。

2. Puppet的運做是典型的C/S模式，一個Server，多個Client。這個Server被稱做master，而Client被叫做agent，也就是指屬於master的node（節點）。在每一個instance上，不管它是master仍是agent，Puppet都做爲daemon程序常駐進程，agent們經過SSL標準與master創建加密認證鏈接，而master就做爲接收上級（也就是用戶）的命令並向agent們發送命令的指揮官。

3. Puppet的語法容許你建立一個單獨腳本，用來在你全部的目標主機上創建一個用戶。全部的目標主機會依次使用適用於本地系統的語法解釋和執行這個模塊。

4. 在大規模的生成環境中，若是隻有一臺puppetmaster會忙不過來的，由於puppet是用ruby寫 的，ruby是解析型語言，每一個客戶端來訪 問，都要解析一次，當客戶端多了就忙不過來，因此須要擴展成一個服務器組。puppetmaster能夠看做一個web服務器，實際上也是由ruby提供 的web服務器模塊來作的。所以能夠利用web代理軟件來配合puppetmaster作集羣設置。

5. 用puppet，能夠運行一個服務器端，而後每一個客戶端經過ssl證書鏈接服務器，獲得本機器的配置列表，而後更加列表的來完成配置工做，因此若是硬件配置好，在一天以內配置好上千上萬臺機器是很容易實現的事情，前提得大部分機器配置相似。

6.  puppet是一種Linux、Unix平臺的集中配置管理系統，所謂配置管理系統，就是管理機器裏面諸如文件，用戶，進程，軟件包這些資源，其設計目標是簡化對這些資源的管理以及妥善處理資源間的依賴關係。puppet使用一種描述性語言來定義配置項，配置項中被稱爲」資源」，描述性語言能夠聲明你的配置的狀態---好比聲明一個軟件包應該被安裝或者一個服務應該被啓動。

7. 在中心的Server上安裝puppet-server包，並運行puppetmasterd進程；在被管理機上安裝puppet包，並運行puppetd進程。另外，在每臺主機上配置好本身的hostname，以後每臺機器要以hostname區分。

8. puppet的服務器端保存着全部的對客戶端服務器的配置代碼，在puppet裏面叫作manifest. 客戶端下載manifest以後，能夠根據manifest對服務器進行配置，例如軟件包管理，用戶管理和文件管理等等。這樣就把平常的系統管理任務代碼化了，代碼化的好處是能夠分享，保存，避免重複勞動，也能夠快速恢復以及快速的大規模部署服務器。同時，manifest能夠的根據客戶端服務器的配置狀況(硬件和軟件)來動態生成。

Puppet 結構

9. puppet的代碼主要就是由這些資源和資源的屬性構成。

10. puppet有兩種執行模式，一是直接運行puppetd file.manifest ，二是puppetd --server puppetmaster.server.com;前面一種是直接讀取file.mainfest文件進行配置，後一種是從服務端下載manifest進行配置。

11. 編寫一個manifest文件/tmp/1.pp，內容以下:

f i l e {

" /tmp/ t e s t " :

content=>" h e l l o \n" ,

mode => 0644;

}

而後執行puppetd /tmp/1.pp ;執行完成之後，將會在/tmp目錄下面生成一個文件test,文件內容是"hello";第一行的file代表是什麼類型的資源，第二行的"/tmp/test"叫作這個資源的title;用來表明這個資源，後面兩行設置這個資源的屬性。

12.

package {

[ " gcc " , "make" ] :

ensure => i n s t a l l e d ;

}

這是配置一個包資源，包是gcc和make, 第三行是指定這兩個包的屬性,在這裏是installed,表示要安裝這兩個軟件包。再次提醒:不一樣的資源有不一樣的屬性,可是又有一些屬性是全部資源都共有的，例如tag,這種屬性叫作元屬性。

13. puppetmaster的第一個執行的代碼是在/etc/puppet/manifest/site.pp 所以這個文件必須存在,並且其餘的代碼也要經過代碼來調用. 如今,創建一個最簡單的site.pp文件,內容以下

node default {

f i l e { " /tmp/temp1 . t x t " :

content => " h e l l o " ; }

}

 

2、原理

    Puppet是一個C/S架構的配置管理工具，在中央服務器上安裝puppet-server軟件包（被稱做Puppet master）。在須要管理的目標主機上安裝puppet客戶端軟件（被稱做Puppet Client）。當客戶端鏈接上Puppet master後，定義在Puppet master上的配置文件會被編譯，而後在客戶端上運行。每一個客戶端默認每半個小時(能夠設置runinterval=30)和服務器進行一次通訊，確認配置信息的更新狀況。若是有新的配置信息或者配置信息已經改變，配置將會被從新編譯併發布到各客戶端執行。也能夠在服務器上主動觸發一個配置信息的更新，強制各客戶端進行配置。若是客戶端的配置信息被改變了，它能夠從服務器得到原始配置進行校訂。

1)客戶端經過facter收集客戶端信息併發送至服務端

2)鏈接服務端並請求catalog日誌

3)請求節點（node）的信息

4)從服務器端接收節點（node)的實例

5)編譯代碼（包括語法檢查等工做）

6)查詢是否有exported 虛擬資源

7)若有，則從數據庫接收虛擬資源

8)接收完整的catalog日誌

9)存儲catalog日誌到數據庫

10)客戶端接收完整的catalog日誌

 

Puppet的工做細節分紅以下幾個步驟：

1、客戶端puppetd調用facter，facter會探測出這臺主機的一些變量如主機名、內存大小、IP地址等。而後puppetd把這些信息發送到服務器端。

2、服務器端的puppetmaster檢測到客戶端的主機名，而後會到manifest裏面對應的node配置，而後對這段內容進行解析，facter送過來的信息能夠做爲變量進行處理的，node牽涉到的代碼才解析，其它的代碼不不解析，解析分幾個過程：語法檢查、而後會生成一箇中間的僞代碼，而後再把僞代碼發給客戶機。

3、客戶端接收到僞代碼以後就會執行，客戶端再把執行結果發送給服務器。

4、服務器再把客戶端的執行結果寫入日誌。

 

 

 

實驗效果圖：

 

 

3、基本安裝

注意:要在安裝軟件之前先設置主機名，由於生成證書的時候要把主機名寫入證書,若是證書生成好了再改主機名，就連不上，這是不少初學者遇到問題。每一個客戶端的證書要通過根證書籤名才能和服務器鏈接。

 

系統配置：centos i386 5.x     最小化安裝+ Developtool

服務端ip: 192.168.10.1  hostname：master.perofu.com

客戶端ip: 192.168.10.3  hostname：client.perofu.com

 

準備狀況：ruby必須是1.8.5的，以上的不兼容。

1、 服務器端安裝

1.

    echo "192.168.10.1 master.perofu.com" >>/etc/hosts

echo "192.168.10.3 client.perofu.com" >>/etc/hosts

 

2.

    hostname master.perofu.com

   

3.

    vi /etc/sysconfig/network

        HOSTNAME=master.perofu.com

 

4.安裝ruby1.8.5,（1.8.6）不支持。若是須要查看幫助文檔,才須要安裝ruby-rdoc ruby-irb

    yum -y install ruby ruby-libs ruby-rdoc ruby-irb

 

5.安裝NTP同步時間，統一master和client上的時間(天天凌晨5點10分同步time.nist.gov，並將 Linux 時間寫入 BIOS時)

    yum install ntp -y

    chkconfig --level 35 ntpd on

    crontab -e

    10 5 * * * root /usr/sbin/ntpdate time.nist.gov ; /sbin/hwclock –w

    service crond restart

    ntpdate pool.ntp.org; hwclock –w

 

6.安裝facter

    tar -axf facter-latest.tgz -C /usr/local/src/

    cd /usr/local/src/facter-1.6.8/

    ruby install.rb

 

7.安裝puppet

    tar -axf puppet-2.6.3.tar.gz -C /usr/local/src/

    cd /usr/local/src/puppet-2.6.3/

    ruby install.rb

mkdir -p /etc/puppet/manifests

cp conf/auth.conf /etc/puppet/

cp conf/redhat/fileserver.conf /etc/puppet/

cp conf/redhat/puppet.conf /etc/puppet/

cp conf/redhat/server.init /etc/init.d/puppetmaster

chmod +x /etc/init.d/puppetmaster

chkconfig --add puppetmaster

chkconfig puppetmaster on

puppetmasterd --mkusers     #生成pupput用戶,#如出現錯誤，則執行groupadd puppet;useradd -g puppet puppet

mkdir -p /var/lib/puppet/rrd

chown puppet:puppet /var/lib/puppet/rrd

/etc/init.d/puppetmaster start  #啓動

netstat -anplt |gerp :8140  #是否已啓動

 

8.測試

    ②puppetca -s -a            #爲全部的客戶端簽證書，僅對某個客戶端第一次使用

 

    ④vi /etc/puppet/manifests/site.pp

        file { "/tmp/testfile":

        ensure => present,

        mode => 644,

        owner => root,

        group => root

        }

     /etc/init.d/puppetmaster restart   #第一次建立site.pp，必須重啓

 

 

 

 

2、 客戶端安裝

1.

    echo "192.168.10.1 master.perofu.com" >>/etc/hosts

echo "192.168.10.3 client.perofu.com" >>/etc/hosts

 

2.

    hostname client.perofu.com

 

3.

    vi /etc/sysconfig/network

        HOSTNAME=client.perofu.com

 

4.安裝ruby1.8.5,（1.8.6）不支持。若是須要查看幫助文檔,才須要安裝ruby-rdoc ruby-irb

    yum -y install ruby ruby-libs ruby-rdoc ruby-irb

 

5.安裝NTP同步時間，統一master和client上的時間(天天凌晨5點10分同步time.nist.gov，並將 Linux 時間寫入 BIOS時)

    yum install ntp -y

chkconfig --level 35 ntpd on

crontab -e

    10 5 * * * root /usr/sbin/ntpdate time.nist.gov ; /sbin/hwclock –w

service crond restart

ntpdate pool.ntp.org; hwclock –w

 

6.安裝facter

tar -axf facter-latest.tgz -C /usr/local/src/

cd /usr/local/src/facter-1.6.8/

ruby install.rb

 

7.安裝puppet

tar -axf puppet-2.6.3.tar.gz -C /usr/local/src/

cd /usr/local/src/puppet-2.6.3/

ruby install.rb

mkdir -p /etc/puppet

cp conf/auth.conf /etc/puppet/

cp conf/namespaceauth.conf /etc/puppet/

cp conf/redhat/puppet.conf /etc/puppet/

cp conf/redhat/client.init /etc/init.d/puppet

chmod +x /etc/init.d/puppet

chkconfig --add puppet

chkconfig puppet on

puppetd --mkusers       #如出現錯誤，則執行groupadd puppet;useradd -g puppet puppet

mkdir -p /var/lib/puppet/rrd

chown puppet:puppet /var/lib/puppet/rrd

/etc/init.d/puppet start

 

8.測試（服務器的第8步先執行）

    ①puppetd --test --server master.perofu.com #向服務器發送證書請求，等待服務器的簽收

    ③puppetd --test --server master.perofu.com #簽過以後，再次向服務器發起請求

    出現如下內容，表示服務器和客戶端能正常通信

        notice: Finished cactlog run in 0.02 seconds

    ⑤puppetd --test --server master.perofu.com

#請求服務器的/etc/puppet/manifests/下的內容

    ⑥ll /tmp/testfile              #若有，則表示測試成功

 

4、語法

1.puppet的代碼主要就是由這些資源和資源的屬性構成. 每一個資源都包含有類型（type），標題（title）和一些其餘屬性的列表。

這是一個典型的resource（資源）的結構：

type { "title ":

　　　　attribute =>"value",

              ...

              attribute => "value",

　　}

2. type是有規定的，並非本身隨便寫的，在Puppet的官方文檔裏有全部可用的type：augeas、computer、cron、exec、file、filebucket、group、host、interface、k5login、macauthorization、

mailalias、maillist、mcx、mount、nagios_command、nagios_contact、nagios_contactgroup、nagios_host、nagios_hostdependency、nagios_hostescalation、nagios_hostextinfo、nagios_hostgroup、nagios_service、nagios_servicedependency、nagios_serviceescalation、nagios_serviceextinfo、nagios_servicegroup、nagios_timeperiod、notify、package、resource、router、schedule、selboolean、selmodule、service、ssh_auth、rized_key、sshkey、stage、tidy、user、vlan、yumrepo、zfs、zone、zpool

3. 不一樣的title（標題），表示不一樣的資源；冒號前的那一部分，就是資源的標題（title）；在標題後面，緊跟的是特定的Attributes（屬性）,屬性用來告訴Puppet如何去配置資源。

4. 屬性和值的結構：attribute => "value",

5. 每個屬性鍵值對後面都要有一個逗號，最後一個屬性鍵值對後面可使用逗號也可使用分號。

6. 若是一個資源只有一個屬性，它能夠被聲明成一行，像這樣:

file { "/etc/group": owner => "root" }

7. 每一個資源寫多行的結構。多個資源能夠被配置在一個資源類型裏面如:
file {
"/etc/passwd":
ensure => present;
"/etc/group" :
owner => "root",
group => "root";
}

8. 首字母大寫的資源類型永遠是一個引用，而小寫的是一個聲明。因爲資源只能被聲明一次，因此重複兩次相同的聲明會致使錯誤。這是Puppet保證你的配置模塊化的重要特性之一。

9.除了每一個資源類型的屬性外，Puppet同時具備稱做元參數（Metaparameters）的全局屬性。元參數能夠與任何資源類型協做。

10. 有時你須要爲一組資源指定一個默認的參數值；Puppet使用一個首字母大寫而且沒有標題（title）的資源格式來實現這個功能。例如，在下面的例子中，咱們將爲全部的命令設定一個默認路徑：

Exec { path => "/usr/bin:/bin:/usr/sbin:/sbin" }

exec { "echo this works": }

這個代碼段中的第一個聲明爲可執行(exec)資源提供了一個默認值；資源Exec須要一個絕對路徑或者可以找到可執行程序的路徑。這樣減小了代碼量，同 時，在須要時這個路徑能被單獨的資源覆蓋。經過這種方法，你能夠爲整個配置文件指定一個默認路徑，而後在須要的時候覆蓋掉這個值。

11. 在Puppet中，資源的默認值對任何資源均生效。

12. 類的關鍵字是class，它的內容由一對大括號包裹。下面這個例子建立了一個用於管理兩個獨立文件的類：

class unix {

    file {

        "/etc/passwd": 

            owner => "root", 

            group => "root", 

            mode  => 644;

        "/etc/shadow": 

            owner => "root", 

            group => "root", 

            mode  => 440;

    }

}

 

13. 定義使用和類相同的基本形式，不一樣的是它們使用關鍵字define（而不是class），而且定義支持參數但不支持繼承。就像以前所提到的，定義能夠接收 參數並在相同的系統上屢次重用。好比咱們可能會在一個系統內建立多個版本庫，這裏可使用定義而不是類。下面是一個例子：

define svn_repo($path) {

    exec { "/usr/bin/svnadmin create $path/$title":

        unless => "/bin/test -d $path",

    }

}

svn_repo { puppet_repo: path => "/var/svn_puppet" }

svn_repo { other_repo:  path => "/var/svn_other" }

注意變量是怎麼在定義中使用的。咱們使用$符號表示變量。注意上面的變量$title。這裏有一點專業知識，在Puppet 0.22.3及之後的版本中，定義能夠分別使用變量$title和$name表示標題和名字。默認狀況下，$title和$name被設置成相同值，不過 你能夠設置一個標題值，同時將一個不一樣的名字值做爲參數進行傳遞。$title和$name只在定義中生效，類或其餘資源均不生效。

 

<一>變量和數組

 

1.變量

puppet用$符號定義變量，變量的內容。

 

聲明格式：$變量名="值"

引用格式： ${變量名}

 

$test=" hello , guys "

file {"/tmp/ test " :

content => ${test};

}

 

2.數組

    puppet利用方括號來定義數組，數組的內容由逗號分割，分別用雙引號括起來

[ "apache2" , " httpd " , " ssh " ]

 

 

 

<二>資源：

定義一個資源，須要指定資源的type（類型）和資源的title（標題）

這是一個典型的resource（資源）的結構：

type { "title1 ",…,"title ":

　　　　attribute => "value",

              ...

              attribute => "value",

　　}

看一個例子：

file{

"/etc/passwd":

name => "/etc/passd",

owner => root,

group => root,

mode => 644;

}

上面的代碼讓/etc/passwd的權限保持644,而且屬於root用戶和root用戶組，file是指定資源的類型是"file"類型，第二行的"/etc/passwd"是資源的title, title的做用是讓puppet能惟一標識這個資源。第三行的name指定了要對那個文件操做,默認狀況下，name都等於title,因此不少時候name是能夠省略的。這點要注意。看下面的例子:

file{

"sshdconfig":

name => $operatingsystem ? {

solaris => "/usr/local/etc/ssh/sshd_config",

default => "/etc/ssh/sshd_config",

},

owner => root,

group => root,

mode => 644,

}

資源的title是sshdconfig,可是name卻能夠經過斷定操做系統本身選擇合適的值。這樣，當其餘的資源要依賴sshdconfig的時候，只須要說明依賴sshdconfig就行，不須要關心文件到底在什麼路徑下面。例以下面的代碼：

service {"sshd":

subscribe => File[sshdconfig],

}

指定了一個sshd的服務，這個服務若是發現文件資源sshdconfig 有變更，就會本身reload配置文件。是否是很方便呢？注意上面的subscribe後面的File,第一個字母要大寫，定義資源關係的時候，這裏的字母要大寫。

一般，在puppet代碼裏面可能會定義不少相同的資源，能夠用[]把全部資源的title寫在一塊兒，例如：

file{

["/etc/passwd","/etc/hosts"]:

owner => root,

group => root,

mode => 644;

}

你可能已經發現了，每次定義文件的時候若是都輸入mode,owner,group會很繁瑣，所以你能夠在puppet的site.pp的開頭定義資源的默認值。定義資源的默認值須要把資源的第一個資源大寫。例以下面的代碼讓全部的file資源的mode是644,owner是root。

File{owner => root,mode => 644;}

默認值能夠被後面的設置覆蓋。

在puppet裏面能夠定義資源之間的關係，例如前面提到的，若是sshdconfig文件若是有修改，sshd服務就重啓。puppet裏面還有另外一個資源關係，依賴。例如資源A依賴資源B,若是資源B不存在，資源A就不被執行。定義資源依賴的屬性是requre 。例如:

file{

"/etc/apache2/port.conf":

content => "80",

require => Package["apache2"];

}

package{

"apache2":

ensure =>installed;

}

file資源設置port.conf的內容爲80,可是在設置file資源以前，要求apache2這個軟件包配置好了（即file資源依賴Package["apache2"]）。

 

<三>資源的類型：

 

puppet的資源是由具體的系統管理任務抽象而來的，系統管理中遇到什麼任務，就會有相應的資源類型，目前puppet支持的資源類型有：

file           文件/目錄的管理

package        軟件包的管理（yum install|remove）

service        某服務的管理（start|restart|stop|status）

cron           crontab定時任務的管理

user           添加用戶

group          添加用戶組

exec           shell命令

notify         資源之間的通信

   

<四>經常使用資源：

puppet管理不一樣的資源，是利用不一樣的provider來管理的。例如管理package資源，在debian上面是用的apt-get,在redhat上面是用的yum 。在這裏,apt,yum就是provider。在定義資源的時候，能夠明確指定provider。可是一般都是puppet本身探測。

 

file資源

 

 

 

 

file {"title":                      #通常是文件名

    ensure => present|absent|file|directory|link

content => "content",   #文件內容（必須有，不然，文件的內容爲空）

    user => "username",

    group => "groupname",

    mode => 權限,       #四位八進制數

    path => "title",

    source => "puppet:///URL",

    #指定到master上文件的絕對路徑或agent上本地文件絕對路徑

   

    target =>               #指定目標文件，用於ln -s $target $title

    recurse => true,            #遞歸

    purge => true,              #將再也不資源中管理的其餘數據，刪除

    force => true,              #如不加，則不會刪除

}

 

content     content => "字符串",

把文件的內容(title或name)設置爲content 參數後面的字符串, 新行,tab,空格可用 escaped syntax 表示（必須有，不然，文件的內容爲空，除非你不須要）

 

ensure      ensure => {absent|present|file|directory|link},

若是文件原本不存在是否要新建title名的文件,

present,檢查該文件是否存在,若是不存在就新建title名的文件,

absent, 文件存在,就會刪除title名的文件(若是recurse => true ,就會刪除目錄).

            file, 不存在就新建title名的文件

            directory, 不存在就新建title名的目錄

 

group       group => {gid|組名},

指定那個該文件的用戶組,值能夠是gid或者組名

 

mode        mode => {rwx},

mode用於設置文件的權限(數字)r=4,w=2,x=1

 

owner       owner => {用戶名},

設置文件的屬主

 

path        path => "文件的路徑",

            指定要管理文件的路徑,必須用引號引發來, 這也是一個資源的 namevar ,一般path 等於資源的title

 

source      source => {"puppet:///URL"|"完整的文件路徑"},

拷貝一個文件覆蓋當前文件,用checksum來判斷是否有必要進行復制,能夠設置的值是一個引用master或agent的完整的文件路徑,或者是URI,當前支持的URI只有puppet和file ; 這是一個對文件經常使用的操做,可讓puppet修改系統的配置文件.

 

backup      backup => {|.文件名|false},

     決定文件的內容在被修改前是否進行備份. 利用filebucket對文件進行備份,按文件的md5sum進行歸類,便於恢復文件的時候找到文件.能夠把文件備份到 puppet 客戶端,也能夠經過設置backpup => bucket_name 把文件備份到網絡上的其餘機器. 若是backup的值是一個點號」.」開頭的字符串,puppet會把文件備份在同一目錄下,備份文件的擴展名就是 bakcup裏面的那個字符串.若是設置 backup => false , 該文件不作備份.

 

recurse     recurse => { true|false|inf|remote},

設置是否以及如何進行遞歸操做，便可以管理子目錄（recurse,purge和force連用，用於刪除子目錄中，不在資源控制的文件或目錄）

 

purge       purge => {true|false},             

將再也不資源中管理的其餘數據，則刪除

 

force       force => {ture|false},

force是否能夠刪除文件或目錄，與ignore相反

 

ignore      ignore => {文件名|正則表達式},

                當用recursion 方法複製一個目錄的時候,能夠用ignore來設定過濾條件,符合過濾條件的文件不被複制或刪除. 使用ruby自帶的匹配法則.所以shell級別的過濾表達式徹底支持,例如[a-g]*， 與force相反

 

target      target => {"源文件或目錄"}

            是爲建立連接文件的，即將target的值，做爲源文件，title的值，做爲目標文件。如lin -s $target $title。當且僅當ensure => link, 纔可使用

 

checksum    checksum => {md5|mtime|time|timestamp},

怎樣檢查文件是否被修改,這個狀態用來在複製文件的時候使用, 這裏有幾種檢測方式,包括md5 ,mtime,time,timestamp等.默認的檢測是用md5,

 

links       link => {follow|manage},

定義操做符合連接文件.文件拷貝的時候,

follow,會拷貝文件的內容,而不是隻拷貝符合連接自己,

manage ,會拷貝符合連接自己.

 

recurselimit    recurselimit => {數字},

遞歸的深度,設置的值能夠匹配/^[0-9]+$/.

 

replace         replace => {true|false},

是否覆蓋已經存在的文件。能夠設置的值是(true,yes),(false,no),注,true和yes同樣，false和no是同樣。

 

selrange    文件內容是否屬於SElinux哪一個組成部分，只適於開啓了Selinux的機器。

selrole     文件所屬的SeLinux 角色

seltype     文件所屬的Selinux   type

seluser     文件所屬的Selinux user

sourceselect    選擇拷貝目錄級別，默認，source是遞歸的。

type        檢查文件是否只讀。

 

 

例：

 

 

file資源在puppet裏面用的挺多，屬性包括你們已經屬性的owner,group,mode,content等等。file還有兩個重要的命令，source和template.一般，一個文件的內容能夠由content屬性來包含固定的內容，可是也能夠用source命令來從其餘url複製文件內容。目前puppet只支持puppet這個url,表示從puppet的fileserver去下載文件內容。例如：

source => "puppet://${fileserver}/lvs/${corp}.${idc}.keepalived.conf "

其中fileserver後面的lvs表示是lvs模塊的files目錄這個路徑。正如前面提到的同樣。用source就能夠把不少配置文件放到puppet服務器端統一管理。

file資源的另外一個template命令是一個功能強大的命令。利用template,能夠經過erb模板生成文件內容，erb模板可使用變量。並且還能夠對變量進行計算和操做。這是puppet強大的地方，舉一個例子,你配置兩臺squid服務器，兩臺服務器的內存不同，那麼在squid.conf裏面有關內存的配置命令就要根據硬件配置來設置。在過去，你只能手工去斷定和修改，如今puppet本身搞定。看下面的代碼：

file {

"/etc/squid/squid.conf":

mode => 0644,

content => template("squid/squid.conf.erb");

}

這裏的template裏面的"squid/squid.conf.erb"表示的路徑是squid模塊下面templates目錄

下的squid.conf.erb這個路徑。看看squid.conf.erb裏面的部份內容1

cache_mem <%= Integer(vmx_memsize.to_i*0.45) -%> MB

visible_hostname <%= fqdn %>

在這裏，cache_mem設置成總內存的45%大小，visible_hostname 設置成主機名。更多有

趣的功能也能夠實現。

 

在使用puppet過程當中,有時有個類須要使用到多個file 資源. 而這些資源有相同的屬性,例如,用戶和組相同,權限相同,你仍是每次都照樣寫嗎?這裏給你們提供一個小的技巧.其實這裏咱們能夠給file 設置默認的屬性.就不用重複寫了.大大地簡化咱們的代碼.

例如:
File {          ##這裏的大寫,表示默認屬性,下面的兩個文件,屬主和組都會被設置爲root且權限爲644  
ensure => "present",
owner  => "root",  
group  => "root",  
mode   => 644,
}
file {  "/etc/cobbler/modules.conf":
  content => template("cobbler/modules.conf"),
}
file { "/etc/cobbler/dhcp.template":
  content => template("cobbler/dhcp.template"),
}

其實咱們能夠再優化下寫法,以下:
File {         
ensure => "present",
owner  => "root",  
group  => "root",  
mode   => 644,
}
file {  "/etc/cobbler/modules.conf":
  content => template("cobbler/modules.conf"),
     "/etc/cobbler/dhcp.template":
content => template("cobbler/dhcp.template"),  
}

 

package資源

1.package資源的屬性

packae {"package name":

    ensure => {present|absent|latest|version|purged},

    #present    只要存在便可，或installed

    #absent     刪除（無依賴），當別的軟件包依賴時，不可刪除

    #latest     升級到最新版本

    #version    指定安裝具體的某個版本號（yum list），格式：ensure => "版本號",

    #purged     刪除該包，和依賴包(有風險，勿用)

    name => "package name",     #應該省略，寫到title部分便可

}

package資源管理系統的軟件包安裝，默認是yum源（/etc/yum.repo.d/）的，經過puppet來自動安裝的軟件包均是經過yum來安裝的，因此須要配置好yum源,該資源的主要屬性是ensure;設置該軟件包應該在什麼狀態. installed 表示要安裝該軟件,也能夠寫成present; absent 表示反安裝該軟件,pureged 表示乾淨的移除該軟件,latest 表示安裝軟件包的最新版本.

 

 

ensure => {installed|absent|pureged|latest}

 

installed:title的軟件必須安裝好了

absent:title的軟件是須要卸載的

pureged:title的軟件是須要所有刪除, 深度卸載，刪除全部配置文件和依賴包，有潛在風險，慎用

latest:title的軟件是須要被更新到最新

 

2.package資源的應用

例如：

package{

["vim","iproute","x-window-system"]:

ensure => installed;

["pppoe","pppoe-conf"]:

ensure => absent;

}

安裝vim等包，刪除pppoe,pppoe-conf包。若是你的系統安裝的是編譯的軟件包，建議你

打包成操做系統的包格式，創建你本身的軟件倉庫。

 

package {"screen":

    ensure => latest,

}

 

Package { ensure => "installed" }   #設置默認屬性

package { "screen": } package { "strace": } package { "sudo": }

 

請注意，第一個P是大寫，這就是意味着對軟件包管理設置了一個全局的的參數，即若是沒有提供參數，那麼默認就是要installed，即安裝

 

service資源

1.service資源的屬性

service {"title":                       #title爲服務名,mysqld

    ensure => {running|stopped},        #當前service的狀態

    enable => {true|false},         #service是否開機啓動

    {status|start|stop|restart} => "cmd ", 

#指定命令的路徑，當且僅當，啓動腳本不在/etc/init.d/下的，才須要，通常用於源碼包安裝的，且命令再也不/etc/init.d/下的

    hasrestart => {true|false},    

#重啓service的步驟，true->restart; false->stop,start

    hasstatus => {true|false},     

#是從命令行查詢仍是從進程表（有沒有該進程）中，查詢service的狀態

}

2.service資源的應用

service {"httpd":

    ensure => running,

    start => "/usr/local/apache2/bin/apachectl start",

}

 

service {"httpd":

    ensure => running,

    restart => "/usr/local/apache2/bin/apachectl restart",

    hasrestart => "true",

}

 

exec資源

 

exec {"title":             

#通常寫上要執行的命令，如不寫，則須要指定command

    cwd => "目錄的絕對路徑",   

#在那個目錄下執行，也可不要

    path => "/bin:/sbin:...",  

#命令執行的搜索路徑,如不要，則需指定命令的絕對路徑

    command => "執行的命令",   

#寫上要執行的命令，通常不須要，可在title中寫上

    creates => "文件名（絕對路徑）",

#當且僅當，該文件名不存在，命令才被執行，可不要

    user => "用戶名",      

#定義運行命令的用戶。 注意若是你使用了這個參數，那麼任何的錯誤輸出不會在當下被捕捉，這是Ruby的一個bug

    logoutput => "true|false", 

#是否記錄輸出,可取的值爲：true，false和其餘合法的日誌等級。

    onlyif => "命令",      

#如onlyif中命令的執行結果爲0（執行正確），才執行title或command中的目錄,與unless相反

    unless => "命令",      

#如unless中命令的執行結果不爲0（執行出錯），才執行title或command中的目錄,與onlyif相反

}

 

 

puppet執行外部命令，屢次反覆用這個方式執行命令是有威脅性的,所以建議對執行的命令進行加鎖或者相似的處理.

建議每一個exec資源的名字最好是惟一的.

建議屬性值的目錄、命令或文件，最好是絕對路徑

 

puppet exec 參數介紹

 

command:    command => "執行的命令",

將會被執行的命令，必須爲被執行命令的絕對路徑，或者得提供該命令的搜索路徑。若是命令被成功執行，全部的輸出會被記錄在實例的正常（normal）日誌裏，可是若是命令執行失敗（既返回值與咱們所指定的不一樣），那麼全部的輸出會在錯誤（err）日誌中被記錄。這個是exec資源類型的名變量（namevar）。

 

creates:    creates => "文件名(絕對路徑）",

指定命令所生成的文件。若是提供了這個參數，那麼命令只會在所指定的文件不存在的狀況的被執行：

 

cwd:        cwd => "目錄的絕對路徑",

指定命令執行的目錄。若是目錄不存在，則命令執行失敗。

 

user        user => "用戶名",

定義運行命令的用戶。 注意若是你使用了這個參數，那麼任何的錯誤輸出不會在當下被捕捉，這是Ruby的一個bug。

If you are using Puppet to create this user, the exec will automatically require the user, as long as it is specified by name

 

onlyif      onlyif => "命令",

如onlyif中命令的執行結果爲0（執行正確），才執行title或command中的目錄,與unless相反。例如：

exec { "logrotate": path => "/usr/bin:/usr/sbin:/bin", onlyif => "test `du /var/log/messages | cut -f1` -gt 100000" }

只有在test返回true的時候logrotate纔會被運行。

須要注意的是onlyif定義的命令跟主命令遵循一樣的規則，也就是說若是path沒有被設置的話，須要使用絕對路徑。

除此以外，onlyif還能夠接受數組作爲其值，例如：

onlyif => ["test -f /tmp/file1", "test -f /tmp/file2"]

上面的代碼限定了只有在全部數組中的條件返回true時exec纔會被執行。

 

unless      unless => "命令",

如unless中命令的執行結果不爲0（執行出錯），才執行title或command中的目錄,與onlyif相反。例如：

exec { "/bin/echo root >> /usr/lib/cron/cron.allow":

            path => "/usr/bin:/usr/sbin:/bin",

            unless => "grep root /usr/lib/cron/cron.allow 2>/dev/null"

            }

上面這段代碼先用grep在cron.allow文件（Solaris系統中）中找root，若是沒有找到，就寫入root。

要注意的是這個參數裏的命令跟主命令遵循一樣的規則，也就是說若是path沒有被設置的話，須要使用絕對路徑。

 

path        path => "/bin:/sbin:...",

命令執行的搜索路徑。若是path沒有被定義，命令須要使用絕對路徑。路徑能夠以數組或以冒號分隔的形式來定義。

 

logoutput   logoutput => "true|false",

是否記錄輸出。默認會根據exec資源的日誌等級（loglevel） 來記錄輸出。若定義爲on_failure，則僅在命令返回錯誤的時候記錄輸出。可取的值爲：true，false和其餘合法的日誌等級。

 

env:

咱們不建議使用這個參數，請使用‘environment’。這一部分還未完成。

 

environment

爲命令設定額外的環境變量。要注意的是若是你用這個來設定PATH，那麼PATH的屬性會被覆蓋。多個環境變量應該以數組的形式來設定。

 

group

定義運行命令的用戶組。在不一樣的平臺下的運行的結果沒法肯定，因爲不一樣用戶運行命令的時候，變量是不變的，因此這是平臺的問題，而不是Ruby或Puppet的問題。

 

refresh

定義如何更新命令。當exec收到一個來自其餘資源的事件時，默認只會從新執行一次命令。不過這個參數容許你定義更新時執行不一樣的命令。

 

refreshonly

該屬性可使命令變成僅刷新觸發的，也就是說只有在一個依賴的對象被改變時，命令纔會被執行。僅當命令與其餘對象有依賴關係時，這個參數纔有意義。當你要觸發某個行爲時，會顯得頗有用：

# Pull down the main aliases file file { "/etc/aliases": source => "puppet://server/module/aliases" } # Rebuild the database, but only when the file changes exec { newaliases: path => ["/usr/bin", "/usr/sbin"], subscribe => File["/etc/aliases"], refreshonly => true }

要注意的是隻有subscribe和notify能夠促發行爲，而不是require，因此在使用refreshonly時，只有同時使用subscribe或notify纔有意義。有效的值爲true, false。

 

returns

指定返回的代碼。若是被執行的命令返回了其餘的代碼，一個錯誤（error）會被返回。默認值是0，能夠定義爲一個由能夠接受的返回代碼組成的數組或單值。

 

timeout     timeout => "秒數",

命令運行的最長時間。若是命令運行的時間超過了timeout定義的時間，那麼這個命令就會被終止，並做爲運行失敗處理。當定義爲負值時就會取消運行時間的限制。timeout的值是以秒爲單位的。

 

 

 

exec資源在不到萬不得已的時候不要去用，簡單說來exec資源就是在執行puppet的時

候，調用shell執行一條shell語句，例如：

exec {"delete config":

path => "/bin:/usr/bin",

command => "rm /etc/ssh/ssh_config";

}

exec能夠用path指定命令執行的預搜索路徑，create屬性代表該exec將建立一個文件，當下一次puppet執行的時候，若是發現了這個文件，就再也不執行這個exec資源。

exec資源是不太好掌控的資源，若是能用腳本實現，儘可能寫成腳本經過file資源分發到服務器上面。而後用其餘的方式來調用腳本。例如crontab。說來crontab資源，羅嗦一句，雖然puppet提供了crontab資源，可是你徹底能夠用file資源來把crontab任務放到/etc/cron.d目錄下來實現crontab資源的管理。使用puppet的時候，儘可能用最簡單的語法，越是花哨的語法也越容易出錯。

 

cron資源

 

1.cron資源的屬性

minute hour month monthday weekday command

 

cron {"title":

    ensure => {present|absent},

#決定該計劃任務的目標狀態,present 如該cron不存在，則添加之;absent 如該cron已存在，則刪除之

    command => "命令",      #欲執行的命令或腳本路徑，也可不寫，默認是title

    user => "用戶",         #執行該cron的用戶身份

    minute => "值",         #同crontab，不寫，表明*

    hour => "值",          

    month => "值",

    monthday => "值",

    weekday => "值",

}

除了用戶和command兩個參數之外,其餘的參數都是可選項.

ensure      ensure => {present|absent},

決定該計劃任務的目標狀態,

present 如該cron不存在，則添加;

absent 如該cron已存在，則刪除之

 

command     command => "命令",     

欲執行的命令或腳本路徑，也可不寫，默認是title

 

user        user => "用戶",        

把該crontab加到那個用戶的crontab列表,默認是運行puppet的用戶

 

minute      minute => "值",        

運行crontab的分鐘,可設置成0-59,同crontab，不寫，表明*

 

hour        hour => "值",          

            運行crontab的小時,可設置成0-23

 

monthday    monthday => "值",

            一個月份中的日子,1-31

 

month       month => "值",

            設置crontab運行的月份,1-12

 

weekda      weekday => "值",

            運行crontab的星期數,0-7，週日是爲0或7.

 

2.cron資源的應用

cron {"logrotate":

command => 「/usr/sbin/logrotate」,

user => root,

hour => 2,

minute => 0

}

上述例子執行的結果就是在crontab中增長了一行：

crontab –e –u root

0 2 * * * /usr/sbin/logrotate

 

user資源

1.user資源的屬性

 

user {"title":              #用戶名，同name同樣

    name => "用戶名",       #用戶名，能夠不寫，默認與title同樣

    ensure => {present|absent},

    #指定用戶的目標狀態present 該用戶不存在則生成;absent 該用戶存在則刪除

    uid => "值",           

    gid => "值",

    groups => "組名",       #groups該用戶所屬用戶組名，可爲列表

    home => "絕對路徑",    

#該用戶分配的家目錄,如沒有managehome => true, 則不會建立家目錄

    managehome => {true|false},

#是否自動生成家目錄，默認爲false，表示，即便指定home，也不會建立；true表示建立home的目錄

    shell => "shell的絕對路徑",     #用戶登陸後默認分配的shell

    password => '密鑰',    

#指定用戶的結過MD5加密碼後的密碼（grub-md5-crypt）。最好以‘’引發來，記着，用單引號，由於通過MD5加密後可能會出$符號。

}

 

name        name => "用戶名",      

指定建立的用戶名，能夠不寫，默認與title同樣

 

ensure      ensure => {present|absent},

指定用戶的目標狀態。

present 該用戶不存在則生成;

absent 該用戶存在則刪除

uid         uid => "值",

            用戶的uid

 

gid         gid => "值",

            用戶的gid

 

groups      groups => "組名",      

groups該用戶所屬用戶組名，可爲列表

 

home        home => "絕對路徑",    

該用戶分配的家目錄,如沒有managehome => true, 則不會建立家目錄

 

managehome  managehome => {true|false},

是否自動生成家目錄，默認爲false，表示，即便指定home，也不會建立；true表示建立home的目錄

   

shell       shell => "shell的絕對路徑",

用戶登陸後默認分配的shell

password    password => '密鑰',

指定用戶的結過MD5加密碼後的密碼（grub-md5-crypt）。最好以‘’引發來，記着，用單引號，由於通過MD5加密後可能會出$符號。

 

2.user資源的應用

 

①.我要建立一個名爲test的用戶.

代碼示例

user { "test":

uid => 2000,

gid => 2000,

home => "/home/test",

shell => "/bin/bash";

}

 

注意：puppet在建立用戶的時候，並不會建立用戶的home目錄。

 

②.好比test用戶離職了，須要刪除test用戶。

 

代碼示例：

user { "test":

ensure => "absent",

}

 

③. 建立test用戶並管理用戶目錄

 

代碼示例

user { "test":

ensure => "present",

managehome => true,

 }

 

④.建立test用戶，且讓test用戶是屬於sa組。

 

代碼示例

 

user { "test":

ensure => "present",

managehome => true,

groups => sa,

 }

 

注意，用戶所屬的SA組要先建立。

 

關於如何建立組，在接下來的會爲你們講，這裏給舉個例子.

 

代碼示例：

group { "sa":

ensure => "present",

gid => 3000,

}

 

⑥

user {

     "test":

     ensure   => present,

     shell =>"/bin/bash",

     home  => "/home/test",

     managehome => true,

     comment =>"www.mysqlops.com test by sky add  test",

     password => '$1$Nnh0M0$t9s7Bbwx2fFer6IP/QGdA0',

       }

使用grub-md5-crypt生成密碼

 

總結：用戶和密碼跟系統管理員關係密切，管理用戶的切不可馬虎。方便快捷，實用的管理纔是王道，今天運維自動化管理

 

<二>引用資源

當咱們引用一個資源時，須要大寫資源類型的首字母，例如File[sshdconfig]。當看到一個大寫的資源類型，須要明白那實際上就是一個資源引用。小寫字母是用來定義的。資源只能被定義一次，重複定義相同的資源會致使錯誤。

 

1.資源的引用：

    基本格式：          Type ["title",…, "title"]

注：Type:表示資源的類型，且第一個字母必須大寫

    title：表示該資源的title，多個title，可用逗號分隔，必須存在

經常使用於require => Type ["title",…, "title"]

表示require以後的引用，必須先存在或正確執行

 

2.例子

①file { 'sshdconfig':

    path => $operatingsystem ? {

        solaris => '/usr/local/etc/ssh/sshd_config',

        default => '/etc/ssh/sshd_config',

    },

    owner => 'root',

    group => 'root',

    mode  => '0644',

}

service { 'sshd':

    subscribe => File['sshdconfig'],

}

 

<五>資源默認值

爲某類資源指定一個默認的參數。使用沒有標題的大寫資源首字母方式。

格式：     Type { 屬性 => 值,…, 屬性 => 值}

注：Type:表示資源的類型，且第一個字母必須大寫,不須要title

例如，爲全部的執行命令設置默認的path參數：

Exec { path => '/usr/bin:/bin:/usr/sbin:/sbin' }

exec { 'echo this works': }

第一行代碼爲exec資源提供一個默認的path參數。exec資源須要一個完整的限定路徑或者可以經過path參數找到具體的可執行文件。資源定 義時如有必要能夠覆蓋path的默認設置。這種狀況下咱們能夠爲全部的配置指定一個默認path參數，特殊狀況時覆蓋它就能夠了。

Puppet默認值支持全部的資源類型。

默認值不是全局的 - 它只在當前範圍和當前範圍下面有效。若是你想爲全部的配置設置默認值，惟一選擇是在任意類的外面定義它們。

 

<六>資源之間相互關係

 

①puppet 資源之間簡單依賴關係

puppet 資源之間簡單依賴關係，主要是有下面的三個參數。

before：在某個資源以前執行

 

after： 在某個資源以後執行

 

require： 某個資源必須存在或者正確執行後，才執行相應的資源。經常使用

 

爲了便於理解，下面就給你們看個代碼示例：

代碼示例：

  file {"/etc/ssh/sshd_config":

        .....

    require => Package["openssh-server"],   #引用package {"openssh-server": …}

   }

package { 「openssh-server」:

……

before => File["/etc/ssh/sshd_config"]，

}

 

上面例 子咱們能夠知道：/etc/ssh/sshd_config必須在openssh-server這個軟件包安裝後，纔會生成。

after和before相反，就不舉例說明了。那你們會有個問題，那/etc/ssh/sshd_config有改動的時候，那要怎麼辦呢，接下來就爲你們介紹,puppet資源之間觸發更新動做。

 

class admin::ntp {

     package { "ntp":

         ensure => installed,

         require => File["/etc/ntp.conf"],

     }

     service { "ntp":

         ensure  => running,

         require => Package["ntp"],

     }

     file { "/etc/ntp.conf":

         source  => "puppet:///modules/admin/ntp.conf",

         notify  => Service["ntp"],

         require => Package["ntp"],

     }

 }

Package["ntp"] -> File["/etc/ntp.conf"] ~> Service["ntp"]

 

 

②puppet 資源之間觸發更新

puppet資源之間觸發更新主要是由下面二個參數。在執行Services,Exec資源中很是有用。

notify：用來通知某個資源進行更新。

 

subscribe：該資源有更新時，通知另外一個資源執行相應的動做。

 

其實這兩個效果參數效果是同樣的。接下來看下代碼示例，更好的理解上面的兩個參數。

 

 file {"/etc/ssh/sshd_config":

       .....

       notify => Service[sshd],

      }

  service {"sshd":

           ......

           subscribe => File["/etc/ssh/sshd_config"],

      }

上面的例子，咱們能夠看到，當/etc/ssh/sshd_config文件發生更新時，就會通知sshd服務，進行reload.

 

你們能夠接合上面的兩個例子來看，能夠看到整個流程是這樣的，sshd服務運行，須要/etc/ssh/sshd_config配置文件，而/etc/ssh/sshd_config是要由openssh-server軟件包安裝來生成。

 

 

 

 

 

<七>類（class）

類能夠把多個相關的資源定義在一塊兒,組成一個類，一塊兒使用，例如把sshd和他的配置文件作成一個ssh類，其餘的地方要用到就直接包含ssh類就能夠了，方便寫出更簡潔的代

碼，便於維護。類能夠繼承。少用

    class 是一個資源的集合，它表明節點上一個單獨的配置項目，SSH服務或者NFS包，class在一個結點上僅僅造成1次(即在相同的系統上僅能使用一次)，由於已經完成的配置應該僅僅存在一次

 

1.定義類

類定義以class關鍵字開始，內容放在花括號裏面

class 類名 {

    type { "title ":

　　　　   attribute => "value",

       ...

       attribute => "value",

　　   }

    ...(各類資源)

    type { "title ":

　　　　   attribute => "value",

       ...

       attribute => "value",

　　   }

}

2. 繼承

類也有用基類（父類）和子類來實現簡單的繼承和覆蓋的模型，一個子類能夠繼承基類的值而且可以實現它一個或者多個值對基類的值進行覆蓋.

       子類的做用：完成某個任務，基本同父類的做用，但只是某些參數的不一樣

 

class 類名（新建）inherits 父類名（已存在）{

       Type ["title"] {attribute => "value",}

}

注：Type:表示資源的類型，且第一個字母必須大寫，且必須存在於父類中

{attribute => "value",}：表示修改父類的某些屬性的值

①{attribute => "value",…, attribute => "value",}    表示修改父類的某些屬性的值

②{attribute => undef,…,attribute => undef,}        表示取消父類的某個屬性的值

③{attribute +> "value"}

{[attribute +> "value",…, attribute +> "value",]} 表示增長父類沒有的某些屬性的值或者中歸納([])中的數組值

 

3. 禁用資源

爲繼承和覆蓋最多見的用法是禁止服務或者其它資源:

class apache::disabled inherits apache {

Service["apache2"] {

enable => false,

ensure => stopped,

}

}

 

 

4.實例

①class unix {

    file { "/etc/password":

         owner => "root",

         group => "root",

         mode  => 644;

    }

    file { "/etc/shadow":

         owner => "root",

         group => "root",

         mode  => 440;

    }

}

②

class freebsd inherits unix {

    File["/etc/passwd"] { group => undef }

}

在上面的例子中，包含類unix的節點的password文件的組名將被設置爲「wheel」，而包含類freebsd的節點的password文件的組名則不會被設置（既保持原來的值，不去修改）。

 

③

你能夠同時覆蓋多個值，好比：

class freebsd inherits unix {

    File["/etc/passwd","/etc/shadow"] { group => wheel }

}

 

④

可使用操做符‘+>’（‘再賦值’）來追加資源的參數：

 

class apache {

    service { "apache": require => Package["httpd"] }

}

 

class apache-ssl inherits apache {

    # host certificate is required for SSL to function

    Service[apache] { require +> File["apache.pem"] }

}

 

上面的例子中使第二個類依賴了全部第一個類所依賴的包，同時增長對包'apache.pem'的依賴。

 

當追加多個依賴時，使用中括號和逗號：

 

class apache {

    service { "apache": require => Package["httpd"] }

}

 

class apache-ssl inherits apache {

    Service[apache] { require +> [ File["apache.pem"], File["/etc/httpd/conf/httpd.conf"] ] }

}

 

⑤

 

class myclass {

class nested {

    file { "/etc/passwd":

    owner => "root",

    group => "root",

    mode  => 644;

    }

}

}

 

class anotherclass {

include myclass::nested

}

 

在這個例子中，在外層類中的嵌套類能夠經過在名爲anotherclass的類中以myclass::nested包括進來。在這裏順序很重要，若是要讓這個例子正確的運行的話，myclass類必定要在anotherclass類被求值以前被求值。

 

<八>函數（定義）

定義使用和類相同的基本形式，不一樣的是它們使用關鍵字define（而不是class），而且定義支持參數但不支持繼承。就像以前所提到的，定義能夠接收參數並在相同的系統上屢次重用

注：使用define最好在定義時，使用變量，負責就可使用class

 

1.無變量

①define 函數名() {

       type { "title ":

　　　　       attribute => "value",

              ...

              attribute => "value",

　　       }

       ...(各類資源)

       type { "title ":

　　　　       attribute => "value",

              ...

              attribute => "value",

　　       }

}

 

②有變量

define 函數名(變量名1,...,變量名n) {             #格式：$var

       type { "title ":

　　　　       attribute => "變量名",          #格式：${var},下同

              ...

              attribute => "變量名",

　　       }

       ...(各類資源)

       type { "title ":

　　　　       attribute => "變量名",

              ...

              attribute => "變量名",

　　       }

}

 

③在class中定義define

class 類名 {

define 函數名 (變量名1,...,變量名n) {

       type { "title ":

　　　　       attribute => "變量名",          #格式：${var},下同

              ...

              attribute => "變量名",

　　       }

       ...(各類資源)

       type { "title ":

　　　　       attribute => "變量名",

              ...

              attribute => "變量名",

　　       }

}

}

 

 

2.引用define

①通常狀況（無class）

函數名 {

       變量名 => "值",

       ...

       變量名 => "值",

}

 

②class

類名::函數名 {

       變量名 => "值",

       ...

       變量名 => "值",

}

 

3.實例

①定義了一個definition 用來執行一個腳本去配置一個新的主機.

define newip ( $ip ) {
exec { "/sbin/ifconfig" $title $ip ":
}
}

#引用

newip { eth0:
ip => "11.11.11.11"
}
#或

newip(11.11.11.11) {"eth0":

}

 

咱們建立了一個definition叫作newip而且有一個參數叫作$ip,內部定義了咱們用來執行資源類型內部二進制代碼,這裏是ifconfig 命令,咱們已經指出變量$ip和使用的另外一個變量$title（$name）

 

②同上，不過使用了類class

class virtuals {

define newip ( $ip ) {

exec { "/sbin/ifconfig $title $ip":

}

}

}

 

virtuals::newip { eth0:

ip => "11.11.11.11",

}

 

 

③聲明多個參數列表,以逗號分割:

 

define webapp( $domain, $path, $platform ) {

    ...

}

webapp { "mywizzoapp":

          domain   => "mywizzoapp.com",

          path     => "/var/www/apps/mywizzoapp",

          platform => "Rails",

}

 

④建立了一個函數(define),並只添加了一個參數,參數又

是實例的名字.可是,咱們也能夠添加任何咱們想要的參數,所以咱們只要在函數

中進行聲明.  

define tmpfile( $greeting ) {

file { "/tmp/$name":

content => $greeting,

}

}

 

在聲明實例資源的時候,並傳遞相應的變量值. 

tmpfile{ "foo": greeting => "Hello, world" }

 

⑤爲每個參數指定一個默認的值
define config_file(owner = root, group = root, mode = 0644,
source, backup = false, recurse = false, ensure = file ) {
file{ $name:
mode => $mode,
owner => $owner,
group => $group,
backup => $backup,
recurse => $recurse,
ensure => $ensure,
source => "puppet:///$source"
}
}

config_file { "/etc/vnc.conf":
source => "vnc/vnc.conf",
mode => "0640"
}

咱們建立了config_file定義, 而後對其應用，這跟函數調用差很少

 

 

4. 類 VS 定義

類和定義的建立過程都很類似（雖然類不接收參數），不過他們使用起來很是不一樣。

定義是用來定義在一個主機上包含多個實例的可重用對象的，因此定義不能包含任何只能有一個實例的資源。好比，屢次使用同一個定義不能建立相同的文件。

另外一方面，類是獨一無二的——不管你包含它們多少次，你只會獲得資源的一個副本。

大多數時候，服務會被定義成類，服務的包，配置文件以及正在運行的服務都會被定義在類中，由於一般在每個主機上它們都只有一個副本。（這些有時被慣稱爲「服務——包——文件」）。

定義是被用來管理相似虛擬主機這樣能夠有許多的資源，或者使用一個可重用的封裝來包裝一些簡單的信息，以此來減小代碼量。

 

 

<十>模塊

 

若是是你配置的應用，守護進程，或函數包含不少類、文件或模板。最簡單的方法就是將這些資源放到一個包裏面，Modules使管理配置文件的集合更簡單和更結構化。

 

使用模塊的步驟：

1.建立必要的模塊目錄及文件

       mkdir -p /etc/puppet/modules/模塊名/{manifests,files,templates}

       touch /etc/puppet/modules/模塊名/manifests/init.pp

 

2.在init.pp中導入別的pp文件(也可直接在init.pp中寫上puppet的語法)

       vi /etc/puppet/modules/模塊名/manifests/init.pp

              import "*"                                                     #至關於node … { import模塊名}

 

3.寫上puppet的語法,完成某些功能，最好是單獨寫，利於管理

       vi 模塊名.pp 

 

4.根據「模塊名.pp」的內容，考慮是否須要在files目錄下建立，所需的文件。

 

5.定義一個節點，並使用新的模塊(即/etc/puppet/modules/模塊名

       vi /etc/puppet/manifests/site.pp

              node 節點名 {

                     include 模塊名

              }

 

注：

       /etc/puppet/modules/模塊名/manifests  ：存放該模塊的全部配置文件，格式：文件名.pp

       /etc/puppet/modules/模塊名/files         ：存放該模塊中所須要的文件

       /etc/puppet/modules/模塊名/templates  ：存放模板文件的目錄，文件格式：文件名.erb

/etc/puppet/modules/模塊名/manifests/init.pp      ：init.pp文件是該模塊的初始文件，導入一個模塊的時候，會從init.pp開始執行。能夠把全部的代碼都寫到init.pp裏面，也能夠分紅多個pp文件，init再去包含其餘文件（import "*.pp"）

 

Modules組織起來很簡單。他們存儲在一個指明的文件夾下，modulepath的配置在puppet.conf中指出，默認在$confdir/modules 和 /usr/share/puppet/modules目錄，咱們能夠指出多個module路徑用冒號隔開,如：
modulepath = /etc/uppet/modules:/usr/share/puppet/modules

 

引入的時候使用
import "mysql"
Puppet是如何知道加載什麼資源的呢，每一個module被用一個文件夾去進行組織的，調用一個init.pp的文件進行初始化，每個module至少應該有下面的這些目錄結構
module_path/

module_name/

module_name/manifests/
module_name/manifests/init.pp
當引入一個module時init.pp文件是自動處理的，init.pp應該被放到默認的module中
/etc/puppet/modules/mysql/manifests/init.pp
這個init.pp有兩重的功能，它包含了一個核心的classes被用作提供一個引入類和定義的位置,它應該被放到manifests文件夾下面，下面是一個init.pp文件的例子
class mysql {
package { "mysql-server":
...
}
service { "mysqld":
...
}
}
咱們聲明瞭一個叫作mysql的class在這裏咱們配置了package和service的資源,因此當咱們引入一個module的時候，好比是 mysql module，Puppet將在因此的包含mysql的路徑中進行查找，它將查出來的manifests文件夾下的init.pp文件而且加載它的內容.

Puppet 也容許一些聰明的命名方法使使用模塊更加容易，建立一個mysql名空間，使用這個名空間，好比，mysql module建立了一個名空間叫作mysql,使用這個名空間，咱們可以很容易的在咱們的模塊中定義和引用其餘的class，好比咱們要在mysql module裏面添加一個叫作server的class，爲了作到這樣，咱們須要定義一個叫作mysql::server的類而且存儲在一個叫作 server.pp的文件中,咱們使用這個模塊只須要簡單地這樣寫：
include mysql::server
Puppet會認出它的名空間而且會在正確的模塊和文件中去加載這個類名空間的魔法功能也能夠擴展到模板和文件，爲了充分利用這個特性，咱們在root模塊下建立了兩個附加的目錄，叫作templates和files，這些目錄應該包含這個模塊下的任意templates和任意文件，這樣你的模板就可以經過指定模塊名和模板的名字被引用了
template("mysql/my.cnf.erb")
Puppet將會自動的在正確的模塊路徑下去加載須要的模板。
在你模塊包含的文件可以使用Puppet的文件服務的功能，每個模塊自動建立它本身的文件服務模塊，而且加載任意模塊文件路徑下的存儲的文件，好比在你的mysql模塊，文件能使用source屬性被使用
source => "puppet://puppetmaster/mysql/my.cnf"
這將會到mysql模塊下的文件目錄下去找my.cnf，在你的fileserver.conf中，那要定義一個特殊的文件模塊叫作modules，這個容許你去進行訪問控制，定義這個文件模塊沒用path語句，限制文件訪問在全部的模塊中。

 

最重要的一件事能夠去作，那就是把puppet 代碼組織成模塊，以更易於維護並使puppet的代碼結構更加清晰。一個模塊能夠是一個簡單的分組相關的東西：例如：web服務器模塊能夠包括一個web服務器必須要的一切：Apache的配置文件，虛擬主機模板，和必要的puppet代碼去部署這些。

分離成模塊，使得代碼更容易從新使用和共享代碼，也是最合乎邏輯的方式組織代碼。在這個例子中，咱們將建立一個模塊用來管理memcached.memcache是一個內存緩存系統與web應用程序經常使用在一塊兒。

1.明確你的模塊路徑，模塊路徑是在puppet.conf裏設置，默認值是/etc/puppet/modules.若是你的代碼已經使用的版本控制系統，像以前我建議你的方式去作，而後使用你的工做副本目錄用來部署到/etc/puppet/moudules/，並替代原目錄。

memcached實例

 

# puppet --genconfig |grep modulepath

modulepath = /etc/puppet/modules:/usr/share/puppet/modules

# cd /etc/puppet/modules

2. 建立memcached目錄：

# mkdir memcached

3. 在memcached目錄下創manifests和files兩個目錄：

# cd memcached

# mkdir manifests files

4. 在manifests目錄，建立init.pp文件，init.pp文件內容以下：

vi manifests/init.pp

import "*"

5. 在manifests目錄，建立另一個文件名稱爲memcached.pp,其內容以下：

class memcached {

package { "memcached":

ensure => installed,

}

file { "/etc/memcached.conf":

source => "puppet:///modules/memcached/memcached.conf",

}

service { "memcached":

ensure => running,

enable => true,

require => [ Package["memcached"],

File["/etc/memcached.conf"] ],

}

}

6. 切換到files目錄，建立memcached.conf文件，其內容以下：

-m 64

－p 11211

-u nobody

-l 127.0.0.1

7. 定義一個節點，並使用新的模塊(即/etc/puppet/modules/memcached)。

node cookbook {

include memcached

}

8.運行puppet 測試新的配置

# puppet agent --test

info: Retrieving plugin

info: Caching catalog for cookbook.bitfieldconsulting.com

info: Applying configuration version '1300361964'

notice: /Stage[main]/Memcached/Package[memcached]/ensure: ensure

changed 'purged' to 'present'

...

info: /Stage[main]/Memcached/File[/etc/memcached.conf]:

Filebucketed /etc/memcached.conf to puppet with sum a977521922a151

c959ac953712840803

notice: /Stage[main]/Memcached/File[/etc/memcached.conf]/content:

content changed '{md5}a977521922a151c959ac953712840803' to '{md5}f

5c0bb01a24a5b3b86926c7b067ea6ba'

notice: Finished catalog run in 20.68 seconds

# service memcached status

* memcached is running

 

puppet 會自動尋找並自動加載init.pp這個文件，這是模塊在全部導入的類的時候必須的，

在咱們的例子：

import "*"

memcache類是定義在memcached.pp這個文件裏，這將是由 init.pp加載。如今的話，咱們在結點上執行類：

include memcached

在memached類中，咱們提到了memcached.conf文件：

file { "/etc/memcached.conf":

source => "puppet:///modules/memcached/memcached.conf",

}

正如咱們在puppet的文件服務器中自定義掛載點裏所看到的片段。 上面的source參數告訴puppet所要尋找的源文件路徑。

MODULEPATH/

memcached/files/memcached.conf

 

學習着去熱愛模塊，由於他們讓你管理puppet的生活會輕鬆許多，模塊並不複雜。然而，實踐和經驗會幫助咱們判斷什麼時候應該組織劃分爲模塊，以及如何更好的安排你的模塊結構，這裏有一些幫助你正確上路的技巧。

 

 

模板

模板做爲模塊的一部分，若是你須要使用模板，能夠把模板放到MODULE_NAME/templates目錄下，用法能夠參考這樣：

file { "/etc/memcached.conf":

content => template("memcached/memcached.conf"),

}

puppet 會在下面路徑尋找文件：

MODULEPATH/memcached/templates/memcached.conf

Facts,functions(函數)，types(類型)和providers

模塊能夠包含自定義的Facts,自定義函數，和自定義類型以及providers.如需有關這些的詳細信息，請參閱外部工具和puppet的生態系統(ecosystem)

 

使用標準的命名約定

給模塊和類取個合適且簡單明瞭的名稱是很是有用的,尤爲是別人要維護你的代碼的時候,或者有其餘人須要閱讀並使用你的代碼工做的時候.

1. puppet的模塊名以他們所管理的軟件或者服務名:例如:apache或者haproxy

2. 以模塊的功能或者所提供的服務來命名類名,例如:apache::vhost或者rails::dependencies.

譯者說明 apache就是所提供的服務,vhost是功能,中間以::分格.

3.若是模塊內提供禁止提供某服務 ,就能夠命名爲disabled.例如:一個用於中止apache的類應該被命令爲

apache::disabled.

譯者說明:好比iptables服務,有時須要開啓,或者須要關閉,那麼就分紅兩個類, iptables::disabled和iptables::enable.

4. 若是一個節點須要提供多種服務,請在節點定義定義後爲每一個服務執行所須要的類,或者導入模塊.

node server014 inherits server {

include puppet::server

include mail::server

include repo::gem

include repo::apt

include zabbix

}

5.管理用戶的模塊應該命名爲user.

6.在用戶模塊裏,聲明你的虛擬用戶類名爲user::virtual

7.在用戶模塊裏,爲特定的用戶羣體能夠設置爲子類,子類應該被命名爲用戶組.舉例,

user::sysadmins或者user::contractors.

8.若是你須要覆蓋特定節點上的一個類或者服務,可使用繼承,繼承類的話前綴是子類的

名稱.舉例,若是一個節點名稱爲cartman 須要特定的ssh配置,你想覆蓋ssh類,能夠這樣作:

class cartman_ssh inherits ssh {

[ override config here ]

}

9.當你須要運行puppet爲不一樣的服務佈署配置文件時,完整的配置文件名以服務開頭,使用點爲分隔符,

後面爲文件功能.舉例:

Apache的初始化腳本:apache.init

Rails的snippet的定時處理日誌配置文件:rails.logrotate

mywizzoapp的Nginx的虛擬主機配置文件:mywizzoapp.vhost.nginx

standalone 服務的mysql配置文件:standalone.mysql

 

<十一>模板

 

puppet管理的時候，咱們會根據業務進行劃分，將其分爲如web、db、memcache等,爲了方便統一管理，這個時候，在puppet實戰中咱們就可使用模板，好比上面，有web類型，db類型的,memcache類型的，新業務上線的時候，這時候運維自動化，運用puppet就很是有意義，咱們使用pupet模板，能夠節約咱們不少時間和精力，又大大地減小犯錯的概率的。接下來就爲你們介紹，puppet管理中什麼是模板，如何使用模板，運用模板，這些都是實際生產中積累。

 

1.puppet進階之ERB基礎

       puppet管理中，puppet經過erb(embedded Ruby）支持模板，模板是爲資源設置統一的格式，puppet 模板主要是用於文本文件，且模板的文件名必須以erb結尾，例如nginx配置文件等.

①. puppet管理中如何在模板中使用變量？

答:使用這種格式<%= name %>, 變量name必須先定義.

 

②. puppet管理默認模板是路徑是？

答：默認是/var/lib/puppet/templates.

 

③. puppet管理中如何查找當前模板路徑

答：可使用以下命令：puppet –configprint templatedir

 

④. puppet實戰中puppet模板是如何存放？

答：通常都是放在模塊名下的templates目錄下。例 如模塊名nginx，那麼模板通常會放在nginx/templates下。

 

puppet 管理apache的虛擬主機模板建立實例

1. 建立模塊名，以及templates,files目錄。

 

mkdir -p /etc/puppet/modules/apache/{manifests,templates,files}

 

2. 建立/etc/puppet/modules/apache/manifests/init.pp內容爲import 「*」.

 

echo 'import "*" '> /etc/puppet/modules/apache/manifests/init.pp

 

3. 建立/etc/puppet/modules/apache/manifests/apache.pp,類名爲apache

 

class apache {

      package { "http":

                 ensure => present,

      }

      services { "http":

                  ......

                  require => Package["http"],

      }

      define apache_conf ($sitedomain) {

             file { "httpd_conf":

                     ......

                     content => template("apache/httpd.conf.erb"),

                     require => package["httpd"],

             }

      }

}

 

5. 建立/etc/puppet/modules/apache/templates/httpd.conf.erb

 

（1）複製一個標準的httpd.conf爲模板。

 

cp httpd.conf /etc/puppet/modules/apache/templates/httpd.conf.erb

 

（2）根所實際狀況修改/etc/puppet/modules/apache/templates/httpd.conf.erb

如下是貼出部分以供示例:

 

<VirtualHost *:80>

ServerName <%= sitedomain %>

ServerAdmin admin@<%= sitedomain %>

DocumentRoot /var/www/<%= sitedomain %>

ErrorLog logs/<%= sitedomain %>-error_log

CustomLog logs/<%= sitedomain %>-access_log common

</VirtualHost>

 

6. 檢查模板是否有錯誤

 

erb -x -T '-' /etc/puppet/modules/apache/templates/httpd.conf.erb | ruby -c

 

7. 測試，使用一個node ，名爲 c2.inanu.net 進行測試

 

node 'c2.inanu.net' {

      import  "apache"             #可省略，在init.pp中，已有import 「*」

      include "apache"

      apache::apache_conf { "inanu":

                             sitedomain => "inanu.net",

                          }

}

 

8. 在客戶端運行puppet –test –server puppetmaster

 

puppet --test --server c1.inanu.net

 

注意第 7 步中 apache::apache_conf，我在虛擬機裏測試的時候，須要添加的類名，但在實際生產中不須要添加，多是版本差別，另外下面幾點須要注意下：

1. puppet 模板中，也可使用數組，這時經常使用的循環遍歷。

 

示例：

 

$values = [val1, val2, otherval]

<% values.each do |val| -%>

Some stuff with <%= val %>

<% end -%>

 

2. puppet模板中也可使用條件語句

 

示例：

 

<% if broadcast != "NONE" %> broadcast <%= broadcast %> <% end %>

 

3. 模板也能夠做爲變量

 

示例：

$template = 'apache/vhost.erb'

4. 測試變量是否認義

 

示例 ：

 

<% if has_variable?("myvar") then %>

    myvar has <%= myvar %> value

<% end %>

 

5. 變量的做用域

 

<%= scope.lookupvar('apache::user') %>

 

puppet 管理使用模板總結

puppet 管理過程當中會遇到各類問題，而puppet 模板是方便，快捷，容易處理，這樣，咱們在puppet 運維自動化過程充分利用puppet 模板減小出錯的機會的，puppet模板上面介紹的比較少，在寫的過程當中可使用ERB測試別忘記，要按照puppet指南規範代碼。更多能夠參閱官方：http://docs.puppetlabs.com/guides/templating.html

 

 

 

 

<十二>節點

 

node(節點)的做用：區分不一樣的客戶端，而且給不一樣的服務端分配manifest。

 

1. 習慣：

實際生成中，不建議直接在site.pp中定義node，由於當node過多的時候，不利於閱讀和理解，建議建立一個名叫nodes.pp，專門用來存放node信息的

    vi /etc/puppet/manifests/site.pp

import "nodes.pp"

#創建節點文件

touch /etc/puppet/manifests/nodes.pp

 

 

2.節點的定義：

①默認節點的定義：表示沒有定義的節點都是使用default。default的做用能夠在多臺nodes（節點） 須要執行相同的操做的時候，省去屢次書寫node（節點名稱），帶來方便。

 

node default {

    變量的聲明              #聲明格式：$變量名="值" 引用格式： ${變量名}

    include 類名,...,類名       #已定義好的類class

}

 

②客戶端節點的定義：

 

node '客戶端的主機名' {

    變量的聲明                  #聲明格式：$變量名="值" 引用格式： ${變量名}

    include 類名,...,類名       #已定義好的類class

}

 

 

3.節點的繼承（不講，同類的繼承inherits）

 

4.實例;

node 'test01.test.com' {

           file { "/tmp/temp1.txt" :

                  content => "hello world.

                  died, java."

                 }

 }

 

<十三>使vim支持puppet的pp文件的語法

 

1.在用戶根目錄建立目錄

    mkdir -p ~/.vim/{syntax,ftdetect}

 

2.建立puppet.vim文件

    vim ~/.vim/syntax/puppet.vim

        " puppet syntax file

        " Filename: puppet.vim

        " Language: puppet configuration file

        " Copied from the cfengine, ruby, and perl syntax files

        " For version 5.x: Clear all syntax items

        " For version 6.x: Quit when a syntax file was already loaded

 

        if version < 600

        syntax clear

        elseif exists("b:current_syntax")

        finish

        endif

 

        syn region puppetDefine start="^\s*\(class\|define\|site\|node\)" end="{" contains=puppetDefType,puppetDefName,puppetDefArguments

        syn keyword puppetDefType class define site node inherits contained

        syn keyword puppetInherits inherits contained

        syn region puppetDefArguments start="(" end=")" contains=puppetArgument

        syn match puppetArgument "\w\+" contained

        syn match puppetArgument "\$\w\+" contained

        syn match puppetArgument "'[^']+'" contained

        syn match puppetArgument '"[^"]+"' contained

        syn match puppetDefName "\w\+" contained

 

        syn match puppetInstance "\w\+\s*{" contains=puppetTypeBrace,puppetTypeName,puppetTypeDefault

        syn match puppetTypeBrace "{" contained

        syn match puppetTypeName "[a-z]\w*" contained

        syn match puppetTypeDefault "[A-Z]\w*" contained

 

        syn match puppetParam "\w\+\s*=>" contains=puppetTypeRArrow,puppetParamName

        syn match puppetParamRArrow "=>" contained

        syn match puppetParamName "\w\+" contained

        syn match puppetVariable "$\w\+"

        syn match puppetVariable "${\w\+}"

        syn match puppetParen "("

        syn match puppetParen ")"

        syn match puppetBrace "{"

        syn match puppetBrace "}"

 

        syn region puppetString start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=puppetVariable

 

        syn keyword puppetBoolean true false

        syn keyword puppetKeyword import inherits include

        syn keyword puppetControl case default

 

        " comments last overriding everything else

        syn match puppetComment "\s*#.*$" contains=puppetTodo

        syn keyword puppetTodo TODO NOTE FIXME XXX contained

 

        " Define the default highlighting.

        " For version 5.7 and earlier: only when not done already

        " For version 5.8 and later: only when an item doesn't have highlighting yet

        if version >= 508 || !exists("did_puppet_syn_inits")

        if version < 508

        let did_puppet_syn_inits = 1

        command -nargs=+ HiLink hi link <args>

        else

        command -nargs=+ HiLink hi def link <args>

        endif

 

        HiLink puppetVariable Identifier

        HiLink puppetBoolean Boolean

        HiLink puppetType Identifier

        HiLink puppetDefault Identifier

        HiLink puppetKeyword Define

        HiLink puppetTypeDefs Define

        HiLink puppetComment Comment

        HiLink puppetString String

        HiLink puppetTodo Todo

        " HiLink puppetBrace Delimiter

        " HiLink puppetTypeBrace Delimiter

        " HiLink puppetParen Delimiter

        HiLink puppetDelimiter Delimiter

        HiLink puppetControl Statement

        HiLink puppetDefType Define

        HiLink puppetDefName Type

        HiLink puppetTypeName Statement

        HiLink puppetTypeDefault Type

        HiLink puppetParamName Identifier

        HiLink puppetArgument Identifier

 

        delcommand HiLink

        endif

 

        let b:current_syntax = "puppet"

 

3.建立ftdetect/puppet.vim

    vim ~/.vim/ftdetect/puppet.vim 

        au BufRead,BufNewFile *.pp setfiletype puppet

 

4.測試

            vim /etc/puppet/manifests/site.pp

 

 

5、配置、管理、使用

puppet命令

 

 

1.puppet.comf文件詳解

①[main]命名空間選項(全局配置)：

 

confdir 配置文件目錄，默認在/etc/puppet

 

vardir 動態數據目錄，默認在/var/lib/puppet

 

logdir 日誌目錄，默認在/var/log/log

 

rundir puppet PID目錄，默認在/var/run/puppet

 

statedir state目錄，默認在$vardir/state

 

statefile state文件，默認在$statedir/state.yaml

 

ssldir SSL證書目錄，默認在$vardir/ssl

 

trace 發生錯誤時顯示跟蹤信息，默認false

 

filetimeout 檢測配置文件狀態改變的時間週期，單位秒，默認15秒

 

syslogfacility 指定syslog功能爲user級，默認爲daemon級

 

②[puppetmasterd]命名空間選項(服務器的配置):

 

user 後臺進程執行的用戶

 

group 後臺進程執行的組

 

mainfestdir mainfests文件存儲目錄，默認爲$confdir/mainfests

 

mainfest mainfest站點文件的名字，默認爲site.pp

 

bindaddress 後臺進程綁定的網卡地址接口

 

masterport 後臺進程執行的端口，默認爲8140

 

③[puppet]命名空間選項(客戶端的配置):

 

server puppet puppet服務器名，默認爲puppet

 

runinterval seconds puppet應用配置的時間間隔，默認1800秒（0.5小時）

 

puppetdlockfie file puppet lock文件位置，默認$statedir/puppetdlock

 

puppetport port 後臺進程執行的端口，默認8139

 

2.文件服務配置文件（fileserver.conf）的詳解：

 

[files]

 

path /var/lib/puppet/files

 

allow 121.14.1.*

 

allow 60.28.228.0/24

 

allow *.house.sina.com.cn

 

deny *.sina.com.cn

 

path定義文件存放路徑，經過allow/deny來控制訪問權限。

 

3. puppet命令集(建議使用puppet 類型 參數)

 

①puppet 用於執行用戶所寫獨立的mainfests文件

 

語法：

puppet [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose][--detailed-exitcodes] [-l|--logdest ]

 

用法：

# puppet -l /tmp/manifest.log manifest.pp

 

 

 

②puppetd 運行在被管理主機上的客戶端程序

 

語法：

puppetd [-D|--daemonize|--no-daemonize] [-d|--debug] [--disable] [--enable][-h|--help] [--fqdn ] [-l|--logdest syslog||console][-o|--onetime] [--serve ] [-t|--test] [--noop][-V|--version] [-v|--verbose] [-w|--waitforcert ]

 

用法：

# puppetd –server puppet.domain.com

 

 

 

③puppetmasterd 運行在管理機上的服務器程序

 

語法：

puppetmasterd [-D|--daemonize|--no-daemonize] [-d|--debug] [-h|--help][-l|--logdest |console|syslog] [--nobucket] [--nonodes] [-v|--verbose] [-V|--version]

 

用法：

# puppetmasterd

 

 

 

④puppetca puppet認證程序

 

語法：

puppetca [-a|--all] [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose] [-g|--generate] [-l|--list] [-s|--sign] [-r|--revoke] [-p|--print] [-c|--clean] [--verify] [host]

 

用法：

# puppetca –l

# puppetca -s culain.madstop.com

#puppetca -a -s                     #爲全部的客戶端進行認證

 

 

 

⑤puppetrun 用於鏈接客戶端，強制運行在本地配置文件下

語法：

puppetrun [-a|--all] [-c|--class ] [-d|--debug] [-f|--foreground] [-h|--help] [--host ] [--no-fqdn] [--ignoreschedules] [-t|--tag ] [--test] [-p|--ping]

 

用法：

# puppetrun -p 10 –host host1 –host host2 -t remotefile -t webserver

 

 

⑥filebucket 客戶端用於發送文件到puppet file bucket的工具

語法：

filebucket [-h|--help] [-V|--version] [-d|--debug] [-v|--verbose] [-l|--local] [-r|--remote] [-s|--server ] [-b|--bucket ] …

 

用法：

# filebucket -b /tmp/filebucket /my/file

 

⑦ralsh 轉換配置信息到puppet配置代碼

語法：

ralsh [-h|--help] [-d|--debug] [-v|--verbose] [-e|--edit] [-H|--host ] [-p|--param] [-t|--types] type

 

用法：

# ralsh user luke

user {

 

　　‘luke’:

　　home => ‘/home/luke’,

　　uid => ‘100′,

　　ensure => ‘present’,

　　comment => ‘Luke Kanies,,,’,

　　gid => ‘1000′,

　　shell => ‘/bin/bash’,

　　groups => ['sysadmin','audio','video','puppet']

}

 

 

 

⑧puppetdoc 打印puppet參考文檔

語法：

puppetdoc [-a|--all] [-h|--help] [-o|--outputdir ] [-m|--mode ] [-r|--reference <[type]|configuration|..>] [manifest-file]

 

用法：

# puppetdoc -r type > /tmp/type_reference.rst

# puppetdoc –outputdir /tmp/rdoc –mode rdoc /path/to/manifests

# puppetdoc /etc/puppet/manifests/site.pp

 

 

附：個人puppetmaster的配置文件

 

[main]

    vardir  = /var/puppet

    logdir = /var/log/puppet

    rundir = /var/run/puppet

    ssldir = $vardir/ssl

    confdir = /etc/puppet

[puppetd]

  

    classfile = $vardir/classes.txt

    # Where puppetd caches the local configuration.  An

    # extension indicating the cache format is added automatically.

    # The default value is '$confdir/localconfig'.

    localconfig = $vardir/localconfig

[puppetmasterd]

    environment = production

    reports = store,log,mydefine

    logdir = /var/log/puppet

    modulepath = /etc/puppet/modules:/usr/share/puppet/modules

    config = /etc/puppet/puppet.conf

    manifestdir = /etc/puppet/manifests

    manifest = /etc/puppet/manifests/site.pp

    fileserverconfig = /etc/puppet/fileserver.conf

    templatedir = /etc/puppet/templates

    reportdir = /var/lib/puppet/reports

    autosign=true           #自動認證客戶端

    clientyamldir = /var/lib/puppet/client_yaml

 

客戶端的配置文件

 

  [main]

    vardir = /var/lib/puppet

    logdir = /var/log/puppet

    rundir = /var/run/puppet

    ssldir = $vardir/ssl

[puppetd]

    server = pu.server.com

    authconfig = /etc/puppet/namespaceauth.conf

    classfile = $vardir/classes.txt

    localconfig = $vardir/localconfig

    puppetdlog = /var/log/puppet/puppetd.log

    runinterval = 600

    report = true                 #這個默認是false若是不填寫就沒有報表了!

    reportserver = pu.server.com

 

 

經常使用命令：

 

1.#puppetmasterd --genconfig > /etc/puppet/puppet.conf.default

 

2.#puppetmasterd -d -v --no-daemonize

 

3.#puppetd -v -d --no-daemonize