ನಾವು ಈಗಾಗಲೇ ಮಾತನಾಡಿದ್ದೇವೆ ಟ್ಯಾರಂಟೂಲ್ ಕಾರ್ಟ್ರಿಡ್ಜ್, ಇದು ನಿಮಗೆ ವಿತರಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು ಪ್ಯಾಕೇಜ್ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಈ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿಯೋಜಿಸುವುದು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ಕಲಿಯುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ. ಚಿಂತಿಸಬೇಡಿ, ನಾವು ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿದೆ! ಟ್ಯಾರಂಟೂಲ್ ಕಾರ್ಟ್ರಿಡ್ಜ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು ಎಲ್ಲಾ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಿದ್ದೇವೆ ಮತ್ತು ಬರೆದಿದ್ದೇವೆ ಪ್ರಮುಖ ಪಾತ್ರ, ಇದು ಸರ್ವರ್‌ಗಳಿಗೆ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ವಿತರಿಸುತ್ತದೆ, ನಿದರ್ಶನಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ಕ್ಲಸ್ಟರ್‌ಗೆ ಒಂದುಗೂಡಿಸುತ್ತದೆ, ದೃಢೀಕರಣವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ, ಬೂಟ್‌ಸ್ಟ್ರ್ಯಾಪ್ vshard, ಸ್ವಯಂಚಾಲಿತ ವೈಫಲ್ಯವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಸಂರಚನೆಯನ್ನು ಪ್ಯಾಚ್ ಮಾಡುತ್ತದೆ.

ಆಸಕ್ತಿದಾಯಕ? ನಂತರ ದಯವಿಟ್ಟು, ಕಟ್ ಅಡಿಯಲ್ಲಿ, ನಾವು ನಿಮಗೆ ಹೇಳುತ್ತೇವೆ ಮತ್ತು ಎಲ್ಲವನ್ನೂ ತೋರಿಸುತ್ತೇವೆ.

ಒಂದು ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ

ನಾವು ನಮ್ಮ ಪಾತ್ರದ ಕ್ರಿಯಾತ್ಮಕತೆಯ ಭಾಗವನ್ನು ಮಾತ್ರ ನೋಡುತ್ತೇವೆ. ಅದರ ಎಲ್ಲಾ ಸಾಮರ್ಥ್ಯಗಳು ಮತ್ತು ಇನ್‌ಪುಟ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳ ಸಂಪೂರ್ಣ ವಿವರಣೆಯನ್ನು ನೀವು ಯಾವಾಗಲೂ ಕಾಣಬಹುದು ದಸ್ತಾವೇಜನ್ನು. ಆದರೆ ನೂರು ಬಾರಿ ನೋಡುವುದಕ್ಕಿಂತ ಒಮ್ಮೆ ಪ್ರಯತ್ನಿಸುವುದು ಉತ್ತಮ, ಆದ್ದರಿಂದ ನಾವು ಸಣ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸೋಣ.

ಟ್ಯಾರಂಟೂಲ್ ಕಾರ್ಟ್ರಿಡ್ಜ್ ಹೊಂದಿದೆ ಟ್ಯುಟೋರಿಯಲ್ ಬ್ಯಾಂಕ್ ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ಅವರ ಖಾತೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಸಣ್ಣ ಕಾರ್ಟ್ರಿಡ್ಜ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲು ಮತ್ತು 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. ಪ್ರತಿ ಕ್ಲಸ್ಟರ್ ನಿದರ್ಶನವು ಅನ್ಸಿಬಲ್ ಪದಗಳಲ್ಲಿ ಹೋಸ್ಟ್ ಆಗಿರುವುದರಿಂದ, ಪ್ಲೇಬುಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ಯಾವ ನಿದರ್ಶನಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು.

ವೆಬ್ 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ವರ್ಚುವಲ್ ಯಂತ್ರಗಳೊಂದಿಗೆ ನೀವು ಕೆಲಸ ಮಾಡಿದ ನಂತರ ಅವುಗಳನ್ನು ನಿಲ್ಲಿಸಲು.

