FreeBSD jails vs Docker containers: తేడా ఏమిటి?

FreeBSD jails మరియు Docker containers: ఒక పేరాలో

FreeBSD jails మరియు Docker containers ఒకే సమస్యను రెండు భిన్నమైన విధానాల్లో పరిష్కరిస్తాయి. రెండూ ఒకే shared kernel పై isolated userlands ను నడుపుతాయి. అందువల్ల ఇవి రెండూ virtual machineలు కావు. వీటి మధ్య తేడా లోపల ఏమి ఉంటుందన్నదిలో ఉంది. Docker container మీరు registry నుంచి pull చేసిన layered image నుంచి ఒక process ను నడుపుతుంది. jail మాత్రం పూర్తి FreeBSD userland ను నడుపుతుంది: దానికి స్వంత /etc, స్వంత rc startup scripts, స్వంత pkg database ఉంటాయి; మీరు కోరుకున్నన్ని processes ను కూడా నడపవచ్చు. ఈ పేజీలోని దాదాపు ప్రతి ఇతర తేడా ఈ ఒక్క విషయంనుంచే వస్తుంది.

SSD Nodes FreeBSD images ను అందించదు. ఈ platform పై మీరు FreeBSD server ను rent చేయలేరు. కింద ఉన్నది ఇక్కడ కొనుగోలు చేయగల machine కోసం install guide కాదు. ఇది రెండు isolation models కు సంబంధించిన పోలిక. ఒక workload కు నిజంగా ఏది అవసరమో మీరు గుర్తించగలిగేలా, అలాగే ఊహాగానాలు లేకుండా FreeBSD team యొక్క setup ను అర్థం చేసుకోగలిగేలా ఇది రాయబడింది.

ఒక jail అంటే ఏమిటి

Jails 2000 మార్చిలో FreeBSD 4.0లో వచ్చాయి. అందువల్ల అవి cgroups కంటే పాతవి, Docker కంటే సుమారు ఒక దశాబ్దం పాతవి. ఈ విధానం ఒక kernel call పై ఆధారపడి ఉంటుంది. jail(8) ఒక directory tree ను తీసుకుని, దానిలో processes ను jail ID తో ప్రారంభిస్తుంది. ఆ ID ఉన్న ఏ process అయినా నిర్దిష్ట operations చేయకుండా kernel నిరోధిస్తుంది. jail లో ఉన్న process తన jail వెలుపల ఉన్న processes ను చూడలేదు. అది filesystems ను mount లేదా unmount చేయలేదు. kernel modules ను load చేయలేదు. jail కు కేటాయించని network addresses కు bind కాలేదు. నేర్చుకోవాల్సిన ప్రత్యేక namespace రకం లేదు. ప్రతి feature కు విడిగా opt-in చేయాల్సిన అవసరం కూడా లేదు. ఈ restrictions అన్నీ ఒకే unit గా వర్తిస్తాయి. jail configuration లోని parameters ద్వారా వాటిని సర్దుబాటు చేయవచ్చు.

Host పై, jls నడుస్తున్న jails ను చూపిస్తుంది. jexec web sh web పేరున్న jail లోని shell కు తీసుకెళ్తుంది.

ఒక directory లో FreeBSD userland ను ఉంచడం ద్వారా jail ను నిర్మిస్తారు. base system ఈ పనిని మీ కోసం చేస్తుంది:

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

ఈ command మీ release కు సంబంధించిన base distribution set ను fetch చేసి, సాధారణ post-install దశలను అమలు చేస్తుంది. అందువల్ల కొత్త server లో చేసినట్లుగానే root password ను సెట్ చేసి, timezone ను ఎంచుకోవాలి. ఫలితంగా ఒక folder లో FreeBSD installation సిద్ధంగా ఉంటుంది. తరువాత దాన్ని /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;
}

దాన్ని start చేసి, తరువాత తనిఖీ చేయండి:

sudo service jail start web
jls

ఇప్పుడు jls, web ను JID, hostname మరియు IP address తో చూపించాలి. jail కనిపించకపోతే sudo jail -c web ను నేరుగా run చేయండి. ఇది అదే configuration ను foreground లో apply చేసి, అంగీకరించలేని parameter ను చూపిస్తుంది. అందువల్ల failure service output లో మాత్రమే మిగిలిపోదు.

