hjem › Råd › Master of puppets: Installere og konfigurere Puppetnssystemet. Master of puppets: Installere og konfigurere Puppet fjernkonfiInstallere puppet

Master of puppets: Installere og konfigurere Puppetnssystemet. Master of puppets: Installere og konfigurere Puppet fjernkonfiInstallere puppet

For å bruke Puppet mer effektivt, må du forstå hvordan moduler og manifester er bygget. Denne opplæringen vil lede deg gjennom hvordan disse Puppet-komponentene fungerer ved å sette opp en LAMP-stabel på en Ubuntu 14.04-server.

Krav

Installere Puppet (mester og agent). Mer om dette -.
Muligheten til å lage minst én virtuell Ubuntu 14.04-server for å betjene Puppet-agentnoden.

Grunnleggende om dukkekode

Ressurser

Dukkekode består hovedsakelig av ressurser. En ressurs er et stykke kode som beskriver tilstanden til systemet og bestemmer endringene det trenger. For eksempel:

bruker("mitchell":
sikre => presentere,
uid => "1000",
gid => "1000",
skall => "/bin/bash",
hjem => "/hjem/mitchell"
}

Ressurserklæringen har følgende format:

ressurs_type("ressursnavn"
attributt => verdi
...
}

For å se alle Puppet-ressurstyper, utfør kommandoen:

marionetressurs --typer

Du vil lære mer om ressurstyper i denne veiledningen.

Manifester

Et manifest er et orkestreringsmanus. Dukkeprogrammer med en .pp-utvidelse kalles manifester. Standard Puppet-manifest er /etc/puppet/manifests/site.pp.

Klasser

Som i alle vanlig programmeringsspråk, er klassene ansvarlige for å organisere og gjenbruke deler av orkestreringen.

Innenfor en klassedefinisjon er en kodeblokk som beskriver hvordan klassen fungerer. Når du har definert en klasse, kan du bruke den i manifester.

Klassedefinisjonen har følgende format:

klasse eksempel_klasse(
...
kode
...
}

Denne koden definerer klassen example_class. Puppet-koden vil være i krøllete klammeparenteser.

En klasseerklæring er stedet i koden der en bestemt klasse kalles. Med en klasseerklæring behandler Puppet koden sin.

Klassedeklarasjonen kan være ordinær og etter ressurstype.

En vanlig klasseerklæring legges til koden ved å bruke nøkkelordet include.

inkludere eksempelklasse

Når den er deklarert som en ressurstype, er klassen erklært i ressursformat:

klasse("eksempelklasse":)

Denne erklæringen lar deg legge til klasseparametere til koden din som overstyrer standardverdiene til klasseattributter. For eksempel:

node "vert2" (
klasse ("apache": ) # bruk apache-modul
apache::vhost ("example.com": # definer vhost-ressurs
port => "80",
docroot => "/var/www/html"
}
}

Moduler

En modul er en gruppe manifester og andre filer organisert på en forhåndsdefinert måte som gjør det enkelt å dele og gjenbruke individuelle deler av orkestreringen. Moduler hjelper til med å organisere Puppet-kode fordi de kan brukes til å skille kode i flere manifester.

Puppet-moduler er lagret i katalogen /etc/puppet/modules.

Å skrive et manifest

Du kan øve på å skrive Puppet-manifester, -moduler og -klasser ved å bruke eksemplet med å installere en LAMP-stabel på en Ubuntu-server (resultatet blir ).

Så for å orkestrere en Ubuntu 14.04-server og installere en LAMP-stabel på den, trenger du ressurser for følgende handlinger:

installerer apache2-pakken.
starter apache2-tjenesten.
pakkeinstallasjon MySQL-server, mysql-server.
starter mysql-tjenesten.
installere php5-pakken
lage et PHP-testskript, info.php.
oppdatering av apt-indeksen før du installerer hver pakke.

Nedenfor finner du tre eksempler på Puppet-kode som kan brukes for å oppnå et slikt LAMP-stabeloppsett.

Det første eksemplet vil lære deg hvordan du skriver grunnleggende manifester i én fil. Det andre eksemplet vil hjelpe deg med å sette sammen og bruke en klasse og modul basert på tidligere skrevne manifester. Det tredje eksemplet viser deg hvordan du bruker forhåndsbygde offentlige moduler for å installere en LAMP-stabel.

Merk: For testing er det bedre å bruke en fersk virtuell server.

Eksempel 1: Installere LAMP med ett manifest

Puppet-manifestet kan skrives på agentnoden og deretter utføres ved hjelp av puppet application-kommandoen (du trenger ikke ha et master- og agentoppsett for å gjøre dette).

I denne delen lærer du å skrive manifester som vil bruke disse typene ressurserklæringer:

exec: Utfør kommandoer.
pakke: installer pakker.
tjeneste: tjenesteledelse.
fil: filbehandling.

Opprette et manifest

Opprett et nytt manifest:

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

Legg til følgende kode for å deklarere de nødvendige ressursene.

# kjør kommandoen "apt-get update".
exec("apt-update": # ressurs exec "apt-update"
kommando => "/usr/bin/apt-get update" # kommando som denne ressursen vil kjøre
}
# installer apache2-pakken
pakke("apache2":
require => Exec["apt-update"], # be om "apt-update" før du installerer pakken
sikre => installert,
}
# start apache2-tjenesten
service("apache2":
sikre => kjører,
}
# installer mysql-server
pakke("mysql-server":
require => Exec["apt-update"], # be om "apt-update" ved å installere på nytt
sikre => installert,
}
# start mysql-tjenesten
service("mysql":
sikre => kjører,
}
# installer php5-pakken
pakke("php5":
require => Exec["apt-update"], # be om "apt-update" før installasjon
sikre => installert,
}
# start info.php-tjenesten
file("/var/www/html/info.php":
sikre => fil,
innhold => "", # phpinfo-kode
require => Pakke["apache2"], # forespørsel om pakke "apache2"
}

Bruker et manifest

For å bruke det nye manifestet, skriv inn kommandoen:

sudo puppet application --test

Den vil vise et omfangsrikt resultat som viser alle endringer i miljøtilstanden. Hvis det ikke er noen feil i utdataene, bør du kunne åpne din eksterne IP-adresse eller domenenavn i nettleseren din. En testtest vil vises på skjermen. PHP-side med informasjon om stabelen. Dette betyr at Apache og PHP fungerer.

Nå er LAMP-stakken installert på serveren ved hjelp av Puppet.

Dette er et ganske enkelt manifest siden det kan utføres på en agent. Hvis du ikke har en Puppet Master, vil ikke andre agentnoder kunne bruke dette manifestet.

Puppet Master-serveren sjekker for endringer i serverstatus hvert 30. minutt.

Eksempel 2: Installere en LAMPE-stabel ved hjelp av en modul

Prøv nå å lage en enkel modul basert på LAMP-manifestet du skrev i forrige seksjon.

For å opprette en modul, opprette en ny katalog i modulkatalogen (navnet må samsvare med navnet på modulen). Denne katalogen bør inneholde en manifestkatalog og en init.pp-fil. Filen init.pp spesifiserer Puppet-klassen (navnet må også samsvare med navnet på modulen).

Opprette en modul

Gå til Puppet master-serveren og lag en katalogstruktur for modulen:

cd /etc/puppet/modules
sudo mkdir -p lampe/manifester

Opprett og åpne init.pp-filen i redigeringsprogrammet:

sudo vi lampe/manifester/init.pp

Sett inn lampeklassen i filen:

klasse lampe(
}

Kopier innholdet i manifestet fra seksjon 1 og lim det inn i lampeklasseblokken. Du har nå en lampeklassedefinisjon. Andre manifester vil kunne bruke denne klassen som en modul.

Lagre og lukk filen.

Bruke en modul i hovedmanifestet

Nå kan du konfigurere hovedmanifestet og bruke lampemodulen til å installere LAMP-stakken på serveren.

Rediger følgende fil på Puppet Master-serveren:

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

Mest sannsynlig på dette øyeblikket filen er tom. Legg til følgende linjer:

node standard ( )
node "lampe-1" (
}

Merk: Bytt ut lampe-1 med vertsnavnet til Puppet-agenten du vil installere stabelen på.

Nodeblokken lar deg spesifisere Puppet-kode som bare vil gjelde for noen noder.

Standardblokken gjelder for alle agentnoder som ikke har en individuell blokk (la den stå tom). Lampe-1-blokken vil bli brukt på lampe-1-agentnoden.

Legg til følgende linje i denne blokken, som bruker lampemodulen:

Lagre og lukk filen.

Nå vil Puppet-agentnoden kunne laste ned innstillinger fra hovedserveren og installere LAMP-stakken. Hvis du vil gjøre endringer akkurat nå, kjør kommandoen på agenten:

sudo puppet agent --test

Moduler er den mest praktiske måten å gjenbruke Puppet-kode på. I tillegg hjelper moduler deg med å organisere koden logisk.

Eksempel 3: Installasjon av LAMP ved bruk av offentlige moduler

MySQL-modulen brukes på lignende måte. Legg til følgende linjer til nodeblokken:

class("mysql::server":
root_password => "passord",
}

Du kan også sende MySQL-modulparametere.

Legg til en ressurs som kopierer info.php til ønsket plassering. Bruk kildeparameteren. Legg til følgende linjer til nodeblokken:

file("info.php": # ressursfilnavn
bane => "/var/www/html/info.php", # målbane
sikre => fil,
require => Klasse["apache"], # apache-klasse som skal brukes
source => "puppet:///modules/apache/info.php", # sted å kopiere filen til
}

Denne klasseerklæringen bruker kildeparameteren i stedet for innhold. Dette alternativet bruker ikke bare innholdet i filen, men kopierer det også.

Puppet vil kopiere filen puppet:///modules/apache/info.php til /etc/puppet/modules/apache/files/info.php.

Lagre og lukk filen.

Lag en info.php-fil.

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

Nå vil Puppet-agentnoden kunne laste ned innstillinger fra hovedserveren og installere LAMP-stakken. Hvis du vil gjøre endringer i agentmiljøet akkurat nå, kjør kommandoen på denne noden:

sudo puppet agent --test

Denne kommandoen vil laste ned alle oppdateringer for gjeldende node og installere stabelen på den. For å sikre at Apache og PHP fungerer, åpne nodens IP-adresse eller domene i en nettleser:

http://lamp_1_public_IP/info.php

Konklusjon

Du har nå grunnleggende kunnskap om arbeid med Puppet-moduler og manifester. Prøv å lage et enkelt manifest og modul selv.

Puppet er flott for å administrere programkonfigurasjonsfiler.

Tags: ,
Litt poesi. Det ser ut til at denne artikkelen burde være utgangspunktet for hele serien, men målgruppen er fortsatt mer erfarne brukere av Open Source Puppet Labs-produkter som ikke er fornøyd med de individuelle, dårlig integrerte modulene med Puppet Forge. Som med enhver "bibliotek vs. rammeverk"-tilfelle, er prisen å betale å følge verdensbildet til forfatteren av den integrerte løsningen.

Litt om hvordan Puppet fungerer

Puppet er først og fremst et spesifikt språk for deklarativt å spesifisere den endelige tilstanden til systemet. Til sammenligning er GNU Makefile ekstremt egnet, der det i tillegg til den direkte beskrivelsen av avhengigheter er mulig å bli rar til det fulle.

Puppets abstraksjon er noe sånt som dette ( bryte mønstre - glem alt du visste om programmeringsbegreper!).

Node er et sett med konfigurasjoner for et spesifikt målsystem. Faktisk er dette et spesielt tilfelle av en klasse.
Klasse er et sett med deklarativ logikk som er inkludert i nodekonfigurasjonen eller andre klasser. Klassen har verken forekomster eller metoder, men den har parametere og variabler definert i logikken. Faktisk er det snarere en prosedyre som kan arve en annen prosedyre ved ganske enkelt å legge til kode og ha et ikke-så-banalt omfang av variabler.
Type- men dette ser mer ut som en klassisk klasse - det antar forekomster med et navn og definitivt gitte parametere, men ikke noe mer. En spesifikk implementering av en type kan skrives som et Puppet-skript via define , som lager forekomster av andre typer, eller som en Ruby-utvidelse med en fantasi.
Ressurs- disse er faktisk navngitte forekomster av typer. Hvert ressursnavn er unikt innenfor en bestemt type innenfor node (katalog) konfigurasjonen.
Variabler– vel, kort sagt, dette er konstanter... Før Puppet 4 var det enda verre med omfanget. Nå er det tilstrekkelig: for bruk utenfor definisjonsstedet, må en fullt kvalifisert identifikator spesifiseres, bortsett fra når det gjelder klassearv.

Puppet kan brukes til lokal distribusjon uten nettverk eller tilhørende infrastruktur. Dette kan brukes til å lage containerbilder. Det er til og med en hel bevegelse som tar til orde for å forlate en sentralisert server.

På en ideologisk korrekt måte består Puppet-infrastrukturen av en agent - en privilegert tjeneste på målsystemet - og en server som distribuerer verdifulle instruksjoner i form av deklarative ressurskataloger på forespørsel fra agenter. Sikkerhet er implementert på nivået til den private offentlige nøkkelinfrastrukturen (X.509). Enkelt sagt, de samme mekanismene som i HTTPS, men med egen CA og obligatorisk verifisering klientsertifikat.

I en forenklet form ser distribusjonsprosedyren omtrent slik ut:

Behandling via TLS og X.509 (tilkoblingsetablering, CRL-oppdatering, kontroll av sertifikatrestriksjoner osv.)
Agenten mottar faktageneratorer fra serveren med caching og alle tingene (mer presist, alt hentes fra lib/-mappene i modulene). Det er ikke vanskelig å legge til ditt eget Ruby-skript for å samle inn informasjonen av interesse.
Agenten samler inn fakta om målsystemet og sender det til serveren. Alle fakta kan enkelt ses manuelt via puppet facts call. Disse faktaene er tilgjengelige som globale variabler.
Serveren kompilerer en katalog over ressurser og sender den til agenten. Under dette ligger et helt lag av forskjellige konsepter.
Agenten henter alt nødvendig fra serveren og bringer systemet til spesifisert form. Agenten selv vet ikke hva den skal gjøre med ressurser; den er avhengig av implementering av leverandører (den semantiske oversettelsen vil være «implementer», ikke leverandør) av spesifikke typer ressurser. Noen leverandører er standard og er inkludert i Puppet-pakker, mens resten er trukket fra moduler.

For å nyte alle herlighetene er det ekstra boller i form av:

Modul- en samling av deklarative Puppet-skript, Ruby-utvidelser for Puppet, filer, filmaler, Hiera-data og mye mer. Et mer korrekt begrep ville være "pakke".
Miljø- et sett med skript, moduler og Hiera-data. Etter hvert som infrastrukturen ble mer kompleks, ble det uunngåelig nødvendig å dele opp konfigurasjonen lenger enn standardinndelingen etter noder. I utgangspunktet er dette nødvendig for pilotinnovasjoner og banal tilgangskontroll (når ikke alle administratorer har tilgang til alle noder i IT-infrastrukturen).
Hiera- hierarkisk database. Denne formuleringen kan være veldig skremmende. Dette er sannsynligvis grunnen til at det ble endret i dokumentasjonen til senere versjoner. Faktisk er dette en ekstremt enkel og praktisk mekanisme for å trekke ut konfigurasjon fra YAML- eller JSON-filer. Hierarki er muligheten til å spesifisere leserekkefølgen til flere konfigurasjonsfiler - dvs. hierarki/prioritet til disse filene.
- I tillegg til å hente data ved funksjonskall, trekker Puppet standard klasseparametere, som er hovedhøydepunktet.
- Selvfølgelig støtter Hiera faktainterpolering og til og med oppkalling av spesielle funksjoner.
- I Puppet 4.3 implementerte vi den samme funksjonaliteten igjen for å støtte ikke bare den globale databasen, men også den lokale for miljøet og modulen, selv om forfatteren allerede har funnet flere problemer i implementeringen deres (PUP-5983, PUP-5952 og PUP -5899), som umiddelbart ble fikset av Puppet Labs.
- Flere strategier støttes for å trekke ut verdier fra alle filer i hierarkiet:
  - først - den første verdien funnet av prioritet returneres
  - unik - samler alle verdier i en endimensjonal matrise og fjerner duplikater
  - hash - kombinerer alle funnet YAML Hash. Dupliserte nøkler velges etter prioritet.
  - dyp er egentlig en rekursiv versjon av hasj
