sql >> Database teknologi >  >> RDS >> PostgreSQL

PostgreSQL-implementering og konfiguration med Puppet

Puppet er open source-software til konfigurationsstyring og implementering. Grundlagt i 2005, er det multi-platform og har endda sit eget deklarative sprog til konfiguration.

Opgaverne relateret til administration og vedligeholdelse af PostgreSQL (eller anden software egentlig) består af daglige, gentagne processer, der kræver overvågning. Dette gælder selv for de opgaver, der drives af scripts eller kommandoer gennem et planlægningsværktøj. Kompleksiteten af ​​disse opgaver øges eksponentielt, når de udføres på en massiv infrastruktur, men brug af Puppet til denne slags opgaver kan ofte løse disse typer problemer i stor skala, da Puppet centraliserer og automatiserer udførelsen af ​​disse operationer på en meget smidig måde.

Puppet arbejder inden for arkitekturen på klient-/serverniveauet, hvor konfigurationen udføres; disse ops spredes derefter og udføres på alle klienterne (også kendt som noder).

Kører typisk hvert 30. minut, og agenternes node indsamler et sæt informationer (type processor, arkitektur, IP-adresse osv..), også kaldet fakta, og sender derefter informationen til master, som venter på svar for at se, om der er nye konfigurationer, der skal gælde.

Disse fakta vil give masteren mulighed for at tilpasse den samme konfiguration for hver node.

Puppet er på en meget forenklet måde et af de vigtigste DevOps-værktøjer tilgængelig i dag. I denne blog vil vi tage et kig på følgende...

  • The Use Case for Puppet &PostgreSQL
  • Installation af Puppet
  • Konfiguration og programmering af marionet
  • Konfiguration af Puppet til PostgreSQL 

Installationen og opsætningen af ​​Puppet (version 5.3.10) beskrevet nedenfor blev udført i et sæt værter, der brugte CentOS 7.0 som operativsystem.

The Use Case for Puppet &PostgreSQL

Antag, at der er et problem i din firewall på de maskiner, der hoster alle dine PostgreSQL-servere, vil det så være nødvendigt at nægte alle udgående forbindelser til PostgreSQL og gøre det så hurtigt som muligt.

Puppet er det perfekte værktøj til denne situation, især fordi hastighed og effektivitet er vigtig. Vi vil tale om dette eksempel præsenteret i afsnittet "Konfiguration af Puppet for PostgreSQL" ved at administrere parameteren listen_addresses.

Installation af Puppet

Der er et sæt almindelige trin, der skal udføres enten på master- eller agentværter:

Trin 1

Opdatering af /etc/hosts-fil med værtsnavne og deres IP-adresse

192.168.1.85 agent agent.severalnines.com

192.168.1.87 master master.severalnines.com puppet

Trin to

Tilføjelse af Puppet-lagrene på systemet

$ sudo rpm –Uvh https://yum.puppetlabs.com/puppet5/el/7/x86_64/puppet5-release-5.0.0-1-el7.noarch.rpm

For andre operativsystemer eller CentOS-versioner kan det mest passende lager findes i Puppet, Inc. Yum Repositories.

Trin tre

Konfiguration af NTP-server (Network Time Protocol)

$ sudo yum -y install chrony

Trin fire

Chrony'en bruges til at synkronisere systemuret fra forskellige NTP-servere og holder dermed tiden synkroniseret mellem master- og agentserver.

Når chrony er installeret  skal den aktiveres og genstartes:

$ sudo systemctl enable chronyd.service

$ sudo systemctl restart chronyd.service

Trin fem

Deaktiver SELinux-parameteren

På filen /etc/sysconfig/selinux skal parameteren SELINUX (Security-Enhanced Linux)  være deaktiveret for ikke at begrænse adgangen på begge værter.

SELINUX=disabled

Trin seks

Før Puppet-installationen (enten master eller agent) skal firewallen i disse værter defineres i overensstemmelse hermed:

$ sudo firewall-cmd -–add-service=ntp -–permanent 

$ sudo firewall-cmd –-reload

Installation af Puppet Master

Når pakkelageret puppet5-release-5.0.0-1-el7.noarch.rpm er føjet til systemet, kan dukkeserverinstallationen udføres:

$ sudo yum install -y puppetserver

Maksimal hukommelsesallokeringsparameteren er en vigtig indstilling for at opdatere på /etc/sysconfig/puppetserver-filen til 2GB (eller til 1GB, hvis tjenesten ikke starter):

JAVA_ARGS="-Xms2g –Xmx2g "

I konfigurationsfilen /etc/puppetlabs/puppet/puppet.conf er det nødvendigt at tilføje følgende parametrering:

[master]

dns_alt_names=master.severalnines.com,puppet



[main]

certname = master.severalnines.com

server = master.severalnines.com

environment = production

runinterval = 1h

Puppetserver-tjenesten bruger porten 8140 til at lytte til nodeanmodningerne, så det er nødvendigt at sikre, at denne port aktiveres:

$ sudo firewall-cmd --add-port=8140/tcp --permanent

$ sudo firewall-cmd --reload

Når alle indstillinger er lavet i puppet master, er det tid til at starte denne tjeneste op:

$ sudo systemctl start puppetserver

$ sudo systemctl enable puppetserver

Installation af Puppet Agent

Puppet-agenten i pakkelageret puppet5-release-5.0.0-1-el7.noarch.rpm er også føjet til systemet. Puppet-agent-installationen kan udføres med det samme:

$ sudo yum install -y puppet-agent

Puppet-agent-konfigurationsfilen /etc/puppetlabs/puppet/puppet.conf skal også opdateres ved at tilføje følgende parameter:

[main]

certname = agent.severalnines.com

server = master.severalnines.com

environment = production

runinterval = 1h

Det næste trin består i at registrere agentnoden på masterværten ved at udføre følgende kommando:

$ sudo /opt/puppetlabs/bin/puppet resource service puppet ensure=running enable=true

service { ‘puppet’:

ensure => ‘running’,

enable => ‘true’

  }

I dette øjeblik, på master-værten, er der en afventende anmodning fra dukkeagenten om at underskrive et certifikat:

Det skal underskrives ved at udføre en af ​​følgende kommandoer:

$ sudo /opt/puppetlabs/bin/puppet cert sign agent.severalnines.com

eller

$ sudo /opt/puppetlabs/bin/puppet cert sign --all

Endelig (og når dukkeføreren har underskrevet certifikatet) er det tid til at anvende konfigurationerne på agenten ved at hente kataloget fra dukkeføreren:

$ sudo /opt/puppetlabs/bin/puppet agent --test

I denne kommando betyder parameteren --test ikke en test, indstillingerne hentet fra masteren vil blive anvendt på den lokale agent. For at teste/kontrollere konfigurationerne fra master skal følgende kommando udføres:

$ sudo /opt/puppetlabs/bin/puppet agent --noop

Konfiguration og programmering af marionet

Puppet bruger en deklarativ programmeringstilgang, hvor formålet er at specificere, hvad der skal gøres, og det er ligegyldigt måden at opnå det på!

Det mest elementære stykke kode på Puppet er den ressource, der specificerer en systemegenskab såsom kommando, service, fil, mappe, bruger eller pakke.

Nedenfor præsenteres syntaksen for en ressource for at oprette en bruger:

user { 'admin_postgresql':

  ensure     => present,

  uid        => '1000',

  gid        => '1000',

  home       => '/home/admin/postresql'

}

Forskellige ressourcer kunne føjes til den tidligere klasse (også kendt som et manifest) af fil med filtypenavnet "pp" (det står for Puppet Program), ikke desto mindre flere manifester og data (såsom fakta, filer og skabeloner) vil sammensætte et modul. Alle de logiske hierarkier og regler er repræsenteret i diagrammet nedenfor:

Formålet med hvert modul er at indeholde alle de nødvendige manifester til at udføre enkeltstående opgaver på en modulær måde. På den anden side er begrebet klasse ikke det samme fra objektorienterede programmeringssprog, i Puppet fungerer det som en aggregator af ressourcer.

Denne filorganisation har en specifik mappestruktur, der skal følges:

hvor formålet med hver mappe er følgende:

Mappe

Beskrivelse

manifester

Dukkekode

filer

Statiske filer, der skal kopieres til noder