రెండుసార్లు చదవాల్సిన line exec.start = "/bin/sh /etc/rc". jail ను start చేయడం వల్ల దాని లోపల FreeBSD యొక్క సాధారణ boot script run అవుతుంది. అందువల్ల jail తన స్వంత /etc/rc.conf లో enabled చేసిన ప్రతి service ను ప్రారంభిస్తుంది. Docker container కు దీనికి సమానమైన దశ ఉండదు. అది image యొక్క entrypoint process ను run చేసి, ఆ process ఆగినప్పుడు తానే ఆగిపోతుంది.

సాఫ్ట్‌వేర్‌ను ఎలా పొందుతారు: images మరియు registries వర్సెస్ మీరు స్వయంగా నింపే userland

మొదటి రోజునే మీకు స్పష్టంగా కనిపించే తేడా ఇదే.

Dockerలో మీరు సాఫ్ట్‌వేర్ పేరు ఇస్తే అది మీకు లభిస్తుంది. docker pull nginx ఇతరులు build చేసి, test చేసిన layered, content-addressed image ను fetch చేస్తుంది. docker compose up -d ఆ image ను దాని volumes మరియు network అనుసంధానంతో ప్రారంభిస్తుంది. Registryనే ప్రధాన భాగం. Docker workflowలోని ఎక్కువ విలువ ఏమిటంటే, వేలాది projectలు పనిచేసే imageలను publish చేస్తాయి. అందువల్ల VPSపై Docker నడపడం ఒక project కాకుండా తక్కువ సమయంలో పూర్తయ్యే పనిగా మారుతుంది.

FreeBSD jail images కోసం default public registryని అందించదు. మీరు ఖాళీ userlandను సృష్టించి, bare serverను setup చేసినట్లే అందులో సాఫ్ట్‌వేర్‌ను install చేస్తారు. దీనికి ఎక్కువ typing అవసరం. అయితే ఇది మరింత పారదర్శకంగా ఉంటుంది, ఎందుకంటే jailలో నడిచేది host ఉపయోగించే అదే package set నుంచి pkg అందులో install చేసినదే.

Tooling ఈ ప్రక్రియను చిన్నదిగా చేస్తుంది. BastilleBSD సాధారణంగా ఉపయోగించే jail manager, ఇది ఒక packageగా లభిస్తుంది:

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

bastille setup networking, storage మరియు firewallను మీ కోసం configure చేస్తుంది. bastille bootstrap ఒక releaseను ఒక్కసారి download చేస్తుంది. తరువాత మీరు సృష్టించే ప్రతి jail దానినే మళ్లీ ఉపయోగిస్తుంది. FreeBSD 15.1 ప్రస్తుత production release; ఇది June 2026లో విడుదలైంది. మీరు నడుపుతున్న releaseకు అనుగుణంగా దాన్ని మార్చండి.

ఆ తరువాత jailను సృష్టించడానికి ఒక command, దాన్ని నింపడానికి మరో command చాలు:

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 jailలో login shellను అందిస్తుంది. bastille list hostలో ఉన్న వాటిని చూపిస్తుంది. Buildను మళ్లీ పునరావృతం చేయడానికి Bastille templates దశలను ఒక fileలో ఉంచి, వాటిని jailకు వర్తింపజేస్తాయి. ఈ విధానం Dockerfileకు ఈ పరిసరంలో ఉన్న అత్యంత సమీపమైన ప్రత్యామ్నాయం. ప్రతి jailపై templateను మళ్లీ అమలు చేయవచ్చు. ముందే build చేసినది ఏదీ అందుబాటులోకి రాదు.

కాబట్టి సూటిగా చెప్పాలంటే: Docker ఇతరులు చేసిన buildsను మీకు అందిస్తుంది. Jailsలో మీరు స్వయంగా installs చేస్తారు. మీ ఎంపికల జాబితాలోని సాఫ్ట్‌వేర్ container imageగా మాత్రమే లభించి, మరే విధంగానూ అందుబాటులో లేకపోతే, ఇతర అంశాలను పరిశీలించే ముందే నిర్ణయం స్పష్టమవుతుంది.

