זוהי הפעלת הפקודה docker שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
docker-run - הפעל פקודה במיכל חדש
תַקצִיר
סַוָר לָרוּץ [-a|--לְצַרֵף[=[]]] [--add-host[=[]]] [--בלקיו-משקל[=[BLKIO-WEIGHT]]]
[--blkio-weight-device[=[]]] [---cpu-shares[=0]] [--cap-add[=[]]] [--cap-drop[=[]]]
[--cgroup-הורה[=CGROUP-PATH]] [--cidfile[=CIDFILE]] [---cpu-period[=0]] [--מכסת מעבד[=0]]
[--cpuset-cpus[=CPUSET-CPUS]] [--cpuset-mems[=CPUSET-MEMS]] [-d|--לנתק]
[--ניתוק-מפתחות[=[]]] [--התקן[=[]]] [--device-read-bps[=[]]] [--device-read-iops[=[]]]
[--device-write-bps[=[]]] [--device-write-iops[=[]]] [--dns[=[]]] [--dns-opt[=[]]]
[--dns-search[=[]]] [-e|--env[=[]]] [--נקודת כניסה[=נקודת כניסה]] [--env-קובץ[=[]]]
[--לַחשׂוֹף[=[]]] [--קבוצה-הוסף[=[]]] [-h|--שם מארח[=שם מארח]] [- עזרה] [-i|--אינטראקטיבי]
[--ip[=כתובת IPv4]] [--ip6[=כתובת IPv6]] [--ipc[=IPC]] [--בידוד[=ברירת מחדל]]
[---kernel-memory[=זיכרון קרנל]] [-l|--תווית[=[]]] [--תווית-קובץ[=[]]] [--קישור[=[]]]
[---log-driver[=[]]] [--log-opt[=[]]] [-m|--זיכרון[=זיכרון]] [--כתובת מק[=כתובת MAC]]
[--שימור זיכרון[=זיכרון-שימור]] [--החלפת זיכרון[=להגביל]]
[--זיכרון-החלפה[=זיכרון-החלפה]] [--שֵׁם[=שֵׁם]] [--נֶטוֹ[="לְגַשֵׁר"]]
[--net-alias[=[]]] [--oom-kill-disable] [--oom-score-adj[=0]] [-P|--פרסם-הכל]
[-p|--לְפַרְסֵם[=[]]] [--pid[=[]]] [--חָסוּי] [--לקריאה בלבד] [--אתחול[=איתחול]] [--rm]
[---Security-opt[=[]]] [--אות עצור[=אוֹת]] [--שמ-גודל[=[]]] [--sig-proxy[=נָכוֹן]]
[-t|--tty] [--tmpfs[=[CONTAINER-DIR[: ]]] [-u|--מִשׁתַמֵשׁ[=משתמש]] [--ulimit[=[]]]
[--אוטס[=[]]] [-v|--כרך[=[[HOST-DIR:]DIR-CONTAINER[:OPTIONS]]]]
[--התקן-נפח[=נהג]] [--כרכים-מאת[=[]]] [-w|--workdir[=WORKDIR]] תמונה [פקודה]
[ARG...]
תיאור
הפעל תהליך במיכל חדש. סַוָר לָרוּץ מתחיל תהליך עם מערכת קבצים משלו,
רשת משלו, ועץ תהליכים מבודד משלו. ה-IMAGE שמתחיל את התהליך
עשוי להגדיר ברירות מחדל הקשורות לתהליך שיופעל בקונטיינר, ה
נטוורקינג כדי לחשוף, ועוד, אבל סַוָר לָרוּץ נותן שליטה סופית למפעיל או
מנהל שמתחיל את המכולה מהתמונה. מסיבה זו סַוָר לָרוּץ יש יותר
אפשרויות מכל פקודת Docker אחרת.
אם ה-IMAGE עדיין לא נטען אז סַוָר לָרוּץ ימשוך את התמונה ואת כל התמונה
תלות, מהמאגר באותו אופן פועל סַוָר למשוך IMAGE, לפניה
מתחיל את המיכל מאותה תמונה.
אפשרויות
-a, --לְצַרֵף=[]
צרף ל-STDIN, STDOUT או STDERR.
במצב חזית (ברירת המחדל מתי -d לא מצוין), סַוָר לָרוּץ יכול להתחיל את
לעבד במיכל ולצרף את המסוף לקלט, פלט סטנדרטי של התהליך,
ושגיאת תקן. זה אפילו יכול להעמיד פנים שהוא TTY (זה מה שרוב שורת הפקודה
קובצי הפעלה מצפים) ומעבירים אותות. ה -a ניתן להגדיר אפשרות עבור כל אחד מהסטדין,
stdout, ו-stderr.
--add-host=[]
הוסף מיפוי מארח ל-IP מותאם אישית (host:ip)
הוסף שורה ל-/etc/hosts. הפורמט הוא hostname:ip. ה --add-host ניתן להגדיר אפשרות
מספר פעמים.
--בלקיו-משקל=0
משקל IO בלוק (משקל יחסי) מקבל ערך משקל בין 10 ל-1000.
--blkio-weight-device=[]
משקל IO בלוק (משקל מכשיר יחסי, פורמט: DEVICE_NAME: משקל).
---cpu-shares=0
נתחי מעבד (משקל יחסי)
כברירת מחדל, כל הקונטיינרים מקבלים את אותו פרופורציה של מחזורי מעבד. פרופורציה זו יכולה להיות
שונה על ידי שינוי שקלול נתח ה-CPU של המכולה ביחס לשקלול של כולם
מכולות פועלות אחרות.
כדי לשנות את הפרופורציה מברירת המחדל של 1024, השתמש ב- ---cpu-shares דגל כדי להגדיר את
שקלול ל-2 ומעלה.
הפרופורציה תחול רק כאשר פועלים תהליכים עתירי מעבד. כאשר משימות נכנסות
מיכל אחד לא פעיל, מיכלים אחרים יכולים להשתמש בזמן המעבד שנותר. הסכום בפועל
זמן ה-CPU ישתנה בהתאם למספר הקונטיינרים הפועלים במערכת.
לדוגמה, קחו בחשבון שלושה מיכלים, לאחד יש שיתוף מעבד של 1024 ולשניים אחרים יש a
הגדרת שיתוף cpu של 512. כאשר תהליכים בכל שלושת הקונטיינרים מנסים להשתמש ב-100%
CPU, המיכל הראשון יקבל 50% מזמן המעבד הכולל. אם תוסיף רביעית
מיכל עם נתח מעבד של 1024, המיכל הראשון מקבל רק 33% מהמעבד. ה
הקונטיינרים הנותרים מקבלים 16.5%, 16.5% ו-33% מהמעבד.
במערכת מרובת ליבות, הנתחים של זמן המעבד מחולקים על פני כל ליבות המעבד. אפילו אם
מיכל מוגבל לפחות מ-100% מזמן ה-CPU, הוא יכול להשתמש ב-100% מכל אדם
ליבת מעבד.
לדוגמה, שקול מערכת עם יותר משלוש ליבות. אם אתה מתחיל מיכל אחד {C0}
עם -c=512 הפעלת תהליך אחד, ומיכל אחר {C1} עם -c=1024 רץ שניים
תהליכים, זה יכול לגרום לחלוקה הבאה של שיתופי CPU:
שיתוף מעבד של מיכל PID
100 {C0} 0 100% מ-CPU0
101 {C1} 1 100% מ-CPU1
102 {C1} 2 100% מ-CPU2
--cap-add=[]
הוסף יכולות לינוקס
--cap-drop=[]
שחרר את יכולות לינוקס
--cgroup-הורה= ""
נתיב ל-cgroups שמתחתם תיווצר ה-cgroup עבור המכולה. אם השביל
אינו מוחלט, הנתיב נחשב כיחסי לנתיב cgroups של ה-init
תהליך. קבוצות C ייווצרו אם הן לא קיימות כבר.
--cidfile= ""
כתוב את מזהה המכולה לקובץ
---cpu-period=0
הגבל את תקופת CPU CFS (מתזמן הוגן לחלוטין).
הגבל את השימוש במעבד של המכולה. הדגל הזה אומר לקרנל להגביל את המעבד של המיכל
שימוש לתקופה שאתה מציין.
--cpuset-cpus= ""
מעבדים שבהם ניתן לאפשר ביצוע (0-3, 0,1)
--cpuset-mems= ""
צמתי זיכרון (MEMs) שבהם לאפשר ביצוע (0-3, 0,1). תקף רק ב-NUMA
מערכות.
אם יש לך ארבעה צמתי זיכרון במערכת שלך (0-3), השתמש --cpuset-mems=0,1 אחר כך תהליכים
במיכל Docker שלך ישתמש רק בזיכרון משני צמתי הזיכרון הראשונים.
--מכסת מעבד=0
הגבל את מכסת המעבד CFS (תזמן הוגן לחלוטין).
הגבל את השימוש במעבד של המכולה. כברירת מחדל, קונטיינרים פועלים עם משאב המעבד המלא.
הדגל הזה אומר לקרנל להגביל את השימוש ב-CPU של המיכל למכסה שאתה מציין.
-d, --לנתק=נָכוֹן|שקר
מצב מנותק: הפעל את המכולה ברקע והדפיס את מזהה המכולה החדש. ה
ברירת המחדל היא שקר.
בכל עת אתה יכול לרוץ סַוָר ps במעטפת השנייה כדי להציג רשימה של הרצים
מיכלים. ניתן לחבר מחדש למיכל מנותק עם סַוָר לצרף. אם תבחר
הפעל מיכל במצב מנותק, ואז לא תוכל להשתמש ב- -רם אוֹפְּצִיָה.
כאשר מחוברים במצב tty, ניתן לנתק מהמיכל (ולהשאיר אותו פועל)
באמצעות רצף מקשים שניתן להגדרה. רצף ברירת המחדל הוא CTRL-p CTRL-q. אתה קובע
רצף המקשים באמצעות --ניתוק-מפתחות אפשרות או קובץ תצורה. לִרְאוֹת
config-json(5) לתיעוד על השימוש בקובץ תצורה.
--ניתוק-מפתחות= ""
תעקוף את רצף המקשים לניתוק מיכל. פורמט הוא תו בודד [aZ]
or ctrl- איפה אחד מ: AZ, @, ^, [, , or _.
--התקן=[]
הוסף מכשיר מארח למיכל (למשל --device=/dev/sdc:/dev/xvdc:rwm)
--device-read-bps=[]
הגבל את קצב הקריאה ממכשיר (למשל --device-read-bps=/dev/sda:1mb)
--device-read-iops=[]
הגבל את קצב הקריאה ממכשיר (למשל --device-read-iops=/dev/sda:1000)
--device-write-bps=[]
הגבל את קצב הכתיבה למכשיר (למשל --device-write-bps=/dev/sda:1mb)
--device-write-iops=[]
הגבלת קצב כתיבה במכשיר (למשל --device-write-iops=/dev/sda:1000)
--dns-search=[]
הגדר דומיינים מותאמים אישית לחיפוש DNS (השתמש ב--dns-search=. אם אינך רוצה להגדיר את החיפוש
תחום)
--dns-opt=[]
הגדר אפשרויות DNS מותאמות אישית
--dns=[]
הגדר שרתי DNS מותאמים אישית
ניתן להשתמש באפשרות זו כדי לעקוף את תצורת ה-DNS המועברת למיכל.
בדרך כלל זה הכרחי כאשר תצורת ה-DNS המארח אינה חוקית עבור המכולה
(למשל, 127.0.0.1). כאשר זה המקרה ה --dns דגלים נחוצים לכל ריצה.
-e, --env=[]
הגדר משתני סביבה
אפשרות זו מאפשרת לך לציין משתני סביבה שרירותיים הזמינים עבור
התהליך שיושק בתוך המיכל.
--נקודת כניסה= ""
החלף את ברירת המחדל ENTRYPOINT של התמונה
אפשרות זו מאפשרת לך להחליף את נקודת הכניסה המוגדרת כברירת מחדל של התמונה המוגדרת ב-
Dockerfile. נקודת ה-ENTRYPOINT של תמונה דומה לCOMMAND מכיוון שהיא מציינת מה
קובץ הפעלה להפעלה כאשר המיכל מתחיל, אך (בכוונה) קשה יותר לעשות זאת
לעקוף. ה-ENTRYPOINT נותן למיכל את אופי ברירת המחדל או התנהגותו, כך שמתי
אתה מגדיר ENTRYPOINT אתה יכול להריץ את המיכל כאילו זה בינארי, להשלים עם
אפשרויות ברירת המחדל, ותוכלו להעביר אפשרויות נוספות באמצעות ה-COMMAND. אבל, לפעמים א
ייתכן שהמפעיל ירצה להפעיל משהו אחר בתוך המכולה, כדי שתוכל לעקוף את
ברירת המחדל ENTRYPOINT בזמן ריצה באמצעות א --נקודת כניסה ומחרוזת לציון החדש
נקודת כניסה.
--env-קובץ=[]
קרא בקובץ מופרד בשורות של משתני סביבה
--לַחשׂוֹף=[]
חשיפת יציאה, או טווח של יציאות (למשל --expose=3300-3310) מודיע ל-Docker שה-
container מאזין ביציאות הרשת שצוינו בזמן ריצה. Docker משתמש במידע זה
לחיבור קונטיינרים באמצעות קישורים ולהגדיר ניתוב מחדש של פורטים במערכת המארחת.
--קבוצה-הוסף=[]
הוסף קבוצות נוספות להפעלה
-h, --שם מארח= ""
שם מארח של מיכל
מגדיר את שם המארח של המכולה הזמין בתוך המכולה.
- עזרה
הדפס הצהרת שימוש
-i, --אינטראקטיבי=נָכוֹן|שקר
השאר STDIN פתוח גם אם אינו מחובר. ברירת המחדל היא שקר.
כאשר מוגדר כ-true, השאר את stdin פתוח גם אם לא מצורף. ברירת המחדל היא שקר.
--ip= ""
מגדיר את כתובת ה-IPv4 של ממשק המאגר (למשל 172.23.0.9)
ניתן להשתמש בו רק בשילוב עם --נֶטוֹ עבור רשתות מוגדרות על ידי משתמש
--ip6= ""
מגדיר את כתובת ה-IPv6 של ממשק המאגר (למשל 2001:db8::1b99)
ניתן להשתמש בו רק בשילוב עם --נֶטוֹ עבור רשתות מוגדרות על ידי משתמש
--ipc= ""
ברירת המחדל היא ליצור מרחב שמות IPC פרטי (POSIX SysV IPC) עבור המכולה
'מְכוֹלָה: ': עושה שימוש חוזר במכל אחר משותף
זיכרון, סמפורות ותורי הודעות
'מארח': השתמש בזיכרון המשותף, הסמאפור וההודעה המארח
תורים בתוך המכולה. הערה: מצב המארח נותן למיכל גישה מלאה למקומון
זיכרון משותף ולכן נחשב לא בטוח.
--בידוד="ברירת מחדל"
בידוד מציין את סוג טכנולוגיית הבידוד המשמשת מכולות.
-l, --תווית=[]
הגדר מטא נתונים על המכולה (למשל, --label com.example.key=value)
---kernel-memory= ""
מגבלת זיכרון ליבה (פורמט: [ ], כאשר יחידה = b, k, m או g)
מגביל את זיכרון הליבה הזמין למיכל. אם צוין מגבלה של 0 (לא
באמצעות ---kernel-memory), זיכרון הליבה של המיכל אינו מוגבל. אם תציין א
מגבלה, ניתן לעגל אותה לכפולה של גודל העמוד של מערכת ההפעלה וה-
הערך יכול להיות גדול מאוד, מיליוני טריליונים.
--תווית-קובץ=[]
קרא בקובץ תוויות מופרד בשורות
--קישור=[]
הוסף קישור למיכל אחר בצורה של :כינוי או סתם ב
במקרה זה הכינוי יתאים לשם
אם המפעיל משתמש --קישור כאשר מתחילים את מיכל הלקוח החדש, ולאחר מכן את הלקוח
מיכל יכול לגשת ליציאה החשופה באמצעות ממשק רשת פרטי. Docker יקבע
כמה משתני סביבה במיכל הלקוח כדי לעזור לציין איזה ממשק ו
יציאה לשימוש.
---log-driver="json-קובץ|syslog|ג'ורנלד|gelf|שוטף|awslogs|מפוצץ|אף לא אחד"
מנהל התקן רישום עבור מיכל. ברירת המחדל מוגדרת על ידי דמון ---log-driver דגל.
אזהרה: ה סַוָר יומני הפקודה פועלת רק עבור json-קובץ ו
ג'ורנלד רישום מנהלי התקנים.
--log-opt=[]
רישום אפשרויות ספציפיות של מנהל ההתקן.
-m, --זיכרון= ""
מגבלת זיכרון (פורמט: [ ], כאשר יחידה = b, k, m או g)
מאפשר לך להגביל את הזיכרון הזמין למיכל. אם המארח תומך ב-swap
זיכרון, ואז ה -m הגדרת הזיכרון יכולה להיות גדולה יותר מזיכרון RAM פיזי. אם מגבלה של 0 היא
שצוין (לא משתמש -m), הזיכרון של המיכל אינו מוגבל. הגבול בפועל עשוי להיות
מעוגל כלפי מעלה לכפולה של גודל העמוד של מערכת ההפעלה (הערך יהיה מאוד
גדול, זה מיליוני טריליונים).
--שימור זיכרון= ""
מגבלת זיכרון רכה (פורמט: [ ], כאשר יחידה = b, k, m או g)
לאחר הגדרת שמירת זיכרון, כאשר המערכת מזהה מחלוקת בזיכרון או זיכרון נמוך,
מכולות נאלצות להגביל את צריכתן להזמנה שלהן. אז כדי לך
הגדר תמיד את הערך למטה --זיכרון, אחרת הגבול הקשה יקבל עדיפות. על ידי
ברירת המחדל, שמירת הזיכרון תהיה זהה למגבלת הזיכרון.
--החלפת זיכרון="LIMIT"
ערך גבול השווה לזיכרון בתוספת החלפה. חייב לשמש עם -m (--זיכרון) דגל. ה
להחליף להגביל תמיד צריך להיות גדול מ -m (--זיכרון) ערך.
הפורמט של להגביל is [ ]. יחידה יכולה להיות b (בתים), k (קילובייט), m
(מגה-בייט), או g (גיגה-בייט). אם לא תציין יחידה, b משמש. הגדר את LIMIT ל -1 ל
אפשר החלפה בלתי מוגבלת.
--כתובת מק= ""
כתובת MAC של מיכל (למשל 92:d0:c6:0a:29:33)
זכור שכתובת ה-MAC ברשת Ethernet חייבת להיות ייחודית. ה-IPv6 קישור מקומי
הכתובת תתבסס על כתובת ה-MAC של המכשיר לפי RFC4862.
--שֵׁם= ""
הקצה שם למיכל
המפעיל יכול לזהות מיכל בשלוש דרכים:
מזהה ארוך של UUID
(“f78375b1c487e03c9438c729345e54db9d20cfa2ac1fc3494b6eb60872e74778”)
מזהה קצר של UUID ("f78375b1c487")
שם ("ג'ונה")
מזהי ה-UUID מגיעים מדמון Docker, ואם לא מוקצה שם ל-
מיכל עם --שֵׁם אז הדמון גם יפיק שם מחרוזת אקראית. השם הוא
שימושי בעת הגדרת קישורים (ראה --קישור) (או כל מקום אחר שאתה צריך כדי לזהות א
מְכוֹלָה). זה עובד גם עבור מכולות Docker ברקע וגם בחזית.
--נֶטוֹ="גשר"
הגדר את מצב הרשת עבור המכולה
'גשר': צור ערימת רשת ב-Docker ברירת המחדל
גשר
'ללא': אין רשת
'מְכוֹלָה: ': השתמש מחדש ברשת של מיכל אחר
לערום
'מארח': השתמש בערימת הרשת המארח של Docker. הערה: המארח
מצב נותן למכולה גישה מלאה לשירותי מערכת מקומיים כגון D-bus ו-is
לכן נחשב לחסר ביטחון.
' | ': התחבר למשתמש מוגדר
רשת
--net-alias=[]
הוסף כינוי בהיקף רשת עבור המכולה
--oom-kill-disable=נָכוֹן|שקר
האם להשבית את OOM Killer עבור המיכל או לא.
--oom-score-adj= ""
כוונן את העדפות ה-OOM של המארח עבור מכולות (מקבל -1000 עד 1000)
-P, --פרסם-הכל=נָכוֹן|שקר
פרסם את כל היציאות החשופות ליציאות אקראיות בממשקי המארח. ברירת המחדל היא שקר.
כאשר מוגדר כ-true פרסם את כל היציאות החשופות לממשקי המארח. ברירת המחדל היא שקר.
אם המפעיל משתמש ב-P (או -p) אז Docker יהפוך את היציאה החשופה לנגישה ב-
המארח והיציאות יהיו זמינות לכל לקוח שיכול להגיע למארח. בעת שימוש ב-P,
Docker יקשר כל יציאה חשופה ליציאה אקראית במארח בתוך חלוף-חלוף נמל
רכס מוגדר על ידי /proc/sys/net/ipv4/ip_local_port_range. כדי למצוא את המיפוי בין ה
יציאות מארח והיציאות החשופות, השתמש סַוָר נמל.
-p, --לְפַרְסֵם=[]
פרסם יציאה של מכולה, או טווח יציאות, למארח.
פוּרמָט: ip:hostPort:containerPort | ip::containerPort | hostPort:containerPort |
containerPort ניתן לציין גם hostPort וגם containerPort כטווח של יציאות. מתי
ציון טווחים עבור שניהם, מספר יציאות המכולה בטווח חייב להתאים ל-
מספר יציאות מארח בטווח. (לְמָשָׁל, סַוָר לָרוּץ -p 1234-1236: 1222-1224 --שֵׁם
זה עובד -t busybox אך לא סַוָר לָרוּץ -p 1230-1236: 1230-1240 --שֵׁם
RangeContainerPortsBiggerThanRangeHostPorts -t busybox) עם ip: סַוָר לָרוּץ -p
127.0.0.1:$HOSTPORT:$CONTAINERPORT --שֵׁם מיכל -t תמונה כלשהי השתמש סַוָר נמל כדי לראות
המיפוי בפועל: סַוָר נמל מיכל $CONTAINERPORT
--pid=המארח
הגדר את מצב PID עבור המיכל
המארח: השתמש במרחב השמות PID של המארח בתוך המכולה.
הערה: מצב המארח נותן למיכל גישה מלאה ל-PID מקומי ולכן הוא
נחשב חסר ביטחון.
--אוטס=המארח
הגדר את מצב UTS עבור המכולה
המארח: השתמש במרחב השמות של ה-UTS של המארח בתוך המכולה.
הערה: מצב המארח נותן למיכל גישה לשינוי שם המארח של המארח והוא
לכן נחשב לחסר ביטחון.
--חָסוּי=נָכוֹן|שקר
תן הרשאות מורחבות למיכל זה. ברירת המחדל היא שקר.
כברירת מחדל, קונטיינרים של Docker הם "בלתי מורשים" (=false) ואינם יכולים, למשל, להריץ את a
Docker daemon בתוך מיכל Docker. הסיבה לכך היא שכברירת מחדל קונטיינר אינו
מורשים לגשת לכל מכשיר. מיכל "מועדף" מקבל גישה לכל המכשירים.
כאשר המפעיל מבצע סַוָר לָרוּץ --חָסוּי, Docker יאפשר גישה לכל
התקנים במארח וכן הגדר תצורה כלשהי ב-AppArmor כדי לאפשר את המכולה
כמעט כל אותה גישה למארח כמו תהליכים הפועלים מחוץ למיכל ב-
מנחה.
--לקריאה בלבד=נָכוֹן|שקר
התקן את מערכת הקבצים הבסיסית של המיכל כקריאה בלבד.
כברירת מחדל, מערכת הקבצים הבסיסית של מיכל תהיה ניתנת לכתיבה המאפשרת לתהליכים לכתוב
קבצים בכל מקום. על ידי ציון ה --לקריאה בלבד הדגל למיכל יהיה השורש שלו
מערכת הקבצים מותאמת לקריאה בלבד ואוסרת כל כתיבה.
--אתחול="לא"
מדיניות הפעלה מחדש שתחול כשמכולה יוצאת (לא, בכשל[:max-retry], תמיד,
אלא אם כן נעצר).
--rm=נָכוֹן|שקר
הסר אוטומטית את המיכל כאשר הוא יוצא (לא תואם ל-d). ברירת המחדל היא
שקר.
---Security-opt=[]
אפשרויות אבטחה
"label:user:USER" : הגדר את משתמש התווית עבור המיכל
"label:role:ROLE" : הגדר את תפקיד התווית עבור המיכל
"label:type:TYPE" : הגדר את סוג התווית עבור המיכל
"label:level:LEVEL" : הגדר את רמת התווית עבור המיכל
"label:disable" : כבה את כליאת התווית עבור המיכל
--אות עצור=טווח יעד
איתות לעצור מכולה. ברירת המחדל היא SIGTERM.
--שמ-גודל= ""
מידה של / dev / shm. הפורמט הוא .
מספר חייב להיות גדול מ 0. היחידה היא אופציונלית ויכולה להיות b (בתים), k (קילובייט),
m(מגה-בייט), או g (גיגה-בייט).
אם תשמיט את היחידה, המערכת משתמשת בתים. אם תשמיט את הגודל לחלוטין, המערכת
שימושים 64m.
--sig-proxy=נָכוֹן|שקר
אותות פרוקסי שהתקבלו לתהליך (ללא מצב TTY בלבד). SIGCHLD, SIGSTOP, ו
ל-SIGKILL אין פרוקסי. ברירת המחדל היא נָכוֹן.
--זיכרון-החלפה= ""
כוונן את התנהגות החלפת הזיכרון של מיכל. מקבל מספר שלם בין 0 ל-100.
-t, --tty=נָכוֹן|שקר
הקצאת פסאודו-TTY. ברירת המחדל היא שקר.
כאשר הוא מוגדר כ-true Docker יכול להקצות פסאודו-tty ולצרף לקלט הסטנדרטי של כל אחד
מְכוֹלָה. זה יכול לשמש, למשל, כדי להפעיל מעטפת אינטראקטיבית לזריקה. ה
ברירת המחדל היא שקר.
אל האני -t האפשרות אינה תואמת להפניה מחדש של הקלט הסטנדרטי של לקוח docker.
--tmpfs=[] צור mount tmpfs
התקן מערכת קבצים זמנית (tmpfs) לעלות לתוך מיכל, לדוגמה:
$ docker run -d --tmpfs / Tmp:rw,size=787448k,mode=1777 my_image
פקודה זו עולה א tmpfs at / Tmp בתוך המיכל. אפשרויות ההרכבה הנתמכות הן
זהה לברירת המחדל של לינוקס הר דגלים. אם לא תציין אפשרויות כלשהן, המערכות
משתמש באפשרויות הבאות: rw,noexec,nosuid,nodev,size=65536k.
-u, --מִשׁתַמֵשׁ= ""
מגדיר את שם המשתמש או ה-UID בשימוש ובאופן אופציונלי את שם הקבוצה או ה-GID עבור המצוין
פקודה.
הדוגמאות הבאות כולן תקפות:
--משתמש [משתמש | משתמש:קבוצה | uid | uid:gid | user:gid | uid:group ]
ללא ארגומנט זה הפקודה תופעל כ-root במיכל.
--ulimit=[]
אפשרויות Ulimit
-v|--כרך[=[[HOST-DIR:]DIR-CONTAINER[:OPTIONS]]]
צור חיבור לחיבור. אם תפרט, -v /HOST-DIR:/CONTAINER-DIR, דוקר
לאגד תושבות /HOST-DIR במארח ל /CONTAINER-DIR ב-Docker
מְכוֹלָה. אם 'HOST-DIR' מושמט, Docker יוצר אוטומטית את החדש
נפח על המארח. ה אפשרויות הם רשימה מופרדת בפסיק ויכולה להיות:
· [rw|ro]
· [z|Z]
· [[r]שיתף|[ר]עבד|[r]פרטי]
אל האני CONTAINER-DIR חייב להיות נתיב מוחלט כגון /src/docs. ה HOST-DIR יכול להיות
נתיב מוחלט או א שם ערך. א שם הערך חייב להתחיל בתו אלפאנומרי,
אחריו a-z0-9, _ (מדגיש), . (נקודה) או - (מַקָף). דרך מוחלטת מתחילה ב
a / (קו נטוי).
אם אתה מספק א HOST-DIR זהו נתיב מוחלט, Docker מתחבר לנתיב שאתה
לפרט. אם אתה מספק א שם, Docker יוצר אמצעי אחסון בשם על ידי זה שם. לדוגמה,
אתה יכול לציין גם / פו or Foo עבור HOST-DIR ערך. אם אתה מספק את / פו ערך
Docker יוצר חיבור לחיבור. אם אתה מספק את Foo מפרט, Docker יוצר שם
נפח.
אתה יכול לציין מרובים -v אפשרויות להרכבת תושבת אחת או יותר למיכל. להשתמש
אותם תושבות במיכלים אחרים, ציין את --כרכים-מאת אפשרות גם.
ניתן להוסיף :רו or :rw סיומת לנפח כדי להעלות אותו לקריאה בלבד או קריאה-כתיבה,
בהתאמה. כברירת מחדל, אמצעי האחסון מותקנים קריאה-כתיבה. ראה דוגמאות.
מערכות תיוג כמו SELinux דורשות הצבת תוויות מתאימות על תוכן נפח
מותקן לתוך מיכל. ללא תווית, מערכת האבטחה עשויה למנוע את התהליכים
ריצה בתוך המיכל משימוש בתוכן. כברירת מחדל, Docker אינו משתנה
התוויות שנקבעו על ידי מערכת ההפעלה.
כדי לשנות תווית בהקשר המכולה, תוכל להוסיף אחת משתי הסיומות :z or :Z ל
תושבת הווליום. סיומות אלו אומרות ל-Docker לתייג מחדש אובייקטים של קבצים ב-Shared
כרכים. ה z option אומר ל-Docker ששני קונטיינרים חולקים את תוכן הנפח. כ
כתוצאה מכך, Docker מסמן את התוכן עם תווית תוכן משותף. תוויות נפח משותפות מאפשרות
כל הקונטיינרים לקריאה/כתיבה של תוכן. ה Z אפשרות אומרת ל-Docker לתייג את התוכן עם
תווית פרטית שלא שותפה. רק המכולה הנוכחית יכולה להשתמש באמצעי אחסון פרטי.
כברירת מחדל, כרכים רכובים ב-bind הם פְּרָטִי. זה אומר שכל התקנות שנעשו בתוך המכולה
לא יהיה גלוי במארח ולהיפך. אפשר לשנות התנהגות זו על ידי ציון א
מאפיין התפשטות נפח. יצירת נפח משותף התקנות שנעשו מתחת לנפח זה
המכולה הפנימית תהיה גלויה על המארח ולהיפך. יצירת נפח עבד מאפשר
רק התפשטות mount בכיוון אחד וזה mounts שבוצעו על המארח מתחת לנפח זה
גלוי בתוך המיכל אך לא להיפך.
כדי לשלוט על מאפיין התפשטות הר של נפח אפשר להשתמש :[r]שיתף, :[r]עבד or
:[r]פרטי דגל התפשטות. ניתן לציין את מאפיין ההפצה רק עבור ה-bind mounted
כרכים ולא עבור כרכים פנימיים או כרכים בעלי שם. כדי שהתפשטות הר תעבוד
נקודת ההרכבה של המקור (נקודת ההרכבה שבה מותקן ה-Dir של המקור) צריכה להיות נכונה
תכונות ריבוי. עבור אמצעי אחסון משותפים, יש לשתף את נקודת ההרכבה של המקור. ועבור
נפחי עבדים, התקן מקור חייב להיות משותף או עבד.
השתמש df כדי לברר את רכיב המקור ולאחר מכן להשתמש מצא -o
מטרה, התפשטות כדי להבין את תכונות ההפצה של המקור
הר. אם מצא כלי השירות אינו זמין, אז אפשר להסתכל על ערך הר למקור
נקודת הרכבה פנימה /proc/self/mountinfo. להסתכל על אופציונלי שדות ולראות אם יש תפוצה
מאפיינים מצוינים. משותף: X פירושו הר הוא משותף, מאסטר:X פירושו הר הוא עבד
ואם אין שום דבר זה אומר הר הוא פְּרָטִי.
כדי לשנות את מאפייני ההפצה של נקודת הרכבה השתמש הר פקודה. לדוגמה, אם אחד
רוצה לאגד את ספריית המקור של הר / פו אחד יכול לעשות הר --לִקְשׁוֹר / פו / פו ו הר
--להפוך לפרטי --לעשות-משותף / פו. זה ימיר את /foo ל-a משותף נקודת הרכבה.
לחלופין, ניתן לשנות ישירות את מאפייני ההפצה של הרכבת המקור. אמר / is
מקור הר עבור / פוואז השתמש הר --לעשות-משותף / להמיר / אל משותף הר.
הערות: בעת שימוש ב-systemd לניהול ההתחלה והעצירה של דמון Docker, ב-
קובץ systemd unit יש אפשרות לשלוט בהפצת mount עבור Docker
הדמון עצמו, שנקרא הר דגלים. הערך של הגדרה זו עלול לגרום ל-Docker שלא
ראה שינויים בהתפשטות הר שבוצעו בנקודת ההרכבה. לדוגמה, אם הערך הזה
is עבד, ייתכן שלא תוכל להשתמש ב- משותף or rshared התפשטות על נפח.
--התקן-נפח= ""
מנהל הנפח של מיכל. מנהל התקן זה יוצר אמצעי אחסון שצוינו מאחד מהם
של Dockerfile כֶּרֶך הוראה או מה סַוָר לָרוּץ -v דגל.
לִרְאוֹת docker-volume-create(1) לקבלת פרטים מלאים.
--כרכים-מאת=[]
הרכב נפחים מהמיכל/ים שצוינו
מעלה נפחים שכבר הורכבו ממיכל מקור על אחר
מְכוֹלָה. עליך לספק את מזהה המכולה של המקור. לשתף
נפח, השתמש ב- --כרכים-מאת אפשרות בעת ריצה
מיכל היעד. אתה יכול לשתף אמצעי אחסון גם אם מכיל המקור
לא רץ.
כברירת מחדל, Docker מעלה את אמצעי האחסון באותו מצב (קריאה-כתיבה או
לקריאה בלבד) כפי שהוא מותקן במיכל המקור. לחלופין, אתה
יכול לשנות זאת על ידי סיומת ה-container-id עם ה- :רו or
:rw מילת מפתח.
אם מיקום עוצמת הקול ממיכל המקור חופף עם
נתונים השוכנים על מיכל יעד, ואז אמצעי האחסון מסתתר
הנתונים האלה על היעד.
-w, --workdir= ""
ספריית עבודה בתוך המכולה
ספריית העבודה המוגדרת כברירת מחדל להפעלת קבצים בינאריים בתוך מיכל היא השורש
ספרייה (/). המפתח יכול להגדיר ברירת מחדל אחרת עם Dockerfile WORKDIR
הוראה. המפעיל יכול לעקוף את ספריית העבודה באמצעות ה- -w אוֹפְּצִיָה.
יציאה מצב
קוד היציאה מ סַוָר לָרוּץ נותן מידע על הסיבה לכך שהמכולה לא הצליחה לפעול או
למה זה יצא. מתי סַוָר לָרוּץ יוצא עם קוד שאינו אפס, קודי היציאה עוקבים אחר ה-
נתח תקן, ראה להלן:
125 if מה היא שגיאה is עם סַוָר דמון עצמו
$ docker run --foo busybox; הד $?
# דגל מסופק אך לא מוגדר: --foo
ראה 'דוקר ריצת --עזרה'.
125
126 if מה היא הכלול הפקודה לא יכול be הופעל
$ docker run busybox /וכו; הד $?
# exec: "/וכו": ההרשאה נדחתה
docker: תגובת שגיאה מדמון: לא ניתן היה להפעיל את הפקודה הכלולה
126
127 if מה היא הכלול הפקודה לא יכול be מצא
$ docker run busybox foo; הד $?
# exec: "foo": קובץ ההפעלה לא נמצא ב-$PATH
docker: תגובת שגיאה מדמון: הפקודה הכלולה לא נמצאה או לא קיימת
127
יציאה קוד of הכלול הפקודה אַחֶרֶת
$ docker run busybox / Bin / sh -c 'יציאה 3'
# 3
דוגמאות
ריצה מכולה in לקריאה בלבד מצב
במהלך פיתוח תמונת קונטיינרים, קונטיינרים צריכים לרוב לכתוב לתוכן התמונה.
התקנת חבילות לתוך / usr, לדוגמה. בייצור, יישומים צריכים לעתים רחוקות
לכתוב לתמונה. יישומי מיכל כותבים לאמצעי אחסון אם הם צריכים לכתוב לקובץ
מערכות בכלל. ניתן להפוך יישומים לאבטחים יותר על ידי הפעלתם במצב קריאה בלבד
באמצעות המתג --קריאה בלבד. זה מגן על תמונת המיכלים מפני שינוי. לקרוא
ייתכן שרק קונטיינרים עדיין יצטרכו לכתוב נתונים זמניים. הדרך הטובה ביותר להתמודד עם זה היא לעשות
הפעל את ספריות tmpfs / לרוץ ו-/tmp.
# docker run --read-only --tmpfs / לרוץ --tmpfs / Tmp -אי -ט פדורה / bin / bash
חשיפה היכנס הודעות החל מ- מה היא מכולה ל מה היא של המארח היכנס
אם אתה רוצה שהודעות שנרשמו במיכל שלך יופיעו אצל המארח
syslog/journal אז אתה צריך bind mount את ספריית /dev/log באופן הבא.
# docker run -v /dev/log:/dev/log -i -t fedora / bin / bash
מתוך הקונטיינר תוכלו לבדוק זאת על ידי שליחת הודעה ליומן.
(bash)# logger "שלום מהמכולה שלי"
לאחר מכן צא ובדוק את היומן.
# יציאה
# journalctl -b | grep שלום
זה אמור לרשום את ההודעה שנשלחה ל-logger.
מצרף ל אחד or יותר החל מ- STDIN, STDOUT, STDERR
אם לא תציין -a אז Docker יצרף את כל מה שתרצה (stdin,stdout,stderr)
אוהב להתחבר במקום זאת, כמו ב:
# docker run -a stdin -a stdout -i -t fedora / bin / bash
שיתוף IPC בֵּין מכולות
שימוש ב-shm_server.c זמין כאן: ⟨https://www.cs.cf.ac.uk/Dave/C/node27.html⟩
בדיקות --ipc=מארח מצב:
המארח מציג קטע זיכרון משותף עם 7 פידים מחוברים, במקרה מ-httpd:
$ sudo ipcs -m
------ פלחי זיכרון משותף --------
הבעלים של מפתח shmid perms bytes status nattch
0x01128e25 0 שורש 600 1000 7
כעת הפעל קונטיינר רגיל, והוא לא רואה כהלכה את קטע הזיכרון המשותף ממנו
המארח:
$ docker run -it shm ipcs -m
------ פלחי זיכרון משותף --------
הבעלים של מפתח shmid perms bytes status nattch
הפעל מיכל עם החדש --ipc=מארח אפשרות, והוא רואה כעת את קטע הזיכרון המשותף
מהמארח httpd:
$ docker run -it --ipc=host shm ipcs -m
------ פלחי זיכרון משותף --------
הבעלים של מפתח shmid perms bytes status nattch
0x01128e25 0 שורש 600 1000 7
בדיקות --ipc=container:CONTAINERID מצב:
התחל מיכל עם תוכנית ליצירת קטע זיכרון משותף:
$ docker run -it shm bash
$ sudo shm/shm_server
$ sudo ipcs -m
------ פלחי זיכרון משותף --------
הבעלים של מפתח shmid perms bytes status nattch
0x0000162e 0 שורש 666 27 1
צור מיכל 2 בצורה נכונה לא מציג קטע זיכרון משותף ממיכל ראשון:
$ docker run shm ipcs -m
------ פלחי זיכרון משותף --------
הבעלים של מפתח shmid perms bytes status nattch
צור קונטיינר שלישי באמצעות האפשרות החדשה --ipc=container:CONTAINERID, כעת הוא מציג את
קטע זיכרון משותף מהראשון:
$ docker run -it --ipc=container:ed735b2264ac shm ipcs -m
$ sudo ipcs -m
------ פלחי זיכרון משותף --------
הבעלים של מפתח shmid perms bytes status nattch
0x0000162e 0 שורש 666 27 1
מקשר מכולות
הערות: סעיף זה מתאר קישור בין קונטיינרים בברירת המחדל (גשר)
רשת, המכונה גם "קישורים מדור קודם". באמצעות --קישור על שימושים ברשתות מוגדרות על ידי המשתמש
הגילוי מבוסס ה-DNS, שאינו מוסיף ערכים ל / Etc / hosts, ואינו קובע
משתני סביבה לגילוי.
תכונת הקישור מאפשרת למספר קונטיינרים לתקשר אחד עם השני. לדוגמה, א
ניתן להפעיל קונטיינר ש-Dockerfile שלו חשף את יציאה 80 וניתן לתת שם כדלקמן:
# docker run --name=link-test -d -i -t fedora/httpd
מיכל שני, במקרה זה הנקרא מקשר, יכול לתקשר עם מיכל httpd,
בשם link-test, על ידי ריצה עם ה- --קישור= :
# docker run -t -i --link=link-test:lt --name=linker fedora / bin / bash
כעת מקשר המיכל מקושר ל-container link-test עם הכינוי lt. מפעיל את
env הפקודה במיכל המקשר מציגה משתני סביבה
עם ההקשר LT (כינוי) (LT_)
# env
HOSTNAME=668231cb0978
TERM=xterm
LT_PORT_80_TCP=tcp://172.17.0.3:80
LT_PORT_80_TCP_PORT=80
LT_PORT_80_TCP_PROTO=tcp
LT_PORT=tcp://172.17.0.3:80
דרך =/ usr / local / sbin:/ usr / local / bin:/ usr / sbin:/ usr / bin:/ sbin:/ סל
PWD=/
LT_NAME=/linker/lt
SHLVL=1
HOME=/
LT_PORT_80_TCP_ADDR=172.17.0.3
_=/usr/bin/env
בעת קישור בין שני קונטיינרים Docker ישתמש ביציאות החשופות של הקונטיינר כדי ליצור א
מנהרה מאובטחת לגישה להורה.
אם קונטיינר מחובר לרשת הגשר המוגדרת כברירת מחדל ו צמוד עם אחרים
מיכלים, ואז של המכולה / Etc / hosts הקובץ מתעדכן עם זה של המכולה המקושרת
שם.
הערות מאז Docker עשוי לעדכן את המכולה / Etc / hosts קובץ, יכול להיות שיש
מצבים שבהם תהליכים בתוך המיכל יכולים בסופו של דבר לקרוא ריק או
לא שלם / Etc / hosts קוֹבֶץ. ברוב המקרים, ניסיון חוזר לקרוא שוב אמור לתקן את
בעיה.
מיפוי נמלים ל חיצוני נוֹהָג
ניתן למפות את היציאה החשופה של אפליקציה ליציאה מארח באמצעות ה- -p דֶגֶל. ל
לדוגמה, ניתן למפות יציאת httpd 80 ליציאת המארח 8080 באמצעות הפעולות הבאות:
# docker run -p 8080:80 -d -i -t fedora/httpd
יוצרים ו הרכבה a נתונים תכולה מכולה
יישומים רבים דורשים שיתוף של נתונים קבועים על פני מספר קונטיינרים. דוקר
מאפשר לך ליצור מיכל נפח נתונים שמכילים אחרים יכולים לעלות ממנו. ל
לדוגמה, צור מיכל בעל שם המכיל ספריות /var/volume1 ו-/tmp/volume2.
התמונה תצטרך להכיל את הספריות האלה, אז כמה הוראות RUN mkdir
ייתכן שתידרש עבורך תמונת fedora-data:
# docker run --name=data -v /var/volume1 -v /tmp/volume2 -i -t fedora-data true
# docker run --volumes-from=data --name=fedora-container1 -i -t fedora bash
פרמטרים מרובים --volumes-from יביאו יחד מספר נפחי נתונים ממספר רב
מיכלים. ואפשר להרכיב את הנפחים שהגיעו ממיכל ה-DATA פנימה
מיכל נוסף דרך מיכל המתווך fedora-container1, המאפשר
הפשט את מקור הנתונים בפועל ממשתמשים של נתונים אלה:
# docker run --volumes-from=fedora-container1 --name=fedora-container2 -i -t פדורה bash
הרכבה חיצוני כרכים
כדי לטעון ספריית מארח כאמצעי אחסון, ציין את הנתיב המוחלט ל-
ספרייה והנתיב המוחלט עבור ספריית המכולה מופרדים בנקודתיים:
# docker run -v /var/db:/data1 -i -t fedora bash
בעת שימוש ב-SELinux, שים לב שלמארח אין ידע במדיניות SELinux של מיכל.
לכן, בדוגמה לעיל, אם מדיניות SELinux נאכפת, ה /var/db הספרייה היא
לא ניתן לכתיבה למיכל. תופיע הודעת "הרשאה נדחתה" והודעה avc:
הודעה ב-syslog של המארח.
כדי לעקוף זאת, בזמן כתיבת דף האיש הזה, הפקודה הבאה צריכה להיות
הפעל על מנת שתווית סוג המדיניות המתאימה של SELinux תוצמד למארח
Directory:
# chcon -Rt svirt_sandbox_file_t /var/db
כעת, כתיבה לאמצעי האחסון /data1 במיכל תתאפשר והשינויים יהיו
ישתקף גם על המארח ב-/var/db.
שימוש חלופה אבטחה תיוג
אתה יכול לעקוף את ערכת ברירת המחדל של תיוג עבור כל מיכל על ידי ציון ה
---Security-opt דֶגֶל. לדוגמה, אתה יכול לציין את רמת MCS/MLS, דרישה עבור MLS
מערכות. ציון הרמה בפקודה הבאה מאפשר לך לשתף אותו
תוכן בין מיכלים.
# docker run --security-opt label:level:s0:c100,c200 -i -t fedora bash
דוגמה ל-MLS עשויה להיות:
# docker run --security-opt label:level:TopSecret -i -t rhel7 bash
כדי להשבית את תיוג האבטחה עבור מיכל זה לעומת ריצה עם --מַתִיר
דגל, השתמש בפקודה הבאה:
# docker run --security-opt label:disable -i -t fedora bash
אם אתה רוצה מדיניות אבטחה מחמירה יותר על התהליכים בתוך קונטיינר, אתה יכול לציין
סוג חלופי עבור המכולה. אתה יכול להפעיל מיכל שמותר לו רק
האזן ביציאות Apache על ידי ביצוע הפקודה הבאה:
# docker run --security-opt label:type:svirt_apache_t -i -t centos bash
הערה:
תצטרך לכתוב מדיניות המגדירה את א svirt_apache_t הקלד.
הגדרת מכשיר מִשׁקָל
אם אתה רוצה להגדיר / dev / sda משקל המכשיר ל 200, אתה יכול לציין את משקל המכשיר לפי
--blkio-weight-device דֶגֶל. השתמש בפקודה הבאה:
# docker run -it --blkio-weight-device "/dev/sda:200" ubuntu
לפרט בדידות טֶכנוֹלוֹגִיָה ל מכולה (--בידוד)
אפשרות זו שימושית במצבים שבהם אתה מריץ קונטיינרים של Docker ב-Microsoft
חלונות. ה --בידוד אפשרות מגדירה את טכנולוגיית הבידוד של מיכל. בלינוקס,
הנתמכת היחידה היא ברירת מחדל אפשרות המשתמשת במרחבי שמות של לינוקס. שתי הפקודות הללו
מקבילים בלינוקס:
$ docker run -d busybox top
$ docker run -d --isolation ברירת המחדל של busybox top
ב-Microsoft Windows, יכול לקחת כל אחד מהערכים הבאים:
· ברירת מחדל: השתמש בערך שצוין על ידי ה-Docker daemon --exec-opt . אם דמון עושה
לא לציין טכנולוגיית בידוד, משתמשת Microsoft Windows תהליך כברירת המחדל שלו
ערך.
· תהליך: בידוד מרחב שמות בלבד.
· hyperv: בידוד מבוסס מחיצות Hyper-V hypervisor.
בפועל, כאשר פועל על Microsoft Windows ללא a דמון סט אפשרויות, שני אלה
הפקודות שוות ערך:
$ docker run -d --isolation ברירת המחדל של busybox top
$ docker run -d -- תהליך בידוד busybox top
אם הגדרת את --exec-opt isolation=hyperv אפשרות ב-Docker דמון, כל אחד מאלה
גם פקודות מובילות hyperv בידוד:
$ docker run -d --isolation ברירת המחדל של busybox top
$ docker run -d --isolation hyperv busybox top
הִיסטוֹרִיָה
אפריל 2014, חובר במקור על ידי ויליאם הנרי (כאשר נכתב ב-redhat dot com) על סמך
חומר מקור של docker.com ועבודה פנימית. יוני 2014, עודכן על ידי Sven Dowideit
⟨[מוגן בדוא"ל]⟩ יולי 2014, עודכן על ידי Sven Dowideit ⟨[מוגן בדוא"ל]⟩
נובמבר 2015, עודכן על ידי סאלי אומאלי ⟨[מוגן בדוא"ל]⟩
השתמש ב-Docker-Run באינטרנט באמצעות שירותי onworks.net
