Apabila bilangan pelayan yang anda uruskan kurang daripada sepuluh, jarang sekali sesiapa memikirkan pengurusan berpusat mereka, ini mungkin tidak diperlukan. Apabila terdapat berpuluh-puluh pelayan, perisian terpusat dan pengurusan konfigurasi amat berguna. Apabila terdapat ratusan dan ribuan pelayan, ini adalah penting. Terdapat banyak program seperti ini, contohnya: Chef, CFEngine, ... Yang terakhir yang akan dibincangkan dalam siaran ini.

Boneka dianggap sebagai salah satu penyelesaian terbaik jenis ini. Ia digunakan oleh syarikat seperti Google, Citrix dan Red Hat. Ini dengan sendirinya aplikasi pelanggan-pelayan ditulis dalam bahasa pengaturcaraan Ruby, yang diedarkan dalam dua versi:

• Boneka Sumber terbuka- versi percuma sepenuhnya
• Puppet Enterprise - percuma untuk sehingga 10 pelayan, maka lesen diperlukan

Mari pertimbangkan untuk memasang pelayan dan ejen Sumber Terbuka Boneka, yang disertakan dalam pakej kebanyakan pengedaran moden. Seterusnya kita akan bercakap tentang Ubuntu 12.04 Precise Trenggiling.

Bahagian belakang Boneka dipanggil ketua boneka, mari mulakan pemasangan dari sana:

:~# apt-get install puppetmaster

Dan kini pelanggan:

:~# apt-get install puppet

Dalam fail konfigurasi klien /etc/puppet/puppet.conf anda perlu bercakap tentang pelayan dengan menambah bahagian berikut:

Server=puppet.local report=true pluginsync=false

Pada peringkat awal, adalah lebih baik untuk mematikan pluginsync.

Mari jalankan klien boneka supaya ia membuat permintaan untuk sijil:

:~# puppetd --verbose --test info: Mencipta kunci SSL baharu untuk linux.local info: Caching sijil untuk ca info: Mencipta permintaan sijil SSL baharu untuk linux.local info: Permintaan Sijil cap jari (md5): E5: EA:AC:5B:22:9A:BA:42:B8:A1:63:9E:1F:1F:23:51 Keluar; tiada sijil ditemui dan waitforcert dilumpuhkan

Pada pelayan, anda perlu menyemak sama ada permintaan sijil telah diterima dan, jika ya, keluarkan sijil:

:~# puppetca --list "linux.local" (E5:EA:AC:5B:22:9A:BA:42:B8:A1:63:9E:1F:1F:23:51) :~# puppetca - -tandatangani notis linux.local: Permintaan sijil yang ditandatangani untuk notis linux.local: Mengalih keluar fail Puppet::SSL::CertificateRequest linux.local di "/var/lib/puppet/ssl/ca/requests/linux.local.pem"

Ulangi langkah sebelumnya pada klien:

:~# puppetd --verbose --test info: Caching sijil untuk linux.local info: Mendapatkan semula maklumat pemalam: Caching certificate_revocation_list untuk ca info: Caching katalog untuk linux.local info: Menggunakan versi konfigurasi "1356278451" maklumat: Mencipta fail keadaan / var/lib/puppet/state/state.yaml notis: Katalog selesai dijalankan dalam 0.02 saat

Hebat, semuanya berfungsi. Mari kita beralih kepada mewujudkan manifesto pertama. Manifes, atau konfigurasi, diterangkan dalam bahasa perisytiharan khas. Kami akan segera membiasakan diri dengan perkara yang baik, menggunakan struktur modular dan kelas. Sebagai contoh, mari tulis modul yang akan memastikan fail dikemas kini /etc/hosts pada semua pelayan kami.

Mari kita semak di mana boneka mencari modul:

:~# boneka digunakan --configprint modulepath /etc/puppet/modules:/usr/share/puppet/modules

Buat direktori untuk modul anda

:~# cd /etc/puppet/modules :~# mkdir hos; hos cd; mkdir nyata; cd manifes

Manifes pertama, juga dikenali sebagai fail modul utama, harus dipanggil init.pp

