बैकअप PostgreSQL pg_dump और pg_dumpall का उपयोग कर

व्यवसाय और सेवाएं डेटा के आधार पर मूल्य प्रदान करती हैं। ग्राहकों और अंतिम-उपयोगकर्ताओं को संतुष्ट रखने के लिए उपलब्धता, सुसंगत स्थिति और स्थायित्व सर्वोच्च प्राथमिकताएं हैं। खोया या अप्राप्य डेटा संभवतः खोए हुए ग्राहकों के बराबर हो सकता है।

डेटाबेस बैकअप दैनिक संचालन और कार्यों में सबसे आगे होना चाहिए।

हमें इस घटना के लिए तैयार रहना चाहिए कि हमारा डेटा दूषित हो जाए या खो जाए।

मैं एक पुरानी कहावत में दृढ़ आस्तिक हूं जो मैंने सुना है:"इसे रखना बेहतर है और इसकी आवश्यकता नहीं है और इसकी आवश्यकता नहीं है . "

यह डेटाबेस बैकअप पर भी लागू होता है। आइए इसका सामना करते हैं, उनके बिना, आपके पास मूल रूप से कुछ भी नहीं है। इस धारणा पर काम करना कि आपके डेटा को कुछ नहीं हो सकता, एक झूठ है।

अधिकांश DBMS बिल्ट-इन बैकअप उपयोगिताओं के कुछ साधन प्रदान करते हैं। PostgreSQL में बॉक्स से बाहर pg_dump और pg_dumpall है।

दोनों कई अनुकूलन और संरचना विकल्प प्रस्तुत करते हैं। उन सभी को एक ब्लॉग पोस्ट में व्यक्तिगत रूप से कवर करना असंभव के बगल में होगा। इसके बजाय, मैं उन उदाहरणों को देखूंगा जिन्हें मैं अपने व्यक्तिगत विकास/सीखने के माहौल में सर्वोत्तम रूप से लागू कर सकता हूं।

कहा जा रहा है कि, यह ब्लॉग पोस्ट उत्पादन परिवेश पर लक्षित नहीं है। अधिक संभावना है, एक एकल कार्य केंद्र/विकास पर्यावरण को सबसे अधिक लाभ होना चाहिए।

pg_dump और pg_dumpall क्या हैं?

प्रलेखन pg_dump का वर्णन इस प्रकार करता है:"pg_dump PostgreSQL डेटाबेस का बैकअप लेने के लिए एक उपयोगिता है"

और pg_dumpall दस्तावेज़ीकरण:"pg_dumpall क्लस्टर के सभी PostgreSQL डेटाबेस को एक स्क्रिप्ट फ़ाइल में लिखने ("डंपिंग") के लिए एक उपयोगिता है।"

डेटाबेस और/या टेबल का बैकअप लेना

शुरू करने के लिए, मैं नीचे दिए गए SQL का उपयोग करके काम करने के लिए एक अभ्यास डेटाबेस और कुछ तालिकाएँ बनाऊँगा:

postgres=# CREATE DATABASE example_backups;
CREATE DATABASE

