🔓 📠 🐻 Comment créer un cloud hybride avec Kubernetes pour remplacer DBaaS 👉🏿 👩‍💼 👩‍🎤

Je m'appelle Petr Zaitsev, je suis le PDG, fondateur de Percona et je tiens à vous dire:

comment nous sommes passés des solutions open source à 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 supprimant la dépendance du fournisseur et en conservant le SGBD en tant que service aussi simple que possible.

L'article est basé sur le rapport de @Databases Meetup par Mail.ru Cloud Solutions & Tarantool. Si vous ne voulez pas lire, vous pouvez voir:

Comment de l'open source est-il arrivé à Database as a Service dans le cloud?

Je fais 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 facile. Il était nécessaire de télécharger les sources, de corriger, de compiler et de ne les utiliser qu'ensuite.

Ensuite, l'open source est passé par une série de simplifications:

Les sources Tar.gz et INSTALL qui devaient être compilées;
les 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 paquets comme APT et YUM, à travers lesquels l'installation se fait automatiquement;
des solutions telles que Docker et Snap, qui vous permettent d'obtenir des packages lors de l'installation sans dépendances externes.

En conséquence, il devient plus facile d'utiliser des logiciels open source et la barrière à l'entrée dans le développement de telles applications est réduite.

Dans le même temps, contrairement à la situation d'il y a 20 ans, lorsque tout le monde était expert en assemblage, la plupart des développeurs ne peuvent plus assembler les outils utilisés à partir de la source.

En fait, ce n'est pas mal car:

Nous pouvons utiliser des logiciels plus complexes, mais plus pratiques. Par exemple, un navigateur est pratique à utiliser, mais il comprend de nombreux composants open source, il n'est pas pratique de le créer à partir de zéro.
Plus de personnes peuvent devenir des développeurs de logiciels open source et d'autres logiciels, plus de logiciels sont utilisés par les entreprises et le besoin en est plus grand.

L'inconvénient est que la prochaine étape de simplification est associée à l'utilisation de solutions cloud, ce qui conduit à un verrouillage spécifique du fournisseur, c'est-à-dire lié à un 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 nuages. Autrement dit, le moyen le plus simple et le plus rapide de déployer des logiciels open source (et compatibles) est dans les nuages, à l'aide d'une API propriétaire.

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

Construisez l'infrastructure de base de données comme dans un centre de données ordinaire. Autrement dit, prenez les blocs de construction standard: calcul, stockage, etc., mettez Linux dessus, une base de données, configurez.
Utilisez Database as a Service, où le fournisseur propose une base de données prête à l'emploi dans le cloud.

Désormais, DBaaS est un marché en croissance rapide, car un tel service permet aux développeurs de travailler directement avec des bases de données et minimise le travail de routine. Le fournisseur suppose la fourniture d'une haute disponibilité (haute disponibilité) et d'une mise à l'échelle facile, des correctifs de base de données, des sauvegardes et du réglage des performances.

Deux types de base de données en tant que service basé sur l'open source et une alternative sous la forme de Kubernetes

Il existe deux types de base de données en tant que service pour les bases de données open source:

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 capacité de migration entre les clouds et réduisent la portabilité des données et des applications. Par exemple, malgré le fait que différents types de nuages prennent en charge, en fait, le même MySQL standard, il existe des différences significatives entre eux: en fonctionnement, en performances, en sauvegarde, etc. La migration d'un cloud vers un autre peut être délicate, en particulier pour les applications complexes.

Et ici, la question se pose - est-il possible d'obtenir la commodité de Database as a Service, mais en tant que simple solution open source?

La mauvaise nouvelle est que, malheureusement, il n’existe pas encore de telles solutions sur le marché. La bonne nouvelle est qu'il existe Kubernetes qui vous permet de mettre en œuvre de telles solutions.

Kubernetes est un système d'exploitation cloud ou de centre de données qui vous permet de déployer et de gérer votre application sur plusieurs serveurs dans un cluster plutôt que sur un seul hôte.

Kubernetes est désormais leader dans cette catégorie de logiciels. Il y avait de nombreuses solutions différentes pour de telles tâches, mais c'est lui qui est devenu la norme. De nombreuses entreprises qui se sont lancées dans 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 qui est prise en charge dans les clouds privés, publics et hybrides de nombreux fournisseurs, par exemple: AWS, Google Cloud, Microsoft Azure, Mail.ru Cloud Solutions .

Comment Kubernetes fonctionne avec les bases de données

