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

גישה למכולות ורשת המארח דרך Gluetun

מכולה המשתמשת ב-network_mode: service:gluetun מאבדת את ממשקי הרשת שלה. למדו כיצד לפרסם פורטים ב-Gluetun ולהגדיר חוקי ניתוב כדי לאפשר תקשורת תקינה מחוץ למנהרת ה-VPN.

מה קורה כאשר מכולה מצטרפת לרשת של gluetun

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

network namespace הוא עותק פרטי של ה-kernel למחסנית רשת: ממשקים משלו, טבלת ניתוב משלו, חוקי firewall משלו ו-sockets מאזינים משלו. Docker מעניק לכל מכולה אחד כזה כברירת מחדל. כאשר כותבים network_mode: service:gluetun, ‏Docker מדלג על שלב זה ומציב את המכולה החדשה בתוך ה-namespace ש-gluetun כבר מחזיק. המכולה שומרת על מערכת הקבצים שלה, אך לא על ה-/etc/hosts או ה-/etc/resolv.conf שלה: ‏Docker מעביר לה את אותם קבצים ש-gluetun משתמש בהם, וזה משמעותי בהמשך.

ניתן לראות זאת ישירות.

docker inspect -f '{{.HostConfig.NetworkMode}}' qbittorrent

פקודה זו מדפיסה container: ואחריו את מזהה המכולה (container ID) של gluetun, בעוד שמכולה רגילה הייתה מדפיסה bridge. מדריך זה ממשיך מהנקודה שבה ניתוב תעבורת Docker דרך VPN באמצעות gluetun נעצר: המנהרה (tunnel) עובדת, וכעת שום דבר לא יכול לתקשר עם המכולה.

פרסום הפורט ב-gluetun, לא ביישום

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

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

הסיבה לכך ישירה. פרסום פורט משמעו הוספת חוק NAT (תרגום כתובות רשת) המעביר פורט מהמארח אל מרחב השמות (namespace) של הרשת של המכולה, אך למכולה זו אין מרחב כזה. העבירו את המיפוי לשירות gluetun. מספר הפורט אינו משתנה, כיוון שהיישום עדיין מאזין לאותו פורט בתוך מרחב השמות המשותף.

services:
  gluetun:
    ports:
      - "8080:8080/tcp"   # qBittorrent web UI

  qbittorrent:
    network_mode: "service:gluetun"
    # no ports: block here

בלוק expose: בשירות תלוי ייכשל באותו אופן, עם conflicting options: port exposing and the container type network mode, ובלוק networks: שם מהווה גם הוא עצירה מוחלטת: Compose מדווח שהשירות מצהיר על network_mode ו-networks שמוציאים זה את זה, ומסרב לטעון את הקובץ כלל.

תוצאה אחת מורגשת בשלב מאוחר יותר. כל מכולה במרחב השמות חולקת מרחב פורטים יחיד, לכן שני יישומים ששניהם מוגדרים כברירת מחדל ל-8080 יתנגשו, והשני שביניהם ינסה לעלות ייכשל עם שגיאת כתובת שכבר בשימוש (address already in use). שנו את אחד מהם בתצורה שלו, למשל המשתנה WEBUI_PORT בתמונת qBittorrent של LinuxServer, ולאחר מכן פרסמו את המספר החדש ב-gluetun.

כיצד מכולות הנמצאות מאחורי gluetun מתקשרות זו עם זו?

בתוך ה-namespace הן כבר חולקות ממשק loopback. מכולה הנמצאת מאחורי gluetun מגיעה למכולה אחות ב-127.0.0.1:<port> ללא מעורבות של רשת Docker.

מחוץ ל-namespace, למכולה אין שם. ה-DNS המוטמע של Docker מתרגם שם שירות לכתובת של אותו שירות ברשת שהוגדרה על ידי המשתמש, אך למכולה זו אין כתובת באף רשת. לכן, מכולה רגילה כמו Sonarr לא מגיעה ללקוח הטורנטים ב-http://qbittorrent:8080. היא מגיעה אליו ב-http://gluetun:8080, כיוון שה-socket מאזין בתוך ה-namespace של gluetun, בכתובת של gluetun. עובדה זו מפתיעה אנשים שמכירים את אופן הפעולה של רשתות ושמות שירותים ב-Docker Compose ומצפים שכללי השיום הרגילים יחולו. זה עובד גם ללא פרסום פורטים למארח (host), כיוון ששתי המכולות נמצאות על אותה רשת Compose.

