🥇Hoe een hybride cloud op te zetten met Kubernetes, die DBaaS kan vervangen

Mijn naam is Peter Zaitsev, ik ben CEO en oprichter Percona en ik wil vertellen:

hoe we van open source-oplossingen zijn overgestapt naar Database as a Service;
welke benaderingen er zijn voor het implementeren van databases in de cloud;
hoe Kubernetes DBaaS kan vervangen door de afhankelijkheid van leveranciers te elimineren en de eenvoud van databases als een service te behouden.

Dit artikel is gebaseerd op een presentatie op de @Databases Meetup door Mail.ru Cloud Solutions & Tarantool. Als je niet wilt lezen, kun je kijken:

Hoe we van open source naar Database as a Service in de cloud zijn overgestapt

Ik houd me sinds het einde van de jaren '90 bezig met open source. Twintig jaar geleden was het niet zo eenvoudig om open source, zoals databases, te gebruiken. Je moest de broncode downloaden, patchen, compileren en pas dan gebruiken.

Vervolgens heeft open source een serie vereenvoudigingen ondergaan:

de bronbestanden Tar.gz en INSTALL, die je moest compileren;
pakketten met afhankelijkheden zoals .deb en .rpm, waarvoor je alleen een set pakketten hoefde te installeren;
pakkettenrepositories zoals APT en YUM, waarmee installatie automatisch verloopt;
oplossingen zoals Docker en Snap, die je in staat stellen om pakketten te ontvangen zonder externe afhankelijkheden.

Uiteindelijk wordt het gebruik van open source software eenvoudiger, en ook de drempel om dergelijke applicaties te ontwikkelen neemt af.

In tegenstelling tot de situatie van 20 jaar geleden, toen nog iedereen experts waren in compileren, kunnen de meeste ontwikkelaars nu de gebruikte tools niet uit de broncode compileren.

Dat is eigenlijk niet slecht, omdat:

We complexere, maar gebruiksvriendelijkere software kunnen gebruiken. Bijvoorbeeld een browser - het is handig om te gebruiken, maar er zijn veel open source-componenten in opgenomen, het is onhandig om dit vanaf nul te compileren.
Meer mensen kunnen ontwikkelaars worden van open source en andere software, meer software wordt gebruikt door bedrijven, en de vraag ernaar is groter.

De keerzijde is dat de volgende stap in vereenvoudiging gepaard gaat met het gebruik van cloudoplossingen, wat leidt tot een bepaalde vendor lock-in, oftewel binding aan één leverancier. We gebruiken eenvoudige oplossingen en providers gebruiken open source-componenten, maar feitelijk zijn ze bevestigd aan een van de grote cloudproviders. Dit betekent dat de eenvoudigste en snelste manier om open source (en compatibele software) in te richten, in de cloud is, met gebruik van propriëtaire API.

Als we het hebben over cloud-databases, zijn er twee benaderingen:

Bouw de infrastructuur voor de database zoals in een traditionele datacenter. Dat wil zeggen, neem standaardcomponenten zoals compute, storage, enzovoort, installeer Linux, de database en configureer het.
Gebruik Database as a Service, waar de provider al een kant-en-klare database in de cloud aanbiedt.

DBaaS is momenteel een snelgroeiende markt, omdat deze dienst ontwikkelaars in staat stelt om direct met databases te werken en routinematig werk te minimaliseren. De provider zorgt voor High Availability en eenvoudige schaalbaarheid, databasepatches, back-ups en performance tuning.

Twee soorten Database as a Service op basis van open source en een alternatief in de vorm van Kubernetes.

Er zijn twee soorten Database as a Service voor open databases:

Een standaard open source-product verpakt in een backend voor beheer, wat het implementeren en beheren vereenvoudigt.
Een geavanceerde commerciële oplossing met verschillende extensies, compatibel met open source.

Beide opties verminderen de mogelijkheid om tussen clouds te migreren en verlagen de draagbaarheid van gegevens en applicaties. Hoewel verschillende soorten clouds in wezen dezelfde standaard MySQL ondersteunen, zijn er aanzienlijke verschillen in werking, prestaties, back-ups, enzovoort. Migreren van de ene cloud naar de andere kan moeilijk zijn, vooral voor complexe applicaties.

