רעקווירעמענץ פֿאַר דעוועלאָפּינג אַ אַפּלאַקיישאַן אין Kubernetes

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

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

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

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

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

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

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

ווייַל, אין אַלגעמיין, די אינפֿאָרמאַציע איז "ctrl+c, ctrl+v", פֿון צווישן אנדערע זאכן, אונדזער וויקי אין די DevOps אָפּטיילונג, ווו מיר האָבן געשריבן רעקווירעמענץ פֿאַר דעוועלאָפּערס: "יויס, אַזוי אַז מיר קאַטער דיין אַפּלאַקיישאַן אין קובערנעטעס, עס זאָל זיין אַזוי."

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

וואָס מיר וועלן איצט קוקן אין:

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

לאָגס

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

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

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

עס טורנס אויס אַז אויב מיר רעדן וועגן Kubernetes, די רעכט אָרט צו שרייַבן לאָגס ערגעץ פֿון אַ דאָקקער קאַנטיינער איז פשוט צו שרייַבן זיי פֿון די אַפּלאַקיישאַן צו די אַזוי גערופענע סטדאָוט / סטדערר, דאָס איז די נאָרמאַל רעזולטאַט סטרימז פון די אָפּערייטינג סיסטעם, דער נאָרמאַל טעות רעזולטאַט. דאָס איז די מערסט ריכטיק, סימפּלאַסט און מערסט לאַדזשיקאַל וועג צו שטעלן לאָגס אין פּרינציפּ אין דאָקקער און ספּאַסיפיקלי אין Kubernetis. ווייַל אויב דיין אַפּלאַקיישאַן שרייבט לאָגס צו Stdout / Stderr, עס איז צו Docker און די Kubernetes אַדישאַן צו באַשליסן וואָס צו טאָן מיט די לאָגס. דאָקער וועט דורך פעליקייַט בויען זייַן ספּעציעל טעקעס אין JSON פֿאָרמאַט.

דאָ די קשיא ערייזאַז, וואָס וועט איר טאָן ווייַטער מיט די לאָגס? די יזיאַסט וועג איז קלאָר, מיר האָבן די פיייקייט צו טאָן kubectl logs און קוק אין די לאָגס פון די "פּאָדס". אָבער, מיסטאָמע, דאָס איז נישט אַ זייער גוט אָפּציע - עפּעס אַנדערש דאַרף זיין געטאן מיט די לאָגס.

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

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

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

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

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

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

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

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

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

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

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

קאָנפיגוראַטיאָן

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

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

און די זאַך - מיר געוויינט עס פריער, עס איז נאָר געווארן ספּעציעל פאָלקס מיט די אַדווענט פון קאַנטיינערז - די זאַך איז גערופֿן ENV (ענוויראָנמענט) וועריאַבאַלז, דאָס איז ינווייראַנמענאַל וועריאַבאַלז וואָס זענען אין דיין אָפּערייטינג סיסטעם. דאָס איז בכלל אַן אידעאל וועג צו קאַנפיגיער דיין אַפּלאַקיישאַן, ווייַל אויב איר האָבן אַפּלאַקיישאַנז אין JAVA, Python, Go, Perl, און זיי קענען אַלע לייענען די דייטאַבייס באַלעבאָס, דאַטאַבייס באַניצער, דאַטאַבייס פּאַראָל וועריאַבאַלז, דאָס איז ידעאַל. איר האָבן אַפּלאַקיישאַנז אין פיר פאַרשידענע שפּראַכן קאַנפיגיערד אין די דאַטאַבייס פּלאַן אין דער זעלביקער וועג. עס זענען ניט מער פאַרשידענע קאַנפיגיעריישאַנז.

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

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

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

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

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

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

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

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

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

געזונט טשעק

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

