SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor

השוואה בין FreeBSD jails לבין Docker containers

מה ההבדל בין FreeBSD jails לבין Docker containers? המדריך משווה בין מודל ה-userland המלא של jails לבין המכולות מבוססות ה-images של Docker, כולל ניהול רשת, משאבים וביצועים.

השוואה בין FreeBSD jails לבין Docker containers בפסקה אחת

‏FreeBSD jails ו־Docker containers פותרים את אותה הבעיה בשתי צורות שונות. שניהם מריצים סביבות משתמש מבודדות על גבי ליבה משותפת, ולכן אף אחד מהם אינו מכונה וירטואלית. ההבדל טמון במה שנמצא בתוכם. מכולת Docker מריצה תהליך אחד מתוך image שכבתית שנמשכה מתוך registry. לעומת זאת, jail מריץ סביבת משתמש מלאה של FreeBSD: יש לו /etc משלו, סקריפטים של עליית מערכת מסוג rc משלו, מסד נתונים של pkg משלו, ומספר תהליכים כרצונכם. כמעט כל הבדל אחר בדף זה נובע מההבחנה הבסיסית הזו.

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

מהו Jail בפועל

מנגנון ה-Jails הגיע ל-FreeBSD בגרסה 4.0 במרץ 2000, מה שהופך אותו לוותיק יותר מ-cgroups ובוגר בכעשור מ-Docker. המנגנון מבוסס על קריאת kernel אחת. jail(8) לוקח עץ ספריות ומפעיל בתוכו תהליכים עם מזהה jail צמוד, וה-kernel מסרב לבצע עבור כל תהליך הנושא מזהה זה סדרה של פעולות מורשות (privileged). כברירת מחדל, תהליך בתוך jail אינו יכול לראות תהליכים מחוץ ל-jail שלו, אינו יכול לבצע mount או unmount למערכות קבצים, אינו יכול לפתוח raw sockets, אינו יכול לטעון מודולים של ה-kernel, ואינו יכול לבצע bind לכתובות רשת שלא הוקצו לו. קבוצה זו אינה קבועה. פרמטרים בוליאניים מסוג allow.* בקובץ התצורה של ה-jail מסירים הגבלות ספציפיות עבור אותו jail בלבד: allow.raw_sockets, allow.mount, allow.chflags, משפחת allow.sysvipc ואחרים. רובם כבויים כברירת מחדל, למעט allow.set_hostname ו-allow.reserved_ports. חלקם נכנסים לתוקף רק לצד הגדרה אחרת: allow.mount עובד רק כאשר enforce_statfs מוגדר לערך נמוך מ-2. מודול kernel טעון יכול גם הוא להוסיף פרמטרים משלו ל-jail. אין סוגי namespace נפרדים ללמוד: ההגבלות מגיעות כיחידה אחת, ואתה משחרר אותן פרמטר אחר פרמטר.

במערכת המארחת (host), הפקודה jls מציגה רשימה של jails פעילים, ו-jexec web sh מעבירה אותך ל-shell בתוך ה-jail ששמו web.

אתה בונה jail על ידי הצבת סביבת משתמש (userland) של FreeBSD בתוך ספרייה. מערכת הבסיס מבצעת זאת עבורך:

sudo bsdinstall jail /usr/local/jails/containers/web

פעולה זו מושכת את ערכת ההפצה הבסיסית עבור הגרסה שלך ומריצה את רוב שלבי ה-post-install הרגילים, כך שתוכל להגדיר סיסמת root, לבחור שירותים ולהוסיף משתמשים כפי שהיית עושה בשרת חדש. היא לעולם לא תבקש אזור זמן: המתקין מעתיק את /etc/localtime של המארח לתוך ה-jail, כך שה-jail יורש את אזור הזמן של המארח. התוצאה היא התקנת FreeBSD השוכנת בתוך תיקייה. לאחר מכן עליך לתאר אותה ב-/etc/jail.conf:

web {
  host.hostname = "web.example.internal";
  path = "/usr/local/jails/containers/web";
  ip4.addr = "10.0.0.10";
  exec.start = "/bin/sh /etc/rc";
  exec.stop = "/bin/sh /etc/rc.shutdown";
  mount.devfs;
}

הפעל אותו, ולאחר מכן בדוק אותו:

sudo service jail start web
jls

