અમે પહેલાથી જ વિશે વાત કરી છે ટેરેન્ટૂલ કારતૂસ, જે તમને વિતરિત એપ્લિકેશનો વિકસાવવા અને તેમને પેકેજ કરવાની મંજૂરી આપે છે. ત્યાં કંઈ બાકી નથી: આ એપ્લિકેશનોને કેવી રીતે જમાવવા અને સંચાલિત કરવી તે શીખો. ચિંતા કરશો નહીં, અમે બધું જ વિચાર્યું છે! અમે Tarantool Cartridge સાથે કામ કરવા માટેની તમામ શ્રેષ્ઠ પદ્ધતિઓ એકસાથે મૂકી છે અને લખ્યું છે જવાબદાર ભૂમિકા, જે પેકેજને સર્વર્સમાં વિઘટિત કરશે, દાખલાઓ શરૂ કરશે, તેમને ક્લસ્ટરમાં જોડશે, અધિકૃતતા રૂપરેખાંકિત કરશે, vshard બુટસ્ટ્રેપ કરશે, સ્વચાલિત ફેલઓવરને સક્ષમ કરશે અને ક્લસ્ટર રૂપરેખાને પેચ કરશે.

રસપ્રદ? પછી હું કટ હેઠળ પૂછું છું, અમે બધું કહીશું અને બતાવીશું.

ચાલો એક ઉદાહરણથી શરૂઆત કરીએ

અમે અમારી ભૂમિકાની કાર્યક્ષમતાનો માત્ર એક ભાગ આવરી લઈશું. તમે હંમેશા તેની તમામ સુવિધાઓ અને ઇનપુટ પરિમાણોનું સંપૂર્ણ વર્ણન મેળવી શકો છો દસ્તાવેજીકરણ. પરંતુ સો વખત જોવા કરતાં એકવાર પ્રયાસ કરવો વધુ સારું છે, તેથી ચાલો એક નાની એપ્લિકેશનનો ઉપયોગ કરીએ.

ટેરન્ટૂલ કારતૂસ ધરાવે છે ટ્યુટોરીયલ એક નાની કારતૂસ એપ્લિકેશન બનાવવા માટે જે બેંક ગ્રાહકો અને તેમના ખાતાઓ વિશેની માહિતી સંગ્રહિત કરે છે, અને HTTP દ્વારા ડેટા મેનેજ કરવા માટે API પણ પ્રદાન કરે છે. આ કરવા માટે, એપ્લિકેશન બે સંભવિત ભૂમિકાઓનું વર્ણન કરે છે: api и storageજે દાખલાઓને સોંપી શકાય છે.

કારતૂસ પોતે પ્રક્રિયાઓ કેવી રીતે શરૂ કરવી તે વિશે કશું કહેતું નથી, તે ફક્ત પહેલાથી ચાલી રહેલા ઉદાહરણોને ગોઠવવાની ક્ષમતા પ્રદાન કરે છે. વપરાશકર્તાએ બાકીનું જાતે કરવું જોઈએ: રૂપરેખાંકન ફાઇલોને વિઘટિત કરવી, સેવાઓ શરૂ કરવી અને ટોપોલોજી સેટ કરવી. પણ અમે આ બધું નહીં કરીએ, જવાબીબલ અમારા માટે કરશે.

શબ્દોથી કાર્યો સુધી

તેથી, ચાલો અમારી એપ્લિકેશનને બે વર્ચ્યુઅલ મશીનો પર જમાવીએ અને એક સરળ ટોપોલોજી સેટ કરીએ:

• પ્રતિકૃતિ app-1 ભૂમિકા ભજવશે apiજેમાં ભૂમિકાનો સમાવેશ થાય છે vshard-router. અહીં માત્ર એક જ દાખલો હશે.
• પ્રતિકૃતિ storage-1 ભૂમિકાનો અમલ કરે છે storage (અને તે જ સમયે vshard-storage), અહીં આપણે વિવિધ મશીનોમાંથી બે ઉદાહરણો ઉમેરીએ છીએ.

ઉદાહરણ ચલાવવા માટે, અમને જરૂર છે જાગ્રત и Ansible (સંસ્કરણ 2.8 અથવા પછીનું).

ભૂમિકા પોતે જ છે જવાબી ગેલેક્સી. આ એક ભંડાર છે જે તમને તમારું કાર્ય શેર કરવા અને તૈયાર ભૂમિકાઓનો ઉપયોગ કરવાની મંજૂરી આપે છે.

ઉદાહરણ સાથે રીપોઝીટરીને ક્લોન કરો:

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

અમે વર્ચ્યુઅલ મશીનો ઉભા કરીએ છીએ:

$ vagrant up

ટેરન્ટૂલ કારતૂસને જવાબદાર ભૂમિકા સ્થાપિત કરો:

$ 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

અહીં કશું જ રસપ્રદ થતું નથી, અમે જવાબી ભૂમિકા શરૂ કરીએ છીએ, જેને કહેવાય છે 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_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 -i hosts.yml 
                   --limit storage-2,storage-2-replica 
                   playbook.yml

વિકલ્પ પર ધ્યાન આપો --limit. દરેક ક્લસ્ટર ઇન્સ્ટન્સ એન્સિબલ શરતોમાં યજમાન હોવાથી, અમે સ્પષ્ટપણે સ્પષ્ટ કરી શકીએ છીએ કે પ્લેબુક ચલાવતી વખતે કઈ ઘટનાઓ ગોઠવવી જોઈએ.

વેબ UI પર પાછા જાઓ 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 બુટસ્ટ્રેપિંગ, ઓટોમેટિક ફેલઓવર મોડ, અધિકૃતતા પરિમાણો અને એપ્લિકેશન ગોઠવણી).

અમે સ્પષ્ટપણે સ્પષ્ટ કરી શકીએ છીએ કે અમે કાર્યનો કયો ભાગ કરવા માંગીએ છીએ, પછી ભૂમિકા બાકીના કાર્યોને છોડી દેશે. અમારા કિસ્સામાં, અમે ફક્ત ટોપોલોજી સાથે કામ કરવા માંગીએ છીએ, તેથી અમે સ્પષ્ટ કર્યું છે cartridge-replicasets.

ચાલો આપણા પ્રયત્નોના પરિણામનું મૂલ્યાંકન કરીએ. નવી પ્રતિકૃતિ શોધવી http://localhost:8181/admin/cluster/dashboard.

હુરે!

પુનઃરૂપરેખાંકિત ઉદાહરણો અને પ્રતિકૃતિઓ સાથે પ્રયોગ કરો અને જુઓ કે ક્લસ્ટર ટોપોલોજી કેવી રીતે બદલાય છે. તમે વિવિધ ઓપરેશનલ દૃશ્યો અજમાવી શકો છો, ઉદાહરણ તરીકે, રોલિંગ અપડેટ અથવા વધારો memtx_memory. ભૂમિકા તમારી એપ્લિકેશનના સંભવિત ડાઉનટાઇમને ઘટાડવા માટે ઉદાહરણને પુનઃપ્રારંભ કર્યા વિના આ કરવાનો પ્રયાસ કરશે.

દોડવાનું ભૂલશો નહીં vagrant haltજ્યારે તમે VM ને પૂર્ણ કરી લો ત્યારે તેને રોકવા માટે.

હૂડ હેઠળ શું છે?

અમારા પ્રયોગો દરમિયાન જવાબદાર ભૂમિકાના હૂડ હેઠળ શું થયું તે વિશે હું અહીં વધુ વાત કરીશ.

ચાલો એક કાર્ટિજ એપ્લિકેશનને તબક્કાવાર ગોઠવવા પર એક નજર કરીએ.

પેકેજ ઇન્સ્ટોલ કરી રહ્યા છીએ અને દાખલાઓ શરૂ કરી રહ્યા છીએ

પ્રથમ તમારે પેકેજને સર્વર પર પહોંચાડવાની અને તેને ઇન્સ્ટોલ કરવાની જરૂર છે. હવે ભૂમિકા RPM અને DEB પેકેજો સાથે કામ કરી શકે છે.

આગળ, અમે ઉદાહરણો શરૂ કરીએ છીએ. અહીં બધું ખૂબ જ સરળ છે: દરેક ઉદાહરણ અલગ છે systemd- સેવા. હું એક ઉદાહરણ વિશે વાત કરું છું:

$ systemctl start myapp@storage-1

આ આદેશ દાખલો શરૂ કરશે storage-1 એપ્લિકેશન્સ myapp. લોન્ચ કરેલ દાખલો તેના માટે જોશે રૂપરેખાંકન в /etc/tarantool/conf.d/. ઇન્સ્ટન્સ લોગનો ઉપયોગ કરીને જોઈ શકાય છે journald.

યુનિટ ફાઇલ /etc/systemd/system/myapp@.sevice એક systemd સેવા માટે પેકેજ સાથે વિતરિત કરવામાં આવશે.

Ansible પાસે પેકેજો ઇન્સ્ટોલ કરવા અને સિસ્ટમd સેવાઓનું સંચાલન કરવા માટે બિલ્ટ-ઇન મોડ્યુલો છે, અમે અહીં કંઈપણ નવું શોધ્યું નથી.

ક્લસ્ટર ટોપોલોજી રૂપરેખાંકિત કરી રહ્યા છીએ