ווען איר אַקסעס דעם URL, אַקאָרדינגלי, אונדזער אַפּלאַקיישאַן זאגט אָדער "יאָ, אָוקיי, אַלץ איז גוט מיט מיר, 200" אָדער "ניין, אַלץ איז נישט גוט מיט מיר, עטלעכע 500." אַקקאָרדינגלי, אויב אונדזער אַפּלאַקיישאַן איז נישט http, ניט אַ וועב אַפּלאַקיישאַן, מיר זענען איצט גערעדט וועגן אַ מין פון דיימאַן, מיר קענען געפֿינען אויס ווי צו טאָן געזונט טשעקס. דאָס איז, עס איז ניט נייטיק, אויב די אַפּלאַקיישאַן איז נישט http, אַלץ אַרבעט אָן אַ געזונט טשעק און דאָס קען נישט זיין געטאן אין קיין וועג. איר קענען פּיריאַדיקלי דערהייַנטיקן עטלעכע אינפֿאָרמאַציע אין דער טעקע, איר קענען באַקומען אַ ספּעציעל באַפֿעל פֿאַר דיין דיימאַן, ווי, daemon status, וואָס וועט זאָגן "יאָ, אַלץ איז גוט, די דיימאַן אַרבעט, עס איז לעבעדיק."

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

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

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

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

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

אַז איז, דיין אַפּלאַקיישאַן, ווען אַ בקשה קומט צו אים /health, עס ריספּאַנד נישט בלויז, "200, אָוקיי", עס ערשטער גייט, פֿאַר בייַשפּיל, צו די דאַטאַבאַסע, פרוווט צו פאַרבינדן צו עס, טוט עפּעס זייער יקערדיק דאָרט, ווי אויסקלייַבן איינער, נאָר טשעק אַז עס איז אַ קשר אין די דאַטאַבייס און איר קענען אָנפֿרעג די דאַטאַבייס. אויב אַלע דעם איז געראָטן, דער ענטפער איז "200, גוט." אויב עס איז נישט געראָטן, עס זאגט אַז עס איז אַ טעות, די דאַטאַבייס איז אַנאַוויילאַבאַל.

דעריבער, אין דעם אַכטונג, איך ווידער צוריקקומען צו די גרייטקייַט / ​​לייוונאַס טעסץ - וואָס איר רובֿ מסתּמא דאַרפֿן אַ גרייטקייַט פּרובירן, אָבער אַ לעבןנעסס פּראָבע איז אין קשיא. ווייַל אויב איר באַשרייַבן געזונט טשעקס פּונקט ווי איך נאָר געזאגט, עס וועט קער אויס אַז עס איז נישט בנימצא אין דעם בייַשפּיל טיילв или со всех instanceאין אַ דאַטאַבייס, למשל. ווען איר האָט דערקלערט אַ גרייטקייט פּראָבע, אונדזער געזונט טשעקס אנגעהויבן צו פאַרלאָזן, און אַקאָרדינגלי אַלע די אַפּלאַקיישאַנז פון וואָס די דאַטאַבייס איז ניט צוטריטלעך, זיי זענען פשוט אויסגעדרייט אַוועק פון באַלאַנסינג און אין פאַקט "הענגען" נאָר אין אַ אָפּגעלאָזן שטאַט און וואַרטן פֿאַר זייער דאַטאַבייסיז אַרבעט.

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

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

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

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

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

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

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

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

אויב אַלץ איז גוט, ריספּאַנד מיט די צוויי הונדערט ענטפֿער. אין פּרינציפּ, יעדער צוויי-הונדערט ענטפער וועט פּאַסן איר. אויב איר לייענען ראַגסי זייער גוט און וויסן אַז עטלעכע ענטפער סטאַטוסעס זענען אַנדערש פון אנדערע, ענטפֿערן מיט די צונעמען אָנעס: 204, 5, 10, 15, וועלכער. אויב עס איז נישט זייער גוט, נאָר "צוויי נול נול." אויב אַלץ גייט שלעכט און די געזונט טשעק טוט נישט ריספּאַנד, דעמאָלט ענטפֿערן מיט קיין פינף הונדערט. ווידער, אויב איר פֿאַרשטיין ווי צו ריספּאַנד, ווי פאַרשידענע ענטפער סטאַטוסעס אַנדערש פון יעדער אנדערער. אויב איר טאָן ניט פֿאַרשטיין, 502 איז דיין אָפּציע צו ריספּאַנד צו געזונט טשעקס אויב עפּעס גייט פאַלש.

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

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

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

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

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

