🥇Wéi ufänken Ansible ze testen, e Projet an engem Joer ze refactoréieren an net verréckt ginn

Dëst ass den Transkript Opféierungen op DevOps-40 2020-03-18:

Vun der zweeter Verpflichtung un, gëtt all Code Legacy, well initial Iddien fänken aus der haarder Realitéit ze divergéieren. Dëst ass weder gutt nach schlecht, et ass e Gegeben mat deem et schwéier ass ze streiden a muss gelieft ginn. En Deel vun dësem Prozess ass Refactoring. Refactoring Infrastruktur als Code. Loosst d'Geschicht ufänken wéi een Ansible an engem Joer refactoréiert an net verréckt gëtt.

D'Gebuert vun Legacy

Dag # 1: Patient Zero

Eemol gouf et e bedingte Projet. Et hat en Dev Entwécklungsteam an Ops Ingenieuren. Si hunn dee selwechte Problem geléist: wéi Serveren ofsetzen an eng Applikatioun lafen. De Problem war, datt all Equipe dëse Problem op seng Manéier geléist huet. Am Projet gouf decidéiert Ansible ze benotzen fir Wëssen tëscht den Dev an Ops Teams ze synchroniséieren.

Dag # 89: D'Gebuert vun Legacy

Ouni et selwer ze bemierken, wollten se et esou gutt wéi méiglech maachen, awer et huet sech als Legacy erausgestallt. Wéi geschitt dat?

Mir hunn eng dréngend Aufgab hei, loosst eis en dreckeg Hack maachen an et dann fixéieren.
Dir musst keng Dokumentatioun schreiwen an alles ass kloer wat hei lass ass.
Ech weess Ansible / Python / Bash / Terraform! Kuckt wéi ech dodge kann!
Ech sinn e Full Stack Overflow Entwéckler a kopéiert dëst aus Stackoverflow, Ech weess net wéi et funktionnéiert, awer et gesäit cool aus a léist de Problem.

Als Resultat kënnt Dir eng onverständlech Aart vu Code kréien, fir deen et keng Dokumentatioun gëtt, et ass net kloer wat et mécht, ob et néideg ass, awer de Problem ass datt Dir et braucht ze entwéckelen, z'änneren, d'Krüchen derbäi ze ënnerstëtzen an z'ënnerstëtzen. , mécht d'Situatioun nach méi schlëmm.

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

Dag # 109: Sensibiliséierung vum Problem

Den ursprénglech konzipéierten an implementéierten IaC Modell entsprécht net méi den Ufuerderunge vun de Benotzer / Business / aneren Teams, an d'Zäit fir Ännerungen an der Infrastruktur ze maachen hält op akzeptabel ze sinn. Zu dësem Moment kënnt d'Verständnis datt et Zäit ass ze handelen.

IaC Refactoring

Dag #139: Braucht Dir wierklech Refactoring?

Ier Dir op de Refactor rennt, musst Dir eng Rei wichteg Froen beäntweren:

Firwat braucht Dir dat alles?
Hutt Dir Zäit?
Ass Wëssen genuch?

Wann Dir net wësst wéi d'Froen beäntweren, da wäert d'Refactoring ophalen ier se ufänkt, oder et kann nëmme verschlechtert ginn. Well hat Erfahrung ( Wat ech geléiert hunn aus Testen 200 Linnen vun Infrastruktur Code), dann krut de Projet eng Demande fir Hëllef fir d'Rollen ze fixéieren an se mat Tester ze decken.

Dag # 149: Preparéieren der refactoring

Déi éischt Saach ass ze preparéieren. Entscheede wat mir maachen. Fir dëst ze maachen, kommunizéieren mir, fanne Problemberäicher a fannen Weeër fir se ze léisen. Mir notéieren déi resultéierend Konzepter iergendwéi, zum Beispill en Artikel am Zesummenhang, sou datt wann d'Fro stellt "wat ass am Beschten?" oder "wat ass richteg?" Mir hunn de Wee net verluer. An eisem Fall hu mir un d'Iddi festgehalen deelen a regéieren: Mir zerbriechen d'Infrastruktur a kleng Stécker/Zille. Dës Approche erlaabt Iech en isoléiert Stéck Infrastruktur ze huelen, ze verstoen wat et mécht, et mat Tester ofdecken an et z'änneren ouni Angscht eppes ze briechen.

Et stellt sech eraus datt Infrastrukturtesten den Ecksteen gëtt an hei ass et derwäert d'Infrastrukturtest Pyramid ze ernimmen. Genau déiselwecht Iddi déi an der Entwécklung ass, awer fir d'Infrastruktur: mir plënneren vu bëllege Schnelltesten, déi einfach Saache kontrolléieren, wéi z.

Ansible Test Versich

