אסטרטגיות גיבוי בפייתון: מדריך מקיף ליישום הגנה על נתונים

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

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

כלל 3-2-1: אבן הפינה של אסטרטגיית גיבוי

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

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

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

אסטרטגיות גיבוי מקומיות בסיסיות עם פייתון

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

העתקת קבצים וספריות פשוטה עם `shutil`

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

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

העתקת קובץ בודד: `shutil.copy(source, destination)` מעתיק קובץ ואת ההרשאות שלו.

העתקת עץ ספריות שלם: `shutil.copytree(source, destination)` מעתיק באופן רקורסיבי ספריה וכל מה שבתוכה.

דוגמה מעשית: גיבוי תיקיית פרויקט

import shutil import os import datetime source_dir = '/path/to/your/project' dest_dir_base = '/mnt/backup_drive/projects/' # Create a timestamp for a unique backup folder name timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') dest_dir = os.path.join(dest_dir_base, f'project_backup_{timestamp}') try: shutil.copytree(source_dir, dest_dir) print(f"Successfully backed up '{source_dir}' to '{dest_dir}'") except FileExistsError: print(f"Error: Destination directory '{dest_dir}' already exists.") except Exception as e: print(f"An error occurred: {e}")

יצירת ארכיונים דחוסים

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

הפונקציה `shutil.make_archive()` הופכת את זה לפשוט להפליא.

דוגמה מעשית: יצירת ארכיון גיבוי דחוס

import shutil import datetime import os source_dir = '/var/www/my_application' archive_dest_base = '/var/backups/application/' # Ensure the destination directory exists os.makedirs(archive_dest_base, exist_ok=True) # Create a timestamped filename timestamp = datetime.datetime.now().strftime('%Y-%m-%d') archive_name = os.path.join(archive_dest_base, f'my_app_backup_{timestamp}') try: # Create a gzipped tar archive (.tar.gz) archive_path = shutil.make_archive(archive_name, 'gztar', source_dir) print(f"Successfully created archive: {archive_path}") except Exception as e: print(f"An error occurred during archival: {e}")

אסטרטגיית ביניים: סנכרון וגיבויים מרחוק

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

העוצמה של גיבויים מצטברים עם `rsync`

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

אתה יכול למנף את העוצמה של `rsync` מתוך פייתון על ידי שימוש במודול `subprocess` כדי להפעיל אותו כתהליך של שורת פקודה.

דוגמה מעשית: שימוש בפייתון כדי לקרוא ל-`rsync` לגיבוי מרחוק

import subprocess source_dir = '/path/to/local/data/' remote_user = 'backupuser' remote_host = 'backup.server.com' remote_dir = '/home/backupuser/backups/data/' # The rsync command. -a is for archive mode, -v for verbose, -z for compression. # The trailing slash on source_dir is important for rsync's behavior. command = [ 'rsync', '-avz', '--delete', # Deletes files on the destination if they're removed from the source source_dir, f'{remote_user}@{remote_host}:{remote_dir}' ] try: print(f"Starting rsync backup to {remote_host}...") # Using check=True will raise CalledProcessError if rsync returns a non-zero exit code result = subprocess.run(command, check=True, capture_output=True, text=True) print("Rsync backup completed successfully.") print("STDOUT:", result.stdout) except subprocess.CalledProcessError as e: print("Rsync backup failed.") print("Return Code:", e.returncode) print("STDERR:", e.stderr) except Exception as e: print(f"An unexpected error occurred: {e}")

שימוש ב-`paramiko` להעברות SFTP בפייתון טהור

אם אתה מעדיף פתרון פייתון טהור מבלי להסתמך על כלי שורת פקודה חיצוניים, הספרייה `paramiko` היא בחירה מצוינת. היא מספקת יישום מלא של פרוטוקול SSHv2, כולל SFTP (פרוטוקול העברת קבצים SSH), המאפשר העברת קבצים מאובטחת ותוכניתית.

ראשית, עליך להתקין אותו: `pip install paramiko`

דוגמה מעשית: העלאת ארכיון גיבוי באמצעות SFTP עם `paramiko`

