Մենք արդեն խոսել ենք Tarantool Քարտրիջ, որը թույլ է տալիս մշակել բաշխված հավելվածներ և փաթեթավորել դրանք։ Ոչինչ չի մնացել. սովորեք, թե ինչպես տեղակայել և կառավարել այս հավելվածները: Մի անհանգստացեք, մենք ամեն ինչ մտածել ենք: Մենք հավաքել ենք Tarantool Cartridge-ի հետ աշխատելու բոլոր լավագույն փորձը և գրել անսպասելի դեր, որը փաթեթը կկազմի սերվերների, կսկսի օրինակները, կմիավորի դրանք կլաստերի մեջ, կկարգավորի թույլտվությունը, bootstrap vshard-ը, միացնի ավտոմատ ձախողումը և կկարկատի կլաստերի կազմաձևը։

Հետաքրքի՞ր է: Հետո կտրվածքի տակ հարցնում եմ, ամեն ինչ կասենք ու ցույց կտանք։

Սկսենք օրինակով

Մենք կլուսաբանենք մեր դերի ֆունկցիոնալության միայն մի մասը: Դուք միշտ կարող եք գտնել դրա բոլոր հատկանիշների և մուտքային պարամետրերի ամբողջական նկարագրությունը փաստաթղթավորում. Բայց ավելի լավ է մեկ անգամ փորձել, քան հարյուր անգամ տեսնել, այնպես որ եկեք տեղակայենք մի փոքրիկ հավելված:

Tarantool Քարթրիջն ունի ուսուցողական ստեղծել փոքրիկ Քարտրիջ հավելված, որը պահում է տեղեկատվություն բանկի հաճախորդների և նրանց հաշիվների մասին, ինչպես նաև տրամադրում է API՝ HTTP-ի միջոցով տվյալները կառավարելու համար: Դա անելու համար հավելվածը նկարագրում է երկու հնարավոր դեր. api и storageորոնք կարող են վերագրվել ատյաններին:

Քարթրիջն ինքնին ոչինչ չի ասում, թե ինչպես սկսել գործընթացները, այն միայն ապահովում է արդեն գործող ատյանները կարգավորելու հնարավորություն: Մնացածը օգտվողը պետք է անի ինքը՝ քայքայել կազմաձևման ֆայլերը, գործարկել ծառայությունները և կարգավորել տոպոլոգիան։ Բայց մենք այս ամենը չենք անի, Անսիբլը կանի դա մեզ փոխարեն։

Խոսքից գործ

Այսպիսով, եկեք տեղակայենք մեր հավելվածը երկու վիրտուալ մեքենաների վրա և ստեղծենք պարզ տոպոլոգիա.

• Replicaset app-1 դերը կխաղա apiորը ներառում է դերը vshard-router. Այստեղ կլինի միայն մեկ օրինակ.
• replicaset storage-1 իրականացնում է դերը storage (և միևնույն ժամանակ vshard-storage), այստեղ մենք ավելացնում ենք երկու օրինակ տարբեր մեքենաներից:

Օրինակը գործարկելու համար մեզ անհրաժեշտ է Vagrant и Հղիություն (տարբերակ 2.8 կամ ավելի ուշ):

Դերը ինքնին է Ansible Galaxy. Սա պահեստ է, որը թույլ է տալիս կիսվել ձեր աշխատանքով և օգտագործել պատրաստի դերեր:

Կլոնավորեք պահեստը օրինակով.

$ git clone https://github.com/dokshina/deploy-tarantool-cartridge-app.git
$ cd deploy-tarantool-cartridge-app && git checkout 1.0.0

Մենք բարձրացնում ենք վիրտուալ մեքենաներ.

$ vagrant up

Տեղադրեք Tarantool Cartridge-ի հիմնական դերը.

$ ansible-galaxy install tarantool.cartridge,1.0.1

Գործարկեք տեղադրված դերը.

$ ansible-playbook -i hosts.yml playbook.yml

