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

ניתוב מכולות Docker דרך VPN עם Gluetun

נתקלתם בשגיאת conflicting options בעת שימוש ב-network_mode service:gluetun? גלו מדוע הפורטים נעלמים ואיך להגדיר נכון את קובץ ה-compose כדי לנתב תעבורה בבטחה דרך VPN.

מדוע פורטים נעלמים כאשר מנתבים מכולות Docker דרך VPN

כדי לנתב מכולות Docker דרך VPN, יש להעניק למכולה אחת את המנהרה, ולאחר מכן לחבר את האחרות למרחב השמות (network namespace) שלה באמצעות network_mode: "service:gluetun". החיבור הזה הוא החלק שמפתיע משתמשים. למכולה המחוברת אין יותר רשת משל עצמה, לכן הפורטים שפורסמו בה ושם שירות ה-Docker שלה מתבטלים. יש לפרסם את הפורטים במכולת ה-VPN במקום זאת, ומכולות אחרות יגיעו ליישום דרך שם מכולת ה-VPN.

השארת בלוק ports: במכולה המחוברת תגרום ל-Docker לסרב ליצור אותה כלל:

Error response from daemon: conflicting options: port publishing and the container type network mode

הכלי המשמש כאן הוא Gluetun, מכולה שמתחברת לספק VPN (רשת פרטית וירטואלית) מסחרי באמצעות WireGuard או OpenVPN ומפעילה חומת אש משלה. גרסה v3.41.3 היא העדכנית נכון לאוקטובר 2026. הדוגמאות משתמשות ב-Mullvad עם WireGuard, לכן נדרשים חשבון ומפתח מהספק שלכם. אם אתם מעדיפים לסיים את המנהרה על חומרה שבבעלותכם, הרצת שרת WireGuard משלכם על גבי VPS בונה את הצד השני, ו-wg-easy בתוך Docker עוטף זאת בממשק אינטרנטי.

מה network_mode: "service:gluetun" עושה בפועל

כל מכולת Docker מקבלת בדרך כלל מרחב שמות רשת משלה: ממשקים, טבלת ניתוב, כללי firewall ו־sockets מאזינים משלה. מצב service: מדלג על השלב הזה ומפעיל את המכולה בתוך מרחב השמות של gluetun. מרחב שמות אחד פירושו כתובת IP אחת, והדבר משנה שישה היבטים.

  • ליישום אין כתובת משלו. הכתובת שלו היא הכתובת של gluetun.
  • היישום אינו מחובר לאף רשת Docker, ולכן שם השירות שלו אינו נרשם ואינו נפתר. מכולות אחרות חייבות להשתמש ב־gluetun.
  • מכולות בתוך אותו מרחב שמות מתקשרות זו עם זו באמצעות localhost.
  • שתי מכולות באותו מרחב שמות אינן יכולות להאזין לאותו פורט. התיעוד של Gluetun חד־משמעי בנושא זה: אין לכך פתרון עוקף.
  • capabilities שייכות למכולה ולא למרחב השמות. Gluetun מחזיק ב־NET_ADMIN וב־/dev/net/tun, משום שהוא יוצר את ממשק המנהרה. המכולה המחוברת אינה יורשת אותן.
  • Compose דוחה כל קובץ שבו שירות אחד מגדיר גם network_mode וגם networks. חברו את gluetun לרשתות שלכם, והיישום ישתמש בחיבור זה.

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

קובץ compose שעובד

services:
  gluetun:
    image: qmcgaw/gluetun:v3
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    environment:
      - VPN_SERVICE_PROVIDER=mullvad
      - VPN_TYPE=wireguard
      - SERVER_CITIES=Amsterdam
      - TZ=Europe/Amsterdam
    env_file:
      - ./gluetun.env
    volumes:
      - ./gluetun:/gluetun
    ports:
      - 127.0.0.1:8080:8080/tcp
    restart: unless-stopped

  qbittorrent:
    image: lscr.io/linuxserver/qbittorrent:latest
    container_name: qbittorrent
    network_mode: "service:gluetun"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Amsterdam
      - WEBUI_PORT=8080
    volumes:
      - ./qbittorrent:/config
      - ./downloads:/downloads
    depends_on:
      gluetun:
        condition: service_healthy
    restart: unless-stopped