example_backups=# CREATE TABLE students(id INTEGER,
example_backups(# f_name VARCHAR(20),
example_backups(# l_name VARCHAR(20));
CREATE TABLE

example_backups=# CREATE TABLE classes(id INTEGER,
example_backups(# subject VARCHAR(20));
CREATE TABLE

example_backups=# INSERT INTO students(id, f_name, l_name)
example_backups-# VALUES (1, 'John', 'Thorn'), (2, 'Phil', 'Hampt'),
example_backups-# (3, 'Sue', 'Dean'), (4, 'Johnny', 'Rames');
INSERT 0 4

example_backups=# INSERT INTO classes(id, subject)
example_backups-# VALUES (1, 'Math'), (2, 'Science'),
example_backups-# (3, 'Biology');
INSERT 0 3

example_backups=# \dt;
         List of relations
Schema |   Name | Type  | Owner
--------+----------+-------+----------
public | classes  | table | postgres
public | students | table | postgres
(2 rows)

example_backups=# SELECT * FROM students;
id | f_name | l_name
----+--------+--------
 1 | John   | Thorn
 2 | Phil   | Hampt
 3 | Sue    | Dean
 4 | Johnny | Rames
(4 rows)

example_backups=# SELECT * FROM classes;
id | subject
----+---------
 1 | Math
 2 | Science
 3 | Biology
(3 rows)

डेटाबेस और टेबल सभी सेट अप।

ध्यान दें:

इनमें से कई उदाहरणों में, मैं psql के \! मेटा-कमांड, आपको या तो एक शेल (कमांड-लाइन) में छोड़ने की अनुमति देता है, या जो भी शेल कमांड का पालन करता है उसे निष्पादित करता है।

बस इस बात से अवगत रहें कि टर्मिनल या कमांड-लाइन सत्र में (इस ब्लॉग पोस्ट में एक अग्रणी '$' द्वारा दर्शाया गया है), \! मेटा-कमांड को किसी भी pg_dump या pg_dumpall कमांड में शामिल नहीं किया जाना चाहिए। फिर से, यह psql के भीतर एक सुविधा मेटा-कमांड है।

एक टेबल का बैकअप लेना

इस पहले उदाहरण में, मैं केवल छात्र तालिका को डंप करूँगा:

example_backups=# \! pg_dump -U postgres -t students example_backups > ~/Example_Dumps/students.sql.

निर्देशिका की सामग्री को सूचीबद्ध करते हुए, हम देखते हैं कि फ़ाइल वहाँ है:

example_backups=# \! ls -a ~/Example_Dumps
.  .. students.sql

इस व्यक्तिगत कमांड के लिए कमांड-लाइन विकल्प हैं:

-यू पोस्टग्रेज करता है:निर्दिष्ट उपयोगकर्ता नाम
-t छात्र:डंप करने के लिए टेबल
example_backups:डेटाबेस

Students.sql फ़ाइल में क्या है?

$ cat students.sql
--
-- PostgreSQL database dump
--
-- Dumped from database version 10.4 (Ubuntu 10.4-2.pgdg16.04+1)
-- Dumped by pg_dump version 10.4 (Ubuntu 10.4-2.pgdg16.04+1)
SET statement_timeout = 0;
SET lock_timeout = 0;
SET idle_in_transaction_session_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SELECT pg_catalog.set_config('search_path', '', false);
SET check_function_bodies = false;
SET client_min_messages = warning;
SET row_security = off;
 
SET default_tablespace = '';
 
SET default_with_oids = false;
 
--
-- Name: students; Type: TABLE; Schema: public; Owner: postgres
--
CREATE TABLE public.students (
   id integer,
   f_name character varying(20),
   l_name character varying(20)
);
 
ALTER TABLE public.students OWNER TO postgres;
 
--
-- Data for Name: students; Type: TABLE DATA; Schema: public; Owner: postgres
--
COPY public.students (id, f_name, l_name) FROM stdin;
1 John Thorn
2 Phil Hampt
3 Sue Dean
4 Johnny Rames
\.
--
-- PostgreSQL database dump complete

हम देख सकते हैं कि फ़ाइल में टेबल छात्रों को फिर से बनाने और फिर से भरने के लिए आवश्यक SQL कमांड हैं।

लेकिन, क्या बैकअप अच्छा है? भरोसेमंद और काम कर रहे हैं?

हम इसका परीक्षण करेंगे और देखेंगे।

example_backups=# DROP TABLE students;
DROP TABLE

example_backups=# \dt;
         List of relations
Schema |  Name | Type  | Owner
--------+---------+-------+----------
public | classes | table | postgres
(1 row)

यह चला गया है।

फिर कमांड-लाइन से सहेजे गए बैकअप को psql में पास करें:

$ psql -U postgres -W -d example_backups -f ~/Example_Dumps/students.sql
Password for user postgres:
SET
SET
SET
SET
SET
set_config
------------
(1 row)
 
SET
SET
SET
SET
SET
CREATE TABLE
ALTER TABLE
COPY 4

आइए डेटाबेस में सत्यापित करें:

example_backups=# \dt;
         List of relations
Schema |   Name | Type  | Owner
--------+----------+-------+----------
public | classes  | table | postgres
public | students | table | postgres
(2 rows)

example_backups=# SELECT * FROM students;
id | f_name | l_name
----+--------+--------
 1 | John   | Thorn
 2 | Phil   | Hampt
 3 | Sue    | Dean
 4 | Johnny | Rames
(4 rows)

तालिका और डेटा बहाल कर दिया गया है।

एकाधिक तालिकाओं का बैकअप लेना

इस अगले उदाहरण में, हम इस कमांड का उपयोग करके दोनों तालिकाओं का बैकअप लेंगे:

example_backups=# \! pg_dump -U postgres -W -t classes -t students -d example_backups > ~/Example_Dumps/all_tables.sql
Password:

(ध्यान दें कि -W विकल्प के कारण मुझे इस कमांड में एक पासवर्ड निर्दिष्ट करने की आवश्यकता है, जहां मैंने पहले उदाहरण में नहीं किया था। इस पर और अधिक आने के लिए।)

आइए फिर से सत्यापित करें कि निर्देशिका सामग्री को सूचीबद्ध करके फ़ाइल बनाई गई थी:

example_backups=# \! ls -a ~/Example_Dumps
.  .. all_tables.sql  students.sql

फिर टेबल छोड़ दें:

example_backups=# DROP TABLE classes;
DROP TABLE
example_backups=# DROP TABLE students;
DROP TABLE
example_backups=# \dt;
Did not find any relations.

फिर all_tables.sql बैकअप फ़ाइल के साथ पुनर्स्थापित करें:

$ psql -U postgres -W -d example_backups -f ~/Example_Dumps/all_tables.sql
Password for user postgres:
SET
SET
SET
SET
SET
set_config
------------
(1 row)
 
SET
SET
SET
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
COPY 3
COPY 4

example_backups=# \dt;
         List of relations
Schema |   Name | Type  | Owner
--------+----------+-------+----------
public | classes  | table | postgres
public | students | table | postgres
(2 rows)

दोनों टेबल को बहाल कर दिया गया है।

जैसा कि हम pg_dump के साथ देख सकते हैं, आप किसी विशिष्ट डेटाबेस में केवल एक या एकाधिक तालिकाओं का बैकअप ले सकते हैं।

डेटाबेस का बैकअप लेना

आइए अब देखें कि pg_dump के साथ संपूर्ण example_backups डेटाबेस का बैकअप कैसे लें।

example_backups=# \! pg_dump -U postgres -W -d example_backups > ~/Example_Dumps/ex_back_db.sql
Password:
 
example_backups=# \! ls -a ~/Example_Dumps
.  .. all_tables.sql  ex_back_db.sql students.sql

Ex_back_db.sql फ़ाइल वहाँ है।

example_backups डेटाबेस को छोड़ने के लिए मैं पोस्टग्रेज़ डेटाबेस से जुड़ूँगा।

postgres=# DROP DATABASE example_backups;
DROP DATABASE

फिर कमांड-लाइन से पुनर्स्थापित करें:

$ psql -U postgres -W -d example_backups -f ~/Example_Dumps/ex_back_db.sql
Password for user postgres:
psql: FATAL:  database "example_backups" does not exist

यह वहाँ नहीं है। क्यों नहीं? और वह कहाँ है?

हमें इसे पहले बनाना होगा।

postgres=# CREATE DATABASE example_backups;
CREATE DATABASE

फिर उसी कमांड से रिस्टोर करें:

$ psql -U postgres -W -d example_backups -f ~/Example_Dumps/ex_back_db.sql
Password for user postgres:
SET
SET
SET
SET
SET
set_config
------------
(1 row)
 
SET
SET
SET
CREATE EXTENSION
COMMENT
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
COPY 3
COPY 4

postgres=# \c example_backups;
You are now connected to database "example_backups" as user "postgres".
example_backups=# \dt;
         List of relations
Schema |   Name | Type  | Owner
--------+----------+-------+----------
public | classes  | table | postgres
public | students | table | postgres
(2 rows)

डेटाबेस और सभी टेबल मौजूद हैं और उनका हिसाब रखा गया है।

बैकअप लेते समय -C विकल्प को शामिल करके हम पहले लक्ष्य डेटाबेस बनाने के इस परिदृश्य से बच सकते हैं।

example_backups=# \! pg_dump -U postgres -W -C -d example_backups > ~/Example_Dumps/ex_back2_db.sql
Password:

मैं पोस्टग्रेज़ डेटाबेस से फिर से कनेक्ट करूँगा और example_backups डेटाबेस को छोड़ दूँगा ताकि हम देख सकें कि अब पुनर्स्थापना कैसे काम करती है (ध्यान दें कि कनेक्ट और DROP कमांड संक्षिप्तता के लिए नहीं दिखाए गए हैं)।

फिर कमांड-लाइन पर (नोटिस no -d dbname विकल्प शामिल है):

$ psql -U postgres -W -f ~/Example_Dumps/ex_back2_db.sql
Password for user postgres:
……………..
(And partway through the output...)
CREATE DATABASE
ALTER DATABASE
Password for user postgres:
You are now connected to database "example_backups" as user "postgres".
SET
SET
SET
SET
SET
set_config
------------
(1 row)
 
SET
SET
SET
CREATE EXTENSION
COMMENT
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
COPY 3
COPY 4

-C विकल्प का उपयोग करते हुए, हमें कनेक्शन बनाने के लिए पासवर्ड के लिए कहा जाता है, जैसा कि -C ध्वज से संबंधित दस्तावेज़ीकरण में बताया गया है:

"डेटाबेस को स्वयं बनाने और बनाए गए डेटाबेस से फिर से कनेक्ट करने के लिए एक कमांड के साथ आउटपुट शुरू करें।"

फिर psql सत्र में:

postgres=# \c example_backups;
You are now connected to database "example_backups" as user "postgres".

सब कुछ बहाल कर दिया गया है, जाने के लिए अच्छा है, और पुनर्स्थापना से पहले लक्ष्य डेटाबेस बनाने की आवश्यकता के बिना।

पूरे क्लस्टर के लिए pg_dumpall

अब तक, हमने एक टेबल, कई टेबल और एक डेटाबेस का बैकअप लिया है।

लेकिन अगर हम इससे अधिक चाहते हैं, उदाहरण के लिए पूरे PostgreSQL क्लस्टर का बैकअप लेना, तो हमें pg_dumpall का उपयोग करने की आवश्यकता है।

तो pg_dump और pg_dumpall के बीच कुछ उल्लेखनीय अंतर क्या हैं?

शुरुआत के लिए, यहाँ दस्तावेज़ीकरण से एक महत्वपूर्ण अंतर है:

"चूंकि pg_dumpall सभी डेटाबेस से तालिकाओं को पढ़ता है, इसलिए आपको पूर्ण डंप बनाने के लिए डेटाबेस सुपरयुसर के रूप में कनेक्ट होने की सबसे अधिक संभावना होगी। साथ ही, आपको उपयोगकर्ताओं और समूहों को जोड़ने और डेटाबेस बनाने की अनुमति देने के लिए सहेजी गई स्क्रिप्ट को निष्पादित करने के लिए सुपरयुसर विशेषाधिकारों की आवश्यकता होगी।"

नीचे दिए गए आदेश का उपयोग करते हुए, मैं अपने पूरे PostgreSQL क्लस्टर का बैकअप लूंगा और इसे संपूर्ण_cluster.sql फ़ाइल में सहेजूंगा:

$ pg_dumpall -U postgres -W -f ~/Example_Dumps/Cluster_Dumps/entire_cluster.sql
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:
Password:

पृथ्वी पर क्या? क्या आप सोच रहे हैं कि क्या मुझे प्रत्येक संकेत के लिए एक पासवर्ड दर्ज करना होगा?

हाँ, ज़रूर किया। 24 बार।

उन्हें गिनें। (अरे, जैसे-जैसे मैं सीखता हूं, मैं अलग-अलग डेटाबेस को एक्सप्लोर करना और तल्लीन करना पसंद करता हूं? मैं क्या कह सकता हूं?)

लेकिन सभी संकेत क्यों?

सबसे पहले, इतनी मेहनत के बाद क्या pg_dumpall ने बैकअप फ़ाइल बनाई?

postgres=# \! ls -a ~/Example_Dumps/Cluster_Dumps
.  .. entire_cluster.sql

हाँ, बैकअप फ़ाइल वहाँ है।

आइए उस सभी 'टाइपिंग अभ्यास . पर कुछ प्रकाश डालें ' दस्तावेज़ीकरण से इस मार्ग को देखकर:

"pg_dumpall को PostgreSQL सर्वर (एक बार प्रति डेटाबेस) से कई बार कनेक्ट करने की आवश्यकता होती है। यदि आप पासवर्ड प्रमाणीकरण का उपयोग करते हैं तो यह हर बार पासवर्ड मांगेगा।"

मुझे पता है कि तुम क्या सोच रहे हो।

यह आदर्श या व्यवहार्य भी नहीं हो सकता है। आधी रात में चलने वाली प्रक्रियाओं, स्क्रिप्ट या क्रॉन जॉब्स के बारे में क्या?

क्या कोई टाइप करने के लिए कीबोर्ड पर होवर करने जा रहा है?

शायद नहीं।

उन दोहराए गए पासवर्ड संकेतों का सामना करने से रोकने के लिए एक प्रभावी उपाय ~/.pgpass फ़ाइल है।

यहाँ वाक्य रचना है ~/.pgpass फ़ाइल को काम करने की आवश्यकता है (उदाहरण दस्तावेज़ीकरण से प्रदान किया गया है ऊपर लिंक देखें):

hostname:port:database:username:password

मेरे विकास परिवेश में मौजूद ~/.pgpass फ़ाइल के साथ, पोस्टग्रेज भूमिका के लिए आवश्यक क्रेडेंशियल्स के साथ, मैं -W (भी -w) विकल्प को छोड़ सकता हूं और पासवर्ड के साथ मैन्युअल रूप से प्रमाणित किए बिना pg_dumpall चला सकता हूं:

$ pg_dumpall -U postgres -f ~/Example_Dumps/Cluster_Dumps/entire_cluster2nd.sql

निर्देशिका सामग्री को सूचीबद्ध करना:

postgres=# \! ls -a ~/Example_Dumps/Cluster_Dumps
.  .. entire_cluster2nd.sql  entire_cluster.sql

फ़ाइल बनाई गई है और कोई दोहराए जाने वाला पासवर्ड संकेत नहीं देता है।

सहेजी गई फ़ाइल को pg_dump के समान psql के साथ पुनः लोड किया जा सकता है।

दस्तावेज़ीकरण से इस मार्ग के अनुसार कनेक्शन डेटाबेस कम महत्वपूर्ण है:"यह महत्वपूर्ण नहीं है कि आप यहां किस डेटाबेस से जुड़ते हैं क्योंकि pg_dumpall द्वारा बनाई गई स्क्रिप्ट फ़ाइल में सहेजे गए डेटाबेस बनाने और कनेक्ट करने के लिए उपयुक्त कमांड होंगे।" आज श्वेतपत्र डाउनलोड करें क्लस्टरकंट्रोल के साथ पोस्टग्रेएसक्यूएल प्रबंधन और स्वचालन इस बारे में जानें कि पोस्टग्रेएसक्यूएल को तैनात करने, मॉनिटर करने, प्रबंधित करने और स्केल करने के लिए आपको क्या जानना चाहिए। श्वेतपत्र डाउनलोड करें

pg_dump, pg_dumpall, और शेल स्क्रिप्ट - एक आसान संयोजन

इस खंड में, हम pg_dump और pg_dumpall को सरल शेल स्क्रिप्ट में शामिल करने के कुछ उदाहरण देखेंगे।

स्पष्ट रहें, यह शेल स्क्रिप्ट ट्यूटोरियल नहीं है। न ही मैं शेल स्क्रिप्ट गुरु हूं। मैं मुख्य रूप से अपने स्थानीय विकास/सीखने के माहौल में उपयोग किए जाने वाले कुछ उदाहरण प्रदान करूंगा।

सबसे पहले, आइए एक साधारण शेल स्क्रिप्ट को देखें जिसका उपयोग आप किसी एकल डेटाबेस का बैकअप लेने के लिए कर सकते हैं:

#!/bin/bash
# This script performs a pg_dump, saving the file the specified dir.
# The first arg ($1) is the database user to connect with.
# The second arg ($2) is the database to backup and is included in the file name.
# $(date +"%Y_%m_%d") includes the current system date into the actual file name.

pg_dump -U $1 -W -C -d $2 > ~/PG_dumps/Dump_Scripts/$(date +"%Y_%m_%d")_$2.sql

जैसा कि आप देख सकते हैं, यह स्क्रिप्ट 2 तर्कों को स्वीकार करती है:पहला बैकअप के लिए कनेक्ट करने के लिए उपयोगकर्ता (या भूमिका) है, जबकि दूसरा उस डेटाबेस का नाम है जिसका आप बैकअप लेना चाहते हैं।

कमांड में -C विकल्प पर ध्यान दें ताकि यदि डेटाबेस पहले से मौजूद नहीं है, तो हम इसे पहले से मैन्युअल रूप से बनाने की आवश्यकता के बिना पुनर्स्थापित कर सकते हैं।

आइए example_backups डेटाबेस के लिए पोस्टग्रेज भूमिका के साथ स्क्रिप्ट को कॉल करें (पहली बार कॉल करने से पहले कम से कम chmod +x के साथ स्क्रिप्ट को निष्पादन योग्य बनाना न भूलें):

$ ~/My_Scripts/pgd.sh postgres example_backups
Password:

और सत्यापित करें कि यह वहां है:

$ ls -a ~/PG_dumps/Dump_Scripts/
.  .. 2018_06_06_example_backups.sql

पिछले उदाहरणों की तरह इस बैकअप स्क्रिप्ट के साथ बहाली की जाती है।

संपूर्ण PostgreSQL क्लस्टर का बैकअप लेने के लिए pg_dumpall के साथ एक समान शेल स्क्रिप्ट का उपयोग किया जा सकता है।

यह शेल स्क्रिप्ट (|) pg_dumpall को gzip में पाइप करेगी, जिसे तब निर्दिष्ट फ़ाइल स्थान पर निर्देशित किया जाता है:

#!/bin/bash
# This shell script calls pg_dumpall and pipes into the gzip utility, then directs to
# a directory for storage.
# $(date +"%Y_%m_%d") incorporates the current system date into the file name.
 
pg_dumpall -U postgres | gzip > ~/PG_dumps/Cluster_Dumps/$(date +"%Y_%m_%d")_pg_bck.gz

पिछली उदाहरण स्क्रिप्ट के विपरीत, यह किसी भी तर्क को स्वीकार नहीं करता है।

मैं इस स्क्रिप्ट को कमांड-लाइन पर कॉल करूंगा, (कोई पासवर्ड प्रॉम्प्ट नहीं है क्योंकि पोस्टग्रेज भूमिका ~/.pgpass फ़ाइल का उपयोग करती है - ऊपर अनुभाग देखें।)

$ ~/My_Scripts/pgalldmp.sh

एक बार पूरा हो जाने पर, मैं .sql और gz फ़ाइलों के बीच तुलना के लिए फ़ाइल आकार दिखाने वाली निर्देशिका सामग्री को सूचीबद्ध करूँगा:

postgres=# \! ls -sh ~/PG_dumps/Cluster_Dumps
total 957M
37M 2018_05_22_pg_bck.gz   32M 2018_06_06_pg_bck.gz 445M entire_cluster2nd.sql  445M entire_cluster.sql

दस्तावेज़ों से gz संग्रह प्रारूप के लिए एक नोट:

"डेटाबेस के पुनर्निर्माण के लिए वैकल्पिक संग्रह फ़ाइल स्वरूपों का उपयोग pg_restore के साथ किया जाना चाहिए।"

सारांश

मैंने इस ब्लॉग पोस्ट को बंद करने के लिए, अपनी टिप्पणियों के साथ, pg_dump और pg_dumpall पर प्रलेखन से मुख्य बिंदुओं को इकट्ठा किया है:

नोट:प्रलेखन से प्रदान किए गए अंक उद्धरणों में हैं।

“pg_dump केवल एक डेटाबेस को डंप करता है”
सादा-पाठ SQL फ़ाइल स्वरूप pg_dump के लिए डिफ़ॉल्ट आउटपुट है।
प्रलेखन में इस पंक्ति के अनुसार pg_dump चलाने के लिए एक भूमिका को SELECT विशेषाधिकार की आवश्यकता होती है:"pg_dump आंतरिक रूप से SELECT कथन निष्पादित करता है। यदि आपको pg_dump चलाने में समस्या हो रही है, तो सुनिश्चित करें कि आप डेटाबेस से जानकारी का चयन करने में सक्षम हैं, उदाहरण के लिए, psql”
आवश्यक DDL CREATE DATABASE कमांड और बैकअप फ़ाइल में एक कनेक्शन शामिल करने के लिए, -C विकल्प शामिल करें।
-W:यह विकल्प pg_dump को पासवर्ड के लिए प्रांप्ट करने के लिए बाध्य करता है। यह ध्वज आवश्यक नहीं है क्योंकि यदि सर्वर को पासवर्ड की आवश्यकता होती है, तो आपको वैसे भी संकेत दिया जाता है। फिर भी, प्रलेखन में इस मार्ग ने मेरी आंख को पकड़ लिया, इसलिए मैंने इसे यहां शामिल करने के बारे में सोचा:"हालांकि, pg_dump यह पता लगाने के लिए कनेक्शन प्रयास को बर्बाद कर देगा कि सर्वर एक पासवर्ड चाहता है। कुछ मामलों में अतिरिक्त कनेक्शन प्रयास से बचने के लिए -W टाइप करना उचित है।"
-d:कनेक्ट करने के लिए डेटाबेस निर्दिष्ट करता है। दस्तावेज़ीकरण में भी:"यह dbname को कमांड लाइन पर पहले गैर-विकल्प तर्क के रूप में निर्दिष्ट करने के बराबर है।"
फ्लैग का उपयोग करना जैसे -t (टेबल) उपयोगकर्ताओं को डेटाबेस के कुछ हिस्सों का बैकअप लेने की अनुमति देता है, अर्थात् टेबल, उनके पास एक्सेस विशेषाधिकार हैं।
बैकअप फ़ाइल स्वरूप भिन्न हो सकते हैं। हालाँकि, .sql फ़ाइलें दूसरों के बीच एक बढ़िया विकल्प हैं। पुनर्स्थापित करने के लिए psql द्वारा बैकअप फ़ाइलें वापस पढ़ी जाती हैं।
pg_dump अन्य कार्यों (यानी, अन्य पाठकों और लेखकों) के साथ हस्तक्षेप किए बिना एक चालू, सक्रिय डेटाबेस का बैकअप ले सकता है।
एक चेतावनी:pg_dump टेबल स्पेस सहित भूमिकाओं या अन्य डेटाबेस ऑब्जेक्ट को डंप नहीं करता, केवल एक डेटाबेस।
अपने संपूर्ण PostgreSQL क्लस्टर पर बैकअप लेने के लिए, pg_dumpall बेहतर विकल्प है।
pg_dumpall पूरे क्लस्टर को संभाल सकता है, भूमिकाओं, टेबलस्पेस, उपयोगकर्ताओं, अनुमतियों, आदि पर जानकारी का बैकअप ले सकता है ... जहां pg_dump नहीं कर सकता।
संभावना है, SUPERUSER विशेषाधिकारों के साथ एक भूमिका को डंप करना होगा, और फ़ाइल को पुनर्स्थापित/पुन:बनाना होगा जब इसे psql के माध्यम से वापस पढ़ा जाएगा क्योंकि पुनर्स्थापना के दौरान, सभी डेटाबेस में सभी तालिकाओं को पढ़ने के लिए विशेषाधिकार की आवश्यकता होती है।

मेरी आशा इस ब्लॉग पोस्ट के माध्यम से है, मैंने एक ही विकास/अधिगम PostgreSQL वातावरण के लिए pg_dump और pg_dumpall पर शुरुआती स्तर के अवलोकन के लिए पर्याप्त उदाहरण और विवरण प्रदान किए हैं।

हालांकि सभी उपलब्ध विकल्पों का पता नहीं लगाया गया था, आधिकारिक दस्तावेज में दोनों उपयोगिताओं के उदाहरणों के साथ जानकारी का खजाना है, इसलिए सुनिश्चित करें और आगे के अध्ययन, प्रश्नों और पढ़ने के लिए उस संसाधन से परामर्श लें।