🥇WAL-G: PostgreSQL DBMS இன் காப்பு பிரதிகள் மற்றும் மீட்பு

SQL டம்ப்களாக காப்புப்பிரதிகளை உருவாக்குவது நீண்ட காலமாக அறியப்படுகிறது (பயன்படுத்துதல் pg_dump அல்லது pg_dumpall) ஒரு நல்ல யோசனை இல்லை. PostgreSQL DBMS ஐ காப்புப் பிரதி எடுக்க, கட்டளையைப் பயன்படுத்துவது நல்லது pg_basebackup, இது WAL பதிவுகளின் பைனரி நகலை உருவாக்குகிறது. ஆனால் நகலை உருவாக்கி மீட்டெடுப்பதற்கான முழு செயல்முறையையும் நீங்கள் படிக்கத் தொடங்கும்போது, இது வேலை செய்ய குறைந்தபட்சம் இரண்டு முச்சக்கரவண்டிகளையாவது எழுத வேண்டும் என்பதை நீங்கள் புரிந்துகொள்வீர்கள், மேலும் உங்களுக்கு மேலேயும் கீழேயும் வலியை ஏற்படுத்தாது. துன்பத்தைப் போக்க, WAL-G உருவாக்கப்பட்டது.

வால்-ஜி PostgreSQL தரவுத்தளங்களை காப்புப் பிரதி எடுப்பதற்கும் மீட்டமைப்பதற்கும் Go இல் எழுதப்பட்ட ஒரு கருவியாகும் (மேலும் சமீபத்தில் MySQL/MariaDB, MongoDB மற்றும் FoundationDB) இது அமேசான் S3 சேமிப்பகத்துடன் (மற்றும் அனலாக்ஸ், எடுத்துக்காட்டாக, யாண்டெக்ஸ் ஆப்ஜெக்ட் ஸ்டோரேஜ்), அத்துடன் கூகுள் கிளவுட் ஸ்டோரேஜ், அஸூர் ஸ்டோரேஜ், ஸ்விஃப்ட் ஆப்ஜெக்ட் ஸ்டோரேஜ் மற்றும் கோப்பு முறைமையுடன் வேலை செய்வதை ஆதரிக்கிறது. முழு அமைப்பும் எளிமையான படிகளுக்குக் கீழே வருகிறது, ஆனால் அதைப் பற்றிய கட்டுரைகள் இணையம் முழுவதும் சிதறிக் கிடப்பதால், ஆரம்பம் முதல் முடிவு வரை அனைத்து படிகளையும் உள்ளடக்கிய முழுமையான கையேடு எதுவும் இல்லை (ஹப்ரேயில் பல இடுகைகள் உள்ளன, ஆனால் பல புள்ளிகள் அங்கு தவறவிடப்பட்டுள்ளன).

இந்தக் கட்டுரை எனது அறிவை முறைப்படுத்தவே முதன்மையாக எழுதப்பட்டது. நான் ஒரு DBA அல்ல, மேலும் எங்காவது சாமானியரின் மொழியில் என்னை வெளிப்படுத்த முடியும், எனவே ஏதேனும் திருத்தங்கள் வரவேற்கப்படுகின்றன!

தனித்தனியாக, உபுண்டு 12.3 இல் PostgreSQL 18.04 க்கு கீழே உள்ள அனைத்தும் பொருத்தமானது மற்றும் சோதிக்கப்பட்டது என்பதை நான் கவனிக்கிறேன், அனைத்து கட்டளைகளும் ஒரு சலுகை பெற்ற பயனராக செயல்படுத்தப்பட வேண்டும்.

நிறுவல்

இந்த கட்டுரையை எழுதும் நேரத்தில், WAL-G இன் நிலையான பதிப்பு v0.2.15 (மார்ச் 2020). இதைத்தான் நாங்கள் பயன்படுத்துவோம் (ஆனால் நீங்கள் அதை முதன்மை கிளையிலிருந்து உருவாக்க விரும்பினால், கிதுப் களஞ்சியத்தில் இதற்கான அனைத்து வழிமுறைகளும் உள்ளன) பதிவிறக்கம் செய்து நிறுவ நீங்கள் செய்ய வேண்டியது:

#!/bin/bash

curl -L "https://github.com/wal-g/wal-g/releases/download/v0.2.15/wal-g.linux-amd64.tar.gz" -o "wal-g.linux-amd64.tar.gz"
tar -xzf wal-g.linux-amd64.tar.gz
mv wal-g /usr/local/bin/

இதற்குப் பிறகு, நீங்கள் முதலில் WAL-G ஐ கட்டமைக்க வேண்டும், பின்னர் PostgreSQL ஐ கட்டமைக்க வேண்டும்.

WAL-G ஐ அமைத்தல்

காப்புப்பிரதிகளை சேமிப்பதற்கான உதாரணத்திற்கு, Amazon S3 பயன்படுத்தப்படும் (ஏனெனில் இது எனது சேவையகங்களுக்கு நெருக்கமாக உள்ளது மற்றும் அதன் பயன்பாடு மிகவும் மலிவானது) அதனுடன் வேலை செய்ய, உங்களுக்கு "s3 பக்கெட்" மற்றும் அணுகல் விசைகள் தேவை.

WAL-G பற்றிய அனைத்து முந்தைய கட்டுரைகளும் சூழல் மாறிகளைப் பயன்படுத்தி உள்ளமைவைப் பயன்படுத்தியது, ஆனால் இந்த வெளியீட்டில் அமைப்புகளை உள்ளிடலாம் .walg.json கோப்பு postgres பயனரின் முகப்பு கோப்பகத்தில். அதை உருவாக்க, பின்வரும் பாஷ் ஸ்கிரிப்டை இயக்கவும்:

#!/bin/bash

cat > /var/lib/postgresql/.walg.json << EOF
{
    "WALG_S3_PREFIX": "s3://your_bucket/path",
    "AWS_ACCESS_KEY_ID": "key_id",
    "AWS_SECRET_ACCESS_KEY": "secret_key",
    "WALG_COMPRESSION_METHOD": "brotli",
    "WALG_DELTA_MAX_STEPS": "5",
    "PGDATA": "/var/lib/postgresql/12/main",
    "PGHOST": "/var/run/postgresql/.s.PGSQL.5432"
}
EOF
# обязательно меняем владельца файла:
chown postgres: /var/lib/postgresql/.walg.json

எல்லா அளவுருக்களையும் பற்றி கொஞ்சம் விளக்குகிறேன்:

WALG_S3_PREFIX - காப்புப்பிரதிகள் பதிவேற்றப்படும் உங்கள் S3 வாளிக்கான பாதை (நீங்கள் ரூட்டிற்கு அல்லது கோப்புறையில் செய்யலாம்);
AWS_ACCESS_KEY_ID - S3 இல் அணுகல் விசை (சோதனைச் சேவையகத்தில் மீட்டெடுக்கப்பட்டால், இந்த விசைகள் படிக்க மட்டும் கொள்கையைக் கொண்டிருக்க வேண்டும்! மீட்பு பற்றிய பிரிவில் இது இன்னும் விரிவாக விவரிக்கப்பட்டுள்ளது.);
AWS_SECRET_ACCESS_KEY - S3 சேமிப்பகத்தில் இரகசிய விசை;
WALG_COMPRESSION_METHOD - சுருக்க முறை, ப்ரோட்லியைப் பயன்படுத்துவது நல்லது (இறுதி அளவு மற்றும் சுருக்க/டிகம்பரஷ்ஷன் வேகத்திற்கு இடையே உள்ள தங்க சராசரி இது என்பதால்);
WALG_DELTA_MAX_STEPS - முழு காப்புப்பிரதியை உருவாக்கும் முன் "டெல்டாக்கள்" எண்ணிக்கை (அவை பதிவிறக்கம் செய்யப்பட்ட தரவின் நேரத்தையும் அளவையும் சேமிக்கின்றன, ஆனால் மீட்டெடுப்பு செயல்முறையை சிறிது குறைக்கலாம், எனவே பெரிய மதிப்புகளைப் பயன்படுத்துவது நல்லதல்ல);
PGDATA - உங்கள் தரவுத்தளத் தரவுடன் கோப்பகத்திற்கான பாதை (கட்டளையை இயக்குவதன் மூலம் நீங்கள் கண்டுபிடிக்கலாம் pg_lsclusters);
PGHOST - தரவுத்தளத்துடன் இணைத்தல், உள்ளூர் காப்புப்பிரதியுடன் இந்த எடுத்துக்காட்டில் உள்ளதைப் போல யூனிக்ஸ்-சாக்கெட் வழியாகச் செய்வது நல்லது.

