ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਗੱਲ ਕੀਤੀ ਹੈ Tarantool ਕਾਰਟ੍ਰੀਜ, ਜੋ ਤੁਹਾਨੂੰ ਵੰਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਪੈਕੇਜ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਇੱਥੇ ਕੁਝ ਵੀ ਨਹੀਂ ਬਚਿਆ ਹੈ: ਇਹਨਾਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਅਤੇ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਹੈ ਸਿੱਖੋ। ਚਿੰਤਾ ਨਾ ਕਰੋ, ਅਸੀਂ ਸਭ ਕੁਝ ਸੋਚ ਲਿਆ ਹੈ! ਅਸੀਂ Tarantool Cartridge ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਅਭਿਆਸਾਂ ਨੂੰ ਇਕੱਠਾ ਕੀਤਾ ਹੈ ਅਤੇ ਲਿਖਿਆ ਹੈ ਜਵਾਬਦੇਹ-ਭੂਮਿਕਾ, ਜੋ ਪੈਕੇਜ ਨੂੰ ਸਰਵਰਾਂ ਵਿੱਚ ਕੰਪੋਜ਼ ਕਰੇਗਾ, ਉਦਾਹਰਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰੇਗਾ, ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਕਲੱਸਟਰ ਵਿੱਚ ਜੋੜ ਦੇਵੇਗਾ, ਅਧਿਕਾਰ ਸੰਰਚਿਤ ਕਰੇਗਾ, ਬੂਟਸਟਰੈਪ vshard, ਆਟੋਮੈਟਿਕ ਫੇਲਓਵਰ ਨੂੰ ਸਮਰੱਥ ਕਰੇਗਾ ਅਤੇ ਕਲੱਸਟਰ ਸੰਰਚਨਾ ਨੂੰ ਪੈਚ ਕਰੇਗਾ।

ਦਿਲਚਸਪ? ਫਿਰ ਮੈਂ ਕੱਟ ਦੇ ਹੇਠਾਂ ਪੁੱਛਦਾ ਹਾਂ, ਅਸੀਂ ਸਭ ਕੁਝ ਦੱਸਾਂਗੇ ਅਤੇ ਦਿਖਾਵਾਂਗੇ.

ਆਉ ਇੱਕ ਉਦਾਹਰਣ ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰੀਏ

ਅਸੀਂ ਆਪਣੀ ਭੂਮਿਕਾ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਦੇ ਸਿਰਫ ਹਿੱਸੇ ਨੂੰ ਕਵਰ ਕਰਾਂਗੇ। ਤੁਸੀਂ ਹਮੇਸ਼ਾਂ ਇਸ ਦੀਆਂ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਇਨਪੁਟ ਪੈਰਾਮੀਟਰਾਂ ਦਾ ਪੂਰਾ ਵੇਰਵਾ ਲੱਭ ਸਕਦੇ ਹੋ ਦਸਤਾਵੇਜ਼. ਪਰ ਸੌ ਵਾਰ ਦੇਖਣ ਨਾਲੋਂ ਇੱਕ ਵਾਰ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਬਿਹਤਰ ਹੈ, ਇਸ ਲਈ ਆਓ ਇੱਕ ਛੋਟੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰੀਏ।

ਤਰਨਟੂਲ ਕਾਰਟ੍ਰੀਜ ਕੋਲ ਹੈ ਟਿਊਟੋਰਿਅਲ ਇੱਕ ਛੋਟੀ ਕਾਰਟ੍ਰੀਜ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਜੋ ਬੈਂਕ ਗਾਹਕਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਖਾਤਿਆਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕਰਦੀ ਹੈ, ਅਤੇ HTTP ਦੁਆਰਾ ਡੇਟਾ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਇੱਕ API ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਐਪਲੀਕੇਸ਼ਨ ਦੋ ਸੰਭਵ ਭੂਮਿਕਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਦੀ ਹੈ: api и storageਜੋ ਕਿ ਉਦਾਹਰਨਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਕਾਰਟ੍ਰੀਜ ਖੁਦ ਇਸ ਬਾਰੇ ਕੁਝ ਨਹੀਂ ਕਹਿੰਦਾ ਕਿ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ, ਇਹ ਸਿਰਫ ਪਹਿਲਾਂ ਤੋਂ ਚੱਲ ਰਹੇ ਉਦਾਹਰਣਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਯੋਗਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ. ਉਪਭੋਗਤਾ ਨੂੰ ਬਾਕੀ ਖੁਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ: ਸੰਰਚਨਾ ਫਾਈਲਾਂ ਨੂੰ ਕੰਪੋਜ਼ ਕਰੋ, ਸੇਵਾਵਾਂ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਟੌਪੋਲੋਜੀ ਸੈਟ ਅਪ ਕਰੋ। ਪਰ ਅਸੀਂ ਇਹ ਸਭ ਨਹੀਂ ਕਰਾਂਗੇ, ਜਵਾਬਦੇਹ ਇਹ ਸਾਡੇ ਲਈ ਕਰੇਗਾ।