- Det fine er at samplingsstrategien kan spesifiseres både når du kaller lookup()-funksjonen, fordi og i en hvilken som helst hierarkifil gjennom den spesielle lookup_options-nøkkelen, som brukes aktivt i cfnetwork-modulen.
PuppetDB- i hovedsak et lag med forretningslogikk rundt en relasjonsdatabase (PostgreSQL), som lar deg lagre rapporter om fakta og utførte distribusjoner og eksportere ressurser for påfølgende import til kataloger på andre noder eller valg via spesielle funksjoner. Det er også et nettgrensesnitt i form av Puppet Dashboard.
X.509 PKI- den allerede nevnte sertifikatinfrastrukturen, som er ekstremt praktisk å bruke for andre tjenester uten behov for å administrere en egen infrastruktur.
MCollective- ser ut til å være en nyttig ting for hendelsesbasert lansering av oppgaver på en serverfarm, men forfatteren har en viss mistillit til sikkerheten til en bestemt løsning.
Puppet Forge- en åpen plattform for publisering og nedlasting av moduler.
noen andre funksjoner i form av kontroller eksterne enheter type Cisco-utstyr og utplassering på bart metall, men det er en annen historie

Merknader om sikkerhet og tilgjengelighet

Du må forstå at Puppet Server blir et sårbart punkt i hele IT-infrastrukturen, fordi... bestemmer den endelige konfigurasjonen av alle systemer. I spesielle tilfeller er det fornuftig å gjøre en separasjon - en egen server for kritiske infrastrukturelementer med ekstremt begrenset tilgang og manuell oppdatering og den andre for alt annet.

Tilgjengeligheten til Puppet Server avgjør muligheten til å administrere hele infrastrukturen. Det er fornuftig å være vert for Puppet Server på en virtuell maskin i en mer pålitelig og raskt gjenopprettbar tredjepartssky enn dine egne evner. Eller du bør installere flere servere.

I alle fall bør du ikke installere andre tjenester på systemet der Puppet Server med bjeller og fløyter vil bli utplassert. Virtualisering og containerisering kan hjelpe deg.

Multi-master (flere separate Puppet Servers)

I dette tilfellet fungerer bare én server som en CA (sertifikatmyndighet) - utilgjengelighet betyr at det er umulig å legge til nye noder.
- Puppet lar deg bruke en tredjeparts X.509-infrastruktur hvis den innebygde ikke er tilfredsstillende.
Hele konfigurasjonen (Environment) må lagres i et versjonskontrollsystem og distribueres til hver server samtidig.
Det eneste som er felles er PostgreSQL-databasen, hvis organisering av høy tilgjengelighet ligger utenfor rammen av denne artikkelen.
cfpuppetserver-modulen støtter installasjoner som en primær (med CA) og som en sekundær server.

Hva vesentlig har endret seg siden eldre versjoner

Produsenten har en fullstendig beskrivelse.

Alle tjenester er flyttet til JVM, JRuby og Jetty. Til tross for de åpenbare fordelene med integrasjon, er det også ulemper med tanke på minneforbruk.
Lambda-funksjoner er lagt til for behandling av samlinger - nå er det ikke nødvendig å kutte krykker i Ruby eller pervertere via create_resources()
Et verktøy for å behandle EPP-maler har dukket opp - i hovedsak den samme ERB, men med Puppet DSL i stedet for Ruby,
Standard katalogstruktur for konfigurasjonsfiler har endret seg betydelig
Lagt til støtte for dataleverandører for miljøer og moduler (hack er ikke lenger nødvendig).
Nedtoning av rollen til det globale Hiera. Ny og relatert kommando er dukkeoppslag.

Installasjon

Denne prosessen er ganske primitiv, men krever at du følger en viss sekvens av trinn. Siden å gjøre dette manuelt er en utakknemlig oppgave, vil forfatteren lære deg noe dårlig, nemlig å laste ned uforståelige skript fra Internett og kjøre dem som root på systemet ditt.

De tre hovedserverkomponentene er selve Puppet Server, PuppetDB og PostgreSQL. De kan alle settes sammen i én node eller deles inn i to eller tre systemer. Puppet Server og Puppet DB kan kjøres flere ganger, men PostgeSQL er et enkelt feilpunkt. Det finnes ulike tilnærminger til PostgeSQL-replikering og clustering.En praktisk tilnærming for hoved- og sekundærservere vil være Master + Read-Only Slave, som støttes i selve PuppetDB som hoved- og skrivebeskyttet databasenode, men automatisering av f.eks. et oppsett tar tid og er derfor ennå ikke tilgjengelig inkludert i cfpuppetserver-modulen.

Selve konfigurasjonen kan enkelt lagres i det minste på filsystem sammen med Puppet Server, men det er som å skrive skript på en produksjonswebserver. Den mest passende løsningen er et git-depot. r10k-verktøyet kan trekke alle grener av depotet og distribuere dem til Puppet Server som separate miljøer. r10k er ganske dårlig til å trekke avhengigheter, så bibliotekar-puppet brukes på toppen. Det er verdt å merke seg med en gang at det viktigste kanoniske dukkemiljøet er "produksjon". Derfor bør konfigurasjonslageret bruke en gren kalt "produksjon" i stedet for "master".

Systemkrav

Maskinvaren er beskrevet av produsenten selv. Cfpuppetserver-modulen støtter for øyeblikket bare Debian Jessie+ og Ubuntu Trusty+.

Konfigurasjon i Git

For r10k selv spiller ikke plasseringen av depotet så stor rolle - det viktigste er tilgjengeligheten. For eksempel, for testformål, kan depotet være vert på det samme systemet og få tilgang til via file:// . Et godt sted å starte er codingfuture/puppet-exampleenv konfigurasjonseksemplet.

Kloning av depotet: git clone https://github.com/codingfuture/puppet-exampleenv my-puppet-conf && cd my-puppet-conf
Installere Generelle innstillinger administratortilgang ved å bruke hint i kommentarene:
- $EDITOR data/common.yaml
La oss lage en nodekonfigurasjon:
- $MY_DOMAIN - rotdomenenavn (for eksempel example.org)
- $HOST_NAME – klientvertsnavn uten domene
- mkdir data/$MY_DOMAIN
- cp data/example.com/puppet.yaml data/$(MY_DOMAIN)/puppet.yaml
- $EDITOR nano -w data/$(MY_DOMAIN)/puppet.yaml - sette opp en node med Puppet Server i henhold til forslag i kommentarene
- cp data/example.com/host.yaml data/$(MY_DOMAIN)/$(HOST_NAME).yaml
- $EDITOR nano -w data/$(MY_DOMAIN)/$(HOST_NAME).yaml - sette opp en vilkårlig node basert på forslag i kommentarene
Vi pusher til vår egen Git-server eller gjør den tilgjengelig lokalt på en node med Puppet Server via rsync eller scp. Et lokalt depot er praktisk som et mellomtrinn til Git-serveren er distribuert fra selve Puppet. På en måte minner dette om å sette sammen en kompilator i flere trinn.

Installere fra bunnen av på et rent system

Cfpuppetserver-modulen lar deg installere alt ved å bruke Puppet selv, men for den første installasjonen dupliseres de grunnleggende operasjonene av et Bash-skript.

På målsystemet:

Last ned installasjonsskriptet: wget https://raw.githubusercontent.com/codingfuture/puppet-cfpuppetserver/master/setup_puppetserver.sh
Vi ser gjennom skriptet og rynker: mindre setup_puppetserver.sh
Kjør: bash setup_puppetserver.sh
marionett.$(MY_DOMAIN) .
- Eksempel med et eksternt depot: bash setup_puppetserver.sh ssh:// [e-postbeskyttet]/puppet-conf
- Eksempel med lokal: bash setup_puppetserver.sh file:///root/puppetconf/
Vi ser hvordan systemet blåser opp og ikke installerer alt veldig raskt.
Hvis depotet er eksternt:
- Lag en SSH-nøkkel for root: ssh-keygen -t rsa -b 2048
- Vi registrerer den offentlige nøkkelen /root/.ssh/id_rsa.pub på den eksterne Git-serveren...
- ... og der satte vi opp en Git-hook ved å kalle følgende kommando: /usr/bin/ssh -T deploypuppet@puppet.$(MY_DOMAIN) ./puppetdeploy.sh
Vi begynner å distribuere konfigurasjonen manuelt: /etc/puppetlabs/deploy.sh
La oss prøve hvordan det fungerer på selve serveren: /opt/puppetlabs/bin/puppet agent --test
Sjekk nettverksinnstillingene dine, overspenningsvern og SSH-tilgang

Legger til administrerte noder

