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

דאָס איז דער טראַנסקריפּט פּערפאָרמאַנסיז אויף DevOps-40 2020-03-18:

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

די געבורט פון לעגאַט

טאָג # 1: פּאַציענט נול

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

טאָג #89: דער געבורט פון לעגאַט

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

• מיר האָבן דאָ אַ דרינגלעך אַרבעט, לאָזן אונדז טאָן אַ שמוציק כאַק און דעמאָלט פאַרריכטן עס.
• איר טאָן ניט האָבן צו שרייַבן דאַקיומענטיישאַן און אַלץ איז קלאָר וואָס איז געשעעניש דאָ.
• איך וויסן Ansible / Python / Bash / Terraform! קוק ווי איך קענען ויסמיידן!
• איך בין אַ גאַנץ סטאַק אָווערפלאָוו דעוועלאָפּער און קאַפּיד דעם פֿון סטאַקקאָווערפלאָוו, איך טאָן ניט וויסן ווי עס אַרבעט, אָבער עס קוקט קיל און סאַלווז די פּראָבלעם.

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

- hosts: localhost
  tasks:
    - shell: echo -n Z >> a.txt && cat a.txt
      register: output
      delay: 1
      retries: 5
      until: not output.stdout.find("ZZZ")

טאָג #109: וויסיקייַט פון דעם פּראָבלעם

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

IaC רעפאַקטורינג

טאָג #139: צי איר טאַקע דאַרפֿן רעפאַקטאָרינג?

איידער איר קאַמיש צו רעפאַקטאָר, איר מוזן ענטפֿערן אַ נומער פון וויכטיק פֿראגן:

1. פארוואס טאָן איר דאַרפֿן אַלע דעם?
2. צי איר האָבן צייַט?
3. איז וויסן גענוג?

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

טאָג #149: פּריפּערינג די רעפאַקטאָרינג

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

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

אַנסיבלע טעסטינג פרווון

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

טאָג נומ -997: SDS טנייַ

דער ערשטער מאָל איך טעסטעד Ansible איז געווען אויף אַ פּרויעקט צו אַנטוויקלען SDS (Software Defined Storage). עס איז אַ באַזונדער אַרטיקל אויף דעם טעמע
ווי צו ברעכן בייסיקאַלז איבער קראַטשיז ווען טעסטינג דיין פאַרשפּרייטונג, אָבער אין קורץ, מיר ענדיקט זיך מיט אַ ינווערטיד טעסטינג פּיראַמיד און טעסטינג מיר פארבראכט 60-90 מינוט אויף איין ראָלע, וואָס איז אַ לאַנג צייַט. דער יסוד איז געווען ע2ע טעסץ, ד.ה. מיר האָבן דיפּלויד אַ פול-פלעדזשד ינסטאַלירונג און דעמאָלט טעסטעד עס. וואָס איז געווען אפילו מער אַגראַווייטינג איז די דערפינדונג פון זיין אייגן וועלאָסיפּעד. אָבער איך מוזן אַרייַנלאָזן, די לייזונג געארבעט און ערלויבט פֿאַר אַ סטאַביל מעלדונג.

טאָג # -701: אַנסיבלע און פּרובירן קיך

די אַנטוויקלונג פון די אַנסיבלע טעסטינג געדאַנק איז געווען די נוצן פון פאַרטיק מכשירים, ניימלי פּרובירן קיך / קיך-סי און ינספּעק. די ברירה איז באשלאסן דורך וויסן פון רובי (פֿאַר מער דעטאַילס, זען דעם אַרטיקל אויף Habré: צי YML פּראָוגראַמערז חלום פון טעסטינג Ansible?) געארבעט פאַסטער, וועגן 40 מינוט פֿאַר 10 ראָלעס. מיר באשאפן אַ פּאַק פון ווירטואַל מאשינען און לויפן טעסץ ין.

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

טאָג # -601: אַנסיבלע און מאַלאַקיול

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

דורך ינקריסינג די נומער פון טעסטעד ראָלעס צו 17 און לינדינג 45 ראָלעס, מיר לויפן דעם אין 28 מינוט אויף 2 דזשענקינס סלאַוועס.

טאָג #167: אַדינג אַנסיבלע טעסץ צו די פּרויעקט

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

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

די רעפאַקטורינג איז פּשוט:

• עסן.
• שלאָפן.
• קאָדעקס.
• יאַק פּרובירן.
• יבערכאַזערן

און מיר איבערחזרן דאָס ביז מיר דערגרייכן דעם בדעה ציל.

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

טאָג #181: גרין בויען האר

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

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

טאָג #193: פֿון לינטינג צו אַפּאַראַט טעסץ

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

טאָג #211: פֿון אַפּאַראַט צו ינטאַגריישאַן טעסץ

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

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

Jenkins + Docker + Ansible = טעסץ