בדקו את ה-DNS לפני שאתם מנפים שגיאות בכל דבר אחר. gluetun מריץ שרת DNS משלו בתוך ה-namespace, ו-Docker נותן לכל מכולה מאחורי gluetun את אותו קובץ /etc/resolv.conf כמו ל-gluetun, כך שהשאילתות של היישום שלכם עוברות דרך ה-resolver של gluetun ולא דרך זה של המארח. כברירת מחדל, ה-resolver הזה גם מסרב לספק תשובות שמצביעות על כתובות פרטיות, וזו הסיבה ששם שמתורגם בהצלחה במארח עלול להיכשל בתוך המכולה. התיעוד של gluetun מציין ששמות מארח כאלו חייבים להופיע ב-DNS_REBINDING_PROTECTION_EXEMPT_HOSTNAMES.

docker exec qbittorrent cat /etc/resolv.conf

FAQ

כיצד אוכל לגשת לשירות שרץ על ה-Docker host?

השתמשו ב-host.docker.internal. נדרשות שתי הגדרות, שתיהן בשירות gluetun, כיוון ששני דברים שונים אינם תקינים.

השם מופיע ראשון. מכולה (container) שנמצאת מאחורי gluetun קוראת את ה-/etc/hosts של gluetun, ו-Docker דוחה רשומת extra_hosts בשירות שמגדיר network_mode עם conflicting options: custom host-to-IP mapping and the network mode. לכן, הרשומה שייכת ל-gluetun, וכל מכולה ב-namespace רואה אותה.

  gluetun:
    extra_hosts:
      - "host.docker.internal:host-gateway"

host-gateway הוא ערך מיוחד ש-Docker מחליף בכתובת פנימית של ה-host עצמו. בהתקנת Docker סטנדרטית על Linux, זו הכתובת של ה-bridge מסוג docker0, שבדרך כלל היא 172.17.0.1. אשרו את הכתובת שלכם באמצעות ip -4 addr show docker0 ב-VPS. ‏Docker Desktop פותר את השם הזה בעצמו, וזו הסיבה שמדריכים שנכתבו על מחשב נייד מדלגים על שורת ה-extra_hosts, מה שגורם לקובץ להיכשל בשרת.

הניתוב מופיע שני. הוספת השם רק אומרת למכולה באיזו כתובת להשתמש. החבילה (packet) עדיין יוצאת דרך נתיב ברירת המחדל של gluetun, שהוא ה-tunnel, וה-firewall של gluetun משליך אותה. הסימפטום הוא חיבור שנתקע ואז מגיע ל-timeout, במקום חיבור שנדחה. דחייה (refused) משמעותה שהחבילה הגיעה ומשהו ענה "לא". ‏Timeout משמעו שהיא מעולם לא הגיעה.

  gluetun:
    environment:
      - FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32

לאחר מכן, ודאו ששירות ה-host אכן מאזין בכתובת הזו. שרת PostgreSQL שקשור (bound) רק ל-127.0.0.1 אינו נגיש מאף מכולה שיש לה network namespace משלה, מה שכולל כל מכולה מאחורי gluetun, עם או בלי tunnel, כיוון ש-127.0.0.1 בתוך ה-namespace הוא ה-loopback של ה-namespace עצמו. רק מכולה שמשתמשת ב-host networking חולקת את ה-loopback של ה-host, ומכולה מאחורי gluetun כבר השתמשה ב-network_mode שלה עבור gluetun. קשרו את PostgreSQL ל-172.17.0.1 במקום זאת: כך הוא יקבל חיבורים ממכולות מבלי להיחשף לממשק הציבורי. אשתו זאת באמצעות ss -lntp | grep 5432 ב-host.

מה ההגדרה FIREWALL_OUTBOUND_SUBNETS משנה בפועל

התיעוד של gluetun מתאר זאת כרשימת רשתות משנה (subnets) מופרדות בפסיקים, ש־gluetun והמכולות החולקות איתו את מחסנית הרשת מורשים לגשת אליהן. התיעוד מציין כי הדבר כרוך בשינויים ב־firewall ובניתוב. שני החלקים חשובים. gluetun מוסיף נתיב (route) לכל רשת משנה המפורטת דרך ה-gateway של ה-Docker bridge, כך שחבילות מידע עבור כתובות אלו יוצאות דרך eth0 במקום דרך ה-tunnel. בנוסף, הוא פותח עבורן את ה-firewall, שכן ללא הגדרה זו, gluetun משליך (drops) תעבורה יוצאת שאינה מיועדת לשרת ה-VPN.