התגית :v3 היא הגרסה היציבה החדשה ביותר בסדרת v3. התגית :latest מצביעה על ה־commit האחרון בענף master, שהוא ענף הפיתוח העדכני. לכן יש לקבע את :v3 במכונה שאינכם רוצים לנפות בה תקלות באופן בלתי צפוי.

WEBUI_PORT=8080 חייב להתאים לפורט שפורסם, משום ש־qBittorrent מאזין בתוך ה־namespace של gluetun, וכלל הפרסום מנתב אליו את תעבורת הרשת מהמארח בפורט 8080. אם משנים אחד מהמספרים בלי לשנות את האחר, אין מענה בפורט. 127.0.0.1:8080:8080 משאיר את ממשק האינטרנט בכתובת ה־loopback של המארח. 8080:8080 ללא כתובת ספציפית מפרסם את הפורט בכל הממשקים ויוצר כלל firewall משלו. כך פורט שפורסם ב־Docker עוקף ישירות את ufw.

הפעילו את השירותים, ולאחר מכן בדקו אותם לפי הסדר הזה:

docker compose up -d
docker compose ps
docker compose logs gluetun | tail -30

docker compose ps אמור להציג את gluetun במצב healthy ואת qbittorrent במצב running. לאחר מכן אשרו את כתובת היציאה מתוך ה־namespace. זו הבדיקה שקובעת את התוצאה של כל שאר הבדיקות:

docker run --rm --network=container:gluetun alpine:3.22 sh -c "apk add wget && wget -qO- https://ipinfo.io"

השדה ip ב־JSON הזה אמור להכיל את הכתובת של ספק ה־VPN שלכם. אם זו הכתובת של השרת שלכם, היישום אינו נמצא בתוך ה־tunnel, ושום דבר מהשלבים הבאים לא יעבוד כמתואר.

הרחיקו את המפתחות מקובץ compose

gluetun.env מכיל את פרטי האימות, ואינו נשמר ב־git:

WIREGUARD_PRIVATE_KEY=wOEI9rqqbDwnN8/Bpp22sVz48T71vJ4fYmFWujulwUU=
WIREGUARD_ADDRESSES=10.64.222.21/32

שני הערכים מגיעים מקובץ תצורת WireGuard שאתם יוצרים באזור החשבון שלכם אצל הספק. הגדירו לקובץ הרשאה במצב 600. חשוב להציג את היתרון באופן מדויק: המפתח נשאר מחוץ למאגר שלכם, אך docker inspect gluetun עדיין מציג כל משתנה סביבה לכל מי שיכול לגשת ל־Docker socket. קובצי סביבה וסודות ב־Docker Compose סוקר אפשרויות חזקות יותר.

כיצד מכולה מחוץ למנהרה מתקשרת עם מכולה בתוכה

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

מבחוץ פנימה, השתמשו בשם של gluetun ובפורט שבו היישום מאזין. מכולת reverse proxy מגיעה לממשק ה-web של qBittorrent בכתובת gluetun:8080. אין צורך ברשומה ports: עבור פעולה זו, כיוון שתעבורה בין מכולות נשארת ברשת ה-Docker ולעולם אינה נוגעת בפורט של המארח (host).

מבפנים החוצה, השתמשו בשם השירות של המכולה האחרת, למשל postgres:5432. החל מגרסה v3.41, gluetun פותרת שמות של מכולות אחרות מתוך מרחב השמות שלה, לכן קבעו גרסה זו או חדשה יותר אם שם מסוים מסרב להיפתר.

ה-firewall של gluetun מחליט למי מותר לפתוח חיבור אליה. תעבורה מרשת ה-Docker של gluetun עצמה מורשית. לקוח ברשת משנה (subnet) אחרת, מחשב נייד ב-LAN שלכם או מכולה ברשת bridge נפרדת, זקוקים לנתיב חזרה שמאושר על ידי ה-firewall והניתוב של gluetun:

FIREWALL_OUTBOUND_SUBNETS=192.168.1.0/24

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