import paramiko import os host = 'backup.server.com' port = 22 username = 'backupuser' # For production, always use SSH key authentication instead of passwords! # password = 'your_password' private_key_path = '/home/user/.ssh/id_rsa' local_archive_path = '/var/backups/application/my_app_backup_2023-10-27.tar.gz' remote_path = f'/home/backupuser/archives/{os.path.basename(local_archive_path)}' try: # Load private key key = paramiko.RSAKey.from_private_key_file(private_key_path) # Establish SSH client connection with paramiko.SSHClient() as ssh_client: ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # ssh_client.connect(hostname=host, port=port, username=username, password=password) ssh_client.connect(hostname=host, port=port, username=username, pkey=key) # Open SFTP session with ssh_client.open_sftp() as sftp_client: print(f"Uploading {local_archive_path} to {remote_path}...") sftp_client.put(local_archive_path, remote_path) print("Upload complete.") except Exception as e: print(f"An error occurred during SFTP transfer: {e}")

אסטרטגיה מתקדמת: שילוב אחסון בענן

אחסון בענן הוא היעד האידיאלי לגיבוי מחוץ לאתר שלך. ספקים כמו Amazon Web Services (AWS), Google Cloud Platform (GCP) ו-Microsoft Azure מציעים שירותי אחסון אובייקטים עמידים, ניתנים להרחבה וחסכוניים ביותר. שירותים אלה מושלמים לאחסון ארכיוני גיבוי.

גיבוי ל-Amazon S3 עם `boto3`

Amazon S3 (Simple Storage Service) הוא אחד משירותי אחסון האובייקטים הפופולריים ביותר. הספרייה `boto3` היא ה-AWS SDK הרשמי עבור פייתון, מה שמקל על האינטראקציה עם S3.

ראשית, התקן אותה: `pip install boto3`