స్థితి మరియు అప్‌గ్రేడ్‌లు: ZFS మార్చే భాగం

Docker ఉద్దేశపూర్వకంగా state ను వేరు చేస్తుంది. Container filesystem తాత్కాలికమైనది. మీ data named volume లేదా bind mount లో ఉంటుంది. అప్‌గ్రేడ్ అంటే docker compose pull తర్వాత docker compose up -d. Container ను భర్తీ చేస్తారు. Volume లో ఉంచని ఏదైనా తొలగిపోతుంది. ఈ నియమాన్ని పాటిస్తే ఇది ఒక లక్షణం. మర్చిపోతే ఇది data-loss సంఘటనగా మారుతుంది. అందుకే Compose stack లో bind mounts మరియు named volumes మధ్య ఎంపికకు అంత ప్రాధాన్యం ఉంటుంది.

Jail state ను వేరు చేయదు. ఇది పనిచేయడానికి 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 తో పరిశీలించండి. పై path handbook ఉపయోగించే layout. Snapshot తీసుకోవడానికి సుమారు ఒక సెకను పడుతుంది. Jail contents మారే వరకు దానికి దాదాపు disk space అవసరం ఉండదు. అప్‌గ్రేడ్ తర్వాత service సరిగా పనిచేయకపోతే rollback ద్వారా మొత్తం userland ను దాని మునుపటి స్థితికి తీసుకురావచ్చు. ఇందులో package database, మీరు రాత్రి 2am కు చేతితో మార్చిన config files కూడా ఉంటాయి. Docker లో దీనికి built-in equivalent లేదు. ఎందుకంటే దాని model ప్రకారం మీకు అలాంటి వ్యవస్థ అవసరం ఉండదని భావిస్తుంది.

zfs clone మరో ముఖ్యమైన భాగం. Snapshot యొక్క clone అనేది కొత్త writable jail. ఇది parent తో మారని blocks ను share చేస్తుంది. అందువల్ల 3 GB jail యొక్క staging copy కు disk పై దాదాపు ఏమీ ఖర్చు ఉండదు. మీరు దానిలో మార్పులు చేయడం ప్రారంభించే వరకు ఇదే పరిస్థితి. FreeBSD admin production కు సమానమైన jail ను తయారు చేసి అప్‌గ్రేడ్‌ను ముందుగా పరీక్షించే విధానం ఇదే.

Base system upgrade packages నుండి వేరు. Userland యొక్క స్వంత copy కలిగిన jail కోసం:

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

Thin jails ఈ పనిని పునరావృతం చేయకుండా ఉంటాయి. అవి nullfs ద్వారా ఒకే shared read-only base ను mount చేస్తాయి. ప్రతి jail కు దాని స్వంత చిన్న writable layer ఉంటుంది. అందువల్ల base ను ఒకసారి patch చేస్తే ప్రతి jail ఆ మార్పును చూస్తుంది. Bastille డిఫాల్ట్‌గా thin jails ను సృష్టిస్తుంది.

నెట్‌వర్కింగ్: published ports మరియు addressing నిర్ణయం

Docker మీకు నెట్‌వర్కింగ్‌ను స్వయంచాలకంగా నిర్ణయించి, అవసరమైన మినహాయింపులను publish చేయమని కోరుతుంది. Containers bridge పైకి చేరుతాయి, user-defined network లో service name ద్వారా ఒకదానినొకటి చేరుకుంటాయి, మరియు -p 8080:80 వాటిలో ఒకదాన్ని host కు expose చేస్తుంది. ఇది జరగడానికి Docker స్వంత packet filter rules రాస్తుంది. అందువల్లనే published container port ufw ను నేరుగా దాటిపోతుంది.

Jail లో మీరు ముందుగానే మోడల్‌ను ఎంచుకోవాలి. దీనికి రెండు ఎంపికలు ఉన్నాయి.