חיבורים נכנסים מהאינטרנט הם בעיה נפרדת. עמיתים (peers) של לקוח torrent מגיעים מצד ה-VPN, לכן פרסום פורט 6881 במארח לא עושה עבורם דבר. אתם זקוקים לפורט מועבר (forwarded port) מהספק שלכם, ופורט זה חייב להופיע ב-FIREWALL_VPN_INPUT_PORTS, המאפשר פורטים מצד שרת ה-VPN. Mullvad, המשמש בדוגמה זו, אינו תומך בהעברת פורטים, לכן נדרש ספק שכן תומך בכך. זהו החלק שרוב מחסניות המדיה שנבנו עם Docker Compose משאירות לא תקין.

מנגנון ה-kill switch: מה קורה כשהמנהרה מתנתקת

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

Gluetun מנטר את החיבור של עצמו. בכל דקה הוא שולח ICMP echo (פינג) לכתובות ב-HEALTH_ICMP_TARGET_IPS, שברירת המחדל שלהן היא 1.1.1.1,8.8.8.8. אם ICMP אינו מורשה, בדיקה קטנה זו עוברת לשימוש בשאילתת DNS ב-UDP בטקסט גלוי. בכל חמש דקות הוא מבצע ניסיון התקשרות TCP ו-TLS (אבטחת שכבת תעבורה) מלא ל-HEALTH_TARGET_ADDRESSES, שברירת המחדל היא cloudflare.com:443,github.com:443. כאשר אלו נכשלים, הוא מאתחל את ה-VPN בתוך המכולה ומתעד זאת:

WARN [vpn] restarting VPN because it failed to pass the healthcheck: periodic check: dialing: dial tcp4: lookup cloudflare.com: i/o timeout

קראו את הלוגים של המכולה המצורפת תוך התחשבות בסדר זה. שורות כמו connection refused, operation not permitted ו-i/o timeout בתוך היישום הן תוצאות של מנהרה מתה, לא הגורמים לכך. התיעוד של Gluetun מציין זאת במפורש, כיוון שאנשים מדווחים על התוצאה ורודפים אחריה במשך שעות.

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

סדר פעולות: מניעת עליית ה-stack לפני שה-tunnel מוכן

ה-image כולל healthcheck מובנה של Docker:

HEALTHCHECK --interval=5s --timeout=5s --start-period=10s --retries=3 CMD /gluetun-entrypoint healthcheck

הפקודה מריצה עותק שני וקצר-מועד של gluetun, הפונה לשרת ה-health של המופע הפעיל בכתובת http://127.0.0.1:9999/. מנהרה תקינה משיבה 200 OK. מנהרה תקולה משיבה 500 Internal server error בצירוף מחרוזת שגיאה, ו-Docker מסמן את ה-container כ-unhealthy לאחר שלושה כישלונות רצופים.

condition: service_healthy הוא המנגנון שממתין לכך. שימוש ב-depends_on: [gluetun] בלבד ממתין רק לעליית ה-container, שמתרחשת שניות לפני השלמת ה-handshake; כתוצאה מכך, היישום עולה לתוך רשת שאינה זמינה ולעיתים קרובות מוותר על ניסיון ההתחברות הראשון. המדריך Healthchecks in Docker Compose מפרט את התחביר ואת שדות התזמון.

מגבלה אחת עלולה להפתיע משתמשים: Compose מעריך את התנאי בעת הפעלת ה-stack. הוא אינו עוצר או מאתחל את היישום בשלב מאוחר יותר אם gluetun הופך ל-unhealthy. מנגנון ה-auto-healing הפנימי של gluetun מטפל במקרה זה, וזו הסיבה שהוא מאתחל את תהליך ה-VPN במקום את ה-container עצמו.

בדיקת דליפת DNS לפני מתן אמון בהגדרה

מערכת ה-DNS (Domain Name System) היא הדליפה ששורדת מנהרה תקינה. Gluetun מריץ פותר (resolver) משלו בתוך ה-namespace ומעביר שאילתות באמצעות DoT (DNS over TLS) ל-Cloudflare כברירת מחדל: DNS_UPSTREAM_RESOLVER_TYPE=dot ו-DNS_UPSTREAM_RESOLVERS=cloudflare. השאירו את שניהם ללא שינוי, והחיפושים שלכם יהיו מוצפנים ויעברו דרך המנהרה.