אבטחה תחילה: לעולם אל תקודד את אישורי ה-AWS שלך בסקריפט שלך. הגדר אותם באמצעות משתני סביבה (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`) או קובץ אישורים של AWS (`~/.aws/credentials`). `boto3` ימצא וישתמש בהם באופן אוטומטי.

דוגמה מעשית: העלאת קובץ גיבוי לדלי S3

import boto3 from botocore.exceptions import ClientError import os # Configuration BUCKET_NAME = 'your-company-backup-bucket-name' # Must be globally unique LOCAL_FILE_PATH = '/var/backups/application/my_app_backup_2023-10-27.tar.gz' S3_OBJECT_KEY = f'application_backups/{os.path.basename(LOCAL_FILE_PATH)}' def upload_to_s3(file_path, bucket, object_name): """Upload a file to an S3 bucket""" # Create an S3 client. Boto3 will use credentials from the environment. s3_client = boto3.client('s3') try: print(f"Uploading {file_path} to S3 bucket {bucket} as {object_name}...") response = s3_client.upload_file(file_path, bucket, object_name) print("Upload successful.") return True except ClientError as e: print(f"An error occurred: {e}") return False except FileNotFoundError: print(f"The file was not found: {file_path}") return False # Execute the upload if __name__ == "__main__": upload_to_s3(LOCAL_FILE_PATH, BUCKET_NAME, S3_OBJECT_KEY)

תוכל לשפר זאת עוד יותר על ידי שימוש בתכונות המובנות של S3 כמו גרסאות כדי לשמור היסטוריה של הגיבויים שלך ומדיניות מחזור חיים כדי להעביר באופן אוטומטי גיבויים ישנים יותר לרמות אחסון זולות יותר (כמו S3 Glacier) או למחוק אותם לאחר תקופה מסוימת.

שילוב עם ספקי ענן אחרים

הדפוס עבור ספקי ענן אחרים דומה מאוד. היית משתמש בערכות ה-SDK של פייתון שלהם:

• Google Cloud Storage: השתמש בספרייה `google-cloud-storage`.
• Microsoft Azure Blob Storage: השתמש בספרייה `azure-storage-blob`.

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

גיבויים מיוחדים: הגנה על מסדי הנתונים שלך

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

גיבוי PostgreSQL

כלי שורת הפקודה של PostgreSQL ליצירת גיבוי לוגי הוא `pg_dump`. הוא מייצר סקריפט של פקודות SQL שניתן להשתמש בו כדי ליצור מחדש את מסד הנתונים. אנו יכולים לקרוא לזה מפייתון באמצעות `subprocess`.

הערת אבטחה: הימנע מהכנסת סיסמאות ישירות לפקודה. השתמש בקובץ `.pgpass` או במשתני סביבה כמו `PGPASSWORD`.

דוגמה מעשית: יצירת dump למסד נתונים של PostgreSQL

import subprocess import datetime import os # Database configuration DB_NAME = 'production_db' DB_USER = 'backup_user' DB_HOST = 'localhost' BACKUP_DIR = '/var/backups/postgres/' # Create a timestamped filename timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') backup_file = os.path.join(BACKUP_DIR, f'{DB_NAME}_{timestamp}.sql') # Ensure the backup directory exists os.makedirs(BACKUP_DIR, exist_ok=True) # Set the PGPASSWORD environment variable for the subprocess env = os.environ.copy() env['PGPASSWORD'] = 'your_secure_password' # In production, get this from a secrets manager! command = [ 'pg_dump', f'--dbname={DB_NAME}', f'--username={DB_USER}', f'--host={DB_HOST}', f'--file={backup_file}' ] try: print(f"Starting PostgreSQL backup for database '{DB_NAME}'...") # We pass the modified environment to the subprocess subprocess.run(command, check=True, env=env, capture_output=True) print(f"Database backup successful. File created: {backup_file}") except subprocess.CalledProcessError as e: print("PostgreSQL backup failed.") print("Error:", e.stderr.decode())

גיבוי MySQL/MariaDB

התהליך עבור MySQL או MariaDB דומה מאוד, באמצעות כלי השירות `mysqldump`. עבור אישורים, מומלץ להשתמש בקובץ אפשרויות כמו `~/.my.cnf` כדי להימנע מחשיפת סיסמאות.

דוגמה מעשית: יצירת dump למסד נתונים של MySQL

import subprocess import datetime import os DB_NAME = 'production_db' DB_USER = 'backup_user' BACKUP_DIR = '/var/backups/mysql/' # For this to work without a password, create a .my.cnf file in the user's home directory: # [mysqldump] # user = backup_user # password = your_secure_password timestamp = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S') backup_file_path = os.path.join(BACKUP_DIR, f'{DB_NAME}_{timestamp}.sql') os.makedirs(BACKUP_DIR, exist_ok=True) command = [ 'mysqldump', f'--user={DB_USER}', DB_NAME ] try: print(f"Starting MySQL backup for database '{DB_NAME}'...") with open(backup_file_path, 'w') as f: subprocess.run(command, check=True, stdout=f, stderr=subprocess.PIPE) print(f"Database backup successful. File created: {backup_file_path}") except subprocess.CalledProcessError as e: print("MySQL backup failed.") print("Error:", e.stderr.decode())

טיפול ב-SQLite

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

דוגמה מעשית: גיבוי מסד נתונים של SQLite

import sqlite3 import shutil def backup_sqlite_db(db_path, backup_path): """Creates a backup of a live SQLite database.""" print(f"Backing up '{db_path}' to '{backup_path}'...") # Connect to the source database source_conn = sqlite3.connect(db_path) # Connect to the destination database (it will be created) backup_conn = sqlite3.connect(backup_path) try: with backup_conn: source_conn.backup(backup_conn) print("Backup successful.") except sqlite3.Error as e: print(f"Backup failed: {e}") finally: source_conn.close() backup_conn.close() # Usage backup_sqlite_db('/path/to/my_app.db', '/var/backups/sqlite/my_app_backup.db')

אוטומציה ותזמון: גישת "הגדר ושכח"

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

שימוש בעבודות Cron (עבור Linux/macOS)

Cron הוא מתזמן העבודות הסטנדרטי מבוסס הזמן במערכות הפעלה דמויות Unix. אתה יכול ליצור ערך crontab כדי להפעיל את סקריפט הגיבוי של פייתון שלך בלוח זמנים חוזר. כדי לערוך את ה-crontab שלך, הפעל `crontab -e` במסוף שלך.

דוגמה לערך crontab להפעלת סקריפט כל יום בשעה 2:30 לפנות בוקר:

30 2 * * * /usr/bin/python3 /path/to/your/backup_script.py >> /var/log/backups.log 2>&1

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

שימוש במתזמן המשימות של Windows

עבור סביבות Windows, מתזמן המשימות הוא המקבילה המובנית ל-cron. אתה יכול ליצור משימה חדשה באמצעות הממשק הגרפי שלה, לציין את הטריגר (למשל, מדי יום בשעה מסוימת) ולהגדיר את הפעולה להפעלת סקריפט הפייתון שלך (`python.exe C:\path\to\backup_script.py`).

תזמון בתוך האפליקציה עם `apscheduler`

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

ראשית, התקן אותה: `pip install apscheduler`

דוגמה מעשית: מתזמן פשוט שמריץ פונקציית גיבוי כל שעה

from apscheduler.schedulers.blocking import BlockingScheduler import time def my_backup_job(): print(f"Performing backup job at {time.ctime()}...") # Insert your backup logic here (e.g., call the S3 upload function) scheduler = BlockingScheduler() # Schedule job to run every hour scheduler.add_job(my_backup_job, 'interval', hours=1) # Schedule job to run every day at 3:00 AM in a specific timezone scheduler.add_job(my_backup_job, 'cron', hour=3, minute=0, timezone='UTC') print("Scheduler started. Press Ctrl+C to exit.") try: scheduler.start() except (KeyboardInterrupt, SystemExit): pass

שיטות עבודה מומלצות למערכות גיבוי חזקות

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

• הצפנה: הצפן תמיד גיבויים רגישים, במיוחד לפני שליחתם למיקום מרוחק או בענן. הספרייה `cryptography` בפייתון היא כלי רב עוצמה לכך. אתה יכול להצפין את הארכיון שלך לפני העלאתו.
• רישום ומעקב: סקריפט הגיבוי שלך צריך להפיק יומנים ברורים של פעילויותיו. רשום מה גובה, לאן זה הלך והכי חשוב, כל שגיאה שהתרחשה. הגדר הודעות אוטומטיות (למשל, באמצעות דואר אלקטרוני או פלטפורמת הודעות כמו Slack) כדי להתריע בפניך מיד אם גיבוי נכשל.
• בדיקת הגיבויים שלך: זהו השלב החשוב ביותר והמוזנח ביותר. גיבוי אינו גיבוי עד שהצלחת לשחזר ממנו. תזמן באופן קבוע בדיקות שבהן אתה מנסה לשחזר נתונים מהגיבויים שלך לסביבה שאינה ייצור. זה מוודא שהגיבויים שלך אינם פגומים ושהליך השחזור שלך באמת עובד.
• ניהול אישורים מאובטח: חזור על נקודה זו: לעולם אל תקודד סיסמאות, מפתחות API או סודות אחרים ישירות בקוד שלך. השתמש במשתני סביבה, קבצי `.env` (עם `python-dotenv`) או שירות ניהול סודות ייעודי (כמו AWS Secrets Manager או HashiCorp Vault).
• גרסאות: אל תדרוס את אותו קובץ גיבוי בכל פעם. שמור מספר גרסאות (למשל, גיבויים יומיים לשבוע האחרון, שבועיים לחודש האחרון). זה מגן עליך ממצבים שבהם השחתת נתונים לא הורגשה במשך מספר ימים וגובתה בנאמנות במצבה הפגום. חותמות זמן בשמות קבצים הן צורה פשוטה של ניהול גרסאות.
• אידמפוטנטיות: ודא שניתן להריץ את הסקריפט שלך מספר פעמים מבלי לגרום לתופעות לוואי שליליות. אם ריצה נכשלת באמצע ואתה מריץ אותה מחדש, היא אמורה להיות מסוגלת להמשיך מהמקום שבו הפסיקה או להתחיל מחדש בצורה נקייה.
• טיפול בשגיאות: בנה בלוקים מקיפים של `try...except` בקוד שלך כדי לטפל בחן בבעיות פוטנציאליות כמו הפסקות רשת, שגיאות הרשאה, דיסקים מלאים או ויסות API מספקי ענן.

מסקנה

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

על ידי התחלה עם כלל 3-2-1 הבסיסי ויישום הדרגתי של אסטרטגיות מקומיות, מרוחקות ומבוססות ענן, אתה יכול לבנות מערכת מקיפה להגנה על נתונים. כיסינו הכל, החל מפעולות קבצים בסיסיות עם `shutil` ועד העברות מרחוק מאובטחות עם `rsync` ו-`paramiko`, שילוב ענן עם `boto3` ויצירת dumps מיוחדים למסדי נתונים. זכור שאוטומציה היא בעלת הברית הגדולה ביותר שלך בהבטחת עקביות, ובדיקות קפדניות הן הדרך היחידה להבטיח אמינות.

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