Hos kelas ( # tuan rumah puppet.local ( "puppet.local": pastikan => "hadir", sasaran => "/etc/hosts", ip => "192.168.0.1", host_aliases => "puppet", ) # hos linux.local ( "linux.local": pastikan => "hadir", sasaran => "/etc/hosts", ip => "192.168.0.2", host_aliases => "linux", ) )

Secara lalai, boneka mencari fail /etc/puppet/manifests/site.pp untuk memuatkan konfigurasi, mari bawa ke borang berikut:

Lalai nod (termasuk hos )

Kami menyemak manifes pada pelayan:

:~# boneka digunakan --verbose /etc/puppet/manifests/site.pp info: Menggunakan versi konfigurasi "1356281036" notis: /Stage//Host/ensure: membuat maklumat: FileBucket menambah (md5)notis: /Stage// Hos/pastikan: mencipta notis: Katalog selesai dijalankan dalam 0.03 saat

Pada klien:

:~# ll /etc/hosts rw-r--r-- 1 root root 290 Dis 16 19:10 /etc/hosts :~# puppetd --verbose --test info: Caching catalog for linux.local info: Memohon versi konfigurasi maklumat "1356283380": FileBucket menambah (md5)notis: /Stage/Hosts/Host/ensure: membuat notis: /Stage/Hosts/Host/ensure: mencipta notis: Katalog siap dijalankan dalam 0.04 saat :~# ll /etc /hosts -rw-r--r-- 1 root root 551 Dis 23 20:43 /etc/hosts

Selepas kami yakin bahawa semuanya berfungsi, kami membenarkan perkhidmatan bermula, masuk /etc/default/puppet ubah:

# Mulakan boneka semasa but? MULA=ya

Memulakan perkhidmatan

:~# perkhidmatan boneka bermula

Puppet akan meninjau pelayan puppetmaster setiap 30 minit untuk perubahan konfigurasi dan, jika perlu, melaraskan sistem dengan sewajarnya.

Untuk lebih penggunaan yang berkesan Boneka perlu memahami cara modul dan manifes dibina. Tutorial ini akan membimbing anda melalui cara komponen Boneka ini berfungsi dengan menyediakan tindanan LAMP pada pelayan Ubuntu 14.04.

Keperluan

• Memasang Boneka (tuan dan ejen). Lebih lanjut mengenai ini -.
• Kemungkinan untuk mencipta sekurang-kurangnya satu pelayan maya Ubuntu 14.04 untuk melayan nod ejen Puppet.

Asas Kod Boneka

Sumber

Kod boneka terutamanya terdiri daripada sumber. Sumber ialah sekeping kod yang menerangkan keadaan sistem dan menentukan perubahan yang diperlukannya. Sebagai contoh:

pengguna("mitchell":
pastikan => hadir,
uid => "1000",
gid => "1000",
shell => "/bin/bash",
home => "/home/mitchell"
}

Pengisytiharan sumber mempunyai format berikut:

jenis_sumber("nama_sumber"
atribut => nilai
...
}

Untuk melihat semua jenis sumber Boneka, keluarkan arahan:

sumber boneka --jenis

Anda akan mengetahui lebih lanjut tentang jenis sumber dalam panduan ini.

Manifesto

Manifes ialah skrip orkestrasi. Program boneka dengan sambungan .pp dipanggil manifes. Manifes Boneka lalai ialah /etc/puppet/manifests/site.pp.

Kelas

Seperti dalam mana-mana bahasa pengaturcaraan biasa, kelas bertanggungjawab untuk mengatur dan menggunakan semula bahagian orkestrasi.

Dalam definisi kelas ialah blok kod yang menerangkan cara kelas berfungsi. Setelah anda menentukan kelas, anda boleh menggunakannya dalam manifes.

Definisi kelas mempunyai format berikut:

kelas contoh_kelas(
...
kod
...
}

Kod ini mentakrifkan kelas example_class. Kod Puppet akan diletakkan dalam kurungan kerinting.

Pengisytiharan kelas ialah tempat dalam kod di mana kelas tertentu dipanggil. Dengan pengisytiharan kelas, Puppet memproses kodnya.

Pengisytiharan kelas boleh menjadi biasa dan mengikut jenis sumber.

Pengisytiharan kelas biasa ditambahkan pada kod menggunakan kata kunci include.

sertakan kelas_contoh

Apabila diisytiharkan sebagai jenis sumber, kelas diisytiharkan dalam format sumber:

class("example_class" :)

Pengisytiharan ini membolehkan anda menambah parameter kelas pada kod anda yang mengatasi nilai lalai atribut kelas. Sebagai contoh:

nod "host2" (
class ("apache": ) # gunakan modul apache
apache::vhost ( "example.com": # tentukan sumber vhost
port => "80",
docroot => "/var/www/html"
}
}

Modul

Modul ialah sekumpulan manifes dan fail lain yang disusun dalam cara yang telah ditetapkan untuk memudahkan perkongsian dan penggunaan semula bahagian individu orkestrasi. Modul membantu menyusun kod Boneka kerana ia boleh digunakan untuk memisahkan kod kepada berbilang manifes.

Modul boneka disimpan dalam direktori /etc/puppet/modules.

Menulis manifesto

Anda boleh berlatih menulis manifes, modul dan kelas Boneka menggunakan contoh memasang tindanan LAMP pada pelayan Ubuntu (hasilnya ialah ).

Jadi untuk melakukan orkestrasi pelayan Ubuntu 14.04 dan pasang tindanan LAMP padanya, anda memerlukan sumber untuk tindakan berikut:

• memasang pakej apache2.
• memulakan perkhidmatan apache2.
• memasang pakej pelayan MySQL, mysql-server.
• memulakan perkhidmatan mysql.
• memasang pakej php5
• mencipta skrip ujian PHP, info.php.
• mengemas kini indeks apt sebelum memasang setiap pakej.

Di bawah anda akan menemui tiga contoh kod Boneka yang boleh digunakan untuk mencapai persediaan tindanan LAMP sedemikian.

Contoh pertama akan mengajar anda cara menulis manifes asas dalam satu fail. Contoh kedua akan membantu anda memasang dan menggunakan kelas dan modul berdasarkan manifes yang ditulis sebelum ini. Contoh ketiga akan menunjukkan kepada anda cara menggunakan modul awam pra-bina untuk memasang tindanan LAMP.

Catatan: Untuk ujian adalah lebih baik menggunakan pelayan maya yang baru.

Contoh 1: Memasang LAMP dengan satu manifes

Manifes Puppet boleh ditulis pada nod ejen dan kemudian dilaksanakan menggunakan arahan penggunaan boneka (anda tidak perlu mempunyai persediaan induk dan ejen untuk melakukan ini).

Dalam bahagian ini, anda akan belajar menulis manifes yang akan menggunakan jenis pengisytiharan sumber ini:

• exec: Laksanakan arahan.
• pakej: pasang pakej.
• perkhidmatan: pengurusan perkhidmatan.
• fail: pengurusan fail.

Mencipta manifes

Buat manifes baharu:

sudo vi /etc/puppet/manifests/lamp.pp

Tambahkan kod berikut padanya untuk mengisytiharkan sumber yang diperlukan.

# jalankan arahan "apt-get update".
exec("apt-update": # exec sumber "apt-update"
command => "/usr/bin/apt-get update" # arahan yang sumber ini akan dijalankan
}
# pasang pakej apache2
pakej("apache2":
memerlukan => Exec["apt-update"], # minta "apt-update" sebelum memasang pakej
pastikan => dipasang,
}
# mulakan perkhidmatan apache2
perkhidmatan ("apache2":
memastikan => berjalan,
}
# pasang mysql-server
pakej("mysql-server":
memerlukan => Exec["apt-update"], # minta "apt-update" dengan memasang semula
pastikan => dipasang,
}
# mulakan perkhidmatan mysql
perkhidmatan("mysql":
memastikan => berjalan,
}
# pasang pakej php5
pakej("php5":
memerlukan => Exec["apt-update"], # minta "apt-update" sebelum pemasangan
pastikan => dipasang,
}
# mulakan perkhidmatan info.php
fail("/var/www/html/info.php":
pastikan => fail,
kandungan => "", # kod phpinfo
memerlukan => Pakej["apache2"], # permintaan untuk pakej "apache2"
}

Memohon manifes

Untuk menggunakan manifes baharu, masukkan arahan:

sudo puppet apply --test

Ia akan memaparkan hasil yang besar yang memaparkan semua perubahan dalam keadaan persekitaran. Jika tiada ralat dalam output, anda sepatutnya boleh membuka alamat IP luaran anda atau Nama domain dalam pelayar. Halaman ujian PHP dengan maklumat tindanan akan muncul pada skrin. Ini bermakna Apache dan PHP berfungsi.

Kini tindanan LAMP dipasang pada pelayan menggunakan Puppet.

Ini adalah manifes yang agak mudah kerana ia boleh dilaksanakan pada ejen. Jika anda tidak mempunyai Puppet master, nod ejen lain tidak akan dapat menggunakan manifes ini.

Pelayan induk Boneka menyemak keadaan pelayan berubah setiap 30 minit.

Contoh 2: Memasang tindanan LAMP menggunakan modul

Sekarang cuba buat modul ringkas berdasarkan manifes LAMP yang anda tulis di bahagian sebelumnya.

Untuk membuat modul, buat dalam direktori modul katalog baru(namanya mesti sepadan dengan nama modul). Direktori ini harus mengandungi direktori manifes dan fail init.pp. Fail init.pp menentukan kelas Boneka (namanya juga mesti sepadan dengan nama modul).

Mencipta Modul

Pergi ke pelayan induk Boneka dan buat struktur direktori untuk modul:

cd /etc/puppet/modules
sudo mkdir -p lampu/manifes

Buat dan buka fail init.pp dalam editor:

sudo vi lamp/manifests/init.pp

Masukkan kelas lampu ke dalam fail:

lampu kelas (
}

Salin kandungan manifes daripada bahagian 1 dan tampalkannya ke dalam blok kelas lampu. Anda kini mempunyai definisi kelas lampu. Manifes lain akan dapat menggunakan kelas ini sebagai modul.

Simpan dan tutup fail.

Menggunakan modul dalam manifes utama

Kini anda boleh mengkonfigurasi manifes utama dan menggunakan modul lampu untuk memasang tindanan LAMP pada pelayan.

Pada pelayan induk Boneka, edit fail berikut:

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

Kemungkinan besar pada masa ini fail itu kosong. Tambahkan baris berikut padanya:

lalai nod ( )
nod "lampu-1" (
}

Catatan: Gantikan lampu-1 dengan nama hos ejen Boneka anda untuk memasang tindanan.

Blok nod membolehkan anda menentukan kod Puppet yang hanya akan digunakan pada beberapa nod.

Blok lalai digunakan untuk semua nod ejen yang tidak mempunyai blok individu (biarkan kosong). Blok lampu-1 akan digunakan pada nod agen lampu-1.

Tambahkan pada blok ini baris seterusnya, yang menggunakan modul lampu:

Simpan dan tutup fail.

Kini nod ejen Boneka akan dapat memuat turun tetapan daripada pelayan induk dan memasang tindanan LAMP. Jika anda ingin membuat perubahan sekarang, jalankan arahan pada ejen:

sudo puppet agent --test

Modul adalah cara yang paling mudah guna semula Kod boneka. Selain itu, modul membantu anda menyusun kod anda secara logik.

Contoh 3: Memasang LAMP menggunakan modul awam

Modul MySQL digunakan dengan cara yang sama. Tambahkan baris berikut pada blok nod:

class("mysql::server":
root_password => "kata laluan",
}

Anda juga boleh lulus parameter modul MySQL.

Tambahkan sumber yang akan menyalin info.php ke lokasi yang dikehendaki. Gunakan parameter sumber. Tambahkan baris berikut pada blok nod:

fail("info.php": # nama fail sumber
laluan => "/var/www/html/info.php", # laluan sasaran
pastikan => fail,
memerlukan => Kelas["apache"], # kelas apache untuk digunakan
sumber => "puppet:///modules/apache/info.php", # lokasi untuk menyalin fail ke
}

Pengisytiharan kelas ini menggunakan parameter sumber dan bukannya kandungan. Pilihan ini bukan sahaja menggunakan kandungan fail, tetapi juga menyalinnya.

Puppet akan menyalin fail puppet:///modules/apache/info.php ke /etc/puppet/modules/apache/files/info.php.

Simpan dan tutup fail.

Buat fail info.php.

sudo sh -c "gema""> /etc/puppet/modules/apache/files/info.php"

Kini nod ejen Boneka akan dapat memuat turun tetapan daripada pelayan induk dan memasang tindanan LAMP. Jika anda ingin membuat perubahan pada persekitaran ejen sekarang, jalankan arahan pada nod ini:

sudo puppet agent --test

Perintah ini akan memuat turun semua kemas kini untuk nod semasa dan memasang tindanan padanya. Untuk memastikan Apache dan PHP berfungsi, buka alamat IP atau domain nod dalam penyemak imbas:

http://lamp_1_public_IP/info.php

Kesimpulan

Anda kini mempunyai pengetahuan asas tentang bekerja dengan modul dan manifes Boneka. Cuba buat sendiri manifes dan modul mudah.

Boneka bagus untuk mengurus fail konfigurasi aplikasi.

Tag: ,
Dihantar oleh Luke Kanies
Tarikh diterbitkan: 2 Mei 2012
Terjemahan: A. Panin
Tarikh terjemahan: 27 Ogos 2013

18.1. pengenalan

Puppet ialah alat pengurusan infrastruktur IT yang dibangunkan menggunakan bahasa pengaturcaraan Ruby dan digunakan untuk mengautomasikan penyelenggaraan pusat data dan pengurusan pelayan untuk Google, Twitter, Bursa Saham New York dan banyak organisasi lain. Pembangunan projek ini disokong terutamanya oleh organisasi Puppet Labs, yang meletakkan asas untuk pembangunannya. Boneka boleh mengurus mana-mana dari 2 hingga 50,000 pelayan dan diselenggara oleh satu pasukan atau ratusan pentadbir sistem.

Boneka ialah alat yang direka untuk menyediakan dan menyelenggara komputer anda; Dengan menggunakan bahasa konfigurasinya yang mudah, anda boleh memberitahu Puppet cara anda mahu mesin anda dikonfigurasikan, dan ia akan mengkonfigurasi semulanya mengikut keperluan untuk memenuhi spesifikasi anda. Semasa anda menukar spesifikasi ini dari semasa ke semasa disebabkan oleh keadaan seperti kemas kini pakej, menambah pengguna baharu atau kemas kini konfigurasi, Puppet akan mengemas kini konfigurasi mesin anda secara automatik agar sepadan dengan spesifikasi. Sekiranya ia telah dikonfigurasikan dengan betul, Puppet tidak akan melakukan apa-apa kerja.

Secara umum, Puppet melakukan segala-galanya tindakan yang mungkin bertujuan untuk menggunakan fungsi sistem sedia ada untuk melaksanakan kerja mereka; iaitu, pada pengedaran berdasarkan teknologi RedHat, ia akan menggunakan utiliti yum untuk mengurus pakej dan init.d untuk mengurus perkhidmatan, manakala pada OS X ia akan menggunakan utiliti dmg untuk mengurus pakej dan melancarkan untuk mengurus perkhidmatan . Salah satu matlamat asas Projek Boneka adalah untuk menghasilkan karya yang berguna, sama ada menggunakan kod Projek Boneka atau sistem itu sendiri, jadi piawaian sistem berikut adalah kritikal.

Projek Boneka dibina berdasarkan pengalaman dengan banyak alatan lain. Dalam dunia aplikasi sumber terbuka, pengaruh terbesar ke atas pembangunannya ialah projek CFEngine, yang merupakan alat konfigurasi pertama tujuan am sumber terbuka, serta projek ISconf, yang menggunakan utiliti make untuk melakukan semua kerja, yang seterusnya menyebabkan Perhatian istimewa kepada kebergantungan yang diterangkan secara eksplisit dalam sistem. Dalam dunia komersial perisian Boneka boleh dilihat sebagai pesaing kepada projek BladeLogic dan Opsware (yang kemudiannya diperoleh oleh syarikat yang lebih besar), yang masing-masing berjaya dijual apabila Boneka diperkenalkan, tetapi setiap alat ini dijual kepada ketua syarikat besar, bukannya sedang dibangunkan selaras dengan keperluan segera untuk alat pentadbir sistem kualiti. Tujuan projek Boneka adalah untuk menyelesaikan masalah yang serupa dengan yang diselesaikan oleh alat ini, sementara ia bertujuan untuk pengguna yang berbeza.

Sebagai contoh mudah tentang cara menggunakan Puppet, berikut ialah coretan kod untuk memastikan perkhidmatan Secure Shell (SSH) dipasang dan dikonfigurasikan dengan betul: class ssh ( package ( ssh: ensure => installation ) fail ( "/etc/ssh /sshd_config ": source => "puppet:///modules/ssh/sshd_config", pastikan => hadir, memerlukan => Pakej ) perkhidmatan ( sshd: pastikan => berjalan, memerlukan => , Pakej] ) )