יש לכתוב את הערך ללא רווחים אחרי הפסיקים.

      - FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32,192.168.1.0/24,100.64.7.9/32

קל לפספס שתי תכונות. זוהי הגדרה ברמת ה-namespace, לכן היא חלה על כל מכולה שנמצאת מאחורי gluetun, ולא רק על זו שהתכוונת אליה. כמו כן, מדובר בתעבורה יוצאת בלבד: ההגדרה קובעת אילו חיבורים מכולה יכולה ליזום. חיבורים שמגיעים לפורט שפורסם (published port) עוברים בנתיב שונה ואינם זקוקים לרישום כאן.

גישה לממשק הניהול מתוך עמית Tailscale

Tailscale מעניקה לכל מכונה כתובת בטווח 100.64.0.0/10, הטווח השמור ל-carrier grade NAT. אין לכך עלות ב-tailnet אישי, אם כי מגבלת ששת המשתמשים בתוכנית החינמית קובעת אם זה נשאר נכון כאשר אנשים אחרים זקוקים לגישה לאותם ממשקים. מספר המכשירים של משתמשים אינו מוגבל בכל תוכנית. שרתים ומכשירים מתויגים אחרים נספרים בנפרד: דף התמחור של Tailscale מציין 50 משאבים מתויגים כלולים, עם תוספת של 1 דולר לחודש לכל אחד. מאחר שהחיוב סופר משתמשים ולא מכונות, העלות בפועל של tailnet בתשלום תלויה בעיקר במספר האנשים שאתם מזמינים, ולא במספר המכולות שאתם חושפים בפניהם. שני הכיוונים דורשים עבודה שונה.

תעבורה נכנסת היא הפשוטה מביניהן. פרסום 8080:8080 ב-gluetun קושר את הפורט הזה לכל הכתובות של המארח, וממשק ה-tailscale0 של המארח הוא אחת מהן, לכן עמית פותח את http://<machine-name>:8080 ומגיע למכולה. Docker מבצע NAT על המארח, וה-firewall של gluetun מאפשר תעבורה נכנסת ל-subnet של ה-Docker שלו.

כדי להפוך את הממשק לנגיש רק דרך ה-tailnet, קשרו את הפורט המפורסם לכתובת ה-Tailscale של המארח במקום לכל הכתובות.

    ports:
      - "100.101.102.103:8080:8080/tcp"

מצאו את הכתובת הזו באמצעות tailscale ip -4 על המארח. קשירה היא אמצעי בקרה חזק יותר מחוק firewall במקרה זה, כיוון שהפורט כלל אינו נפתח בממשק הציבורי. אם אתם מעדיפים להגיע לממשק דרך שם HTTPS במקום דרך מארח ופורט, tailscale serve יכול לשמש כחזית לפורט המפורסם הזה, אם כי serve ו-funnel נבדלים במי שמסוגל להגיע אליו בסוף ורק אחד מהם משאיר את הממשק בתוך ה-tailnet. זה גם עוקף את הבעיה ב-פרסום פורטים ב-Docker ישירות מעבר ל-ufw. ה-תבנית sidecar של Tailscale עבור Compose מרחיקה לכת ומסירה את פורט המארח לחלוטין, אך היא פועלת על ידי הכנסת היישום למרחב השמות של הרשת של ה-sidecar, ומכולה מאחורי gluetun כבר השתמשה ב-network_mode היחיד שלה עבור gluetun.

תעבורה יוצאת היא המקום שבו FIREWALL_OUTBOUND_SUBNETS חוזר. אם מכולה צריכה לקרוא לעמית, הוסיפו את הכתובת של אותו עמית, והעדיפו /32 לכל עמית על פני /10 שלם. אם המכונה שאליה אתם פונים יושבת ברשת פרטית אליה מגיעים דרך שרת VPS שמפרסם את ה-subnet הזה ל-tailnet שלכם, רשמו את הטווח המפורסם במקום כתובת ה-100.x של הנתב עצמו, ואשרו שהמארח עצמו קיבל את הנתיבים הללו. שמות MagicDNS אינם מתורגמים בתוך המכולה כברירת מחדל, כיוון שהמכולה משתמשת בשרת ה-DNS של gluetun ולא ב-resolver של המארח, לכן השתמשו בכתובת ה-100.x המספרית או קבעו את השם עם שורת extra_hosts בשירות gluetun. האפשרות DNS_UPSTREAM_PLAIN_ADDRESSES של gluetun יכולה להעביר שאילתות ל-resolver אחר במקום זאת, אך היא שולחת כל שאילתה בטקסט גלוי, ותיעוד gluetun ממליץ נגד זה כיוון ששאילתות לכתובת פרטית דולפות מחוץ למנהרת ה-VPN. אותו הדבר חל כאשר אתם מריצים שרת בקרה עצמאי של Tailscale עם Headscale.