1. ויסשרייַבן רעפּאָ און דזשענערייט בויען סטאַגעס.
2. לויפן לינט פּלייַבאָאָק סטאַגעס אין פּאַראַלעל.
3. לויפן לינט ראָלע סטאַגעס אין פּאַראַלעל.
4. לויפן סינטאַקס קאָנטראָל ראָלע סטאַגעס אין פּאַראַלעל.
5. לויפן פּרובירן ראָלע סטאַגעס אין פּאַראַלעל.
   1. לינט ראָלע.
   2. קוק אָפענגיקייַט אויף אנדערע ראָלעס.
   3. קוק סינטאַקס.
   4. שאַפֿן אַ דאָקקער בייַשפּיל
   5. לויפן molecule/default/playbook.yml.
   6. קאָנטראָלירן די אידעפּאָטענסי.
6. לויפן ינטאַגריישאַן טעסץ
7. ענדיקן

טאָג #271: ויטאָבוס פאַקטאָר

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

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

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

- get_url:
    url: "{{ actk_certs }}/{{ item.1 }}"
    dest: "{{ actk_src_tmp }}/"
    username: "{{ actk_mvn_user }}"
    password: "{{ actk_mvn_pass }}"
  with_subelements:
    - "{{ actk_cert_list }}"
    - "{{ actk_certs }}"
  delegate_to: localhost

- copy:
    src: "{{ actk_src_tmp }}/{{ item.1 }}"
    dest: "{{ actk_dst_tmp }}"
  with_subelements:
    - "{{ actk_cert_list }}"
    - "{{ actk_certs }}"

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

get_url:
    url: "{{ actk_certs }}/{{ actk_item }}"
    dest: "{{ actk_src_tmp }}/{{ actk_item }}"
    username: "{{ actk_mvn_user }}"
    password: "{{ actk_mvn_pass }}"
  loop_control:
    loop_var: actk_item
  with_items: "{{ actk_cert_list }}"
  delegate_to: localhost

- copy:
    src: "{{ actk_src_tmp }}/{{ actk_item }}"
    dest: "{{ actk_dst_tmp }}"
  loop_control:
    loop_var: actk_item
  with_items: "{{ actk_cert_list }}"

טאָג #311: גיכקייַט אַרויף טעסץ

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

שטרענג גערעדט, עס איז געווען אַ גאַנג פון מיטלען:

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

ווי אַ רעזולטאַט, פּייפּליין אויף דזשענקינס איז אויך יונאַפייד

1. שאַפֿן בויען סטאַגעס.
2. לינט אַלע אין פּאַראַלעל.
3. לויפן פּרובירן ראָלע סטאַגעס אין פּאַראַלעל.
4. ענדיקן.

לעקציעס געלערנט

ויסמיידן גלאבאלע וועריאַבאַלז

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

לאמיר דיר געבן א ביישפיל. זאל אונדז האָבן role_a и role_b

# cat role_a/defaults/main.yml
---
msg: a

# cat role_a/tasks/main.yml
---
- debug:
    msg: role_a={{ msg }}

# cat role_b/defaults/main.yml
---
msg: b

# cat role_b/tasks/main.yml
---
- set_fact:
    msg: b
- debug:
    msg: role_b={{ msg }}

- hosts: localhost
  vars:
    msg: hello
  roles:
    - role: role_a
    - role: role_b
  tasks:
    - debug:
        msg: play={{msg}}

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

שלעכט: נוצן גלאבאלע בייַטעוודיק.

# cat roles/some_role/tasks/main.yml
---
debug:
  var: java_home

גוט: אין defaults דעפינירן די נויטיק וועריאַבאַלז און שפּעטער נוצן זיי בלויז.

# cat roles/some_role/defaults/main.yml
---
r__java_home:
 "{{ java_home | default('/path') }}"

# cat roles/some_role/tasks/main.yml
---
debug:
  var: r__java_home

פּרעפיקס ראָלע וועריאַבאַלז

שלעכט: נוצן גלאבאלע בייַטעוודיק.

# cat roles/some_role/defaults/main.yml
---
db_port: 5432

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

# cat roles/some_role/defaults/main.yml
---
some_role__db_port: 5432

ניצן שלייף קאָנטראָל בייַטעוודיק

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

---
- hosts: localhost
  tasks:
    - debug:
        msg: "{{ item }}"
      loop:
        - item1
        - item2

גוט: רידיפיין אַ בייַטעוודיק אין אַ שלייף דורך loop_var.

---
- hosts: localhost
  tasks:
    - debug:
        msg: "{{ item_name }}"
      loop:
        - item1
        - item2
      loop_control:
        loop_var: item_name

קאָנטראָלירן אַרייַנשרייַב וועריאַבאַלז

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

גוט: קוק וועריאַבאַלז.

- name: "Verify that required string variables are defined"
  assert:
    that: ahs_var is defined and ahs_var | length > 0 and ahs_var != None
    fail_msg: "{{ ahs_var }} needs to be set for the role to work "
    success_msg: "Required variables {{ ahs_var }} is defined"
  loop_control:
    loop_var: ahs_var
  with_items:
    - ahs_item1
    - ahs_item2
    - ahs_item3

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

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