Մենք սպասում ենք խաղատախտակի կատարման ավարտին, գնացեք http://localhost:8181/admin/cluster/dashboard և վայելեք արդյունքը.

Դուք կարող եք լցնել տվյալները: Թույն, չէ՞:

Հիմա եկեք պարզենք, թե ինչպես աշխատել դրա հետ, և միևնույն ժամանակ տոպոլոգիայում ավելացնենք ևս մեկ կրկնօրինակ հավաքածու:

Մենք սկսում ենք հասկանալ

Եւ ինչ պատահեց?

Մենք երկու VM-ներ պատրաստեցինք և գործարկեցինք անուսանելի խաղագիրք, որը ստեղծեց մեր կլաստերը: Եկեք նայենք ֆայլի բովանդակությանը playbook.yml:

---
- name: Deploy my Tarantool Cartridge app
  hosts: all
  become: true
  become_user: root
  tasks:
  - name: Import Tarantool Cartridge role
    import_role:
      name: tarantool.cartridge

Այստեղ ոչ մի հետաքրքիր բան տեղի չի ունենում, մենք սկսում ենք ansible-role-ը, որը կոչվում է tarantool.cartridge.

Ամենակարևորը (մասնավորապես՝ կլաստերի կոնֆիգուրացիան) գտնվում է այստեղ գույքացուցակ- ֆայլ hosts.yml:

---
all:
  vars:
    # common cluster variables
    cartridge_app_name: getting-started-app
    cartridge_package_path: ./getting-started-app-1.0.0-0.rpm  # path to package

    cartridge_cluster_cookie: app-default-cookie  # cluster cookie

    # common ssh options
    ansible_ssh_private_key_file: ~/.vagrant.d/insecure_private_key
    ansible_ssh_common_args: '-o IdentitiesOnly=yes -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no'

  # INSTANCES
  hosts:
    storage-1:
      config:
        advertise_uri: '172.19.0.2:3301'
        http_port: 8181

    app-1:
      config:
        advertise_uri: '172.19.0.3:3301'
        http_port: 8182

    storage-1-replica:
      config:
        advertise_uri: '172.19.0.3:3302'
        http_port: 8183

  children:
    # GROUP INSTANCES BY MACHINES
    host1:
      vars:
        # first machine connection options
        ansible_host: 172.19.0.2
        ansible_user: vagrant

      hosts:  # instances to be started on the first machine
        storage-1:

    host2:
      vars:
        # second machine connection options
        ansible_host: 172.19.0.3
        ansible_user: vagrant

      hosts:  # instances to be started on the second machine
        app-1:
        storage-1-replica:

    # GROUP INSTANCES BY REPLICA SETS
    replicaset_app_1:
      vars:  # replica set configuration
        replicaset_alias: app-1
        failover_priority:
          - app-1  # leader
        roles:
          - 'api'

      hosts:  # replica set instances
        app-1:

    replicaset_storage_1:
      vars:  # replica set configuration
        replicaset_alias: storage-1
        weight: 3
        failover_priority:
          - storage-1  # leader
          - storage-1-replica
        roles:
          - 'storage'

      hosts:   # replica set instances
        storage-1:
        storage-1-replica:

Մեզ անհրաժեշտ է միայն սովորել, թե ինչպես կառավարել օրինակները և կրկնօրինակների հավաքածուները՝ փոխելով այս ֆայլի բովանդակությունը: Հաջորդը, մենք կավելացնենք նոր բաժիններ դրան: Որպեսզի չշփոթվեք, թե որտեղ ավելացնել դրանք, կարող եք դիտել այս ֆայլի վերջնական տարբերակը, hosts.updated.yml, որը գտնվում է օրինակի պահոցում։

Օրինակների կառավարում

Ansible-ի առումով յուրաքանչյուր օրինակ հոսթ է (չշփոթել երկաթյա սերվերի հետ), այսինքն. ենթակառուցվածքի հանգույցը, որը կկառավարի Ansible-ը: Յուրաքանչյուր հոսթի համար մենք կարող ենք նշել կապի պարամետրերը (օրինակ ansible_host и ansible_user), ինչպես նաև օրինակի կոնֆիգուրացիան: Դեպքերի նկարագրությունը բաժնում է hosts.

