🥇Comment construire un cloud hybride avec Kubernetes pouvant remplacer DBaaS

Je m'appelle Piotr Zaïtsev, je suis le directeur général, le fondateur Percona et je veux vous parler :

comment nous sommes passés des solutions open source à la Database as a Service ;
quelles sont les approches pour déployer des bases de données dans le cloud ;
comment Kubernetes peut remplacer DBaaS, en éliminant la dépendance vis-à-vis du fournisseur tout en conservant la simplicité des bases de données en tant que service.

Cet article est basé sur une présentation lors du @Databases Meetup par Mail.ru Cloud Solutions & Tarantool. Si vous ne voulez pas lire, vous pouvez regarder :

Comment nous sommes passés de l'open source à la Database as a Service dans le cloud

Je m'occupe de 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 seulement ensuite l'utiliser.

Puis, l'open source a connu une série de simplifications :

des sources Tar.gz et INSTALL, qui devaient être compilées ;
des paquets avec des dépendances comme .deb et .rpm, où il suffisait d'installer un ensemble de paquets ;
des dépôts de paquets comme APT et YUM, avec lesquels l'installation se fait automatiquement ;
des solutions comme Docker et Snap, permettant d'obtenir des paquets par installation sans dépendances externes.

Au final, l'utilisation de logiciels libres devient plus simple et la barrière d'entrée dans le développement de telles applications diminue.

Cependant, contrairement à la situation d'il y a 20 ans, où tout le monde était expert en compilation, la plupart des développeurs aujourd'hui ne peuvent pas compiler les outils qu'ils utilisent à partir des sources.

En réalité, ce n'est pas si mal, car :

Nous pouvons utiliser des logiciels plus complexes mais plus pratiques. Par exemple, un navigateur — il est pratique à utiliser, mais il contient de nombreux composants open source, et il est peu pratique de le compiler à partir de zéro.
Plus de personnes peuvent devenir des développeurs open source et d'autres logiciels, plus de logiciels sont utilisés par les entreprises, et la demande pour eux augmente.

L'autre face de la médaille est que la prochaine étape dans cette simplification est liée à l'utilisation de solutions cloud, ce qui entraîne un certain verrouillage fournisseur, c'est-à-dire une dépendance à un seul fournisseur. Nous utilisons des solutions simples et les fournisseurs utilisent des composants open source, mais en réalité, ils sont cloués à l'un des grands clouds. Ainsi, le moyen le plus simple et le plus rapide de déployer de l'open source (et des logiciels compatibles) est dans les clouds, en utilisant une API propriétaire.

En ce qui concerne les bases de données dans le cloud, il existe deux approches :

Construire une infrastructure de base de données, comme dans un centre de données traditionnel. Cela signifie prendre des blocs de construction standard : compute, storage, etc., les installer sur Linux, la base de données, et configurer.
Utiliser Database as a Service, où le fournisseur propose déjà une base de données prête à l'emploi dans le cloud.

Actuellement, le DBaaS est un marché en forte croissance, car ce service permet aux développeurs de travailler directement avec des bases de données et minimise le travail répétitif. Le fournisseur prend en charge la High Availability (haute disponibilité) et la mise à l'échelle facile, le patching des bases de données, les sauvegardes, et l'optimisation des performances.

Deux types de Database as a Service basés sur l'open source et une alternative sous forme de Kubernetes.

Il existe deux types de Database as a Service pour les bases de données ouvertes :

Un produit open source standard, emballé dans un backend pour l'administration, ce qui facilite le déploiement et la gestion.
Une solution commerciale avancée avec diverses extensions, compatible avec l'open source.

Les deux options réduisent la possibilité de migration entre les clouds, diminuent la portabilité des données et des applications. Par exemple, bien que différents types de clouds prennent en charge le même standard MySQL, ils présentent des différences significatives en termes de fonctionnement, de performance, de sauvegarde, etc. Migrer d'un cloud à un autre peut être complexe, surtout pour des applications difficiles.

Et la question se pose : peut-on obtenir la commodité de Database as a Service, mais sous forme d'une solution open source simple ?

La mauvaise nouvelle est qu'il n'existe malheureusement pas encore de telles solutions sur le marché. La bonne nouvelle est qu'il y a Kubernetes, qui permet de réaliser de telles solutions.

Kubernetes est un système d'exploitation pour le cloud ou le centre de données, qui permet de déployer une application et de la gérer sur de nombreux serveurs de clusters, et non sur un seul hôte.

Actuellement, Kubernetes est le leader dans sa catégorie de logiciel. Plusieurs solutions ont été mises en place pour de telles tâches, mais c'est lui qui est devenu la norme. De nombreuses entreprises, qui auparavant exploraient d'autres solutions, se concentrent maintenant sur l'adaptation de leurs produits pour prendre en charge Kubernetes.

De plus, Kubernetes est une solution universelle qui est prise en charge dans des clouds privés, publics et hybrides de nombreux fournisseurs, par exemple : AWS, Google Cloud, Microsoft Azure, Mail.ru Cloud Solutions.

Comment Kubernetes fonctionne avec des bases de données

Kubernetes a été initialement conçu pour des applications sans état qui traitent des données sans les stocker, comme des microservices ou des 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 à l'origine destiné à de telles applications.

Cependant, il existe des fonctionnalités qui ont récemment été ajoutées à Kubernetes et qui permettent l'utilisation de bases de données et d'autres applications avec état :