Shared IP. ip4.addr = "10.0.0.10" ఆ address ను ఇప్పటికే ఉన్న host interface కు జోడించి, jail ను దానికే పరిమితం చేస్తుంది. Jail కు స్వంత network stack ఉండదు. అందువల్ల అది స్వంత firewall ను నడపలేడు. ఇది ప్రతి address కు bind కూడా కాలేదు: 0.0.0.0 కోసం అభ్యర్థించే jailed socket ను kernel jail యొక్క స్వంత address కు మార్చుతుంది. ఒకే address లోని port 80 పై రెండు jails రెండూ listen చేయలేవు. కాబట్టి ప్రతి jail కు ఒక address ఇవ్వాలి లేదా ముందు reverse proxy ఉంచాలి.

VNET. Jail కు vnet; జోడిస్తే పూర్తి network stack లభిస్తుంది: స్వంత interfaces, స్వంత routing table, స్వంత firewall rules. దాన్ని host కు epair ద్వారా అనుసంధానిస్తారు. ఇది రెండు వైపులా ఒక్కో చివర ఉన్న virtual cable వంటిది. తరువాత host వైపు ఉన్న చివరను bridge పై ఉంచాలి. Docker అందించే విధానానికి ఇది అత్యంత సమీపమైనది. Bastille యొక్క -V మరియు -B jail types వెనుక ఉన్న mode కూడా ఇదే.

Host port ను jail లోకి forward చేయడం pf redirect rule. Bastille దీన్ని ఇలా wrap చేస్తుంది:

sudo bastille rdr web tcp 80 80

ఇక్కడ EXPOSE ఉండదు. స్వయంచాలక publishing కూడా ఉండదు. దాని address లేదా redirect rule అనుమతిస్తే తప్ప ఏదీ jail ను చేరదు. ప్రారంభానికి ఇది కొంత ఎక్కువ సమయం తీసుకుంటుంది. అయితే firewall మరింత నిశ్శబ్దంగా ఉంటుంది.

వనరుల పరిమితులు: cgroups మరియు rctl

Docker, cgroups ఉపయోగించి container కు పరిమితులు విధిస్తుంది. ఆ పరిమితులు container నిర్వచించిన చోటే ఉంటాయి: command line లోని --memory=1g --cpus=1.5 లేదా Compose file లోని సంబంధిత keys. మీ stack ను ఇప్పటికే VPS లోని Docker Compose file లో నిర్వహిస్తే, పరిమితి వర్తించే service పక్కనే ఉంటుంది. అది git లో service తో పాటు కొనసాగుతుంది.

FreeBSD, rctl ను ఉపయోగిస్తుంది. దీన్ని మీరు ప్రత్యేకంగా enable చేయాలి. ప్రతి allocation పై కొంత overhead ఉండటం వల్ల resource accounting డిఫాల్ట్‌గా off లో ఉంటుంది. /boot/loader.conf కు tunable ను జోడించి reboot చేయండి:

kern.racct.enable=1

తర్వాత ఒక rule సెట్ చేసి దాన్ని monitor చేయండి:

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

rctl -hu jail:web jail యొక్క ప్రస్తుత వినియోగాన్ని మనుషులు సులభంగా చదవగల units లో చూపిస్తుంది. ఏదైనా విఫలమయ్యే ముందు limit కు ఎంత దగ్గరగా ఉందో మీరు చూడవచ్చు. deny action, limit మించిన allocation ను jail లోనే fail చేస్తుంది. అందువల్ల host పై kill message కనిపించకుండా, application స్వయంగా ఇచ్చే allocation error కనిపిస్తుంది.

rctl -a తో జోడించిన rules తదుపరి reboot సమయంలో తొలగిపోతాయి. FreeBSD యొక్క rctl service, వాటిని /etc/rctl.conf నుంచి reload చేస్తుంది. కాబట్టి rule ను ఆ file లో రాసి service ను enable చేయండి:

sudo sysrc rctl_enable=YES

ఈ విషయంలో Docker స్పష్టంగా మరింత సౌకర్యవంతంగా ఉంటుంది. Compose file లోని limit, అది నియంత్రించే service తో పాటు review చేయవచ్చు. rctl rule అనేది ప్రత్యేక file లోని ఒక line. ఆ line లో మరెక్కడో నిర్వచించిన jail పేరు ఉంటుంది.

సమాధానం virtual machine అయితే: bhyve