Hier rijst de vraag: kun je het gemak van Database as a Service krijgen, maar als een eenvoudige open source-oplossing?

Het slechte nieuws is dat er helaas momenteel geen dergelijke oplossingen op de markt zijn. Het goede nieuws is dat er Kubernetes is, dat het mogelijk maakt om dergelijke oplossingen te realiseren.

Kubernetes is een besturingssysteem voor de cloud of datacenter dat het mogelijk maakt om applicaties te implementeren en te beheren op meerdere servers in een cluster, in plaats van op één host.

Kubernetes is momenteel de leider in de categorie van dergelijke software. Er waren veel verschillende oplossingen voor dergelijke taken, maar het is de standaard geworden. Veel bedrijven die eerder alternatieve oplossingen aanboden, richten zich nu op het aanpassen van hun producten voor ondersteuning van Kubernetes.

Bovendien is Kubernetes een veelzijdige oplossing die wordt ondersteund in private, publieke en hybride clouds van veel leveranciers, bijvoorbeeld: AWS, Google Cloud, Microsoft Azure, Mail.ru Cloud Solutions.

Hoe Kubernetes werkt met databases

Kubernetes is oorspronkelijk ontwikkeld voor stateless applicaties die gegevens verwerken, maar niets opslaan, zoals microservices of webapplicaties. Databases bevinden zich aan de andere kant van het spectrum, dat wil zeggen, dit zijn stateful applicaties. Kubernetes was oorspronkelijk niet ontworpen voor dergelijke applicaties.

Er zijn echter functies die recent in Kubernetes zijn verschenen en die het mogelijk maken om databases en andere stateful applicaties te gebruiken:

Het concept StatefulSet — een reeks primitieve elementen voor het afhandelen van gebeurtenissen bij het stoppen van pods en het uitvoeren van Graceful Shutdown (voorspelbare beëindiging van een applicatie).
Persistente Volumes — gegevensopslag die is gekoppeld aan pods, objecten die door Kubernetes worden beheerd.
Operator Framework — de mogelijkheid om componenten te creëren voor het beheer van databases en andere stateful applicaties die op meerdere knooppunten zijn verdeeld.

In de publieke cloud zijn er al grote Database as a Service-oplossingen, waarbij Kubernetes aan de achterkant wordt gebruikt, zoals: CockroachCloud, InfluxDB, PlanetScale. Dus een database op Kubernetes is niet alleen theoretisch mogelijk, maar ook praktisch werkzaam.

Percona heeft twee open source oplossingen voor Kubernetes:

Kubernetes Operator voor Percona Server voor MongoDB.
Kubernetes Operator voor XtraDB CLUSTER — een service die compatibel is met MySQL, hoge beschikbaarheid en consistentie biedt. Ook kan je een enkele node gebruiken als hoge beschikbaarheid niet nodig is, bijvoorbeeld voor een dev-database.

Kubernetes-gebruikers kunnen in twee groepen worden verdeeld. De een gebruikt Kubernetes Operators direct — dit zijn voornamelijk gevorderde gebruikers die goed begrijpen hoe de technologie werkt. De andere draait het op de achterkant — deze gebruikers zijn geïnteresseerd in iets als Database as a Service, ze willen niet in de nuances van Kubernetes duiken. Voor de tweede groep gebruikers hebben we nog een open source oplossing — Percona DBaaS CLI Tool. Dit is een experimentele oplossing voor degenen die een open source DBaaS op basis van Kubernetes willen zonder diepgaand begrip van de technologie.

Hoe Percona's DBaaS te starten op Google Kubernetes Engine

Google Kubernetes Engine, in mijn ogen, is een van de meest functionele implementaties van de Kubernetes-technologie. Het is beschikbaar in veel regio's over de wereld en heeft een eenvoudige en gebruiksvriendelijke Command Line Tool (SDK), waarmee je scripts kunt maken in plaats van het platform handmatig te beheren.

Om ervoor te zorgen dat onze DBaaS werkt, zijn de volgende componenten nodig:

Kubectl.
Google Cloud SDK.
Percona DBaaS CLI.

Installeren van kubectl