קובץ compose מלא למבנה נפוץ

לקוח הורדות מאחורי VPN, שני ממשקי אינטרנט המגיבים רק בתוך ה-tailnet, ומכולה אחת שניגשת למסד נתונים PostgreSQL שרץ על המארח.

services:
  gluetun:
    image: qmcgaw/gluetun:latest
    container_name: gluetun
    cap_add:
      - NET_ADMIN
    devices:
      - /dev/net/tun:/dev/net/tun
    ports:
      - "127.0.0.1:8000:8000/tcp"        # gluetun control server, host only
      - "100.101.102.103:8080:8080/tcp"  # qBittorrent UI, tailnet only
      - "100.101.102.103:9696:9696/tcp"  # Prowlarr UI, tailnet only
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - ./gluetun:/gluetun
    environment:
      - VPN_SERVICE_PROVIDER=mullvad
      - VPN_TYPE=wireguard
      - WIREGUARD_PRIVATE_KEY=${WIREGUARD_PRIVATE_KEY}
      - WIREGUARD_ADDRESSES=${WIREGUARD_ADDRESSES}
      - SERVER_CITIES=Amsterdam
      - FIREWALL_OUTBOUND_SUBNETS=172.17.0.1/32,100.64.7.9/32
      - TZ=Europe/Amsterdam
    restart: unless-stopped

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

  prowlarr:
    image: lscr.io/linuxserver/prowlarr:latest
    network_mode: "service:gluetun"
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Amsterdam
      - PROWLARR__POSTGRES__HOST=host.docker.internal
      - PROWLARR__POSTGRES__PORT=5432
      - PROWLARR__POSTGRES__USER=prowlarr
      - PROWLARR__POSTGRES__PASSWORD=${PROWLARR_DB_PASSWORD}
      - PROWLARR__POSTGRES__MAINDB=prowlarr-main
      - PROWLARR__POSTGRES__LOGDB=prowlarr-log
    volumes:
      - ./prowlarr:/config
    depends_on:
      gluetun:
        condition: service_healthy
    restart: unless-stopped

קראו את הקובץ כדי להבין את התבנית ולא את שמות המוצרים. שני הממשקים מפורסמים על גבי gluetun וקשורים לכתובת ה-tailnet של המארח, כך שהם מגיבים ב-Tailscale בלבד ולא בשום מקום אחר. השורה extra_hosts נמצאת גם היא על gluetun, כיוון ש-Prowlarr קורא את ה-/etc/hosts של gluetun כאשר הוא מבצע resolution ל-host.docker.internal, ו-Docker יסרב להגדיר שורה זו ישירות ב-Prowlarr. ה-FIREWALL_OUTBOUND_SUBNETS מציין שתי כתובות בודדות: כתובת ה-bridge של Docker במארח, כדי ש-Prowlarr יוכל לפתוח חיבור למסד הנתונים, וכתובת של עמית אחד ב-tailnet.

שרת ה-PostgreSQL נעדר במכוון מהקובץ. הוא רץ על ה-VPS כשירות מערכת רגיל המאזין ב-172.17.0.1:5432. זהו אותו מבנה שכבות כמו ב-arr stack on Docker Compose, כאשר מסד הנתונים מוצא מחוץ ל-Docker.

שמרו את מפתח ה-WireGuard הפרטי מחוץ לקובץ ה-compose. ה-${WIREGUARD_PRIVATE_KEY} קורא מתוך קובץ .env שנמצא לצידו, תבנית המוסברת ב-env files and secrets for Docker Compose. סעיף ה-condition: service_healthy משתמש ב-healthcheck שמגיע מובנה עם ה-image של gluetun, כך ששום דבר לא מתחיל לפני שהמנהרה מדווחת שהיא פעילה. Compose healthchecks מסבירים את המבנה הכללי.

פרסום בכל הכתובות במקום רק ב-tailnet