மற்ற அளவுருக்கள் ஆவணத்தில் காணலாம்: https://github.com/wal-g/wal-g/blob/v0.2.15/PostgreSQL.md#configuration.

PostgreSQL ஐ அமைக்கிறது

தரவுத்தளத்தில் உள்ள காப்பகத்திற்கு WAL பதிவுகளை மேகக்கணியில் பதிவேற்றவும், அவற்றை மீட்டெடுக்கவும் (தேவைப்பட்டால்), நீங்கள் உள்ளமைவு கோப்பில் பல அளவுருக்களை அமைக்க வேண்டும். /etc/postgresql/12/main/postgresql.conf. ஆரம்பிப்பவர்களுக்கு மட்டும் நீங்கள் உறுதி செய்ய வேண்டும்கீழே உள்ள அமைப்புகள் எதுவும் வேறு எந்த மதிப்புகளுக்கும் அமைக்கப்படவில்லை, அதனால் உள்ளமைவு மீண்டும் ஏற்றப்படும் போது, DBMS செயலிழக்காது. இதைப் பயன்படுத்தி இந்த அளவுருக்களை நீங்கள் சேர்க்கலாம்:

#!/bin/bash

echo "wal_level=replica" >> /etc/postgresql/12/main/postgresql.conf
echo "archive_mode=on" >> /etc/postgresql/12/main/postgresql.conf
echo "archive_command='/usr/local/bin/wal-g wal-push "%p" >> /var/log/postgresql/archive_command.log 2>&1' " >> /etc/postgresql/12/main/postgresql.conf
echo “archive_timeout=60” >> /etc/postgresql/12/main/postgresql.conf
echo "restore_command='/usr/local/bin/wal-g wal-fetch "%f" "%p" >> /var/log/postgresql/restore_command.log 2>&1' " >> /etc/postgresql/12/main/postgresql.conf

# перезагружаем конфиг через отправку SIGHUP сигнала всем процессам БД
killall -s HUP postgres

அமைக்க வேண்டிய அளவுருக்களின் விளக்கம்:

வால்_நிலை - WAL பதிவுகளில் எவ்வளவு தகவல்களை எழுத வேண்டும், "பிரதி" - எல்லாவற்றையும் எழுதுங்கள்;
காப்பக_முறை - அளவுருவிலிருந்து கட்டளையைப் பயன்படுத்தி WAL பதிவுகளைப் பதிவிறக்குவதை இயக்கவும் காப்பகம்_கட்டளை;
காப்பகம்_கட்டளை - முடிக்கப்பட்ட WAL பதிவை காப்பகப்படுத்துவதற்கான கட்டளை;
காப்பக_காலம் முடிந்தது - பதிவுகளை காப்பகப்படுத்துவது அது முடிந்ததும் மட்டுமே செய்யப்படுகிறது, ஆனால் உங்கள் சேவையகம் தரவுத்தளத்தில் சிறிய தரவை மாற்றினால் / சேர்த்தால், சில நொடிகளில் இங்கே வரம்பை அமைப்பது அர்த்தமுள்ளதாக இருக்கும், அதன் பிறகு காப்பக கட்டளை வலுக்கட்டாயமாக அழைக்கப்படும் (நான் ஒவ்வொரு நொடியும் தரவுத்தளத்தில் தீவிரமாக எழுதுகிறேன், எனவே உற்பத்தியில் இந்த அளவுருவை அமைக்க வேண்டாம் என்று முடிவு செய்தேன்);
மீட்டமை_கட்டளை - "முழு காப்புப்பிரதி" (அடிப்படை காப்புப்பிரதி) தரவுத்தளத்தில் சமீபத்திய மாற்றங்கள் இல்லாதிருந்தால், காப்புப்பிரதியிலிருந்து WAL பதிவை மீட்டமைப்பதற்கான கட்டளை பயன்படுத்தப்படும்.

அதிகாரப்பூர்வ ஆவணத்தின் மொழிபெயர்ப்பில் இந்த அளவுருக்கள் அனைத்தையும் பற்றி மேலும் படிக்கலாம்: https://postgrespro.ru/docs/postgresql/12/runtime-config-wal.

காப்புப் பிரதி அட்டவணையை அமைத்தல்

ஒருவர் என்ன சொன்னாலும், அதை இயக்க மிகவும் வசதியான வழி கிரான். காப்புப்பிரதிகளை உருவாக்க இதைத்தான் கட்டமைப்போம். முழு காப்புப்பிரதியை உருவாக்குவதற்கான கட்டளையுடன் ஆரம்பிக்கலாம்: wal-g இல் இது வெளியீட்டு வாதம் காப்பு-மிகுதி. ஆனால் முதலில், போஸ்ட்கிரெஸ் பயனரிடமிருந்து இந்த கட்டளையை கைமுறையாக இயக்குவது நல்லது (மற்றும் அணுகல் பிழைகள் எதுவும் இல்லை):

#!/bin/bash

su - postgres -c '/usr/local/bin/wal-g backup-push /var/lib/postgresql/12/main'

வெளியீட்டு வாதங்கள் தரவு கோப்பகத்திற்கான பாதையைக் குறிக்கின்றன - நீங்கள் அதை இயக்குவதன் மூலம் கண்டுபிடிக்கலாம் என்பதை நான் உங்களுக்கு நினைவூட்டுகிறேன் pg_lsclusters.

எல்லாமே பிழைகள் இல்லாமல் சென்று தரவு S3 சேமிப்பகத்தில் ஏற்றப்பட்டால், நீங்கள் க்ரான்டாப்பில் குறிப்பிட்ட கால இடைவெளியை உள்ளமைக்கலாம்:

#!/bin/bash

echo "15 4 * * *    /usr/local/bin/wal-g backup-push /var/lib/postgresql/12/main >> /var/log/postgresql/walg_backup.log 2>&1" >> /var/spool/cron/crontabs/postgres
# задаем владельца и выставляем правильные права файлу
chown postgres: /var/spool/cron/crontabs/postgres
chmod 600 /var/spool/cron/crontabs/postgres

இந்த எடுத்துக்காட்டில், காப்புப்பிரதி செயல்முறை ஒவ்வொரு நாளும் அதிகாலை 4:15 மணிக்கு தொடங்குகிறது.

பழைய காப்புப்பிரதிகளை நீக்குகிறது

பெரும்பாலும், நீங்கள் Mesozoic சகாப்தத்தின் அனைத்து காப்புப்பிரதிகளையும் வைத்திருக்க வேண்டிய அவசியமில்லை, எனவே உங்கள் சேமிப்பகத்தை அவ்வப்போது "சுத்தம்" செய்வது பயனுள்ளதாக இருக்கும் ("முழு காப்புப்பிரதிகள்" மற்றும் WAL பதிவுகள் இரண்டும்). கிரான் டாஸ்க் மூலம் இதையெல்லாம் செய்வோம்:

#!/bin/bash

echo "30 6 * * *    /usr/local/bin/wal-g delete before FIND_FULL $(date -d '-10 days' '+%FT%TZ') --confirm >> /var/log/postgresql/walg_delete.log 2>&1" >> /var/spool/cron/crontabs/postgres
# ещё раз задаем владельца и выставляем правильные права файлу (хоть это обычно это и не нужно повторно делать)
chown postgres: /var/spool/cron/crontabs/postgres
chmod 600 /var/spool/cron/crontabs/postgres

கிரான் இந்த பணியை ஒவ்வொரு நாளும் காலை 6:30 மணிக்கு இயக்கும், கடந்த 10 நாட்களில் நகல்களைத் தவிர அனைத்தையும் (முழு காப்புப்பிரதிகள், டெல்டாக்கள் மற்றும் WALகள்) நீக்கும், ஆனால் குறைந்தது ஒரு காப்புப்பிரதியையாவது விட்டுவிடும் செய்ய குறிப்பிட்ட தேதி அதனால் எந்த புள்ளி после PITR இல் தேதிகள் சேர்க்கப்பட்டுள்ளன.

காப்புப்பிரதியிலிருந்து மீட்டமைக்கிறது

ஆரோக்கியமான தரவுத்தளத்தின் திறவுகோல், அவ்வப்போது மறுசீரமைப்பு மற்றும் உள்ளே உள்ள தரவின் ஒருமைப்பாட்டை சரிபார்ப்பது என்பது இரகசியமல்ல. இந்த பிரிவில் WAL-G ஐப் பயன்படுத்தி எவ்வாறு மீட்டெடுப்பது என்பதை நான் உங்களுக்குச் சொல்கிறேன், மேலும் சரிபார்ப்புகளைப் பற்றி பின்னர் பேசுவோம்.

அதை தனித்தனியாக கவனிக்க வேண்டும் சோதனைச் சூழலில் மீட்டமைக்க (உற்பத்தி செய்யாத அனைத்தும்) நீங்கள் S3 இல் படிக்க மட்டும் கணக்கைப் பயன்படுத்த வேண்டும், எனவே தற்செயலாக காப்புப்பிரதிகளை மேலெழுத வேண்டாம். WAL-G விஷயத்தில், குழுக் கொள்கையில் S3 பயனருக்கான பின்வரும் உரிமைகளை நீங்கள் அமைக்க வேண்டும் (விளைவு: அனுமதி): s3:GetObject, s3:ListBucket, s3:GetBucketLocation. மற்றும், நிச்சயமாக, அமைக்க மறக்க வேண்டாம் archive_mode=off அமைப்புகள் கோப்பில் postgresql.conf, அதனால் உங்கள் சோதனை தரவுத்தளமானது அமைதியாக காப்புப் பிரதி எடுக்கப்பட விரும்பவில்லை.

கையின் சிறிய இயக்கத்துடன் மறுசீரமைப்பு மேற்கொள்ளப்படுகிறது அனைத்து PostgreSQL தரவையும் நீக்குகிறது (பயனர்கள் உட்பட), எனவே பின்வரும் கட்டளைகளை இயக்கும்போது மிகவும் கவனமாக இருக்கவும்.

#!/bin/bash