jls אמור כעת להציג את web עם JID, שם המארח (hostname) וכתובת ה-IP שלו. אם ה-jail אינו מופיע, הרץ את sudo jail -c web ישירות. הוא מחיל את אותה תצורה בחזית (foreground) ומדפיס את הפרמטר שלא התקבל, במקום להשאיר את הכשל בפלט השירות.

השורה ששווה לקרוא פעמיים היא exec.start = "/bin/sh /etc/rc". הפעלת jail מריצה את סקריפט ה-boot הרגיל של FreeBSD בתוכו, כך שה-jail מעלה כל שירות שמוגדר כפעיל ב-/etc/rc.conf שלו. למכולת Docker אין שלב מקביל, מכיוון שהיא מריצה את תהליך ה-entrypoint של ה-image ועוצרת כאשר תהליך זה מסתיים.

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

זהו ההבדל שתחושו כבר ביום הראשון.

ב־Docker אתם מציינים שם של תוכנה ומקבלים אותה. הפקודה docker pull nginx מושכת תמונה מבוססת שכבות וממוענת-תוכן, שמישהו אחר בנה ובדק, והפקודה docker compose up -d מפעילה אותה עם ה-volumes והרשת המחוברים אליה. ה-registry הוא המוצר. רוב הערך בשימוש ב-Docker נובע מכך שאלפי פרויקטים מפרסמים תמונה עובדת, מה שהופך את הרצת Docker על גבי VPS למשימה קצרה במקום לפרויקט מורכב.

ב-FreeBSD אין registry ציבורי מובנה של תמונות jail. אתם יוצרים סביבת משתמש (userland) ריקה ומתקינים לתוכה תוכנות, בדיוק כפי שהייתם מגדירים שרת חשוף. זה דורש יותר הקלדה. זה גם שקוף יותר, מכיוון שמה שרץ בתוך ה-jail הוא בדיוק מה שהפקודה pkg הציבה שם, מתוך אותה קבוצת חבילות שבה משתמש המארח (host).

כלי עבודה מקצרים את התהליך. BastilleBSD הוא מנהל ה-jail הנפוץ והוא זמין כחבילה:

sudo pkg install bastille
sudo sysrc bastille_enable=YES
sudo bastille setup
sudo bastille bootstrap 15.1-RELEASE

הפקודה bastille setup מגדירה עבורכם את הרשת, האחסון וה-firewall. הפקודה bastille bootstrap מורידה גרסה פעם אחת, וכל jail שתצרו לאחר מכן יעשה בה שימוש חוזר. FreeBSD 15.1 היא גרסת ה-production הנוכחית, שיצאה ביוני 2026; החליפו אותה בגרסה שאתם מריצים.

יצירת jail היא פעולה של פקודה אחת, ומילוי התוכן שלה דורש פקודה נוספת:

sudo bastille create web 15.1-RELEASE 10.17.89.10/24
sudo bastille pkg web install nginx
sudo bastille service web nginx start
sudo bastille console web

הפקודה bastille console web מעניקה לכם shell לכניסה לתוך ה-jail, והפקודה bastille list מציגה מה קיים על המארח. כדי לחזור על תהליך בנייה, תבניות (templates) של Bastille שומרות את השלבים בקובץ ומחילות אותם על ה-jail; זהו הדבר הקרוב ביותר בעולם הזה ל-Dockerfile. תבנית מופעלת מחדש על כל jail. שום דבר לא מגיע מוכן מראש.

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

מצב ושדרוגים: החלק של שינויי ZFS

Docker מפריד מצב (state) באופן מכוון. מערכת הקבצים של המכולה היא זמנית, הנתונים שלכם נשמרים ב-named volume או ב-bind mount, ושדרוג הוא docker compose pull ולאחריו docker compose up -d. המכולה מוחלפת, וכל מה שלא שמרתם ב-volume אובד. זו תכונה מועילה כשפועלים לפי הכלל, אך היא מובילה לאובדן נתונים כששוכחים אותו; זו הסיבה ש-הבחירה בין bind mounts לבין named volumes כה משמעותית ב-Compose stack.

Jail אינו מפריד מצב, ו-ZFS היא הסיבה לכך שזה עובד. ה-jail כולו הוא dataset אחד:

sudo zfs snapshot zroot/jails/containers/web@pre-upgrade
sudo pkg -j web upgrade
sudo zfs rollback zroot/jails/containers/web@pre-upgrade

