5 פּראָסט סענס פּרינסאַפּאַלז פֿאַר בילדינג קלאָוד-געבוירן אַפּפּס

"וואָלקן געבוירן" אָדער פשוט "וואָלקן" אַפּלאַקיישאַנז זענען באשאפן ספּאַסיפיקלי צו אַרבעטן אין וואָלקן ינפראַסטראַקטשער. זיי זענען טיפּיקלי געבויט ווי אַ סכום פון לוסלי קאַפּאַלד מיקראָ באַדינונגס פּאַקידזשד אין קאַנטיינערז, וואָס אין קער זענען געראטן דורך אַ וואָלקן פּלאַטפאָרמע. אַזאַ אַפּלאַקיישאַנז זענען צוגעגרייט פֿאַר פייליערז דורך פעליקייַט, וואָס מיטל אַז זיי אַרבעטן רילייאַבלי און וואָג אפילו אין פאַל פון ערנסט ינפראַסטראַקטשער פייליערז. די אנדערע זייַט פון די מאַטבייע איז די שטעלט פון ריסטריקשאַנז (קאָנטראַקץ) וואָס די וואָלקן פּלאַטפאָרמע ימפּאָוזאַז אויף קאַנטיינער אַפּלאַקיישאַנז אין סדר צו קענען צו פירן זיי אויטאָמאַטיש.

כאָטש זיי זענען גאָר אַווער פון די נויט און וויכטיקייט פון מאַך צו וואָלקן-באזירט אַפּלאַקיישאַנז, פילע אָרגאַנאַזיישאַנז נאָך טאָן ניט וויסן ווו צו אָנהייבן. אין דעם פּאָסטן, מיר וועלן קוקן אין אַ נומער פון פּרינסאַפּאַלז וואָס, אויב איר נאָכפאָלגן ווען דעוועלאָפּינג קאַנטיינערז אַפּלאַקיישאַנז, לאָזן איר צו פאַרשטיין די פּאָטענציעל פון וואָלקן פּלאַטפאָרמס און דערגרייכן פאַרלאָזלעך אָפּעראַציע און סקיילינג פון אַפּלאַקיישאַנז אפילו אין פאַל פון ערנסט פייליערז אין די IT ינפראַסטראַקטשער. מדרגה. די לעצט ציל פון די פּרינסאַפּאַלז אַוטליינד דאָ איז צו לערנען ווי צו בויען אַפּלאַקיישאַנז וואָס קענען זיין אויטאָמאַטיש געראטן דורך וואָלקן פּלאַטפאָרמס אַזאַ ווי Kubernetes.

ווייכווארג פּלאַן פּרינסיפּלעס

אין דער פּראָגראַממינג וועלט, פּרינסאַפּאַלז אָפּשיקן צו גאַנץ גענעראַל כּללים וואָס מוזן זיין נאכגעגאנגען ווען דעוועלאָפּינג ווייכווארג. זיי קענען זיין געוויינט ווען איר אַרבעט מיט קיין פּראָגראַממינג שפּראַך. יעדער פּרינציפּ האט זיין אייגענע צילן, די מכשירים פֿאַר דערגרייכן וואָס זענען יוזשאַוואַלי טעמפּלאַטעס און פּראַקטיסיז. עס זענען אויך אַ נומער פון פונדאַמענטאַל פּרינסאַפּאַלז פֿאַר קריייטינג הויך-קוואַליטעט ווייכווארג, פֿון וואָס אַלע אנדערע לויפן. דאָ זענען עטלעכע ביישפילן פון פונדאַמענטאַל פּרינסאַפּאַלז:

• קוש (האַלטן עס פּשוט, נאַריש) - טאָן ניט קאָמפּליצירן עס;
• טרוקן (דו זאלסט נישט איבערחזרן זיך) - טאָן ניט איבערחזרן זיך;
• יאַגני (איר וועט ניט דאַרפֿן עס) - טאָן ניט מאַכן עפּעס וואָס איז נישט מיד דארף;
• סאָק צעשיידונג פון קאַנסערנז - ייַנטיילן ריספּאַנסאַבילאַטיז.

