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

אירוח עצמי של KiroCrew על גבי VPS: מדריך הגדרה

למדו כיצד להריץ את KiroCrew כקונטיינר קבוע על שרת VPS. המדריך מסביר כיצד להגדיר Docker ו-systemd כדי להבטיח שהסוכנים, המשימות והזיכרון ישרדו כל אתחול מחדש של השרת.

למה לארח את KiroCrew בשרת VPS ולא במחשב נייד

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

KiroCrew הוא סביבת עבודה לסוכנים בקוד פתוח מבית צוות Kiro, תחת רישיון Apache 2.0, עם 0.1.0 ששוחרר ב-22 ביולי 2026. תהליך אחד, הנקרא gateway, מחזיק במצב (state) ומגיש לוח בקרה (dashboard) בפורט 5476. אתם ניגשים ל-gateway הזה מלוח הבקרה, מתוך ה-CLI של kirocrew, או מערוץ צ'אט כמו Slack. ה-gateway הוא הרכיב היחיד שאתם מארחים בעצמכם, ולכן מדריך זה עוסק בשמירה על פעילותו, בהרחקתו מהאינטרנט הציבורי, וביכולת לשחזר אותו לאחר שדרוג כושל.

שני דברים שכדאי לדעת לפני שמתחילים. מאז 0.11.0, התקנות חדשות של KiroCrew ללא בחירת harness שמורה כברירת מחדל ל-KAS ללא צורך ב-kiro-cli; בחירות מפורשות קיימות ב-CLI של Kiro נשמרות. הסקה (inference) בשרתי הקצה של Kiro משתמשת בתוכנית ה-Kiro שלכם, ולכן נכון ל-1 בנובמבר 2026, הגדרה זו אינה פועלת במצב לא מקוון (offline). הפרויקט עדיין צעיר ומתקדם במהירות: גרסאות ה-stable שלו עברו מ-0.1.3 ב-5 באוגוסט 2026 ל-0.10.0 ב-25 באוקטובר 2026, עם 0.8.0 ב-9 באוקטובר ו-0.9.0 ב-16 באוקטובר באמצע, ומועמד לשחרור (release candidate) מסוג 0.11.0 כבר יצא כגרסה מוקדמת ב-25 באוקטובר. הניחו שתצטרכו לבצע roll back בשלב כלשהו, והתקינו אותו בדרך שמאפשרת זאת. אם לא הרצתם סוכן על שרת בעבר, הרצת סוכן תכנות על שרת VPS מכסה את כללי היסוד שעליהם מדריך זה מתבסס. אם צד הסוכן חדש לכם יותר מצד השרת, למידה על מה הם באמת לולאת סוכן, הכלים שלו והזיכרון שלו תחילה תהפוך את הבחירות להלן להחלטות מושכלות ולא לכישופים חסרי פשר.

מה KiroCrew דורשת, והיכן נשמר המצב שלה

התקנה מקומית (native) דורשת Python 3.12 ומעלה ו-Node.js 22.12.0 ומעלה אם בונים את ה-dashboard מקוד המקור (הפרויקט ממליץ על Node 24 LTS). ה-backend של ה-Kiro CLI דורש את kiro-cli, עם אימות באמצעות kiro-cli login או מפתח API לשימוש אוטומטי; מאז 0.10.0, מנוע ה-KAS המובנה פועל ללא צורך ב-kiro-cli מותקן, ו-0.11.0 הפך זאת לברירת המחדל עבור התקנות חדשות ללא בחירת harness שמורה. התקנה באמצעות מכולה (container) אינה דורשת דבר מכל אלו על ה-host. היא דורשת Docker. זו הסיבה העיקרית להעדיף אותה.

המצב (state) נשמר ב-~/.kiro/crew, ומשתנה הסביבה KIROCREW_HOME מעביר אותו למיקום אחר. מה נמצא בתוך התיקייה:

  • config.json: הגדרות ה-gateway ופרטי גישה לערוצי צ'אט.
  • .env: סודות (secrets).
  • workspace/memory/: העדפות, הערות פרויקט והיסטוריית צ'אט.
  • memory.db ו-memory_index.db: האינדקסים הסמנטיים ואינדקסי הטקסט המלא.
  • models/: מודל ה-embedding, שיורד בהרצה הראשונה.
  • security_events.jsonl: יומן אירועי האבטחה.