Դիտարկենք օրինակի կոնֆիգուրացիան storage-1:

all:
  vars:
    ...

  # INSTANCES
  hosts:
    storage-1:
      config:
        advertise_uri: '172.19.0.2:3301'
        http_port: 8181

  ...

Փոփոխականի մեջ config մենք նշել ենք օրինակի պարամետրերը. advertise URI и HTTP port.
Ստորև ներկայացված են օրինակի պարամետրերը app-1 и storage-1-replica.

Մենք պետք է Ansible-ին ասենք կապի պարամետրերը յուրաքանչյուր օրինակի համար: Թվում է, թե տրամաբանական է օրինակները խմբավորել վիրտուալ մեքենաների խմբերի մեջ: Դա անելու համար ատյանները միավորվում են խմբերի: host1 и host2, և յուրաքանչյուր խմբում բաժնում vars արժեքներ ansible_host и ansible_user մեկ վիրտուալ մեքենայի համար: Իսկ բաժնում hosts - հյուրընկալողներ (նրանք օրինակներ են), որոնք ներառված են այս խմբում.

all:
  vars:
    ...
  hosts:
    ...
  children:
    # GROUP INSTANCES BY MACHINES
    host1:
      vars:
        # first machine connection options
        ansible_host: 172.19.0.2
        ansible_user: vagrant
       hosts:  # instances to be started on the first machine
        storage-1:

     host2:
      vars:
        # second machine connection options
        ansible_host: 172.19.0.3
        ansible_user: vagrant
       hosts:  # instances to be started on the second machine
        app-1:
        storage-1-replica:

Մենք սկսում ենք փոխվել hosts.yml. Ավելացնենք ևս երկու դեպք. storage-2-replica առաջին վիրտուալ մեքենայի վրա և storage-2 Երկրորդի վրա.

all:
  vars:
    ...

  # INSTANCES
  hosts:
    ...
    storage-2:  # <==
      config:
        advertise_uri: '172.19.0.3:3303'
        http_port: 8184

    storage-2-replica:  # <==
      config:
        advertise_uri: '172.19.0.2:3302'
        http_port: 8185

  children:
    # GROUP INSTANCES BY MACHINES
    host1:
      vars:
        ...
      hosts:  # instances to be started on the first machine
        storage-1:
        storage-2-replica:  # <==

    host2:
      vars:
        ...
      hosts:  # instances to be started on the second machine
        app-1:
        storage-1-replica:
        storage-2:  # <==
  ...

Գործարկել ansible playbook.

$ ansible-playbook -i hosts.yml 
                   --limit storage-2,storage-2-replica 
                   playbook.yml

Ուշադրություն դարձրեք տարբերակին --limit. Քանի որ յուրաքանչյուր կլաստերային օրինակ Ansible-ի տերմիններով հոսթ է, մենք կարող ենք հստակորեն նշել, թե որ օրինակները պետք է կազմաձևվեն խաղագիրքը գործարկելիս:

Վերադարձ դեպի Վեբ միջերես http://localhost:8181/admin/cluster/dashboard և դիտեք մեր նոր դեպքերը.

Մենք չենք հանգստանա մեր դափնիների վրա և կտիրապետենք տոպոլոգիայի վերահսկմանը։

Տոպոլոգիայի կառավարում

Եկեք միաձուլենք մեր նոր օրինակները կրկնօրինակման հավաքածուի մեջ storage-2. Ավելացնել նոր խումբ replicaset_storage_2 և իր փոփոխականներում նկարագրեք ռեպլիկասեթի պարամետրերը անալոգիայով replicaset_storage_1. Բաժնում hosts նշեք, թե որ օրինակները կներառվեն այս խմբում (այսինքն՝ մեր կրկնօրինակների հավաքածուն).