Kod ini membolehkan anda memastikan bahawa pakej akan dipasang, fail akan diletakkan di lokasi yang diperlukan, dan perkhidmatan akan dimulakan. Perlu diingatkan bahawa kami telah menerangkan kebergantungan antara sumber, jadi kami akan sentiasa melaksanakan sebarang kerja dalam urutan yang betul. Kelas ini boleh dikaitkan dengan mana-mana nod untuk menggunakan konfigurasi yang diberikan dalam nod itu. Ambil perhatian bahawa blok binaan konfigurasi Boneka ialah objek berstruktur, dalam dalam kes ini objek ini adalah pakej , fail dan perkhidmatan . Dalam terminologi Boneka, kami memanggil objek ini sebagai sumber ( sumber) dan mana-mana spesifikasi konfigurasi Boneka terdiri daripada sumber ini dan kebergantungan di antaranya.

Pemasangan Boneka biasa akan mengandungi puluhan atau bahkan ratusan keping kod ini, yang kami panggil kelas ( kelas); Kami menyimpan kelas ini pada cakera dalam fail yang dipanggil manifes, dan kami juga mengumpulkan kelas yang berkaitan secara logik bersama-sama dalam kumpulan yang dipanggil modul ( modul). Sebagai contoh, anda mungkin mempunyai modul ssh dengan kelas ssh ini dan mana-mana kelas lain yang berkaitan secara logik, bersama-sama dengan modul mysql, apache dan sudo.