גראַציעז שאַטדאַון

אין אַלגעמיין, וואָס איז Graceful Shutdown און וואָס איז עס דארף? דאָס איז וועגן ווען דיין אַפּלאַקיישאַן קראַשיז פֿאַר עטלעכע סיבה, איר דאַרפֿן צו טאָן app stop - אָדער איר באַקומען, למשל, אַ סיגנאַל פון די אָפּערייטינג סיסטעם, דיין אַפּלאַקיישאַן מוזן פֿאַרשטיין עס און טאָן עפּעס וועגן אים. די ערגסט פאַל סצענאַר, פון קורס, איז ווען דיין אַפּלאַקיישאַן נעמט אַ SIGTERM און איז ווי "SIGTERM, לאָזן אונדז הענגען אויף, אַרבעט, טאָן גאָרנישט." דאָס איז אַ גאָר שלעכט אָפּציע.

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

וואָס אָפּציע איז גוט? דער ערשטער פונט איז צו נעמען אין חשבון די קאַמפּלישאַן פון אַפּעריישאַנז. א גוטע אָפּציע איז פֿאַר דיין סערווער צו נעמען אין חשבון וואָס עס טוט אויב עס נעמט אַ SIGTERM.

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

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

דאָרט קענען מיר ספּעציפֿיש זאָגן ווי לאַנג מיר דאַרפֿן צו וואַרטן צווישן די צייט וואָס מיר שיקן SIGTERM צו די אַפּלאַקיישאַן און ווען מיר פֿאַרשטיין אַז די אַפּלאַקיישאַן סימז צו זיין משוגע פֿאַר עפּעס אָדער איז "סטאַק" און וועט נישט סוף - און מיר דאַרפֿן צו שיקן עס SIGKILL, דאָס איז, שווער פאַרענדיקן זייַן אַרבעט. אַז איז, אַקאָרדינגלי, מיר האָבן עטלעכע מין פון דיימאַן פליסנדיק, עס פּראַסעסאַז אַפּעריישאַנז. מיר פֿאַרשטיין אַז אין דורכשניטלעך אונדזער אַפּעריישאַנז וואָס די דיימאַן אַרבעט אויף טאָן ניט דויערן מער ווי 30 סעקונדעס אין אַ צייט. אַקקאָרדינגלי, ווען SIGTERM ערייווז, מיר פֿאַרשטיין אַז אונדזער דיימאַן קענען, אין רובֿ, ענדיקן 30 סעקונדעס נאָך SIGTERM. מיר שרייַבן עס, פֿאַר בייַשפּיל, 45 סעקונדעס נאָר אין פאַל און זאָגן אַז SIGTERM. נאָך דעם, מיר וואַרטן 45 סעקונדעס. אין טעאָריע, בעשאַס דעם צייַט דער שעד זאָל האָבן געענדיקט זייַן אַרבעט און געענדיקט זיך. אָבער אויב פּלוצלינג עס קען נישט, עס מיטל אַז עס איז רובֿ מסתּמא סטאַק - עס איז ניט מער פּראַסעסינג אונדזער ריקוועס נאָרמאַלי. און אין 45 סעקונדעס איר קענען בעשאָלעם, אין פאַקט, נאָגל אים אַראָפּ.

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

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

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

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

רעסורסן

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

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

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

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

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

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

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

דאַטן סטאָרידזש

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

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

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

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

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

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

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

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

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

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

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

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

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

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

קלאָודנאַטיווענעסס

און די לעצט סובטאָפּיק איז וואָס קלאָודנאַטיווע איז. פארוואס איז עס דארף? קלאָודנאַטיווענעסס און אַזוי אויף.

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

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

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

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

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

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

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

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

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

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

מקור: www.habr.com