---
all:
  vars:
    ...
  hosts:
    ...
  children:
    ...
    # GROUP INSTANCES BY REPLICA SETS
    ...
    replicaset_storage_2:  # <==
      vars:  # replicaset configuration
        replicaset_alias: storage-2
        weight: 2
        failover_priority:
          - storage-2
          - storage-2-replica
        roles:
          - 'storage'

      hosts:   # replicaset instances
        storage-2:
        storage-2-replica:

Եկեք նորից սկսենք խաղագիրքը.

$ ansible-playbook -i hosts.yml 
                   --limit replicaset_storage_2 
                   --tags cartridge-replicasets 
                   playbook.yml

Պարամետրով --limit մենք այս անգամ փոխանցեցինք այն խմբի անունը, որը համապատասխանում է մեր ռեպլիկասեթին:

Մտածեք տարբերակը tags.

Մեր դերը հաջորդաբար կատարում է տարբեր առաջադրանքներ, որոնք նշվում են հետևյալ պիտակներով.

• cartridge-instancesօրինակների կառավարում (կոնֆիգուրացիա, միացում անդամակցությանը);
• cartridge-replicasetsտոպոլոգիայի կառավարում (կրկնօրինակների հավաքածուի կառավարում և կլաստերից ատյանների մշտական ​​հեռացում (արտաքսում));
• cartridge-configկառավարել այլ կլաստերի պարամետրերը (vshard bootstrapping, ավտոմատ ձախողման ռեժիմ, թույլտվության պարամետրեր և հավելվածի կազմաձևում):

Մենք կարող ենք հստակորեն նշել, թե աշխատանքի որ մասն ենք ուզում անել, այնուհետև դերը բաց կթողնի մնացած առաջադրանքները: Մեր դեպքում մենք ուզում ենք աշխատել միայն տոպոլոգիայի հետ, ուստի մենք հստակեցրել ենք cartridge-replicasets.

Եկեք գնահատենք մեր ջանքերի արդյունքը։ Նոր կրկնօրինակման հավաքածուի որոնում http://localhost:8181/admin/cluster/dashboard.

Hooray!

Փորձեք վերակազմավորելով օրինակները և կրկնօրինակող հավաքածուները և տեսեք, թե ինչպես է փոխվում կլաստերի տոպոլոգիան: Դուք կարող եք փորձել տարբեր գործառնական սցենարներ, օրինակ. շարժական թարմացում կամ ավելացնել memtx_memory. Դոլը կփորձի դա անել առանց օրինակը վերագործարկելու՝ ձեր հավելվածի հնարավոր խափանումները նվազեցնելու համար:

Մի մոռացեք վազել vagrant haltդադարեցնել VM-ները, երբ ավարտեք դրանց հետ աշխատելը:

Իսկ ինչ կա գլխարկի տակ:

Այստեղ ես ավելի շատ կխոսեմ այն ​​մասին, թե ինչ է տեղի ունեցել մեր փորձերի ընթացքում անսխալ դերի տակ:

Եկեք քայլ առ քայլ նայենք Քարթրիջ հավելվածի տեղակայմանը:

Փաթեթի տեղադրում և մեկնարկային օրինակներ

Նախ անհրաժեշտ է փաթեթը հասցնել սերվերին և տեղադրել այն: Այժմ դերը կարող է աշխատել RPM և DEB փաթեթների հետ:

Հաջորդը, մենք գործարկում ենք օրինակները: Այստեղ ամեն ինչ շատ պարզ է. յուրաքանչյուր օրինակ առանձին է systemd- ծառայություն. Ես խոսում եմ օրինակի մասին.

$ systemctl start myapp@storage-1

Այս հրամանը կգործարկի օրինակը storage-1 հավելվածներ myapp. Գործարկված օրինակը կփնտրի իր կոնֆիգուրացիա в /etc/tarantool/conf.d/. Օրինակների տեղեկամատյանները կարելի է դիտել՝ օգտագործելով journald.

Միավոր ֆայլ /etc/systemd/system/[email protected] համակարգային ծառայության համար կառաքվի փաթեթի հետ միասին։