שלעכט: ניצן האַש / ווערטערבוך.

---
user:
  name: admin
  group: admin

גוט: ניצן אַ פלאַך בייַטעוודיק סטרוקטור.

---
user_name: admin
user_group: "{{ user_name }}"

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

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

ויסמיידן ניצן באַפֿעלן שאָל מאַדזשולז

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

פּרובירן דיין ראָלעס דורך מאַלאַקיול

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

מאָלעקולע קייפל ינסטאַנסיז

В molecule.yml אין אָפּטיילונג platforms איר קענען באַשרייַבן פילע מחנות אַז איר קענען צעוויקלען.

---
    driver:
      name: docker
    platforms:
      - name: postgresql-instance
        hostname: postgresql-instance
        image: registry.example.com/postgres10:latest
        pre_build_image: true
        override_command: false
        network_mode: host
      - name: app-instance
        hostname: app-instance
        pre_build_image: true
        image: registry.example.com/docker_centos_ansible_tests
        network_mode: host

דעריבער, די מחנות קענען זיין converge.yml נוצן:

---
- name: Converge all
  hosts: all
  vars:
    ansible_user: root
  roles:
    - role: some_role

- name: Converge db
  hosts: db-instance
  roles:
    - role: some_db_role

- name: Converge app
  hosts: app-instance
  roles:
    - role: some_app_role

אַנסיבלע וועראַפייער

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

---
- name: Verify
  hosts: all
  tasks:
    - name: copy config
      copy:
        src: expected_standalone.conf
        dest: /root/wildfly/bin/standalone.conf
        mode: "0644"
        owner: root
        group: root
      register: config_copy_result

    - name: Certify that standalone.conf changed
      assert:
        that: not config_copy_result.changed

אָדער צעוויקלען די סערוויס, וואַרטן ביז עס איז בארעכטיגט און טאָן אַ רויך פּראָבע:

---
  - name: Verify
    hosts: solr
    tasks:
      - command: /blah/solr/bin/solr start -s /solr_home -p 8983 -force
      - uri:
          url: http://127.0.0.1:8983/solr
          method: GET
          status_code: 200
        register: uri_result
        until: uri_result is not failed
        retries: 12
        delay: 10
      - name: Post documents to solr
        command: /blah/solr/bin/post -c master /exampledocs/books.csv

שטעלן קאָמפּלעקס לאָגיק אין מאַדזשולז & פּלוגינס

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

סאַמערייז עצות און טריקס

1. ויסמיידן גלאבאלע וועריאַבאַלז.
2. פּרעפיקס ראָלע וועריאַבאַלז.
3. ניצן שלייף קאָנטראָל בייַטעוודיק.
4. קאָנטראָלירן אַרייַנשרייַב וועריאַבאַלז.
5. ויסמיידן האַשעס דיקשאַנעריז, נוצן פלאַך סטרוקטור.
6. שאַפֿן אידעמאָטענט פּלייַבאָאָקס און ראָלעס.
7. ויסמיידן ניצן באַפֿעלן שאָל מאַדזשולז.
8. פּרובירן דיין ראָלעס דורך מאַלאַקיול.
9. שטעלן קאָמפּלעקס לאָגיק אין מאַדזשולז & פּלוגינס.

סאָף

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

לינקס

• סליידז ווי צו פּרובירן אַנסיבלע און טאָן ניט גיין ניסלעך
• ווידעא ווי צו פּרובירן אַנסיבלע און טאָן ניט גיין ניסלעך
• וואָס איך געלערנט פון טעסטינג 200 שורות פון ינפראַסטראַקטשער קאָד
• אַנסאַבאַל: מיגראַטיאָן פון 120 VM קאַנפיגיעריישאַן פון קאָרעאָס צו Centos אין 18 חדשים
• ווי צו ברעכן בייסיקאַלז איבער קראַטשיז ווען טעסטינג דיין פאַרשפּרייטונג
• פּרובירן מיר אויב איר קענען אָדער טאָן YML פּראָוגראַמערז חלום פון טעסטינג אַנסיבלע?
• א רשימה פון אָסאַם IaC טעסטינג אַרטיקלען, רעדעס און לינקס
• קרייַז פּאָסטן
• ענגליש ווערסיע

UPD1 2020.05.01 20:30 - פֿאַר ערשטיק פּראָפילינג פון פּלייַבאָאָקס איר קענען נוצן callback_whitelist = profile_tasks צו פֿאַרשטיין וואָס פּונקט אַרבעט פֿאַר אַ לאַנג צייַט. דעמאָלט מיר גיין דורך אַנסאַבאַל אַקסעלעריישאַן קלאַסיקס. איר קענען אויך פּרובירן מיטאָגען
UPD2 2020.05.03 16:34 - ענגליש ווערסיע

מקור: www.habr.com