הסירו את הקידומת של הכתובת ואת ה-port binds ב-0.0.0.0, מה שיכלול את ה-IP הציבורי של ה-VPS. בצעו זאת רק מאחורי firewall שבשליטתכם, וקראו תחילה את ההערה על ufw לעיל.

    ports:
      - "8080:8080/tcp"

אימות שהמנהרה עדיין מעבירה תעבורה

הריצו את אותה בקשה פעמיים: פעם אחת מתוך ה-namespace ופעם אחת מה-host, ולאחר מכן השוו את התוצאות.

docker run --rm --network=container:gluetun curlimages/curl:latest -s https://api.ipify.org
curl -s https://api.ipify.org

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

חוקי הניתוב וטבלאות הניתוב מראים מה עובר מחוץ למנהרה ומה לא.

docker run --rm --network=container:gluetun alpine:3.22 sh -c 'ip rule show; ip route show table 51820; ip route show table 199'

בהגדרת WireGuard במדריך זה, gluetun קורא לממשק המנהרה wg0. השם tun0 הוא ברירת המחדל של OpenVPN בלבד. כמו כן, gluetun שומר את נתיב ברירת המחדל של המנהרה מחוץ לטבלת הניתוב הראשית. ip rule show אמור לכלול חוק ששולח את כל התעבורה שלא סומנה על ידי WireGuard עצמו לטבלה 51820, וטבלה זו אמורה להכיל נתיב ברירת מחדל דרך wg0. טבלה 199 מחזיקה נתיב אחד עבור כל ערך ב-FIREWALL_OUTBOUND_SUBNETS, כאשר כל אחד מהם מצביע על ה-gateway של ה-bridge של Docker ב-eth0, והחוק שלה נבדק רגע לפני החוק של המנהרה. פקודת ip route show פשוטה עדיין תציג את נתיב ברירת המחדל של Docker ב-eth0. זה צפוי ואינו מהווה דליפה, כיוון ששני החוקים של gluetun נבדקים לפני הטבלה הראשית. כל נתיב בטבלה 199 שלא הגדרתם הוא תעבורה שעוקפת את ה-VPN.

שרת הבקרה של gluetun יכול לדווח על אותה כתובת IP ציבורית בפורט 8000, ב-/v1/publicip/ip, אך כברירת מחדל רק לאחר שתגדירו אימות. התיעוד של gluetun מציין שכל הנתיבים של שרת הבקרה הם כעת פרטיים כברירת מחדל, לכן בקשה פשוטה לנתיב זה תיכשל. הגדירו אותו עם קובץ אימות ב-bind mount ב-/gluetun/auth/config.toml באמצעות השיטה basic או apikey, ולאחר מכן הפעילו מחדש את gluetun. קובץ ה-compose לעיל כבר מבצע mount ל-./gluetun ב-/gluetun, לכן הקובץ צריך להיות ממוקם ב-./gluetun/auth/config.toml על ה-host. המשתנה HTTP_CONTROL_SERVER_AUTH_DEFAULT_ROLE הוא הדרך המהירה יותר. הגדרתו ל-{"auth":"none"} מבטלת את האימות לחלוטין, דבר שהתיעוד מציין כלא מומלץ בעליל. בגרסאות שלפני v3.39.1 השרת אינו נעול בצורה זו, והתיעוד מזהיר שיש לתת אמון בכל מי שיכול להגיע אליו.

הדליפה שיוצר subnet שגוי

FIREWALL_OUTBOUND_SUBNETS הוא חור שאתם מנקבים ב-firewall בכוונה, לכן גודל החור הוא גודל הסיכון. ארבע טעויות שיש להימנע מהן:

  • 0.0.0.0/0 נכשל באימות התצורה עם outbound subnet has an unspecified address: 0.0.0.0/0. gluetun דוחה זאת במקום לנתב הכל מחוץ למנהרה.
  • טווח רחב יותר מהיעד. פתיחת 10.0.0.0/8 כדי להגיע למכונה אחת ב-10.0.1.7 פותחת גם כל כתובת שעמית torrent עשוי לפרסם בטווח הזה. כתבו 10.0.1.7/32.
  • טווח שחופף לכתובות של המנהרה עצמה. תיעוד gluetun מזהיר שזה גורם ל-gluetun לשלוח תעבורת VPN החוצה דרך ה-bridge, מה שמשבש את העברת הפורטים. בדקו את ערך ה-WIREGUARD_ADDRESSES שלכם לפני פתיחת טווח פרטי כלשהו.
  • 100.64.0.0/10 עבור Tailscale. מדובר בכארבעה מיליון כתובות שנפתחות כדי שעמית אחד יהיה נגיש. רשמו את העמיתים שאתם צריכים כערכי /32.