Kebanyakan interaksi dengan Boneka dilakukan menggunakan cangkerang atau sentiasa menjalankan perkhidmatan HTTP, tetapi terdapat juga antara muka grafik untuk melaksanakan tugas seperti memproses laporan. Puppet Labs juga menyediakan produk perisian Boneka komersial yang menggunakan GUI web.

Prototaip Boneka pertama telah dibangunkan pada musim panas 2004, dan pembangunan penuh projek itu bermula pada Februari 2005. Ia pada asalnya direka dan dibangunkan oleh Luke Kanies, pentadbir sistem dengan pengalaman luas membangunkan alatan kecil tetapi tiada pengalaman membangunkan projek yang mengandungi lebih daripada 10,000 baris kod. Pada asasnya, Luke Kanies mempelajari kemahiran pengaturcaraan semasa pembangunan projek Boneka, yang mempengaruhi seni bina projek secara positif dan negatif.

Boneka telah dibangunkan pada mulanya dan terutamanya sebagai alat untuk pentadbir sistem untuk menjadikan kehidupan mereka lebih mudah, membolehkan mereka menyelesaikan kerja dengan lebih cepat, lebih cekap dan dengan ralat yang lebih sedikit. Inovasi utama pertama untuk melaksanakan prinsip ini ialah sumber yang diterangkan di atas, iaitu boneka primitif; ia boleh dipindahkan antara sistem pengendalian sambil mewakili butiran pelaksanaan secara abstrak, membolehkan pengguna memikirkan hasil kerja dan bukannya cara mencapainya. Set primitif ini telah dilaksanakan pada Lapisan Abstraksi Sumber Boneka.

Sumber boneka mestilah unik untuk nod tertentu. Anda hanya boleh mempunyai satu pakej bernama "ssh", satu perkhidmatan bernama "sshd" dan satu fail bernama "/etc/ssh/sshd_config". Had ini menghalang konflik bersama antara bahagian konfigurasi anda yang berbeza dan anda menyedari konflik ini pada awal proses konfigurasi. Kami merujuk kepada sumber ini mengikut jenis dan nama mereka, iaitu, Pakej dan Perkhidmatan. Anda boleh mempunyai pakej dan perkhidmatan dengan nama yang sama kerana ia adalah jenis yang berbeza, tetapi bukan dua pakej atau perkhidmatan dengan nama yang sama.

Inovasi utama kedua dalam Puppet ialah keupayaan untuk menentukan secara langsung kebergantungan antara sumber. Alat yang digunakan sebelum ini bertujuan untuk melaksanakan tugas individu tanpa mengambil kira hubungan antara tugas ini; Boneka ialah alat pertama yang menyatakan secara eksplisit bahawa kebergantungan adalah bahagian asas konfigurasi anda, yang seterusnya harus dimodelkan dengan sewajarnya. Ia mencipta graf sumber dan kebergantungannya sebagai salah satu jenis data utama, dan hampir semua tindakan Boneka bergantung pada graf ini (dipanggil Katalog), bucu dan tepinya.

Komponen penting terakhir Puppet ialah bahasa konfigurasi. Bahasa ini adalah deklaratif dan lebih bertujuan untuk menerangkan konfigurasi daripada untuk pengaturcaraan sepenuhnya - ia hampir mengulang sepenuhnya format konfigurasi Nagios, tetapi juga dicipta di bawah pengaruh ketara daripada bahasa dari CFEngine dan Ruby.

Komponen fungsian boneka adalah berdasarkan dua prinsip panduan: ia harus semudah mungkin untuk digunakan, mengutamakan kebolehgunaan berbanding ciri; dan ia juga harus dibangunkan dalam bentuk rangka kerja pertama dan aplikasi kedua, oleh itu, jika dikehendaki, pembangun pihak ketiga akan berpeluang untuk mencipta aplikasi mereka berdasarkan komponen perisian Boneka. Ia adalah jelas bahawa sebagai tambahan kepada rangka kerja, yang boleh digunakan secara meluas aplikasi berkualiti, tetapi pembangun masih tertumpu terutamanya pada rangka kerja, bukan aplikasi. Ramai orang masih percaya bahawa Puppet ialah aplikasi itu sendiri, dan bukan rangka kerja ia dilaksanakan.

Selepas membina prototaip Boneka pertamanya, Luke menjadi pembangun Perl yang umumnya baik dengan beberapa pengalaman skrip shell dan beberapa pengalaman C, kebanyakannya diperoleh daripada bekerja dengan sistem CFEngine. Di samping itu, beliau mempunyai pengalaman membina sistem penghuraian untuk bahasa mudah, setelah membangunkan dua sistem sedemikian untuk dijalankan dalam alatan kecil, dan membangunkan semula sistem penghuraian CFEngine dari awal untuk memudahkan penyelenggaraan (kod ini tidak dipindahkan ke projek disebabkan oleh ketidakserasian kecil).

Keputusan untuk menggunakan bahasa dinamik untuk melaksanakan Boneka dibuat dengan cepat disebabkan oleh produktiviti dan pengedaran pembangun yang jauh lebih tinggi jenis ini bahasa, tetapi pilihan itu sendiri ternyata agak sukar. Prototaip awal dalam Perl telah ditolak, jadi percubaan telah dijalankan untuk mencari bahasa lain. Percubaan telah dibuat untuk digunakan bahasa sawa, tetapi Luke menganggap bahasa ini sangat bertentangan dengan pandangannya tentang dunia. Selepas mendengar rakan bercakap tentang faedah bahasa baharu itu, Luke cuba menggunakan Ruby dan mencipta prototaip yang berfungsi dalam masa empat jam. Apabila pembangunan Boneka berskala penuh bermula, bahasa Ruby hampir tidak diketahui, jadi keputusan untuk menggunakannya adalah risiko yang besar, tetapi dalam kes ini, produktiviti pembangun sekali lagi memainkan peranan penting dalam pilihan bahasa. Ciri pembezaan utama bahasa Ruby, sekurang-kurangnya dari Perl, ialah kemudahan mewujudkan hubungan kelas bukan hierarki, manakala bahasa itu tidak bercanggah dengan pemikiran pemaju Luke, yang sangat kritikal.

Bayangkan diri anda dalam peranan itu pentadbir sistem, bertanggungjawab untuk mengekalkan kefungsian ratusan mesin yang menjalankan sistem pengendalian seperti UNIX. Setiap satu memerlukan konfigurasi dan pengemaskinian dan pemantauan berkala, tetapi ramai yang dijangka melaksanakan fungsi yang serupa. Dua pertiga adalah stesen kerja, beberapa lagi adalah penghala, selebihnya adalah beberapa pelayan web dan storan data. Soalan: bagaimana untuk menguruskan semua perniagaan ini?

Jawapan paling mudah adalah dengan hanya menyambung kepada setiap daripada mereka menggunakan SSH dan membuat perubahan yang diperlukan. Walau bagaimanapun, kaedah ini mempunyai dua masalah. Pertama, ia sangat intensif buruh. Kedua, pentadbir sentiasa perlu melakukan banyak tindakan membosankan (contohnya, untuk mengemas kini OpenOffice.org pada semua stesen kerja, anda perlu menjalankan arahan yang sama beberapa dozen kali). Anda boleh cuba mengelakkan masalah ini dengan menulis beberapa skrip yang akan menyambung ke setiap mesin sendiri dan melaksanakan arahan pratulis. Tetapi di sini juga, masalah menanti kita. Skrip perlu sentiasa diubah suai agar sesuai dengan setiap tugas, skrip perlu mengambil kira perbezaan dalam sistem pengendalian dan versi, dan ia perlu dinyahpepijat untuk masa yang lama sebelum digunakan pada mesin yang sedang berjalan. Secara umum, bukan camilleaux.

