Mijn naam is Petr Zaitsev, ik ben de CEO en oprichter en ik wil je vertellen:
- hoe we van open source oplossingen naar Database as a Service zijn gekomen;
- welke benaderingen bestaan er voor het inzetten van databases in de cloud;
- hoe Kubernetes DBaaS kan vervangen, waardoor de afhankelijkheid van leveranciers wordt geëlimineerd en de eenvoud van DBMS as a service behouden blijft.
Het artikel is opgesteld op basis van een rapport op @Databases Meetup door Mail.ru Cloud Solutions & Tarantool. Als je niet wilt lezen, kun je kijken naar:
Hoe we van open source naar Database as a Service in de cloud zijn gekomen
Ik werk al sinds eind jaren negentig met open source. Twintig jaar geleden was het gebruik van open source, zoals databases, niet zo eenvoudig. Het was nodig om de broncode te downloaden, te patchen, te compileren en pas daarna te gebruiken.
Open source onderging vervolgens een reeks vereenvoudigingen:
- Tar.gz- en INSTALL-bronnen die moesten worden gecompileerd;
- pakketten met afhankelijkheden zoals .deb en .rpm, waarbij u slechts een set pakketten hoeft te installeren;
- pakketrepository's zoals APT en YUM, waarbij de installatie automatisch gebeurt;
- oplossingen zoals Docker en Snap, waarmee u pakketten kunt ontvangen via installatie zonder externe afhankelijkheden.
Als gevolg hiervan wordt het gemakkelijker om open source-software te gebruiken en wordt ook de drempel verlaagd om dergelijke toepassingen te ontwikkelen.
Tegelijkertijd kunnen de meeste ontwikkelaars, in tegenstelling tot de situatie twintig jaar geleden, toen iedereen een assemblage-expert was, de tools die ze gebruiken nu niet vanaf de bron bouwen.
In feite is dit niet slecht, omdat:
- We kunnen complexere maar gebruiksvriendelijkere software gebruiken. Een browser is bijvoorbeeld handig in gebruik, maar bevat veel open source-componenten en is lastig om helemaal opnieuw te bouwen.
- Er kunnen meer mensen ontwikkelaar worden van (open source) software, er wordt meer software gebruikt door bedrijven en de behoefte daaraan is groter.
Het nadeel is dat de volgende stap in vereenvoudiging gepaard gaat met het gebruik van cloudoplossingen, en dit leidt tot een zekere leverancierslock-in, dat wil zeggen binding aan één leverancier. Wij gebruiken simpele oplossingen en providers gebruiken open source componenten, maar zitten feitelijk vastgenageld aan één van de grote clouds. Dat wil zeggen dat de eenvoudigste en snelste manier om open source (en software die daarmee compatibel is) in de cloud te implementeren, met behulp van een eigen API.
Als het om databases in de cloud gaat, zijn er twee benaderingen:
- Monteer de database-infrastructuur, zoals in een regulier datacenter. Dat wil zeggen, neem standaardbouwstenen: rekenkracht, opslag, enzovoort, installeer Linux en een database erop en configureer ze.
- Gebruik Database as a Service, waarbij de provider een kant-en-klare database in de cloud aanbiedt.
DBaaS is momenteel een snelgroeiende markt omdat het ontwikkelaars in staat stelt rechtstreeks met databases te werken en routinewerk tot een minimum beperkt. De provider verbindt zich ertoe te zorgen voor hoge beschikbaarheid en eenvoudige schaalbaarheid, databasepatching, back-ups en prestatie-afstemming.
Twee soorten Database as a Service op basis van open source en een alternatief in de vorm van Kubernetes
Er zijn twee typen Database as a Service voor open databases:
- Een standaard open source-product verpakt in een beheerbackend voor eenvoudige implementatie en beheer.
- Een geavanceerde commerciële oplossing met diverse add-ons, compatibel met open source.
Beide opties verminderen de mogelijkheid van migratie tussen clouds en verminderen de portabiliteit van gegevens en applicaties. Ondanks het feit dat verschillende soorten clouds in wezen dezelfde standaard MySQL ondersteunen, zijn er bijvoorbeeld aanzienlijke verschillen tussen de verschillende soorten clouds: in werking, prestaties, back-up, enzovoort. Migreren van de ene cloud naar de andere kan een uitdaging zijn, vooral voor complexe applicaties.
En hier rijst de vraag: is het mogelijk om het gemak van Database as a Service te krijgen, maar dan als een eenvoudige open source-oplossing?
Het slechte nieuws is dat dergelijke oplossingen helaas nog niet op de markt zijn. Het goede nieuws is dat er Kubernetes bestaat, waarmee je dergelijke oplossingen kunt implementeren.
Kubernetes is een besturingssysteem voor de cloud of het datacenter waarmee u een applicatie op meerdere servers in een cluster kunt implementeren en beheren in plaats van op één host.
Nu is Kubernetes de leider in de categorie van dergelijke software. Er waren veel verschillende oplossingen voor dergelijke problemen, maar het werd de standaard. Veel bedrijven die zich vroeger op alternatieve oplossingen concentreerden, richten zich nu op het aanpassen van hun producten om Kubernetes te ondersteunen.
Daarnaast is Kubernetes een universele oplossing die wordt ondersteund in private, publieke en hybride clouds van veel leveranciers, bijvoorbeeld: AWS, Google Cloud, Microsoft Azure, .
Hoe Kubernetes werkt met databases
Kubernetes is oorspronkelijk ontworpen voor stateless applicaties die data verwerken maar niets opslaan, zoals microservices of webapplicaties. Databases bevinden zich aan de andere kant van het spectrum, dat wil zeggen: het zijn stateful applicaties. En Kubernetes was oorspronkelijk niet bedoeld voor dergelijke toepassingen.
Er zijn echter onlangs functies in Kubernetes verschenen die het gebruik van databases en andere stateful applicaties mogelijk maken:
- Het StatefulSet-concept is een hele reeks primitieven voor het verwerken van gebeurtenissen over het stoppen van het werk van pods en het implementeren van Graceful Shutdown (voorspelbaar afsluiten van de applicatie).
- Persistente volumes zijn gegevensarchieven die zijn gekoppeld aan pods, Kubernetes-beheerobjecten.
- Operator Framework - dat wil zeggen de mogelijkheid om componenten te maken voor het beheren van databases en andere stateful applicaties die over veel knooppunten zijn verdeeld.
In publieke clouds zijn er nu al grote Databases as a Service, waarvan de backend Kubernetes is, bijvoorbeeld: CockroachCloud, InfluxDB, PlanetScale. Dat wil zeggen: een database op Kubernetes is niet alleen iets dat theoretisch mogelijk is, maar ook iets dat in de praktijk werkt.
Percona heeft twee open source oplossingen voor Kubernetes:
- Kubernetes-operator voor Percona Server voor MongoDB.
- Kubernetes Operator voor XtraDB CLUSTER is een service die compatibel is met MySQL en hoge beschikbaarheid en consistentie biedt. U kunt ook één knooppunt gebruiken als hoge beschikbaarheid niet nodig is, bijvoorbeeld voor een ontwikkelaarsdatabase.
Kubernetes-gebruikers kunnen in twee groepen worden verdeeld. Sommige mensen maken rechtstreeks gebruik van Kubernetes Operators – dit zijn vooral gevorderde gebruikers die goed begrijpen hoe de technologie werkt. Anderen draaien het op de backend - zulke gebruikers zijn geïnteresseerd in zoiets als Database as a Service, ze willen zich niet verdiepen in de nuances van Kubernetes. 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 willen krijgen op basis van Kubernetes zonder een diep begrip van de technologie.
Hoe u DBaaS van Percona kunt uitvoeren op Google Kubernetes Engine
Google Kubernetes Engine is naar mijn mening een van de meest functionele implementaties van Kubernetes-technologie. Het is beschikbaar in veel delen van de wereld en heeft een eenvoudige en handige Command Line Tool (SDK), waarmee u scripts kunt maken in plaats van het platform handmatig te beheren.
Om onze DBaaS te laten werken, hebben we de volgende componenten nodig:
- Kubectl.
- Google Cloud-SDK.
- Percona DBaaS CLI.
Installeer kubectl
We installeren het pakket voor jouw besturingssysteem, we kijken naar het voorbeeld van Ubuntu. Meer details .
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 installeren
Wij installeren het softwarepakket op dezelfde manier. Meer details .
# 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 installeren
Installeer vanuit de Percona-repository's. Percona DBaaS CLI Tool is nog steeds een experimenteel product en bevindt zich dus in de experimentele repository, die afzonderlijk moet worden ingeschakeld, zelfs als u al Percona-repository's hebt geïnstalleerd.
Meer .
Installatie algoritme:
- Stel Percona-repository's in met de percona-releasetool. Eerst moet u het officiële percona-releasepakket 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 component voor de experimentele 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 instellingen .
Eerst moet u inloggen op uw Google-account. Bovendien staat Google Cloud toe dat één gebruiker veel onafhankelijke projecten heeft, dus u moet een werkend project specificeren met behulp van de code voor dit project:
gcloud auth login
gcloud config set project hidden-brace-236921
Vervolgens maken we een cluster. Voor de demo heb ik een Kubernetes-cluster van slechts drie knooppunten gemaakt - 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 gewenste 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 naamruimte en maken deze actief. Naamruimte is grofweg ook een project of omgeving, maar dan al binnen een Kubernetes-cluster. Het is onafhankelijk van Google Cloud-projecten:
kubectl create namespace my-namespace
kubectl config set-context --current --namespace=my-namespace
Het cluster starten
Nadat we deze paar stappen hebben doorlopen, kunnen we een cluster met 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
Verbinding maken met een cluster
Standaard is het alleen beschikbaar binnen Kubernetes. Dat wil zeggen, het is niet toegankelijk vanaf deze server waarop u de opdracht “Create” hebt uitgevoerd. Om deze bijvoorbeeld beschikbaar te maken voor tests met een klant, moet je de poort doorsturen via Port Mapping:
kubectl port-forward svc/example-proxysql 3306:3306 $Vervolgens verbinden we uw MySQL-client:
mysql -h 127.0.0.1 -P 3306 -uroot -pNt9YZquajW7nfVXTTrP
Geavanceerde clusterbeheeropdrachten
Database op openbaar IP-adres
Als u een meer permanente oplossing voor clusterbeschikbaarheid wilt, kunt u een extern IP-adres verkrijgen. In dit geval is de database overal toegankelijk. Dit is minder veilig, maar vaak wel handiger. Voor 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 het wachtwoord expliciet in
In plaats van dat het systeem willekeurig een wachtwoord genereert, kunt u het wachtwoord expliciet instellen:
# 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 toon de uitvoer van de scripts in een voor mensen leesbaar formaat, maar het JSON-formaat wordt ook ondersteund.
Hoge beschikbaarheid uitschakelen
Met de volgende opdracht kunt u hoge beschikbaarheid uitschakelen om één knooppunt te implementeren:
# 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 het testen van taken om MySQL zo snel en eenvoudig mogelijk aan de praat te krijgen, te testen en vervolgens af te sluiten of te gebruiken voor ontwikkeling.
Met de Percona DBaaS CLI-tool realiseert u een DBaaS-achtige oplossing op Kubernetes. Tegelijkertijd blijven we werken aan de functionaliteit en bruikbaarheid ervan.
Dit rapport werd voor het eerst gepresenteerd op door Mail.ru Cloud Solutions&Tarantool. Kijk andere optredens en abonneer je op evenementaankondigingen op Telegram .
Wat kun je nog meer lezen over dit onderwerp:
Bron: www.habr.com