skabeloner

Skabelonfiler, der skal kopieres til administrerede noder (den kan tilpasses med variabler)

eksempler

Manifest for at vise, hvordan modulet bruges
Klasserne(manifester) kan bruges af andre klasser som vist i eksemplet nedenfor:manifestet init.pp på dev_accounts bruger manifestgrupperne fra kontomodulet.
class dev_accounts {

  $rootgroup = $osfamily ? {

    'Debian'  => 'sudo',

    'RedHat'  => 'wheel',

    default   => warning('This distribution is not supported by the Accounts module'),

  }



  include accounts::groups



  user { 'username':

    ensure      => present,

    home        => '/home/admin/postresql',

    shell       => '/bin/bash',

    managehome  => true,

    gid         => 'admin_db',

    groups      => "$rootgroup",

    password    => '$1$7URTNNqb$65ca6wPFDvixURc/MMg7O1'

  }

}

I næste afsnit viser vi dig, hvordan du genererer indholdet af mappen eksempler samt kommandoerne til at teste og udgive hvert modul.

Konfiguration af Puppet til PostgreSQL

Før du præsenterer de adskillige konfigurationseksempler til at implementere og vedligeholde en PostgreSQL-database, er det nødvendigt at installere PostgreSQL-dukkemodulet (på serverværten) for at bruge alle deres funktionaliteter:

$ sudo /opt/puppetlabs/bin/puppet module install puppetlabs-postgresql

I øjeblikket er tusindvis af moduler klar til brug på Puppet tilgængelige på det offentlige modullager Puppet Forge.

Trin 1

Konfigurer og implementer en ny PostgreSQL-instans. Her er al den nødvendige programmering og konfiguration for at installere en ny PostgreSQL-instans i alle noder.

Det første trin er at oprette et nyt modulstrukturbibliotek som tidligere delt:

$ cd /etc/puppetlabs/code/environments/production/modules

$ mkdir db_postgresql_admin

$ cd db_postgresql_admin; mkdir{examples,files,manifests,templates}

Derefter skal du i manifestfilen manifests/init.pp inkludere klassen postgresql::server leveret af det installerede modul :

class db_postgresql_admin{

  include postgresql::server

}

For at kontrollere manifestets syntaks er det en god praksis at udføre følgende kommando:

$ sudo /opt/puppetlabs/bin/puppet parser validate init.pp

Hvis intet returneres, betyder det, at syntaksen er korrekt

For at vise dig, hvordan du bruger dette modul i eksempelmappen, er det nødvendigt at oprette en ny manifestfil init.pp med følgende indhold:

include db_postgresql_admin

Eksempelplaceringen i modulet skal testes og anvendes på masterkataloget:

$ sudo /opt/puppetlabs/bin/puppet apply --modulepath=/etc/puppetlabs/code/environments/production/modules --noop init.pp

Til sidst er det nødvendigt at definere, hvilket modul hver node har adgang til i filen "/etc/puppetlabs/code/environments/production/manifests/site.pp" :

node ’agent.severalnines.com’,’agent2.severalnines.com’{

 include db_postgresql_admin

}

Eller en standardkonfiguration for alle noder:

node default {

 include db_postgresql_admin

}

Normalt hver 30. minut tjekker noderne masterkataloget, ikke desto mindre kan denne forespørgsel tvinges på nodesiden af ​​følgende kommando:

$ /opt/puppetlabs/bin/puppet agent -t

Eller hvis formålet er at simulere forskellene mellem masterkonfigurationen og de aktuelle nodeindstillinger, kan den bruges med parameteren nopp (ingen operation):

$ /opt/puppetlabs/bin/puppet agent -t --noop

Trin to

Opdater PostgreSQL-instansen for at lytte til alle grænseflader. Den tidligere installation definerer en instansindstilling i en meget restriktiv tilstand:tillader kun forbindelser på localhost, som kan bekræftes af de værter, der er knyttet til porten 5432 (defineret for PostgreSQL):

$ sudo netstat -ntlp|grep 5432

tcp        0 0 127.0.0.1:5432          0.0.0.0:* LISTEN   3237/postgres       

tcp6       0 0 ::1:5432                :::* LISTEN   3237/postgres