ההגדרה שגורמת לכשל במצב זה כאשר מצביעים על פותר מקומי היא DNS_UPSTREAM_PLAIN_ADDRESSES. משתמשים פונים אליה כאשר שם מתחם אינו מתפענח והם מעוניינים שהנתב שלהם או הפותר של ספק האינטרנט ישיבו במקום. התיעוד של Gluetun מזהיר כי שאילתות שנשלחות לפותר ב-Docker bridge או ב-LAN דולפות מחוץ למנהרת ה-VPN. פותר ציבורי בטקסט גלוי עדיין מקבל שאילתות דרך המנהרה, אך ספק ה-VPN יכול לקרוא ולשנות אותן. גרסת ה-WireGuard לאותה טעות מכוסה ב-DNS שחדל לפעול דרך מנהרת WireGuard.

כדי לבדוק זאת, הגדירו את SHADOWSOCKS=on ו-SHADOWSOCKS_PASSWORD ב-gluetun, פרסמו את 8388:8388/tcp ו-8388:8388/udp, לאחר מכן התחברו עם לקוח Shadowsocks שהוגדר להעביר UDP DNS במנהרה, וטענו אתר לבדיקת דליפות DNS. התוצאה צריכה להציג את הספק שלכם או את Cloudflare, ולעולם לא את הנתב הביתי. התיעוד של Gluetun עצמו מזהיר כי חלק מבדיקות הדליפה מדווחות על תוצאות מוזרות, כיוון שהפותר בתוך ה-namespace הוא מתווך מטמון מקומי ולא השרת שמשיב בפועל. התייחסו למדינה שגויה או לפותר של ספק האינטרנט שלכם כאל אינדיקציה ממשית לדליפה.

הוספת Tailscale לצד ה-VPN sidecar, ומי מהם גובר

Tailscale היא רשת overlay המבוססת על WireGuard לגישה למכונות שלכם. משתמשים מריצים אותה לצד VPN של ספק כדי לשמור על נתיב ניהול לתוך ה-stack. שיתוף namespace משמעו גם שיתוף חוקי firewall, לכן השניים זקוקים להגדרות firewall וניתוב תואמות. התיעוד של Tailscale מציין את ברירת המחדל: היא פועלת כרשת overlay, מנתבת תעבורה רק בין התקנים שמריצים Tailscale, ואינה נוגעת בתעבורת האינטרנט הציבורית שלכם.

התשובה תלויה בהגדרה אחת.

  • Tailscale במכולה (container) משלה, בתצורת ברירת מחדל: היא לעולם לא רואה את התעבורה היוצאת של היישום. Gluetun נושא את כולה. תהליך במכולת Tailscale מגיע ליישום ב-gluetun:8080 דרך רשת Docker משותפת; חשיפת חיבור זה ללקוחות tailnet דורשת העברה (forwarding) או proxy.
  • Tailscale מחוברת ל-namespace של gluetun עם network_mode: "service:gluetun": במצב ברירת המחדל של userspace networking, כאשר TS_USERSPACE פעיל, tailscaled לא יוצרת ממשק כלל ופועלת כ-proxy מסוג SOCKS5 או HTTP, לכן היא אינה יכולה לשנות ניתוב. Gluetun עדיין נושא את התעבורה היוצאת הרגילה, אלא אם יישום משתמש במפורש ב-proxy זה.
  • אותו מצב, עם TS_USERSPACE=false: Tailscale זקוקה להתקן /dev/net/tun משלה וליכולות (capabilities) מתאימות, כיוון שאלו אינם מגיעים עם ה-namespace. Tailscaled יוצרת התקן tunnel, וב-Linux, היא מתקינה בדרך כלל נתיבי IPv4 פרטניים של peer /32 במקום נתיב אחד עבור 100.64.0.0/10. הגדרת TS_USERSPACE=false לבדה אינה מפעילה את הניתוב המצטבר. היא מתקינה נתיבי subnet של צמתים אחרים רק אם מעבירים --accept-routes דרך TS_EXTRA_ARGS. TS_ROUTES פועל בכיוון ההפוך: הוא מפרסם (advertise) רשתות משנה שהמכולה הזו יכולה להגיע אליהן לשאר ה-tailnet שלכם, המקביל ל-tailscale set --advertise-routes=, ואינו מוסיף נתיבים כאן. תעבורה ציבורית עדיין יוצאת דרך gluetun.
  • Kernel networking ב-namespace של gluetun עם exit node נבחר, sudo tailscale set --exit-node=<exit-node-ip>: Tailscale מתקינה נתיבי ברירת מחדל ב-namespace הזה, אך ה-firewall של Gluetun יכול לחסום נתיב זה. בחירת exit node במכולה נפרדת אינה משנה את הנתיבים של היישום, ומצב userspace מעביר רק תעבורה שנשלחה במפורש דרך ה-proxy שלו. אל תשלבו נתיבי ברירת מחדל מתחרים ב-namespace של gluetun. נתיב ברירת מחדל אחד, בעלים אחד.

