Je m'appelle Petr Zaitsev, je suis le PDG, fondateur et je veux te dire :
- comment nous sommes passés des solutions open source à la base de données en tant que service ;
- quelles approches existent pour déployer des bases de données dans le cloud ;
- comment Kubernetes peut remplacer DBaaS, en éliminant la dépendance aux fournisseurs et en conservant la simplicité du SGBD en tant que service.
L'article a été préparé sur la base d'un rapport du @Databases Meetup de Mail.ru Cloud Solutions & Tarantool. Si vous ne voulez pas lire, vous pouvez regarder :
Comment nous sommes passés de l'open source à la base de données en tant que service dans le cloud
Je travaille dans l'open source depuis la fin des années 90. Il y a vingt ans, utiliser l’open source, comme les bases de données, n’était pas si simple. Il fallait télécharger le code source, le patcher, le compiler et ensuite seulement l'utiliser.
L’open source a ensuite connu une série de simplifications :
- Sources Tar.gz et INSTALL qui devaient être compilées ;
- des packages avec des dépendances telles que .deb et .rpm, où il vous suffit d'installer un ensemble de packages ;
- des référentiels de packages comme APT et YUM, avec lesquels l'installation est automatique ;
- des solutions telles que Docker et Snap, qui permettent de recevoir des packages par installation sans dépendances externes.
En conséquence, il devient plus facile d’utiliser des logiciels open source et abaisse également les barrières à l’entrée dans le développement de telles applications.
Dans le même temps, contrairement à la situation d’il y a 20 ans, où tout le monde était un expert en assemblage, la plupart des développeurs ne peuvent désormais pas créer les outils qu’ils utilisent à partir des sources.
En fait, ce n'est pas mal, car :
- Nous pouvons utiliser des logiciels plus complexes mais plus conviviaux. Par exemple, un navigateur est pratique à utiliser, mais il inclut de nombreux composants open source et n'est pas pratique à créer à partir de zéro.
- De plus en plus de personnes peuvent devenir développeurs de logiciels open source et autres, davantage de logiciels sont utilisés par les entreprises et leur besoin est plus grand.
L'inconvénient est que la prochaine étape de la simplification est associée à l'utilisation de solutions cloud, ce qui conduit à un certain verrouillage du fournisseur, c'est-à-dire une liaison avec un seul fournisseur. Nous utilisons des solutions simples et les fournisseurs utilisent des composants open source, mais en fait ils sont cloués à l'un des grands cloud. Autrement dit, le moyen le plus simple et le plus rapide de déployer l'open source (et les logiciels compatibles avec celui-ci) est dans les nuages, à l'aide d'une API propriétaire.
Lorsqu'il s'agit de bases de données dans le cloud, il existe deux approches :
- Assemblez l’infrastructure de base de données, comme dans un centre de données classique. Autrement dit, prenez des éléments de base standard : calcul, stockage, etc., installez Linux et une base de données dessus, et configurez-les.
- Utilisez la base de données en tant que service, où le fournisseur propose une base de données prête à l'emploi dans le cloud.
DBaaS est actuellement un marché en croissance rapide car il permet aux développeurs de travailler directement avec des bases de données et minimise le travail de routine. Le fournisseur s'engage à garantir une haute disponibilité et une mise à l'échelle facile, des correctifs de base de données, des sauvegardes et un réglage des performances.
Deux types de Database as a Service basés sur l'open source et une alternative sous la forme de Kubernetes
Il existe deux types de Database as a Service pour les bases de données ouvertes :
- Un produit open source standard intégré dans un backend d'administration pour un déploiement et une gestion faciles.
- Une solution commerciale avancée avec divers modules complémentaires, compatible avec l'open source.
Les deux options réduisent la possibilité de migration entre les cloud et réduisent la portabilité des données et des applications. Par exemple, même si différents types de cloud prennent en charge essentiellement le même standard MySQL, il existe des différences significatives entre eux : en termes de fonctionnement, de performances, de sauvegarde, etc. La migration d'un cloud à un autre peut s'avérer difficile, en particulier pour les applications complexes.
Et ici, la question se pose : est-il possible d'obtenir la commodité d'une base de données en tant que service, mais en tant que simple solution open source ?
La mauvaise nouvelle est que, malheureusement, de telles solutions n’existent pas encore sur le marché. La bonne nouvelle est qu’il existe Kubernetes, qui permet de mettre en œuvre de telles solutions.
Kubernetes est un système d'exploitation pour le cloud ou le centre de données qui vous permet de déployer et de gérer une application sur plusieurs serveurs dans un cluster plutôt que sur un seul hôte.
Kubernetes est désormais le leader dans la catégorie de ces logiciels. Il existait de nombreuses solutions différentes à ces problèmes, mais elles sont devenues la norme. De nombreuses entreprises qui se concentraient auparavant sur des solutions alternatives se concentrent désormais sur l'adaptation de leurs produits pour prendre en charge Kubernetes.
De plus, Kubernetes est une solution universelle prise en charge dans les cloud privés, publics et hybrides de nombreux fournisseurs, par exemple : AWS, Google Cloud, Microsoft Azure, .
Comment Kubernetes fonctionne avec les bases de données
Kubernetes a été initialement conçu pour les applications sans état qui traitent des données mais ne stockent rien, comme les microservices ou les applications Web. Les bases de données se situent à l’autre extrémité du spectre, c’est-à-dire qu’elles sont des applications avec état. Et Kubernetes n’était pas initialement destiné à de telles applications.
Cependant, certaines fonctionnalités sont apparues récemment dans Kubernetes et permettent d'utiliser des bases de données et d'autres applications avec état :
- Le concept StatefulSet est toute une série de primitives permettant de traiter les événements relatifs à l'arrêt du travail des pods et à la mise en œuvre de Graceful Shutdown (arrêt prévisible de l'application).
- Les volumes persistants sont des magasins de données associés à des pods, des objets de gestion Kubernetes.
- Operator Framework - c'est-à-dire la possibilité de créer des composants pour gérer des bases de données et d'autres applications avec état distribuées sur de nombreux nœuds.
Il existe déjà dans les cloud publics de grandes bases de données en tant que service, dont le backend est Kubernetes, par exemple : CockroachCloud, InfluxDB, PlanetScale. Autrement dit, une base de données sur Kubernetes n’est pas seulement quelque chose de théoriquement possible, mais aussi quelque chose qui fonctionne dans la pratique.
Percona propose deux solutions open source pour Kubernetes :
- Opérateur Kubernetes pour Percona Server pour MongoDB.
- Kubernetes Operator for XtraDB CLUSTER est un service compatible avec MySQL et offre une haute disponibilité et cohérence. Vous pouvez également utiliser un seul nœud si la haute disponibilité n'est pas nécessaire, par exemple pour une base de données de développement.
Les utilisateurs de Kubernetes peuvent être divisés en deux groupes. Certaines personnes utilisent directement les opérateurs Kubernetes. Il s’agit principalement d’utilisateurs avancés qui comprennent bien le fonctionnement de la technologie. D'autres l'exécutent sur le backend - ces utilisateurs sont intéressés par quelque chose comme Database as a Service, ils ne veulent pas se plonger dans les nuances de Kubernetes. Pour le deuxième groupe d'utilisateurs, nous avons une autre solution open source - Percona DBaaS CLI Tool. Il s'agit d'une solution expérimentale pour ceux qui souhaitent obtenir une DBaaS open source basée sur Kubernetes sans une compréhension approfondie de la technologie.
Comment exécuter le DBaaS de Percona sur Google Kubernetes Engine
Google Kubernetes Engine, à mon avis, est l'une des implémentations les plus fonctionnelles de la technologie Kubernetes. Il est disponible dans de nombreuses régions du monde et dispose d'un outil de ligne de commande (SDK) simple et pratique, qui vous permet de créer des scripts plutôt que de gérer manuellement la plate-forme.
Pour que notre DBaaS fonctionne, nous avons besoin des composants suivants :
- Kubectl.
- SDK Google Cloud.
- Percona DBaaS CLI.
Installer Kubectl
Nous installons le package pour votre système d'exploitation, nous regarderons l'exemple d'Ubuntu. Plus de détails .
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
Installation du SDK Google Cloud
Nous installons le progiciel de la même manière. Plus de détails .
# 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
Installation de la CLI Percona DBaaS
Installez à partir des référentiels Percona. L'outil Percona DBaaS CLI est toujours un produit expérimental, il se trouve donc dans le référentiel expérimental, qui doit être activé séparément, même si des référentiels Percona sont déjà installés.
Plus .
Algorithme d'installation :
- Configurez les référentiels Percona à l'aide de l'outil percona-release. Vous devez d’abord télécharger et installer le package officiel percona-release de Percona :
wget https://repo.percona.com/apt/percona-release_latest.generic_all.deb sudo dpkg -i percona-release_latest.generic_all.deb - Activez le composant de référentiel d'outils expérimentaux comme suit :
sudo percona-release enable tools experimental - Installez le paquet percona-dbaas-cli :
sudo apt-get update sudo apt-get install percona-dbaas-cli
Mise en place du fonctionnement des composants
En savoir plus sur les paramètres .
Vous devez d'abord vous connecter à votre compte Google. De plus, Google Cloud permet à un utilisateur d'avoir de nombreux projets indépendants. Vous devez donc spécifier un projet fonctionnel à l'aide du code de ce projet :
gcloud auth login
gcloud config set project hidden-brace-236921
Ensuite, nous créons un cluster. Pour la démo, j'ai créé un cluster Kubernetes de seulement trois nœuds - c'est le minimum requis pour la haute disponibilité :
gcloud container clusters create --zone us-central1-a your-cluster-name --cluster-version 1.15 --num-nodes=3
La commande kubectl suivante donne les privilèges souhaités à notre utilisateur actuel :
kubectl create clusterrolebinding cluster-admin-binding-$USER
--clusterrole=cluster-admin --user=$(gcloud config get-value core/account)Ensuite, nous créons un espace de noms et le rendons actif. L'espace de noms est, en gros, également comme un projet ou un environnement, mais déjà à l'intérieur d'un cluster Kubernetes. Il est indépendant des projets Google Cloud :
kubectl create namespace my-namespace
kubectl config set-context --current --namespace=my-namespace
Démarrage du cluster
Une fois que nous avons parcouru ces quelques étapes, nous pouvons démarrer un cluster à trois nœuds avec cette simple commande :
# 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
Comment se connecter à un cluster
Par défaut, il n'est disponible que dans Kubernetes. Autrement dit, il n'est pas accessible depuis ce serveur à partir duquel vous avez exécuté la commande « Créer ». Pour le rendre disponible, par exemple, pour des tests avec un client, vous devez transférer le port via Port Mapping :
kubectl port-forward svc/example-proxysql 3306:3306 $Ensuite, nous connectons votre client MySQL :
mysql -h 127.0.0.1 -P 3306 -uroot -pNt9YZquajW7nfVXTTrP
Commandes avancées de gestion de cluster
Base de données sur IP publique
Si vous souhaitez une solution plus permanente pour la disponibilité du cluster, vous pouvez obtenir une adresse IP externe. Dans ce cas, la base de données sera accessible de n'importe où. C'est moins sûr, mais souvent plus pratique. Pour l'IP externe, nous utilisons la commande suivante :
# 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
Définir explicitement le mot de passe
Au lieu que le système génère un mot de passe de manière aléatoire, vous pouvez définir le mot de passe explicitement :
# 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
J'affiche la sortie des scripts dans un format lisible par l'homme, mais le format JSON est également pris en charge.
Désactiver la haute disponibilité
Avec la commande suivante, vous pouvez désactiver la haute disponibilité pour déployer un seul nœud :
# 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
Il s'agit d'une solution permettant de tester des tâches afin de rendre MySQL opérationnel aussi rapidement et facilement que possible, de le tester, puis de l'arrêter ou de l'utiliser pour le développement.
L'outil Percona DBaaS CLI vous aide à réaliser une solution de type DBaaS sur Kubernetes. En parallèle, nous continuons à travailler sur sa fonctionnalité et sa convivialité.
Ce rapport a été présenté pour la première fois à par Mail.ru Cloud Solutions&Tarantool. Regarder d'autres performances et abonnez-vous aux annonces d'événements sur Telegram .
Que lire d'autre sur le sujet :
Source: habr.com