Le concept de StatefulSet est une série de primitives pour gérer les événements liés à l'arrêt des pods et réaliser un arrêt en douceur (graceful shutdown) de l'application.
Les Volumes Persistants sont des stockages de données associés aux pods, des objets de gestion de Kubernetes.
Le Framework Operator, c'est-à-dire la capacité de créer des composants pour gérer des bases de données et d'autres applications avec état, réparties sur plusieurs nœuds.

Il existe déjà dans les cloud publics de grandes solutions Database as a Service, qui reposent sur Kubernetes, par exemple : CockroachCloud, InfluxDB, PlanetScale. Ainsi, une base de données sur Kubernetes n'est pas seulement une possibilité théorique, mais fonctionne aussi dans la pratique.

Percona propose deux solutions open source pour Kubernetes :

Kubernetes Operator pour Percona Server for MongoDB.
Kubernetes Operator pour XtraDB CLUSTER — un service compatible avec MySQL, assurant une haute disponibilité et cohérence. Un nœud unique peut également être utilisé si une haute disponibilité n'est pas nécessaire, par exemple pour une base de développement.

Les utilisateurs de Kubernetes peuvent être divisés en deux groupes. Certains utilisent directement les Kubernetes Operators — ce sont principalement des utilisateurs avancés qui comprennent bien le fonctionnement de la technologie. D'autres le lancent sur le backend — ces utilisateurs sont intéressés par des solutions comme Database as a Service, et ne souhaitent pas se plonger dans les détails du fonctionnement de Kubernetes. Pour ce deuxième groupe d'utilisateurs, nous avons une autre solution open source — l'outil Percona DBaaS CLI Tool. C'est une solution expérimentale pour ceux qui souhaitent obtenir un DBaaS open source basé sur Kubernetes sans avoir besoin de comprendre profondément la technologie.

Comment lancer le DBaaS de Percona sur Google Kubernetes Engine

Google Kubernetes Engine est, à mon avis, l'une des implémentations les plus fonctionnelles de la technologie Kubernetes. Elle est disponible dans de nombreuses régions du monde et possède un outil de ligne de commande simple et convivial (SDK), permettant de créer des scripts au lieu de gérer la plateforme manuellement.

Pour que notre DBaaS fonctionne, les composants suivants sont nécessaires :

Kubectl.
Google Cloud SDK.
Percona DBaaS CLI.

Installer kubectl

Installez le package pour votre système d'exploitation, nous allons voir l'exemple d'Ubuntu. En savoir plus ici.

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

Installer Google Cloud SDK

De la même manière, installez le package logiciel. En savoir plus ici.

# 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

Installer Percona DBaaS CLI

Installez-le depuis les dépôts Percona. L'outil Percona DBaaS CLI est un produit encore expérimental, il se trouve donc dans un dépôt expérimental qui doit être activé séparément, même si vous avez déjà installé les dépôts Percona.

En savoir plus ici.

Algorithme d'installation :

Configurez les dépôts Percona à l'aide de l'outil percona-release. D'abord, vous devez 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 expérimental des dépôts d'outils comme suit :
```
sudo percona-release enable tools experimental
```

Installez le package percona-dbaas-cli :

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

Configurer le fonctionnement des composants

En savoir plus sur les configurations ici.

Tout d'abord, vous devez vous connecter à votre compte Google. Ensuite, Google Cloud permet à un utilisateur d'avoir plusieurs projets indépendants, il est donc nécessaire d'indiquer le projet de travail en utilisant le 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 avec seulement trois nœuds — c'est le minimum requis pour une haute disponibilité :

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

La commande suivante kubectl donne les privilèges nécessaires à 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 namespace et le rendons actif. Un namespace est, en gros, comme un projet ou un environnement, mais à l'intérieur du cluster Kubernetes. Il est indépendant des projets Google Cloud :

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

Lancer le cluster

Après avoir suivi ces plusieurs étapes, nous pouvons lancer le cluster de 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 au cluster

Par défaut, il n'est accessible que depuis Kubernetes. Cela signifie que depuis le serveur à partir duquel vous avez lancé la commande « Créer », il n'est pas accessible. Pour le rendre accessible, par exemple pour des tests avec un client, vous devez transférer le port via le Port Mapping :

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

Ensuite, connectez 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 une IP publique

Si vous souhaitez une solution plus permanente pour l'accessibilité 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écurisé, mais souvent plus pratique. Pour obtenir l'IP externe, utilisez 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éfinissons le mot de passe explicitement

Au lieu de laisser le système générer un mot de passe aléatoirement, vous pouvez le définir 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 les résultats des scripts dans un format lisible, mais le format JSON est également pris en charge.

Désactivation de la haute disponibilité

La commande suivante permet de désactiver la haute disponibilité pour déployer un nœud unique :

# 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

C'est une solution pour des tâches de test, afin de mettre rapidement et facilement en place MySQL, de le tester, puis de le démanteler ou de l'utiliser pour le développement.

L'outil Percona DBaaS CLI aide à obtenir une solution sur Kubernetes, semblable à DBaaS. Nous continuons à travailler sur sa fonctionnalité et son ergonomie.

Cette présentation a été prononcée pour la première fois à @Databases Meetup par Mail.ru Cloud Solutions & Tarantool. Voir vidéo d'autres présentations et abonnez-vous aux annonces des événements sur Telegram. Autour de Kubernetes dans Mail.ru Group..

Que lire d'autre sur le sujet :

Source : habr.com

Comment construire un cloud hybride avec Kubernetes, capable de remplacer DBaaS