మేము ఇప్పటికే గురించి మాట్లాడాము
ఆసక్తికరమైన? అప్పుడు దయచేసి, కట్ కింద, మేము మీకు చెప్తాము మరియు మీకు ప్రతిదీ చూపుతాము.
ఒక ఉదాహరణతో ప్రారంభిద్దాం
మేము మా పాత్ర యొక్క కార్యాచరణలో కొంత భాగాన్ని మాత్రమే పరిశీలిస్తాము. మీరు దాని అన్ని సామర్థ్యాలు మరియు ఇన్పుట్ పారామితుల యొక్క పూర్తి వివరణను ఎల్లప్పుడూ కనుగొనవచ్చు
టరాన్టూల్ కార్ట్రిడ్జ్ ఉంది api
и storage
, ఇది సందర్భాలకు కేటాయించబడుతుంది.
ప్రాసెస్లను ఎలా ప్రారంభించాలో గుళిక స్వయంగా ఏమీ చెప్పదు, ఇది ఇప్పటికే నడుస్తున్న సందర్భాలను కాన్ఫిగర్ చేసే సామర్థ్యాన్ని మాత్రమే అందిస్తుంది. వినియోగదారు మిగిలిన వాటిని తప్పనిసరిగా చేయాలి: కాన్ఫిగరేషన్ ఫైల్లను ఏర్పాటు చేయండి, సేవలను ప్రారంభించండి మరియు టోపోలాజీని కాన్ఫిగర్ చేయండి. కానీ మేము ఇవన్నీ చేయము; అన్సిబుల్ మన కోసం చేస్తుంది.
పదాల నుండి పనుల వరకు
కాబట్టి, మన అప్లికేషన్ను రెండు వర్చువల్ మెషీన్లకు అమర్చి, సాధారణ టోపోలాజీని సెటప్ చేద్దాం:
- ప్రతిరూపం
app-1
పాత్రను అమలు చేస్తుందిapi
, ఇందులో పాత్ర ఉంటుందిvshard-router
. ఇక్కడ ఒక ఉదాహరణ మాత్రమే ఉంటుంది. - ప్రతిరూపం
storage-1
పాత్రను అమలు చేస్తుందిstorage
(మరియు అదే సమయంలోvshard-storage
), ఇక్కడ మేము వేర్వేరు యంత్రాల నుండి రెండు ఉదాహరణలను జోడిస్తాము.
మనకు అవసరమైన ఉదాహరణను అమలు చేయడానికి
పాత్రలోనే ఉంది
ఒక ఉదాహరణతో రిపోజిటరీని క్లోన్ చేద్దాం:
$ 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
మేము ప్లేబుక్ అమలును పూర్తి చేయడానికి వేచి ఉన్నాము, వెళ్ళండి
మీరు డేటాను అప్లోడ్ చేయవచ్చు. కూల్, సరియైనదా?
ఇప్పుడు దీనితో ఎలా పని చేయాలో గుర్తించండి మరియు అదే సమయంలో టోపోలాజీకి మరొక ప్రతిరూపాన్ని జోడించండి.
దాన్ని గుర్తించడం ప్రారంభిద్దాం
కాబట్టి ఏమి జరిగింది?
మేము రెండు వర్చువల్ మెషీన్లను సెటప్ చేసాము మరియు మా క్లస్టర్ని కాన్ఫిగర్ చేసిన ఒక యాన్సిబుల్ ప్లేబుక్ని ప్రారంభించాము. ఫైల్ యొక్క కంటెంట్లను చూద్దాం 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
. ప్రతి క్లస్టర్ ఉదాహరణ Ansible నిబంధనలలో హోస్ట్ అయినందున, ప్లేబుక్ని అమలు చేస్తున్నప్పుడు ఏ సందర్భాలను కాన్ఫిగర్ చేయాలో మేము స్పష్టంగా పేర్కొనవచ్చు.
వెబ్ UIకి తిరిగి వెళుతున్నాను
అంతటితో ఆగకుండా టోపోలాజీ మేనేజ్మెంట్పై పట్టుసాధిద్దాం.
టోపాలజీ నిర్వహణ
మన కొత్త ఉదాహరణలను ప్రతిరూప సెట్గా మిళితం చేద్దాం 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
.
మన ప్రయత్నాల ఫలితాన్ని విశ్లేషించుకుందాం. మేము కొత్త ప్రతిరూపాన్ని కనుగొన్నాము
హుర్రే!
ఉదంతాలు మరియు ప్రతిరూప సెట్ల కాన్ఫిగరేషన్ను మార్చడంలో ప్రయోగం చేయండి మరియు క్లస్టర్ టోపోలాజీ ఎలా మారుతుందో చూడండి. మీరు విభిన్న కార్యాచరణ దృశ్యాలను ప్రయత్నించవచ్చు, ఉదా. 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 సేవ కోసం ప్యాకేజీతో పాటు పంపిణీ చేయబడుతుంది.
Ansible ప్యాకేజీలను ఇన్స్టాల్ చేయడం మరియు systemd సేవలను నిర్వహించడం కోసం అంతర్నిర్మిత మాడ్యూల్లను కలిగి ఉంది; మేము ఇక్కడ కొత్తగా ఏమీ కనుగొనలేదు.
క్లస్టర్ టోపోలాజీని ఏర్పాటు చేస్తోంది
ఇక్కడే సరదా మొదలవుతుంది. అంగీకరిస్తున్నారు, ప్యాకేజీలను ఇన్స్టాల్ చేయడం మరియు అమలు చేయడం కోసం ప్రత్యేక Ansible పాత్రతో ఇబ్బంది పడటం వింతగా ఉంటుంది systemd
సేవలు.
మీరు క్లస్టర్ను మాన్యువల్గా కాన్ఫిగర్ చేయవచ్చు:
- మొదటి ఎంపిక: వెబ్ UIని తెరిచి, బటన్లపై క్లిక్ చేయండి. అనేక సందర్భాల్లో ఒక-పర్యాయ ప్రారంభానికి ఇది చాలా అనుకూలంగా ఉంటుంది.
- రెండవ ఎంపిక: మీరు GraphQl APIని ఉపయోగించవచ్చు. ఇక్కడ మీరు ఇప్పటికే ఏదైనా ఆటోమేట్ చేయవచ్చు, ఉదాహరణకు, పైథాన్లో స్క్రిప్ట్ రాయండి.
- మూడవ ఎంపిక (బలమైన సంకల్పం ఉన్నవారి కోసం): సర్వర్కి వెళ్లి, ఉపయోగించి ఉదాహరణలలో ఒకదానికి కనెక్ట్ చేయండి
tarantoolctl connect
మరియు లువా మాడ్యూల్తో అవసరమైన అన్ని అవకతవకలను చేయండిcartridge
.
మా ఆవిష్కరణ యొక్క ప్రధాన పని సరిగ్గా దీన్ని చేయడం, మీ కోసం పనిలో చాలా కష్టమైన భాగం.
అన్సిబుల్ మీ స్వంత మాడ్యూల్ను వ్రాయడానికి మరియు దానిని పాత్రలో ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తుంది. వివిధ క్లస్టర్ భాగాలను నిర్వహించడానికి మా పాత్ర అటువంటి మాడ్యూళ్లను ఉపయోగిస్తుంది.
అది ఎలా పని చేస్తుంది? మీరు క్లస్టర్ యొక్క కావలసిన స్థితిని డిక్లరేటివ్ కాన్ఫిగరేషన్లో వివరిస్తారు మరియు పాత్ర ప్రతి మాడ్యూల్కు దాని కాన్ఫిగరేషన్ విభాగాన్ని ఇన్పుట్గా అందిస్తుంది. మాడ్యూల్ క్లస్టర్ యొక్క ప్రస్తుత స్థితిని అందుకుంటుంది మరియు దానిని ఇన్పుట్గా స్వీకరించిన దానితో పోలుస్తుంది. తరువాత, ఒక సంకేతం యొక్క సాకెట్ ద్వారా కోడ్ ప్రారంభించబడుతుంది, ఇది క్లస్టర్ను కావలసిన స్థితికి తీసుకువస్తుంది.
ఫలితాలు
ఈ రోజు మేము మీ అప్లికేషన్ను టరాన్టూల్ కార్ట్రిడ్జ్కి ఎలా అమర్చాలో మరియు సాధారణ టోపోలాజీని ఎలా సెటప్ చేయాలో చెప్పాము మరియు చూపించాము. దీన్ని చేయడానికి, మేము Ansible ను ఉపయోగించాము - ఇది ఉపయోగించడానికి సులభమైన మరియు ఏకకాలంలో అనేక ఇన్ఫ్రాస్ట్రక్చర్ నోడ్లను కాన్ఫిగర్ చేయడానికి మిమ్మల్ని అనుమతించే శక్తివంతమైన సాధనం (మా విషయంలో, క్లస్టర్ సందర్భాలు).
పైన మేము Ansible ఉపయోగించి క్లస్టర్ కాన్ఫిగరేషన్ను వివరించడానికి అనేక మార్గాలలో ఒకదాన్ని చూశాము. మీరు కొనసాగడానికి సిద్ధంగా ఉన్నట్లు భావించిన తర్వాత, అన్వేషించండి group_vars
и host_vars
.
టోపోలాజీ, బూట్స్ట్రాప్ vshard, ఆటోమేటిక్ ఫెయిల్ఓవర్ మోడ్ను నిర్వహించడం, అధికారాన్ని కాన్ఫిగర్ చేయడం మరియు క్లస్టర్ కాన్ఫిగర్ను ప్యాచ్ చేయడం వంటి వాటి నుండి దృష్టాంతాలను శాశ్వతంగా తొలగించడం (బహిష్కరించడం) ఎలాగో త్వరలో మేము మీకు తెలియజేస్తాము. ఈలోగా సొంతంగా చదువుకోవచ్చు
ఏదైనా పని చేయకపోతే, నిర్ధారించుకోండి
మూలం: www.habr.com