Ansible-ն ունի ներկառուցված մոդուլներ փաթեթներ տեղադրելու և համակարգային ծառայություններ կառավարելու համար, մենք այստեղ նոր բան չենք հորինել։

Կլաստերային տոպոլոգիայի կարգավորում

Եվ այստեղ սկսվում է ամենահետաքրքիրը. Համաձայն եմ, տարօրինակ կլիներ անհանգստանալ փաթեթներ տեղադրելու և գործարկելու համար հատուկ անսխալ դերով systemd-ծառայություններ:

Դուք կարող եք ձեռքով կարգավորել կլաստերը.

• Առաջին տարբերակը՝ բացեք վեբ միջերեսը և սեղմեք կոճակների վրա։ Մի քանի օրինակների միանվագ մեկնարկի համար դա բավականին հարմար է:
• Երկրորդ տարբերակ. կարող եք օգտագործել GraphQl API-ն: Այստեղ արդեն կարող եք ինչ-որ բան ավտոմատացնել, օրինակ՝ գրել սկրիպտ Python-ում։
• Երրորդ տարբերակը (ոգով ուժեղների համար). գնալ սերվեր, միանալ ատյաններից մեկին՝ օգտագործելով tarantoolctl connect և կատարել բոլոր անհրաժեշտ մանիպուլյացիաները Lua մոդուլի միջոցով cartridge.

Մեր գյուտի հիմնական խնդիրն է դա անել՝ աշխատանքի ամենադժվար մասը ձեզ համար։

Ansible-ը թույլ է տալիս գրել ձեր սեփական մոդուլը և օգտագործել այն դերում: Մեր դերն օգտագործում է այս մոդուլները՝ կլաստերի տարբեր բաղադրիչները կառավարելու համար:

Ինչպես է դա աշխատում? Դուք նկարագրում եք կլաստերի ցանկալի վիճակը դեկլարատիվ կազմաձևում, և դերը տալիս է յուրաքանչյուր մոդուլի իր կազմաձևման բաժինը որպես մուտքագրում: Մոդուլը ստանում է կլաստերի ներկայիս վիճակը և համեմատում այն ​​մուտքագրման հետ: Այնուհետև, օրինակներից մեկի վարդակից գործարկվում է ծածկագիր, որը կլաստերին բերում է ցանկալի վիճակի:

Արդյունքները

Այսօր մենք պատմեցինք և ցույց տվեցինք, թե ինչպես կարելի է տեղադրել ձեր հավելվածը Tarantool Քարտրիջում և ստեղծել պարզ տոպոլոգիա: Դա անելու համար մենք օգտագործեցինք Ansible-ը, հզոր գործիք, որը հեշտ է օգտագործել և թույլ է տալիս միաժամանակ կարգավորել բազմաթիվ ենթակառուցվածքային հանգույցներ (մեր դեպքում դրանք կլաստերային օրինակներ են):

Վերևում մենք գործ ունենք Ansible-ի միջոցով կլաստերի կազմաձևումը նկարագրելու բազմաթիվ եղանակներից մեկի հետ: Երբ իմանաք, որ պատրաստ եք առաջ գնալ, սովորեք լավագույն փորձ խաղային գրքեր գրելու համար. Դուք կարող եք ավելի հարմար գտնել տոպոլոգիայի հետ կառավարելը group_vars и host_vars.

Շատ շուտով մենք ձեզ կպատմենք, թե ինչպես ընդմիշտ հեռացնել (արտահանել) օրինակները տոպոլոգիայից, bootstrap vshard-ը, կառավարել ավտոմատ ձախողման ռեժիմը, կարգավորել թույլտվությունը և կարկատել կլաստերի կազմաձևը: Այդ ընթացքում կարող եք ինքնուրույն սովորել փաստաթղթեր և փորձ՝ փոխելով կլաստերի պարամետրերը:

Եթե ​​ինչ-որ բան չի ստացվում, վստահ եղեք ինձ տեղյակ պահեք մեզ խնդրի մասին։ Մենք այն արագ կքանդենք:

Source: www.habr.com