Jawapan yang betul ialah menggunakan sistem yang dipanggil alat kawalan jauh konfigurasi, wakil yang paling terkenal ialah sistem terbuka Cfengine dan Boneka. Sistem sedemikian mengambil semua tanggungjawab untuk membawa konfigurasi mesin ke bentuk yang diingini, memerlukan pentadbir hanya untuk menerangkan keadaan akhir sistem dalam bahasa khas (contohnya, penerangan tentang pakej yang harus dipasang dalam OS, yang baris hendaklah ditambahkan pada fail konfigurasi, arahan yang mesti dilaksanakan, dsb.). Selepas ini, semua nod sendiri akan menerima maklumat tentang keadaan yang diperlukan daripada pelayan dan mengkonfigurasi sistem secara automatik. Terima kasih kepada mekanisme ini, mesin baharu boleh dikonfigurasikan sepenuhnya tanpa campur tangan manusia, dan yang sedia ada boleh dikonfigurasikan semula dengan menambah hanya beberapa baris pada perihalan keadaan.

Boneka?

Puppet telah dibangunkan oleh Luke Kanies, yang bosan dengan batasan Cfengine dan memutuskan untuk mencipta versi yang lebih baik dari awal. Jika anda telah menggunakan Cfenfine, anda mungkin akan mendapati Puppet sistem yang lebih mudah dan berkuasa. Bahasa negeri Puppet adalah lebih tinggi dan fleksibel, jadi pentadbir tidak perlu risau tentang perkara seperti menulis peraturan berasingan untuk setiap jenis OS atau Penerangan terperinci melakukan tindakan remeh temeh. Boneka membolehkan anda memberi tumpuan kepada apa Apa dia mahu lakukan, bukannya bagaimana untuk melakukannya (contohnya, untuk memasang pakej tertentu pada mana-mana sistem pengendalian yang disokong oleh sistem, cukup untuk menulis beberapa baris secara literal mengatakan "Pasang program ini", dan bukannya menerangkan arahan yang diperlukan untuk memasangnya). Boneka ditulis dalam dalam bahasa mudah Ruby, berkat yang agak mudah untuk menyesuaikannya dengan tugas tertentu dan mengembangkan fungsinya (dengan syarat sistem yang fleksibel pemalam). Selain itu, tidak seperti model pembangunan Cfengine, yang pada asasnya berkisar pada satu orang, Puppet telah berkembang sekitar komuniti yang hebat peminat yang membuat penambahbaikan pada kod, berkongsi contoh konfigurasi dan menulis dokumentasi.

Secara keseluruhan, Puppet tampil sebagai sistem yang lebih moden dan direka dengan baik. Seperti Cfengine, ia menyokong hampir semua sistem pengendalian seperti UNIX moden (termasuk MacOS X), dan juga boleh dijalankan dalam persekitaran Cygwin di atas Windows. Senarai pergantungannya hanya termasuk penterjemah Ruby dan alat Faktor, jadi tidak sepatutnya ada masalah dengan pemasangan (untuk bersikap adil, senarai pergantungan Cfengine adalah lebih pendek).

Pelayan fail

Banyak tugas pentadbiran jauh tidak boleh diselesaikan tanpa menyalin fail tambahan ke mesin. Ini boleh menjadi konfigurasi yang telah disediakan sebelumnya, halaman web untuk Apache, pakej yang tiada dalam repositori rasmi dan banyak lagi. Untuk memudahkan proses pemindahan fail ini ke nod jauh, Puppet menyertakan pelayan fail.

Tetapan pelayan fail disimpan dalam fail /etc/puppet/fileserver.conf. Untuk memaksa Puppet menyampaikan kandungan direktori khusus kepada pelanggan, anda perlu meletakkan beberapa baris di dalamnya:

Laluan = /var/puppet/files benarkan *.server.com

Kedua-dua baris ini menunjukkan bahawa direktori /var/puppet/files harus boleh diakses oleh semua hos dalam domain server.com. Kami juga boleh menentukan nama domain penuh mesin yang dibenarkan atau alamat IPnya, dan juga memotong yang tidak diingini menggunakan arahan penafian. Mana-mana fail dalam direktori itu kemudiannya boleh dialihkan kepada klien menggunakan sumber fail. Sebagai contoh:

Fail ("/etc/httpd/conf/httpd.conf": sumber => "puppet://httpd/httpd.conf", mod => 644, )

Fail httpd.conf yang terletak pada pelayan dalam direktori /var/puppet/files/httpd akan disalin ke mesin sasaran di sepanjang laluan yang dinyatakan dalam nama sumber.

kesimpulan

Dalam artikel ini kita telah melihat sangat sebahagian kecil Ciri-ciri boneka. Sebenarnya, ini adalah sistem yang sangat kompleks, yang hanya boleh diterangkan sepenuhnya pada halaman buku. Pada masa yang sama, Puppet sangat mudah untuk dikonfigurasikan dan diselenggara, terutamanya kerana anda boleh menemui banyak contoh konfigurasinya di Internet.

Tidak lama dahulu, di halaman majalah, kami melihat sistem pengurusan konfigurasi jauh Cfengine untuk mesin UNIX, yang sangat memudahkan kehidupan pentadbir sistem dengan mengautomasikan langkah untuk mengkonfigurasi banyak nod rangkaian. Tetapi, tidak kira betapa mudahnya Cfengine, ia mempunyai banyak kelemahan yang tidak dimiliki oleh sistem yang dipanggil Puppet.

Bayangkan diri anda berperanan sebagai pentadbir sistem, bertanggungjawab untuk mengekalkan kefungsian ratusan mesin yang menjalankan sistem pengendalian jenis UNIX. Setiap daripada mereka memerlukan konfigurasi, pengemaskinian dan pemantauan berkala, dan diandaikan bahawa kebanyakannya menjalankan fungsi yang serupa.

Dua pertiga ialah stesen kerja, beberapa lagi adalah penghala, dan selebihnya ialah beberapa pelayan web dan storan data. Soalan: bagaimana untuk menguruskan semua perniagaan ini? Jawapan paling mudah adalah dengan hanya menyambung kepada setiap daripada mereka menggunakan SSH dan membuat perubahan yang diperlukan. Walau bagaimanapun, kaedah ini mempunyai dua masalah. Pertama, ia sangat intensif buruh. Kedua, pentadbir sentiasa perlu melakukan banyak tindakan membosankan (contohnya, untuk mengemas kini OpenOffice.org pada semua stesen kerja, anda perlu melaksanakan arahan yang sama beberapa dozen kali). Anda boleh cuba mengelakkan masalah ini dengan menulis beberapa skrip yang akan menyambung ke setiap mesin sendiri dan melaksanakan arahan pratulis. Tetapi di sini juga, masalah menanti anda.