For at tillade lytning på alle grænseflader, er det nødvendigt at have følgende indhold i filen /etc/puppetlabs/code/environments/production/modules/db_postgresql_admin/manifests/init.pp

class db_postgresql_admin{

  class{‘postgresql:server’:

        listen_addresses=>’*’ #listening all interfaces

       }

}

I eksemplet ovenfor er der erklæret klassen postgresql::server og sætter parameteren listen_addresses til "*", hvilket betyder alle grænseflader.

Nu er port 5432 tilknyttet alle grænseflader, det kan bekræftes med følgende IP-adresse/port:"0.0.0.0:5432"

$ sudo netstat -ntlp|grep 5432

tcp        0 0 0.0.0.0:5432            0.0.0.0:* LISTEN   1232/postgres       

tcp6       0 0 :::5432                 :::* LISTEN   1232/postgres

For at sætte den oprindelige indstilling tilbage:tillad kun databaseforbindelser fra localhost parameteren listen_addresses skal indstilles til "localhost" eller angive en liste over værter, hvis det ønskes:

listen_addresses = 'agent2.severalnines.com,agent3.severalnines.com,localhost'

For at hente den nye konfiguration fra masterværten er det kun nødvendigt at anmode om det på noden:

$ /opt/puppetlabs/bin/puppet agent -t

Trin tre

Opret en PostgreSQL-database. PostgreSQL-instansen kan oprettes med en ny database såvel som en ny bruger (med adgangskode) til at bruge denne database og en regel på pg_hab.conf-filen for at tillade databaseforbindelsen for denne nye bruger:

class db_postgresql_admin{

  class{‘postgresql:server’:

        listen_addresses=>’*’ #listening all interfaces

  }



   postgresql::server::db{‘nines_blog_db’:

     user => ‘severalnines’,          password=> postgresql_password(‘severalnines’,’passwd12’)

   }



   postgresql::server::pg_hba_rule{‘Authentication for severalnines’:

     Description =>’Open access to severalnines’,

     type => ‘local’,

database => ‘nines_blog_db’,

     user => ‘severalnines’,

address => ‘127.0.0.1/32’

         auth_method => ‘md5’

   }

}

Denne sidste ressource har navnet "Authentication for severalnines", og filen pg_hba.conf vil have en yderligere regel:

# Rule Name: Authentication for severalnines

# Description: Open access for severalnines

# Order: 150

local   nines_blog_db   severalnines 127.0.0.1/32    md5

For at hente den nye konfiguration fra masterværten er det eneste, der kræves, at anmode om det på noden:

$ /opt/puppetlabs/bin/puppet agent -t

Trin fire

Opret en skrivebeskyttet bruger. For at oprette en ny bruger med skrivebeskyttede rettigheder skal følgende ressourcer tilføjes til det forrige manifest:

postgresql::server::role{‘Creation of a new role nines_reader’:

createdb   => false,

createrole => false,

superuser => false,     password_hash=> postgresql_password(‘nines_reader’,’passwd13’)

}

postgresql::server::pg_hba_rule{‘Authentication for nines_reader’:

     description =>’Open access to nines_reader’,

     type => ‘host’,

database => ‘nines_blog_db’,

     user => ‘nines_reader’,

address => ‘192.168.1.10/32’,

         auth_method => ‘md5’

   }

For at hente den nye konfiguration fra masterværten er det eneste, der kræves, at anmode om det på noden:

$ /opt/puppetlabs/bin/puppet agent -t

Konklusion 

I dette blogindlæg viste vi dig de grundlæggende trin til at implementere og begynde at konfigurere din PostgreSQL-database via en automatisk og tilpasset måde på flere noder (som endda kunne være virtuelle maskiner).

Disse typer af automatisering kan hjælpe dig med at blive mere effektiv end at gøre det manuelt, og PostgreSQL-konfiguration kan nemt udføres ved at bruge flere af de tilgængelige klasser i puppetforge-lageret


  1. MYSQL ORDER BY CASE Problem

  2. Fremskynder rækkeoptællingen i MySQL

  3. MySQL match() mod() - rækkefølge efter relevans og kolonne?

  4. ændre størrelsen på datatype i sql