Dukkeopplæring for nybegynnere: Hva er dukke og hvordan du bruker?

Før vi lærer Puppet, la oss forstå:

Hva er Configuration Management?

Konfigurasjonsadministrasjon er prosessen med å opprettholde programvare og datasystemer (for eksempel servere, lagring, nettverk) i en kjent, ønsket og konsistent tilstand. Den gir også tilgang til en nøyaktig historisk oversikt over systemtilstand for prosjektledelse og revisjonsformål.

Systemadministratorer utfører for det meste repeterende oppgaver som å installere servere, konfigurere disse serverne osv. Disse fagfolkene kan automatisere denne oppgaven ved å skrive skript.

Det er imidlertid en vanskelig jobb når de jobber med en massiv infrastruktur. Configuration Management-verktøyet som en Puppet ble introdusert for å løse slike problemer.

Hva er Puppet?

Puppet er et systemadministrasjonsverktøy for sentralisering og automatisering av konfigurasjonsadministrasjonsprosessen. Puppet brukes også som et programvaredistribusjonsverktøy. Det er en åpen kildekode konfigurasjonsadministrasjonsprogramvare som er mye brukt for serverkonfigurasjon, administrasjon, distribusjon og orkestrering av ulike applikasjoner og tjenester på tvers av hele infrastrukturen til en organisasjon.

Puppet er spesielt designet for å administrere konfigurasjonen av Linux og Windows systemer. Den er skrevet i Ruby og bruker sin unike Dhoved- Specific Lnguage (DSL) for å beskrive systemkonfigurasjonen.

Hva er Puppet-versjonene?

Puppet kommer i to versjoner:

• Dukke med åpen kildekode: Det er en grunnleggende versjon av Puppet-konfigurasjonsadministrasjonsverktøyet, som også er kjent som Open Source Puppet. Den er tilgjengelig direkte fra Puppets nettside og er lisensiert under Apache 2.0-systemet.

• Puppet Enterprise: Kommersiell versjon som tilbyr funksjoner som samsvarsrapportering, orkestrering, rollebasert tilgangskontroll, GUI, API og kommandolinjeverktøy for effektiv administrasjon av noder.

Hva kan dukke gjøre?

For eksempel har du en infrastruktur med rundt 100 servere. Som systemadministrator er det din rolle å sørge for at alle disse serverne alltid er oppdatert og kjører med full funksjonalitet.

For å gjøre dette kan du bruke Puppet, som lar deg skrive en enkel kode som kan distribueres automatisk på disse serverne. Dette reduserer den menneskelige innsatsen og gjør utviklingsprosessen rask og effektiv.

Puppet utfører følgende funksjoner:

• Puppet lar deg definere distinkte konfigurasjoner for hver vert.
• Verktøyet lar deg kontinuerlig overvåke servere for å bekrefte om den nødvendige konfigurasjonen eksisterer eller ikke, og den er ikke endret. Hvis konfigurasjonen endres, vil Puppet-verktøyet gå tilbake til den forhåndsdefinerte konfigurasjonen på verten.
• Det gir også kontroll over alt det konfigurerte systemet, slik at en sentralisert endring blir utført automatisk.
• Det brukes også som et distribusjonsverktøy da det automatisk distribuerer programvare til systemet. Den implementerer infrastruktur som en kode fordi policyer og konfigurasjoner er skrevet som kode.

Puppet DSL og programmeringsparadigmer

Før vi lærer Puppet DSL, la oss forstå programmeringsparadigmer:

Et programmeringsparadigme er en stil du bruker i dataprogrammering.

Fire typer paradigmer er:

• Avgjørende.
• Erklærende.
• Funksjonell (som regnes som en undergruppe av det deklarative paradigmet)
• Objektorientert.

Vi vil fokusere på imperativ og deklarativ.

Imperative paradigmer

Dette programmeringsparadigmet uttrykker logikken til en beregning (Hva skal gjøres) og beskriver kontrollflyten (Hvordan gjøres)

Eksempel:

Anta at du skal til kontoret ditt, bestiller du en drosje og begynner å gi trinnvise veibeskrivelser til sjåføren til du kommer til kontoret. Å spesifisere hva du skal gjøre og hvordan du skal gjøre er en imperativ stil.