Ier mer beschreiwen wéi mir Ansible Tester iwwer de Projet ofgedeckt hunn, wäert ech d'Versich an d'Approche beschreiwen, déi ech d'Geleeënheet hat virdrun ze benotzen fir de Kontext vun den Entscheedungen ze verstoen.

Dag Nr -997: SDS Bestëmmung

Déi éischte Kéier wou ech Ansible getest hunn war op engem Projet fir SDS (Software Defined Storage) z'entwéckelen. Et gëtt en separaten Artikel iwwer dëst Thema
Wéi briechen Vëloen iwwer Krut wann Dir Är Verdeelung testen, awer kuerz, mir hunn eng ëmgedréint Testpyramid opgehalen an Tester hu mir 60-90 Minutten op eng Roll verbruecht, wat eng laang Zäit ass. D'Basis war e2e Tester, d.h. mir hunn eng vollwäerteg Installatioun agesat an duerno getest. Wat nach méi schlëmm war, war d'Erfindung vu sengem eegene Vëlo. Awer ech muss zouginn, dës Léisung huet geschafft an erlaabt eng stabil Verëffentlechung.

Dag # -701: Ansible an Test Kichen

D'Entwécklung vun der Ansible Test Iddi war d'Benotzung vu fäerdege Tools, nämlech Test Kichen / Kitchen-ci an Inspec. D'Wiel gouf vum Wëssen vum Ruby bestëmmt (fir méi Detailer, kuckt den Artikel iwwer Habré: Dram YML Programméierer vun Testen Ansible?) méi séier geschafft, ongeféier 40 Minutten fir 10 Rollen. Mir hunn e Pak vu virtuelle Maschinnen erstallt an Tester dobannen ausgefouert.

Am Allgemengen huet d'Léisung geschafft, awer et gouf e Sediment wéinst der Heterogenitéit. Wann d'Zuel vun de getestene Leit op 13 Basisrollen an 2 Metarollen erhéicht gouf, déi méi kleng Rollen kombinéieren, dunn hunn d'Tester op eemol ugefaang fir 70 Minutten ze lafen, wat bal 2 Mol méi laang ass. Et war schwéier iwwer XP (extrem Programméierungs) Praktiken ze schwätzen, well ... keen wëll 70 Minutten wait. Dëst war de Grond fir d'Approche ze änneren

Dag # -601: Ansible a Molekül

Konzeptuell ass dëst ähnlech wéi Testkitchen, nëmme mir hunn d'Rolltestung op Docker geplënnert an de Stack geännert. Als Resultat gouf d'Zäit op eng stabil 20-25 Minutte fir 7 Rollen reduzéiert.

Duerch d'Erhéijung vun der Unzuel vun de geteste Rollen op 17 a 45 Rollen ze zéien, hu mir dëst an 28 Minutten op 2 Jenkins Sklaven gelaf.

Dag #167: Ansible Tester fir de Projet bäidroen

Wahrscheinlech wäert et net méiglech sinn d'Refactoring Aufgab séier ze maachen. D'Aufgab muss moossbar sinn, sou datt Dir se a kleng Stécker zerbriechen an den Elefant Stéck fir Stéck mat engem Teelöffel iessen. Et muss e Verständnis sinn, ob Dir an déi richteg Richtung beweegt, wéi laang ze goen.

Am Allgemengen ass et egal wéi et gemaach gëtt, Dir kënnt op e Stéck Pabeier schreiwen, Dir kënnt Stickeren op de Kleederschaf setzen, Dir kënnt Aufgaben am Jira erstellen, oder Dir kënnt Google Docs opmaachen an den aktuelle Status opschreiwen do. D'Been wuessen aus der Tatsaach, datt de Prozess net direkt ass, et wäert laang an langweileg sinn. Et ass onwahrscheinlech datt iergendeen wëllt datt Dir Iddie verbrennt, midd gëtt a während der Refactoring iwwerwältegt gëtt.

D'Refactoring ass einfach:

Iessen.
Schlof.
Code gitt.
IaC Test.
Erëmfannen

a mir widderhuelen dat bis mir dat virgesinnt Zil erreechen.

Et ass vläicht net méiglech alles direkt ze testen, sou datt eis éischt Aufgab war mam Linting unzefänken an d'Syntax ze kontrolléieren.

Dag # 181: Green Build Master

Linting ass e klengen éischte Schrëtt a Richtung Green Build Master. Dëst wäert bal näischt briechen, awer et erlaabt Iech Prozesser ze debuggen a gréng Builds zu Jenkins ze maachen. D'Iddi ass Gewunnechten am Team z'entwéckelen:

Rout Tester si schlecht.
Ech sinn komm fir eppes ze fixéieren a gläichzäiteg de Code e bësse besser ze maachen wéi et virun Iech war.

Dag # 193: Vun linting zu Eenheet Tester

