🥇როგორ ავაშენოთ ჰიბრიდული ღრუბელი Kubernetes-ის გამოყენებით, რომელსაც შეუძლია შეცვალოს DBaaS

მე მქვია პეტრ ზაიცევი, მე ვარ აღმასრულებელი დირექტორი, დამფუძნებელი პერკონა და მინდა გითხრათ:

როგორ მივედით ღია კოდის გადაწყვეტილებებიდან მონაცემთა ბაზაში, როგორც სერვისში;
რა მიდგომები არსებობს ღრუბელში მონაცემთა ბაზების განლაგებისას;
როგორ შეუძლია Kubernetes-ს შეცვალოს DBaaS, აღმოფხვრას მომწოდებლის დამოკიდებულება და შეინარჩუნოს DBMS, როგორც სერვისის სიმარტივე.

სტატია მომზადდა @Databases Meetup-ის ანგარიშის საფუძველზე Mail.ru Cloud Solutions & Tarantool-ის მიერ. თუ კითხვა არ გსურთ, შეგიძლიათ უყუროთ:

როგორ მივედით ღია წყაროდან მონაცემთა ბაზაში, როგორც სერვისი ღრუბელში

90-იანი წლების ბოლოდან ღია წყაროზე ვმუშაობ. ოცი წლის წინ ღია კოდის გამოყენება, როგორიცაა მონაცემთა ბაზები, არც ისე ადვილი იყო. საჭირო იყო საწყისი კოდის ჩამოტვირთვა, პატჩი, კომპილაცია და მხოლოდ ამის შემდეგ გამოყენება.

შემდეგ ღია წყარომ გაიარა გამარტივებების სერია:

Tar.gz და INSTALL წყაროები, რომლებიც საჭიროებდა შედგენას;
პაკეტები დამოკიდებულებებით, როგორიცაა .deb და .rpm, სადაც საჭიროა მხოლოდ პაკეტების ნაკრების დაყენება;
პაკეტის საცავი, როგორიცაა APT და YUM, რომლებთანაც ინსტალაცია ავტომატურია;
გადაწყვეტილებები, როგორიცაა Docker და Snap, რომლებიც საშუალებას გაძლევთ მიიღოთ პაკეტები ინსტალაციის გზით გარე დამოკიდებულების გარეშე.

შედეგად, უფრო ადვილი ხდება ღია კოდის პროგრამული უზრუნველყოფის გამოყენება და ასევე ამცირებს ბარიერს ასეთი აპლიკაციების შემუშავებაში შესვლისთვის.

ამავდროულად, 20 წლის წინანდელი სიტუაციისგან განსხვავებით, როდესაც ყველა ასამბლეის ექსპერტი იყო, ახლა დეველოპერების უმეტესობას არ შეუძლია შექმნას ინსტრუმენტები, რომლებსაც ისინი იყენებენ წყაროდან.

სინამდვილეში, ეს არ არის ცუდი, რადგან:

ჩვენ შეგვიძლია გამოვიყენოთ უფრო რთული, მაგრამ უფრო მოსახერხებელი პროგრამული უზრუნველყოფა. მაგალითად, ბრაუზერი მოსახერხებელია გამოსაყენებლად, მაგრამ ის შეიცავს ბევრ ღია კოდის კომპონენტს და არასასიამოვნოა ნულიდან აშენება.
მეტი ადამიანი შეიძლება გახდეს ღია კოდის და სხვა პროგრამული უზრუნველყოფის დეველოპერები, მეტი პროგრამული უზრუნველყოფა გამოიყენება ბიზნესის მიერ და ამის საჭიროება უფრო დიდია.

მინუსი ის არის, რომ გამარტივების შემდეგი ნაბიჯი დაკავშირებულია ღრუბლოვანი გადაწყვეტილებების გამოყენებასთან და ეს იწვევს გარკვეული გამყიდველის ჩაკეტვას, ანუ ერთ მიმწოდებელთან დაკავშირებას. ჩვენ ვიყენებთ მარტივ გადაწყვეტილებებს და პროვაიდერები იყენებენ ღია კოდის კომპონენტებს, მაგრამ სინამდვილეში ისინი მიმაგრებულია ერთ-ერთ დიდ ღრუბელზე. ანუ, ღია კოდის (და მასთან თავსებადი პროგრამული უზრუნველყოფის) განლაგების ყველაზე მარტივი და სწრაფი გზა ღრუბლებშია, საკუთრების API-ს გამოყენებით.

რაც შეეხება ღრუბელში არსებულ მონაცემთა ბაზებს, არსებობს ორი მიდგომა:

შეაგროვეთ მონაცემთა ბაზის ინფრასტრუქტურა, როგორც ჩვეულებრივ მონაცემთა ცენტრში. ანუ, აიღეთ სტანდარტული სამშენებლო ბლოკები: გამოთვლა, შენახვა და ასე შემდეგ, დააინსტალირეთ Linux და მონაცემთა ბაზა მათზე და დააკონფიგურირეთ ისინი.
გამოიყენეთ მონაცემთა ბაზა, როგორც სერვისი, სადაც პროვაიდერი გთავაზობთ მზა მონაცემთა ბაზას ღრუბლის შიგნით.

DBaaS ახლა სწრაფად მზარდი ბაზარია, რადგან ის დეველოპერებს საშუალებას აძლევს უშუალოდ იმუშაონ მონაცემთა ბაზებთან და ამცირებს რუტინულ სამუშაოს. პროვაიდერი იღებს ვალდებულებას უზრუნველყოს მაღალი ხელმისაწვდომობა და მარტივი სკალირება, მონაცემთა ბაზის შესწორება, სარეზერვო ასლები და შესრულების დარეგულირება.

ორი ტიპის მონაცემთა ბაზა, როგორც სერვისი, რომელიც დაფუძნებულია ღია წყაროზე და ალტერნატივა Kubernetes-ის სახით

არსებობს ორი ტიპის მონაცემთა ბაზა, როგორც სერვისი ღია მონაცემთა ბაზებისთვის:

სტანდარტული ღია კოდის პროდუქტი, რომელიც შეფუთულია ადმინისტრაციულ ბაზაში მარტივი განლაგებისა და მართვისთვის.
მოწინავე კომერციული გადაწყვეტა სხვადასხვა დანამატებით, თავსებადი ღია წყაროსთან.

ორივე ვარიანტი ამცირებს ღრუბლებს შორის მიგრაციის შესაძლებლობას და ამცირებს მონაცემთა და აპლიკაციების პორტაბელურობას. მაგალითად, იმისდა მიუხედავად, რომ ღრუბლების სხვადასხვა ტიპები მხარს უჭერენ არსებითად ერთსა და იმავე სტანდარტს MySQL-ს, მათ შორის არის მნიშვნელოვანი განსხვავებები: ფუნქციონირებაში, შესრულებაში, სარეზერვო ასლში და ა.შ. ერთი ღრუბლიდან მეორეზე მიგრაცია შეიძლება იყოს რთული, განსაკუთრებით რთული აპლიკაციებისთვის.

და აქ ჩნდება კითხვა - შესაძლებელია თუ არა მონაცემთა ბაზის მოხერხებულობის მიღება, როგორც სერვისი, მაგრამ როგორც მარტივი ღია კოდის გადაწყვეტა?

ცუდი ამბავი ის არის, რომ, სამწუხაროდ, ბაზარზე ჯერ არ არის ასეთი გადაწყვეტილებები. კარგი ამბავი ის არის, რომ არსებობს Kubernetes, რომელიც საშუალებას გაძლევთ განახორციელოთ ასეთი გადაწყვეტილებები.

Kubernetes არის ოპერაციული სისტემა ღრუბლის ან მონაცემთა ცენტრისთვის, რომელიც საშუალებას გაძლევთ განათავსოთ და მართოთ აპლიკაცია მრავალ სერვერზე კლასტერში და არა ერთ ჰოსტზე.

ახლა Kubernetes არის ლიდერი ასეთი პროგრამული უზრუნველყოფის კატეგორიაში. ასეთი პრობლემების მრავალი განსხვავებული გადაწყვეტა იყო, მაგრამ ის გახდა სტანდარტი. ბევრი კომპანია, რომლებიც აქცენტს აკეთებდნენ ალტერნატიულ გადაწყვეტილებებზე, ახლა ყურადღებას ამახვილებენ თავიანთი პროდუქტების ადაპტაციაზე Kubernetes-ის მხარდასაჭერად.

გარდა ამისა, Kubernetes არის უნივერსალური გადაწყვეტა, რომელიც მხარდაჭერილია მრავალი გამყიდველის კერძო, საჯარო და ჰიბრიდულ ღრუბლებში, მაგალითად: AWS, Google Cloud, Microsoft Azure, Mail.ru Cloud Solutions.

როგორ მუშაობს Kubernetes მონაცემთა ბაზებთან