# если есть балансировщик подключений (например, pgbouncer), то вначале отключаем его, чтобы он не нарыгал ошибок в лог
service pgbouncer stop
# если есть демон, который перезапускает упавшие процессы (например, monit), то останавливаем в нём процесс мониторинга базы (у меня это pgsql12)
monit stop pgsql12
# или останавливаем мониторинг полностью
service monit stop
# останавливаем саму базу данных
service postgresql stop
# удаляем все данные из текущей базы (!!!); лучше предварительно сделать их копию, если есть свободное место на диске
rm -rf /var/lib/postgresql/12/main
# скачиваем резервную копию и разархивируем её
su - postgres -c '/usr/local/bin/wal-g backup-fetch /var/lib/postgresql/12/main LATEST'
# помещаем рядом с базой специальный файл-сигнал для восстановления (см. https://postgrespro.ru/docs/postgresql/12/runtime-config-wal#RUNTIME-CONFIG-WAL-ARCHIVE-RECOVERY ), он обязательно должен быть создан от пользователя postgres
su - postgres -c 'touch /var/lib/postgresql/12/main/recovery.signal'
# запускаем базу данных, чтобы она инициировала процесс восстановления
service postgresql start

மீட்பு செயல்முறையைச் சரிபார்க்க விரும்புவோருக்கு, ஒரு சிறிய பாஷ் மேஜிக் கீழே தயார் செய்யப்பட்டுள்ளது, இதனால் மீட்டெடுப்பதில் சிக்கல்கள் ஏற்பட்டால், ஸ்கிரிப்ட் பூஜ்ஜியமற்ற வெளியேறும் குறியீட்டைக் கொண்டு செயலிழக்கச் செய்யும். இந்த எடுத்துக்காட்டில், சிக்னல் கோப்பு நீக்கப்பட்டதா என்பதைக் கண்டறிய 120 வினாடிகள் (மீட்டெடுப்பதற்கு மொத்தம் 5 நிமிடங்கள்) 10 காசோலைகள் செய்யப்படுகின்றன (மீட்பு வெற்றிகரமாக இருந்தது என்று அர்த்தம்):

#!/bin/bash

CHECK_RECOVERY_SIGNAL_ITER=0
while [ ${CHECK_RECOVERY_SIGNAL_ITER} -le 120 ]
do
    if [ ! -f "/var/lib/postgresql/12/main/recovery.signal" ]
    then
        echo "recovery.signal removed"
        break
    fi
    sleep 5
    ((CHECK_RECOVERY_SIGNAL_ITER+1))
done

# если после всех проверок файл всё равно существует, то падаем с ошибкой
if [ -f "/var/lib/postgresql/12/main/recovery.signal" ]
then
    echo "recovery.signal still exists!"
    exit 17
fi

வெற்றிகரமாக மீட்டெடுத்த பிறகு, அனைத்து செயல்முறைகளையும் மீண்டும் தொடங்க மறக்காதீர்கள் (pgbouncer/monit, முதலியன).

மீட்டெடுத்த பிறகு தரவைச் சரிபார்க்கிறது

மறுசீரமைப்பிற்குப் பிறகு தரவுத்தளத்தின் ஒருமைப்பாட்டை சரிபார்க்க வேண்டியது அவசியம், இதனால் உடைந்த/வளைந்த காப்புப்பிரதியுடன் கூடிய சூழ்நிலை ஏற்படாது. உருவாக்கப்பட்ட ஒவ்வொரு காப்பகத்திலும் இதைச் செய்வது நல்லது, ஆனால் எங்கு, எப்படி உங்கள் கற்பனையைப் பொறுத்தது (நீங்கள் ஒரு மணிநேர அடிப்படையில் தனிப்பட்ட சேவையகங்களை உயர்த்தலாம் அல்லது CI இல் சரிபார்ப்பை இயக்கலாம்). ஆனால் குறைந்தபட்சம், தரவுத்தளத்தில் உள்ள தரவு மற்றும் குறியீடுகளை சரிபார்க்க வேண்டியது அவசியம்.

தரவைச் சரிபார்க்க, அதை ஒரு டம்ப் மூலம் இயக்கினால் போதும், ஆனால் தரவுத்தளத்தை உருவாக்கும் போது செக்சம்கள் இயக்கப்பட்டிருப்பது நல்லது (தரவு சரிபார்ப்புகள்):

#!/bin/bash

if ! su - postgres -c 'pg_dumpall > /dev/null'
then
    echo 'pg_dumpall failed'
    exit 125