Puppet Servers fullt kvalifiserte navn må være tilgjengelig via DNS på den administrerte verten eller hardkodet til /etc/hosts.
- Eksempel: echo "128.1.1.1 puppet.example.com" >> /etc/hosts
På noden med Puppet Server, kjør følgende skript /root/genclientinit.sh $(HOST_NAME).$(MY_DOMAIN) .
Kopier hele resultatet og lim det inn kommandolinje på målsystemet.
Vi venter på slutten av kjøringen og kjører /opt/puppetlabs/bin/puppet agent --test . Ved første lansering vil en sertifikatsigneringsforespørsel genereres.
Vi går til Puppet Server-noden for å signere sertifikatet.
- puppet cert list - vi sjekker sertifikatsignaturen for ekstra paranoia.
- marionettsertifikattegn $(HOST_NAME).$(MY_DOMAIN) - faktisk signerer vi sertifikatet.
Vi går tilbake til den administrerte noden og kjører: /opt/puppetlabs/bin/puppet agent --test` igjen. Dette vil tvinge distribusjonsprosedyren til å starte.
Vi venter på at distribusjonen skal fullføres via Puppet Agent.
Det er det, du har en minimal Puppet-infrastruktur klar!

Eksempelutgang fra /root/genclientinit.sh

bash</etc/cflocation fi if test ! -z ""; deretter echo -n >/etc/cflocationpool fi if test ! -z "\$http_proxy"; eksporter deretter http_proxy eksport https_proxy="\$http_proxy" eksport HTTP_PROXY="\$http_proxy" eksport HTTPS_PROXY="\$http_proxy" fi echo host.example.com > /etc/vertsnavn vertsnavn host.example.com hvis ! hvilken lsb-utgivelse | lese; deretter apt-get install lsb-release fi kodenavn=\$(lsb_release -cs) hvis test -z "\$kodenavn"; deretter ekko "Kunnet ikke oppdage korrekt kodenavn" exit 1 fi wget https://apt.puppetlabs.com/puppetlabs-release-pc1-\$(kodenavn).deb dpkg -i puppetlabs-release-pc1-\$(kodenavn) .deb mkdir -p /etc/puppetlabs/puppet cat > /etc/puppetlabs/puppet/puppet.conf<puppet cert sign host.example.com" ekko "Bruk CTRL+C for å stoppe syklusen, hvis det mislykkes på grunn av forskjellige årsaker" søvn 5 ferdig EOT

Modulbeskrivelse

Komplett liste over Bash-parametere for det første installasjonsskriptet

~# ./setup_puppetserver.sh Bruk: ./setup_puppetserver.sh [ [ [ [] ] ] ]

r10k_repo_url - URI til Git-depotet
certname - fullt kvalifisert domenenavn til verten
cflocation - initialisering av faktum cf_location
cflocationpool - initialisering av fakta cf_location_pool
http_proxy - proxy-server for HTTP- og HTTPS-forespørsler

Komplett liste over Bash-parametere for Puppet-klientens init-skript

~# /root/genclientinit.sh Bruk: ./genclientinit.sh [ [ []]]
Betydningen av parametrene er den samme som i forrige skript.

cfpuppetserver-klassen

deployuser = "deploypuppet" - brukernavn for automatisk distribusjon av konfigurasjonsoppdateringer
deployuser_auth_keys = undef - liste over nøkler for $deployuser
repo_url = undef - repository URI (eksempel: ssh://user@host/repo eller file:///some/path)
puppetserver = true - om du vil installere Puppet Server-komponenten på denne noden
puppetdb = true - om PuppetDB-komponenten skal installeres på denne noden
puppetdb_port = 8081 - port for PuppetDB
setup_postgresql = true - om PostgreSQL-komponenten skal installeres på denne noden (bare hvis PuppetDB-installasjon er aktivert)
service_face = "any" - navnet på cfnetwork::iface-ressursen for å akseptere innkommende tilkoblinger
puppetserver_mem = auto - RAM for Puppet Server i megabyte (minimum 192MB)
puppetdb_mem = auto - RAM for PuppetDB i megabyte (minimum 192MB)
postgresql_mem = auto - RAM for PostgreSQL i megabyte (minimum 128MB)

klasse cfpuppetserver::puppetdb

postgresql_host = "localhost" - databaseadresse
postgresql_listen = $postgresql_host - verdien går direkte til listen_addresses PostgreSQL-direktivet
postgresql_port = 5432 - databaseport
postgresql_user = "puppetdb" - PuppetDB-bruker i databasen
postgresql_pass = "puppetdb" - passordet til PuppetDB-brukeren i databasen
postgresql_ssl = false - aktiver tilkoblingskryptering basert på Puppet PKI-sertifikater

klasse cfpuppetserver::puppetserver

autosign = false - BØR IKKE brukes i et kampmiljø, unntatt kanskje i DMZ. Eksisterer utelukkende for testautomatisering.
global_hiera_config = "cfpuppetserver/hiera.yaml" - banen til standard Hiera-konfigurasjonsfil i henhold til Puppet-kanoner (den første komponenten er navnet på modulen, resten er banen under filene/mappen i modulen)

Du kan hjelpe og overføre noen midler til utviklingen av nettstedet

Å administrere et stort antall Unix-systemer kan ikke kalles praktisk. For å endre én parameter må administratoren kontakte hver maskin; skript kan bare hjelpe delvis, og ikke i alle situasjoner.

Det bør erkjennes at Windows-nettverksadministratorer fortsatt er i en mer fordelaktig posisjon. Det er nok å endre gruppepolicyinnstillingene, og etter en stund vil alle datamaskiner på nettverket, inkludert de med et nylig installert operativsystem, "lære" om innovasjonen, hvis det gjelder dem, selvfølgelig. Når du ser tilbake på den lange perioden med Unix-utvikling, vil du legge merke til at ingenting som dette noen gang har fanget opp. Det finnes løsninger som kickstart som hjelper med den første installasjonen operativsystem, men ytterligere foredling vil kreve betydelig innsats. Kommersielle løsninger som BladeLogic og OpsWare løser bare delvis problemet med å automatisere innstillinger; deres største fordel er tilgjengeligheten GUI, og de kan bare kjøpes fra store organisasjoner. Det finnes selvfølgelig prosjekter som tilbyr gratisløsninger, men gjennom hele deres eksistens har de aldri klart å skape et stort fellesskap. For eksempel er Cfengine ikke veldig populær blant administratorer, selv om den i tillegg til Linux kan brukes i *BSD, Windows og Mac OS X. Dette kan skyldes den relative kompleksiteten ved å lage konfigurasjoner. Når du beskriver oppgaver, må du ta hensyn til funksjonene til hvert spesifikke system og manuelt kontrollere sekvensen av handlinger når du utfører kommandoer. Det vil si at administratoren må huske at for noen systemer bør du skrive adduser for andre, useradd, ta hensyn til plasseringen av filer på forskjellige systemer, og så videre. Dette kompliserer prosessen med å skrive kommandoer i en størrelsesorden; det er veldig vanskelig å lage den riktige konfigurasjonen med en gang, og det er nesten umulig å lese de opprettede konfigurasjonene etter en stund. Til tross for GPL-lisensen er Cfengine faktisk et enmannsprosjekt som kontrollerer alle endringer og er lite interessert i å bygge et åpent samfunn. Som et resultat er egenskapene til cfengine ganske tilfredsstillende for utvikleren, men for andre administratorer er det heller en ekstra hodepine. For å forbedre cfengine ble forskjellige tillegg laget av tredjepartsutviklere, noe som ofte bare gjorde situasjonen verre. Forfatteren av flere slike moduler for cfengine, Luke Kanies, bestemte seg til slutt for å utvikle et lignende verktøy, men uten mange av cfengines mangler.

Dukkefunksjoner

Puppet, som cfengine, er et klient-serversystem som bruker et deklarativt, det vil si obligatorisk språk for å beskrive oppgaver og biblioteker for implementeringen av dem. Klienter kobler seg med jevne mellomrom (30 minutter som standard) til den sentrale serveren og mottar den siste konfigurasjonen. Hvis de mottatte innstillingene ikke samsvarer med systemtilstanden, vil de bli utført, og om nødvendig vil en rapport om utførte operasjoner bli sendt til serveren. Serveren kan lagre meldinger til syslog eller en fil, lage en RRD-graf og sende dem til en spesifisert e-post. Ytterligere transaksjons- og ressursabstraksjonslag gir maksimal kompatibilitet med eksisterende innstillinger og applikasjoner, slik at du kan fokusere på systemobjekter uten å bekymre deg for forskjeller i implementering og beskrivelse av detaljerte kommandoer og filformater. Administratoren opererer kun med objekttypen, Puppet tar seg av resten. Dermed vet pakketypen om 17 pakkesystemer; det nødvendige vil bli gjenkjent automatisk basert på informasjon om versjonen av distribusjonen eller systemet, selv om pakkebehandleren kan tvinges om nødvendig.

I motsetning til skript, som ofte ikke er mulig å bruke på andre systemer, vil Puppet-konfigurasjoner skrevet av tredjepartsadministratorer for det meste fungere uten problemer på andre nettverk. I Puppet CookBook [ http://www.reductivelabs.com/trac/puppet/tags/puppet%2Crecipe] finnes det allerede tre dusin ferdige oppskrifter. Puppet støtter for tiden offisielt følgende operativsystemer og tjenester: Debian, RedHat/Fedora, Solaris, SUSE, CentOS, Mac OS X, OpenBSD, Gentoo og MySQL, LDAP.

Dukkespråk

For å komme videre må du først forstå de grunnleggende elementene og egenskapene til språket. Språk er en av styrker Dukke. Med dens hjelp beskrives ressursene som administratoren planlegger å administrere og handlinger. I motsetning til de fleste lignende løsninger, lar Puppet språket forenkle tilgangen til alle lignende ressurser på ethvert system i et heterogent miljø. En ressursbeskrivelse består vanligvis av navn, type og attributter. La oss for eksempel peke på filen /etc/passwd og angi attributtene:

file("/etc/passwd":

eier => rot,

gruppe => rot,

Nå vil klienter, etter å ha koblet til serveren, kopiere filen /etc/passwd og installere de spesifiserte attributtene. Du kan definere flere ressurser i én regel, og skille dem med et semikolon. Hva skal jeg gjøre hvis konfigurasjonsfilen som brukes på serveren er forskjellig fra klienten eller ikke brukes i det hele tatt? For eksempel kan denne situasjonen oppstå når VPN-innstillinger forbindelser. I dette tilfellet kan filen pekes på ved å bruke kildedirektivet. Det er to alternativer her, som vanlig, for å spesifisere banen til en annen fil; to URI-protokoller støttes også: fil og marionett. I det første tilfellet, en lenke til en ekstern NFS server, i det andre alternativet lanseres en NFS-lignende tjeneste på Puppet-serveren, som eksporterer ressurser. I det siste tilfellet er standardbanen i forhold til marionettens rotkatalog - /etc/puppet. Det vil si at lenken puppet://server.domain.com/config/sshd_config vil tilsvare filen /etc/puppet/config/sshd_config. Du kan overstyre denne katalogen ved å bruke filebucket-direktivet, selv om det er mer riktig å bruke delen med samme navn i filen /etc/puppet/fileserver.conf. I dette tilfellet kan du begrense tilgangen til tjenesten bare fra bestemte adresser. La oss for eksempel beskrive konfigurasjonsdelen.

bane /var/puppet/config

tillat *.domene.com

tillat 192.168.0.*

tillate 192.168.1.0/24

nekte *.wireless.domain.com

Og så går vi til denne delen når vi beskriver ressursen.

kilde => "puppet://server.domain.com/config/sshd_config"

Før kolon er navnet på ressursen. I de enkleste tilfellene kan du ganske enkelt spesifisere et alias eller variabler som et navn. Aliaset settes ved hjelp av aliasdirektivet. full bane til filen. I mer komplekse konfigurasjoner

file("/etc/passwd":

alias => passwd

Et annet alternativ for å lage et alias er bra når du må forholde deg til forskjellige operativsystemer. La oss for eksempel lage en ressurs som beskriver sshd_config-filen:

fil(sshdconfig:

navn => $operativsystem ? (

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

default => "/etc/ssh/sshd_config"

I dette eksemplet står vi overfor et valg. Filen for Solaris er spesifisert separat, for alle andre vil filen /etc/ssh/sshd_config bli valgt. Nå kan denne ressursen nås som sshdconfig, avhengig av operativsystemet vil den ønskede banen bli valgt. For eksempel indikerer vi at hvis sshd-demonen kjører og mottas ny fil, bør du starte tjenesten på nytt.

sikre => sant,

abonner => Fil

Variabler brukes ofte når man arbeider med brukerdata. For eksempel beskriver vi plasseringen av brukerhjemmekataloger:

$homeroot = "/hjem"

Nå kan filene til en spesifikk bruker åpnes som

$(homeroot)/$navn

$name-parameteren vil bli fylt med brukerens kontonavn. I noen tilfeller er det praktisk å definere en standardverdi for en type. For eksempel, for exec-typen, angir de ofte katalogene der den skal se etter den kjørbare filen:

Exec (bane => "/usr/bin:/bin:/usr/sbin:/sbin")

Hvis du trenger å peke på flere nestede filer og kataloger, kan du bruke parameteren recurse.

file("/etc/apache2/conf.d":

kilde => "puppet:// puppet://server.domain.com/config/apache/conf.d",

gjentakelse => "sant"

Flere ressurser kan kombineres til klasser eller definisjoner. Klasser er en fullstendig beskrivelse av et system eller en tjeneste og brukes separat.

"/etc/passwd": eier => rot, gruppe => rot, modus => 644;

"/etc/shadow": eier => rot, gruppe => rot, modus => 440

Som i objektorienterte språk, kan klasser overstyres. For eksempel, på FreeBSD er gruppeeieren av disse filene wheel. Derfor, for ikke å skrive om ressursen fullstendig, la oss lage en ny klasse freebsd, som vil arve linux-klassen:

klasse freebsd arver linux (

Fil[“/etc/passwd”] ( gruppe => hjul );

Fil[“/etc/shadow”] ( gruppe => hjul )

For enkelhets skyld kan alle klasser plasseres i en egen fil, som kan kobles til ved hjelp av include-direktivet. Definisjoner kan ta flere parametere som argumenter, men støtter ikke arv og brukes når du skal beskrive gjenbrukbare objekter. La oss for eksempel definere hjemmekatalogen til brukere og kommandoene som er nødvendige for å opprette en ny konto.

definer user_homedir ($group, $fullname, $ingroups) (

bruker("$navn":

sikre => presentere,

kommentar => "$fullnavn",

gid => "$gruppe",

grupper => $ingroups,

medlemskap => minimum,

skall => "/bin/bash",

home => "/hjem/$navn",

kreve => Gruppe[$group],

exec("$name homedir":

kommando => “/bin/cp -R /etc/skel /home/$name; /bin/chown -R $navn:$gruppe /hjem/$navn",

oppretter => "/hjem/$navn",

krever => Bruker[$navn],

Nå for å lage en ny regnskap bare kontakt user_homedir.

user_homedir("sergej":

gruppe => "sergej",

fullt navn => "Sergej Jaremchuk",

ingroups => ["media", "admin]

Det er separate beskrivelser av noder som støtter arv som klasser. Når en klient kobler til Puppet-serveren, vil den korresponderende nodeseksjonen bli søkt, og innstillinger som kun er spesifikke for denne datamaskinen vil bli gitt. For å beskrive alle andre systemer kan du bruke nodestandard. En beskrivelse av alle typer er gitt i "Typereferanse"-dokumentet, som i alle fall må leses, i det minste for å forstå alle egenskapene til dukkespråket. Forskjellige typer tillate deg å utføre spesifiserte kommandoer, inkludert når visse betingelser er oppfylt (for eksempel endre en konfigurasjonsfil), arbeide med cron, brukerlegitimasjon og grupper, datamaskiner, montere ressurser, starte og stoppe tjenester, installere, oppdatere og fjerne pakker, arbeide med SSH-nøkler, Solaris-soner og så videre. Så enkelt er det å tvinge listen over pakker i distribusjoner med apt til å oppdateres hver dag mellom 2 og 4 timer.

tidsplan (daglig:

periode => daglig,

rekkevidde =>

exec("/usr/bin/apt-get update":

timeplan => daglig

Oppdateringen for den perioden vil kun utføres av hvert system én gang, hvoretter oppgaven anses som fullført og vil bli slettet fra klientdatamaskinen. Puppet-språket støtter andre kjente strukturer: forhold, funksjoner, matriser, kommentarer og lignende.

Installerer Puppet

Puppet krever Ruby (>= 1.8.1) med OpenSSL-støtte og XMLRPC-biblioteker, samt Faster-biblioteket [ http://reductivelabs.com/projects/facter]. Ubuntu 7.04-depotet som ble brukt til testinstallasjonen inkluderte allerede valpepakken.

$ sudo apt-cache søkedukke

marionett — sentralisert konfigurasjonsadministrasjon for nettverk

puppetmaster - sentralisertemon

Under installasjonen vil alle nødvendige avhengighetspakker bli installert: facter libopenssl-ruby libxmlrpc-ruby.

$ sudo apt-get install puppet puppetmaster

Du kan sjekke tilgjengeligheten til Ruby-biblioteker med kommandoen.

$ ruby -ropenssl -e "puts:yep"

~$ ruby -rxmlrpc/client -e "puts:yep"

Hvis ingen feil mottas, er alt du trenger allerede inkludert. Filer som beskriver ønsket konfigurasjon av systemer kalles manifester i Puppet-terminologi. Når den startes, prøver demonen å lese filen /etc/puppet/manifests/site.pp; hvis den mangler, viser den en advarsel. Når du tester, kan du fortelle daemonen å fungere i frakoblet modus, i så fall er manifestet ikke nødvendig

$ sudo /usr/bin/puppetmasterd --nonodes

Om nødvendig kan du koble andre filer til site.pp, for eksempel med klassebeskrivelser. For en testkjøring kan du legge inn de enkleste instruksjonene i denne filen.

file("/etc/sudoers":

eier => rot,

gruppe => rot,

Alle konfigurasjonsfiler for både serveren og klientene ligger i /etc/puppet. Fileserver.conf-filen som vi snakket om ovenfor er valgfri og brukes bare hvis Puppet også vil fungere som en filserver. På Ubuntu eksporterer denne filen /etc/puppet/files underkatalogen. ssl-underkatalogen inneholder sertifikater og nøkler som vil bli brukt til kryptering ved tilkobling av klienter. Nøkler opprettes automatisk første gang du starter puppetmasterd; du kan lage dem manuelt med kommandoen.

$ sudo /usr/bin/ puppetmasterd --mkusers.

Filene puppetd.conf og puppetmasterd.conf er like. De indikerer noen parametere for driften av demoner på klientsystemet og serveren. Klientfilen er forskjellig bare i nærvær av serverparameteren, som peker til datamaskinen som puppetmasterd kjører på.

server = grinder.com

logdir = /var/log/puppet

vardir = /var/lib/puppet

rundir = /var/run

# send en rapport til serveren

For å unngå å skrive alt manuelt, kan du lage en mal ved å bruke puppetd selv.

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

På samme måte kan du opprette site.pp på serveren.

$ puppetd --genmanifest > /etc/puppet/manifests/site.pp

En annen fil, tagmail.conf, lar deg spesifisere e-postadressene rapportene skal sendes til. I det enkleste tilfellet kan du bruke en linje.

alle: [e-postbeskyttet]

Konfigurasjonsfilene er ikke nok til at klienten kan koble seg til serveren. For å gjøre dette må du også signere sertifikatene. Først, for å gi serveren beskjed om den nye datamaskinen på klientsystemet, skriv inn kommandoen:

$ sudo puppetd --server grinder.com --waitforcert 60 --test

info: Ber om sertifikat

advarsel: Peer-sertifikat vil ikke bli bekreftet i denne SSL-økten

varsel: Fikk ikke sertifikat

Hvis en annen linje returneres, bør du sjekke driften av serveren.

$ ps aux | grep marionett

dukke 5779 0,0 1,4 27764 15404 ? Ssl 21:49 0:00 ruby/usr/sbin/puppetmasterd

Brannmuren må tillate tilkoblinger på port 8140.

På serveren mottar vi en liste over sertifikater som må signeres.

$ sudo puppetca --liste

nomad.grinder.com

Og vi signerer klientsertifikatet.

$ sudo puppetca –sign nomad.grinder.com

Nå kan klienten fritt koble til serveren og motta innstillinger.

Dessverre er det rett og slett ikke mulig å vise alle egenskapene til Puppet i artikkelen. Men som du kan se, er dette et funksjonelt og fleksibelt verktøy som lar deg løse de fleste problemene med samtidig administrasjon av et stort antall systemer. Hvis din arbeidslinje krever at du setter opp flere systemer. Og viktigst av alt, prosjektet klarte å samle et lite, men stadig voksende samfunn. La oss derfor håpe at en god idé ikke får lov til å dø eller gå til side.

Dukke er en kryssplattformstruktur som tillater systemadministratorer Utfør vanlige oppgaver ved hjelp av kode. Koden lar deg utføre ulike oppgaver fra å installere nye programmer til å sjekke filtillatelser eller oppdatere brukerkontoer. Dukke overlegen ikke bare under den første installasjonen av systemet, men gjennom hele systemets livssyklus. I de fleste tilfeller marionett brukes i klient/server-konfigurasjon.

Denne delen viser installasjon og konfigurasjon Dukke i en klient/server-konfigurasjon. Dette enkle eksemplet viser hvordan du installerer Apache ved hjelp av Dukke.

Installasjon

For installasjon Dukke skriv inn i terminal:

Sudo apt-get install puppetmaster

På klientmaskinen(e) skriver du inn:

Sudo apt-get install marionett

Innstillinger

Før du setter opp dukke, vil du kanskje legge til en oppføring DNS CNAME Til puppet.example.com, Hvor eksempel.com- dette er ditt domene. Standard klienter Dukke sjekk DNS for puppet.example.com som dukkeservernavnet ( Dukke mester). Se Domain Name Service for ytterligere detaljer om bruk av DNS.

Hvis du ikke har tenkt å bruke DNS, kan du legge til oppføringer i filen /etc/hosts på serveren og klienten. For eksempel i filen /etc/hosts Dukke server legge til:

127.0.0.1 localhost.localdomain localhost marionett 192.168.1.17 meercat02.example.com meercat02

På hver Dukke I klienten legger du til en oppføring for serveren:

192.168.1.16 meercat.example.com meercat marionett

Bytt ut IP-adresser og domenenavn fra eksempelet til dine nåværende adresser og navn på serveren og klientene.

La oss nå sette opp noen ressurser for apache2. Opprett en fil /etc/puppet/manifests/site.pp som inneholder følgende:

Pakke ("apache2": sikre => installert) tjeneste ("apache2": sikre => true, aktiver => true, require => Pakke["apache2"])

Node "meercat02.example.com" (inkluder apache2)

Erstatte meercat02.example.com til ditt nåværende navn Dukke klient.

Det siste trinnet for dette enkle Dukke serveren skal starte tjenesten på nytt:

Sudo /etc/init.d/puppetmaster restart

Nå på Dukke alt er konfigurert på serveren og det er på tide å konfigurere klienten.

Først, la oss konfigurere tjenesten Dukke agent å lansere. Rediger /etc/default/puppet, og erstatter verdien START på ja:

Sudo /etc/init.d/puppet start

La oss gå tilbake til Dukke server for å signere klientsertifikatet ved å bruke kommandoen:

Sudo puppetca --sign meercat02.example.com

Kryss av /var/log/syslog for eventuelle konfigurasjonsfeil. Hvis alt gikk bra, pakken apache2 og dens avhengigheter vil bli installert til Dukke klient.

Dette eksemplet er veldig enkelt og viser ikke mange av funksjonene og fordelene. Dukke. Til tilleggsinformasjon se

Sergey Yaremchuk

Sentralisert konfigurasjon av UNIX-systemer ved bruk av Puppet

Å administrere et stort antall UNIX-systemer kan ikke kalles praktisk. For å endre én parameter må administratoren kontakte hver maskin; skript kan bare hjelpe delvis, og ikke i alle situasjoner.

Det bør erkjennes at Windows-nettverksadministratorer fortsatt er i en mer fordelaktig posisjon. Det er nok å endre gruppepolicyinnstillingene, og etter en stund vil alle datamaskiner på nettverket, inkludert de med et nylig installert operativsystem, "lære" om innovasjonen, hvis det gjelder dem, selvfølgelig. Når du ser tilbake på den lange perioden med UNIX-utvikling, kan du se at ingenting som dette noen gang har fanget opp. Det finnes løsninger som kickstart som hjelper med den første installasjonen av operativsystemet, men videre utvikling vil kreve betydelig innsats. Kommersielle løsninger, som BladeLogic og OpsWare, løser problemet med å automatisere innstillinger bare delvis; deres største fordel er tilstedeværelsen av et grafisk grensesnitt, og bare store organisasjoner har råd til å kjøpe dem. Det finnes selvfølgelig prosjekter som tilbyr gratisløsninger, men gjennom hele deres eksistens har de ikke klart å skape et stort fellesskap. For eksempel er Cfengine ikke veldig populær blant administratorer, selv om den i tillegg til Linux kan brukes i *BSD, Windows og Mac OS X. Dette kan skyldes den relative kompleksiteten ved å lage konfigurasjoner. Når du beskriver oppgaver, er det nødvendig å ta hensyn til egenskapene til hvert spesifikt system og manuelt kontrollere sekvensen av handlinger når du utfører kommandoer. Det vil si at administratoren må huske at for noen systemer bør du skrive adduser, for andre - useradd, ta hensyn til plasseringen av filer på forskjellige systemer, og så videre. Dette kompliserer prosessen med å skrive kommandoer i en størrelsesorden; det er veldig vanskelig å lage den riktige konfigurasjonen med en gang, og det er nesten umulig å lese de opprettede konfigurasjonene etter en stund. Til tross for GPL-lisensen er Cfengine i hovedsak et enmannsprosjekt som kontrollerer alle endringer og er lite interessert i å bygge et åpent samfunn. Som et resultat er egenskapene til Cfengine ganske tilfredsstillende for utvikleren, men for andre administratorer er det heller en ekstra hodepine. For å forbedre Cfengine ble forskjellige tillegg laget av tredjepartsutviklere, noe som ofte bare gjorde situasjonen verre. Forfatteren av flere slike moduler for Cfengine, Luke Kanies, bestemte seg til slutt for å utvikle et lignende verktøy, men uten mange av manglene til Cfengine.

Dukkefunksjoner

Puppet, som Cfengine, er et klient-serversystem som bruker et deklarativt språk for å beskrive oppgaver og biblioteker for å implementere dem. Klienter kobler seg med jevne mellomrom (hvert 30. minutt som standard) til den sentrale serveren og mottar den siste konfigurasjonen. Hvis de mottatte innstillingene ikke samsvarer med systemtilstanden, vil de bli utført, og om nødvendig vil en rapport om utførte operasjoner bli sendt til serveren. Meldingsserveren kan lagre den i syslog eller en fil, lage en RRD-graf og sende den til den angitte e-posten. Ytterligere transaksjons- og ressursabstraksjonslag gir maksimal kompatibilitet med eksisterende innstillinger og applikasjoner, slik at du kan fokusere på systemobjekter uten å bekymre deg for forskjeller i implementering og beskrivelse av detaljerte kommandoer og filformater. Administratoren opererer kun med objekttypen, Puppet tar seg av resten. Dermed kjenner pakketypen til om 17 pakkesystemer; det nødvendige vil automatisk gjenkjennes basert på informasjon om versjonen av distribusjonen eller systemet, selv om pakkebehandlingen om nødvendig kan settes med makt.

I motsetning til skript, som ofte er umulige å bruke på andre systemer, vil Puppet-konfigurasjoner skrevet av tredjepartsadministratorer stort sett fungere uten problemer på andre nettverk. Puppet CookBook har allerede tre dusin ferdige oppskrifter. Puppet støtter for tiden offisielt følgende operativsystemer og tjenester: Debian, RedHat/Fedora, Solaris, SUSE, CentOS, Mac OS X, OpenBSD, Gentoo og MySQL, LDAP.

Dukkespråk

For å komme videre må du først forstå de grunnleggende elementene og egenskapene til språket. Språk er en av Puppets styrker. Den beskriver ressursene som administratoren planlegger å administrere og handlingene de tar. I motsetning til de fleste lignende løsninger, lar Puppet språket forenkle tilgangen til alle lignende ressurser på ethvert system i et heterogent miljø. En ressursbeskrivelse består vanligvis av navn, type og attributter. La oss for eksempel peke på filen /etc/passwd og angi attributtene:

file("/etc/passwd":

Eier => rot,

Gruppe => rot,

Modus => 644,

Nå vil klienter som kobler til serveren kopiere /etc/passwd-filen og angi de angitte attributtene. Du kan definere flere ressurser i én regel, og skille dem med et semikolon. Men hva om konfigurasjonsfilen som brukes på serveren er forskjellig fra klienten eller ikke brukes i det hele tatt? For eksempel kan denne situasjonen oppstå når du setter opp VPN-tilkoblinger. I dette tilfellet bør du peke på filen ved å bruke kildedirektivet. Det er to alternativer her; du kan, som vanlig, spesifisere banen til en annen fil, og også bruke de to støttede URI-protokollene: fil og marionett. I det første tilfellet brukes en kobling til en ekstern NFS-server, i det andre alternativet startes en NFS-lignende tjeneste på Puppet-serveren, som eksporterer ressurser. I det siste tilfellet er standardbanen i forhold til marionettens rotkatalog – /etc/puppet. Det vil si at lenken puppet://server.domain.com/config/sshd_config vil tilsvare filen /etc/puppet/config/sshd_config. Du kan overstyre denne katalogen ved å bruke filebucket-direktivet, selv om det er mer riktig å bruke delen med samme navn i filen /etc/puppet/fileserver.conf. I dette tilfellet kan du begrense tilgangen til tjenesten til bare bestemte adresser. La oss for eksempel beskrive konfigurasjonsdelen:

Bane /var/puppet/config

Tillat *.domain.com

Tillat 127.0.0.1

Tillat 192.168.0.*

Tillat 192.168.1.0/24

Avslå *.wireless.domain.com

Og så refererer vi til denne delen når vi beskriver ressursen:

kilde => "puppet://server.domain.com/config/sshd_config"

Før kolon er navnet på ressursen. I de enkleste tilfellene kan du ganske enkelt angi hele banen til filen som navn. I mer komplekse konfigurasjoner er det bedre å bruke et alias eller variabler. Aliaset er satt ved å bruke aliasdirektivet:

file("/etc/passwd":

Alias => passwd

Et annet alternativ for å lage et alias er bra når du må forholde deg til forskjellige operativsystemer. La oss for eksempel lage en ressurs som beskriver sshd_config-filen:

fil(sshdconfig:

Navn => $operativsystem ? (

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

Standard => "/etc/ssh/sshd_config"

tjeneste(sshd:

Sørg for => sant,

Abonner => Fil

Variabler brukes ofte når man arbeider med brukerdata. For eksempel beskriver vi plasseringen av brukerhjemmekataloger:

$homeroot = "/hjem"

Nå kan filene til en spesifikk bruker nås som:

$(homeroot)/$navn

$name-parameteren vil bli fylt med brukerens kontonavn. I noen tilfeller er det praktisk å definere en standardverdi for en type. For eksempel, for exec-typen er det veldig vanlig å spesifisere katalogene der den skal se etter den kjørbare filen:

Exec ( bane => "/usr/bin:/bin:/usr/sbin:/sbin" )

Hvis du trenger å peke på flere nestede filer og kataloger, kan du bruke recurse-parameteren:

file("/etc/apache2/conf.d":

Kilde => "puppet:// puppet://server.domain.com/config/apache/conf.d",

Gjentakelse => "sant"

Flere ressurser kan kombineres til klasser eller definisjoner. Klasser er en fullstendig beskrivelse av et system eller en tjeneste og brukes separat:

klasse linux (

Fil(

"/etc/passwd": eier => rot, gruppe => rot, modus => 644;

"/etc/shadow": eier => rot, gruppe => rot, modus => 440

klasse freebsd arver linux (

Fil["/etc/passwd"] ( gruppe => hjul );

Fil["/etc/shadow"] ( gruppe => hjul )

For enkelhets skyld kan alle klasser plasseres i en egen fil, som må inkluderes ved å bruke include-direktivet. Definisjoner kan ta flere parametere som argumenter, men støtter ikke arv og brukes når du skal beskrive gjenbrukbare objekter. La oss for eksempel definere brukerens hjemmekatalog og kommandoene som trengs for å opprette en ny konto:

definer user_homedir ($group, $fullname, $ingroups) (

Bruker("$navn":

Sørg for => presentere,

Kommentar => "$fullnavn",

Gid => "$gruppe",

Grupper => $ingroups,

Medlemskap => minimum,

Shell => "/bin/bash",

Hjem => "/hjem/$navn",

Krev => Gruppe[$group],

Exec("$name homedir":

Kommando => "/bin/cp -R /etc/skel /home/$name; /bin/chown -R $name:$group /home/$name",

Oppretter => "/home/$name",

Krev => Bruker[$name],

Nå, for å opprette en ny konto, bare kontakt user_homedir:

user_homedir("sergej":

Gruppe => "sergej",

Fullt navn => "Sergej Jaremchuk",

Ingroups => ["media", " admin]

Det er separate beskrivelser av noder som støtter arv, samt klasser. Når en klient kobler til Puppet-serveren, vil den korresponderende nodeseksjonen bli søkt, og innstillinger som kun er spesifikke for denne datamaskinen vil bli gitt. For å beskrive alle andre systemer kan du bruke nodestandard. En beskrivelse av alle typer er gitt i "Typereferanse"-dokumentet, som i alle fall må leses, i det minste for å forstå alle egenskapene til dukkespråket. Ulike typer lar deg utføre spesifiserte kommandoer, inkludert når visse betingelser er oppfylt (for eksempel endring av en konfigurasjonsfil), arbeid med cron, brukerlegitimasjon og grupper, datamaskiner, montere ressurser, starte og stoppe tjenester, installere, oppdatere og fjerne pakker , arbeider med SSH-nøkler, Solaris-soner og så videre. Slik kan du enkelt tvinge listen over pakker i distribusjoner ved å bruke apt til å oppdateres daglig mellom 2 og 4 timer:

tidsplan (daglig:

Periode => daglig,

Rekkevidde =>

exec("/usr/bin/apt-get update":

Timeplan => daglig

Installerer Puppet

Puppet krever Ruby (versjon 1.8.1 og nyere) med OpenSSL-støtte og XMLRPC-biblioteker, samt Faster-biblioteket. Ubuntu 7.04-depotet som ble brukt til testinstallasjonen inkluderer allerede valpepakken:

$ sudo apt-cache søkedukke

~$ ruby -rxmlrpc/client -e "puts:yep"

jepp

Hvis ingen feil mottas, er alt du trenger allerede inkludert. Filer som beskriver ønsket konfigurasjon av systemer kalles manifester i Puppet-terminologi. Når den startes, prøver demonen å lese filen /etc/puppet/manifests/site.pp; hvis den mangler, viser den en advarsel. Når du tester, kan du fortelle daemonen å kjøre i frittstående modus, som ikke krever et manifest:

$ sudo /usr/bin/puppetmasterd --nonodes

Om nødvendig kan du koble andre filer til site.pp, for eksempel med klassebeskrivelser. For en testkjøring kan du legge inn de enkleste instruksjonene i denne filen.

klasse sudo (

File("/etc/sudoers":

Eier => rot,

Gruppe => rot,

Modus => 440,

node standard(

Inkluder sudo

Alle konfigurasjonsfiler, både server og klient, ligger i /etc/puppet. Fileserver.conf-filen, som vi allerede har snakket om, er valgfri og brukes bare hvis Puppet også vil fungere som en filserver. På Ubuntu eksporterer denne filen /etc/puppet/files underkatalogen. ssl-underkatalogen inneholder sertifikater og nøkler som vil bli brukt til kryptering ved tilkobling av klienter. Nøkler opprettes automatisk første gang du starter puppetmasterd; du kan lage dem manuelt med kommandoen:

$ sudo /usr/bin/puppetmasterd --mkusers

Filene puppetd.conf og puppetmasterd.conf er like. De indikerer noen parametere for driften av demoner på klientsystemet og serveren. Klientfilen skiller seg bare i nærvær av serverparameteren, som peker til datamaskinen som puppetmasterd kjører på:

server = grinder.com

logdir = /var/log/puppet

vardir = /var/lib/puppet

rundir = /var/run

# send en rapport til serveren

rapport = sant

For å unngå å skrive alt manuelt, kan du lage en mal ved å bruke puppetd selv:

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

På samme måte kan du opprette site.pp på serveren:

$ puppetd --genmanifest > /etc/puppet/manifests/site.pp

En annen fil, tagmail.conf, lar deg spesifisere e-postadresser som rapporter skal sendes til. I det enkleste tilfellet kan du bruke en linje:

alle: [e-postbeskyttet]

Konfigurasjonsfilene er ikke nok til at klienten kan koble seg til serveren. For å gjøre dette må du også signere sertifikatene.

Først, for å fortelle serveren om den nye datamaskinen, skriv inn kommandoen på klientsystemet:

$ sudo puppetd --server grinder.com --waitforcert 60 –test

Brannmuren må tillate tilkoblinger på port 8140.

På serveren får vi en liste over sertifikater som må signeres:

$ sudo puppetca –liste

nomad.grinder.com

Og signer klientsertifikatet:

$ sudo puppetca –sign nomad.grinder.com

Nå kan klienten fritt koble til serveren og motta innstillinger.

Dessverre er det umulig å vise alle egenskapene til Puppet i artikkelen. Men som du kan se, er dette et funksjonelt og fleksibelt verktøy som lar deg løse de fleste problemene med samtidig administrasjon av et stort antall systemer. Og viktigst av alt, prosjektet klarte å samle et lite, men stadig voksende samfunn. La oss derfor håpe at en god idé ikke får lov til å dø eller gå til side.

Lykke til!