Kubernetes თავდაპირველად შეიქმნა მოქალაქეობის არმქონე აპლიკაციებისთვის, რომლებიც ამუშავებენ მონაცემებს, მაგრამ არ ინახავს არაფერს, როგორიცაა მიკროსერვისები ან ვებ აპლიკაციები. მონაცემთა ბაზები არის სპექტრის მეორე ბოლოში, ანუ ისინი სახელმწიფო აპლიკაციებია. და Kubernetes თავდაპირველად არ იყო განკუთვნილი ასეთი აპლიკაციებისთვის.

თუმცა, არის ფუნქციები, რომლებიც ახლახან გამოჩნდა Kubernetes-ში, რომლებიც საშუალებას იძლევა გამოიყენონ მონაცემთა ბაზები და სხვა სახელმწიფო აპლიკაციები:

StatefulSet კონცეფცია არის პრიმიტივების მთელი რიგი ღონისძიებების დასამუშავებლად პოდების მუშაობის შეჩერებისა და Graceful Shutdown-ის (აპლიკაციის პროგნოზირებადი გამორთვა) განხორციელების შესახებ.
მუდმივი ტომები არის მონაცემთა მაღაზიები, რომლებიც დაკავშირებულია პოდებთან, Kubernetes-ის მართვის ობიექტებთან.
ოპერატორის ჩარჩო - ეს არის უნარი შექმნას კომპონენტები მონაცემთა ბაზებისა და სხვა სახელმწიფო აპლიკაციების მართვისთვის, რომლებიც განაწილებულია მრავალ კვანძზე.

უკვე საჯარო ღრუბლებში არის დიდი მონაცემთა ბაზები, როგორც სერვისი, რომლის უკანა ნაწილია Kubernetes, მაგალითად: CockroachCloud, InfluxDB, PlanetScale. ანუ, Kubernetes-ის მონაცემთა ბაზა არა მხოლოდ თეორიულად შესაძლებელია, არამედ ის, რაც პრაქტიკაში მუშაობს.

Percona-ს აქვს ორი ღია კოდის გადაწყვეტა Kubernetes-ისთვის:

Kubernetes ოპერატორი Percona სერვერისთვის MongoDB-სთვის.
Kubernetes ოპერატორი XtraDB CLUSTER-ისთვის არის სერვისი, რომელიც თავსებადია MySQL-თან და უზრუნველყოფს მაღალ ხელმისაწვდომობას და თანმიმდევრულობას. თქვენ ასევე შეგიძლიათ გამოიყენოთ ერთი კვანძი, თუ მაღალი ხელმისაწვდომობა არ არის საჭირო, მაგალითად, dev მონაცემთა ბაზისთვის.

Kubernetes-ის მომხმარებლები შეიძლება დაიყოს ორ ჯგუფად. ზოგიერთი ადამიანი პირდაპირ იყენებს Kubernetes ოპერატორებს - ეს ძირითადად მოწინავე მომხმარებლები არიან, რომლებსაც კარგად ესმით, თუ როგორ მუშაობს ტექნოლოგია. სხვები აწარმოებენ მას უკანა პლანზე - ასეთ მომხმარებლებს აინტერესებთ მონაცემთა ბაზა, როგორც სერვისი, მათ არ სურთ Kubernetes-ის ნიუანსებში ჩაღრმავება. მომხმარებელთა მეორე ჯგუფისთვის ჩვენ გვაქვს კიდევ ერთი ღია კოდის გადაწყვეტა - Percona DBaaS CLI Tool. ეს არის ექსპერიმენტული გადაწყვეტა მათთვის, ვისაც სურს მიიღოს ღია კოდის DBaaS Kubernetes-ზე დაფუძნებული ტექნოლოგიის ღრმა გაგების გარეშე.

როგორ გავუშვათ Percona-ს DBaaS Google Kubernetes Engine-ზე

Google Kubernetes Engine, ჩემი აზრით, არის Kubernetes ტექნოლოგიის ერთ-ერთი ყველაზე ფუნქციონალური განხორციელება. ის ხელმისაწვდომია მსოფლიოს მრავალ რეგიონში და აქვს მარტივი და მოსახერხებელი Command Line Tool (SDK), რომელიც საშუალებას გაძლევთ შექმნათ სკრიპტები, ვიდრე ხელით მართოთ პლატფორმა.

იმისათვის, რომ ჩვენი DBaaS იმუშაოს, ჩვენ გვჭირდება შემდეგი კომპონენტები:

Kubectl.
Google Cloud SDK.
Percona DBaaS CLI.

დააინსტალირეთ kubectl

ჩვენ ვაინსტალირებთ პაკეტს თქვენი ოპერაციული სისტემისთვის, განვიხილავთ Ubuntu-ს მაგალითს. Უფრო ვრცლად აქ.