ਸ਼ਬਦਾਂ ਤੋਂ ਕਰਮ ਤੱਕ

ਇਸ ਲਈ, ਆਓ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਦੋ ਵਰਚੁਅਲ ਮਸ਼ੀਨਾਂ 'ਤੇ ਤੈਨਾਤ ਕਰੀਏ ਅਤੇ ਇੱਕ ਸਧਾਰਨ ਟੋਪੋਲੋਜੀ ਸੈਟ ਅਪ ਕਰੀਏ:

• ਪ੍ਰਤੀਕ੍ਰਿਤੀ app-1 ਦੀ ਭੂਮਿਕਾ ਨਿਭਾਉਣਗੇ apiਜਿਸ ਵਿੱਚ ਭੂਮਿਕਾ ਸ਼ਾਮਲ ਹੈ vshard-router. ਇੱਥੇ ਕੇਵਲ ਇੱਕ ਹੀ ਉਦਾਹਰਣ ਹੋਵੇਗੀ।
• ਪ੍ਰਤੀਕ੍ਰਿਤੀ storage-1 ਭੂਮਿਕਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ storage (ਅਤੇ ਉਸੇ ਸਮੇਂ vshard-storage), ਇੱਥੇ ਅਸੀਂ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ ਤੋਂ ਦੋ ਉਦਾਹਰਨਾਂ ਜੋੜਦੇ ਹਾਂ।