התיקייה הזו היא ההתקנה. העתיקו אותה ל-VPS חדש והעברתם את הסוכן שלכם; זו הסיבה שסעיף הגיבוי להלן חשוב יותר מסעיף ההתקנה.

תכננו לפי נפח דיסק ולא לפי RAM. ה-gateway הוא תהליך Python; מה שבאמת מעמיס על השרת הוא מה שהסוכן מריץ, כגון build או חבילת בדיקות. תיקיית המצב גדלה עם היסטוריית הצ'אט, ומודל ה-embedding מגיע בהפעלה הראשונה, לכן מדדו את הנפח על השרת שלכם באמצעות du -sh ~/.kiro/crew לאחר מספר שבועות, במקום להסתמך על נתונים שפורסמו בחודשים הראשונים של הפרויקט. השוו זאת ל-runtime שנותן לכל worker מכולה משלו ודפדפן משלו, שם אירוח עצמי של עמיתי ה-AI של OpenBot הופך את תכנון המשאבים לשאלה של RAM לפני שהוא שאלה של דיסק.

באיזה מתוך ארבעת נתיבי ההתקנה כדאי לבחור

הפרויקט מפיץ ארבע גרסאות: אפליקציית שולחן עבודה, חבילת wheel בשורת פקודה אחת, קוד מקור ו־Docker. מתקין שורת הפקודה מושך חבילת wheel ויוצר משגר (launcher) בנתיב kirocrew; אם הספרייה שלו אינה מוגדרת ב־PATH שלכם, הוא ידפיס הוראות להוספתה:

curl -fsSL https://download.crew.kiro.dev/cli.sh | sh

הוא מקבל דגל ערוץ (channel) ודגל גרסה (version):

curl -fsSL https://download.crew.kiro.dev/cli.sh | sh -s -- --channel insider
curl -fsSL https://download.crew.kiro.dev/cli.sh | sh -s -- --version 0.8.0

תמונת ה־container מפורסמת ב־ghcr.io/kirodotdev/kirocrew, עבור linux/amd64 ו־linux/arm64 תחת כל תג (tag). בנייה מקוד מקור דורשת git clone בתוספת make build, והיא מיועדת לאנשים שמשנים את הקוד, לא לאנשים שמריצים אותו.

השתמשו ב־container. התקנה מקומית מקוד מקור מציבה חבילות Python ו־Node על אותו מארח שמריץ את השירותים האחרים שלכם, בתוספת kiro-cli בעת שימוש ב־backend של Kiro CLI, כך ששדרוג שמשתבש משאיר אתכם לפתור את הבעיות ידנית. ה־container שומר את סביבת הריצה בתמונה אחת ואת המצב (state) בנפח אחסון (volume) אחד, מה שהופך ביצוע rollback לשינוי תג ואתחול מחדש.

קבעו את ה-image ל-tag של גרסה ספציפית, לא ל-stable

הדוגמה של הפרויקט עצמו משתמשת ב-tag מסוג stable:

docker run -d --name kirocrew \
  -p 127.0.0.1:5476:5476 \
  -v kirocrew-home:/home/kirocrew \
  ghcr.io/kirodotdev/kirocrew:stable

stable הוא tag דינמי, וכך גם latest, שמצביע על אותה גרסה. הוא מצביע תמיד על הגרסה היציבה העדכנית ביותר, לכן ה-pull הבא עלול לשנות את הגרסה שרצה אצלכם ללא בחירה מודעת מצדכם, וה-tag אינו מתעד איזו גרסה הותקנה. tags של גרסאות הם בלתי ניתנים לשינוי (immutable), לכן קבעו אחד מהם. הגרסה היציבה העדכנית ביותר נכון ל-1 בנובמבר 2026 היא 0.11.1, שפורסמה ב-31 באוקטובר 2026, ומהווה תיקון דחוף (hot patch) עבור שלמות זיכרון ותיקוני KAS ב-0.11.0. הדוגמה ל-0.8.0 להלן משתמשת ב-Kiro CLI. קיימים גם tags מסוג insider ו-nightly; ה-nightly עוקב אחר build-ים מ-main.

