Chcete-li používat Puppet efektivněji, musíte pochopit, jak jsou moduly a manifesty sestavovány. Tento tutoriál vás provede tím, jak tyto komponenty Puppet fungují, nastavením zásobníku LAMP na serveru Ubuntu 14.04.
Požadavky
- Instalace Puppet (master a agent). Více o tomto -.
- Možnost vytvořit alespoň jeden virtuální server Ubuntu 14.04 pro obsluhu uzlu Puppet agent.
Základy loutkového kódu
Zdroje
Loutkový kód se skládá hlavně ze zdrojů. Zdroj je část kódu, která popisuje stav systému a určuje změny, které potřebuje. Například:
user("mitchell":
zajistit => přítomen,
uid => "1000",
gid => "1000",
shell => "/bin/bash",
domov => "/home/mitchell"
}
Deklarace zdroje má následující formát:
resource_type("název_zdroje"
atribut => hodnota
...
}
Chcete-li zobrazit všechny typy prostředků loutky, zadejte příkaz:
loutkový zdroj --typy
Více o typech zdrojů se dozvíte v této příručce.
Manifesty
Manifest je orchestrační skript. Loutkové programy s příponou .pp se nazývají manifesty. Výchozí manifest Puppet je /etc/puppet/manifests/site.pp.
Třídy
Stejně jako v každém běžném programovacím jazyce jsou třídy zodpovědné za organizaci a opětovné použití částí orchestrace.
V rámci definice třídy je blok kódu, který popisuje, jak třída funguje. Jakmile definujete třídu, můžete ji použít v manifestech.
Definice třídy má následující formát:
třída example_class(
...
kód
...
}
Tento kód definuje třídu example_class. Kód loutky bude ve složených závorkách.
Deklarace třídy je místo v kódu, kde je volána konkrétní třída. S deklarací třídy zpracovává Puppet svůj kód.
Deklarace třídy může být běžná a podle typu zdroje.
Do kódu je přidána běžná deklarace třídy pomocí klíčového slova include.
zahrnout example_class
Když je deklarována jako typ zdroje, je třída deklarována ve formátu zdroje:
class("example_class" :)
Tato deklarace vám umožňuje přidat do kódu parametry třídy, které přepíší výchozí hodnoty atributů třídy. Například:
uzel "host2" (
class ("apache": ) # použijte modul apache
apache::vhost ( "example.com": # definovat zdroj vhost
port => "80",
docroot => "/var/www/html"
}
}
Moduly
Modul je skupina manifestů a dalších souborů organizovaných předdefinovaným způsobem, který usnadňuje sdílení a opětovné použití jednotlivých částí orchestrace. Moduly pomáhají organizovat kód Puppet, protože je lze použít k oddělení kódu do více manifestů.
Moduly loutek jsou uloženy v adresáři /etc/puppet/modules.
Psaní manifestu
Můžete si procvičit psaní loutkových manifestů, modulů a tříd na příkladu instalace zásobníku LAMP na server Ubuntu (výsledek bude ).
Chcete-li tedy zorganizovat server Ubuntu 14.04 a nainstalovat na něj zásobník LAMP, potřebujete prostředky pro následující akce:
- instalace balíčku apache2.
- spuštění služby apache2.
- instalace balíčku serveru MySQL, mysql-server.
- spuštění služby mysql.
- instalace balíčku php5
- vytvoření testovacího skriptu PHP, info.php.
- aktualizujte index apt před instalací každého balíčku.
Níže naleznete tři příklady loutkového kódu, které lze použít k dosažení takového nastavení zásobníku LAMP.
První příklad vás naučí, jak psát základní manifesty do jednoho souboru. Druhý příklad vám pomůže sestavit a používat třídu a modul na základě dříve napsaných manifestů. Třetí příklad vám ukáže, jak použít předpřipravené veřejné moduly k instalaci zásobníku LAMP.
Poznámka: Pro testování je lepší použít nový virtuální server.
Příklad 1: Instalace LAMP s jedním manifestem
Manifest Puppet lze zapsat na uzel agenta a poté jej spustit pomocí příkazu aplikace puppet (nepotřebujete k tomu mít nastavení hlavního a agenta).
V této části se naučíte psát manifesty, které budou používat tyto typy deklarací zdrojů:
- exec: Provádění příkazů.
- balíček: instalace balíčků.
- služba: správa služeb.
- soubor: správa souborů.
Vytvoření manifestu
Vytvořte nový manifest:
sudo vi /etc/puppet/manifests/lamp.pp
Přidejte do něj následující kód, abyste deklarovali požadované prostředky.
# spusťte příkaz "apt-get update".
exec("apt-update": # zdroj exec "apt-update"
příkaz => "/usr/bin/apt-get update" # příkaz, který tento prostředek spustí
}
# nainstalujte balíček apache2
balíček("apache2":
vyžadovat => Exec["apt-update"], # před instalací balíčku požadovat "apt-update"
zajistit => nainstalováno,
}
# spusťte službu apache2
service("apache2":
zajistit => běh,
}
# nainstalovat mysql-server
package("mysql-server":
vyžadovat => Exec["apt-update"], # vyžadovat "apt-update" přeinstalací
zajistit => nainstalováno,
}
# spusťte službu mysql
service("mysql":
zajistit => běh,
}
# nainstalovat balíček php5
balíček("php5":
vyžadovat => Exec["apt-update"], # před instalací požadovat "apt-update".
zajistit => nainstalováno,
}
# spusťte službu info.php
soubor("/var/www/html/info.php":
zajistit => soubor,
obsah => "“, # phpinfo kód
vyžadovat => Balíček["apache2"], # požadavek na balíček "apache2"
}
Použití manifestu
Chcete-li použít nový manifest, zadejte příkaz:
sudo loutka aplikovat --test
Zobrazí objemný výsledek, který zobrazí všechny změny stavu prostředí. Pokud ve výstupu nejsou žádné chyby, měli byste být schopni otevřít svou externí IP adresu nebo název domény ve vašem prohlížeči. Na obrazovce se objeví testovací test. stránka PHP s informacemi o zásobníku. To znamená, že Apache a PHP fungují.
Nyní je zásobník LAMP nainstalován na server pomocí Puppet.
Toto je poměrně jednoduchý manifest, protože jej lze spustit na agentovi. Pokud nemáte mistr loutek, ostatní uzly agentů nebudou moci tento manifest používat.
Hlavní server loutek kontroluje změny stavu serveru každých 30 minut.
Příklad 2: Instalace sady LAMP pomocí modulu
Nyní zkuste vytvořit jednoduchý modul založený na manifestu LAMP, který jste napsali v předchozí části.
Chcete-li vytvořit modul, vytvořte nový adresář v adresáři modules (jeho název se musí shodovat s názvem modulu). Tento adresář by měl obsahovat adresář manifests a soubor init.pp. Soubor init.pp specifikuje třídu Puppet (její jméno se také musí shodovat s názvem modulu).
Vytvoření modulu
Přejděte na server Puppet master a vytvořte adresářovou strukturu pro modul:
cd /etc/puppet/modules
sudo mkdir -p lampa/manifesty
Vytvořte a otevřete soubor init.pp v editoru:
sudo vi lampa/manifesty/init.pp
Vložte třídu lampy do souboru:
třída lampa (
}
Zkopírujte obsah manifestu ze sekce 1 a vložte jej do bloku třídy lamp. Nyní máte definici třídy lampy. Jiné manifesty budou moci používat tuto třídu jako modul.
Uložte a zavřete soubor.
Použití modulu v hlavním manifestu
Nyní můžete nakonfigurovat hlavní manifest a použít modul lampy k instalaci zásobníku LAMP na server.
Na serveru Puppet master upravte následující soubor:
sudo vi /etc/puppet/manifests/site.pp
S největší pravděpodobností na tento moment soubor je prázdný. Přidejte k němu následující řádky:
výchozí uzel ( )
uzel "lamp-1" (
}
Poznámka: Nahraďte lampu-1 názvem hostitele vašeho agenta Puppet, na který chcete sadu nainstalovat.
Blok uzlů umožňuje zadat kód loutky, který se bude vztahovat pouze na některé uzly.
Výchozí blok se vztahuje na všechny uzly agentů, které nemají samostatný blok (nechte jej prázdný). Blok lampy 1 bude aplikován na uzel agenta lampy 1.
Přidejte do tohoto bloku, který používá modul lampy, následující řádek:
Uložte a zavřete soubor.
Nyní bude uzel Puppet agent schopen stáhnout nastavení z hlavního serveru a nainstalovat zásobník LAMP. Pokud chcete provést změny hned teď, spusťte příkaz na agentovi:
sudo loutkový agent --test
Moduly jsou nejpohodlnějším způsobem opětovného použití kódu Puppet. Kromě toho vám moduly pomáhají logicky organizovat váš kód.
Příklad 3: Instalace LAMP pomocí veřejných modulů
Podobným způsobem se používá modul MySQL. Přidejte do bloku uzlů následující řádky:
class("mysql::server":
root_password => "heslo",
}
Můžete také předat parametry modulu MySQL.
Přidejte zdroj, do kterého se zkopíruje info.php Správné místo. Použijte parametr source. Přidejte do bloku uzlů následující řádky:
file("info.php": # název_souboru prostředku
cesta => "/var/www/html/info.php", # cílová cesta
zajistit => soubor,
vyžadovat => Třída["apache"], # třída apache k použití
source => "puppet:///modules/apache/info.php", # umístění, kam se má soubor zkopírovat
}
Tato deklarace třídy používá zdrojový parametr namísto obsahu. Tato možnost nejen využívá obsah souboru, ale také jej zkopíruje.
Puppet zkopíruje soubor puppet:///modules/apache/info.php do /etc/puppet/modules/apache/files/info.php.
Uložte a zavřete soubor.
Vytvořte soubor info.php.
sudo sh -c "echo""> /etc/puppet/modules/apache/files/info.php"
Nyní bude uzel Puppet agent schopen stáhnout nastavení z hlavního serveru a nainstalovat zásobník LAMP. Pokud chcete provést změny v prostředí agenta právě teď, spusťte příkaz na tomto uzlu:
sudo loutkový agent --test
Tento příkaz stáhne všechny aktualizace pro aktuální uzel a nainstaluje na něj zásobník. Abyste se ujistili, že Apache a PHP fungují, otevřete v prohlížeči IP adresu nebo doménu uzlu:
http://lamp_1_public_IP/info.php
Závěr
Nyní máte základní znalosti práce s moduly a manifesty Puppet. Zkuste si sami vytvořit jednoduchý manifest a modul.
Puppet je skvělý pro správu konfiguračních souborů aplikace.
Štítky: ,Před nedávnem jsme se na stránkách časopisu podívali na systém dálkové ovládání konfigurace UNIXových strojů Cfengine, což značně zjednodušuje život správce systému automatizací kroků pro konfiguraci mnoha síťových uzlů. Ale bez ohledu na to, jak pohodlný je Cfengine, má mnoho nevýhod, které systém zvaný Puppet nemá.
Představte si sami sebe v roli systémového administrátora, zodpovědného za údržbu funkčnosti stovek strojů s operačními systémy typu UNIX. Každý z nich vyžaduje konfiguraci, pravidelnou aktualizaci a monitorování a předpokládá se, že mnoho z nich plní podobné funkce.
Dvě třetiny jsou pracovní stanice, několik dalších jsou routery a zbytek tvoří několik webových serverů a datových úložišť. Otázka: jak řídit celý tento obchod? Nejjednodušší odpovědí je jednoduše se připojit ke každému z nich pomocí SSH a provést potřebné změny. Tato metoda má však dva problémy. Za prvé je to velmi pracné. Za druhé, administrátor bude muset neustále provádět mnoho monotónních akcí (například pro aktualizaci OpenOffice.org na všech pracovních stanicích budete muset stejné příkazy provést několikrát). Tomuto problému se můžete pokusit vyhnout napsáním několika skriptů, které se samy připojí ke každému počítači a provedou předem napsané příkazy. Ale i zde na vás čekají problémy.
Skripty se budou muset neustále upravovat, aby se přizpůsobily každému úkolu; Skripty budou muset brát v úvahu rozdíly v operačních systémech a verzích a před aplikací na běžící stroje budou muset být dlouho laděny. Obecně, ne comme il faut. Správnou odpovědí je použití tzv. systémů pro správu vzdálené konfigurace, jejichž nejznámějšími zástupci jsou otevřené systémy Cfengine a loutka. Takové systémy přebírají veškerou odpovědnost za uvedení konfigurace stroje do správný typ, vyžadující od administrátora pouze popis konečného stavu systému ve speciálním jazyce (například popis toho, jaké balíčky by měly být nainstalovány v OS, jaké řádky by měly být přidány do konfiguračních souborů, jaké příkazy by se měly provádět atd. ). Poté všechny uzly samy obdrží informace o požadovaném stavu ze serveru a provedou automatickou konfiguraci systému. Díky tomuto mechanismu lze nové stroje plně konfigurovat bez lidského zásahu a stávající lze překonfigurovat přidáním pouhých několika řádků do popisu stavu.
Loutka?
Systému Cfengine jsme již věnovali celý článek, a tak se dnes zaměříme na systém Puppet, který lze klidně nazvat jeho ideovým nástupcem. Puppet byl vyvinut Lukem Kaniesem, kterého omrzela Cfenginova omezení a rozhodl se vytvořit lepší verzi od začátku. Pokud jste již Cfenfine používali, pravděpodobně zjistíte, že Puppet je pohodlnější a výkonnější systém. Státní jazyk Puppet je na vyšší úrovni a flexibilnější, což znamená, že se správce nemusí starat o věci, jako je psaní samostatných pravidel pro každý typ OS nebo Detailní popis provádění triviálních akcí. Puppet umožňuje svému pánovi soustředit se na to, co chce dělat, místo toho, jak to udělat (například pro instalaci konkrétního balíčku na některý z podporovaných operačních systémů systému stačí napsat doslova pár řádků „Nainstalujte tento program“ " místo popisu příkazů nezbytných pro jeho instalaci). Loutka je napsána v jednoduchým jazykem Ruby, což usnadňuje jeho přizpůsobení konkrétnímu úkolu a rozšíření jeho funkčnosti (je poskytován flexibilní systém pluginů).
Navíc, na rozdíl od vývojového modelu Cfengine, který se v podstatě točí kolem jedné osoby, má Puppet velkou komunitu nadšenců, kteří vylepšují kód, sdílejí příklady konfigurace a píší dokumentaci.
Celkově Puppet působí jako modernější a propracovanější systém. Stejně jako Cfengine podporuje téměř všechny moderní operační systémy typu UNIX (včetně MacOS X) a může také běžet v prostředí Cygwin nad Windows. Jeho seznam závislostí obsahuje pouze interpret Ruby a nástroj Factor, takže by neměly být žádné problémy s instalací (abych byl spravedlivý, seznam závislostí Cfengine je ještě kratší).
Instalace
Stejně jako Cfengne, Puppet je systém klient-server, který se skládá z řídicího serveru a podřízených uzlů. Server ukládá popis konečných stavů uzlů (který se v podmínkách loutky nazývá manifest) a čeká, až se připojí. Klient se každou půlhodinu (standardně) připojí k serveru, obdrží od něj popis konečného stavu, porovná jej s aktuálním a v případě, že se změnil a/nebo popsaný stav, překonfiguruje systém a poté jde spát. Komunikace probíhá šifrovaným kanálem, takže jsou vyloučeny útoky založené na substituci popisu stavu (ale pokud útočník převezme server, pak budou všechny uzly pod jeho kontrolou).
Puppet je součástí repozitářů všech populárních distribucí, takže jeho instalace by neměla být obtížná. Například na Debian/Ubuntu lze klienta Puppet nainstalovat takto:
$ sudo apt-get install loutka
A server je takový:
$ sudo apt-get install puppet puppetmaster
Konfigurační soubory klienta a serveru jsou uloženy v adresáři /etc/puppet. Nejdůležitější z nich je soubor /etc/puppet/manifests/site.pp, který obsahuje manifest.
Ukládá popis stavů a měl by existovat pouze na serveru. Pro usnadnění ladění do něj přidáme jednoduchou konfiguraci:
class passwd(
soubor("/etc/passwd":
vlastník => root,
skupina => kořen,
režim => 644,
}
}
výchozí uzel (
zahrnout heslo
}
Tyto řádky popisují stav, kdy vlastník souboru /etc/passwd musí být root a jeho oprávnění jsou nastavena na 644. V další části se podíváme blíže na formát souboru manifestu. Druhým nejdůležitějším souborem je /etc/puppet/puppet.conf. Nastavuje konfiguraci serveru a klientů, takže musí být přítomen na všech počítačích organizovaných v síti Puppet. V Ubuntu tento soubor obsahuje minimální nutné a ve většině případů dostačující nastavení. Níže jsou uvedeny s komentáři:
# vi /etc/puppet/puppet.conf
# Standardní cesty k adresářům
logdir=/var/log/puppet
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
# Umístění nástroje Factor,
# slouží k získání informací o OS
factpath=$vardir/lib/facter
# Synchronizujte pluginy
# (nainstalované pluginy na serveru - jsou zkopírovány do klientů)
pluginsync=true
# Katalog se šablonami (přečtěte si o nich níže)
templatedir=$confdir/templates
# Synchronizace s etckeeper
# (kdo ví, pochopí, ostatní to nepotřebují)
prerun_command=/etc/puppet/etckeeper-commitpre
postrun_command=/etc/puppet/etckeeper-commitpost
Konfigurační soubor může obsahovat velký počet různé možnosti, o kterých lze získat informace vygenerováním výchozí konfigurace:
$ sudo puppetmasterd -genconfig > /etc/puppet/
puppetd.conf.default
Výchozí konfigurace klienta se generuje pomocí jiného příkazu:
$ sudo puppet -genconfig > /etc/puppet/puppetd.conf.default
Ke konfiguraci se používají soubory Fileserver.conf a auth.conf souborový server(přečtěte si o tom v části „Souborový server“) a ověřování. Zatím nemá smysl se jich dotýkat. Po dokončení konfigurace je nutné restartovat server Puppet:
$ sudo /etc/init.d/puppetmaster restart
Poté bude připraven přijímat požadavky zákazníků. Bez podepsaného certifikátu však žádný klient nebude moci přijmout manifest ze serveru a nakonfigurovat počítač.
Proto musíme klienty Puppet spustit v testovacím režimu, aby mohli odeslat své certifikáty serveru k podpisu (mimochodem, lze to provést na všech počítačích současně pomocí nástroje shmux):
$ sudo puppetd -server puppet-server.com -verbose -test
Vrátíme se na server a obdržíme seznam certifikátů připravených k podpisu:
$ sudo puppetca --list
Vyberte hostitele ze seznamu a podepište jeho certifikát:
$ sudo puppetca --sign nomad.grinder.com
Nebo podepíšeme vše najednou:
$ sudo puppetca --sign --all
Nyní můžete spustit klienty v bojovém režimu. Nejprve však musíte zadat název serveru Puppet konfigurační soubor(ve výchozím nastavení je jeho název jen loutka):
$sudo su
# echo "" >> /etc/puppet/puppet.conf
# echo "server=puppet-server.com" >> /etc/puppet/puppet.conf
# východ
Spouštění klientů:
$ sudo /etc/init.d/puppet start
Jazyk popisu stavu
Jak již bylo zmíněno výše, Puppet používá svůj vlastní jazyk pro popis konečného stavu operační systém, s jehož pomocí správce systému udává, do jaké podoby mají být součásti OS uvedeny, aby dosáhl požadovaného stavu. Jedná se o poměrně složitý jazyk, který je však mnohem jednodušší než jakýkoli programovací jazyk. Pokud jste alespoň povrchně obeznámeni se skriptovacím jazykem bash, snadno porozumíte jazyku Puppet. Klíčovým prvkem jazyka jsou prostředky, které se používají k popisu toho, do jaké podoby by měla být jedna z komponent operačního systému převedena. Například následující jednoduchý zdroj popisuje požadovaný stav souboru /etc/passwd:
# vi /etc/puppet/manifests/site.pp
soubor("/etc/passwd":
vlastník => "root"
}
Zde je soubor typu prostředku. Celkem jich je několik desítek, od zdrojů, které spravují soubory, jako v tomto příkladu, až po balíčky a služby. Řádek /etc/passwd je název zdroje.
V případě typu souboru je název stejný jako cesta k souboru, ale u některých jiných typů může být název libovolný. Řádek vlastník => "root" popisuje nastavení atributu vlastníka na root, to znamená, že říká, že vlastník zadaný soubor musí existovat správce.
Každý typ zdroje má svou vlastní sadu atributů, které lze upravit, a navíc existují speciální meta atributy, které lze použít v libovolném zdroji. Jednou z důležitých vlastností zdrojů je schopnost na ně odkazovat. To lze použít k vytvoření řetězců závislostí. Následující záznam vytvoří prostředek /etc/group, který závisí na prostředku /etc/passwd (závislosti se zadávají pomocí atributu required meta):
# vi /etc/puppet/manifests/site.pp
soubor("/etc/group":
vyžadovat => Soubor["/etc/passwd"],
vlastník => "kořen",
}
To znamená, že prostředek /etc/group lze nakonfigurovat (přenést do popsaného formuláře) pouze tehdy, když je nakonfigurován prostředek /etc/passwd. Prostředky lze seskupit do kolekcí zdrojů nazývaných třídy. To je nezbytné pro spojení zdrojů, které mají podobný význam a typ prováděného úkolu, do jednoho abstraktního zdroje. Pro pohodlí bychom například mohli zkombinovat instalaci a spuštění webového serveru nginx do jednoho abstraktního zdroje se stejným názvem:
# vi /etc/puppet/manifests/site.pp
třída nginx(
balíček("nginx":
zajistit => nainstalováno
}
služba("nginx":
zajistit => běh,
vyžadovat => Balíček["nginx"],
}
}
Zde se typ prostředku balíčku používá k instalaci balíčku nginx do systému a služba se používá ke spuštění služby se stejným názvem. S požadavkem donutíme systém spustit službu pouze v případě, že byl balíček úspěšně nainstalován. Výhodou tříd je, že mohou být také zahrnuty v závislosti na:
# vi /etc/puppet/manifests/site.pp
služba("chobotnice":
zajistit => běh,
vyžadovat => Třída["nginx"],
}
Stejně jako ve skutečných jazycích OOP mohou třídy od sebe dědit a přepisovat atributy:
# vi /etc/puppet/manifests/site.pp
class passwd(
soubor("/etc/passwd":
vlastník => "kořen",
skupina => "kořen",
}
}
class passwd-bsd zdědí passwd (
Soubor["/etc/passwd"] ( skupina => "kolečko" )
}
Zde třída passwd-bsd dědí z passwd, aby přepsala atribut group zdroje /etc/passwd (na systémech BSD patří /etc/passwd do skupiny wheel, takže jsme pro takové systémy vytvořili samostatnou třídu). Později se podíváme na správnější a zjevnější způsob výběru alternativních hodnot atributů pomocí podmínek.
Proměnné jsou jednou z nedílných součástí každého programovacího jazyka a má je také Puppet. Proměnné začínají znakem $ a mohou obsahovat libovolné číslo, řetězec nebo booleovskou hodnotu (true, false):
$want_apache = true
$apache_version = "2.2.14"
Jednou z nejvýkonnějších funkcí aplikace Puppet související s proměnnými je její integrace s nástrojem facter machine information tool. Tento nástroj vrací všechny informace specifické pro počítač ve formě párů klíč-hodnota, které jsou v Puppet převedeny na proměnné stejného jména. Spolu s podmíněnými instrukcemi v jazyce Puppet je lze použít ke změně atributů prostředků v závislosti na vlastnostech stroje.
Například výše popsanou třídu passwd lze snadno přepsat tak, aby automaticky vybrala atribut v závislosti na typu operačního systému (aniž by byla potřeba samotná třída):
# vi /etc/puppet/manifests/site.pp
soubor("/etc/passwd":
vlastník => "kořen",
skupina => $kernel ? (
Linux => "root",
FreeBSD => "kolo",
},
}
V závislosti na operačním systému, na kterém bude tento fragment manifestu analyzován, bude hodnota atributu group buď root nebo wheel. Kromě podmíněného operátoru podporuje jazyk Puppet také operátor výběru případu, který lze použít k vytvoření konkrétního zdroje v závislosti na hodnotě proměnné:
# vi /etc/puppet/manifests/site.pp
případ $operační systém (
redhat: (služba("httpd": zajistit => běží))
debian: (service("apache": zajistit => běží))
výchozí: ( služba ( "apache2": zajistit =>
běh))
}
Tento kód definuje různé varianty prostředku typu služby v závislosti na operačním systému (názvy služeb se mohou mezi distribucemi Linuxu lišit, takže pro každou z nich musí být individuálně specifikována služba Puppet).
Výchozí možnost se použije, pokud hodnota proměnné neodpovídá žádné z předchozích možností. Kromě dříve diskutovaných typů zdrojů souboru, balíčku a služby podporuje Puppet velké množství dalších, včetně těch vytvořených vývojáři třetích stran typy zdrojů. Jejich podrobný popis včetně příkladů, podporovaných atributů a funkcí naleznete v oficiální dokumentaci – http://docs.puppetlabs.com/references/stable/type.html. Níže je uveden seznam a Stručný popis nejpoužívanější jsou:
Populární typy loutkových zdrojů
- cron - správa úloh cron
- exec - spouštění skriptů a příkazů
- soubor - správa souborů
- filebucket - záloha soubory
- skupina - řízení skupiny
- hostitel - správa položek v souboru /etc/hosts
- interface - konfigurace síťových rozhraní
- mount - připojení souborových systémů
- notify - odeslání zprávy do souboru protokolu Puppet
- balíček - správa balíčků
- servis - správa služeb
- sshkey - správa klíčů SSH
- tidy - mazání souborů v závislosti na podmínkách
- uživatel - správa uživatelů
- zóny - správa zón Solaris
Druhým nejdůležitějším prvkem jazyka Puppet po zdrojích jsou uzly. S jejich pomocí může administrátor popsat, na které stroje by měly být použity určité prostředky a třídy. Jinými slovy, je to způsob, jak specifikovat individuální konfiguraci pro každý ze strojů účastnících se sítě Puppet. Nejjednodušší příklad uzlu je uveden na začátku článku v části „Instalace“:
# vi /etc/puppet/manifests/site.pp
výchozí uzel (
zahrnout heslo
}
Toto je definice výchozího uzlu, který zahrnuje prostředek/třídu passwd. Výchozí název znamená „všechny ostatní uzly“, takže prostředek/třída passwd definovaná někde výše bude nakonfigurována na každém z nich. Klíčové slovo include je zde použito pro usnadnění; ve skutečnosti lze všechny třídy a prostředky popsat přímo v popisu uzlu, ale nedoporučuje se to. Kromě výchozí hodnoty můžete zadat název uzlu jméno sítě stroj (pak budou všechny prostředky popsané v uzlu konfigurovány pouze na tomto počítači), nebo libovolný název (pak může být tento uzel zděděn jiným uzlem). Abychom pochopili, jak to všechno funguje společně s třídami a prostředky, podívejme se na příklad hotového manifestu Puppet používaného ke konfiguraci dvou síťových strojů (webového serveru a serveru NTP):
# vi /etc/puppet/manifests/site.pp
# Instalace a spuštění serveru SSH
třída sshd(
balíček ( openssh-server: zajistit => nainstalováno )
služba (sshd:
jméno => $operační systém ? (
fedora => "sshd",
debian => "ssh",
výchozí => "sshd",
},
povolit => pravda,
zajistit => běh,
}
}
# Nainstalujte a spusťte Apache
třída httpd(
balíček ( httpd: zajistit => nainstalováno )
služba (httpd:
povolit => pravda,
zajistit => běh,
}
}
# Instalace a spuštění serveru NTP
třída ntpd(
balíček ( ntp-server: zajistit => nainstalováno )
služba (
ntp server:
povolit => pravda,
zajistit => běh,
}
}
# Základní uzel používaný pouze jako rodič všech ostatních
základna uzlů (
zahrnout sshd
}
# Uzel, kde bude umístěn webový server
uzel web.server.com zdědí základ (
zahrnout httpd
}
# Uzel serveru NTP
uzel ntp.server.com dědí základ (
zahrnout ntpd
}
Tato zdánlivě jednoduchá konfigurace dělá docela hodně: nainstaluje a spustí Apache na stroji na web.server.com a na stroji nainstaluje a spustí NTP server. ntp.server.com. Oba počítače navíc nainstalují server SSH. Tato konfigurace pravděpodobně nebude vyhovovat ani jednomu správci; bude muset být vážně vylepšen, aby se naučil, jak správně konfigurovat servery, přijímat čerstvé konfigurace a další soubory z hlavního serveru Puppet.
Jasně však ukazuje sílu Puppet. Pomocí jednoduché konfigurace jsme donutili stroje, aby si samy nainstalovaly a spustily potřebný software a udržovaly jej v provozuschopném stavu (pokud se server zhroutí, Puppet se sám překonfiguruje, aby uvedl systémy do požadovaného stavu).
Souborový server
Mnoho úloh vzdálené správy nelze vyřešit bez zkopírování dalších souborů do počítačů. Mohou to být předem připravené konfigurace, webové stránky pro Apache, balíčky, které nejsou v oficiálním úložišti, a mnoho dalšího. Pro usnadnění procesu přenosu těchto souborů na vzdálené hostitele obsahuje Puppet souborový server.
Nastavení souborového serveru jsou uložena v souboru /etc/puppet/fileserver.conf. Chcete-li přinutit Puppet poskytovat klientům obsah konkrétního adresáře, musíte do něj vložit několik řádků:
# vi /etc/puppet/fileserver.conf
cesta = /var/puppet/files
povolit *.server.com
Tyto dva řádky označují, že adresář /var/puppet/files by měl být přístupný všem hostitelům v doméně server.com. Kromě toho můžeme zadat celé doménové jméno povoleného stroje nebo jeho IP adresu a také odříznout nechtěné pomocí direktivy deny. Jakýkoli soubor v tomto adresáři lze poté přesunout do klienta pomocí prostředku souboru. Například:
# vi /etc/puppet/manifests/site.pp
soubor("/etc/httpd/conf/httpd.conf":
zdroj => "puppet://httpd/httpd.conf",
režim => 644,
}
Soubor httpd.conf, který se nachází na serveru v adresáři /var/puppet/files/httpd, bude zkopírován do cílového počítače cestou zadanou v názvu prostředku.
závěry
V tomto článku jsme pokryli velmi malou část schopností Puppet. Ve skutečnosti se jedná o složitý systém, který lze plně popsat pouze na stránkách knihy. Zároveň se Puppet velmi snadno konfiguruje a udržuje, zejména proto, že na internetu najdete spoustu příkladů jeho konfigurace.
Info
- Puppet používá protokol HTTP, takže jej lze spustit pod webovým serverem pro zlepšení výkonu.
- Puppet lze použít k automatické konfiguraci a údržbě jednoho místního počítače.
- Spojením loutky, instalace sítě OS (pxe-install) a samostatně sestavené instalační obrazy, můžete vytvořit zcela samokonfigurující síť počítačů, kterou lze nasadit pouze jedním příkazem.
- Puppet ve své práci používá mnoho velkých společností, jako je Google, Fedora Project, Stanford University, červená čepice, Siemens IT Solution a SugarCRM.
Odkazy
- http://docs.puppetlabs.com - Dokumentace loutek
- http://docs.puppetlabs.com/guides/language_tutorial.html – Kompletní popis jazyka Puppet
- http://docs.puppetlabs.com/references/stable/type.html – Typy zdrojů
Před časem přesáhl seznam serverů v mých záložkách 200. S rostoucím počtem serverů zabírá nasazení jakékoli nové konfigurace nebo instalace nových balíčků obrovské množství času. Tak jsem se rozhodl použít loutku.
Loutka(anglicky puppet) je multiplatformní aplikace klient-server, která umožňuje centrálně spravovat konfiguraci operačních systémů a programů nainstalovaných na několika počítačích. Puppet je napsán v programovacím jazyce Ruby.
Říká se také, že puppet je systém pro správu vzdálené konfigurace, jehož nejznámějšími představiteli jsou otevřené systémy Cfengine a Puppet.
Po přečtení recenzí jsem se rozhodl použít loutku.
Instalace a konfigurace loutkového serveru:
Instalace loutkového serveru:
Nainstalujte puppet-server na OpenSuSE 11.4:
zip v loutkovém serveru
Změňme název serveru na loutkový:
/etc/HOSTNAME:
DNS záznam se musí přeložit na 127.0.0.2
cat /etc/hosts:
127.0.0.2 loutka.site loutka
Dejme uživatelská práva loutka:
Spustíme službu Puppet Master:
spuštění rcpuppetmasterd
Ke spuštění přidáme spuštění loutkového démona:
chkconfig -a puppetmasterd
Nastavení loutkového serveru:
Definujme adresář, kam se budou ukládat soubory, které bude loutkový server přenášet na klientské stroje v manifestech typu souboru.
vim /etc/puppet/fileserver
cesta /etc/puppet/files
dovolit *
mkdir /etc/puppet/files
chown -R puppet:puppet /etc/puppet/files
Vytvoříme soubor libovolného obsahu pro nasazení a testování na klientech
dotkněte se /etc/puppet/files/puppettesting
Restartujeme loutkový server:
restart rcpuppetmasterd
Loutka používá pro popis konečného stavu operačního systému svůj vlastní jazyk, pomocí kterého správce systému naznačí, do jaké podoby má uvést komponenty OS, aby dosáhl požadovaného stavu. Stav může znamenat přítomnost určitého souboru, složky, spuštěných služeb nainstalované balíčky, aktualizace a další. Všechna nastavení stavu jsou popsána v souborech nebo manifestech, které jsou umístěny v adresáři: /etc/puppet/manifests. Tyto soubory mají názvy jako *.pp.
Pojďme vytvořit to nejjednodušší manifest:
/etc/puppet/manifests/1.file.pp:
soubor("/tmp/puppettetesting":
zdroj => "puppet:///files/puppettesting",
}
Chcete-li použít tento manifest:
loutka aplikovat 1.soubor.pp
Instalace a konfigurace loutkového klienta:
zip v loutce
Dejme uživateli práva loutky:
chown -R puppet.puppet /var/lib/puppet/
Pro navázání spojení s loutkovým serverem odešle loutkový klient žádost o potvrzení certifikátu, po potvrzení této žádosti na serveru začne loutkový klient používat jemu určené manifesty. Zašleme žádost o potvrzení certifikátu:
Na serveru můžeme vidět, jaké požadavky na potvrzení čekají:
"loutka-klient.místní doména" (B5:12 :69 :63 :DE:19 :E9:75 :32 :2B:AA:74 :06:F6:8E:8A)
Potvrzujeme:
puppetca --sign "puppet-client.localdomain"
Je čas podívat se na nejjednodušší příklady vytváření manifestů:
vytvořte soubor /etc/puppet/manifests/site.pp:
výchozí uzel (
soubor("/tmp/puppettetesting":
zdroj => "puppet:///files/puppettesting",
}
služba("ntp":
zajistit => běh,
povolit => true ,
}
balíček("htop":
zajistit => nainstalováno,
}
}
výchozí - platí pro všechny klienty
soubor - tato sekce říká, že se má vytvořit nebo přepsat soubor /tmp/puppettetesting, který je umístěn na serveru v adresáři /etc/puppet/files
služba: zkontrolujte, zda je služba spuštěna, pokud neběží, spusťte ji a také ji přidejte do spuštění
balíček: zkontrolujte, zda je na klientovi nainstalován balíček htop, a pokud ne, nainstalujte jej.
Pro kontrolu spusťte na klientovi:
Jak můžete vidět, na klientovi byl přidán ntp do spuštění, byl spuštěn démon ntp, nainstalován balíček htop a soubor puppettetesting byl zkopírován do adresáře /tmp/
info: Caching katalog pro puppet-client.localdomain
info: Použití verze konfigurace "1370163660"
upozornění: / Stage[ main] // Node[ default] / Service[ ntp] / zajistit: zajistěte změnu "zastaveno" na "spuštěno"
upozornění: / Stage[ main] // Node[ default] / Package[ htop ] / secure: created
upozornění: / Stage[ main] // Node[ default] / File[ / tmp/ puppettesting] / zajistit: definovaný obsah jako "(md5)f2171ac69ba86781bea2b7c95d1c8e67"
upozornění: Dokončený běh katalogu za 3,95 sekundy
V příštím článku popíšu složitější příklady tvorby manifestů a webového rozhraní loutka-dashboard.
Populární typy loutkových zdrojů
cron- správa úloh cron
exec- spouštění skriptů a příkazů
soubor- správa souborů
filebucket- záloha souborů
skupina- vedení skupiny
hostitel- správa záznamů v souboru /etc/hosts
rozhraní- konfigurace síťových rozhraní
namontovat- připojování souborových systémů
oznámit- odeslání zprávy do souboru protokolu Puppet
balík- správa balíků
servis- správa služeb
sshkey- Správa klíčů SSH
uklidit- mazání souborů v závislosti na podmínkách
uživatel- správa uživatelů
zóny- Správa zón Solaris
Loutka je multiplatformní struktura, která umožňuje správci systému Provádějte běžné úkoly pomocí kódu. Kód umožňuje provádět různé úkoly od instalace nových programů po kontrolu oprávnění k souborům nebo aktualizaci uživatelských účtů. Loutka vynikající nejen při prvotní instalaci systému, ale po celou dobu životní cyklus systémy. Většinou loutka používá se v konfiguraci klient/server.
Tato část ukazuje instalaci a konfiguraci Loutka v konfiguraci klient/server. Tento jednoduchý příklad ukazuje, jak nainstalovat Apache použitím Loutka.
Instalace
Pro instalaci Loutka zadejte do terminálu:
Sudo apt-get install puppetmaster
Na klientských počítačích zadejte:
Sudo apt-get instalační loutka
Nastavení
Před nastavením loutky možná budete chtít přidat záznam DNS CNAME Pro loutka.example.com, Kde example.com- toto je vaše doména. Výchozí klienti Loutka zkontrolujte DNS pro puppet.example.com jako název loutkového serveru ( Loutkař). Další podrobnosti o používání DNS naleznete v části Služba doménových jmen.
Pokud nemáte v úmyslu používat DNS, můžete přidat položky do souboru /etc/hosts na serveru a klientovi. Například v souboru /etc/hosts Loutka přidat server:
127.0.0.1 localhost.localdomain localhost loutka 192.168.1.17 meercat02.example.com meercat02
Na každém Loutka V klientovi přidejte položku pro server:
192.168.1.16 meercat.example.com loutka meercat
Nahraďte IP adresy a názvy domén od příkladu po vaše aktuální adresy a názvy serveru a klientů.
Nyní nastavíme nějaké zdroje pro apache2. Vytvořte soubor /etc/puppet/manifests/site.pp obsahující následující:
Balíček ( "apache2": zajistit => nainstalováno) služba ( "apache2": zajistit => true, povolit => true, vyžadovat => balíček["apache2"] )
Uzel "meercat02.example.com" (včetně apache2)
Nahradit meercat02.example.com na vaše aktuální jméno Loutka klienta.
Poslední krok pro tento jednoduchý Loutka server má restartovat službu:
Sudo /etc/init.d/puppetmaster restartujte
Teď dál Loutka vše je nakonfigurováno na serveru a je čas nakonfigurovat klienta.
Nejprve nakonfigurujeme službu Loutka agenta spustit. Upravte /etc/default/puppet a nahraďte hodnotu START na Ano:
Sudo /etc/init.d/puppet start
Vraťme se k Loutka server podepíše klientský certifikát pomocí příkazu:
Sudo puppetca --sign meercat02.example.com
Šek /var/log/syslog pro případné chyby konfigurace. Pokud vše proběhlo v pořádku, balíček apache2 a jeho závislosti budou nainstalovány do Loutka klienta.
Tento příklad je velmi jednoduchý a neukazuje mnoho funkcí a výhod. Loutka. Pro dodatečné informace Koukni se