ਉਦਾਹਰਣ ਨੂੰ ਚਲਾਉਣ ਲਈ, ਸਾਨੂੰ ਲੋੜ ਹੈ ਭਟਕਣਾ и Ansimate (ਵਰਜਨ 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 haltVM ਨੂੰ ਰੋਕਣ ਲਈ ਜਦੋਂ ਤੁਸੀਂ ਉਹਨਾਂ ਨਾਲ ਕੰਮ ਕਰ ਲੈਂਦੇ ਹੋ।

ਅਤੇ ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਕੀ ਹੈ?

ਇੱਥੇ ਮੈਂ ਇਸ ਬਾਰੇ ਹੋਰ ਗੱਲ ਕਰਾਂਗਾ ਕਿ ਸਾਡੇ ਪ੍ਰਯੋਗਾਂ ਦੌਰਾਨ ਜਵਾਬਦੇਹ ਭੂਮਿਕਾ ਦੇ ਹੁੱਡ ਹੇਠ ਕੀ ਹੋਇਆ.

ਆਉ ਇੱਕ ਕਾਰਟ੍ਰੀਜ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕਦਮ ਦਰ ਕਦਮ ਤੈਨਾਤ ਕਰਨ 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰੀਏ।

ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰਨਾ ਅਤੇ ਉਦਾਹਰਨਾਂ ਸ਼ੁਰੂ ਕਰਨਾ

ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਪੈਕੇਜ ਨੂੰ ਸਰਵਰ 'ਤੇ ਪਹੁੰਚਾਉਣ ਅਤੇ ਇਸਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਹੁਣ ਭੂਮਿਕਾ RPM ਅਤੇ DEB ਪੈਕੇਜਾਂ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ।

ਅੱਗੇ, ਅਸੀਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਲਾਂਚ ਕਰਦੇ ਹਾਂ। ਇੱਥੇ ਸਭ ਕੁਝ ਬਹੁਤ ਸਾਦਾ ਹੈ: ਹਰ ਇੱਕ ਉਦਾਹਰਣ ਵੱਖਰੀ ਹੈ systemd-ਸੇਵਾ। ਮੈਂ ਇੱਕ ਉਦਾਹਰਣ ਬਾਰੇ ਗੱਲ ਕਰ ਰਿਹਾ ਹਾਂ:

$ systemctl start myapp@storage-1

ਇਹ ਕਮਾਂਡ ਉਦਾਹਰਣ ਨੂੰ ਲਾਂਚ ਕਰੇਗੀ storage-1 ਐਪਸ myapp. ਲਾਂਚ ਕੀਤੀ ਗਈ ਉਦਾਹਰਣ ਇਸਦੇ ਲਈ ਖੋਜ ਕਰੇਗੀ ਸੰਰਚਨਾ в /etc/tarantool/conf.d/. ਇੰਸਟੈਂਸ ਲੌਗਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ journald.

ਯੂਨਿਟ ਫਾਈਲ /etc/systemd/system/[email protected] ਇੱਕ systemd ਸੇਵਾ ਲਈ ਪੈਕੇਜ ਨਾਲ ਡਿਲੀਵਰ ਕੀਤਾ ਜਾਵੇਗਾ।

Ansible ਕੋਲ ਪੈਕੇਜ ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਸਿਸਟਮਡ ਸੇਵਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਬਿਲਟ-ਇਨ ਮੋਡੀਊਲ ਹਨ, ਅਸੀਂ ਇੱਥੇ ਕੁਝ ਵੀ ਨਵਾਂ ਨਹੀਂ ਲੱਭਿਆ ਹੈ।

ਕਲੱਸਟਰ ਟੋਪੋਲੋਜੀ ਦੀ ਸੰਰਚਨਾ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ

ਅਤੇ ਇੱਥੇ ਸਭ ਤੋਂ ਦਿਲਚਸਪ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ. ਸਹਿਮਤ ਹੋਵੋ, ਪੈਕੇਜਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਜਵਾਬਦੇਹ ਭੂਮਿਕਾ ਨਾਲ ਪਰੇਸ਼ਾਨ ਹੋਣਾ ਅਜੀਬ ਹੋਵੇਗਾ systemd-ਸਰਕਾਰੀ.

ਤੁਸੀਂ ਕਲੱਸਟਰ ਨੂੰ ਹੱਥੀਂ ਸੈਟ ਅਪ ਕਰ ਸਕਦੇ ਹੋ:

• ਪਹਿਲਾ ਵਿਕਲਪ: ਵੈੱਬ UI ਖੋਲ੍ਹੋ ਅਤੇ ਬਟਨਾਂ 'ਤੇ ਕਲਿੱਕ ਕਰੋ। ਕਈ ਉਦਾਹਰਣਾਂ ਦੀ ਇੱਕ-ਵਾਰ ਸ਼ੁਰੂਆਤ ਲਈ, ਇਹ ਕਾਫ਼ੀ ਢੁਕਵਾਂ ਹੈ।
• ਦੂਜਾ ਵਿਕਲਪ: ਤੁਸੀਂ GraphQl API ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਇੱਥੇ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੁਝ ਸਵੈਚਾਲਤ ਕਰ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ, ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸਕ੍ਰਿਪਟ ਲਿਖੋ।
• ਤੀਜਾ ਵਿਕਲਪ (ਮਜ਼ਬੂਤ ​​ਆਤਮਾ ਲਈ): ਸਰਵਰ 'ਤੇ ਜਾਓ, ਵਰਤਦੇ ਹੋਏ ਕਿਸੇ ਇੱਕ ਉਦਾਹਰਣ ਨਾਲ ਜੁੜੋ tarantoolctl connect ਅਤੇ ਲੁਆ ਮੋਡੀਊਲ ਨਾਲ ਸਾਰੇ ਜ਼ਰੂਰੀ ਹੇਰਾਫੇਰੀ ਕਰੋ cartridge.

ਸਾਡੀ ਕਾਢ ਦਾ ਮੁੱਖ ਕੰਮ ਇਹ ਕਰਨਾ ਹੈ, ਤੁਹਾਡੇ ਲਈ ਕੰਮ ਦਾ ਸਭ ਤੋਂ ਮੁਸ਼ਕਲ ਹਿੱਸਾ.

Ansible ਤੁਹਾਨੂੰ ਆਪਣਾ ਖੁਦ ਦਾ ਮੋਡੀਊਲ ਲਿਖਣ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਭੂਮਿਕਾ ਵਿੱਚ ਵਰਤਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਸਾਡੀ ਭੂਮਿਕਾ ਕਲੱਸਟਰ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਇਹਨਾਂ ਮੈਡਿਊਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ।

ਕਿਦਾ ਚਲਦਾ? ਤੁਸੀਂ ਇੱਕ ਘੋਸ਼ਣਾਤਮਕ ਸੰਰਚਨਾ ਵਿੱਚ ਕਲੱਸਟਰ ਦੀ ਲੋੜੀਂਦੀ ਸਥਿਤੀ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹੋ, ਅਤੇ ਰੋਲ ਹਰੇਕ ਮੋਡੀਊਲ ਨੂੰ ਇਸਦੇ ਸੰਰਚਨਾ ਭਾਗ ਨੂੰ ਇਨਪੁਟ ਦੇ ਤੌਰ ਤੇ ਦਿੰਦਾ ਹੈ। ਮੋਡੀਊਲ ਕਲੱਸਟਰ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਨਪੁਟ ਨਾਲ ਇਸਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ। ਅੱਗੇ, ਇੱਕ ਕੋਡ ਨੂੰ ਇੱਕ ਉਦਾਹਰਣ ਦੇ ਸਾਕਟ ਦੁਆਰਾ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਲੱਸਟਰ ਨੂੰ ਲੋੜੀਂਦੀ ਸਥਿਤੀ ਵਿੱਚ ਲਿਆਉਂਦਾ ਹੈ।

ਨਤੀਜੇ

ਅੱਜ ਅਸੀਂ ਦੱਸਿਆ ਅਤੇ ਦਿਖਾਇਆ ਕਿ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ Tarantool ਕਾਰਟ੍ਰੀਜ 'ਤੇ ਕਿਵੇਂ ਤੈਨਾਤ ਕਰਨਾ ਹੈ ਅਤੇ ਇੱਕ ਸਧਾਰਨ ਟੌਪੌਲੋਜੀ ਸੈਟ ਅਪ ਕਰਨਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ Ansible ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਟੂਲ ਜੋ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕੋ ਸਮੇਂ ਬਹੁਤ ਸਾਰੇ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੇ ਨੋਡਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ (ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਕਲੱਸਟਰ ਉਦਾਹਰਣ ਹਨ)।

ਉੱਪਰ, ਅਸੀਂ Ansible ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਲੱਸਟਰ ਸੰਰਚਨਾ ਦਾ ਵਰਣਨ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਨਾਲ ਨਜਿੱਠਿਆ ਹੈ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਅੱਗੇ ਵਧਣ ਲਈ ਤਿਆਰ ਹੋ, ਤਾਂ ਸਿੱਖੋ ਵਧੀਆ ਅਮਲ ਪਲੇਬੁੱਕ ਲਿਖਣ ਲਈ। ਨਾਲ ਟੌਪੌਲੋਜੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਤੁਹਾਨੂੰ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਲੱਗ ਸਕਦਾ ਹੈ group_vars и host_vars.

ਬਹੁਤ ਜਲਦੀ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗੇ ਕਿ ਕਿਵੇਂ ਟੌਪੌਲੋਜੀ, ਬੂਟਸਟਰੈਪ vshard, ਆਟੋਮੈਟਿਕ ਫੇਲਓਵਰ ਮੋਡ ਦਾ ਪ੍ਰਬੰਧਨ, ਅਧਿਕਾਰ ਸੰਰਚਨਾ ਅਤੇ ਕਲੱਸਟਰ ਸੰਰਚਨਾ ਨੂੰ ਪੈਚ ਕਰਨ ਤੋਂ ਉਦਾਹਰਨਾਂ ਨੂੰ ਸਥਾਈ ਤੌਰ 'ਤੇ ਹਟਾਉਣਾ ਹੈ। ਇਸ ਦੌਰਾਨ, ਤੁਸੀਂ ਆਪਣੇ ਆਪ ਅਧਿਐਨ ਕਰ ਸਕਦੇ ਹੋ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਕਲੱਸਟਰ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਬਦਲਣ ਦੇ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰੋ।

ਜੇ ਕੁਝ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਤਾਂ ਯਕੀਨੀ ਬਣਾਓ ਸੂਚਿਤ ਕਰੋ ਸਾਨੂੰ ਸਮੱਸਿਆ ਬਾਰੇ. ਅਸੀਂ ਇਸਨੂੰ ਜਲਦੀ ਤੋੜ ਦੇਵਾਂਗੇ!

ਸਰੋਤ: www.habr.com