कठपुतली के साथ बर्मन को स्वचालित करना:it2ndq/barman (भाग दो)

इस लेख के पहले भाग में हमने वैग्रांट को दो उबंटू 14.04 भरोसेमंद तहर वर्चुअल मशीनों को निष्पादित करने के लिए कॉन्फ़िगर किया है, जिन्हें क्रमशः pg कहा जाता है। और बैकअप . इस दूसरे भाग में हम देखेंगे कि pg पर PostgreSQL सर्वर को सेट करने और कॉन्फ़िगर करने के लिए कठपुतली का उपयोग कैसे करें और बैकअप . से बर्मन के माध्यम से इसका बैकअप लें बॉक्स।

कठपुतली:विन्यास

पिछले लेख के अनुसार मशीनों को परिभाषित करने के बाद, हमें आवश्यक कठपुतली मॉड्यूल निर्दिष्ट करने की आवश्यकता है जो लाइब्रेरियन-कठपुतली हमारे लिए प्रबंधन करेगा।

दो मॉड्यूल की आवश्यकता है:

कठपुतली लैब/पोस्टग्रेस्क्ल (http://github.com/puppetlabs/puppetlabs-postgresql/) PostgreSQL को pg पर इंस्टॉल करने के लिए वीएम
it2ndq/barman (http://github.com/2ndquadrant-it/puppet-barman) बर्मन को बैकअप पर इंस्टॉल करने के लिए

दोनों मॉड्यूल कठपुतली फोर्ज से स्थापित किए जाएंगे। कठपुतली/पोस्टग्रेस्क्ल के लिए मॉड्यूल, हमें इस समय अधिकतम संस्करण 4.2.0 का उपयोग करना होगा, क्योंकि नवीनतम संस्करण (4.3.0) postgres_password को तोड़ रहा है पैरामीटर जिसका हम बाद में उपयोग करेंगे (यह पुल अनुरोध देखें)। चलिए Puppetfile called नाम की एक फाइल बनाते हैं परियोजना निर्देशिका में इस सामग्री को शामिल करना:

forge "http://forgeapi.puppetlabs.com"
mod "puppetlabs/postgresql", "<4.3.0"
mod "it2ndq/barman"

अब हम कठपुतली मॉड्यूल और उनकी निर्भरता को चलाकर स्थापित कर सकते हैं:

$ librarian-puppet install --verbose

हालांकि जरूरी नहीं है, विकल्प का उपयोग करना बेहतर है --verbose हर बार लाइब्रेरियन-कठपुतली प्रयोग किया जाता है। इसके बिना कमांड बहुत शांत है और यह पहले से क्या कर रहा है, इसके बारे में विवरण रखना उपयोगी है। उदाहरण के लिए, --verbose . का उपयोग किए बिना , आपको पता चल सकता है कि आपने एक निर्भरता संघर्ष के हल होने की प्रतीक्षा में अपना कीमती समय बर्बाद किया है, केवल कई मिनट बाद एक त्रुटि देखने के लिए।

कमांड के सफलतापूर्वक पूरा होने पर, एक मॉड्यूल निर्देशिका जिसमें बर्मन . है और postgresql मॉड्यूल और उनकी निर्भरताएं (उपयुक्त , concat , stdlib ) हमारी कार्यशील निर्देशिका में बनाया जाएगा। इसके अलावा, लाइब्रेरियन-कठपुतली Puppetfile.lock बनाएगा भविष्य के अपडेट को रोकने के लिए उन्हें पिन करते हुए, स्थापित मॉड्यूल की निर्भरता और संस्करणों की पहचान करने के लिए फ़ाइल। इस तरह, बाद में लाइब्रेरियन-कठपुतली इंस्टॉल रन हमेशा संभावित अपग्रेड के बजाय मॉड्यूल का एक ही संस्करण स्थापित करेगा (यदि अपग्रेड की आवश्यकता है, तो लाइब्रेरियन-पपेट अपडेट चाल चलेगा)।

अब हम वैग्रांट को बता सकते हैं कि हम सर्वर को प्रोविजन करने के लिए कठपुतली मैनिफेस्ट का उपयोग कर रहे हैं। हम Vagrantfile . को बदल देते हैं इस प्रकार:

Vagrant.configure("2") do |config|
  {
    :pg => {
      :ip      => '192.168.56.221',
      :box     => 'ubuntu/trusty64'
    },
    :backup => {
      :ip      => '192.168.56.222',
      :box     => 'ubuntu/trusty64'
    }
  }.each do |name,cfg|
    config.vm.define name do |local|
      local.vm.box = cfg[:box]
      local.vm.hostname = name.to_s + '.local.lan'
      local.vm.network :private_network, ip: cfg[:ip]
      family = 'ubuntu'
      bootstrap_url = 'http://raw.github.com/hashicorp/puppet-bootstrap/master/' + family + '.sh'

      # Run puppet-bootstrap only once
      local.vm.provision :shell, :inline => <<-eos
        if [ ! -e /tmp/.bash.provision.done ]; then
          curl -L #{bootstrap_url} | bash
          touch /tmp/.bash.provision.done
        fi
      eos

      # Provision with Puppet
      local.vm.provision :puppet do |puppet|
        puppet.manifests_path = "manifests"
        puppet.module_path = [".", "modules"]
        puppet.manifest_file = "site.pp"
        puppet.options = [
         '--verbose',
        ]
      end
    end
  end
end

जिन पंक्तियों को हमने अभी जोड़ा है, हमने Vagrant को manifests/site.pp का उपयोग करके VMs को प्रोविज़न करने के निर्देश दिए हैं। मुख्य मेनिफेस्ट और मॉड्यूल के रूप में मॉड्यूल . में शामिल हैं निर्देशिका। यह हमारे Vagrantfile . का अंतिम संस्करण है ।

अब हमें मेनिफेस्ट . बनाना है निर्देशिका:

$ mkdir manifests

और उसमें site.pp . का पहला संस्करण लिखें . हम एक बहुत ही बुनियादी सेटअप के साथ शुरुआत करेंगे:

node backup {
  class { 'barman':
    manage_package_repo => true,
  }
}
node pg {}

अब हम मशीनें शुरू कर सकते हैं और देख सकते हैं कि बैकअप . पर डिफ़ॉल्ट कॉन्फ़िगरेशन वाला एक बर्मन सर्वर है (और pg . पर कोई PostgreSQL नहीं है अभी तक)। आइए लॉग इन करें बैकअप :

$ vagrant ssh backup

और /etc/barman.conf पर एक नजर डालें :

# Main configuration file for Barman (Backup and Recovery Manager for PostgreSQL)
# Further information on the Barman project at www.pgbarman.org
# IMPORTANT: Please do not edit this file as it is managed by Puppet!
# Global options

[barman]
barman_home = /var/lib/barman
barman_user = barman
log_file = /var/log/barman/barman.log
compression = gzip
backup_options = exclusive_backup
minimum_redundancy = 0
retention_policy =
retention_policy_mode = auto
wal_retention_policy = main
configuration_files_directory = /etc/barman.conf.d

अगला चरण pg . पर PostgreSQL इंस्टेंस चला रहा है . हमें PostgreSQL सर्वर पर बर्मन द्वारा आवश्यक मापदंडों के बारे में पता होना चाहिए, इसलिए हमें सेट करने की आवश्यकता है:

wal_level कम से कम संग्रह स्तर
archive_mode करने के लिए चालू
archive_command ताकि WALs को बैकअप . पर कॉपी किया जा सके
एक नियम pg_hba.conf . में बैकअप . से एक्सेस के लिए

इन सभी मापदंडों को puppetlabs/postgresql . के माध्यम से आसानी से सेट किया जा सकता है मापांक। इसके अलावा, बर्मन सर्वर पर, हमें चाहिए:

एक PostgreSQL कनेक्शन स्ट्रिंग
एक .pgpass प्रमाणीकरण के लिए फ़ाइल
एक SSH कमांड
SSH कुंजी विनिमय करने के लिए

it2ndq/barman ~barman/.ssh . में एक निजी/सार्वजनिक की-युग्म उत्पन्न करता है . हालांकि, सर्वर के बीच स्वचालित रूप से चाबियों का आदान-प्रदान करने के लिए एक कठपुतली मास्टर की उपस्थिति की आवश्यकता होती है जो इस ट्यूटोरियल के उद्देश्यों से परे है (यह अगली किस्त का हिस्सा होगा, जो कठपुतली मास्टर और ::ऑटोकॉन्फ़िगर class) - इसलिए यह अंतिम चरण मैन्युअल रूप से किया जाएगा।

हम site.pp . संपादित करते हैं फ़ाइल इस प्रकार है:

node backup {
  class { 'barman':
    manage_package_repo => true,
  }
  barman::server {'test-server':
    conninfo     => 'user=postgres host=192.168.56.221',
    ssh_command  => 'ssh [email protected]',
  }
  file { '/var/lib/barman/.pgpass':
    ensure  => 'present',
    owner   => 'barman',
    group   => 'barman',
    mode    => 0600,
    content => '192.168.56.221:5432:*:postgres:insecure_password',
  }
}

node pg {
  class { 'postgresql::server':
    listen_addresses     => '*',
    postgres_password    => 'insecure_password',
    pg_hba_conf_defaults => false,
  }
  postgresql::server::pg_hba_rule {'Local access':
    type        => 'local',
    database    => 'all',
    user        => 'all',
    auth_method => 'peer',
  }
  postgresql::server::pg_hba_rule {'Barman access':
    type        => 'host',
    database    => 'all',
    user        => 'postgres',
    address     => '192.168.56.222/32',
    auth_method => 'md5',
  }
  postgresql::server::config_entry {
    'wal_level'       : value => 'archive';
    'archive_mode'    : value => 'on';
    'archive_command' : value => 'rsync -a %p [email protected]:/var/lib/barman/test-server/incoming/%f';
  }
  class { 'postgresql::server::contrib':
    package_ensure => 'present',
  }
}

मैनिफेस्ट को बदलने के बाद, प्रावधान को फिर से चलाना होगा:

$ vagrant provision

मशीनों के चलने के साथ, हम प्रमुख एक्सचेंजों के साथ आगे बढ़ सकते हैं। हम pg . में लॉग इन करते हैं :

$ vagrant ssh pg

और हम postgres . के लिए keypair बनाते हैं उपयोगकर्ता, ssh-keygen . का उपयोग कर रहे हैं , संकेत दिए जाने पर प्रत्येक फ़ील्ड को खाली छोड़ दें (इसलिए हमेशा एंटर दबाएं):

[email protected]:~$ sudo -iu postgres
[email protected]:~$ ssh-keygen
[email protected]:~$ cat .ssh/id_rsa.pub

अंतिम कमांड एक लंबी अल्फ़ान्यूमेरिक स्ट्रिंग को आउटपुट करता है जिसे ~barman/.ssh/authorized_keys में जोड़ा जाना है। बैकअप पर फ़ाइल करें ।

$ vagrant ssh backup
[email protected]:~$ sudo -iu barman
[email protected]:~$ echo "ssh-rsa ..." >> .ssh/authorized_keys

इसी तरह, हम barman . की सार्वजनिक कुंजी को कॉपी करते हैं उपयोगकर्ता authorized_keys . में पोस्टग्रेज . की फ़ाइल उपयोगकर्ता pg . पर :

[email protected]:~$ cat .ssh/id_rsa.pub
ssh-rsa ...
[email protected]:~$ logout
[email protected]:~$ logout
$ vagrant ssh pg
[email protected]:~$ sudo -iu postgres
[email protected]:~$ echo "ssh-rsa ..." >> .ssh/authorized_keys

इस बिंदु पर, हम दो सर्वरों के बीच दोनों दिशाओं में पहला संबंध बनाते हैं:

[email protected]:$ ssh [email protected]
[email protected]:$ ssh [email protected]

हम बर्मन चेक चला सकते हैं यह सत्यापित करने के लिए कि बर्मन सही ढंग से काम कर रहा है:

[email protected]:~$ barman check all
Server test-server:
        ssh: OK
        PostgreSQL: OK
        archive_mode: OK
        archive_command: OK
        directories: OK
        retention policy settings: OK
        backup maximum age: OK (no last_backup_maximum_age provided)
        compression settings: OK
        minimum redundancy requirements: OK (have 0 backups, expected at least 0)

प्रत्येक पंक्ति को "ओके" पढ़ना चाहिए। अब, बैकअप करने के लिए, बस दौड़ें:

[email protected]:$ barman backup test-server

एक वास्तविक कॉन्फ़िगरेशन

अब तक इस्तेमाल किया गया बर्मन कॉन्फ़िगरेशन बहुत आसान है, लेकिन आप site.pp में कुछ पैरामीटर आसानी से जोड़ सकते हैं और बर्मन की सभी सुविधाओं का लाभ उठाएं, जैसे कि अवधारण नीतियां और बर्मन 1.4.0 में उपलब्ध नया वृद्धिशील बैकअप।

हम निम्नलिखित आवश्यकताओं के साथ इस ट्यूटोरियल को एक वास्तविक उपयोग के मामले के साथ समाप्त करते हैं:

हर रात 1:00 बजे बैकअप
पिछले सप्ताह के किसी भी क्षण में पॉइंट इन टाइम रिकवरी करने की संभावना
हमेशा कम से कम एक बैकअप उपलब्ध होना
barman check के माध्यम से किसी त्रुटि की रिपोर्ट करना यदि नवीनतम बैकअप एक सप्ताह से अधिक पुराना हो
डिस्क स्थान बचाने के लिए वृद्धिशील बैकअप सक्षम करना

हम कठपुतली फ़ाइल . का उपयोग करते हैं .pgpass . बनाने के लिए संसाधन कनेक्शन पैरामीटर और cron . के साथ फ़ाइल हर रात चलाने के लिए नौकरी उत्पन्न करने के लिए संसाधन। अंत में, हम barman::server . संपादित करते हैं आवश्यक बर्मन पैरामीटर जोड़ने के लिए।

अंतिम परिणाम है:

node backup {
  class { 'barman':
    manage_package_repo => true,
  }
  barman::server {'test-server':
    conninfo                => 'user=postgres host=192.168.56.221',
    ssh_command             => 'ssh [email protected]',
    retention_policy        => 'RECOVERY WINDOW OF 1 WEEK',
    minimum_redundancy      => 1,
    last_backup_maximum_age => '1 WEEK',
    reuse_backup            => 'link',
  }
  file { '/var/lib/barman/.pgpass':
    ensure  => 'present',
    owner   => 'barman',
    group   => 'barman',
    mode    => 0600,
    content => '192.168.56.221:5432:*:postgres:insecure_password',
  }
  cron { 'barman backup test-server':
    command => '/usr/bin/barman backup test-server',
    user    => 'barman',
    hour    => 1,
    minute  => 0,
  }
}
node pg {
  class { 'postgresql::server':
    listen_addresses  => '*',
    postgres_password => 'insecure_password',
    pg_hba_conf_defaults => false,
  }
  postgresql::server::pg_hba_rule {'Local access':
    type        => 'local',
    database    => 'all',
    user        => 'all',
    auth_method => 'peer',
  }
  postgresql::server::pg_hba_rule {'Barman access':
    type        => 'host',
    database    => 'all',
    user        => 'postgres',
    address     => '192.168.56.222/32',
    auth_method => 'md5',
  }
  postgresql::server::config_entry {
    'wal_level'       : value => 'archive';
    'archive_mode'    : value => 'on';
    'archive_command' : value => 'rsync -a %p [email protected]:/var/lib/barman/test-server/incoming/%f';
  }
}

निष्कर्ष

कठपुतली मेनिफेस्ट की 51 पंक्तियों के साथ हम पोस्टग्रेएसक्यूएल/बरमन सर्वर की एक जोड़ी को उन सेटिंग्स के साथ कॉन्फ़िगर करने में कामयाब रहे जो हम उत्पादन सर्वर पर चाहते हैं। हमने बैकअप को संभालने के लिए बर्मन सर्वर होने के लाभों को कठपुतली, पुन:प्रयोज्य और संस्करण योग्य द्वारा प्रबंधित एक बुनियादी ढांचे के साथ जोड़ दिया है।

लेखों की इस श्रृंखला में अगली और अंतिम पोस्ट में हम देखेंगे कि विभिन्न मशीनों के बीच संसाधन निर्यात करने के लिए कठपुतली मास्टर का उपयोग कैसे करें, इस प्रकार वीएम को barman::autoconfigure<के माध्यम से सही कामकाज के लिए आवश्यक मापदंडों का आदान-प्रदान करने की अनुमति मिलती है। /कोड> पूरी सेटअप प्रक्रिया को आसान बनाने वाली कक्षा।