Deklarative paradigmer

Dette programmeringsparadigmet uttrykker logikken til en beregning (Hva skal gjøres) uten å beskrive kontrollflyten (Hvordan gjøre)

Eksempel:

Anta at du skal til kontoret ditt, bestiller du Uber drosje og spesifiserer den endelige destinasjonen (Office). Å spesifisere hva som ikke skal gjøres, er en deklarativ stil.

Paradigm	Hva du skal gjøre	Hvordan å gjøre
avgjørende	Ja	Ja
deklarativ	Ja	Nei

Puppet bruker et deklarativt programmeringsparadigme

Puppet bruker en deklarativ programmeringsmetode.

Eksempel: Opprett en bruker på systemet:

Det kan gjøres ved hjelp av imperativt programmeringsmønster ved hjelp av et skallskript: Her spesifiserer vi hvordan brukeren skal opprettes og hvilke kommandoer som skal brukes på operativsystem.

Imidlertid kan det gjøres ved å bruke deklarativt programmeringsmønster med bare noen få linjer med dukkekode, Puppet domene spesifikt språk (DSL), og fortsatt oppnå det samme resultatet.

Implementeringsmodeller for verktøy for konfigurasjonsadministrasjon

Det er to distribusjonsmodeller for verktøy for konfigurasjonsadministrasjon :

• Push-basert distribusjonsmodell: initiert av en hovednode.
• Pull-basert distribusjonsmodell: initiert av agenter.

Push-basert distribusjonsmodell

I denne distribusjonsmodellen sender masterserveren konfigurasjonene og programvaren til de individuelle agentene. Etter å ha verifisert en sikker tilkobling, kjører masteren kommandoer eksternt på agentene. For eksempel Ansible og Salt Stack.

Pull-basert distribusjonsmodell.

I denne distribusjonsmodellen kontakter individuelle servere en hovedserver, verifiserer og etablerer en sikker tilkobling, laster ned konfigurasjonene og programvaren deres og konfigurerer seg deretter – for eksempel Puppet og Chef.

Hvordan fungerer Puppet?

Puppet er basert på en Pull-implementeringsmodell, der agentnodene sjekker inn regelmessig etter hver 1800 sekunder med masternoden for å se om noe må oppdateres i agenten. Hvis noe må oppdateres, henter agenten de nødvendige dukkekodene fra masteren og utfører nødvendige handlinger.

La oss forklare det med et eksempel:

Eksempel: Master – Agentoppsett:

The Master

En Linux-basert maskin med Puppet Master-programvare installert på den. Det er ansvarlig for å opprettholde konfigurasjoner i form av dukkekoder. Hovednoden kan bare være Linux.

Agentene

Målmaskinene administrert av en dukke med dukkeagentprogramvaren installert på dem.

Agenten kan konfigureres på alle støttede operativsystemer som Linux eller Windows or Solaris eller Mac OS.

Kommunikasjonen mellom master og agent etableres gjennom sikre sertifikater.

Kommunikasjon mellom Mesteren og Agenten

Trinn 1) Når tilkoblingen er etablert mellom agenten og masteren, sender Puppet-agenten dataene om tilstanden til Puppet-masterserveren. Disse kalles fakta: Denne informasjonen inkluderer vertsnavnet, kjernedetaljer, IP-adresse, filnavndetaljer, etc.…

Trinn 2) Puppet Master bruker disse dataene og kompilerer en liste med konfigurasjonen som skal brukes på agenten. Denne listen over konfigurasjoner som skal utføres på en agent er kjent som en katalog. Dette kan endres som pakkeinstallasjon, oppgraderinger eller fjerning, opprettelse av filsystem, opprettelse eller sletting av bruker, omstart av server, endringer i IP-konfigurasjon, etc.

Trinn 3) Agenten bruker denne listen over konfigurasjoner til å bruke eventuelle nødvendige konfigurasjonsendringer på noden.

I tilfelle det ikke er noen drifter i konfigurasjonen, utfører ikke Agent noen konfigurasjonsendringer og lar noden kjøre med samme konfigurasjon.