અને અહીં સૌથી રસપ્રદ શરૂઆત થાય છે. સંમત થાઓ, પેકેજો ઇન્સ્ટોલ કરવા અને ચલાવવા માટે વિશેષ જવાબદાર ભૂમિકાથી પરેશાન થવું વિચિત્ર હશે systemd-સેવાઓ.

તમે ક્લસ્ટરને મેન્યુઅલી સેટ કરી શકો છો:

• પ્રથમ વિકલ્પ: વેબ UI ખોલો અને બટનો પર ક્લિક કરો. ઘણા ઉદાહરણોની એક-વખતની શરૂઆત માટે, તે એકદમ યોગ્ય છે.
• બીજો વિકલ્પ: તમે GraphQl API નો ઉપયોગ કરી શકો છો. અહીં તમે પહેલેથી જ કંઈક સ્વચાલિત કરી શકો છો, ઉદાહરણ તરીકે, પાયથોનમાં સ્ક્રિપ્ટ લખો.
• ત્રીજો વિકલ્પ (ભાવનામાં મજબૂત માટે): સર્વર પર જાઓ, ઉપયોગ કરીને એક ઉદાહરણ સાથે કનેક્ટ કરો tarantoolctl connect અને લુઆ મોડ્યુલ સાથે તમામ જરૂરી મેનિપ્યુલેશન્સ કરો cartridge.

અમારી શોધનું મુખ્ય કાર્ય આ કરવાનું છે, તમારા માટે કામનો સૌથી મુશ્કેલ ભાગ.

Ansible તમને તમારું પોતાનું મોડ્યુલ લખવા અને ભૂમિકામાં તેનો ઉપયોગ કરવાની મંજૂરી આપે છે. અમારી ભૂમિકા ક્લસ્ટરના વિવિધ ઘટકોનું સંચાલન કરવા માટે આ મોડ્યુલોનો ઉપયોગ કરે છે.

તે કેવી રીતે કામ કરે છે? તમે ઘોષણાત્મક રૂપરેખામાં ક્લસ્ટરની ઇચ્છિત સ્થિતિનું વર્ણન કરો છો, અને ભૂમિકા દરેક મોડ્યુલને તેના રૂપરેખાંકન વિભાગને ઇનપુટ તરીકે આપે છે. મોડ્યુલ ક્લસ્ટરની વર્તમાન સ્થિતિ મેળવે છે અને તેને ઇનપુટ સાથે સરખાવે છે. આગળ, એક કોડ દાખલાઓમાંથી એકના સોકેટ દ્વારા ચલાવવામાં આવે છે, જે ક્લસ્ટરને ઇચ્છિત સ્થિતિમાં લાવે છે.

પરિણામો

આજે અમે જણાવ્યું અને બતાવ્યું કે તમારી એપ્લિકેશનને ટેરન્ટૂલ કારટ્રિજ પર કેવી રીતે ગોઠવવી અને એક સરળ ટોપોલોજી કેવી રીતે સેટ કરવી. આ કરવા માટે, અમે Ansible નો ઉપયોગ કર્યો, એક શક્તિશાળી સાધન જે વાપરવા માટે સરળ છે અને તમને એકસાથે ઘણા ઇન્ફ્રાસ્ટ્રક્ચર નોડ્સને ગોઠવવાની મંજૂરી આપે છે (અમારા કિસ્સામાં, આ ક્લસ્ટર ઉદાહરણો છે).

ઉપર, અમે Ansible નો ઉપયોગ કરીને ક્લસ્ટર રૂપરેખાંકનનું વર્ણન કરવાની ઘણી રીતોમાંથી એક સાથે વ્યવહાર કર્યો. એકવાર તમે જાણો કે તમે આગળ વધવા માટે તૈયાર છો, શીખો શ્રેષ્ઠ પ્રયાસો પ્લેબુક લખવા માટે. સાથે ટોપોલોજીનું સંચાલન કરવું તમને વધુ અનુકૂળ લાગશે group_vars и host_vars.

ખૂબ જ ટૂંક સમયમાં અમે તમને ટોપોલોજી, બુટસ્ટ્રેપ vshard, ઓટોમેટિક ફેલઓવર મોડને મેનેજ કરવા, અધિકૃતતાને રૂપરેખાંકિત કરવા અને ક્લસ્ટર રૂપરેખાને પેચ કેવી રીતે કાયમી ધોરણે દૂર કરવા (કાઢી નાખવી) તે વિશે જણાવીશું. આ દરમિયાન, તમે તમારા પોતાના પર અભ્યાસ કરી શકો છો દસ્તાવેજીકરણ અને ક્લસ્ટર પરિમાણો બદલવાનો પ્રયોગ કરો.

જો કંઈક કામ કરતું નથી, તો ખાતરી કરો જાણ કરો અમને સમસ્યા વિશે. અમે તેને ઝડપથી તોડી નાખીશું!

સોર્સ: www.habr.com