חלופות ל־n8n באירוח עצמי: השוואת Activepieces ועוד
השוו בין Activepieces, Windmill, Node-RED, Automatisch ו־Huginn מול n8n: רישיון, צריכת RAM, מסד נתונים, צעדי AI וגיבוי שעלול לשבור שחזור.
במה להשתמש במקום n8n
החלופות ל-n8n בהתקנה עצמית (self-hosted) שראויות לבדיקה על גבי VPS (שרת וירטואלי פרטי) הן Activepieces, Windmill, Node-RED, Automatisch ו-Huginn. Activepieces הוא התחליף הקרוב ביותר לאופן שבו רוב המשתמשים עובדים עם n8n, וליבתו מופצת תחת רישיון MIT. Windmill מתאים לצוות שמעדיף לכתוב קוד ב-Python או ב-TypeScript על פני גרירת תיבות על גבי קנבס. Node-RED הוא הפתרון הקל, והוא אינו דורש מסד נתונים כלל.
קוראים רבים צריכים להישאר במקומם. הרישיון של n8n מתיר שימוש עסקי פנימי, כך שאם אתם מריצים תהליכי עבודה עבור החברה שלכם, הרישיון אינו מהווה בעיה. הגירה אינה בחינם. נכון ל-27 באוקטובר 2026, Activepieces לא ידע לקרוא ייצוא של n8n, ולכן הגירה משמעותה בנייה מחדש של כל תהליך עבודה באופן ידני והזנה מחדש של כל פרטי האימות. התקנת n8n עצמה היא משימה נפרדת, המכוסה ב-התקנת n8n על גבי VPS עם Docker ו-HTTPS, והמאמר n8n מול Zapier ו-Make סוקר כיצד כל הקטגוריה הזו משתווה לשירותים מנוהלים.
מדוע אנשים מחפשים חלופות ל־n8n באירוח עצמי
שתי סיבות חוזרות ועולות שוב ושוב.
הראשונה היא הרישיון. n8n מופץ תחת Sustainable Use License v1.0, והפרויקט מגדיר אותו כרישיון fair-code ולא כקוד פתוח. הרישיון מעניק את הזכות "להשתמש בתוכנה או לשנות אותה רק לצורכי העסק הפנימיים שלך, או לשימוש שאינו מסחרי או אישי", ואוסר לספק את התוכנה לאנשים אחרים באופן מסחרי. קבצים ותיקיות שבשמם מופיע .ee כפופים ל־n8n Enterprise License נפרד. מותר לבנות ולהפעיל אוטומציות עבור לקוחות משלמים, כאשר הלקוחות מקבלים את הפלטים בלי גישה לממשק של n8n או ללוגיקה של תהליכי העבודה. מתן אפשרות לאנשים מחוץ לארגון שלך לבנות או להגדיר תהליכי עבודה מחייב רישיון מסחרי. אם אתם צוות תפעול פנימי, הדבר אינו משנה דבר בשגרת העבודה שלכם. הרישיון והמחיר הם שאלות נפרדות, והשאלה אילו תכונות של n8n דורשות מפתח בתשלום היא השאלה שיש לענות עליה לפני שעוזבים בגלל חומת תשלום שעדיין לא נתקלתם בה.
השנייה היא הזיכרון. n8n הוא תהליך של Node.js, ונתוני תהליך העבודה נמצאים בזיכרון בזמן ההרצה. בתיעוד של n8n מפורטות הסיבות: כמות נתוני ה־JSON, גודל הנתונים הבינאריים, מספר הצמתים בתהליך העבודה, צומת Code, הרצות ידניות (שמעתיקות את הנתונים פעם נוספת עבור העורך), ותהליכי עבודה אחרים שפועלים באותו זמן. הפתרון המתועד אינו מוצר אחר. מדובר ב־queue mode עם תהליכי worker נפרדים, בתוספת Postgres במקום קובץ SQLite המוגדר כברירת מחדל ב־~/.n8n/database.sqlite. עבודות גדולות דורשות גם עיבוד באצוות, משום שצומת Loop Over Items שמזין תהליך עבודה משני משאיר בזיכרון בכל פעם רק חלק אחד של הנתונים. נסו זאת לפני שאתם בונים מחדש שישים תהליכי עבודה במקום אחר.
אילו חלופות n8n לאירוח עצמי עדיין מתוחזקות
טקסט הרישיון קריא ונוח, ולכן כולם משווים רישיונות. קל לדלג על בדיקת בריאות הפרויקט. אלו הם 6 הפרויקטים בהשוואה זו, כאשר לכל אחד מהם מצוין התיוג של גרסת ה-stable האחרונה נכון ל-29 באוקטובר 2026.
הנתונים שמאחורי התרשים
[
{
"tool": "n8n",
"licence": "Sustainable Use License",
"latest_release": "2.45.6",
"released": "2026-10-29",
"days_since_release": 0
},
{
"tool": "Activepieces",
"licence": "MIT core, commercial ee",
"latest_release": "0.92.3-hotfix.2",
"released": "2026-10-28",
"days_since_release": 1
},
{
"tool": "Windmill",
"licence": "AGPLv3 source, CE image",
"latest_release": "v1.853.0",
"released": "2026-10-28",
"days_since_release": 1
},
{
"tool": "Node-RED",
"licence": "Apache 2.0",
"latest_release": "5.0.9",
"released": "2026-10-21",
"days_since_release": 8
},
{
"tool": "Automatisch",
"licence": "AGPL-3.0, commercial ee",
"latest_release": "v0.15.0",
"released": "2025-08-08",
"days_since_release": 447
},
{
"tool": "Huginn",
"licence": "MIT",
"latest_release": "v2026.10.26",
"released": "2026-10-26",
"days_since_release": 3
}
]שורה אחת משנה את הרשימה המצומצמת. Automatisch תויג לאחרונה ב-v0.15.0, כלומר לפני 447 ימים; נכון ל-27 באוקטובר 2026, לא בוצע commit בענף ברירת המחדל שלו מאז 15 בינואר 2026. Huginn היה בעבר האזהרה השנייה. הקוד של Huginn המשיך להתעדכן בזמן שעברו ארבע שנים ללא שחרור גרסה מאז v2022.08.18. זה השתנה ב-27 באוגוסט 2026, ומאז Huginn שחרר כמה גרסאות. הגרסה החדשה ביותר היא v2026.10.26, מלפני 3 ימים.
בדקו זאת בעצמכם לפני שאתם סומכים על השוואה כלשהי, כולל זו. פתחו את דף ה-releases של הפרויקט ב-GitHub, ולאחר מכן את רשימת ה-commits של ענף ברירת המחדל שלו. פרויקט עם גרסה טרייה ויומן commits שקט נמצא במצב של דעיכה. פרויקט עם commits טריים וללא שחרור גרסה מזה שנים מבקש מכם להריץ קוד שאף אחד לא אסף לגרסה רשמית.
Activepieces: הבחירה הקרובה ביותר, עם ליבת MIT
Activepieces היא הבחירה המקבילה ביותר. זהו בונה תהליכים ויזואלי עם טריגרים ופעולות המסופקים על ידי אינטגרציות הנקראות pieces, וה-README מצהיר על יותר מ-280 כאלו. כל piece חשוף גם כשרת MCP (פרוטוקול הקשר למודל), כך שלקוח LLM (מודל שפה גדול) יכול להפעיל את אותם מחברים ככלים. הליבה מופצת תחת רישיון MIT. שתי ספריות, packages/ee/ ו-packages/server/api/src/app/ee, נושאות רישיון מסחרי. הוראות האירוח העצמי הרשמיות מגדירות את AP_EDITION=ee, שרץ כברירת מחדל בתוכנית החינמית; תכונות בתשלום דורשות שדרוג. אותו רישיון מאפשר לכם להעתיק ולשנות את הקוד לצורכי פיתוח ובדיקות ללא מנוי.
קראו על הפיצול הזה לפני שתבצעו הגירה, כיוון שהוא רחב יותר מאשר ברוב פרויקטי ה-MIT. מהדורת הקהילה (Community Edition) היא ליבת האוטומציה כשלעצמה, בעוד שהתוכנית החינמית ($0) כוללת גם Flows, Agents, Tables ו-"MCPs and API access", עם אירוח בענן או מקומי (on-prem). סוכנים (Agents) הופכים פעולות של pieces לכלים שהם יכולים להפעיל. פרויקטים, הזדהות אחודה (SSO) ותפקידים סטנדרטיים מתחילים בתוכנית Team; שחרורים (Releases) וסנכרון Git, לוגים של ביקורת, מנהלי סודות ומיתוג נמצאים בתוכנית Ultimate. לכן, המיקום של מודול בספרייה מסחרית לא מעיד בהכרח אם השימוש בו דורש תשלום. יצירת תהליכים באופן תוכנתי אינה דורשת תוכנית בתשלום. Activepieces מגיעה עם שרת MCP מובנה שהכלים שלו יוצרים, משכפלים, משנים שם ומפרסמים תהליכים, מוסיפים, מעדכנים ומוחקים שלבים, ומעדכנים טריגרים (ap_create_flow, ap_build_flow, ap_add_step ואחרים). התיעוד מוסיף כי "כלי MCP הם בחינם, למעט ap_run_action, שעולה קרדיט 1 לכל קריאה". תהליך שהופעל על ידי כלי MCP מחויב כהרצת תהליך רגילה.
מבנה זמן הריצה מורכב ממכולת אפליקציה אחת, מכולת worker אחת או יותר, Postgres ו-Redis. AP_DB_TYPE=POSTGRES ו-AP_REDIS_TYPE=STANDALONE הם ברירות המחדל. קיים מצב של מכולה בודדת עם מסד נתונים מוטמע ותור בתהליך (AP_DB_TYPE=PGLITE עם AP_REDIS_TYPE=MEMORY), והתיעוד מתאר זאת כ"לשימוש אישי על מכונה אחת". קחו זאת כפשוטו. התור בזיכרון תומך במופע יחיד על מכונה יחידה, כך שצמיחה מעבר לכך היא הגירה, לא שינוי flag.
Windmill: קוד תחילה, וכבד מכפי שהוא נראה
Windmill מריצה סקריפטים ב-Python, TypeScript, Go, Bash ו-SQL, ואז מחברת אותם לזרימות עבודה (flows). אם האוטומציות שלכם מבוססות בעיקר על קוד עם מעט דבק מסביב, היא מתאימה יותר מכל ממשק מבוסס צמתים (node canvas).
יש לשים לב לרישיון. קוד המקור הוא תחת AGPLv3 כאשר הוא מקומפל ללא דגל ה-enterprise. האימג'ים המפורסמים ב-ghcr.io/windmill-labs/windmill הם גרסת ה-Community Edition, הכוללת קוד שאינו קוד פתוח אך ניתן לשימוש חופשי במסגרת מכסות. דף התמחור של Windmill מגדיר מכסות אלו כ-50 משתמשים, 3 סביבות עבודה (workspaces) ו-10 GiB של אחסון אובייקטים לסביבת עבודה, עם הרצות ללא הגבלה. עבור אדם אחד או צוות קטן, התקרה הזו רחוקה מאוד, לכן השאלה המעשית אינה המכסה. השאלה היא שהקובץ הבינארי שאתם מריצים אינו גרסת ה-AGPL.
משקל הוא שיקול נוסף. ה-docker-compose.yml של Windmill כולל מסד נתונים Postgres 18, שרת אחד, שלושה עובדים (workers) המוגדרים כברירת מחדל עם מגבלת זיכרון של 2048M לכל אחד, עובד מקורי (native worker) ו-proxy מסוג Caddy. כלל האצבע המתועד הוא "עובד אחד לכל 1vCPU ו-1-2 GB RAM". ניתן לצמצם את מספר הרפליקות בשרת קטן. עליכם להיות מודעים לכך שאתם מצמצמים אותן, כיוון שהעובדים הם אלו שמריצים בפועל את המשימות שלכם.
תכונות ה-AI של Windmill מגיעות בשני סוגים. הראשון הוא עזרה בזמן הבנייה: יצירת קוד, בניית זרימות, צ'אט ומילוי טפסים. הוא דורש הגדרה של משאב ספק מודל בהגדרות סביבת העבודה או ירושה מהגדרות המופע (instance). הסוג השני הוא שלבי סוכן AI, הרצים בתוך זרימות עבודה. הם יכולים לקרוא לסקריפטים מקומיים, סקריפטים של סביבת העבודה, סקריפטים מה-Hub או לשרתי MCP ככלים, והם עובדים עם ספקים הכוללים את OpenAI, Anthropic, Mistral ו-Google AI. לכן, אם אתם רוצים שלב סוכן שרץ לפי לוח זמנים וקורא לכלים, Windmill יכולה לעשות זאת בדיוק כמו ה-AI Agent node של n8n. בניית סוכן AI ב-n8n מכסה את הגרסה של n8n.
Node-RED: הגרסה הקלה, ללא מסד נתונים כלל
Node-RED מופץ תחת רישיון Apache 2.0, רישיון מתירני ללא copyleft, אם כי רישיון ה-MIT של Huginn ושל הליבה של Activepieces דורש אפילו פחות. מדובר בתהליך Node.js יחיד עם volume מסוג /data. ללא Postgres. ללא Redis. יש להצמיד אותו לגרסה nodered/node-red:5.0.9, שהיא הגרסה העדכנית נכון ל-29 באוקטובר 2026.
הכלי צמח מתוך עולם ה-IoT (האינטרנט של הדברים), ולכן הוא מבוסס על אירועים (event-shaped) ולא על מחברים (connector-shaped). צמתים (nodes) עבור שירותי צד-שלישי מגיעים מהספרייה הקהילתית ואיכותם משתנה, וזהו הפשרה הנדרשת עבור טביעת רגל קטנה. אין בו שלב מובנה של סוכן AI. עבור שרת VPS קטן המטפל ב-webhooks ובתעבורת message-queue, זהו הפתרון הקל ביותר כאן שעובד, והוא עולה תוך שניות.
Huginn ו-Automatisch: בדקו תחילה את יומן ה-commit
Huginn מופץ תחת רישיון MIT, כתוב ב-Ruby on Rails, ודורש MySQL או PostgreSQL. הוא פועל לפי מודל של סוכנים (agents) הצופים במקור ומפיקים אירועים, מודל השונה מזה של קנבס זרימת עבודה (flow canvas). סוכן ה-OpenAI LLM שלו שולח השלמת צ'אט אחת לכל אירוע לכל API התואם ל-OpenAI, כולל Ollama, ומפיק את התשובה כאירוע חדש. הוא אינו מפעיל כלים, לכן יש להתייחס אליו כאל שלב טקסטואלי ולא כאל לולאת סוכן. לאחר ארבע שנים ללא גרסה מתויגת (tagged release), הוא פרסם כמה כאלו מאז אוגוסט 2026, החל מגרסאות אבטחה. בחרו בו כאשר מודל הסוכנים מתאים לבעיה שלכם, ולא כתחליף כללי ל-n8n.
Automatisch מופץ תחת רישיון AGPL-3.0, למעט קובצי ה-.ee שלו, והוא נראה כמו גרסה פשוטה יותר של n8n: הוא דורש Postgres, Redis וקטלוג קטן של יישומים. זהו הכלי שמדריכי פריסה בודדת (single-deploy) ממליצים עליו שוב ושוב. היסטוריית הגרסאות מורה להמתין. תקופה של יותר משנה ללא גרסה אינה סיבה להיכנס לפאניקה אם אתם כבר מריצים אותו, אך היא סיבה מספקת שלא להתחיל פריסת ייצור חדשה המבוססת עליו.
העלות האמיתית של מחסנית Activepieces בזיכרון
אי אפשר לפרסם עבורכם נתון של הזיכרון שנמדד במצב סרק ובעבודה, משום שהוא תלוי ב־flows שלכם ובכמות הנתונים שהם מעבירים. מה שאפשר לקרוא הוא מה שכל ספק מציין שיש להקצות. Activepieces מתעדת את המבנה שלהלן, אך המשפט שלצדו חשוב יותר מהמספרים: "Worker עם concurrency-1 עסוק במשך כל זמן הריצה של flow, עד 10 דקות, ולכן יש להקצות משאבים לפי מספר ה־flows המקבילים ולא לפי קצב ה־trigger."
הנתונים שמאחורי התרשים
[
{
"label": "App container",
"vcpu": 1,
"ram_gb": 1
},
{
"label": "Worker (each)",
"vcpu": 0.5,
"ram_gb": 1
},
{
"label": "Postgres",
"vcpu": 2,
"ram_gb": 4
},
{
"label": "Redis",
"vcpu": 1,
"ram_gb": 1
}
]Worker אחד דורש 0.5 vCPU ו־1 GB. הוא מריץ flow אחד בלבד בכל פעם כאשר AP_WORKER_CONCURRENCY=1, ההגדרה שעליה ממליצה התיעוד. ברירת המחדל שמגיעה עם המוצר היא 5, והיא מריצה כמה flows בתוך container אחד. במקרה זה, התיעוד מציין שיש להקצות לכל worker בערך פי חמישה זיכרון. ל־Postgres מוקצים 4 GB. קובץ ה־compose של הפרויקט עצמו מגיע עם חמישה replicas של worker, ולכן גם ב־concurrency 1 המחסנית שבמאגר דורשת בערך 11 GB לפני שה־flows שלכם מבצעים פעולה משמעותית. פריסת הייצור שפורסמה דורשת גם אחסון אובייקטים מסוג S3 עבור נתוני ה־throughput שלה; הנתונים האלה אינם מתארים את המחסנית המקומית שלהלן. מדריכים של כלי יחיד מעתיקים את הקובץ הזה ומציגים אותו כפריסה קטנה.
ב־VPS בנפח 4 GB, הפעילו שני workers ב־concurrency 1, השאירו את Postgres באותו פרויקט compose, ומדדו. docker stats --no-stream מדפיס שורה אחת לכל container ובה הזיכרון התושב בפועל שלו. נתון זה אמין יותר מכל מספר שמפרסם ספק או בלוג. אם container גדל ללא הגבלה, הגבילו אותו. מגבלות זיכרון ב־Docker Compose מציג את התחביר.
קובץ compose עבור Activepieces בשרת VPS יחיד
קבעו את ה-tag. שימוש ב-latest משמעו שה-docker compose pull הבא עלול לשנות את מבנה מסד הנתונים ללא התראה מוקדמת. גרסה 0.92.3-hotfix.1 מתקנת את פרצות האבטחה של Node.js מאוקטובר 2026; ה-0.92.3-hotfix.2 מוסיף תיקון לקריסת API שנגרמת על ידי webhook, לכן הדוגמה להלן מקבעת את ה-hotfix הזה.
צרו תחילה את שני ה-secrets, תוך שימוש באורכים המצוינים בתיעוד.
openssl rand -hex 16 # AP_ENCRYPTION_KEY, encrypts stored connections
openssl rand -hex 32 # AP_JWT_SECRET, signs session tokensכתבו את .env לצד קובץ ה-compose:
AP_ENGINE_EXECUTABLE_PATH=dist/packages/engine/main.js
AP_ENVIRONMENT=prod
AP_FRONTEND_URL=https://automation.example.com
AP_ENCRYPTION_KEY=REPLACE_WITH_HEX_16
AP_JWT_SECRET=REPLACE_WITH_HEX_32
AP_DB_TYPE=POSTGRES
AP_POSTGRES_DATABASE=activepieces
AP_POSTGRES_HOST=postgres
AP_POSTGRES_PORT=5432
AP_POSTGRES_USERNAME=postgres
AP_POSTGRES_PASSWORD=REPLACE_WITH_A_LONG_RANDOM_PASSWORD
AP_REDIS_TYPE=STANDALONE
AP_REDIS_HOST=redis
AP_REDIS_PORT=6379
AP_EDITION=ee
AP_EXECUTION_MODE=SANDBOX_CODE_ONLY
AP_WORKER_CONCURRENCY=1
AP_TELEMETRY_ENABLED=falseהערך AP_FRONTEND_URL חייב להיות כתובת ה-HTTPS הציבורית, כיוון ש-Activepieces מנסה להשתמש בכתובת ה-IP הציבורית שלכם בעת בניית כתובות ה-webhook. כל webhook שאתם מוסרים לצד שלישי נבנה על בסיס ערך זה; אם הוא עדיין מצביע על localhost, הכתובת שתדביקו בשירות אחר לעולם לא תגיע לשרת שלכם. הערך AP_WORKER_CONCURRENCY=1 מגביל כל worker לזרימה (flow) אחת, כך שהגודל שהוגדר לעיל נשמר. המהדורה ומצב ההרצה תואמים להוראות האירוח העצמי: ee מתחיל בתוכנית החינמית, והוא דוחה את UNSANDBOXED בעת העלייה.
services:
app:
image: ghcr.io/activepieces/activepieces:0.92.3-hotfix.2
restart: unless-stopped
ports:
- '127.0.0.1:8080:80'
depends_on:
- postgres
- redis
env_file: .env
environment:
- AP_CONTAINER_TYPE=APP
volumes:
- ./cache:/usr/src/app/cache
worker:
image: ghcr.io/activepieces/activepieces:0.92.3-hotfix.2
restart: unless-stopped
depends_on:
- app
env_file: .env
environment:
- AP_CONTAINER_TYPE=WORKER
- AP_FRONTEND_URL=http://app
deploy:
replicas: 2
volumes:
- ./cache:/usr/src/app/cache
postgres:
image: pgvector/pgvector:0.8.0-pg14
restart: unless-stopped
env_file: .env
environment:
- POSTGRES_DB=${AP_POSTGRES_DATABASE}
- POSTGRES_USER=${AP_POSTGRES_USERNAME}
- POSTGRES_PASSWORD=${AP_POSTGRES_PASSWORD}
volumes:
- postgres_data:/var/lib/postgresql/data
redis:
image: redis:7.0.7
restart: unless-stopped
volumes:
- redis_data:/data
volumes:
postgres_data:
redis_data:הקובץ מבוסס על ה-compose הרשמי של הפרויקט: מספר ה-workers יורד מחמישה לשניים, הפורט המפורסם נקשר ל-127.0.0.1 במקום לכל הממשקים, שמות המכולות הקבועים הוסרו כיוון ששירות עם replicas אינו יכול להשתמש בהם, ובלוק ה-network המפורש הוסר כיוון ש-compose יוצר אחד כזה בכל מקרה. הקובץ גם מקבע את ה-hotfix האבטחתי ומספק ל-worker את כתובת ה-app URL שלו, כפי שנדרש במדריך ההתקנה.
docker compose up -d
docker compose psכל שירות אמור להציג Up, כולל שתי מכולות worker. מכולה שמבצעת restart בלולאה מדפיסה את הסיבה ב-docker compose logs worker, לכן קראו זאת לפני ביצוע שינויים. קישור הפורט אומר ששום דבר לא יגיע ליישום מבחוץ עד שתציבו reverse proxy עם TLS (אבטחת שכבת תעבורה) בחזית, נושא המכוסה ב-הרצת Traefik לפני כמה יישומי compose. שמרו על .env במצב 600 ומחוץ ל-git, כפי שמתואר ב-טיפול ב-secrets בקובצי env של compose.
גיבוי ששומר על פרטי הזדהות קריאים
כלים כמו n8n, Node-RED ו-Activepieces מצפינים פרטי הזדהות (credentials) מאוחסנים, לכן dump של מסד הנתונים לבדו אינו מהווה גיבוי. עליכם לגבות גם את ה-dump וגם את המפתח המשמש לפענוח שלו. המלכוד הוא ש-n8n ו-Node-RED מייצרות את המפתח הזה עבורכם, והוא עשוי להימצא מחוץ לגיבוי מסד הנתונים שלכם.
n8n הוא המקרה המובהק ביותר. אם לא הגדרתם את N8N_ENCRYPTION_KEY, n8n "יוצר מפתח הצפנה אקראי באופן אוטומטי בהפעלה הראשונה ושומר אותו בתיקייה ~/.n8n", ולאחר מכן משתמש במפתח זה כדי להצפין את פרטי ההזדהות לפני שהם מגיעים למסד הנתונים. אם תבצעו dump ל-Postgres ותשחזרו אותו לתוך מכולה חדשה עם volume חדש, תהליכי העבודה (workflows) יחזרו, אך כל פרטי ההזדהות יהיו טקסט מוצפן שלא ניתן לקריאה. מדריך הגיבוי של n8n מתייחס לכך. הוא מנחה אתכם לגבות את התיקייה .n8n גם כאשר אתם משתמשים ב-PostgreSQL, כיוון ש"היא מכילה את קובץ התצורה, ששומר את מפתח ההצפנה של פרטי ההזדהות". הגדירו את המשתנה במפורש, והגדירו את אותו הערך בכל worker כאשר אתם מריצים את המערכת במצב queue.
ל-Node-RED יש מבנה דומה. פרטי ההזדהות נמצאים בקובץ מוצפן משלהם, והמפתח הוא credentialSecret בתוך settings.js. כאשר אינכם מגדירים מפתח, סביבת ההרצה מייצרת מפתח אקראי ושומרת אותו תחת _credentialSecret בתוך חנות ההגדרות ב-/data. גרסה 5.0.9 של Node-RED מתעדת אזהרה שקובץ פרטי ההזדהות משתמש במפתח שנוצר על ידי המערכת, שאיבודו יהפוך את פרטי ההזדהות לבלתי ניתנים לשחזור, ושיש להגדיר credentialSecret משלכם. קובץ ההגדרות המקורי מציין את ההשלכות: "ברגע שהגדרת מאפיין זה, אל תשנה אותו - פעולה זו תמנע מ-Node-RED לפענח את פרטי ההזדהות הקיימים שלך והם יאבדו". גבו את כל ה-volume של /data, לא רק את קובץ ה-flows.
Activepieces שומרת את AP_ENCRYPTION_KEY בתוך ה-.env שלכם, ומתעדת אותו כ-"מפתח הקסדצימלי באורך 32 תווים (16 בתים) המשמש להצפנת חיבורים". Huginn שומרת את APP_SECRET_TOKEN במשתני הסביבה שלה. ל-Automatisch יש שלושה כאלו: ENCRYPTION_KEY, WEBHOOK_SECRET_KEY ו-APP_SECRET_KEY. בכל מקרה, הסוד נמצא בקובץ סביבה, מה שאומר שקובץ הסביבה הוא חלק מהגיבוי.
Windmill היא החריגה שכדאי להכיר. הסודות שלה מוצפנים באמצעות מפתח סימטרי ספציפי ל-workspace ש-Windmill שומרת במסד הנתונים שלה, כך ש-dump בודד של Postgres נושא את שני החלקים כברירת מחדל. אם הגדרתם את SECRET_SALT, שמרו גם את הערך הזה. הגנו על ה-dump כאילו היה הסודות עצמם. שחזור מלא של המופע דורש גם את מסדי הנתונים האחרים ותפקידי ה-cluster המשמשים תכונות כמו טבלאות נתונים ו-forks של workspace; קובץ ה-compose הנוכחי דורש dump של כל ה-cluster ולא רק של מסד הנתונים windmill.
עבור ה-stack של Activepieces לעיל, הגיבוי מורכב משני קבצים:
cd /srv/activepieces
docker compose exec -T postgres pg_dump -U postgres -Fc activepieces > "ap-$(date +%F).dump"
cp .env "ap-env-$(date +%F).bak"
chmod 600 ap-*.dump ap-env-*.bakלאחר מכן, הוכיחו שהגיבוי עובד, כיוון שגיבוי שלא נבדק הוא רק ניחוש. שחזרו את ה-dump לתוך פרויקט compose זמני שמשתמש ב-AP_ENCRYPTION_KEY שונה במכוון, ואז הריצו תהליך עבודה שמשתמש בחיבור שמור. הוא ייכשל, כיוון שהטקסט המוצפן במסד הנתונים נוצר עם המפתח האחר. חזרו על השחזור עם המפתח האמיתי מ-.env ואותו תהליך עבודה ירוץ. שתי הרצות אלו הן ההוכחה היחידה לכך שהגיבוי שלכם הוא אכן גיבוי. הוציאו את שני הקבצים מהשרת לפי לוח זמנים באמצעות גיבויים של restic מ-VPS, כיוון שגיבוי שנמצא על אותו כונן יאבד יחד עם הכונן במקרה של תקלה.
מתי להישאר עם n8n
הישארו אם העבודה פנימית בתוך החברה שלכם, משום שזה בדיוק השימוש שמתירה Sustainable Use License. הישארו אם אתם מסתמכים על מגוון רחב של אינטגרציות, משום שספריית האינטגרציות של n8n כוללת יותר מ־2,000 אינטגרציות, או על צומת AI Agent שלה, המבוסס על LangChain. מבין האפשרויות החינמיות לאירוח עצמי כאן, Activepieces ו־Windmill מציעות שתיהן agents שקוראים לכלים. Activepieces מציגה Agents בתוכנית Free שלה עם אירוח on-prem, וה־agents שלה משתמשים בפעולות של piece ככלים. Huginn's OpenAI LLM Agent שולח prompt ומפיק את התוצאה, ואינו קורא לכלים. הפעלת workflows של n8n באמצעות Claude מציגה כיצד הדבר נראה בפועל.
עברו ל־Activepieces אם אתם רוצים רישיון מתירני לליבת האוטומציה ו־stack שאפשר לקרוא מקצה לקצה. עברו ל־Windmill אם ה־flows שלכם הם למעשה קוד שעוטה ממשק משתמש. עברו ל־Node-RED אם השרת קטן והעבודה מבוססת על אירועים. אל תעברו משום ש־benchmark קבע ש־n8n כבד. מדדו תחילה את ה־instance שלכם, לאחר מכן קראו מה כדאי לארח בעצמכם ב־2026 ובחרו פעם אחת, משום שהמיגרציה השנייה עולה כמו הראשונה.
FAQ
מהי החלופה ל-n8n בניהול עצמי הקרובה ביותר ל-n8n?
Activepieces. מדובר באותו קונספט: בונה ויזואלי שבו טריגר מפעיל תהליך (flow) וכל שלב קורא לשירות מסוים, עם קטלוג רחב של מחברים. הליבה של המערכת מופצת ברישיון MIT, היא רצה על Postgres ו-Redis תחת Docker, והרכיבים שלה משמשים גם כשרתי MCP עבור לקוחות LLM. העובדה שקיימות ספריות מסחריות לא אומרת שכל תכונה דורשת תשלום: התוכנית החינמית כוללת סוכנים (Agents) וגישה ל-MCP עם אירוח מקומי (on-prem). שרת ה-MCP המובנה מאפשר לעוזר אישי ליצור ולערוך תהליכים.
האם Activepieces היא באמת קוד פתוח?
הליבה היא כזו, תחת רישיון MIT. שתי ספריות, packages/ee/ ו-packages/server/api/src/app/ee, מופצות ברישיון מסחרי. הוראות האירוח העצמי הרשמיות משתמשות ב-AP_EDITION=ee ומתחילות בתוכנית החינמית; תכונות בתשלום דורשות שדרוג. מותר להעתיק ולשנות את הקוד המסחרי לצורכי פיתוח ובדיקות ללא מנוי. התוכנית החינמית כוללת תהליכים, סוכנים, טבלאות וגישה ל-MCP עם אירוח מקומי. פרויקטים, הזדהות אחודה (SSO), לוגים של ביקורת, מנהלי סודות, מיתוג וסנכרון מול Git נמצאים בשכבות בתשלום. לכן, מדובר בקוד פתוח אמיתי לבנייה והרצה של ליבת האוטומציה, בעוד המהדורה המסחרית כוללת תכונות חינמיות ובתשלום כאחד.
כמה זיכרון RAM דורשת Activepieces על שרת VPS?
התיעוד של Activepieces מציין 0.5 vCPU ו-1 GB עבור כל worker, 1 vCPU ו-1 GB עבור מכולת היישום, 4 GB עבור Postgres ו-1 GB עבור Redis. נתון ה-worker מניח AP_WORKER_CONCURRENCY=1. בהגדרה זו, worker מטפל בתהליך אחד בכל פעם למשך כל זמן הריצה שלו, לכן יש לתכנן את המשאבים לפי שיא התהליכים המקבילים ולא לפי תדירות הפעלת הטריגרים. ברירת המחדל שמגיעה עם התוכנה היא 5 תהליכים מקבילים לכל worker, מה שדורש פי חמישה זיכרון לכל worker. קובץ ה-compose במאגר כולל חמישה workers, מה שמסתכם בכ-11 GB של דרישות מערכת מוצהרות גם בעומס של 1. שני workers בעומס של 1 על שרת VPS עם 4 GB הם התחלה סבירה, ו-docker stats --no-stream יאשר את המספר האמיתי עבור התהליכים שלכם בזמן שהם רצים.
מה עלי לגבות כדי ששחזור אכן יעבוד?
את ה-dump של מסד הנתונים ואת מפתח ההצפנה, יחד. עבור Activepieces מדובר ב-pg_dump של מסד הנתונים activepieces בתוספת קובץ ה-.env המכיל את AP_ENCRYPTION_KEY. עבור n8n מדובר במסד הנתונים בתוספת N8N_ENCRYPTION_KEY, ש-n8n יצר עבורכם בתוך תיקיית ~/.n8n אם לא הגדרתם זאת בעצמכם. עבור Node-RED, גבו את כל ה-volume של /data, כיוון שקובץ האישורים והמפתח שמפענח אותו נמצאים שניהם שם. Windmill מאחסנת את מפתח ה-workspace שלה ב-Postgres כברירת מחדל; שמרו גם את SECRET_SALT אם הגדרתם אותו, והשתמשו בגיבוי של כל האשכול (cluster) עבור שחזור מלא של המופע. שמרו על ה-dump כאילו היה הסודות עצמם.
האם ניתן לייבא את תהליכי ה-n8n שלי לכלי אחר?
נכון ל-27 באוקטובר 2026, Activepieces לא ייבאה או המירה תהליכי n8n. הגירה משמעותה בנייה מחדש של כל תהליך בבונה החדש ויצירה מחדש של כל אישור מול השירות המקורי. עבודה זו היא העלות האמיתית של המעבר, לכן ספרו את התהליכים שלכם לפני שתחליטו. שנים-עשר תהליכים הם עבודה של אחר צהריים. מאתיים תהליכים הם פרויקט, ובדרך כלל זול יותר לתקן את צריכת הזיכרון של n8n באמצעות מצב תור (queue mode) ו-Postgres מאשר לבנות את כולם מחדש.