Jail host kernel ను పంచుకుంటుంది. అందువల్ల కొన్ని విషయాలు దానికి ఎప్పటికీ అందుబాటులో ఉండవు. అది వేరే kernel version ను అమలు చేయలేదు. Kernel module ను load చేయలేదు. Linux container చేసే విధంగా Linux binaries ను అమలు చేయలేదు. FreeBSDలో linuxulator అనే Linux compatibility layer ఉంది. అయితే ఇది Linux system calls లో కొంత భాగాన్ని మాత్రమే అమలు చేస్తుంది. ఏవైనా Linux images కోసం ఇది సాధారణ పరిష్కారం కాదు.

bhyve FreeBSD యొక్క hypervisor. నిజమైన machine boundary అవసరమైనప్పుడు ఇది సరైన సాధనం. ఉదాహరణకు వేరే operating system, వేరే kernel లేదా మీరు kernel ను పంచుకోవాలనుకోని tenant అవసరమైనప్పుడు దీన్ని ఉపయోగించాలి. దీనికి shared memory బదులుగా ప్రత్యేకంగా కేటాయించిన memory అవసరం. అలాగే patch చేయాల్సిన రెండవ kernel కూడా ఉంటుంది. Linuxలో containers మరియు పూర్తి virtual machines మధ్య ఎంచుకునే సమయంలో మీరు తీసుకునే నిర్ణయం ఇదే. కింద nested virtualization కు మద్దతు ఇచ్చే VPS అవసరమా లేదా అనేది కూడా ఈ నిర్ణయంపైనే ఆధారపడి ఉంటుంది.

పర్యావరణ వ్యవస్థ: చాలా బృందాలు Docker ను ఉపయోగించడానికి అసలు కారణం

పైన చెప్పినదంతా మోడల్‌కు సంబంధించినది. అయితే చాలా బృందాలు ఏది ఎంచుకోవాలో నిర్ణయించేది, ప్రతి మోడల్ చుట్టూ ఉన్న పర్యావరణ వ్యవస్థ పరిమాణం.

Docker తో Docker Hub మరియు GHCR, docker compose, ఒకే బాక్స్ సరిపోనప్పుడు Kubernetes, container support ముందుగానే అమర్చిన CI runners, అలాగే దాదాపు ప్రతి project READMEలో ఒక-command quickstart లభిస్తాయి. Jails విషయంలో FreeBSD ports tree పెద్దదిగా, జాగ్రత్తగా నిర్వహించబడేదిగా ఉంటుంది. అయితే సిద్ధంగా నడపగల application bundles చాలా తక్కువగా ఉంటాయి. ఒక project container image మాత్రమే ప్రచురించి, మరేమీ ఇవ్వనప్పుడు, FreeBSD మార్గంలో దాని documentation చదివి భాగాలను మీరే సమీకరించాలి.

ఆ trade-off లోని మరో వైపున Jails కు తమ స్థానం ఉంది. మీరు ఇప్పటికే ZFS నడుపుతూ, మొత్తం service కు snapshot మరియు rollback విలువైనవిగా భావిస్తే Jails ఎంచుకోవచ్చు. మీ services FreeBSD native అయితే కూడా అవి అనుకూలంగా ఉంటాయి. ఒకే process కు బదులుగా ప్రతి tenant కు పూర్తి userland కావాలన్నా, kernel, packet filter, filesystem మరియు documentation ను ఒకే system గా కలిపి నిర్వహించాలన్నా Jails ఉపయోగకరంగా ఉంటాయి. FreeBSD ను coherent అని పిలిచేటప్పుడు ప్రజలు ఉద్దేశించేది ఇదే. server platforms గా Linux మరియు FreeBSD పై విస్తృత పోలిక మరియు server వినియోగం కోసం FreeBSD 15 లో మారిన అంశాలు లో దీనికి మరింత వివరాలు ఉన్నాయి.

చివరి నిర్ణయం ఇది. మీ బృందానికి Docker ఇప్పటికే తెలుసు అయితే, మార్పు ఖర్చు నిజమైనదే. దానికి నిర్దిష్ట ప్రయోజనం ఉండాలి. Isolation quality కోసం మాత్రమే మారవద్దు; రెండు మోడళ్ల మధ్య తేడా అంత ఎక్కువగా లేదు, మీ configuration ప్రభావమే ఎక్కువ. మొత్తం services కు ZFS-backed rollback కావాలనుకుంటే లేదా మీరు ఇప్పటికే FreeBSD ఉపయోగిస్తుంటే మారండి.