כתבו את /opt/kirocrew/compose.yaml:

services:
  kirocrew:
    image: ghcr.io/kirodotdev/kirocrew:0.8.0
    container_name: kirocrew
    restart: unless-stopped
    ports:
      - "127.0.0.1:5476:5476"
    volumes:
      - kirocrew-home:/home/kirocrew

volumes:
  kirocrew-home:

הפעילו אותו, ולאחר מכן בדקו את ה-health endpoint שבו ה-image משתמש גם עבור ה-HEALTHCHECK שלו:

cd /opt/kirocrew
docker compose up -d
docker compose ps
curl -s http://127.0.0.1:5476/api/health

docker compose ps אמור לדווח על ה-container כ-healthy בתוך דקה בערך, ו-/api/health משיב ללא token (כמו גם /api/live ו-/api/ready, מה שהופך אותם לשימושיים כ-probes). אם המצב נשאר starting, קראו את docker logs kirocrew לפני שמשנים משהו. ההרצה הראשונה מורידה את מודל ה-embedding ברקע; חיפוש בזיכרון משתמש בהתאמת מילות מפתח עד שהמודל מגיע.

שמירה על פעילות רציפה באמצעות systemd

restart: unless-stopped מחזיר את המכולה לפעולה לאחר קריסה ולאחר אתחול, כל עוד Docker עצמו עולה בעליית המערכת. קובץ unit מגדיר את התלות הזו במפורש ומספק פקודה אחת לעצירת כל ה־stack לפני ביצוע גיבוי. הפעלת Docker Compose stack בעליית המערכת מכסה את התבנית הכללית. זהו המבנה המקובל ב־KiroCrew, בתוך /etc/systemd/system/kirocrew.service:

[Unit]
Description=KiroCrew gateway
Requires=docker.service
After=docker.service

[Service]
Type=oneshot
RemainAfterExit=yes
WorkingDirectory=/opt/kirocrew
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
TimeoutStartSec=0

[Install]
WantedBy=multi-user.target
sudo systemctl daemon-reload
sudo systemctl enable --now kirocrew
systemctl status kirocrew

systemctl status kirocrew אמור להציג active (exited), שזו התוצאה התקינה עבור יחידה זו. Type=oneshot עם RemainAfterExit=yes נדרש כאן כיוון ש־docker compose up -d חוזר מיד ברגע שהמכולה מופעלת: systemd עוקב אחר העובדה שה־stack פעיל, ולא אחר תהליך שרץ ב־foreground. אם תכתבו Type=simple במקום זאת, systemd יראה שהפקודה מסתיימת מיד, יסמן את השירות כמת, ואז או שיוותר או שייכנס ללולאת אתחול, בהתאם להגדרת ה-Restart= שלכם. עבור התקנה מקומית (native), הפרויקט מספק שירות מקביל משלו, kirocrew service install, שכותב ל-/etc/systemd/system/kirocrew.service ומריץ את ה-gateway תחת המשתמש שלכם. אל תריצו את שתי היחידות במקביל. הגרסה המורחבת של נושא זה נמצאת ב-שירותי systemd וטיימרים ב-VPS. יחידה שלא מצליחה לעלות מחדש תישאר שקטה אלא אם תגרמו לה "לדבר", לכן הוסיפו מטפל OnFailure= ש-שולח התראה לשרת ntfy שלכם, וכך תשמעו שה-gateway למטה ישירות מהטלפון, במקום לגלות זאת רק דרך משימה מתוזמנת שמעולם לא רצה.

הרצה ראשונה: התחברות וקבלת אסימון ללוח הבקרה

הקונטיינר מפעיל את ה-gateway, אך סביבת ה-runtime של Kiro CLI המוגדרת בתוך ה-image המקובע 0.8.0 עדיין דורשת אימות. בצעו התחברות בתוך הקונטיינר, או העבירו את KIRO_API_KEY דרך משתני הסביבה של הקונטיינר לשימוש אוטומטי:

docker exec -it kirocrew kiro-cli login