ווי איר קענען זען, די פּרינסאַפּאַלז טאָן ניט שטעלן קיין ספּעציפיש כּללים, אָבער געהערן צו דער קאַטעגאָריע פון ​​אַזוי-גערופן סייכל קאַנסידעריישאַנז באזירט אויף פּראַקטיש דערפאַרונג, וואָס זענען שערד דורך פילע דעוועלאָפּערס און צו וואָס זיי קעסיידער אָפּשיקן.
אין דערצו, עס איז SOLID - א סכום פון די ערשטע פינף פּרינסאַפּאַלז פון כייפעץ-אָריענטיד פּראָגראַממינג און פּלאַן, פאָרמולאַטעד דורך ראבערט מארטין. SOLID ינקלודז ברייט, אָפֿן-געענדיקט, קאַמפּלאַמענטשי פּרינסאַפּאַלז אַז - ווען געווענדט צוזאַמען - העלפֿן צו שאַפֿן בעסער ווייכווארג סיסטעמען און בעסער האַלטן זיי איבער די לאַנג טערמין.

די SOLID פּרינציפּן געהערן צו די פעלד פון OOP און זענען פארמולירט אין די שפּראַך פון אַזאַ קאַנסעפּס און קאַנסעפּס ווי קלאסן, ינטערפייסיז און ירושה. לויט אַנאַלאַדזשי, אַנטוויקלונג פּרינסאַפּאַלז קענען אויך זיין פארמולירט פֿאַר וואָלקן אַפּלאַקיישאַנז, בלויז די יקערדיק עלעמענט דאָ וועט נישט זיין אַ קלאַס, אָבער אַ קאַנטיינער. דורך נאָכפאָלגן די פּרינסאַפּאַלז, איר קענען מאַכן קאַנטאַמאַנייזד אַפּלאַקיישאַנז וואָס בעסער טרעפן די גאָולז און אַבדזשעקטיווז פון וואָלקן פּלאַטפאָרמס ווי Kubernetes.

קלאָוד-געבוירן קאַנטיינערז: די רעד האַט צוגאַנג

הייַנט, כּמעט קיין אַפּלאַקיישאַן קענען זיין פּאַקידזשד לעפיערעך לייכט אין קאַנטיינערז. אָבער פֿאַר אַפּלאַקיישאַנז צו זיין יפעקטיוולי אָטאַמייטיד און אָרקעסטרייטיד אין אַ וואָלקן פּלאַטפאָרמע ווי Kubernetes, נאָך מי איז פארלאנגט.
די יקער פֿאַר די געדאנקען אַוטליינד אונטן איז געווען די מעטאַדאַלאַדזשי די צוועלף-פאַקטאָר אַפּ און פילע אנדערע אַרבעט אויף פאַרשידן אַספּעקץ פון בנין וועב אַפּלאַקיישאַנז, פֿון מקור קאָד פאַרוואַלטונג צו סקיילינג מאָדעלס. די פּרינסאַפּאַלז דיסקרייבד אַפּלייז בלויז צו דער אַנטוויקלונג פון קאַנטיינערז אַפּלאַקיישאַנז וואָס זענען געבויט אויף שפּיץ פון מיקראָסערוויסעס און דיזיינד פֿאַר וואָלקן פּלאַטפאָרמס אַזאַ ווי Kubernetes. די גרונט עלעמענט אין אונדזער דיסקוסיע איז די קאַנטיינער בילד, און דער ציל קאַנטיינער רונטימע איז די קאַנטיינער אָרקעסטראַטיאָן פּלאַטפאָרמע. דער ציל פון די פארגעלייגט פּרינסאַפּאַלז איז צו שאַפֿן קאַנטיינערז פֿאַר וואָס סקעדזשולינג, סקיילינג און מאָניטאָרינג טאַסקס קענען זיין אָטאַמייטיד אויף רובֿ אָרקעסטראַטיאָן פּלאַטפאָרמס. די פּרינסאַפּאַלז זענען דערלאנגט אין קיין באַזונדער סדר.

איין דייַגע פּרינציפּ (SCP)