Trinn 4) Når det er gjort, rapporterer noden tilbake til puppet master som indikerer at konfigurasjonen er tatt i bruk og fullført.

Dukkeblokker

Puppet gir fleksibiliteten til å integrere rapporter med tredjepartsverktøy ved å bruke Puppet APIer.

Fire typer Puppet byggeklosser er

1. Ressurser
2. Klasser
3. Manifest
4. Moduler

Dukkeressurser

Puppet Resources er byggesteinene til Puppet.

Ressurser er innebygde funksjoner som kjører i bakenden for å utføre de nødvendige operasjonene i dukke.

Dukkeklasser

En kombinasjon av forskjellige ressurser kan grupperes sammen til en enkelt enhet kalt klasse.

Dukkemanifest

Manifest er en katalog som inneholder marionett-DSL-filer. Disse filene har filtypen .pp. .pp-utvidelsen står for dukkeprogram. Dukkekoden består av definisjoner eller erklæringer av dukkeklasser.

Dukkemoduler

Moduler er en samling filer og kataloger som Manifester, Klassedefinisjoner. De er gjenbrukbare og delbare enheter i Puppet.

For eksempel MySQL modul for å installere og konfigurere MySQL eller Jenkins-modulen for å administrere Jenkins osv.

Typer dukkeressurser

Generelt består et system av filer, brukere, tjenester, prosesser, pakker osv. I Puppet kalles disse ressurser. Ressurser er de grunnleggende byggesteinene i

Dukke. Alle operasjonene på dukkeagenter utføres ved hjelp av dukkeressurser.

Puppet-ressurser er de ferdiglagde verktøyene som brukes til å utføre ulike oppgaver og operasjoner på enhver støttet plattform. Vi kan bruke en enkelt marionetressurs til å utføre en spesifikk oppgave, eller vi kan bruke flere dukkeressurser sammen for å utføre noen komplekse applikasjonskonfigurasjoner.

Ressurser kan ha forskjellige typer. Dukkebruk ressurser og ressurstyper for å beskrive et systems konfigurasjon.

Det er tre typer ressurstyper:

1. Dukkekjerne eller innebygde ressurstyper.
2. Dukkedefinerte ressurstyper.
3. Dukke tilpassede ressurstyper.

Dukkekjerne eller innebygde ressurstyper

Kjerne- eller innebygde ressurstyper er de forhåndsbygde dukke-ressurstypene som leveres med dukkeprogramvare. Alle kjerne- eller innebygde Puppet-ressurstyper er skrevet og vedlikeholdt av Puppet-teamet.

Dukkedefinerte ressurstyper

Definerte ressurstyper er lette ressurstyper skrevet i Puppet-deklarativt språk ved å bruke en kombinasjon av eksisterende ressurstyper.

Dukke tilpassede ressurstyper

Egendefinerte ressurstyper er fullstendig tilpassede ressurstyper skrevet i Ruby.

La oss utforske om dukkeressurstyper ...

I terminalen skriver du inn følgende kommando for å vise en liste over Puppet-relevante underkommandoer:

Puppet --help

I vårt tilfelle er vi interessert i underkommandoen "ressurs” som vi vil bruke for å finne informasjonen om innebygde dukkeressurstyper.

I terminalen skriver du inn en av følgende kommandoer for å vise en liste over handlinger knyttet til marionettunderkommandoen "ressurs"

Puppet help resource		
Puppet resource --help		

I dette tilfellet har vi ressurs som underkommando og -typer som handling.

Puppet har 49 innebygde kjerneressurstyper.

I terminalen skriver du inn følgende kommando for å vise en liste over tilgjengelige innebygde dukke-ressurstyper:

puppet resource –types

Hver type støtter en liste over attributter. Disse attributtene gir en detaljert beskrivelse som Puppet bruker for å administrere ressursen.

For å finne ut alle attributtene knyttet til dukkeressurstypen, bruk følgende kommando:

puppet describe <resource type name>	

Parametre vil vise alle tilgjengelige attributter for den ressurstypen.

marionett beskrive pakken

Det er vanskelig for en ny person å forstå og relatere mange uadministrerte dukkekodefiler. Det er her vi trenger litt gruppering for å binde sammen operasjoner. Målet er å løse et enkelt problem, for eksempel alle operasjoner som kreves for å konfigurere ssh på en server eller ntp-tjeneste eller en komplett webserver eller databaseserver fra bunnen av.