פעולה זו תדפיס קוד מכשיר וכתובת URL שעליכם לפתוח בדפדפן שלכם. לאחר מכן, צרו אסימון (token) ללוח הבקרה:

docker exec kirocrew kirocrew token --ttl 2h

כתובת ה-URL של לוח הבקרה היא http://localhost:5476/?token=<the token>. אסימונים פוקעים: יש לפתוח את הקישור המודפס בתוך חמש דקות מרגע יצירתו, ופקודה זו מבקשת עוגיית גישה לשעתיים, כאשר עשרים שעות הן המקסימום המתועד. הדפדפן מקבל גם עוגיית רענון עם חלון המתנה (idle window) מתגלגל של 30 ימים, כך שסשן פעיל מתחדש ללא צורך בקישור נוסף. לוח בקרה שנטען ריק או מחזיר אתכם מיד החוצה מעיד בדרך כלל על אסימון שפג תוקפו; צרו אסימון חדש ופתחו אותו מיד. לעולם אל תדביקו אסימון בתוך כרטיס תמיכה (ticket) או בהודעת צ'אט, כיוון שמי שמחזיק בו מחזיק בגישה לסוכן (agent) שלכם.

גישה ללוח הבקרה באמצעות SSH, ללא חשיפת פורט 5476

עיינו שוב בכתובת ה-bind בדוגמה של הפרויקט: -p 127.0.0.1:5476:5476. בתוך המכולה, ה-gateway מאזין ל-0.0.0.0, שכן עליו להיות נגיש דרך מיפוי הפורטים, אך המיפוי עצמו מוגדר ל-loopback בלבד במארח. מחיקת הקידומת 127.0.0.1: תחשוף את ה-gateway לאינטרנט הציבורי עבור כל מי שיסרוק את הפורט. חוק ufw לא יגן עליכם: Docker מפרסם פורטים על ידי כתיבת חוקי DNAT שמנתבים את התעבורה לפני החוקים של ufw, לכן ufw deny 5476 אינו משפיע על פורט שפורסם. עם ה-backend של iptables ב-Docker, הפתרון של Docker הוא הוספת חוקי סינון בשרשרת DOCKER-USER. זה עובד, אך חוקים אלו רואים את הכתובת והפורט הפנימיים של המכולה אלא אם משתמשים ב-conntrack extension, לכן ה-bind ל-loopback נותר אמצעי הבקרה הפשוט והבטוח ביותר. ה-backend של nftables ב-Docker משתמש בטבלאות ובשרשראות בסיס נפרדות לסינון מותאם אישית. המאמר Docker ports bypassing ufw מפרט את המנגנון הזה.

בצעו העברת פורט (forward) דרך SSH מהמחשב הנייד שלכם במקום זאת:

ssh -N -L 5476:127.0.0.1:5476 you@your-server.example.com

השאירו את התהליך רץ ופתחו את http://localhost:5476/?token=<the token> באופן מקומי. כדי להפוך את ההעברה לאוטומטית בכל חיבור, הוסיפו אותה ל-~/.ssh/config:

Host your-server.example.com
    LocalForward 5476 127.0.0.1:5476

אם פורט 5476 כבר בשימוש במחשב שלכם, שנו רק את המספר בצד שמאל: ssh -N -L 45476:127.0.0.1:5476 you@your-server.example.com, ולאחר מכן גלשו ל-http://localhost:45476/?token=.... אין צורך בהגדרת loopback-port נוספת או ביצירה מחדש של המכולה: ה-Origin של ה-loopback תואם ל-Host של הבקשה, לכן בדיקת ה-CSRF מאשרת אותה. תצטרכו לערום העברות כאלו ברגע שסוכן שני ישתף את השרת, כיוון ש-self-hosting open-kritt for security scanning מציב לוח בקרה נוסף מבוסס loopback על אותו שרת, בפורט 5173.