דער פּרינציפּ איז אין פילע וועגן ענלעך צו די איין פֿאַראַנטוואָרטלעכקייט פּרינציפּ. SRP), וואָס איז טייל פון די SOLID סעט און זאגט אַז יעדער כייפעץ מוזן האָבן איין פֿאַראַנטוואָרטלעכקייט, און די פֿאַראַנטוואָרטלעכקייט מוזן זיין גאָר ענקאַפּסאַלייטיד אין אַ קלאַס. די פונט פון SRP איז אַז יעדער פֿאַראַנטוואָרטלעכקייט איז אַ סיבה פֿאַר ענדערונג, און אַ קלאַס מוזן האָבן איין און בלויז איין סיבה פֿאַר טוישן.

אין SCP, מיר נוצן די וואָרט "זייַגע" אַנשטאָט פון די וואָרט "פֿאַראַנטוואָרטלעכקייט" צו אָנווייַזן די העכער מדרגה פון אַבסטראַקציע און אַ ברייטערער ציל פון אַ קאַנטיינער קאַמפּערד מיט אַן OOP קלאַס. און אויב דער ציל פון SRP איז בלויז איין סיבה פֿאַר ענדערונג, הינטער SCP איז דער פאַרלאַנג צו יקספּאַנד די פיייקייט צו רייוס און פאַרבייַטן קאַנטיינערז. דורך נאָכפאָלגן די SRP און שאַפֿן אַ קאַנטיינער וואָס סאַלווז אַ איין פּראָבלעם און טאָן דאָס אין אַ פאַנגקשאַנאַלי גאַנץ וועג, איר פאַרגרעסערן די גיכער פון ריוזינג דעם קאַנטיינער בילד אין פאַרשידענע אַפּלאַקיישאַן קאַנטעקסץ.

דער SCP פּרינציפּ זאגט אַז יעדער קאַנטיינער זאָל סאָלווע איין פּראָבלעם און טאָן דאָס געזונט. דערצו, SCP אין דער קאַנטיינער וועלט איז גרינגער צו דערגרייכן ווי SRP אין די OOP וועלט, ווייַל קאַנטיינערז יוזשאַוואַלי לויפן איין פּראָצעס, און רובֿ פון די צייט דעם פּראָצעס סאַלווז איין אַרבעט.

אויב עטלעכע קאַנטיינער מיקראָסערוויס מוזן סאָלווע עטלעכע פראבלעמען אין אַמאָל, עס קענען זיין צעטיילט אין איין-אַרבעט קאַנטיינערז און קאַמביינד אין איין פּאָד (אַ אַפּאַראַט פון קאַנטיינער פּלאַטפאָרמע דיפּלוימאַנט) ניצן סיידקאַר און יניט קאַנטיינער טעמפּלאַטעס. אין אַדישאַן, SCP מאכט עס גרינג צו פאַרבייַטן אַן אַלט קאַנטיינער (אַזאַ ווי אַ וועב סערווער אָדער אָנזאָג מעקלער) מיט אַ נייַע וואָס סאַלווז די זעלבע פּראָבלעם אָבער האט יקספּאַנדיד פאַנגקשאַנאַליטי אָדער וואָג בעסער.

הויך אָבסערוואַביליטי פּרינציפּ (HOP)

ווען קאַנטיינערז זענען געניצט ווי אַ יונאַפייד וועג צו פּעקל און לויפן אַפּלאַקיישאַנז, די אַפּלאַקיישאַנז זיך זענען באהאנדלט ווי אַ שוואַרץ קעסטל. אָבער, אויב דאָס זענען וואָלקן קאַנטיינערז, זיי מוזן צושטעלן ספּעציעל אַפּיס צו די רונטימע צו מאָניטאָר די געזונט פון די קאַנטיינערז און, אויב נייטיק, נעמען צונעמען קאַמף. אָן דעם, עס וועט ניט זיין מעגלעך צו פאַרייניקן די אָטאַמיישאַן פון אַפּדייטינג קאַנטיינערז און אָנפירונג זייער לעבן ציקל, וואָס, אין קער, וועט פאַרערגערן די פעסטקייַט און וסאַביליטי פון די ווייכווארג סיסטעם.