fi

குறியீடுகளை சரிபார்க்க - உள்ளது amcheck தொகுதி, இதிலிருந்து sql வினவலை எடுத்துக் கொள்வோம் WAL-G சோதனைகள் அதைச் சுற்றி ஒரு சிறிய தர்க்கத்தை உருவாக்கவும்:

#!/bin/bash

# добавляем sql-запрос для проверки в файл во временной директории
cat > /tmp/amcheck.sql << EOF
CREATE EXTENSION IF NOT EXISTS amcheck;
SELECT bt_index_check(c.oid), c.relname, c.relpages
FROM pg_index i
JOIN pg_opclass op ON i.indclass[0] = op.oid
JOIN pg_am am ON op.opcmethod = am.oid
JOIN pg_class c ON i.indexrelid = c.oid
JOIN pg_namespace n ON c.relnamespace = n.oid
WHERE am.amname = 'btree'
AND c.relpersistence != 't'
AND i.indisready AND i.indisvalid;
EOF
chown postgres: /tmp/amcheck.sql

# добавляем скрипт для запуска проверок всех доступных баз в кластере
# (обратите внимание что переменные и запуск команд – экранированы)
cat > /tmp/run_amcheck.sh << EOF
for DBNAME in $(su - postgres -c 'psql -q -A -t -c "SELECT datname FROM pg_database WHERE datistemplate = false;" ')
do
    echo "Database: ${DBNAME}"
    su - postgres -c "psql -f /tmp/amcheck.sql -v 'ON_ERROR_STOP=1' ${DBNAME}" && EXIT_STATUS=$? || EXIT_STATUS=$?
    if [ "${EXIT_STATUS}" -ne 0 ]
    then
        echo "amcheck failed on DB: ${DBNAME}"
        exit 125
    fi
done
EOF
chmod +x /tmp/run_amcheck.sh

# запускаем скрипт
/tmp/run_amcheck.sh > /tmp/amcheck.log

# для проверки что всё прошло успешно можно проверить exit code или grep’нуть ошибку
if grep 'amcheck failed' "/tmp/amcheck.log"
then
    echo 'amcheck failed: '
    cat /tmp/amcheck.log
    exit 125
fi

சுருக்க

வெளியீட்டைத் தயாரிப்பதில் உதவிய ஆண்ட்ரி போரோடினுக்கு எனது நன்றியைத் தெரிவித்துக் கொள்கிறேன் மற்றும் WAL-G இன் வளர்ச்சிக்கு அவர் ஆற்றிய பங்களிப்பிற்கு சிறப்பு நன்றி!

இத்துடன் இந்தக் குறிப்பு முடிகிறது. உங்கள் நிறுவனத்தில் இந்த கருவியைப் பயன்படுத்துவதற்கான மிகப்பெரிய சாத்தியக்கூறுகள் மற்றும் அமைப்பின் எளிமையை என்னால் தெரிவிக்க முடிந்தது என்று நம்புகிறேன். நான் WAL-G பற்றி நிறைய கேள்விப்பட்டேன், ஆனால் உட்கார்ந்து அதை கண்டுபிடிக்க போதுமான நேரம் இல்லை. நான் அதை வீட்டில் செயல்படுத்திய பிறகு, இந்த கட்டுரை என்னிடமிருந்து வந்தது.

தனித்தனியாக, WAL-G பின்வரும் DBMS உடன் வேலை செய்ய முடியும் என்பது கவனிக்கத்தக்கது:

இந்த MySQL / MariaDB,;
MongoDB;
அறக்கட்டளை டிபி;
மற்றும் கமிட்கள் மூலம் ஆராய, இன்னும் பல எதிர்பார்க்கப்படுகிறது!

ஆதாரம்: www.habr.com

WAL-G: PostgreSQL DBMS இன் காப்புப்பிரதிகள் மற்றும் மீட்பு