אם הנתיבים המפורסמים הם העיקר, ואתם רוצים שכל הרשת הפרטית מאחורי התיבה תהיה נגישה ולא רק התיבה עצמה, הרצת Tailscale subnet router על גבי VPS מכסה את אישור הנתיב, ה-IP forwarding ודגל הלקוח ש-TS_ROUTES לבדו מותיר ללא מענה.

אם Tailscale שם כדי לספק לכם URL לניהול ולא נתיב, tailscale serve ו-tailscale funnel מציבים HTTPS לפני שירות HTTP מקומי, כאשר רק funnel פותח אותו לאינטרנט הציבורי. התיעוד של Tailscale Serve תומך רק ב-http://127.0.0.1 כיעד ל-HTTP proxy. רשת Docker משותפת אינה הופכת את http://gluetun:8080 ליעד נתמך. שתפו את ה-network namespace של gluetun עם network_mode: "service:gluetun" וכוונו ל-http://127.0.0.1:8080.

תופעת לוואי אחת נראית לעין כאשר Tailscale רצה בתוך ה-tunnel. ה-peers שלה רואים את הכתובת של ספק ה-VPN, לכן צפו שהיא תחזור להשתמש ב-relays לעיתים קרובות יותר. tailscale status מציג relay "..." לצד peer במקום direct כאשר זה קורה. החיבור עובד והוא איטי יותר. אם ה-overlay הוא הדבר היחיד שהייתם צריכים בפועל, ההבדל בין WireGuard רגיל ל-Tailscale הוא נקודת התחלה טובה יותר.

מה משתבש, ואיזו הודעה תראה

Docker מסרב ליצור את ה-container של היישום. Error response from daemon: conflicting options: port publishing and the container type network mode משמעותו ש-ports: עדיין קיים בשירות המחובר. העבר אותו ל-gluetun.

Compose מסרב לקבל את הקובץ כולו. שירות אינו יכול להגדיר גם network_mode וגם networks. הגדר את ה-networks ב-gluetun.

-container אחר אינו מצליח לבצע resolve ליישום. curl: (6) Could not resolve host: qbittorrent הוא התנהגות תקינה, כיוון שה-container המחובר לא הצטרף לאף רשת ולא רשם שם. השתמש ב-gluetun ובפורט.

ה-container המחובר השני לא עולה. שני תהליכים באותו namespace אינם יכולים להאזין (bind) לאותו פורט, והתהליך שנכשל מדווח שהכתובת כבר בשימוש. שנה את הפורט הפנימי של היישום, או הרץ gluetun שני.

ליישום אין רשת לאחר שנגעת ב-gluetun. הפעלה מחדש או יצירה מחדש של gluetun מנתקת את הקישוריות לכל מה שמחובר אליו. הפעל מחדש את ה-containers הללו.

דפים קטנים נטענים וגדולים נתקעים. מדובר ב-MTU (maximum transmission unit). המנהרה (tunnel) מוסיפה overhead, ורכיב כלשהו בנתיב משליך חבילות גדולות מדי מבלי לשלוח הודעת שגיאה בחזרה. בדוק את WIREGUARD_MTU, שערך ברירת המחדל שלו בגרסה v3.41.3 הוא 1320, והנמך אותו אם הנתיב דורש חבילות קטנות יותר. תמונת הפיתוח משתמשת ב-path MTU discovery כאשר הגדרה זו אינה מוגדרת.

gluetun לעולם לא מגיע למצב healthy. בדיקת העלייה מציינת את החשודים העיקריים: WARN [vpn] restarting VPN because it failed to pass the healthcheck: startup check: dialing: dial tcp4: lookup cloudflare.com: i/o timeout. בדוק אם המפתח פג תוקף, לאחר מכן אם רשימת השרתים מיושנת, ולבסוף אם ה-firewall של המארח חוסם תעבורת UDP יוצאת.