אין פיר, אַ קאַנטיינערייזד אַפּלאַקיישאַן זאָל, אין אַ מינימום, האָבן אַ אַפּי פֿאַר פאַרשידן טייפּס פון געזונט טשעקס: לעבן טעסץ און גרייטקייַט טעסץ. אויב אַ אַפּלאַקיישאַן קליימז צו טאָן מער, עס מוזן צושטעלן אנדערע מיטלען צו מאָניטאָר זייַן שטאַט. פֿאַר בייַשפּיל, לאָגינג וויכטיק געשעענישן דורך STDERR און STDOUT פֿאַר קלאָץ אַגגרעגאַטיאָן ניצן Fluentd, Logstash און אנדערע ענלעך מכשירים. ווי געזונט ווי ינטאַגריישאַן מיט טרייסינג און מעטריק זאַמלונג לייברעריז, אַזאַ ווי OpenTracing, Prometheus, עטק.

אין אַלגעמיין, די אַפּלאַקיישאַן קענען נאָך זיין באהאנדלט ווי אַ שוואַרץ קעסטל, אָבער עס מוזן זיין צוגעשטעלט מיט אַלע די אַפּיס וואָס די פּלאַטפאָרמע דאַרף צו מאָניטאָר און פירן עס אין דער בעסטער מעגלעך וועג.

לעבן-ציקל קאַנפאָרמאַנס פּרינציפּ (LCP)

LCP איז די אַנטיטהעסיס פון HOP. בשעת HOP זאגט אַז דער קאַנטיינער מוזן ויסשטעלן לייענען אַפּיס צו דער פּלאַטפאָרמע, LCP ריקווייערז די אַפּלאַקיישאַן צו קענען צו אָננעמען אינפֿאָרמאַציע פֿון דער פּלאַטפאָרמע. דערצו, דער קאַנטיינער מוזן נישט בלויז באַקומען געשעענישן, אָבער אויך אַדאַפּט זיך, אין אנדערע ווערטער, רעאַגירן צו זיי. דערפאר דער נאָמען פון דעם פּרינציפּ, וואָס קענען זיין באטראכט ווי אַ פאָדערונג צו צושטעלן די פּלאַטפאָרמע מיט שרייבן אַפּיס.

פּלאַטפאָרמס האָבן פאַרשידענע טייפּס פון געשעענישן צו פירן די לייפסייק פון אַ קאַנטיינער. אבער עס איז צו די אַפּלאַקיישאַן זיך צו באַשליסן וואָס פון זיי צו זען און ווי צו רעאַגירן.

עס איז קלאָר אַז עטלעכע געשעענישן זענען מער וויכטיק ווי אנדערע. פֿאַר בייַשפּיל, אויב אַ אַפּלאַקיישאַן טוט נישט דערלאָזן קראַשיז געזונט, עס מוזן אָננעמען סיגנאַל: פאַרענדיקן (SIGTERM) אַרטיקלען און אָנהייבן זייַן טערמאַניישאַן רוטין ווי געשווינד ווי מעגלעך צו כאַפּן דעם סיגנאַל: טייטן (SIGKILL) וואָס קומט נאָך SIGTERM.

אַדדיטיאָנאַללי, events אַזאַ ווי PostStart און PreStop קענען זיין וויכטיק פֿאַר די לייפסייק פון אַ אַפּלאַקיישאַן. פֿאַר בייַשפּיל, נאָך לאָנטשינג אַ אַפּלאַקיישאַן, עס קען דאַרפן עטלעכע וואַרעם-אַרויף צייט איידער עס קענען ריספּאַנד צו ריקוועס. אָדער די אַפּלאַקיישאַן מוזן מעלדונג רעסורסן אין אַ ספּעציעל וועג ווען איר פאַרמאַכן אַראָפּ.

די בילד יממוטאַביליטי פּרינציפּ (IIP)