Skrip sentiasa perlu diubah suai untuk menyesuaikannya dengan setiap tugasan; Skrip perlu mengambil kira perbezaan dalam sistem pengendalian dan versi, dan ia perlu dinyahpepijat untuk masa yang lama sebelum digunakan untuk menjalankan mesin. Secara umum, bukan comme il faut. Jawapan yang betul ialah menggunakan sistem pengurusan konfigurasi jauh yang dipanggil, wakil yang paling terkenal ialah sistem sumber terbuka Cfengine dan Puppet. Sistem sedemikian mengambil semua tanggungjawab untuk membawa konfigurasi mesin ke bentuk yang diingini, memerlukan pentadbir hanya untuk menerangkan keadaan akhir sistem dalam bahasa khas (contohnya, penerangan tentang pakej yang harus dipasang dalam OS, yang baris hendaklah ditambahkan pada fail konfigurasi, arahan yang mesti dilaksanakan, dsb.). Selepas ini, semua nod sendiri akan menerima maklumat tentang keadaan yang diperlukan daripada pelayan dan mengkonfigurasi sistem secara automatik. Terima kasih kepada mekanisme ini, mesin baharu boleh dikonfigurasikan sepenuhnya tanpa campur tangan manusia, dan yang sedia ada boleh dikonfigurasikan semula dengan menambah hanya beberapa baris pada perihalan keadaan.

Boneka?

Kami telah menumpukan keseluruhan artikel kepada sistem Cfengine, jadi hari ini kami akan memberi tumpuan kepada sistem Boneka, yang boleh dipanggil pengganti ideologinya. Puppet telah dibangunkan oleh Luke Kanies, yang bosan dengan batasan Cfengine dan memutuskan untuk mencipta versi yang lebih baik dari awal. Jika anda telah menggunakan Cfenfine, anda mungkin akan mendapati Puppet sistem yang lebih mudah dan berkuasa. Bahasa negeri Puppet adalah lebih tinggi dan fleksibel, jadi pentadbir tidak perlu risau tentang perkara seperti menulis peraturan berasingan untuk setiap jenis OS atau memperincikan cara melakukan tindakan remeh. Boneka membenarkan tuannya menumpukan perhatian pada perkara yang dia mahu lakukan, bukannya cara melakukannya (contohnya, untuk memasang pakej tertentu pada mana-mana OS yang disokong sistem, anda hanya perlu menulis beberapa baris secara literal berkata "Pasang program ini " daripada menerangkan arahan, yang diperlukan untuk pemasangannya). Boneka ditulis dengan mudah bahasa delima, menjadikannya mudah untuk menyesuaikannya dengan tugas tertentu dan mengembangkan fungsinya (sistem pemalam yang fleksibel disediakan).

Selain itu, tidak seperti model pembangunan Cfengine, yang pada asasnya berkisar pada satu orang, Puppet mempunyai komuniti peminat yang besar yang membuat penambahbaikan pada kod, berkongsi contoh konfigurasi dan menulis dokumentasi.

Secara keseluruhan, Puppet tampil sebagai sistem yang lebih moden dan direka dengan baik. Seperti Cfengine, ia menyokong hampir semua sistem pengendalian seperti UNIX moden (termasuk MacOS X), dan juga boleh dijalankan dalam persekitaran Cygwin di atas Windows. Senarai pergantungannya hanya termasuk penterjemah Ruby dan alat Faktor, jadi tidak sepatutnya ada masalah dengan pemasangan (untuk bersikap adil, senarai pergantungan Cfengine adalah lebih pendek).

Pemasangan

Seperti Cfengne, Puppet ialah sistem pelayan pelanggan yang terdiri daripada pelayan kawalan dan nod hamba. Pelayan menyimpan perihalan keadaan akhir nod (yang dalam istilah Boneka dipanggil manifes) dan menunggu mereka menyambung. Setiap setengah jam (secara lalai), pelanggan menyambung ke pelayan, menerima daripadanya penerangan tentang keadaan akhir, membandingkannya dengan keadaan semasa dan, jika ia dan/atau keadaan yang diterangkan telah berubah, mengkonfigurasi semula sistem, dan kemudian pergi tidur. Komunikasi dijalankan melalui saluran yang disulitkan, jadi serangan berdasarkan penggantian perihalan keadaan dikecualikan (tetapi jika penyerang mengambil alih pelayan, maka semua nod akan berada di bawah kawalannya).

Boneka disertakan dalam repositori semua pengedaran popular, jadi pemasangannya tidak sepatutnya sukar. Sebagai contoh, pada Debian/Ubuntu pelanggan Boneka boleh dipasang seperti ini:

$ sudo apt-get install puppet

Dan pelayan adalah seperti ini:

$ sudo apt-get install puppet puppetmaster

Fail konfigurasi klien dan pelayan disimpan dalam direktori /etc/puppet. Yang paling penting ialah fail /etc/puppet/manifests/site.pp, yang mengandungi manifes.

Ia menyimpan perihalan keadaan dan sepatutnya hanya wujud pada pelayan. Untuk memudahkan penyahpepijatan, mari tambahkan konfigurasi mudah padanya:

passwd kelas(
fail("/etc/passwd":
pemilik => akar,
kumpulan => akar,
mod => 644,
}
}
lalai nod(
sertakan passwd
}

Baris ini menerangkan keadaan di mana pemilik fail /etc/passwd mestilah root dan kebenarannya ditetapkan kepada 644. Kami akan melihat dengan lebih dekat format fail manifes dalam bahagian seterusnya. Fail kedua terpenting ialah /etc/puppet/puppet.conf. Ia menetapkan konfigurasi pelayan dan pelanggan, jadi ia mesti ada pada semua mesin yang dianjurkan dalam rangkaian Boneka. Dalam Ubuntu, fail ini mengandungi tetapan minimum yang diperlukan dan dalam kebanyakan kes tetapan mencukupi. Di bawah mereka diberikan dengan ulasan:

# vi /etc/puppet/puppet.conf
# Laluan direktori standard
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
# Lokasi alat faktor,
# digunakan untuk mendapatkan maklumat tentang OS
factpath=$vardir/lib/facter
# Segerakkan pemalam
# (pemalam yang dipasang pada pelayan - ia disalin kepada pelanggan)
pluginsync=benar
# Katalog dengan templat (baca tentangnya di bawah)
templatedir=$confdir/templates
# Penyegerakan dengan etckeeper
# (siapa tahu, akan faham, orang lain tidak memerlukannya)
prerun_command=/etc/puppet/etckeeper-commitpre
postrun_command=/etc/puppet/etckeeper-commitpost

Fail konfigurasi mungkin termasuk sejumlah besar pelbagai pilihan, maklumat tentang yang boleh diperolehi dengan menjana konfigurasi lalai:

$ sudo puppetmasterd -genconfig > /etc/puppet/
puppetd.conf.default

Konfigurasi klien lalai dijana menggunakan arahan lain:

$ sudo puppet -genconfig > /etc/puppet/puppetd.conf.default

Fail fileserver.conf dan auth.conf digunakan untuk mengkonfigurasi pelayan fail (baca tentang perkara ini dalam bahagian "Pelayan Fail") dan pengesahan. Tidak ada gunanya menyentuh mereka lagi. Setelah konfigurasi selesai, pelayan Boneka mesti dimulakan semula:

$ sudo /etc/init.d/puppetmaster restart

Selepas itu dia akan bersedia untuk menerima permintaan pelanggan. Walau bagaimanapun, tanpa sijil yang ditandatangani, tiada pelanggan akan dapat menerima manifes daripada pelayan dan mengkonfigurasi mesin.

Oleh itu, kita mesti menjalankan klien Boneka dalam mod ujian supaya mereka boleh menyerahkan sijil mereka kepada pelayan untuk ditandatangani (secara langsung, ini boleh dilakukan pada semua mesin pada masa yang sama menggunakan alat shmux):

$ sudo puppetd -server puppet-server.com -verbose -test

Kami kembali ke pelayan dan menerima senarai sijil yang sedia untuk ditandatangani:

$ sudo puppetca --list

Pilih hos daripada senarai dan tandatangani sijilnya:

$ sudo puppetca --sign nomad.grinder.com