Installeer het pakket voor uw besturingssysteem, we bekijken dit aan de hand van het voorbeeld van Ubuntu. Meer informatie here.

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

Installeer Google Cloud SDK

Evenzo installeren we het softwarepakket. Meer informatie here.

# 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

Installeer Percona DBaaS CLI

Installeer vanuit de Percona-repositories. De Percona DBaaS CLI Tool is momenteel een experimenteel product, dus bevindt deze zich in een experimentele repository die apart moet worden ingeschakeld, zelfs als u al Percona-repositories heeft geïnstalleerd.

Meer informatie here.

Installatie-algoritme:

Configureer de Percona-repositories met behulp van het percona-release-hulpmiddel. Eerst moet u het officiële percona-release-pakket van Percona downloaden en installeren:
```
wget https://repo.percona.com/apt/percona-release_latest.generic_all.deb
sudo dpkg -i percona-release_latest.generic_all.deb
```
Schakel de experimentele component van de toolrepository als volgt in:
```
sudo percona-release enable tools experimental
```

Installeer het percona-dbaas-cli-pakket:

sudo apt-get update
sudo apt-get install percona-dbaas-cli

Instellen van de werking van componenten

Meer over configuraties here.

Eerst moet u inloggen op uw Google-account. Vervolgens laat Google Cloud één gebruiker meerdere onafhankelijke projecten hebben, dus u moet het werkproject opgeven door de code van dit project te gebruiken:

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

Maak vervolgens een cluster aan. Voor de demo heb ik een Kubernetes-cluster gemaakt met slechts drie knooppunten - dit is het minimum dat nodig is voor hoge beschikbaarheid:

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

De volgende kubectl-opdracht geeft de benodigde rechten aan onze huidige gebruiker:

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

Vervolgens maken we een namespace en maken deze actief. Een namespace is ruwweg ook een project of environment, maar dan binnen het Kubernetes-cluster. Het is onafhankelijk van Google Cloud-projecten:

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

Start het cluster

Nadat we deze stappen hebben doorlopen, kunnen we het cluster van drie knooppunten starten met deze eenvoudige opdracht:

# 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

Hoe u verbinding maakt met het cluster

Standaard is deze alleen toegankelijk binnen Kubernetes. Dat wil zeggen, vanaf de server waar je het commando 'Maak' hebt uitgevoerd, is deze niet toegankelijk. Om het bijvoorbeeld toegankelijk te maken voor tests met de klant, moet je de poort doorsturen via Port Mapping:

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

Verbind nu met je MySQL-client:

mysql -h 127.0.0.1 -P 3306 -uroot -pNt9YZquajW7nfVXTTrP

Geavanceerde clusterbeheercommando's

Database op een openbaar IP-adres

Als je een meer permanente oplossing wilt voor de toegankelijkheid van het cluster, kun je een extern IP-adres verkrijgen. In dit geval is de database toegankelijk vanaf elke plek. Dit is minder veilig, maar vaak handiger. Voor een extern IP gebruiken we het volgende commando:

# 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

Stel expliciet een wachtwoord in

In plaats van dat het systeem een wachtwoord willekeurig genereert, kun je expliciet een wachtwoord opgeven:

# 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

Ik laat de uitvoer van de scripts in een leesbare indeling zien, maar JSON-formaat wordt ook ondersteund.

Schakel hoge beschikbaarheid uit

Met het volgende commando kun je hoge beschikbaarheid uitschakelen om een single node uit te rollen:

# 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

Dit is een oplossing voor testtaken, zodat je snel en eenvoudig MySQL kunt opzetten, testen en daarna weer afbreken of gebruiken voor ontwikkeling.

De Percona DBaaS CLI-tool helpt bij het verkrijgen van een oplossing op Kubernetes, vergelijkbaar met DBaaS. We blijven werken aan de functionaliteit en gebruiksvriendelijkheid.

Deze presentatie werd voor het eerst gegeven op @Databases Meetup door Mail.ru Cloud Solutions & Tarantool. Bekijk video's andere presentaties en abonneer je op evenementaankondigingen in Telegram Rondom Kubernetes bij Mail.ru Group.

Wat nog meer te lezen over dit onderwerp:

Bron: habr.com