עס איז בכלל אנגענומען אַז קאַנטיינערז אַפּלאַקיישאַנז זאָל בלייַבן אַנטשיינדזשד נאָך געבויט, אפילו אויב זיי זענען לויפן אין פאַרשידענע ינווייראַנמאַנץ. דאָס דאַרף די נויטיק צו פונדרויסנדיק דאַטן סטאָרידזש ביי רונטימע (אין אנדערע ווערטער, צו נוצן פונדרויסנדיק מכשירים פֿאַר דעם) און צו פאַרלאָזנ זיך פונדרויסנדיק, רונטימע-ספּעציפיש קאַנפיגיעריישאַנז, אלא ווי מאָדיפיצירן אָדער שאַפֿן יינציק קאַנטיינערז פֿאַר יעדער סוויווע. נאָך קיין ענדערונגען צו די אַפּלאַקיישאַן, די קאַנטיינער בילד מוזן זיין ריבילט און דיפּלויד אין אַלע ינווייראַנמאַנץ. דורך דעם וועג, ווען אָנפירונג עס סיסטעמען, אַ ענלעך פּרינציפּ איז געניצט, באקאנט ווי דער פּרינציפּ פון ימיוטאַביליטי פון סערווערס און ינפראַסטראַקטשער.

דער ציל פון IIP איז צו פאַרמייַדן די שאַפונג פון באַזונדער קאַנטיינער בילדער פֿאַר פאַרשידענע רונטימע ינווייראַנמאַנץ און צו נוצן די זעלבע בילד אומעטום צוזאמען מיט די צונעמען סוויווע-ספּעציפיש קאַנפיגיעריישאַן. לויט דעם פּרינציפּ, איר קענען ינסטרומענט אַזאַ וויכטיק פּראַקטיסיז פֿון די פונט פון מיינונג פון וואָלקן סיסטעמען אָטאַמיישאַן ווי צוריק און פאָרויס פון אַפּלאַקיישאַן דערהייַנטיקונגען.

פּראָצעס דיספּאָוזאַביליטי פּרינציפּ (PDP)

איינער פון די מערסט וויכטיק קעראַקטעריסטיקס פון אַ קאַנטיינער איז זייַן עפעמעראַליטי: אַ בייַשפּיל פון אַ קאַנטיינער איז גרינג צו שאַפֿן און גרינג צו צעשטערן, אַזוי עס קענען זיין לייכט ריפּלייסט מיט אן אנדער בייַשפּיל אין קיין צייט. עס קענען זיין פילע סיבות פֿאַר אַזאַ אַ פאַרבייַט: דורכפאַל פון אַ סערוויסאַביליטי פּרובירן, סקיילינג פון די אַפּלאַקיישאַן, אַריבערפירן צו אן אנדער באַלעבאָס, יגזאָסטשאַן פון פּלאַטפאָרמע רעסורסן אָדער אנדערע סיטואַטיאָנס.

ווי אַ קאַנסאַקוואַנס, קאַנטיינערייזד אַפּלאַקיישאַנז מוזן האַלטן זייער שטאַט מיט עטלעכע פונדרויסנדיק מיטלען, אָדער נוצן ינערלעך פונאנדערגעטיילט סקימז מיט יבעריקייַט פֿאַר דעם. אין אַדישאַן, די אַפּלאַקיישאַן מוזן אָנהייבן געשווינד און געשווינד פאַרמאַכן, און זיין צוגעגרייט פֿאַר פּלוצעמדיק פאַטאַל ייַזנוואַרג דורכפאַל.

איין פיר וואָס העלפּס ינסטרומענט דעם פּרינציפּ איז צו האַלטן קליין קאַנטיינערז. קלאָוד ינווייראַנמאַנץ קענען אויטאָמאַטיש אויסקלייַבן אַ באַלעבאָס צו קאַטער אַ קאַנטיינער בייַשפּיל אויף, אַזוי די קלענערער די קאַנטיינער, די פאַסטער עס וועט אָנהייבן - עס וועט פשוט נאָכמאַכן צו די ציל באַלעבאָס איבער די נעץ פאַסטער.

זעלבסט-קאַנטיינמאַנט פּרינציפּ (S-CP)