שתי התנהגויות מתועדות קובעות אילו הגדרות ניתן לשנות מלוח הבקרה. ראשית, ה-gateway מתייחס לכל בקשה הנושאת כותרות העברה (Forwarded, X-Forwarded-* או X-Real-IP) כבקשה מרוחקת, ונקודות הקצה לכתיבת תצורה וחשיפת סודות מסרבות לבקשות אלו. Reverse proxy מוסיף כותרות אלו; העברת ssh -L פשוטה אינה מוסיפה דבר, לכן היא נראית מקומית ולא נדחית מסיבה זו. שנית, בתמונת המכולה, דפי אישורי הערוץ ותצוגות חשיפת הסודות הם לקריאה בלבד עבור כל דפדפן שאינו direct-local, והתמונה אינה כוללת עורך טקסט. אישור ערוץ שלא נשמר מלוח הבקרה הוא עניין של הגדרה, לא באג. ערכו את התצורה במארח במקום זאת:

docker cp kirocrew:/home/kirocrew/.kiro/crew/config.json .
# edit config.json here
docker cp config.json kirocrew:/home/kirocrew/.kiro/crew/config.json
docker exec -u 0 kirocrew chown kirocrew:kirocrew /home/kirocrew/.kiro/crew/config.json
docker restart kirocrew

עבור גישה מהטלפון, הפרויקט מפנה ל-tailscale serve של Tailscale, השומר את לוח הבקרה בתוך ה-tailnet שלכם במקום על שם מתחם ציבורי. העדיפו זאת על פני reverse proxy ציבורי. האסימון (token) עובר בתוך ה-URL, ו-URL נכתב בכל לוג גישה בנתיב שלו. הכלל הזה נוגע למה שנמצא מאחורי הפורט ולא לפורט עצמו: שירותים כמו Halcyon, which rebuilds a Jellyfin library as a browsable 90s video store קיימים כדי שאנשים אחרים יפתחו אותם והם מועמדים סבירים ל-reverse proxy, בעוד ש-gateway שמסוגל להריץ פקודות על השרת שלכם אינו כזה.

צמצום טווח ההשפעה של ה-agent למינימום האפשרי

ה-container בודק תמיכה ב-sandbox בעת ההפעלה הראשונה, והתוצאה קובעת אם ה-agents יוכלו להריץ פקודות. אם קיימת בידוד באמצעות namespaces, תהליכי המשנה של ה-agent ירוצו בסביבה מבודדת. אם האפשרות אינה זמינה והמשתנה KIROCREW_ALLOW_UNSANDBOXED=1 אינו מוגדר, ההרצה תיחסם במקום להתבצע ללא הגבלות. לכן, gateway שנראה תקין אך כל המשימות בו תקועות מעיד לרוב על מצב זה. ההחלטה נשמרת ב-docker logs kirocrew מההרצה הראשונה. הפרויקט מפרסם גם פרופיל seccomp (מצב מחשוב מאובטח) שניתן להחיל:

curl -fsSL https://raw.githubusercontent.com/kirodotdev/KiroCrew/main/docker/seccomp/kirocrew-seccomp.json \
  -o /opt/kirocrew/kirocrew-seccomp.json
    security_opt:
      - seccomp:./kirocrew-seccomp.json

במארח שבו AppArmor פעיל, מדריך ה-Docker של הפרויקט מציין שפרופיל ה-seccomp הוא רק חצי מהפתרון, כיוון ש-Docker מצמיד גם את פרופיל ה-AppArmor מסוג docker-default, והוא משלב את הפרופיל עם apparmor=unconfined. אפשרות זו מסירה רק את הכללים של AppArmor לכל container; פרופיל ה-seccomp, היכולות שהוסרו (dropped capabilities) והרצת התהליך כמשתמש שאינו root עדיין תקפים.

אם בחרתם להגדיר את KIROCREW_ALLOW_UNSANDBOXED=1, עליכם להבין היטב מה השתנה: ה-container הוא כעת הגבול היחיד שבין ה-agent לבין השרת שלכם. אזהרת הפרויקט ראויה לחזרה מלאה: אל תבצעו mount לנתיבים במארח שלא הייתם מוסרים ישירות לידי ה-agent. בפועל, הדבר פוסל את ה-Docker socket, כל bind mount של /, וכל תיקייה המכילה נתונים של שירות אחר.