בדקו את שם ה-dataset האמיתי בעזרת zfs list לפני הרצת הפקודה; הנתיב לעיל הוא המבנה שבו משתמש ה-handbook. ה-snapshot לוקח כשנייה ואינו תופס כמעט מקום עד לשינוי בתוכן ה-jail. אם השדרוג משבש את השירות, ה-rollback מחזיר את כל ה-userland למצבו הקודם, כולל מסד הנתונים של החבילות וקובצי התצורה שערכתם ידנית בשעות הלילה. ל-Docker אין שקול מובנה, כיוון שהמודל שלו מניח שמעולם לא נזקקתם לאחד כזה.

zfs clone הוא החצי השני. Clone של snapshot הוא jail חדש וניתן לכתיבה, החולק בלוקים ללא שינוי עם ה-parent שלו; לכן, עותק staging של jail בנפח 3 GB כמעט אינו תופס מקום בדיסק עד שמתחילים לבצע בו שינויים. כך מנהל מערכת FreeBSD בונה jail "זהה לייצור" כדי לתרגל שדרוג.

שדרוג מערכת הבסיס נפרד משדרוג חבילות. עבור jail שמחזיק עותק משלו של ה-userland:

sudo freebsd-update -b /usr/local/jails/containers/web fetch install

Thin jails מונעים חזרה על פעולה זו. הם מעגנים (mount) בסיס משותף לקריאה בלבד דרך nullfs ומעניקים לכל jail שכבה קטנה וניתנת לכתיבה משלו; כך מעדכנים את הבסיס פעם אחת וכל ה-jails רואים את התוצאה. Bastille יוצר thin jails כברירת מחדל.

רשת: פורטים מפורסמים לעומת החלטת כתובות

Docker מחליט עבורך על הגדרות הרשת ומבקש ממך לפרסם את החריגים. מכולות ממוקמות על גשר (bridge), הן מגיעות זו לזו לפי שם השירות ברשת שהוגדרה על ידי המשתמש, ו־-p 8080:80 חושף אחת מהן למארח. Docker כותב חוקי סינון חבילות משלו כדי לאפשר זאת, וזו גם הדרך שבה פורט של מכולה מפורסמת עוקף ישירות את ufw.

Jail מחייב אותך לבחור את המודל מראש, וישנם שניים כאלו.

Shared IP. ip4.addr = "10.0.0.10" מגביל את ה-jail לכתובת זו. כשלעצמו, הוא אינו נוגע בממשקי המארח, לכן הכתובת חייבת להיות מוגדרת כבר על אחד מהם. כדי ש־jail(8) יוסיף את הכתובת ככינוי (alias) בעת יצירת ה-jail, יש לציין את הממשק: הגדירו interface = "em0"; בבלוק של ה-jail, או הציבו אותו לפני הכתובת כ־ip4.addr = "em0|10.0.0.10";. ל-jail אין מחסנית רשת משלו, לכן הוא אינו יכול להריץ firewall משלו. הוא גם לא יכול באמת להאזין לכל הכתובות: socket בתוך jail שמבקש את 0.0.0.0 נכתב מחדש על ידי ה-kernel לכתובת של ה-jail עצמו. שני jails לא יכולים להאזין שניהם לפורט 80 באותה כתובת, לכן עליך לתת לכל אחד כתובת, או להציב reverse proxy בחזית.

VNET. הוסיפו vnet; ל-jail והוא יקבל מחסנית רשת מלאה: ממשקים משלו, טבלת ניתוב משלו, וחוקי firewall משלו. אתם מחברים אותו למארח באמצעות epair, כבל וירטואלי עם קצה אחד בכל צד, ומציבים את קצה המארח על גשר. זהו המודל הקרוב ביותר למה ש-Docker מספק, וזהו המצב שמאחורי סוגי ה-jail של Bastille מסוג -V ו־-B.

העברת פורט של מארח לתוך jail היא חוק ניתוב מחדש מסוג pf. Bastille עוטף זאת:

sudo bastille rdr web tcp 80 80

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

מגבלות משאבים: cgroups לעומת rctl

Docker מגביל מכולה באמצעות cgroups, והמגבלות מוגדרות היכן שהמכולה מוגדרת: --memory=1g --cpus=1.5 בשורת הפקודה, או במפתחות התואמים בקובץ Compose. אם אתם כבר מנהלים את ה-stack שלכם בתוך קובץ Docker Compose ב-VPS, המגבלה יושבת לצד השירות שעליו היא חלה ועוברת איתו ב-git.