לויט דעם פּרינציפּ, אין דער פֿאַרזאַמלונג בינע, אַלע נייטיק קאַמפּאָונאַנץ זענען אַרייַנגערעכנט אין דעם קאַנטיינער. דער קאַנטיינער זאָל זיין געבויט אויף די האַשאָרע אַז די סיסטעם בלויז האט אַ ריין לינוקס קערן, אַזוי אַלע די נויטיק נאָך לייברעריז זאָל זיין געשטעלט אין דעם קאַנטיינער זיך. עס זאָל אויך אַנטהאַלטן זאכן ווי די רונטימע פֿאַר די קאָראַספּאַנדינג פּראָגראַממינג שפּראַך, די אַפּלאַקיישאַן פּלאַטפאָרמע (אויב נייטיק) און אנדערע דיפּענדאַנסיז וואָס וועט זיין פארלאנגט בשעת די קאַנטיינער אַפּלאַקיישאַן איז פליסנדיק.

אויסנעמען זענען געמאכט פֿאַר קאַנפיגיעריישאַנז וואָס בייַטן פון סוויווע צו סוויווע און מוזן זיין צוגעשטעלט ביי רונטימע, למשל דורך אַ Kubernetes ConfigMap.

אַ אַפּלאַקיישאַן קען אַנטהאַלטן עטלעכע קאַנטיינערז קאַמפּאָונאַנץ, למשל, אַ באַזונדער DBMS קאַנטיינער אין אַ קאַנטיינערייזד וועב אַפּלאַקיישאַן. לויט די S-CP פּרינציפּ, די קאַנטיינערז זאָל ניט זיין קאַמביינד אין איין, אָבער זאָל זיין געמאכט אַזוי אַז די DBMS קאַנטיינער כּולל אַלץ נייטיק פֿאַר די אָפּעראַציע פון ​​​​די דאַטאַבייס, און די וועב אַפּלאַקיישאַן קאַנטיינער כּולל אַלץ נייטיק פֿאַר די אָפּעראַציע פון ​​​​די וועב. אַפּלאַקיישאַן, דער זעלביקער וועב סערווער. ווי אַ רעזולטאַט, די וועב אַפּלאַקיישאַן קאַנטיינער אין רונטימע וועט אָפענגען אויף די DBMS קאַנטיינער און אַקסעס עס ווי דארף.

רונטימע קאַנפיינמאַנט פּרינציפּ (RCP)

דער S-CP פּרינציפּ דיפיינז ווי דער קאַנטיינער זאָל זיין געבויט און וואָס די בילד ביינערי זאָל אַנטהאַלטן. אבער אַ קאַנטיינער איז נישט בלויז אַ "שוואַרץ קעסטל" וואָס האט בלויז איין כאַראַקטעריסטיש - טעקע גרייס. בעשאַס דורכפירונג, דער קאַנטיינער נעמט אנדערע דימענשאַנז: די סומע פון ​​​​גענוצט זכּרון, קפּו צייט און אנדערע סיסטעם רעסורסן.

און דאָ די RCP פּרינציפּ קומט אין האַנטיק, לויט וואָס דער קאַנטיינער מוזן דעקאַפּיט זיין רעקווירעמענץ פֿאַר סיסטעם רעסורסן און אַריבערפירן זיי צו דער פּלאַטפאָרמע. מיט די מיטל פּראָופיילז פון יעדער קאַנטיינער (ווי פיל קפּו, זיקאָרן, נעץ און דיסק רעסורסן עס דאַרף), די פּלאַטפאָרמע קענען אָפּטימאַללי דורכפירן סקעדזשולינג און אַוטאָסקאַלינג, פירן IT קאַפּאַציטעט און האַלטן SLA לעוועלס פֿאַר קאַנטיינערז.

אין אַדישאַן צו טרעפן די מיטל רעקווירעמענץ פון דעם קאַנטיינער, עס איז אויך וויכטיק אַז די אַפּלאַקיישאַן זאָל נישט גיין ווייַטער פון זיין אייגענע באַונדריז. אַנדערש, ווען אַ מיטל דוחק אַקערז, די פּלאַטפאָרמע איז מער מסתּמא צו אַרייַננעמען עס אין דער רשימה פון אַפּלאַקיישאַנז וואָס דאַרפֿן צו זיין טערמאַנייטיד אָדער מיגרייטיד.