sudo apt-get update && sudo apt-get install -y apt-transport-https gnupg2
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl

მიმდინარეობს Google Cloud SDK-ის ინსტალაცია

ჩვენ ვაინსტალირებთ პროგრამულ პაკეტს ანალოგიურად. Უფრო ვრცლად აქ.

# Add the Cloud SDK distribution URI as a package source
echo "deb [signed-by=/usr/share/keyrings/cloud.google.gpg] 
http://packages.cloud.google.com/apt cloud-sdk main" | sudo tee -a /etc/apt/sources.list.d/google-cloud-sdk.list

# Import the Google Cloud Platform public key
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key --keyring /usr/share/keyrings/cloud.google.gpg add -

# Update the package list and install the Cloud SDK
sudo apt-get update && sudo apt-get install google-cloud-sdk

Percona DBaaS CLI-ის ინსტალაცია

დააინსტალირეთ Percona-ს საცავებიდან. Percona DBaaS CLI Tool კვლავ ექსპერიმენტული პროდუქტია, ამიტომ ის მდებარეობს ექსპერიმენტულ საცავში, რომელიც ცალკე უნდა იყოს ჩართული, მაშინაც კი, თუ თქვენ უკვე გაქვთ დაინსტალირებული Percona საცავი.

სხვა აქ.

ინსტალაციის ალგორითმი:

დააყენეთ Percona-ს საცავი percona-release ინსტრუმენტის გამოყენებით. ჯერ უნდა ჩამოტვირთოთ და დააინსტალიროთ Percona-ის გამოშვების ოფიციალური პაკეტი Percona-დან:
```
wget https://repo.percona.com/apt/percona-release_latest.generic_all.deb
sudo dpkg -i percona-release_latest.generic_all.deb
```
ჩართეთ ექსპერიმენტული ხელსაწყოების საცავის კომპონენტი შემდეგნაირად:
```
sudo percona-release enable tools experimental
```
დააინსტალირეთ percona-dbaas-cli პაკეტი:
```
sudo apt-get update
sudo apt-get install percona-dbaas-cli
```

კომპონენტების მუშაობის დაყენება

მეტი პარამეტრების შესახებ აქ.

პირველ რიგში, თქვენ უნდა შეხვიდეთ თქვენს Google ანგარიშში. გარდა ამისა, Google Cloud საშუალებას აძლევს ერთ მომხმარებელს ჰქონდეს მრავალი დამოუკიდებელი პროექტი, ასე რომ თქვენ უნდა მიუთითოთ სამუშაო პროექტი ამ პროექტის კოდის გამოყენებით:

gcloud auth login
gcloud config set project hidden-brace-236921

შემდეგი, ჩვენ ვქმნით კლასტერს. დემოსთვის მე შევქმენი Kubernetes კლასტერი მხოლოდ სამი კვანძისგან - ეს არის მინიმალური საჭირო მაღალი ხელმისაწვდომობისთვის:

gcloud container clusters create --zone us-central1-a your-cluster-name --cluster-version 1.15 --num-nodes=3

შემდეგი kubectl ბრძანება აძლევს სასურველ პრივილეგიებს ჩვენს ამჟამინდელ მომხმარებელს:

kubectl create clusterrolebinding cluster-admin-binding-$USER 
--clusterrole=cluster-admin --user=$(gcloud config get-value core/account)

შემდეგ ვქმნით სახელთა სივრცეს და ვააქტიურებთ მას. სახელთა სივრცე, უხეშად რომ ვთქვათ, ასევე ჰგავს პროექტს ან გარემოს, მაგრამ უკვე Kubernetes კლასტერშია. ის დამოუკიდებელია Google Cloud პროექტებისგან:

kubectl create namespace my-namespace
kubectl config set-context --current --namespace=my-namespace

კლასტერის დაწყება

მას შემდეგ რაც გავივლით ამ რამდენიმე საფეხურს, შეგვიძლია დავიწყოთ სამი კვანძის კლასტერი ამ მარტივი ბრძანებით:

# percona-dbaas mysql create-db example
Starting ......................................... [done]
Database started successfully, connection details are below:
Provider:          k8s
Engine:            pxc
Resource Name:     example
Resource Endpoint: example-proxysql.my-namespace.pxc.svc.local
Port:              3306
User:              root
Pass:              Nt9YZquajW7nfVXTTrP
Status:            ready

როგორ დავუკავშირდეთ კლასტერს