Hva er dukkeklasser?

Dukkeklasser er samlingen av dukkeressurser samlet som en enkelt enhet.

Puppet introduserte klasser for å gjøre strukturen gjenbrukbar og organisert.

Først må vi definere en klasse ved å bruke klassedefinisjonssyntaks; klasser må være unike og kan kun deklareres én gang med samme navn:

class <class-name> {
<Resource declarations>
}

Eksempel:

class ntpconfig {
    file {
        "/etc/ntp.conf": 
     ensure=> "present", content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}

Så langt har vi kun definert klassen, men vi har ikke brukt den noen steder. Dette betyr at denne koden vi har skrevet aldri vil bli utført med mindre vi erklærer denne klassen et annet sted.

Klasseerklæring

For å bruke en definert klasse i kode, bruk inkludere søkeord.

class ntpconfig {
    file {
        "/etc/ntp.conf": 
      ensure=> "present", 
      content=> "server 0.centos.pool.ntp.org iburst\n",
    }
}
include ntpconfig

La oss forstå dette med et reelt scenario.

Demoinstaller NTP

Først, sørg for at NTP-pakken ikke allerede er til stede på serveren, følgende kommando vil ikke returnere noe hvis telnet ikke er til stede på serveren:

rpm -qa | grep -i ntp

Som vi kan se, er NTP-pakken allerede til stede på serveren. La oss fjerne den eksisterende NTP-pakken:

yum remove ntp

Etter å ha fjernet pakken, sørg for at filen ntp.conf ikke eksisterer:

ls -lrt /etc/ntp.conf

Bekreft at ntp-tjenesten ikke eksisterer ved å kjøre følgende kommando:

systemctl status ntp

Opprett en ny .pp-fil for å lagre koden. Fra kommandolinjen:

vi demontp.pp

Bytt til innsettingsmodus ved å trykke i fra tastaturet.

Skriv inn følgende kode for å lage en ny fil:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

Etter at du er ferdig med redigering: trykk på esc

For å lagre filen, trykk :wq!

Neste trinn er å sjekk om koden har noen syntaksfeil. Utfør følgende kommando:

puppet parser validate demontp.pp

Pass på at du byttet til root for å kunne fullføre testen uten feil, ved å utføre kommandoen:

su root

Test er neste trinn i prosessen for å lage kode. Utfør følgende kommando for å utføre en røyktest:

Puppet applies demontp.pp --noop

Siste trinn er å løpe dukken i ekte modus og verifiser resultatet.

puppet apply demontp.pp

Puppet presterte ikke noe fordi demoklassen var bare definert men ikke erklærte.

Så før du erklærer dukkeklassen, vil ikke koden bli brukt.

la oss erklære demoklassen inne i samme kode ved hjelp av inkludere klassenavn på slutten av koden:

# Class Definition 
class ntpconfig {
    # Installing NTP Package 
  package {"ntp": 
    ensure=> "present",
    }
    # Configuring NTP configuration file 
  file {"/etc/ntp.conf": 
    ensure=> "present", 
    content=> "server 0.centos.pool.ntp.org iburst\n",
    }
    # Starting NTP services 
  service {"ntpd": 
    ensure=> "running",
    }
}

# Class Declaration 
include ntpconfig

Igjen sjekk om koden har noen syntaksfeil. Utfør følgende kommando:

puppet parser validate demontp.pp

Pass på at du byttet til root for å kunne fullføre testen uten feil, ved å utføre kommandoen:

su root

Testing er neste trinn i prosessen for å lage kode. Utfør følgende kommando for å utføre en røyktest:

Puppet apply demontp.pp --noop

Siste trinn er å løpe dukken i ekte modus og verifiser resultatet.

puppet apply demontp.pp

Denne gangen blir koden brukt fordi klassen ble definert og deretter erklært.

Sørg for at ntp.conf nå eksisterer:

ls -lrt /etc/ntp.conf

Bekreft at ntp-tjenesten er startet ved å kjøre følgende kommando:

systemctl status ntpd