ווען מיר רעדן וועגן זיין וואָלקן-ערשטער, מיר רעדן וועגן די וועג מיר אַרבעטן.
אויבן, מיר פארמולירט אַ נומער פון גענעראַל פּרינסאַפּאַלז וואָס שטעלן די מעטאַדאַלאַדזשיקאַל יסוד פֿאַר בנין הויך-קוואַליטעט קאַנטיינער אַפּלאַקיישאַנז פֿאַר וואָלקן ינווייראַנמאַנץ.

באַמערקונג אַז אין אַדישאַן צו די אַלגעמיינע פּרינסאַפּאַלז, איר וועט אויך דאַרפֿן נאָך אַוואַנסירטע מעטהאָדס און טעקניקס פֿאַר ארבעטן מיט קאַנטיינערז. אין אַדישאַן, מיר האָבן אַ ביסל קורץ רעקאַמאַנדיישאַנז וואָס זענען מער ספּעציפיש און זאָל זיין געווענדט (אָדער ניט געווענדט) דיפּענדינג אויף די סיטואַציע:

• פּרוּווט צו רעדוצירן די גרייס פון בילדער: ויסמעקן צייטווייליגע טעקעס און טאָן ניט ינסטאַלירן ומנייטיק פּאַקאַדזשאַז - די קלענערער די קאַנטיינער גרייס, די פאַסטער עס איז פארזאמלט און קאַפּיד צו די ציל באַלעבאָס איבער די נעץ.
• פאָקוס אויף אַרביטראַריש באַניצער-ידס: טאָן ניט נוצן די סודאָ באַפֿעל אָדער קיין ספּעציעל באַניצעריד צו קאַטער דיין קאַנטיינערז.
• צייכן וויכטיק פּאָרץ: איר קענען שטעלן פּאָרט נומערן אין רונטימע, אָבער עס איז בעסער צו ספּעציפיצירן זיי מיט די EXPOSE באַפֿעל - דאָס וועט מאַכן עס גרינגער פֿאַר אנדערע מענטשן און מגילה צו נוצן דיין בילדער.
• סטאָר פּערסיסטענט דאַטן אויף וואַליומז: די דאַטן וואָס זאָל בלייַבן נאָך די צעבראכן קאַנטיינער זאָל זיין געשריבן צו וואַליומז.
• שרייב בילד מעטאַדאַטאַ: טאַגס, לאַבעלס און אַנאַטיישאַנז מאַכן בילדער גרינגער צו נוצן - אנדערע דעוועלאָפּערס וועלן דאַנקען איר.
• סינגקראַנייז באַלעבאָס און בילדער: עטלעכע קאַנטיינערז אַפּלאַקיישאַנז דאַרפן די קאַנטיינער צו סינק מיט דער באַלעבאָס אויף זיכער אַטריביוץ, אַזאַ ווי צייט אָדער מאַשין שייַן.
• אין מסקנא, מיר טיילן טעמפּלאַטעס און בעסטער פּראַקטיסיז וואָס וועט העלפֿן איר מער יפעקטיוולי ינסטרומענט די פּרינסאַפּאַלז ליסטעד אויבן:
  www.slideshare.net/luebken/container-patterns
  docs.docker.com/engine/userguide/eng-image/dockerple_best-practices
  docs.projectatomic.io/container-best-practices
  docs.openshift.com/enterprise/3.0/creating_images/guidelines.html
  www.usenix.org/system/files/conference/hotcloud16/hotcloud16_burns.pdf
  leanpub.com/k8spatterns
  12factor.net

וועבינאַר אויף די נייַע ווערסיע פון ​​​​OpenShift Container Platform - 4
יוני 11 בייַ 11.00

וואָס וועט איר לערנען:

• Immutable Red Hat Enterprise Linux CoreOS
• OpenShift סערוויס מעש
• אָפּעראַטאָר פריימווערק
• קנאַטיווע פריימווערק

מקור: www.habr.com