השאר הוא המסגרת החלה על כל agent שמורשה להריץ פקודות. הגבילו את הרשאות הגישה שלו למאגר (repository) או ל-bucket הספציפי שהוא צריך, ולעולם אל תשתמשו ב-token אישי בעל הרשאות לכל החשבון. הריצו אותו כמשתמש ייעודי שתיקיית ה-home שלו ריקה מכל תוכן אחר, וזהו בדיוק הייעוד של משתמשים בעלי הרשאות מינימליות ב-VPS. כאשר ה-agent כותב קוד ואז מריץ אותו, תנו לו מכונה שמותר לו להרוס: מכונה וירטואלית זמנית עבור agents של פיתוח מהווה גבול חזק יותר מכל דגל בקובץ ה-compose, כיוון שאתם מוחקים אותה במקום לנקות אותה. אותו היגיון מנחה את הרצת OpenClaw בצורה מאובטחת ב-VPS ואת אירוח עצמי של ה-agent מסוג Hermes ב-VPS. גם כלים נחשבים כחלק מטווח ההשפעה: מתן אפשרות ל-agent לבצע חיפוש ברשת הופך כל דף שהוא מושך לקלט לא מהימן, לכן הפניית ה-agent למופע SearXNG משלכם היא החלטה שנוגעת להזרקת הנחיות (prompt injection) לא פחות מאשר לתשתית. עבודה מתוזמנת גם עולה כסף בזמן שאתם ישנים, שכן הסקה (inference) ב-backends של Kiro משתמשת בתוכנית ה-Kiro שלכם; לכן, הגדירו את המגבלות המתוארות ב-שליטה בעלויות של AI agent ב-VPS לפני שתוסיפו משימה לילית.

גבו את נפח הנתונים (volume) לפני כל שדרוג

תחילה, מצאו את השם האמיתי של ה-volume. כלי ה-Compose מוסיפים תחילית לנפחים בעלי שם (named volumes) לפי שם הפרויקט, שברירת המחדל שלו היא שם הספרייה. לכן, volume שהוגדר כ-kirocrew-home בתוך /opt/kirocrew/compose.yaml ייווצר תחת השם kirocrew_kirocrew-home:

docker volume ls

עצרו את ה-gateway לפני העתקת קבצים כלשהם. memory.db ו-memory_index.db הם מסדי נתונים מסוג SQLite, והעתקת מסד נתונים בזמן כתיבה עלולה לתעד טרנזקציה חלקית, מה שיוביל לשחזור קובץ פגום. הוראות המיגרציה של הפרויקט עצמו מציינות זאת במפורש: העבירו נתונים רק כאשר ה-gateways עצורים. כלל ה"עצירה לפני הכל" אינו ייחודי ל-KiroCrew; אם שרת תמונות חולק את אותו השרת, השוואת ה-PhotoPrism ו-Immich מפרטת את פקודות הגיבוי המדויקות הנדרשות עבור כל אחד מהם.

sudo systemctl stop kirocrew
docker run --rm -v kirocrew_kirocrew-home:/data:ro -v "$PWD":/backup \
  alpine tar czf /backup/kirocrew-2026-08-06.tgz -C /data .
sudo systemctl start kirocrew

העתיקו את הארכיון אל מחוץ לשרת. שחזור מתבצע באמצעות אותה פקודה, כאשר המכולה עצורה והשימוש הוא ב-tar xzf במקום ב-tar czf:

sudo systemctl stop kirocrew
docker run --rm -v kirocrew_kirocrew-home:/data -v "$PWD":/backup \
  alpine tar xzf /backup/kirocrew-2026-08-06.tgz -C /data
sudo systemctl start kirocrew

מעבר למארח (host) חדש הוא פעולה שונה משחזור מקומי, והפרויקט מפרט זאת במדויק. היסטוריית הצ'אטים והערות הפרויקט תחת workspace/memory/ עוברות במלואן, וכך גם שני קובצי מסד הנתונים ו-config.json. קובצי PID, לוג אירועי האבטחה ו-.env קשורים למארח הישן, לכן יש להשאיר אותם מאחור ולהזין את ה-secrets מחדש במכונה החדשה.

כיצד לבצע שחזור (Rollback) לאחר שדרוג כושל

תהליך השדרוג הוא קצר, והוא בטוח רק בזכות העובדה שקיבעת גרסה (pinning). בצע גיבוי תחילה, ולאחר מכן שנה את ה-tag:

sudo systemctl stop kirocrew
# take the backup here, as above
sudo nano /opt/kirocrew/compose.yaml   # set the new image tag
sudo systemctl start kirocrew
docker compose -f /opt/kirocrew/compose.yaml ps
curl -s http://127.0.0.1:5476/api/health

הפקודה docker compose up -d מושכת את ה-image אם הוא אינו קיים כבר על השרת, כך שעריכת ה-tag היא כל תהליך השדרוג. ביצוע שחזור (rollback) הוא רצף פעולות זהה עם מספר הגרסה הישן, והוא מחזיר אותך בדיוק ל-image שהיה ברשותך קודם לכן, כיוון ש-version tags הם בלתי ניתנים לשינוי (immutable).

ה-binary חוזר למצבו הקודם בצורה נקייה. ה-state הוא החלק שעלול שלא לחזור למצבו הקודם. gateway חדש יותר יכול לשכתב את config.json או לבצע מיגרציה למסדי הנתונים בזיכרון למבנה ש-gateway ישן אינו יודע לקרוא, ונכון ל-12 באוקטובר 2026, לא מתועד נתיב לשנמוך (downgrade) של ה-state. מדריך ההתקנה מבהיר זאת במפורש במקרה אחד: נתונים שהועברו מחוץ לתיקיית הבית הישנה ~/.kirocrew אינם ניתנים לשחזור, וגרסה שקדמה ל-~/.kiro/crew תעלה כשהיא ריקה. לכן, אם ה-image הישן עולה אך מתנהג בצורה מוזרה, אל תנסה לבצע ניפוי שגיאות (debug). עצור אותו, שחזר את הגיבוי שביצעת לפני השדרוג, והתחל שוב. זו הסיבה המלאה לכך שהגיבוי מגיע לפני הכל, וזו הסיבה שההרגל לשדרג עכשיו ולגבות אחר כך נכשל בפרויקט צעיר כל כך.

מה לא הוכח כאן

היו כנים לגבי גילו של תוכנה זו. גרסה 0.1.3 שוחררה ב-5 באוגוסט 2026, ועד ה-12 באוקטובר 2026 הגיעה סדרת ה-stable לגרסה 0.8.0. רוב הערות השחרור הן עדיין יומני שינויים אוטומטיים; ההערות של 0.8.0 נכתבו ידנית אך אינן כוללות סעיף הגירה, והיסטוריית השחרורים הציבורית משתרעת על פני כשלושה חודשים בלבד. שום דבר במדריך זה אינו תוצאה של עבודה ארוכת טווח, לכן התייחסו לצריכת זיכרון, גודל מסד נתונים ואמינות ה-scheduler כנתונים שעליכם למדוד בשרת שלכם, ולא כדברים שניתן להניח מראש.

שתי התנהגויות ראויות לבדיקה עצמית לפני שתסתמכו עליהן. ראשית, האם ביצוע downgrade מאפשר קריאת מצב שנכתב על ידי גרסה חדשה יותר: נסו זאת על עותק של ה-volume בזמן שזה לא קריטי, ולא במהלך תקלה. שנית, מה ה-gateway עושה כאשר ה-Kiro sign-in פג תוקף בזמן שמתבצע job מתוזמן. שני המקרים הם מסוג הקצוות המחוספסים שפרויקט צעיר משייף בשקט בין שחרורים, ושניהם זולים לבדיקה כעת.

FAQ

מדוע לוח הבקרה של KiroCrew לא נפתח בכתובת ה-IP הציבורית של השרת שלי?

מכיוון שהדוגמה שפורסמה קושרת את הפורט ל-loopback. -p 127.0.0.1:5476:5476 ממפה את הפורט של המכולה לכתובת ה-loopback של המארח בלבד, וזה נעשה בכוונה. ניתן לגשת אליו על ידי העברת הפורט דרך SSH עם ssh -N -L 5476:127.0.0.1:5476 you@your-server, ולאחר מכן פתיחת http://localhost:5476/?token=<token> במחשב הנייד שלך. הסרת הקידומת 127.0.0.1: כדי להפוך אותו לנגיש מציבה את ה-gateway באינטרנט הציבורי, ו-ufw לא יחסום אותו, מכיוון שחוקי ה-DNAT של הפורטים המפורסמים ב-Docker מנתבים את התעבורה לפני שחוקי ה-ufw חלים. השתמש בשרשרת DOCKER-USER של Docker עם ה-backend של iptables, או ב-base chains נפרדים של nftables עם ה-backend של nftables, כדי לסנן פורטים מפורסמים; שמירה על הקישור ל-loopback היא פשוטה יותר.