Atau kami menandatangani semuanya sekaligus:

$ sudo puppetca --sign --semua

Kini anda boleh melancarkan pelanggan dalam mod pertempuran. Tetapi pertama-tama anda perlu memasukkan nama pelayan Boneka dalam fail konfigurasi (secara lalai namanya hanyalah boneka):

$sudo su
# echo "" >> /etc/puppet/puppet.conf
# echo "server=puppet-server.com" >> /etc/puppet/puppet.conf
# keluar

Pelancaran pelanggan:

$ sudo /etc/init.d/puppet start

Nyatakan bahasa huraian

Seperti yang dinyatakan di atas, Puppet menggunakan bahasanya sendiri untuk menggambarkan keadaan akhir sistem operasi, dengan bantuan pentadbir sistem menunjukkan bentuk komponen OS yang harus dibawa untuk mencapai keadaan yang dikehendaki. Ini adalah bahasa yang agak kompleks, yang, bagaimanapun, jauh lebih mudah daripada mana-mana bahasa pengaturcaraan. Jika anda sekurang-kurangnya biasa dengan bahasa skrip bash, anda akan memahami bahasa Boneka dengan mudah. Elemen utama bahasa ialah sumber yang digunakan untuk menerangkan bentuk salah satu komponen OS yang harus ditukar. Sebagai contoh, sumber mudah berikut menerangkan keadaan yang dikehendaki bagi fail /etc/passwd:

# vi /etc/puppet/manifests/site.pp
fail("/etc/passwd":
pemilik => "akar"
}

Di sini fail ialah jenis sumber. Terdapat beberapa dozen daripada mereka secara keseluruhan, daripada sumber yang menguruskan fail, seperti dalam contoh ini, kepada pakej dan perkhidmatan. Baris /etc/passwd ialah nama sumber.

Dalam kes jenis fail, nama adalah sama dengan laluan ke fail, tetapi dalam beberapa jenis lain nama itu boleh sewenang-wenangnya. Pemilik baris => "root" menerangkan menetapkan atribut pemilik kepada akar, iaitu, ia mengatakan bahawa pemilik fail yang ditentukan mesti ada pentadbir.

Setiap jenis sumber mempunyai set atribut tersendiri yang tersedia untuk pengubahsuaian, serta terdapat atribut meta khas yang boleh digunakan dalam mana-mana sumber. Salah satu kualiti penting sumber ialah keupayaan untuk menghubungkannya. Ini boleh digunakan untuk membentuk rantai pergantungan. Entri seterusnya mencipta sumber /etc/group yang bergantung pada sumber /etc/passwd (kebergantungan ditentukan menggunakan atribut meta memerlukan):

# vi /etc/puppet/manifests/site.pp
fail("/etc/group":
memerlukan => Fail["/etc/passwd"],
pemilik => "akar",
}

Ini bermakna sumber /etc/group boleh dikonfigurasikan (dibawa ke borang yang diterangkan) hanya apabila sumber /etc/passwd dikonfigurasikan. Sumber boleh dikumpulkan ke dalam koleksi sumber yang dipanggil kelas. Ini adalah perlu untuk menggabungkan sumber yang serupa dari segi makna dan jenis tugasan yang dilakukan ke dalam satu sumber abstrak. Sebagai contoh, untuk kemudahan kami boleh menggabungkan pemasangan dan pelancaran pelayan web nginx menjadi satu sumber abstrak dengan nama yang sama:

# vi /etc/puppet/manifests/site.pp
kelas nginx(
pakej("nginx":
pastikan => dipasang
}
perkhidmatan("nginx":
memastikan => berjalan,
memerlukan => Pakej["nginx"],
}
}

Di sini, jenis sumber pakej digunakan untuk memasang pakej nginx pada sistem, dan perkhidmatan digunakan untuk melancarkan perkhidmatan dengan nama yang sama. Dengan memerlukan kami memaksa sistem untuk memulakan perkhidmatan hanya jika pakej telah berjaya dipasang. Kemudahan kelas ialah ia juga boleh disertakan bergantung pada:

# vi /etc/puppet/manifests/site.pp
perkhidmatan("sotong":
memastikan => berjalan,
memerlukan => Kelas["nginx"],
}

Seperti dalam bahasa OOP sebenar, kelas boleh mewarisi antara satu sama lain dan mengatasi atribut:

# vi /etc/puppet/manifests/site.pp
passwd kelas(
fail("/etc/passwd":
pemilik => "akar",
kumpulan => "akar",
}
}
kelas passwd-bsd mewarisi passwd (
Fail["/etc/passwd"] ( kumpulan => "roda")
}

Di sini kelas passwd-bsd diwarisi daripada passwd untuk mengatasi atribut kumpulan sumber /etc/passwd (pada sistem BSD /etc/passwd milik kumpulan roda, jadi kami mencipta kelas berasingan untuk sistem sedemikian). Nanti kita tengok yang lebih betul dan cara yang jelas memilih nilai atribut alternatif menggunakan syarat.

Pembolehubah ialah salah satu komponen penting dalam mana-mana bahasa pengaturcaraan, dan Puppet juga mempunyainya. Pembolehubah bermula dengan tanda $ dan boleh mengandungi sebarang nombor, rentetan atau nilai boolean (benar, palsu):

$want_apache = benar
$apache_version = "2.2.14"

Salah satu sifat yang paling berkuasa Bahasa boneka Berkaitan dengan pembolehubah ialah penyepaduan dengan alat maklumat mesin faktor. Utiliti ini mengembalikan semua maklumat khusus mesin dalam bentuk pasangan nilai kunci, yang ditukar menjadi pembolehubah dengan nama yang sama dalam Puppet. Bersama dengan arahan bersyarat dalam bahasa Boneka ia boleh digunakan untuk mengubah atribut sumber bergantung pada sifat mesin.

Sebagai contoh, kelas passwd yang diterangkan di atas boleh ditulis semula dengan mudah pemilihan automatik atribut bergantung pada jenis OS (dalam kes ini, kelas itu sendiri tidak lagi diperlukan):

# vi /etc/puppet/manifests/site.pp
fail("/etc/passwd":
pemilik => "akar",
kumpulan => $kernel ? (
Linux => "root",
FreeBSD => "roda",
},
}

Bergantung pada OS yang mana serpihan manifes ini akan dianalisis, nilai atribut kumpulan akan sama ada akar atau roda. Selain operator bersyarat, bahasa Puppet juga menyokong operator pemilihan kes, yang boleh digunakan untuk mencipta sumber tertentu bergantung pada nilai pembolehubah:

# vi /etc/puppet/manifests/site.pp
kes $sistem pengendalian (
redhat: (perkhidmatan("httpd": pastikan => berjalan))
debian: (perkhidmatan("apache": pastikan => berjalan))
lalai: ( perkhidmatan ( "apache2": pastikan =>
berlari))
}

Kod ini mentakrifkan pelbagai pilihan sumber jenis perkhidmatan bergantung pada sistem pengendalian (nama perkhidmatan dalam pengedaran Linux yang berbeza mungkin berbeza, jadi perkhidmatan Boneka yang harus dijalankan mesti dinyatakan secara individu untuk setiap daripada mereka).

Pilihan lalai digunakan jika nilai pembolehubah tidak sepadan dengan mana-mana pilihan sebelumnya. Sebagai tambahan kepada fail jenis sumber, pakej dan perkhidmatan yang dibincangkan sebelum ini, Puppet menyokong sejumlah besar orang lain, termasuk yang dibuat. pemaju pihak ketiga jenis sumber. Penerangan terperinci mereka, termasuk contoh, atribut dan ciri yang disokong, boleh didapati dalam dokumentasi rasmi- http://docs.puppetlabs.com/references/stable/type.html. Di bawah ialah senarai dan penerangan ringkas tentang yang paling banyak digunakan:

Jenis sumber Boneka yang popular

• cron - mengurus pekerjaan cron
• exec - jalankan skrip dan arahan
• pengurusan fail - fail
• baldi fail - sandaran fail
• pengurusan kumpulan - kumpulan
• hos - uruskan entri dalam fail /etc/hosts
• antara muka - konfigurasi antara muka rangkaian
• mount - sistem fail pemasangan
• maklumkan - hantar mesej ke fail log Boneka
• pakej - pengurusan pakej
• perkhidmatan - pengurusan perkhidmatan
• sshkey - mengurus kekunci SSH
• kemas - memadam fail bergantung pada keadaan
• pengguna - pengurusan pengguna
• zon - pengurusan zon Solaris

Elemen kedua terpenting dalam bahasa Boneka selepas sumber ialah nod. Dengan bantuan mereka, pentadbir boleh menerangkan kepada mesin mana sumber dan kelas tertentu harus digunakan. Dalam erti kata lain, ia adalah satu cara untuk menentukan konfigurasi individu untuk setiap mesin yang mengambil bahagian dalam rangkaian Boneka. Contoh paling mudah nod diberikan pada permulaan artikel dalam bahagian "Pemasangan":

# vi /etc/puppet/manifests/site.pp
lalai nod(
sertakan passwd
}

Ini ialah takrifan nod lalai, yang merangkumi sumber/kelas passwd. Nama lalai bermaksud "semua nod lain", jadi sumber/kelas passwd yang ditakrifkan di suatu tempat di atas akan dikonfigurasikan pada setiap nod. Kata kunci include digunakan di sini untuk kemudahan; sebenarnya, semua kelas dan sumber boleh diterangkan secara langsung dalam perihalan nod, tetapi ini tidak disyorkan. Selain lalai, anda boleh menentukan dalam nama nod nama rangkaian mesin (maka semua sumber yang diterangkan dalam nod akan dikonfigurasikan hanya pada mesin ini), atau nama sewenang-wenangnya (kemudian nod ini boleh diwarisi oleh nod lain). Untuk memahami cara ini semua berfungsi bersama-sama dengan kelas dan sumber, mari lihat contoh manifes Boneka siap pakai yang digunakan untuk mengkonfigurasi dua mesin rangkaian(pelayan web dan pelayan NTP):

# vi /etc/puppet/manifests/site.pp
# Memasang dan menjalankan pelayan SSH
kelas sshd(
pakej ( openssh-server: pastikan => dipasang )
perkhidmatan (sshd:
nama => $sistem pengendalian ? (
fedora => "sshd",
debian => "ssh",
lalai => "sshd",
},
dayakan => benar,
memastikan => berjalan,
}
}
# Pasang dan jalankan Apache
kelas httpd(
pakej ( httpd: pastikan => dipasang )
perkhidmatan (httpd:
dayakan => benar,
memastikan => berjalan,
}
}
# Memasang dan memulakan pelayan NTP
kelas ntpd(
pakej ( ntp-server: pastikan => dipasang )
perkhidmatan (
ntp-server:
dayakan => benar,
memastikan => berjalan,
}
}
# Nod asas, digunakan hanya sebagai induk kepada semua yang lain
asas nod(
termasuk sshd
}
# Nod di mana pelayan web akan ditempatkan
node web.server.com mewarisi asas (
sertakan httpd
}
# Nod pelayan NTP
nod ntp.server.com mewarisi asas (
masukkan ntpd
}

Konfigurasi yang kelihatan mudah ini melakukan banyak perkara: ia memasang dan memulakan Apache pada mesin dengan alamat web.server.com dan untuk memasang dan menjalankan pelayan NTP pada mesin ntp.server.com. Selain itu, kedua-dua mesin memasang pelayan SSH. Konfigurasi ini tidak mungkin sesuai dengan walaupun seorang pentadbir; ia perlu diperbaiki dengan serius untuk mengajar cara mengkonfigurasi pelayan dengan betul, menerima konfigurasi baharu dan fail lain daripada pelayan Boneka utama.

Namun, ia jelas menunjukkan kuasa Boneka. Menggunakan konfigurasi mudah, kami membuat mesin memasang dan menjalankan sendiri perisian yang diperlukan dan mengekalkannya dalam keadaan berfungsi (jika pelayan ranap, Puppet sendiri akan mengkonfigurasi semula untuk membawa sistem ke keadaan yang diperlukan).

Pelayan fail

Banyak tugas pentadbiran jauh tidak dapat diselesaikan tanpa menyalin fail tambahan ke mesin. Ini boleh menjadi konfigurasi yang telah disediakan sebelumnya, halaman web untuk Apache, pakej yang tiada dalam repositori rasmi dan banyak lagi. Untuk memudahkan proses pemindahan fail ini ke hos jauh, Puppet menyertakan pelayan fail.

Tetapan pelayan fail disimpan dalam fail /etc/puppet/fileserver.conf. Untuk memaksa Puppet menyampaikan kandungan direktori khusus kepada pelanggan, anda perlu meletakkan beberapa baris di dalamnya:

# vi /etc/puppet/fileserver.conf
laluan = /var/puppet/files
benarkan *.server.com

Kedua-dua baris ini menunjukkan bahawa direktori /var/puppet/files harus boleh diakses oleh semua hos dalam domain server.com. Di samping itu, kami boleh menentukan nama domain penuh mesin yang dibenarkan atau alamat IPnya, dan juga memotong yang tidak diingini menggunakan arahan penafian. Mana-mana fail dalam direktori itu kemudiannya boleh dialihkan kepada klien menggunakan sumber fail. Sebagai contoh:

# vi /etc/puppet/manifests/site.pp
fail("/etc/httpd/conf/httpd.conf":
sumber => "puppet://httpd/httpd.conf",
mod => 644,
}

Fail httpd.conf, yang terletak pada pelayan dalam direktori /var/puppet/files/httpd, akan disalin ke mesin sasaran di sepanjang laluan yang dinyatakan dalam nama sumber.

kesimpulan

Dalam artikel ini, kami telah membincangkan sebahagian kecil daripada keupayaan Boneka. Sebenarnya, ini adalah sistem yang kompleks, yang hanya boleh diterangkan sepenuhnya pada halaman buku. Pada masa yang sama, Puppet sangat mudah untuk dikonfigurasikan dan diselenggara, terutamanya kerana anda boleh menemui banyak contoh konfigurasinya di Web.

info

• Boneka menggunakan protokol HTTP, jadi ia boleh dijalankan di bawah pelayan web untuk meningkatkan prestasi.
• Boneka boleh digunakan untuk mengkonfigurasi automatik dan menyelenggara mesin tempatan tunggal.
• Dengan menggabungkan Puppet, pemasangan OS rangkaian (pxe-install) dan imej pemasangan binaan sendiri, anda boleh mencipta rangkaian mesin konfigurasi sendiri sepenuhnya yang boleh digunakan dengan hanya satu arahan.
• Ramai orang menggunakan Puppet dalam kerja mereka. syarikat besar, seperti Google, Fedora Project, Stanford University, Red Hat, Siemens IT Solution dan SugarCRM.

Pautan

• http://docs.puppetlabs.com - Dokumentasi Boneka
• http://docs.puppetlabs.com/guides/language_tutorial.html - Penerangan penuh Bahasa boneka
• http://docs.puppetlabs.com/references/stable/type.html - Jenis sumber