[ טוען... ]

גיבוי אתר: מדריך מעשי ל-Next.js, Payload, Postgres וארכיון

תאריך: 03.11.2026
זמן קריאה: 19 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור של אתר המגובה לשלושה עותקים נפרדים: שרת מקומי, מדיה נוספת וענן מרוחק, לפי אסטרטגיית גיבוי 3-2-1

גיבוי אתר הוא משימה שכולם מסכימים שהיא חשובה, אבל מעטים בודקים אותה באמת עד שמשהו נשבר. אתר מודרני הוא כבר לא תיקייה של קבצי HTML. הוא משלב CMS, מסד נתונים, תיקיית העלאות, משתני סביבה ו-Framework כמו Next.js. כל אחד מהרכיבים האלה יכול להיכשל בנפרד: שדרוג שהשתבש, מחיקה בטעות, חולשת אבטחה או חשבון אחסון שנפרץ.

הבעיה לא נעצרת באתרים שבבעלותכם. עסקים ומפתחים תלויים יותר ויותר בתוכן של אחרים, כמו תיעוד של ספרייה, מאמר שמסביר הגדרה קריטית, מאגר ידע במערכת SaaS או דף תנאים של ספק. אתרים חיצוניים נעלמים, משנים כתובות או נסגרים בלי התראה. הרעיון שמאחורי הביטוי "If you love a website, back it up" פשוט: אם משהו חשוב לכם, אל תסמכו על כך שמישהו אחר ישמור אותו בשבילכם.

המדריך הזה מציג גישה שכבתית ומעשית: אסטרטגיית גיבוי 3-2-1, גיבוי מסד נתונים Postgres עם pg_dump, גיבוי Payload CMS כולל מדיה וסודות, הצפנה ושליחה לאחסון חיצוני, גיבוי אוטומטי לאתר עם cron או n8n, ומעל הכול בדיקות שחזור קבועות. בהמשך יש פרק על ארכיון אתרים של צד שלישי וצ'קליסט מסכם שאפשר להעתיק לתיעוד הפנימי.

למה גיבוי אתר הוא יותר מ"יש גיבוי אצל ספק האחסון"

אתרים דינמיים שבירים יותר מאתרים סטטיים. מאמר הארכיון הוותיק של anarcat מתאר בדיוק את זה: ככל שאתר נשען יותר על מסד נתונים, CMS וקוד שרץ בצד השרת, כך יש יותר נקודות כשל שיכולות למחוק את התוכן, ולכן ארכוב אתרים הוא פרקטיקה ותיקה של אנשי תשתיות.

הטעות הנפוצה ביותר היא להסתמך רק על הגיבוי של ספק האחסון. לפי TeamUpdraft, אם חשבון האחסון נפרץ או מושבת, הגיבויים שיושבים באותו חשבון עלולים להיעלם יחד עם האתר. אותו מקור מזכיר גם עיקרון בסיסי: גיבוי של אתר WordPress חייב לכלול גם את הקבצים וגם את מסד הנתונים כדי שאפשר יהיה לשחזר אותו. אותו היגיון חל בדיוק על סטאק Next.js ו-Payload.

מה בדיוק צריך לגבות בסטאק מודרני