Nodeems Dir de Prozess gebaut hutt fir de Code an de Master ze kréien, kënnt Dir de Prozess vun der Schrëtt-fir-Schrëtt Verbesserung ufänken - Linting ersetzen mat Startrollen, Dir kënnt et souguer ouni Idempotenz maachen. Dir musst verstoen wéi d'Rollen applizéiert ginn a wéi se funktionnéieren.

Dag # 211: Vun Eenheet ze Integratioun Tester

Wann déi meescht Rollen mat Eenheetstester ofgedeckt sinn an alles gefleckt ass, kënnt Dir weidergoen fir Integratiounstester ze addéieren. Déi. Testen net eng eenzeg Mauer an der Infrastruktur, mee eng Kombinatioun vun hinnen, zum Beispill, eng voll Instanz Configuratioun.

Benotzt Jenkins, mir generéiert vill Etappe datt Rollen / Playbooks parallel linted, dann Eenheet Tester am Container, an endlech Integratioun Tester.

Jenkins + Docker + Ansible = Tester

Checkout Repo a generéiert Baustadien.
Laf lint playbook Etappe parallel.
Laf lint Roll Etappe parallel.
Run Syntax kontrolléieren Roll Etappe parallel.
Laf Test Roll Etappen parallel.
1. Lint Roll.
2. Check Ofhängegkeet vun anere Rollen.
3. Syntax kontrolléieren.
4. Schafen docker Instanz
5. Run molecule/default/playbook.yml.
6. Iwwerpréift Idempotenz.
Run Integratioun Tester
Freck

Dag # 271: Bus Faktor

Am Ufank gouf d'Refactoring vun engem klenge Grupp vun zwee oder dräi Leit duerchgefouert. Si hunn de Code am Master iwwerpréift. Mat der Zäit huet d'Team Wëssen entwéckelt wéi ee Code schreift an d'Code-Iwwerpréiwung huet zu der Verbreedung vu Wëssen iwwer d'Infrastruktur bäigedroen a wéi et funktionnéiert. Den Highlight hei war, datt d'Rezensoren een nom aneren ausgewielt goufen, no engem Zäitplang, d.h. mat engem gewësse Grad vu Wahrscheinlechkeet wäert Dir an en neit Stéck Infrastruktur klammen.

An et soll hei bequem sinn. Et ass bequem eng Iwwerpréiwung ze maachen, am Kader vu wéi eng Aufgab et gemaach gouf an d'Geschicht vun den Diskussiounen ze gesinn. Mir hunn jenkins integréiert + bitbucket + jira.

Awer als solch ass eng Iwwerpréiwung keng Panacea; iergendwéi si mir an de Mastercode komm, deen eis Floptester gemaach huet:

- 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 }}"

Duerno hunn se et fixéiert, awer de Rescht ass bliwwen.

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 }}"

Dag # 311: Beschleunegt Tester

Mat der Zäit goufen et méi Tester, baut méi lues, bis zu enger Stonn am schlëmmste Fall. Op ee vun de Retros gouf et e Saz wéi "et ass gutt datt et Tester ginn, awer si si lues." Als Resultat hu mir Integratiounstester op virtuelle Maschinnen opginn an se fir Docker adaptéiert fir et méi séier ze maachen. Mir hunn och Testinfra ersat duerch en ansible Verifizéierer fir d'Zuel vun de benotzten Tools ze reduzéieren.

Streng geschwat gouf et eng Rei vu Moossnamen:

Wiesselt op Docker.
Ewechzehuelen Roll Testen, déi duplizéiert ass wéinst Ofhängegkeeten.
Erhéijung der Zuel vun Sklaven.
Test Lafen Uerdnung.
Fähigkeit ze zéien ALL lokal mat engem Kommando.

Als Resultat, Pipeline op jenkins war och vereenegt

Generéiere Baustadien.
Lint all parallel.
Laf Test Roll Etappen parallel.
Ze lafen.

Léieren Erfëllt

Vermeiden global Verännerlechen

Ansible benotzt global Variablen, et gëtt eng partiell Léisung an der Form private_role_vars, awer dëst ass keng Panacea.

Loosst mech Iech e Beispill ginn. Loosst eis hunn 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}}

Déi witzeg Saach ass datt d'Resultat vu Playbooks vun Saachen ofhänken déi net ëmmer offensichtlech sinn, sou wéi d'Uerdnung an där Rollen opgelëscht sinn. Leider ass dëst d'Natur vun Ansible an dat Bescht wat gemaach ka ginn ass eng Aart vun Accord ze benotzen, zum Beispill, bannent enger Roll, benotzt nëmmen déi Variabel déi an dëser Roll beschriwwe gëtt.

SCHLECHT: benotzt global Variabel.

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