FreeBSD משתמש ב-rctl, וזהו תת-מערכת שיש להפעיל באופן יזום. ה-kernel מסוג GENERIC כולל את מנגנון ניהול המשאבים אך הוא מגיע כבוי, דרך אפשרות ה-kernel‏ RACCT_DEFAULT_TO_DISABLED. הוסיפו את ה-tunable לקובץ /boot/loader.conf ובצעו reboot:

kern.racct.enable=1

לאחר מכן, הגדירו חוק ועקבו אחריו:

sudo rctl -a jail:web:vmemoryuse:deny=1g
rctl -hu jail:web

הפקודה rctl -hu jail:web מציגה את השימוש הנוכחי של ה-jail ביחידות קריאות לאדם, כך שניתן לראות כמה קרובים למגבלה לפני שמשהו משתבש. הפעולה deny גורמת להקצאה שחורגת מהמגבלה להיכשל בתוך ה-jail, כך שניתן לראות את שגיאת ההקצאה של היישום עצמו במקום הודעת kill במערכת המארחת.

חוקים שנוספו עם rctl -a נעלמים ב-reboot הבא. השירות rctl ב-FreeBSD טוען אותם מחדש מתוך /etc/rctl.conf, לכן יש לכתוב את החוק לקובץ זה ולהפעיל את השירות:

sudo sysrc rctl_enable=YES

זהו הציר שבו Docker נוח באופן מובהק. מגבלה בקובץ Compose נסקרת יחד עם השירות שהיא מגבילה. חוק rctl הוא שורה בקובץ נפרד המציין jail שמוגדר במקום אחר.

כאשר התשובה היא מכונה וירטואלית: bhyve

jail חולק את ה-kernel של המארח, לכן כמה דברים אינם נגישים באופן קבוע. הוא אינו יכול להריץ גרסת kernel שונה, הוא אינו יכול לטעון מודול kernel, והוא אינו יכול להריץ קובצי binary של Linux כפי שעושה container של Linux. ל-FreeBSD יש שכבת תאימות ל-Linux, ה-linuxulator, אך היא מממשת תת-קבוצה של קריאות מערכת (system calls) של Linux ואינה מהווה פתרון כללי עבור image של Linux שרירותי.

bhyve הוא ה-hypervisor של FreeBSD, והוא הכלי הנכון כאשר נדרש גבול מכונה אמיתי: מערכת הפעלה שונה, kernel שונה, או דייר שאינכם מעוניינים לחלוק איתו את ה-kernel. המחיר הוא זיכרון שמוקצה במקום להיות משותף, ו-kernel נוסף שיש לעדכן. זוהי אותה החלטה שאתם מקבלים ב-Linux בין containers לבין מכונות וירטואליות מלאות, וזו ההחלטה שקובעת האם אתם זקוקים ל-VPS התומך ב-nested virtualization מתחת.

האקו-סיסטם, הסיבה הכנה לכך שרוב הצוותים משתמשים ב-Docker

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

Docker מביא איתו את Docker Hub ו-GHCR, docker compose, את Kubernetes כאשר שרת אחד מפסיק להספיק, את ה-CI runners עם תמיכה מובנית במכולות, ואת ה-quickstart בפקודה אחת שקיים כמעט בכל README של פרויקט. Jails מביאים את ה-FreeBSD ports tree, שהוא רחב ומתוחזק בקפידה, בתוספת קבוצה קטנה בהרבה של חבילות יישומים מוכנות להרצה. כאשר פרויקט מפרסם image של מכולה ולא שום דבר אחר, הדרך ב-FreeBSD היא לקרוא את התיעוד ולהרכיב את החלקים בעצמך.

Jails מרוויחים את מקומם בצד השני של הפשרה הזו. תרצה להשתמש בהם כאשר אתה כבר מריץ ZFS ומעריך יכולות snapshot ו-rollback של שירות שלם, כאשר השירותים שלך הם native ל-FreeBSD, כאשר אתה רוצה userland מלא לכל דייר במקום תהליך בודד, או כאשר אתה רוצה שה-kernel, ה-packet filter, מערכת הקבצים והתיעוד יתוחזקו יחד כמערכת אחת. הנקודה האחרונה הזו היא מה שאנשים מתכוונים אליו כשהם מכנים את FreeBSD קוהרנטית, והיא מקבלת מקום רחב יותר ב-השוואה המקיפה בין Linux ל-FreeBSD כפלטפורמות שרת וב-מה השתנה ב-FreeBSD 15 עבור שימוש בשרתים.