באתר טיפוסי שבנוי על Next.js עם Payload CMS ו-PostgreSQL יש לפחות שש שכבות נפרדות:

  • קוד המקור: נמצא ב-git, אבל גם מאגר ה-git עצמו צריך עותק מחוץ לפלטפורמה (GitHub, GitLab וכו').
  • מסד הנתונים: כל התוכן, המשתמשים, ההגדרות והיחסים בין הישויות.
  • מדיה והעלאות: תמונות, קבצי PDF וכל מה שעורכי התוכן מעלים דרך ה-CMS.
  • סודות וקונפיגורציה: קובצי .env, מפתחות API, הגדרות Docker Compose, Nginx או Caddy.
  • תשתית: הגדרות DNS, תעודות, Cron Jobs והגדרות ספק הענן.
  • תוכן חיצוני שאתם תלויים בו: תיעוד, מאגרי ידע ב-SaaS ודפים של צד שלישי.

גיבוי הוא לא סנכרון ולא שכפול

רפליקציה של מסד נתונים או RAID בדיסקים מגנים מפני תקלת חומרה, אבל לא מפני טעות אנושית. אם מישהו מריץ DELETE בלי WHERE, הפקודה משתכפלת לרפליקה תוך שניות. גיבוי אמיתי הוא עותק נקודתי בזמן, שנשמר במקום נפרד ולא מושפע משינויים שקורים אחריו.

אסטרטגיית גיבוי 3-2-1 בסטאק Next.js ו-Payload

הבסיס לכל תוכנית גיבוי הוא כלל 3-2-1: שלושה עותקים של הנתונים, על שני סוגי מדיה שונים, כשאחד מהם נמצא מחוץ לאתר (OneNine). את הכלל טבע במקור הצלם פיטר קרוג, ובהקשר של אחסון אתרים "מחוץ לאתר" פירושו פשוט "לא על השרתים של ספק האחסון שלכם" (TeamUpdraft).

איך 3-2-1 נראה בפועל

כך אפשר לתרגם את הכלל לסטאק שרץ על VPS עם Docker:

עותק

מיקום

סוג מדיה

הערות

1 (חי)

מסד הנתונים ותיקיית המדיה בשרת הפרודקשן

דיסק השרת

זה לא גיבוי, זה המקור

2

Dump יומי בשרת נפרד או בדיסק נפרד מה-Volume של מסד הנתונים

דיסק אחר / שרת אחר

מאפשר שחזור מהיר

3

אחסון אובייקטים תואם S3 אצל ספק אחר או באזור אחר, מוצפן

Object Storage

העותק שמציל אתכם כשהכול נופל

הנקודה החשובה בעמודה השנייה: לפי SimpleBackups, Dump שנשאר על שרת מסד הנתונים נעלם יחד עם השרת. לכן צריך לשמור גיבויים מחוץ ל-Volume של מסד הנתונים, ובאופן אידיאלי על שרת אחר לגמרי.

גיבוי מלא, אינקרמנטלי או דיפרנציאלי

לא כל גיבוי צריך להיות מלא. OneNine משווה בין שלוש הגישות:

סוג גיבוי

יתרונות

חסרונות

מלא

פשוט, שחזור מהיר

צורך הרבה אחסון וזמן

אינקרמנטלי

קטן ומהיר לגיבוי

שחזור איטי, צריך את כל הסטים בשרשרת

דיפרנציאלי

משתחזר מהר יותר מאינקרמנטלי

צורך יותר אחסון מאינקרמנטלי

המלצה היברידית שמופיעה ב-OneNine היא גיבוי מלא שבועי, דיפרנציאלי יומי וגיבוי בזמן אמת למסד הנתונים. באתר תוכן קטן או בינוני, Dump מלא יומי של מסד הנתונים הוא לרוב קטן מספיק כדי שלא יהיה צורך במורכבות נוספת, ואילו במדיה כדאי להעתיק רק קבצים חדשים או ששונו.

הזווית הישראלית: איפה לשמור את העותק החיצוני

שני שיקולים מקומיים שכדאי להכניס לתכנון:

  • פרטיות ומיקום נתונים: גיבוי שמכיל מידע אישי (לקוחות, טפסי לידים, משתמשים רשומים) כפוף לאותן חובות אבטחה כמו מסד הנתונים החי, כולל חוק הגנת הפרטיות ותקנות אבטחת המידע. בחירת אזור אחסון (למשל אזור באיחוד האירופי או אזור ישראלי אצל ספקי ענן שמציעים אותו) והצפנה מלאה של הגיבוי מצמצמות סיכון. במקרה של מידע רגיש כדאי להתייעץ עם גורם משפטי.
  • עברית ו-UTF-8: מסד נתונים שנוצר עם קידוד שגוי עלול להיראות תקין באתר ולהישבר בשחזור. חובה לבדוק את הקידוד ולשחזר בפועל תוכן בעברית, כפי שמוסבר בהמשך.

גיבוי מסד נתונים Postgres עם pg_dump

לרוב האתרים, גיבוי מסד נתונים Postgres מתחיל ונגמר ב-pg_dump. המדריך של Serversinc מציג את הפקודה המהירה ביותר כשמסד הנתונים רץ בקונטיינר:

docker exec postgres pg_dump -U myuser -d mydb -Fc > mydb.dump

יתרון חשוב: pg_dump לוקח תמונת מצב עקבית, כך שהאפליקציה יכולה להמשיך לקרוא ולכתוב בזמן הגיבוי. רק שינויי סכמה כמו ALTER TABLE ממתינים לסיום ה-Dump (Serversinc). המשמעות המעשית: אין צורך להוריד את האתר כדי לגבות, אבל כדאי לא לתזמן את הגיבוי במקביל להרצת מיגרציות של Payload.

למה דווקא הפורמט המותאם (-Fc)

הדגל -Fc יוצר קובץ בפורמט custom, ולפי Serversinc יש לו שלושה יתרונות מובהקים על פני קובץ SQL רגיל:

  • הוא דחוס כברירת מחדל.
  • אפשר לשחזר אותו במקביל עם pg_restore -j.
  • אפשר לשחזר ממנו טבלה בודדת בלי לשחזר את כל מסד הנתונים.

ב-PostgreSQL 16 ומעלה אפשר להוסיף -Z zstd ולקבל קבצים קטנים עוד יותר:

docker exec postgres pg_dump -U myuser -d mydb -Fc -Z zstd > mydb.dump

מלכודת ה-Volume בתמונת postgres:18

מי שמשדרג לתמונת Docker של PostgreSQL 18 צריך להכיר שינוי חשוב. לפי Serversinc, התמונה postgres:18 שומרת נתונים בנתיב /var/lib/postgresql/18/docker ומצהירה על ה-Volume בנתיב /var/lib/postgresql. חיבור הנתיב הישן /var/lib/postgresql/data לתמונה בגרסה 18 גורם לקונטיינר לא לעלות.

זו בדיוק הסיבה שגיבוי לוגי עם pg_dump לפני כל שדרוג גרסה הוא חובה: הוא נותן לכם דרך נקייה להעביר את הנתונים לקונטיינר חדש, גם אם מבנה ה-Volume השתנה.

גיבוי לוגי מול גיבוי פיזי

השאלה הבאה היא האם pg_dump מספיק. ההשוואה הבאה מבוססת על Serversinc:

קריטריון

גיבוי לוגי (pg_dump)

גיבוי פיזי (pg_basebackup / WAL / pgBackRest)

הקמה

פקודה אחת, פשוט

דורש יותר קונפיגורציה

מהירות במסדים גדולים

איטי

מהיר

שחזור לגרסה ראשית חדשה יותר

כן

לא

שחזור טבלה בודדת

כן, עם -Fc

לא בצורה ישירה

שחזור לנקודה בזמן (PITR)

לא, רק לרגע ה-Dump

כן, עם WAL archiving

כלל האצבע של אותו מקור: לרוב האפליקציות שמסד הנתונים שלהן קטן מכ-50 GB, pg_dump הוא הבחירה הנכונה. מעבר לזה כדאי לשקול גיבוי פיזי עם WAL archiving, שמאפשר שחזור לנקודה מדויקת בזמן. רוב אתרי התוכן והשיווק שבנויים על Payload נמצאים רחוק מתחת לסף הזה.

בדיקת קידוד לפני שסומכים על הגיבוי

כדי לוודא שהעברית תשרוד את המסע, כדאי לבדוק את קידוד מסד הנתונים:

docker exec postgres psql -U myuser -d mydb -c "SHOW server_encoding;"
docker exec postgres psql -U myuser -d mydb -c "SELECT datname, pg_encoding_to_char(encoding) FROM pg_database;"

התוצאה הרצויה היא UTF8. אם מסד הנתונים נוצר בקידוד אחר, עדיף לגלות את זה עכשיו ולא באמצע שחזור חירום.

גיבוי Payload CMS: מדיה, העלאות וסודות

Payload הוא Headless CMS שבגרסאות האחרונות שלו רץ בתוך אפליקציית Next.js עצמה, עם מתאמי מסד נתונים ל-PostgreSQL, MongoDB ו-SQLite. מי שרוצה רקע על הארכיטקטורה הזו ימצא אותו במאמר מה זה Headless CMS ולמה זה משנה את בניית האתרים. מבחינת גיבוי, החשוב הוא להבין ש-Payload מפצל את המידע לשלושה מקומות: מסד הנתונים, אחסון הקבצים, וקונפיגורציה שנמצאת בקוד ובמשתני הסביבה. גיבוי Payload CMS מלא חייב לכסות את שלושתם.

העלאות שנשמרות על דיסק מקומי

כברירת מחדל, Collection מסוג upload שומר את הקבצים בתיקייה על הדיסק של השרת, ובמסד הנתונים נשמרים רק המטא-דאטה והנתיב. Dump של Postgres בלבד ישחזר רשומות שמצביעות על תמונות שלא קיימות.

הכלי הנפוץ להעתקת תיקיית מדיה לאחסון תואם S3 הוא rclone. דוגמה בסיסית:

# העתקה חד-כיוונית של קבצים חדשים/ששונו, בלי למחוק ביעד
rclone copy /srv/app/media remote-backup:my-site-media --transfers 8 --log-file /var/log/media-backup.log

ההבדל בין rclone copy ל-rclone sync קריטי: sync מוחק ביעד קבצים שנמחקו במקור, כלומר מחיקה בטעות בשרת תמחק גם את הגיבוי. אם בכל זאת משתמשים ב-sync, כדאי להפעיל Versioning על ה-Bucket או להשתמש בדגל --backup-dir כדי לשמור עותקים של קבצים שנמחקו או הוחלפו.

העלאות שכבר נמצאות ב-S3

מי שמשתמש במתאם אחסון של Payload (למשל @payloadcms/storage-s3) כבר מחזיק את המדיה מחוץ לשרת, אבל זה עדיין עותק אחד. לפי כלל 3-2-1, צריך עותק נוסף שאינו תלוי באותו חשבון. שלוש אפשרויות מקובלות:

  • הפעלת Versioning על ה-Bucket, כדי שמחיקה או דריסה לא יהיו סופיות.
  • שכפול תקופתי עם rclone copy ל-Bucket אצל ספק אחר.
  • נעילת אובייקטים (Object Lock) למשך תקופה מוגדרת, אם הספק תומך בכך, כהגנה מפני כופרה או מפתח API שדלף.

קונפיגורציה וסודות

את קוד ה-payload.config.ts ואת קובצי המיגרציה מגבים דרך git. משתני הסביבה הם סיפור אחר: DATABASE_URI, PAYLOAD_SECRET, מפתחות S3 ומפתחות של שירותי צד שלישי לא אמורים להיכנס ל-git, אבל בלעדיהם שחזור מלא של האתר בלתי אפשרי. PAYLOAD_SECRET במיוחד משמש את Payload לחתימת טוקנים ולפעולות קריפטוגרפיות, ואובדן שלו עלול לנתק משתמשים או לפגוע בנתונים שתלויים בו.

הפתרון המקובל הוא לשמור עותק של הסודות במנהל סיסמאות או ב-Secret Manager, בנפרד מהגיבויים עצמם. מי שרוצה להבין למה ניהול סודות הוא נקודת תורפה קלאסית יכול לקרוא על דליפת משתני סביבה ב-Trigger.dev ואיך מבצעים רוטציה.

הצפנה והרשאות לעותק החיצוני

עותק חיצוני לא מוצפן הוא דליפת מידע שמחכה לקרות. דוגמת ההקמה שמתוארת ב-Medium משלבת pg_dump, cron, הצפנה עם age, משתמש IAM שמורשה רק להעלות, התראות על כשל, וגם משימה שבועית שמשחזרת בפועל את הגיבוי כדי לבדוק אותו.

שני העקרונות החשובים שם:

  • הצפנה אסימטרית עם age: בשרת נמצא רק המפתח הציבורי, כך שגם תוקף שהשתלט על השרת לא יכול לפענח גיבויים ישנים. המפתח הפרטי נשמר אופליין או במנהל סיסמאות.
  • משתמש שמורשה להעלות בלבד: אם האישורים בשרת דולפים, התוקף לא יכול למחוק או לקרוא את הגיבויים הקיימים.
# יצירת זוג מפתחות (פעם אחת, במחשב מאובטח)
age-keygen -o backup-key.txt
# הצפנה בשרת עם המפתח הציבורי בלבד
age -r age1xxxxxxxxxxxxxxxxxxxx -o mydb.dump.age mydb.dump
# פענוח בזמן שחזור
age -d -i backup-key.txt -o mydb.dump mydb.dump.age

גיבוי אוטומטי לאתר: cron, n8n והתראות

גיבוי ידני הוא גיבוי שיפסיק לקרות בשבוע עמוס. גיבוי אוטומטי לאתר צריך לרוץ בלי התערבות, לדווח על כשל בקול רם, ולהיות כתוב כך שכשל אמיתי לא ידווח בטעות כהצלחה.

סקריפט גיבוי עמיד

לפי SimpleBackups, שלושה כללים מבדילים בין סקריפט שעובד לסקריפט ששוקר:

  • להשתמש ב-set -euo pipefail, כך ש-pg_dump שנכשל לא ידווח כהצלחה רק כי הפקודה האחרונה ב-Pipe הצליחה.
  • לכתוב פלט לנתיב מוחלט, כי תיקיית העבודה של cron שונה מזו של ה-Shell שלכם.
  • לא לשים את סיסמת מסד הנתונים בשורת הפקודה, כי היא חשופה דרך ps. במקומה משתמשים בקובץ ~/.pgpass עם הרשאות chmod 600.

קובץ .pgpass נראה כך:

# hostname:port:database:username:password
localhost:5432:mydb:myuser:SuperSecretPassword
chmod 600 ~/.pgpass

והנה סקריפט מלא שמחבר את כל החלקים: Dump של מסד הנתונים, הצפנה, העלאה לאחסון חיצוני, העתקת מדיה ודיווח ל-Webhook:

#!/usr/bin/env bash
set -euo pipefail

BACKUP_DIR="/srv/backups/postgres"
MEDIA_DIR="/srv/app/media"
AGE_RECIPIENT="age1xxxxxxxxxxxxxxxxxxxx"
REMOTE="remote-backup:my-site-backups"
HEARTBEAT_URL="https://n8n.example.com/webhook/backup-status"
STAMP="$(date +%Y-%m-%d_%H-%M)"
FILE="$BACKUP_DIR/mydb_$STAMP.dump"

report() {
  curl -fsS -m 10 -X POST "$HEARTBEAT_URL" -H "Content-Type: application/json" -d "{\"status\":\"$1\",\"stamp\":\"$STAMP\"}" || true
}
trap 'report failure' ERR

mkdir -p "$BACKUP_DIR"

# 1. Dump בפורמט custom
docker exec postgres pg_dump -U myuser -d mydb -Fc -Z zstd > "$FILE"

# 2. בדיקה בסיסית שהקובץ קריא
docker exec -i postgres pg_restore --list < "$FILE" > /dev/null

# 3. הצפנה ומחיקת הגרסה הלא מוצפנת
age -r "$AGE_RECIPIENT" -o "$FILE.age" "$FILE"
rm -f "$FILE"

# 4. העלאה לאחסון חיצוני
rclone copy "$FILE.age" "$REMOTE/db/"

# 5. העתקת מדיה חדשה
rclone copy "$MEDIA_DIR" "$REMOTE/media/"

# 6. ניקוי עותקים מקומיים ישנים מ-14 יום
find "$BACKUP_DIR" -name "*.age" -mtime +14 -delete

report success

שימו לב: שלב 2 משתמש ב-pg_restore --list כבדיקת שפיות מהירה שהקובץ תקין מבנית. זה לא תחליף לבדיקת שחזור אמיתית, שעליה בפרק הבא.

תזמון עם cron

שורת crontab שמריצה את הסקריפט כל לילה בשלוש וכותבת לוג לנתיב מוחלט:

0 3 * * * /srv/scripts/backup.sh >> /var/log/site-backup.log 2>&1

כדאי לבחור שעה עם תנועה נמוכה, ולוודא שאזור הזמן של השרת מוגדר נכון. שרתים רבים רצים ב-UTC, כך ש-03:00 בשרת היא 05:00 או 06:00 בשעון ישראל, תלוי בשעון קיץ.

n8n כשכבת תזמור והתראות

הבעיה עם cron היא שהוא שותק. אם השרת כבוי, אם הדיסק מלא או אם מישהו מחק את ה-crontab, אף אחד לא יקבל התראה. כאן n8n משתלב היטב, לא בהכרח כמי שמריץ את הגיבוי, אלא כמי שמפקח עליו. מי שעדיין לא עבד עם הכלי יכול להתחיל ממדריך למתחילים: אוטומציה עם n8n.

תבנית מומלצת היא "Dead man's switch":

  1. הסקריפט שולח POST ל-Webhook של n8n בסוף כל ריצה, עם סטטוס success או failure.
  2. Workflow אחד מקבל את ה-Webhook, שומר את זמן ההצלחה האחרונה (למשל ב-Data Table, ב-Google Sheet או במסד נתונים), ושולח התראה מיידית לסלאק, לטלגרם או במייל אם הסטטוס הוא failure.
  3. Workflow שני רץ עם Schedule Trigger כל כמה שעות, בודק מתי הייתה ההצלחה האחרונה, ומתריע אם עברו יותר מ-26 שעות בלי דיווח.

השלב השלישי הוא החשוב ביותר, כי הוא תופס את המקרים שבהם הסקריפט לא רץ בכלל. ב-n8n בהתקנה עצמית אפשר גם להריץ פקודות ישירות דרך Execute Command Node, אבל בגרסאות חדשות הצומת הזה עשוי להיות מושבת כברירת מחדל משיקולי אבטחה, ולרוב עדיף להשאיר את הגיבוי ב-cron ואת הפיקוח ב-n8n. השוואה רחבה יותר בין כלי האוטומציה נמצאת במאמר Make מול Zapier מול n8n.

חלופה מוכנה: קונטיינר גיבוי ייעודי

מי שמעדיף לא לתחזק סקריפט יכול להשתמש בתמונה מוכנה כמו itbm/postgresql-backup-s3. לפי עמוד ה-GitHub, התמונה תומכת בגיבויים תקופתיים, שחזור, Kubernetes והצפנה, מופצת ברישיון MIT ומגיעה עם לקוח PostgreSQL 18 על בסיס Alpine. בזמן הכתיבה לפרויקט 88 כוכבים, 67 פורקים ו-95 קומיטים, כלומר פרויקט קהילתי קטן יחסית. כמו בכל תלות חיצונית שמקבלת גישה לנתונים רגישים, כדאי לקרוא את הקוד ולנעול גרסה. הנושא מפורט במאמר אבטחת שרשרת אספקה בתוכנה: צ'קליסט לצוותים קטנים.

שחזור אתר מגיבוי: בדיקה שבועית אוטומטית

גיבוי שמעולם לא שוחזר הוא השערה, לא גיבוי. רוב הכשלים מתגלים רק בשחזור: קובץ ריק, הרשאות שגויות, גרסה לא תואמת, מפתח הצפנה שאבד או קידוד שבור. לכן שחזור אתר מגיבוי צריך להיות תהליך שגרתי ומתועד, לא אירוע חירום.

איך משחזרים Dump בפורמט custom

לפי Serversinc, משחזרים עם pg_restore לתוך מסד נתונים ריק, ומשתמשים ב---no-owner כדי להימנע משגיאות כשבעל האובייקטים המקורי לא קיים בשרת היעד:

# יצירת מסד נתונים ריק
docker exec postgres createdb -U myuser mydb_restore

# שחזור מקבילי עם 4 תהליכים
docker cp mydb.dump postgres:/tmp/mydb.dump
docker exec postgres pg_restore -U myuser -d mydb_restore --no-owner -j 4 /tmp/mydb.dump

# שחזור טבלה בודדת בלבד
docker exec postgres pg_restore -U myuser -d mydb_restore --no-owner -t pages /tmp/mydb.dump

השימוש ב--j דורש קובץ ולא קלט מ-Pipe, ולכן מעתיקים קודם את הקובץ לקונטיינר. היכולת לשחזר טבלה בודדת שימושית במיוחד כשעורך תוכן מחק בטעות עמודים, ואין רצון להחזיר את כל האתר אחורה.

סקריפט בדיקת שחזור שבועי

הדוגמה מ-Medium כוללת משימה שבועית שמשחזרת בפועל את הגיבוי. כך זה יכול להיראות, כשהבדיקה רצה בקונטיינר זמני ונפרד מהפרודקשן:

#!/usr/bin/env bash
set -euo pipefail

WORK="/srv/restore-test"
REMOTE="remote-backup:my-site-backups/db"
mkdir -p "$WORK"

# 1. הורדת הגיבוי האחרון
LATEST="$(rclone lsf "$REMOTE" | sort | tail -n 1)"
rclone copy "$REMOTE/$LATEST" "$WORK/"

# 2. פענוח (המפתח הפרטי זמין רק בשרת הבדיקה)
age -d -i /srv/keys/backup-key.txt -o "$WORK/restore.dump" "$WORK/$LATEST"

# 3. קונטיינר Postgres זמני
docker run -d --name pg-restore-test -e POSTGRES_PASSWORD=test postgres:18
sleep 10
docker cp "$WORK/restore.dump" pg-restore-test:/tmp/restore.dump
docker exec pg-restore-test createdb -U postgres testdb
docker exec pg-restore-test pg_restore -U postgres -d testdb --no-owner -j 4 /tmp/restore.dump

# 4. בדיקות תוכן: מספר רשומות וטקסט בעברית
docker exec pg-restore-test psql -U postgres -d testdb -tAc "SELECT count(*) FROM pages;"
docker exec pg-restore-test psql -U postgres -d testdb -tAc "SELECT title FROM pages WHERE title ~ '[א-ת]' LIMIT 1;"

# 5. ניקוי
docker rm -f pg-restore-test
rm -rf "$WORK"

שמות הטבלאות תלויים במבנה ה-Collections ב-Payload, ולכן יש להתאים את השאילתות. העיקרון חשוב יותר מהפרטים: לבדוק שיש נתונים, שמספר הרשומות סביר בהשוואה לפרודקשן, ושתווים בעברית חוזרים תקינים ולא כסימני שאלה. את התוצאה כדאי לשלוח לאותו Webhook של n8n, כך שגם כשל בבדיקת השחזור יפיק התראה.

תרגיל שחזור מלא

פעם ברבעון, או לפני כל שינוי תשתיתי גדול, כדאי לבצע תרגיל שחזור מלא של האתר לשרת חדש ולמדוד כמה זמן הוא לוקח:

  1. הקמת שרת נקי עם Docker.
  2. שכפול הקוד מ-git (מהעותק החיצוני, לא רק מ-GitHub).
  3. שחזור קובץ .env ממנהל הסודות.
  4. הורדה, פענוח ושחזור של Dump מסד הנתונים.
  5. העתקת המדיה חזרה מה-Bucket.
  6. בנייה והרצה של אפליקציית Next.js, בדיקת פאנל הניהול של Payload ותמונות בעמודים.
  7. תיעוד כל שלב שנתקע, ועדכון ה-Runbook בהתאם.

הזמן שנמדד כאן הוא המדד האמיתי של מוכנות, והוא מתחבר ישירות למושג RTO שמוסבר בהמשך.

ארכיון אתרים: שמירת תוכן של צד שלישי ו-SaaS

החלק הזה הוא הלב של הרעיון "If you love a website, back it up". תיעוד של ספרייה ותיקה, בלוג טכני שמסביר הגדרה ייחודית או מאגר ידע של ספק יכולים להיעלם מחר. ארכיון אתרים מקומי הופך את התלות הזו לסיכון מנוהל.

שיקוף אתר פשוט עם wget

לאתרים פשוטים או סטטיים, anarcat ממליץ על wget --mirror בשילוב הדגלים --convert-links, --page-requisites ו---adjust-extension. התוצאה היא עותק סטטי שאפשר לפתוח בדפדפן בלי חיבור לאינטרנט, והשיטה מתאימה גם לאתרים שלכם וגם לאתרים של אחרים שאתם רוצים לשמור:

wget --mirror --convert-links --page-requisites --adjust-extension --no-parent --wait=1 --random-wait --reject-regex '/calendar/|\?replytocom=' https://docs.example.com/

הדגל --no-parent מונע מ-wget לטפס מעל התיקייה שהתחלתם ממנה, ו---wait עם --random-wait מאטים את הסריקה.

מגבלות שחשוב להכיר

אותו מקור מפרט כמה מלכודות (anarcat):

  • JavaScript: wget לא מריץ JavaScript, ולכן מתקשה מאוד עם אפליקציות Single Page. אתר שבנוי כולו בצד הלקוח יישמר כשלד ריק.
  • לולאות אינסופיות: עמודים כמו לוחות שנה יכולים לייצר אינסוף כתובות. --reject-regex מאפשר לדלג עליהם.
  • robots.txt ועומס: ארכיונאים רבים מתעלמים מ-robots.txt, אבל צריך להאט את הסריקה כדי לא להעמיס על אתר היעד.

חשוב לציין שהמקור הזה נכתב ב-2018, ושהוא לא עוסק בהיבטים משפטיים. שמירת עותק פרטי של תוכן לשימוש פנימי שונה מאוד מפרסום מחדש שלו. זכויות יוצרים ותנאי שימוש של האתר עדיין חלים, ובמקרה של ספק כדאי לבדוק משפטית.

WARC וסריקה מבוססת דפדפן

עותק HTML מומר הוא נוח לקריאה, אבל משנה את התוכן המקורי. ארכיונים מקצועיים משתמשים בפורמט WARC, שמתעד את בקשות ה-HTTP והתשובות כפי שהיו. גרסאות עדכניות של wget תומכות בדגל --warc-file, כך שאפשר לייצר במקביל גם עותק לגלישה וגם קובץ WARC לשימור:

wget --mirror --page-requisites --warc-file=docs-example --warc-cdx --wait=1 https://docs.example.com/

לאתרים כבדי JavaScript נדרשים כלים שמפעילים דפדפן אמיתי, כמו הכלים של פרויקט Webrecorder, שמייצרים ארכיונים שניתן לנגן מחדש. המקורות שעליהם מבוסס המדריך מתייחסים לכך רק בקצרה, ולכן כדאי לבדוק את מצב הכלים העדכני לפני שבוחרים.

תוכן במערכות SaaS

מאגרי ידע ב-Notion, מסמכים ב-Google Workspace, נתונים ב-CRM או תוכן ב-Webflow הם תוכן שאתם תלויים בו, אבל לא שולטים בתשתית שלו. כאן wget כמעט אף פעם לא הפתרון. הגישות המעשיות הן:

  • ייצוא מובנה: רוב הפלטפורמות מציעות ייצוא ל-Markdown, HTML, CSV או JSON. כדאי לבדוק מה הייצוא כולל בפועל (קבצים מצורפים? היסטוריית גרסאות?).
  • ייצוא דרך API: Workflow ב-n8n שרץ פעם בשבוע, שולף רשומות דרך ה-API של המערכת ושומר קובץ JSON מתוארך ב-Bucket הגיבוי.
  • תדירות לפי קריטיות: CRM עם לידים יומיים מצדיק ייצוא יומי, ואילו מאגר תיעוד פנימי יכול להסתפק בייצוא שבועי.

גם ייצואים כאלה צריכים להיכנס לאותה מסגרת של 3-2-1, הצפנה ובדיקה תקופתית שהקובץ נפתח ומכיל את מה שציפיתם.

RPO, RTO, מדיניות שמירה וצ'קליסט

שני מושגים קובעים את התדירות והמורכבות של כל תוכנית גיבוי. לפי OneNine:

  • RTO (Recovery Time Objective): משך ההשבתה המקסימלי שהעסק מוכן לספוג.
  • RPO (Recovery Point Objective): כמות הנתונים המקסימלית שמותר לאבד, נמדדת בזמן.

לצד אלה נכנסים לחישוב תדירות הגיבוי והקריטיות של הנתונים. אתר תדמית שמתעדכן פעם בשבוע יכול לחיות עם RPO של 24 שעות. חנות או מערכת לידים שמקבלת הזמנות כל הזמן עשויה לדרוש RPO של דקות, ואז Dump יומי לא מספיק וצריך לשקול גיבוי פיזי עם WAL archiving, שמאפשר שחזור לנקודה בזמן (Serversinc).

מדיניות שמירה

כמה זמן לשמור כל גיבוי? אין תשובה אחת, אבל תבנית נפוצה (כדוגמה בלבד, לא כהמלצה מחייבת) נראית כך:

שכבה

תדירות

שמירה

עותק מקומי

יומי

7 עד 14 ימים

עותק חיצוני יומי

יומי

30 ימים

עותק חיצוני שבועי

שבועי

3 חודשים

עותק חיצוני חודשי

חודשי

12 חודשים

רוב ספקי אחסון האובייקטים מאפשרים Lifecycle Rules שמוחקות או מעבירות קבצים ישנים לשכבת אחסון זולה יותר באופן אוטומטי. כשמדובר במידע אישי, מדיניות השמירה צריכה להתיישב גם עם חובות הפרטיות: שמירה של מידע לנצח היא לא תמיד יתרון.

צ'קליסט גיבוי אתר

  • [ ] קוד המקור נמצא ב-git ויש לו עותק מחוץ לפלטפורמה הראשית.
  • [ ] pg_dump בפורמט -Fc רץ אוטומטית לפחות פעם ביום.
  • [ ] הסקריפט משתמש ב-set -euo pipefail ובנתיבים מוחלטים.
  • [ ] הסיסמה נמצאת ב-~/.pgpass עם chmod 600 ולא בשורת הפקודה.
  • [ ] הגיבויים נשמרים מחוץ ל-Volume של מסד הנתונים ומחוץ לחשבון האחסון.
  • [ ] העותק החיצוני מוצפן, והמפתח הפרטי לא נמצא בשרת הפרודקשן.
  • [ ] האישורים בשרת מאפשרים העלאה בלבד, לא מחיקה.
  • [ ] מדיה של Payload מגובה בנפרד, עם Versioning או rclone copy.
  • [ ] קובצי .env ו-PAYLOAD_SECRET שמורים במנהל סודות.
  • [ ] יש התראה על כשל וגם התראה על היעדר דיווח (Dead man's switch).
  • [ ] בדיקת שחזור אוטומטית רצה כל שבוע, כולל בדיקת טקסט בעברית.
  • [ ] תרגיל שחזור מלא בוצע ברבעון האחרון, והזמן שנמדד עומד ב-RTO.
  • [ ] תוכן חיצוני קריטי מאורכב בתדירות שמתאימה לחשיבותו.

שאלות נפוצות

מה זה כלל הגיבוי 3-2-1?

שלושה עותקים של הנתונים (כולל העותק החי), על שני סוגי אחסון שונים, כשלפחות אחד מהם נמצא מחוץ לאתר, כלומר לא על השרתים של ספק האחסון שלכם (TeamUpdraft). בסטאק Next.js ו-Payload זה מתורגם בדרך כלל לשרת הפרודקשן, עותק בשרת או בדיסק נפרד, ועותק מוצפן באחסון תואם S3 אצל ספק אחר.

באיזה פורמט של pg_dump כדאי להשתמש?

בפורמט custom (-Fc). הוא דחוס, ניתן לשחזור מקבילי עם pg_restore -j, ומאפשר לשחזר טבלה בודדת (Serversinc). ב-PostgreSQL 16 ומעלה אפשר להוסיף -Z zstd לקבצים קטנים יותר.

איך יודעים שסקריפט הגיבוי באמת הצליח?

משתמשים ב-set -euo pipefail, מגדירים התראות על כשל, ומריצים משימה קבועה שמשחזרת את הגיבוי למסד נתונים לבדיקה (SimpleBackups). כדאי להוסיף גם התראה כשלא התקבל דיווח בכלל, כדי לתפוס מצב שבו הסקריפט לא רץ.

איך מונעים חשיפה של סיסמת מסד הנתונים בסקריפט?

משתמשים בקובץ ~/.pgpass עם הרשאות chmod 600, במקום סיסמה בשורת הפקודה שגלויה ברשימת התהליכים דרך ps (SimpleBackups).

אפשר לארכב אתר של צד שלישי עם wget?

כן, לאתרים פשוטים או סטטיים, עם wget --mirror בשילוב --convert-links ו---page-requisites. אתרי Single Page כבדי JavaScript בדרך כלל לא יישמרו כראוי, ויש להאט את הסריקה כדי לא להעמיס על האתר (anarcat).

האם אפשר לסמוך על הגיבויים של ספק האחסון?

לא כגיבוי יחיד. אם חשבון האחסון נפרץ או שמרכז הנתונים קורס, אפשר לאבד גם את האתר וגם את הגיבויים, ולכן צריך עותק עצמאי מחוץ לספק (TeamUpdraft). הגיבוי של הספק הוא שכבה נוספת נחמדה, לא תחליף.

סיכום

גיבוי אתר טוב בנוי משכבות: קוד ב-git, מסד נתונים שמגובה עם pg_dump בפורמט custom, מדיה שמועתקת בנפרד, סודות שנשמרים במנהל סודות, וכל זה מאורגן לפי אסטרטגיית גיבוי 3-2-1 עם עותק מוצפן מחוץ לספק האחסון. לרוב האתרים מתחת לכ-50 GB, גיבוי לוגי פשוט מספיק, וגיבוי פיזי עם WAL נכנס לתמונה רק כשה-RPO דורש שחזור לנקודה בזמן.

האוטומציה חשובה, אבל היא לא המטרה. המטרה היא שחזור: סקריפט שנכשל בקול רם, פיקוח שמזהה כשהגיבוי לא רץ, ובדיקת שחזור שבועית שמוודאת שגם הנתונים וגם העברית חוזרים תקינים. ולצד האתרים שלכם, שווה להקדיש מחשבה גם לתוכן של אחרים שאתם תלויים בו: ארכיון אתרים קטן ומסודר היום יכול לחסוך חיפוש מתסכל מחר.

מקורות

וואטסאפ