Kubernetes a été conçu à l'origine pour les applications sans état qui traitent les données mais ne stockent rien, comme les microservices ou les applications Web. Les bases de données sont à l'autre extrémité du spectre, ce qui signifie qu'il s'agit d'applications avec état. Et Kubernetes n'a pas été conçu à l'origine pour de telles applications.

Cependant, certaines fonctionnalités sont apparues récemment dans Kubernetes et permettent l'utilisation de bases de données et d'autres applications avec état:

Le concept StatefulSet est toute une série de primitives pour gérer les événements d'arrêt des pods et effectuer un arrêt progressif (arrêt prévisible de l'application).
Volumes persistants - magasins de données associés à des pods, 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à de grandes bases de données en tant que service dans les clouds publics, dans le backend duquel Kubernetes, par exemple: CockroachCloud, InfluxDB, PlanetScale. Autrement dit, une base de données Kubernetes n'est pas seulement ce qui est théoriquement possible, mais aussi ce qui fonctionne dans la pratique.

Percona propose deux solutions Kubernetes open source:

Opérateur Kubernetes pour le serveur Percona pour MongoDB.
Kubernetes Operator for XtraDB CLUSTER est un service compatible MySQL qui offre une haute disponibilité et une cohérence. Vous pouvez également utiliser un nœud unique si la haute disponibilité n'est pas nécessaire, par exemple pour la base de données de développement.

Les utilisateurs de Kubernetes peuvent être divisés en deux groupes. Certains utilisent directement les opérateurs Kubernetes - ce sont principalement des utilisateurs avancés qui ont une bonne compréhension du 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 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 un DBaaS open source basé sur Kubernetes sans une compréhension approfondie de la technologie.

Comment exécuter DBaaS à partir 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 manipuler manuellement la plate-forme.

Pour que notre DBaaS fonctionne, nous avons besoin des composants suivants:

Kubectl.
SDK Google Cloud.
CLI Percona DBaaS.

Installez kubectl

En installant le package pour votre système d'exploitation, nous allons regarder l'exemple d'Ubuntu. Plus de détails 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 le SDK Google Cloud

Installez le progiciel de la même manière. Plus de détails 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

Installez Percona DBaaS CLI

Installez à partir des référentiels Percona. L'outil CLI Percona DBaaS est toujours un produit expérimental, il se trouve donc dans un référentiel expérimental, qui doit être inclus séparément, même si vous avez déjà des référentiels Percona installés.

Plus de détails ici .

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 de la version percona 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 package percona-dbaas-cli:
```
sudo apt-get update
sudo apt-get install percona-dbaas-cli
```

Mise en place des composants

En savoir plus sur les paramètres ici .

Vous devez d'abord vous connecter à votre compte Google. De plus, Google Cloud permet à un utilisateur d'avoir plusieurs projets indépendants, vous devez donc spécifier un 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 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 requis à 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, grosso modo, é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

Nous démarrons le cluster

Après avoir parcouru ces quelques étapes, nous pouvons démarrer un 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 à un cluster

Par défaut, il n'est disponible que dans Kubernetes. Autrement dit, à partir de ce serveur à partir duquel vous avez exécuté la commande Create, il n'est pas disponible. Pour le rendre disponible, par exemple, pour des tests avec un client, vous devez passer le port via le mappage de ports:

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 de gestion de cluster avancées

Base de données 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 une adresse 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éfinir explicitement le mot de passe

Au lieu que le système génère le mot de passe de manière aléatoire, vous pouvez définir explicitement le mot de passe:

# 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 du script dans un format lisible par l'homme, mais le format JSON est également pris en charge.

Désactiver la haute disponibilité

Vous pouvez désactiver la haute disponibilité avec la commande suivante pour développer le 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 les problèmes de test afin de soulever rapidement et facilement MySQL, de le tester, puis de le remonter ou de l'utiliser pour le développement.

L'outil CLI Percona DBaaS vous aide à obtenir une solution de type DBaaS sur Kubernetes. Dans le même temps, nous continuons à travailler sur sa fonctionnalité et sa convivialité.

Cette conférence a été présentée pour la première fois à @Databases Meetup par Mail.ru Cloud Solutions & Tarantool. Regardez des vidéos d' autres discours et abonnez-vous aux annonces d'événements dans Telegram Around Kubernetes dans Mail.ru Group .

Que lire d'autre sur le sujet:

Comment créer un cloud hybride avec Kubernetes pour remplacer DBaaS