ഞങ്ങൾ ഇതിനകം സംസാരിച്ചു ടാരന്റൂൾ കാട്രിഡ്ജ്, വിതരണം ചെയ്ത ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കാനും അവ പാക്കേജുചെയ്യാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഈ ആപ്ലിക്കേഷനുകൾ എങ്ങനെ വിന്യസിക്കാമെന്നും അവ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നും പഠിക്കുക മാത്രമാണ് അവശേഷിക്കുന്നത്. വിഷമിക്കേണ്ട, ഞങ്ങൾ എല്ലാം കവർ ചെയ്തു! ടാരന്റൂൾ കാട്രിഡ്ജിൽ പ്രവർത്തിക്കുന്നതിനുള്ള എല്ലാ മികച്ച സമ്പ്രദായങ്ങളും ഞങ്ങൾ ഒരുമിച്ചുകൂട്ടി എഴുതി അൻസിബിൾ-റോൾ, ഇത് സെർവറുകളിലേക്ക് പാക്കേജ് വിതരണം ചെയ്യും, ഇൻസ്റ്റൻസുകൾ സമാരംഭിക്കും, അവയെ ഒരു ക്ലസ്റ്ററിലേക്ക് സംയോജിപ്പിക്കും, അംഗീകാരം ക്രമീകരിക്കും, ബൂട്ട്സ്ട്രാപ്പ് vshard, ഓട്ടോമാറ്റിക് പരാജയം പ്രവർത്തനക്ഷമമാക്കുകയും ക്ലസ്റ്റർ കോൺഫിഗറേഷൻ പാച്ച് ചെയ്യുകയും ചെയ്യും.

രസകരമാണോ? അപ്പോൾ ഞാൻ വെട്ടിനു താഴെ ചോദിക്കുന്നു, ഞങ്ങൾ എല്ലാം പറഞ്ഞു കാണിക്കും.

നമുക്ക് ഒരു ഉദാഹരണത്തിൽ നിന്ന് ആരംഭിക്കാം

ഞങ്ങളുടെ റോളിന്റെ പ്രവർത്തനത്തിന്റെ ഒരു ഭാഗം മാത്രമേ ഞങ്ങൾ നോക്കൂ. അതിന്റെ എല്ലാ കഴിവുകളുടെയും ഇൻപുട്ട് പാരാമീറ്ററുകളുടെയും പൂർണ്ണമായ വിവരണം നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും കണ്ടെത്താനാകും പ്രമാണീകരണം. എന്നാൽ നൂറ് തവണ കാണുന്നതിനേക്കാൾ ഒരിക്കൽ ശ്രമിക്കുന്നതാണ് നല്ലത്, അതിനാൽ നമുക്ക് ഒരു ചെറിയ ആപ്ലിക്കേഷൻ വിന്യസിക്കാം.

Tarantool Cartridge ഉണ്ട് ട്യൂട്ടോറിയൽ ബാങ്ക് ക്ലയന്റുകളെയും അവരുടെ അക്കൗണ്ടുകളെയും കുറിച്ചുള്ള വിവരങ്ങൾ സംഭരിക്കുന്ന ഒരു ചെറിയ കാട്രിഡ്ജ് ആപ്ലിക്കേഷൻ സൃഷ്ടിക്കാൻ, കൂടാതെ HTTP വഴി ഡാറ്റ മാനേജ്മെന്റിനായി ഒരു API നൽകുന്നു. ഇത് നേടുന്നതിന്, അനുബന്ധം സാധ്യമായ രണ്ട് റോളുകൾ വിവരിക്കുന്നു: api и storage, ഇത് സന്ദർഭങ്ങളിലേക്ക് നിയോഗിക്കാവുന്നതാണ്.