ნაგულისხმევად, ის ხელმისაწვდომია მხოლოდ Kubernetes-ის შიგნით. ანუ, ის მიუწვდომელია ამ სერვერიდან, საიდანაც თქვენ გაუშვით ბრძანება "Create". იმისათვის, რომ ის ხელმისაწვდომი გახდეს, მაგალითად, კლიენტთან ტესტებისთვის, თქვენ უნდა გადააგზავნოთ პორტი პორტის რუკების საშუალებით:

kubectl port-forward svc/example-proxysql 3306:3306 $

შემდეგ ჩვენ ვუკავშირდებით თქვენს MySQL კლიენტს:

mysql -h 127.0.0.1 -P 3306 -uroot -pNt9YZquajW7nfVXTTrP

კლასტერების მართვის გაფართოებული ბრძანებები

მონაცემთა ბაზა საჯარო IP-ზე

თუ გსურთ უფრო მუდმივი გადაწყვეტა კლასტერების ხელმისაწვდომობისთვის, შეგიძლიათ მიიღოთ გარე IP მისამართი. ამ შემთხვევაში მონაცემთა ბაზა ხელმისაწვდომი იქნება ნებისმიერი ადგილიდან. ეს ნაკლებად უსაფრთხოა, მაგრამ ხშირად უფრო მოსახერხებელია. გარე IP-სთვის ჩვენ ვიყენებთ შემდეგ ბრძანებას:

# percona-dbaas mysql create-db exposed 
--options="proxysql.serviceType=LoadBalancer"
Starting ......................................... [done]
Database started successfully, connection details are below:
Provider:          k8s
Engine:            pxc
Resource Name:     exposed
Resource Endpoint: 104.154.133.197
Port:              3306
User:              root
Pass:              k0QVxTr8EVfgyCLYse
Status:            ready

To access database please run the following command:
mysql -h 104.154.133.197 -P 3306 -uroot -pk0QVxTr8EVfgyCLYse

მკაფიოდ დააყენეთ პაროლი

იმის ნაცვლად, რომ სისტემამ შემთხვევით შექმნას პაროლი, შეგიძლიათ პირდაპირ დააყენოთ პაროლი:

# percona-dbaas mysql create-db withpw --password=mypassword
Starting ......................................... [done]
Database started successfully, connection details are below:
Provider:          k8s
Engine:            pxc
Resource Name:     withpw
Resource Endpoint: withpw-proxysql.my-namespace.pxc.svc.local
Port:              3306
User:              root
Pass:              mypassword
Status:            ready

მე ვაჩვენებ სკრიპტების გამოსავალს ადამიანის წაკითხვადი ფორმატში, მაგრამ JSON ფორმატიც მხარდაჭერილია.

მაღალი ხელმისაწვდომობის გამორთვა

შემდეგი ბრძანებით შეგიძლიათ გამორთოთ მაღალი ხელმისაწვდომობა ერთი კვანძის განსათავსებლად:

# percona-dbaas mysql create-db singlenode 
--options="proxysql.enabled=false, allowUnsafeConfigurations=true,pxc.size=1"
Starting ......................................... [done]
Database started successfully, connection details are below:
Provider:          k8s
Engine:            pxc
Resource Name:     singlenode
Resource Endpoint: singlenode-pxc.my-namespace.pxc.svc.local
Port:              3306
User:              root
Pass:              22VqFD96mvRnmPMGg
Status:            ready

ეს არის გამოსავალი ამოცანების შესამოწმებლად, რათა MySQL ამოქმედდეს რაც შეიძლება სწრაფად და მარტივად, შეამოწმოთ და შემდეგ გამორთოთ ან გამოიყენოთ იგი განვითარებისთვის.

Percona DBaaS CLI ინსტრუმენტი გეხმარებათ მიიღოთ DBaaS მსგავსი გადაწყვეტა Kubernetes-ზე. ამავდროულად, ჩვენ ვაგრძელებთ მუშაობას მის ფუნქციონალურობასა და გამოყენებადობაზე.

ეს ანგარიში პირველად იყო წარმოდგენილი @Databases Meetup Mail.ru Cloud Solutions&Tarantool-ის მიერ. შეხედე ვიდეო სხვა სპექტაკლები და გამოიწერეთ ღონისძიების ანონსები Telegram-ზე Kubernetes-ის გარშემო Mail.ru Group-ზე.

კიდევ რა წაიკითხოთ თემაზე:

წყარო: www.habr.com

როგორ ავაშენოთ ჰიბრიდული ღრუბელი Kubernetes-ის გამოყენებით, რომელსაც შეუძლია შეცვალოს DBaaS