GUTT: V. defaults déi néideg Variabelen definéieren a spéider nëmmen se benotzen.

# 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

Präfix Roll Verännerlechen

SCHLECHT: benotzt global Variabel.

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

GUTT: An Rollen fir Variabelen, benotzt Variabelen mat dem Rollennumm Präfix; dëst, andeems Dir Inventar kuckt, wäert et méi einfach maachen ze verstoen wat geschitt.

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

Benotzen Loop Kontroll Variabel

SCHLECHT: Benotzt Standard Variabel an Loops item, Wann dës Aufgab / Spillbuch iergendwou abegraff ass, kann dëst zu onerwaart Verhalen féieren

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

GUTT: Neidefinéieren eng Variabel an enger Loop via loop_var.

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

Check Input Verännerlechen

Mir hunn eis eens ginn fir variabel Präfixe ze benotzen; et wier net iwwerflësseg ze kontrolléieren ob se definéiert sinn wéi mir et erwaarden an zum Beispill net vun engem eidele Wäert iwwerschratt sinn

GUTT: Kontrolléieren Verännerlechen.

- 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

Vermeiden Hashes Dictionnairen, benotzt flaach Struktur

Wann eng Roll en Hash / Wierderbuch an engem vu senge Parameteren erwaart, da wa mir ee vun de Kannerparameter wëllen änneren, musse mir de ganzen Hash / Wierderbuch iwwerschreiden, wat d'Konfiguratiounskomplexitéit erhéijen.

SCHLECHT: Benotzt Hash / Wierderbuch.

---
user:
  name: admin
  group: admin

GUTT: Benotzt eng flaach Variabel Struktur.

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

Erstellt idempotent Spillbicher & Rollen

Rollen a Spillbicher mussen idempotent sinn, well reduzéiert Konfiguratiounsdrift an Angscht eppes ze briechen. Awer wann Dir Molekül benotzt, dann ass dëst de Standardverhalen.

Vermeiden d'Benotzung vun Kommando Shell Moduler

D'Benotzung vun engem Shellmodul resultéiert an engem imperativen Beschreiwungsparadigma, amplaz vum deklarativen, wat de Kär vun Ansible ass.

Test Är Rollen iwwer Molekül

Molekül ass eng ganz flexibel Saach, loosst eis e puer Szenarie kucken.

Molekül Multiple Instanzen

В molecule.yml an der Rubrik platforms Dir kënnt vill Hosten beschreiwen déi Dir kënnt ofsetzen.

---
    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

Deementspriechend kënnen dës Hosten dann sinn converge.yml benotzen:

---
- 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

Ansible Verifizéierer

A Molekül ass et méiglech d'Ansible ze benotzen fir ze kontrolléieren ob d'Instanz richteg konfiguréiert ass, ausserdeem ass dëst de Standard zënter der Verëffentlechung 3. Et ass net sou flexibel wéi testinfra/inspec, awer mir kënne kontrolléieren ob den Inhalt vun der Datei mat eisen Erwaardungen entsprécht:

---
- 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

Oder deploy de Service, waart bis et verfügbar ass a maacht en Damptest:

---
  - 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

Setzt komplex Logik a Moduler & Plugins

Ansible plädéiert fir eng deklarativ Approche, also wann Dir Code Verzweigung, Datentransformatioun, Shellmoduler maacht, gëtt de Code schwéier ze liesen. Fir dëst ze bekämpfen an et einfach ze verstoen, wier et net iwwerflësseg dës Komplexitéit ze bekämpfen andeems Dir Är eege Moduler erstallt.

Tipps & Tricks zesummefaassen

Vermeiden global Verännerlechen.
Präfix Roll Verännerlechen.
Benotzen Loop Kontroll Variabel.
Check Input Verännerlechen.
Vermeiden Hashes Dictionnairen, benotzt flaach Struktur.
Erstellt idempotent Spillbicher & Rollen.
Vermeiden d'Benotzung vun Kommando Shell Moduler.
Test Är Rollen iwwer Molekül.
Setzt komplex Logik a Moduler & Plugins.

Konklusioun

Dir kënnt net just goen an d'Infrastruktur op engem Projet refactoréieren, och wann Dir IaC hutt. Dëst ass e laange Prozess dee Gedold, Zäit a Wëssen erfuerdert.

Linken

UPD1 2020.05.01 20:30 - Fir primär Profiléierung vu Spillbicher kënnt Dir benotzen callback_whitelist = profile_tasks fir eng laang Zäit ze verstoen wat genau funktionnéiert. Da gi mer duerch Ansible Beschleunegung Klassiker. Dir kënnt och probéieren mitogen
UPD2 2020.05.03 16:34 - Englescher Versioun

Source: will.com

Wéi fänken ech un Ansible ze testen, refaktoréiert de Projet an engem Joer a gitt net verréckt