FAQ

నేను FreeBSDలో Docker images నడపవచ్చా?

Linux images ను కాదు, అలాగే ఇది supported మార్గం కూడా కాదు. FreeBSDలో OCI container support ఉంది: sudo pkg install -y podman-suite ద్వారా Podman install అవుతుంది. ఇది ocijail ద్వారా containers ను నడుపుతుంది. ocijail కింద నిజమైన jails ను సృష్టించే runtime. Container monitor కోసం fdescfs ను /dev/fd పై mount చేయాలి. Container NAT (network address translation) కోసం pf అవసరం. FreeBSD-native OCI images ఉత్తమంగా పనిచేస్తాయి. Linux images కు అదనంగా Linux compatibility layer అవసరం. August 2026 నాటికి FreeBSD Podman port ఇంకా experimental గా వర్ణించబడుతోంది. మీ deployment Linux images సమూహంపై ఆధారపడి ఉంటే, దాన్ని Linuxపై నడపండి.

FreeBSD jails Docker containers కంటే సురక్షితమైనవా?

రెండూ ఒకే host kernel ను పంచుకుంటాయి. అందువల్ల kernel bug రెండింటికీ ప్రమాదమే. నిజంగా నమ్మలేని code కోసం వీటిలో ఏదీ మీరు ఎంచుకునే boundary కాదు. తేడా ప్రారంభ స్థితిలో ఉంటుంది. Jailలో విస్తృతమైన operations ప్రారంభంలో నిరాకరించబడతాయి. తరువాత వాటిని ఒక్కో parameter ద్వారా మళ్లీ enable చేస్తారు. Docker containerలో namespaces సమూహం లోపల rootగా ప్రారంభమవుతుంది. కొన్ని capabilities తొలగించబడతాయి. అదనపు hardening opt-in విధానంలో ఉంటుంది. ఆచరణలో model కంటే configuration ఎక్కువ నిర్ణయిస్తుంది. allow.mount మరియు allow.raw_sockets enable చేసిన jail, జాగ్రత్తగా configure చేసిన container కంటే సురక్షితమైనది కాదు.

నేను jailను ఎలా backup చేయాలి?

Datasetను snapshot తీసి, దాన్ని పంపండి. sudo zfs snapshot zroot/jails/containers/web@backup ఉపయోగించి snapshot తీసుకోండి. తరువాత zfs send ఉపయోగించి ఆ snapshotను మరో poolకు లేదా machine వెలుపల copy చేసే fileలోకి పంపండి. Jail తన మొత్తం userlandను ఒకే datasetలో ఉంచుతుంది. అందువల్ల snapshot install చేసిన packages, data, అలాగే మీరు చేతితో మార్చిన ప్రతి config fileను ఒకే consistent point వద్ద capture చేస్తుంది. Dockerలో సాధారణంగా చేసే విధానానికి ఇది విరుద్ధం. అక్కడ named volumes మరియు Compose fileను backup చేసి, మిగతాదాన్ని image నుంచి మళ్లీ build చేస్తారు.

నాకు BastilleBSD అవసరమా, లేక base system సరిపోతుందా?

Base system సరిపోతుంది. ప్రారంభించడానికి అదే మెరుగైన స్థలం. jail.conf, jls, jexec మరియు service jail start మొత్తం modelను కవర్ చేస్తాయి. వీటిని తెలుసుకున్న తర్వాత, ఆ host యొక్క toolingను ముందుగా నేర్చుకోకుండానే ఏ FreeBSD hostనైనా చదివి అర్థం చేసుకోవచ్చు. Bastille దాని పైన పనిచేసే convenience layer. ఇది releasesను bootstrap చేస్తుంది, thin jailsను సృష్టిస్తుంది, templatesను apply చేస్తుంది మరియు మీ తరఫున pf redirect rulesను రాస్తుంది. ముందుగా base commands నేర్చుకోండి. తరువాత jails సంఖ్య పెరిగి typing ఇబ్బందిగా మారినప్పుడు Bastilleను జోడించండి.