ಮತ್ತು ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಏನಿದೆ?

ನಮ್ಮ ಪ್ರಯೋಗಗಳ ಸಮಯದಲ್ಲಿ ಅನ್ಸಿಬಲ್ ಪಾತ್ರದ ಅಡಿಯಲ್ಲಿ ಏನಾಗುತ್ತಿದೆ ಎಂಬುದರ ಕುರಿತು ಇಲ್ಲಿ ನಾನು ನಿಮಗೆ ಹೆಚ್ಚು ಹೇಳುತ್ತೇನೆ.

ಕಾರ್ಟ್ರಿಡ್ಜ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹಂತ ಹಂತವಾಗಿ ನಿಯೋಜಿಸುವುದನ್ನು ನೋಡೋಣ.

ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ನಿದರ್ಶನಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವುದು

ಮೊದಲು ನೀವು ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಸರ್ವರ್‌ಗೆ ತಲುಪಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ಸ್ಥಾಪಿಸಬೇಕು. ಪ್ರಸ್ತುತ ಪಾತ್ರವು 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-ಸೇವೆಗಳು.

ನೀವು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು:

• ಮೊದಲ ಆಯ್ಕೆ: ವೆಬ್ UI ತೆರೆಯಿರಿ ಮತ್ತು ಬಟನ್‌ಗಳ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ. ಹಲವಾರು ನಿದರ್ಶನಗಳ ಒಂದು-ಬಾರಿ ಪ್ರಾರಂಭಕ್ಕೆ ಇದು ಸಾಕಷ್ಟು ಸೂಕ್ತವಾಗಿದೆ.
• ಎರಡನೇ ಆಯ್ಕೆ: ನೀವು GraphQl API ಅನ್ನು ಬಳಸಬಹುದು. ಇಲ್ಲಿ ನೀವು ಈಗಾಗಲೇ ಏನನ್ನಾದರೂ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಪೈಥಾನ್‌ನಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಬರೆಯಿರಿ.
• ಮೂರನೇ ಆಯ್ಕೆ (ಬಲವಾದ ಇಚ್ಛಾಶಕ್ತಿಯುಳ್ಳವರಿಗೆ): ಸರ್ವರ್‌ಗೆ ಹೋಗಿ, ಬಳಸಿ ನಿದರ್ಶನಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಸಂಪರ್ಕಪಡಿಸಿ tarantoolctl connect ಮತ್ತು ಲುವಾ ಮಾಡ್ಯೂಲ್‌ನೊಂದಿಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಿ cartridge.

ನಮ್ಮ ಆವಿಷ್ಕಾರದ ಮುಖ್ಯ ಕಾರ್ಯವು ನಿಖರವಾಗಿ ಇದನ್ನು ಮಾಡುವುದು, ನಿಮಗಾಗಿ ಕೆಲಸದ ಅತ್ಯಂತ ಕಷ್ಟಕರವಾದ ಭಾಗವಾಗಿದೆ.

ನಿಮ್ಮ ಸ್ವಂತ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬರೆಯಲು ಮತ್ತು ಅದನ್ನು ಪಾತ್ರದಲ್ಲಿ ಬಳಸಲು ಅನ್ಸಿಬಲ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ವಿವಿಧ ಕ್ಲಸ್ಟರ್ ಘಟಕಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನಮ್ಮ ಪಾತ್ರವು ಅಂತಹ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ? ಕ್ಲಸ್ಟರ್‌ನ ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಯನ್ನು ಘೋಷಣಾ ಸಂರಚನೆಯಲ್ಲಿ ನೀವು ವಿವರಿಸುತ್ತೀರಿ, ಮತ್ತು ಪಾತ್ರವು ಪ್ರತಿ ಮಾಡ್ಯೂಲ್‌ಗೆ ಅದರ ಕಾನ್ಫಿಗರೇಶನ್ ವಿಭಾಗವನ್ನು ಇನ್‌ಪುಟ್‌ನಂತೆ ಒದಗಿಸುತ್ತದೆ. ಮಾಡ್ಯೂಲ್ ಕ್ಲಸ್ಟರ್‌ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಇನ್‌ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸಿದ ಸಂಗತಿಗಳೊಂದಿಗೆ ಹೋಲಿಸುತ್ತದೆ. ಮುಂದೆ, ಒಂದು ನಿದರ್ಶನದ ಸಾಕೆಟ್ ಮೂಲಕ ಕೋಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ, ಅದು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಬಯಸಿದ ಸ್ಥಿತಿಗೆ ತರುತ್ತದೆ.