പ്രോസസുകൾ എങ്ങനെ സമാരംഭിക്കണം എന്നതിനെക്കുറിച്ച് കാട്രിഡ്ജ് തന്നെ ഒന്നും പറയുന്നില്ല, ഇതിനകം പ്രവർത്തിക്കുന്ന സംഭവങ്ങൾ കോൺഫിഗർ ചെയ്യാനുള്ള കഴിവ് മാത്രമേ ഇത് നൽകുന്നുള്ളൂ. ഉപയോക്താവ് ബാക്കിയുള്ളവ സ്വയം ചെയ്യണം: കോൺഫിഗറേഷൻ ഫയലുകൾ ക്രമീകരിക്കുക, സേവനങ്ങൾ ആരംഭിക്കുക, ടോപ്പോളജി കോൺഫിഗർ ചെയ്യുക. എന്നാൽ ഞങ്ങൾ ഇതെല്ലാം ചെയ്യില്ല; അൻസിബിൾ നമുക്ക് വേണ്ടി ചെയ്യും.

വാക്കുകളിൽ നിന്ന് പ്രവൃത്തികളിലേക്ക്

അതിനാൽ, രണ്ട് വെർച്വൽ മെഷീനുകളിലേക്ക് ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ വിന്യസിച്ച് ലളിതമായ ടോപ്പോളജി സജ്ജീകരിക്കാം:

• പകർപ്പ് app-1 പങ്ക് നടപ്പിലാക്കും api, ഇതിൽ വേഷം ഉൾപ്പെടുന്നു vshard-router. ഇവിടെ ഒരു ഉദാഹരണം മാത്രമേ ഉണ്ടാകൂ.
• പകർപ്പ് storage-1 പങ്ക് നടപ്പിലാക്കുന്നു storage (അതേ സമയം vshard-storage), ഇവിടെ ഞങ്ങൾ വ്യത്യസ്ത മെഷീനുകളിൽ നിന്നുള്ള രണ്ട് സന്ദർഭങ്ങൾ ചേർക്കുന്നു.

ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന്, നമുക്ക് ആവശ്യമാണ് വാഗ്‌റന്റ് и അസാധ്യം (പതിപ്പ് 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

Tarantool കാട്രിഡ്ജ് അൻസിബിൾ റോൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

$ ansible-galaxy install tarantool.cartridge,1.0.1

ഇൻസ്റ്റാൾ ചെയ്ത റോൾ പ്രവർത്തിപ്പിക്കുക:

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

പ്ലേബുക്ക് എക്‌സിക്യൂഷൻ പൂർത്തിയാകുന്നതിനായി ഞങ്ങൾ കാത്തിരിക്കുന്നു, ഇതിലേക്ക് പോകുക http://localhost:8181/admin/cluster/dashboard ഫലം ആസ്വദിക്കൂ:

നിങ്ങൾക്ക് ഡാറ്റ പകരാൻ കഴിയും. കൊള്ളാം, അല്ലേ?

ഇത് ഉപയോഗിച്ച് എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് ഇപ്പോൾ നമുക്ക് കണ്ടെത്താം, അതേ സമയം ടോപ്പോളജിയിൽ മറ്റൊരു പകർപ്പ് ചേർക്കുക.

നമുക്ക് അത് കണ്ടുപിടിക്കാൻ തുടങ്ങാം

അതുകൊണ്ട് എന്തു സംഭവിച്ചു?

ഞങ്ങൾ രണ്ട് വെർച്വൽ മെഷീനുകൾ സജ്ജീകരിക്കുകയും ഞങ്ങളുടെ ക്ലസ്റ്റർ കോൺഫിഗർ ചെയ്ത ഒരു അൻസിബിൾ പ്ലേബുക്ക് പുറത്തിറക്കുകയും ചെയ്തു. ഫയലിന്റെ ഉള്ളടക്കം നോക്കാം 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.

ഓരോ സംഭവത്തിനും ഞങ്ങൾ അൻസിബിളിനോട് കണക്ഷൻ പാരാമീറ്ററുകൾ പറയേണ്ടതുണ്ട്. ഉദാഹരണങ്ങൾ വെർച്വൽ മെഷീൻ ഗ്രൂപ്പുകളായി ഗ്രൂപ്പുചെയ്യുന്നത് യുക്തിസഹമാണെന്ന് തോന്നുന്നു. ഇത് ചെയ്യുന്നതിന്, ഉദാഹരണങ്ങൾ ഗ്രൂപ്പുകളായി സംയോജിപ്പിച്ചിരിക്കുന്നു. 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. ഓരോ ക്ലസ്റ്റർ ഇൻസ്‌റ്റൻസും അൻസിബിൾ പദങ്ങളിൽ ഒരു ഹോസ്റ്റ് ആയതിനാൽ, പ്ലേബുക്ക് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഏതൊക്കെ സന്ദർഭങ്ങളാണ് കോൺഫിഗർ ചെയ്യേണ്ടതെന്ന് നമുക്ക് വ്യക്തമായി വ്യക്തമാക്കാൻ കഴിയും.

വെബ് യുഐയിലേക്ക് മടങ്ങുക 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/[email protected] ഒരു systemd സേവനം പാക്കേജിനൊപ്പം വിതരണം ചെയ്യും.

പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും systemd സേവനങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുമുള്ള ബിൽറ്റ്-ഇൻ മൊഡ്യൂളുകൾ Ansible-ൽ ഉണ്ട്, ഞങ്ങൾ ഇവിടെ പുതിയതായി ഒന്നും കണ്ടുപിടിച്ചിട്ടില്ല.

ഒരു ക്ലസ്റ്റർ ടോപ്പോളജി സജ്ജീകരിക്കുന്നു

ഇവിടെയാണ് വിനോദം ആരംഭിക്കുന്നത്. സമ്മതിക്കുന്നു, പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള ഒരു പ്രത്യേക അൻസിബിൾ റോളിൽ വിഷമിക്കുന്നത് വിചിത്രമായിരിക്കും systemd-സേവനങ്ങള്.

നിങ്ങൾക്ക് ക്ലസ്റ്റർ സ്വമേധയാ ക്രമീകരിക്കാൻ കഴിയും:

• ആദ്യ ഓപ്ഷൻ: വെബ് യുഐ തുറന്ന് ബട്ടണുകളിൽ ക്ലിക്ക് ചെയ്യുക. നിരവധി സംഭവങ്ങളുടെ ഒറ്റത്തവണ ആരംഭിക്കുന്നതിന് ഇത് തികച്ചും അനുയോജ്യമാണ്.
• രണ്ടാമത്തെ ഓപ്ഷൻ: നിങ്ങൾക്ക് GraphQl API ഉപയോഗിക്കാം. ഇവിടെ നിങ്ങൾക്ക് ഇതിനകം എന്തെങ്കിലും ഓട്ടോമേറ്റ് ചെയ്യാൻ കഴിയും, ഉദാഹരണത്തിന്, പൈത്തണിൽ ഒരു സ്ക്രിപ്റ്റ് എഴുതുക.
• മൂന്നാമത്തെ ഓപ്‌ഷൻ (ശക്തമായ ഇച്ഛാശക്തിയുള്ളവർക്ക്): സെർവറിലേക്ക് പോകുക, ഉപയോഗിച്ച് ഒരു സന്ദർഭത്തിലേക്ക് കണക്റ്റുചെയ്യുക tarantoolctl connect ലുവാ മൊഡ്യൂൾ ഉപയോഗിച്ച് ആവശ്യമായ എല്ലാ കൃത്രിമത്വങ്ങളും നടത്തുക cartridge.

ഞങ്ങളുടെ കണ്ടുപിടുത്തത്തിന്റെ പ്രധാന ദൌത്യം ഇത് കൃത്യമായി ചെയ്യുക എന്നതാണ്, നിങ്ങൾക്കുള്ള ജോലിയുടെ ഏറ്റവും ബുദ്ധിമുട്ടുള്ള ഭാഗം.

നിങ്ങളുടെ സ്വന്തം മൊഡ്യൂൾ എഴുതാനും ഒരു റോളിൽ ഉപയോഗിക്കാനും അൻസിബിൾ നിങ്ങളെ അനുവദിക്കുന്നു. ക്ലസ്റ്ററിന്റെ വിവിധ ഘടകങ്ങൾ കൈകാര്യം ചെയ്യാൻ ഞങ്ങളുടെ റോൾ ഈ മൊഡ്യൂളുകൾ ഉപയോഗിക്കുന്നു.

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു? ഒരു ഡിക്ലറേറ്റീവ് കോൺഫിഗറേഷനിൽ ക്ലസ്റ്ററിന്റെ ആവശ്യമുള്ള അവസ്ഥ നിങ്ങൾ വിവരിക്കുന്നു, കൂടാതെ റോൾ ഓരോ മൊഡ്യൂളിനും അതിന്റെ കോൺഫിഗറേഷൻ വിഭാഗം ഇൻപുട്ടായി നൽകുന്നു. മൊഡ്യൂൾ ക്ലസ്റ്ററിന്റെ നിലവിലെ അവസ്ഥ സ്വീകരിക്കുകയും ഇൻപുട്ടായി ലഭിച്ചതുമായി താരതമ്യം ചെയ്യുകയും ചെയ്യുന്നു. അടുത്തതായി, ഒരു സംഭവത്തിന്റെ സോക്കറ്റിലൂടെ ഒരു കോഡ് സമാരംഭിക്കുന്നു, അത് ക്ലസ്റ്ററിനെ ആവശ്യമുള്ള അവസ്ഥയിലേക്ക് കൊണ്ടുവരുന്നു.

ഫലങ്ങൾ

ടാരന്റൂൾ കാട്രിഡ്ജിൽ നിങ്ങളുടെ ആപ്ലിക്കേഷൻ എങ്ങനെ വിന്യസിക്കാമെന്നും ഒരു ലളിതമായ ടോപ്പോളജി സജ്ജീകരിക്കാമെന്നും ഇന്ന് ഞങ്ങൾ പറയുകയും കാണിച്ചുതരികയും ചെയ്തു. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ അൻസിബിൾ ഉപയോഗിച്ചു, അത് ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതും നിരവധി ഇൻഫ്രാസ്ട്രക്ചർ നോഡുകൾ ഒരേസമയം ക്രമീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നതുമായ ഒരു ശക്തമായ ഉപകരണമാണ് (ഞങ്ങളുടെ കാര്യത്തിൽ, ഇവ ക്ലസ്റ്റർ സംഭവങ്ങളാണ്).

മുകളിൽ, അൻസിബിൾ ഉപയോഗിച്ച് ക്ലസ്റ്റർ കോൺഫിഗറേഷൻ വിവരിക്കുന്നതിനുള്ള നിരവധി മാർഗങ്ങളിൽ ഒന്ന് ഞങ്ങൾ കൈകാര്യം ചെയ്തു. നിങ്ങൾ മുന്നോട്ട് പോകാൻ തയ്യാറാണെന്ന് അറിഞ്ഞുകഴിഞ്ഞാൽ, പഠിക്കുക മികച്ച രീതികൾ പ്ലേബുക്കുകൾ എഴുതുന്നതിൽ. നിങ്ങളുടെ ടോപ്പോളജി ഉപയോഗിച്ച് നിയന്ത്രിക്കുന്നത് നിങ്ങൾക്ക് എളുപ്പമാണെന്ന് തോന്നിയേക്കാം group_vars и host_vars.

ടോപ്പോളജി, ബൂട്ട്‌സ്‌ട്രാപ്പ് vshard, ഓട്ടോമാറ്റിക് ഫെയ്‌ലോവർ മോഡ് നിയന്ത്രിക്കൽ, അംഗീകാരം ക്രമീകരിക്കൽ, ക്ലസ്റ്റർ കോൺഫിഗർ പാച്ച് എന്നിവയിൽ നിന്ന് എങ്ങനെ ശാശ്വതമായി ഇൻസ്റ്റൻസുകൾ നീക്കം ചെയ്യാമെന്നും (പുറന്തള്ളാമെന്നും) ഉടൻ തന്നെ ഞങ്ങൾ നിങ്ങളോട് പറയും. അതിനിടയിൽ സ്വന്തമായി പഠിക്കാം പ്രമാണീകരണം കൂടാതെ ക്ലസ്റ്റർ പാരാമീറ്ററുകൾ മാറ്റിക്കൊണ്ട് പരീക്ഷിക്കുക.

എന്തെങ്കിലും പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ഉറപ്പാക്കുക അറിയിക്കുക പ്രശ്നത്തെക്കുറിച്ച് ഞങ്ങളോട്. ഞങ്ങൾ അത് വേഗത്തിൽ തകർക്കും!

അവലംബം: www.habr.com