פסיקה מסכמת אחת. אם הצוות שלך כבר מכיר את Docker, העלות של מעבר היא ממשית והתמורה חייבת להיות ספציפית. אל תעבור בגלל איכות הבידוד; שני המודלים קרובים מספיק כך שהתצורה שלך משנה יותר. עבור אם אתה רוצה rollback מבוסס ZFS של שירותים שלמים, או אם אתה כבר נמצא על FreeBSD.

FAQ

האם ניתן להריץ אימג'ים של Docker על FreeBSD?

לא אימג'ים של Linux, ולא כמסלול נתמך. ל-FreeBSD יש תמיכה במכולות OCI: הפקודה sudo pkg install -y podman-suite מתקינה את Podman, שמריץ מכולות באמצעות ocijail, סביבת הרצה (runtime) שיוצרת jails אמיתיים ברקע. הוא דורש את fdescfs מותקן ב-/dev/fd עבור ניטור המכולות, ואת pf עבור NAT (תרגום כתובות רשת) של המכולות. אימג'ים של OCI המותאמים ל-FreeBSD עובדים בצורה הטובה ביותר. אימג'ים של Linux דורשים בנוסף את שכבת התאימות ל-Linux, ונכון לאוקטובר 2026, הודעת ההתקנה של ה-port של Podman ב-FreeBSD עדיין מגדירה את כל ה-port כניסיוני ומיועד להערכה ובדיקות בלבד. אם הפריסה שלכם מבוססת על ערימת אימג'ים של Linux, הריצו אותה על Linux. במשפחת RHEL, המשמעות היא התקנת Docker על Rocky Linux או AlmaLinux, שם Podman מופיע פעם שנייה כחבילה שכבר מחזיקה בפקודה docker עוד לפני שהתקנתם דבר מה.

האם jails של FreeBSD מאובטחים יותר ממכולות Docker?

שניהם חולקים kernel מארח אחד, לכן באג ב-kernel מהווה סיכון לשניהם, ואף אחד מהם אינו הגבול שהייתם בוחרים עבור קוד שאינו מהימן באמת. ההבדל הוא בנקודת המוצא. jail מתחיל עם קבוצה רחבה של פעולות חסומות, ואתם מאפשרים אותן מחדש פרמטר אחר פרמטר. מכולת Docker מתחילה כ-root בתוך קבוצה של namespaces עם חלק מהיכולות (capabilities) מוסרות, והקשחה נוספת היא אופציונלית. בפועל, התצורה קובעת יותר מהמודל: jail שרץ עם allow.mount ו-allow.raw_sockets מופעלים אינו בטוח יותר ממכולה שהוגדרה בקפידה.

כיצד מגבים jail?

בצעו snapshot ל-dataset ושלחו אותו. השתמשו ב-sudo zfs snapshot zroot/jails/containers/web@backup, ולאחר מכן ב-zfs send כדי לשלוח את ה-snapshot ל-pool אחר או לקובץ שאתם מעתיקים מחוץ למכונה. מכיוון ש-jail שומר את כל ה-userland שלו ב-dataset אחד, ה-snapshot לוכד את החבילות המותקנות ואת הנתונים בנקודת זמן עקבית אחת, יחד עם כל קובץ תצורה שערכתם ידנית. זהו ההפך מהרגלי העבודה של Docker, שבהם מגבים את ה-volumes בעלי השם ואת קובץ ה-Compose ובונים מחדש את השאר מתוך ה-image.

האם אני זקוק ל-BastilleBSD, או שהמערכת הבסיסית מספיקה?

המערכת הבסיסית מספיקה, והיא המקום הטוב יותר להתחיל בו. הפקודות jail.conf, jls, jexec ו-service jail start מכסות את כל המודל, וברגע שתכירו אותן תוכלו לקרוא כל מארח FreeBSD מבלי ללמוד תחילה את כלי הניהול הספציפיים של אותו מארח. Bastille היא שכבת נוחות מעל: היא מבצעת bootstrap לגרסאות, יוצרת jails רזים, מחילה תבניות וכותבת עבורכם חוקי ניתוב של pf. למדו תחילה את הפקודות הבסיסיות, ולאחר מכן הוסיפו את Bastille כאשר מספר ה-jails הופך את ההקלדה למייגעת.

האם המאמר הזה היה מועיל?