ಫಲಿತಾಂಶಗಳು

ಇಂದು ನಾವು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಟ್ಯಾರಂಟೂಲ್ ಕಾರ್ಟ್ರಿಡ್ಜ್‌ಗೆ ನಿಯೋಜಿಸುವುದು ಮತ್ತು ಸರಳ ಟೋಪೋಲಜಿಯನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು ಎಂದು ಹೇಳಿದ್ದೇವೆ ಮತ್ತು ತೋರಿಸಿದ್ದೇವೆ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಅನ್ಸಿಬಲ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ - ಇದು ಬಳಸಲು ಸುಲಭವಾದ ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ ಮತ್ತು ಏಕಕಾಲದಲ್ಲಿ ಅನೇಕ ಮೂಲಸೌಕರ್ಯ ನೋಡ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಕ್ಲಸ್ಟರ್ ನಿದರ್ಶನಗಳು).

Ansible ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲಸ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ವಿವರಿಸುವ ಹಲವು ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ನಾವು ಮೇಲೆ ನೋಡಿದ್ದೇವೆ. ಒಮ್ಮೆ ನೀವು ಮುಂದುವರಿಯಲು ಸಿದ್ಧರಾಗಿದ್ದರೆ, ಅನ್ವೇಷಿಸಿ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು ಆಟದ ಪುಸ್ತಕಗಳನ್ನು ಬರೆಯುವುದರ ಮೇಲೆ. ಬಳಸಿ ನಿಮ್ಮ ಟೋಪೋಲಜಿಯನ್ನು ನಿರ್ವಹಿಸುವುದು ನಿಮಗೆ ಸುಲಭವಾಗಬಹುದು group_vars и host_vars.

ಟೋಪೋಲಜಿಯಿಂದ ನಿದರ್ಶನಗಳನ್ನು ಶಾಶ್ವತವಾಗಿ ಅಳಿಸುವುದು (ಹೊರಹಾಕುವುದು), ಬೂಟ್‌ಸ್ಟ್ರ್ಯಾಪ್ vshard, ಸ್ವಯಂಚಾಲಿತ ವಿಫಲ ಮೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು, ದೃಢೀಕರಣವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವುದು ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಸಂರಚನೆಯನ್ನು ಪ್ಯಾಚ್ ಮಾಡುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಶೀಘ್ರದಲ್ಲೇ ನಾವು ನಿಮಗೆ ತಿಳಿಸುತ್ತೇವೆ. ಈ ಮಧ್ಯೆ, ನೀವು ಸ್ವಂತವಾಗಿ ಅಧ್ಯಯನ ಮಾಡಬಹುದು ದಸ್ತಾವೇಜನ್ನು ಮತ್ತು ಕ್ಲಸ್ಟರ್ ನಿಯತಾಂಕಗಳನ್ನು ಬದಲಾಯಿಸುವ ಪ್ರಯೋಗ.

ಏನಾದರೂ ಕೆಲಸ ಮಾಡದಿದ್ದರೆ, ಖಚಿತವಾಗಿರಿ ನನಗೆ ತಿಳಿಸು ಸಮಸ್ಯೆಯ ಬಗ್ಗೆ ನಮಗೆ. ನಾವು ಎಲ್ಲವನ್ನೂ ತ್ವರಿತವಾಗಿ ವಿಂಗಡಿಸುತ್ತೇವೆ!

ಮೂಲ: www.habr.com