FAQ

מדוע הפורטים שפרסמתי עבור הקונטיינר הפסיקו לעבוד מאחורי Gluetun?

מכיוון ש-network_mode: "service:gluetun" מציב את הקונטיינר בתוך ה-network namespace של Gluetun, ול-namespace יש כתובת IP אחת וסט פורטים מאזינים אחד. היישום ממשיך להאזין, אך חוק ה-publish חייב להיות מוגדר על הקונטיינר שבבעלותו ה-namespace. העבירו את רשימת ה-ports: לשירות של Gluetun. אם השארתם אותה על השירות המצורף, Docker אפילו לא ייצור אותה: Error response from daemon: conflicting options: port publishing and the container type network mode.

כיצד אוכל לגשת לקונטיינר שנמצא בתוך מנהרת ה-VPN מקונטיינר שנמצא מחוצה לה?

השתמשו בשם השירות של Gluetun ובפורט שבו היישום מאזין, לדוגמה gluetun:8080. הקונטיינר המצורף אינו נמצא באף רשת Docker משלו, ולכן השם שלו לעולם לא יתורגם (resolve). אין צורך לבצע publish עבור תעבורה בין קונטיינרים. בכיוון ההפוך, קונטיינר בתוך ה-namespace ניגש לקונטיינר חיצוני לפי שם השירות שלו, כגון postgres:5432, בגרסאות Gluetun v3.41 ומעלה. לקוח ברשת משנה (subnet) אחרת, כמו מחשב נייד ב-LAN שלכם, זקוק לנתיב חזרה שמאושר על ידי ה-firewall והניתוב של Gluetun; הוסיפו את רשת המשנה הזו ל-FIREWALL_OUTBOUND_SUBNETS.

האם Gluetun מתפקד כ-kill switch כאשר ה-VPN מתנתק?

כן, כאשר ה-firewall שלו מופעל. הקונטיינר המצורף חולק את הממשקים והנתיבים של Gluetun, וה-firewall חוסם תעבורת אינטרנט רגילה מחוץ למנהרה, תוך שהוא מאפשר את נקודת הקצה של שרת ה-VPN, תעבורת Docker מקומית וחריגים מוגדרים. Gluetun מאתחל את ה-VPN באופן פנימי, תוך רישום WARN [vpn] restarting VPN because it failed to pass the healthcheck בלוגים, במקום לצאת מהתהליך, כיוון שכל קונטיינר מצורף מאבד את הרשת שלו כאשר Gluetun עצמו עובר אתחול.

Tailscale ו-Gluetun באותו stack: מי מהם נושא את התעבורה היוצאת?

Gluetun נושא את התעבורה היוצאת הרגילה, אלא אם תשלחו אותה במפורש דרך Tailscale. כברירת מחדל, Tailscale מנתב תעבורה רק בין התקנים ב-tailnet שלכם ואינו נוגע בתעבורה ציבורית. במצב ה-userspace המוגדר כברירת מחדל בתמונת הקונטיינר, הוא אינו יוצר ממשק כלל, ולכן אינו יכול להשפיע על הניתוב. עם TS_USERSPACE=false, לינוקס מקבלת בדרך כלל נתיבי peer /32 בודדים עבור IPv4 במקום נתיב 100.64.0.0/10 מאוחד, בתוספת נתיבי רשת משנה של צמתים אחרים רק אם תוסיפו --accept-routes דרך TS_EXTRA_ARGS. TS_ROUTES מפרסם את רשתות המשנה של קונטיינר זה ל-tailnet שלכם ואינו מוסיף נתיבים מקומיים. בחירה ב-exit node עם sudo tailscale set --exit-node=<exit-node-ip> מתקינה נתיבי ברירת מחדל רק ב-namespace המשתמש ב-kernel networking של Tailscale; קונטיינר נפרד אינו משנה את נתיבי היישום, ומצב ה-userspace נושא רק תעבורה שנשלחת דרך ה-proxy שלו. בחרו מוצר אחד שיחזיק בנתיב ברירת המחדל במקום להערים את שניהם.

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