זכרו שההגדרה מכסה את כל מרחב השמות. פתיחת subnet כדי ש-indexer יוכל להגיע לשירות מארח פותחת את אותו ה-subnet עבור לקוח ה-torrent שמשתף את מרחב השמות הזה. הריצו שוב את בדיקת ה-IP הציבורי לאחר כל שינוי במשתנה זה, כיוון שזו הבדיקה היחידה שמראה אם השינוי עשה את מה שהתכוונתם אליו.

מה משתבש בעת אתחול מחדש של gluetun

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

Error response from daemon: cannot join network namespace of a non running container: container <id> is exited

אתחול מחדש של gluetun במקומו הוא כשל שקט יותר. המכולות התלויות ממשיכות לרוץ בזמן שה-namespace שאליו הן מחוברות נבנה מחדש מתחתיהן, כך ש-docker ps מדווח שהכול תקין אך שום דבר אינו מגיב. לאחר כל שינוי בשירות gluetun, יש ליצור מחדש את כל הקבוצה במקום לאתחל חלק אחד ממנה.

docker compose up -d --force-recreate

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

FAQ

מדוע Docker מציג את השגיאה "port publishing and the container type network mode"?

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

כיצד מכולות אחרות יכולות להגיע לשירות שנמצא מאחורי gluetun?

מכולות הנמצאות באותו מרחב רשת מגיעות זו לזו דרך 127.0.0.1. מכולות מחוץ למרחב זה משתמשות בשם השירות של gluetun, לכן http://gluetun:8080 עובד במקום שבו http://qbittorrent:8080 נכשל. מכולת היישום אינה מחזיקה בכתובת באף רשת Docker, ולכן לשרת ה-DNS המוטמע אין מה לפתור עבור שמה. אין צורך בפרסום פורטים עבור פעולה זו, כל עוד שתי המכולות חולקות רשת Compose משותפת.

מה עלי להגדיר ב-FIREWALL_OUTBOUND_SUBNETS?

יש להגדיר רק את הכתובות שאליהן מכולה מאחורי gluetun חייבת ליזום חיבור, תוך הקפדה על טווח מצומצם ככל האפשר. מכונה בודדת מוגדרת כ-/32. שתי הרשומות הנפוצות הן המארח של Docker ב-172.17.0.1/32 וכתובת /32 אחת עבור כל עמית (peer) ב-Tailscale שאליו אתם פונים. לעולם אין להוסיף 0.0.0.0/0, ואין להוסיף טווח שחופף לכתובות ה-tunnel של ה-VPN עצמו. חיבורים נכנסים לפורט שפורסם אינם דורשים הגדרה כאן.

מדוע המכולה אינה מצליחה לפתור את שמות ה-MagicDNS של Tailscale?

MagicDNS פועל על ידי הפניית ה-resolver של המארח לשרת ה-DNS של Tailscale, אך המכולה אינה משתמשת ב-resolver של המארח. היא משתמשת ב-/etc/resolv.conf שהיא חולקת עם gluetun, המצביע על שרת ה-DNS של gluetun עצמו. יש לאמת זאת באמצעות docker exec <container> cat /etc/resolv.conf. השתמשו בכתובת ה-100.x המספרית של העמית, או קבעו את השם באמצעות רשומת extra_hosts בשירות gluetun. ניתן להגדיר ל-gluetun להעביר שאילתות ל-resolver אחר באמצעות DNS_UPSTREAM_PLAIN_ADDRESSES, אך פעולה זו שולחת אותן בטקסט גלוי והתיעוד של השירות ממליץ להימנע מכך.

כיצד אוכל לוודא שהתעבורה עדיין עוברת דרך ה-VPN?

בצעו בקשה אחת מתוך מרחב הרשת ואת אותה בקשה מהמארח, ולאחר מכן השוו את התוצאות. docker run --rm --network=container:gluetun curlimages/curl:latest -s https://api.ipify.org אמור להחזיר את כתובת היציאה של ספק ה-VPN שלכם, בעוד ש-curl -s https://api.ipify.org ב-VPS יחזיר את כתובת ה-VPS. שתי תשובות זהות מעידות על כך שה-tunnel אינו מעביר את תעבורת המכולה. בצעו בדיקה זו שוב לאחר כל שינוי ב-FIREWALL_OUTBOUND_SUBNETS.

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