היכן KiroCrew שומר את הנתונים שלו, ומה עלי לגבות?

הכול נמצא תחת ~/.kiro/crew, שהיא /home/kirocrew/.kiro/crew בתוך תמונת המכולה, ו-KIROCREW_HOME משנה את מיקומה. גבה את כל הספרייה, או את כל ה-Docker volume, כשה-gateway עצור. memory.db ו-memory_index.db הם מסדי נתונים מסוג SQLite, לכן העתק שמתבצע בזמן שה-gateway כותב עלול להיות לא עקבי. בעת מעבר למארח חדש, workspace/memory/, שני קובצי מסד הנתונים ו-config.json מועברים, בעוד שקובצי PID, יומן אירועי האבטחה ו-.env שייכים למארח הישן.

האם עלי להשתמש בתג stable או בתג גרסה?

השתמש בתג גרסה. stable משתנה בכל פעם שיוצאת גרסה חדשה, כך שהגרסה שאתה מריץ עלולה להשתנות מתחת לאפך ב-pull הבא, והתג עצמו לא אומר לך דבר על מה שרץ. תגי גרסה כגון 0.8.0 הם בלתי ניתנים לשינוי, וזה בדיוק מה שגורם ל-rollback לעבוד: אתה מחזיר את המספר הישן ומקבל את אותה תמונה בדיוק. נכון ל-1 בנובמבר 2026, הגרסה היציבה החדשה ביותר היא 0.11.1.

מדוע הסוכן שלי מסרב להריץ פקודות כלשהן?

המכולה בודקת תמיכה ב-sandbox בהרצה הראשונה שלה. אם היא לא יכולה לבודד תהליכי משנה של הסוכן ו-KIROCREW_ALLOW_UNSANDBOXED=1 לא מוגדר, היא מסרבת להריץ אותם במקום להריץ אותם ללא הגבלה, כך שה-gateway נראה תקין בזמן שכל משימה נתקעת. docker logs kirocrew מציג את החלטת ה-sandbox מאותה הרצה ראשונה. הגדרת המשתנה הופכת את המכולה לגבול היחיד בין הסוכן למארח, לכן אם הגדרת אותו, אל תעגן שום דבר שלא היית מוסר לסוכן ישירות.

האם אני צריך חשבון Kiro כדי לארח את KiroCrew בעצמי?

עבור ה-backends של Kiro, כן, נכון ל-1 בנובמבר 2026. KiroCrew היא תוכנה חופשית תחת Apache 2.0, אך הסקה (inference) ב-backends אלו משתמשת בתוכנית ה-Kiro שלך. מכולת ה-0.8.0 המוצמדת משתמשת ב-Kiro CLI: הרץ את docker exec -it kirocrew kiro-cli login ואשר את קוד המכשיר בדפדפן שלך, או העבר את KIRO_API_KEY דרך סביבת המכולה לשימוש אוטומטי. עד להגדרת האימות, ה-gateway הזה עולה ולוח הבקרה נטען, אך ל-harness ברירת המחדל שלו אין מודל לתקשר איתו. מאז 0.10.0 קיים גם מנוע KAS מובנה שלא דורש התקנה של kiro-cli; 0.11.0 הפך את KAS לברירת המחדל עבור התקנות חדשות ללא בחירת harness שמורה, תוך שמירה על בחירות Kiro CLI מפורשות. KAS משתמש בכניסה של Crew עצמו במקום ב-kiro-cli login. מדריך ה-backend המותאם אישית של הפרויקט מאפשר ל-harness מסוג claude לשלוח את תורות המודל הראשי לנקודת קצה תואמת Anthropic שתבחר, אך הכניסה של kiro-cli עדיין נשארת עבור תכונות ספציפיות ל-Kiro.

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