Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Un Aggregate, deux tailles de cluster MySQL

Un MySQL InnoDB Cluster et le plan de contrôle qui le réconcilie, compilés deux fois à partir d’un seul Aggregate inchangé : une fois en demandant une seule instance de serveur, une fois en en demandant trois.

La leçon est l’endroit où vit la taille. Le nombre de serveurs derrière la base de données n’est ni quelque chose que le développeur a écrit, ni quelque chose que la Recipe a décidé — c’est une ligne de dimensionnement par l’opérateur dans la Release, et c’est tout ce qui diffère entre les deux arbres rendus.

Ce que le compilateur écrit, et ce qu’il n’écrit pas

Cette réalisation émet une ressource personnalisée InnoDBCluster. Elle n’émet ni serveurs, ni Services, ni routeurs : le MySQL Operator for Kubernetes les crée dans le cluster cible une fois la ressource personnalisée appliquée, un travail qui a lieu bien après que le compilateur a terminé.

Tout ce qui suit décrit donc ce que la ressource personnalisée rendue demande. Ce que contient finalement un cluster en fonctionnement est la réponse du contrôleur à cette demande, à un moment que le compilateur ne voit jamais — et le compilateur n’affirme rien à ce sujet, car il n’a aucun moyen de regarder.

La seule chose qui varie

.-- release-single.yaml ----- spec.instances: 1
/
one Aggregate -- one Manifest -+
one Component \
one Recipe '- release-replicated.yaml -- spec.instances: 3

Les deux Releases sélectionnent le même Component et la même Recipe, il y a donc un seul Manifest, et non un par Release. Lorsque deux Releases ne diffèrent que par le dimensionnement, le mappage d’Ops n’a rien à dire sur la différence, et une seconde copie de celui-ci serait une seconde chose à maintenir en phase sans aucun gain.

Fichiers

  • aggregate.yaml — l’intention du développeur, et le même document pour les deux Releases : un composant mysql-operator pour le plan de contrôle, un composant db de type core/datastore/mysql-innodb-cluster, et le jeu de caractères que le développeur veut que le serveur parle. Rien ici ne dit combien de serveurs il y a.
  • manifest.yaml — le mappage d’Ops, partagé par les deux Releases. Deux lignes : quelle Recipe réalise le plan de contrôle, et laquelle réalise la base de données.
  • release-single.yaml, release-replicated.yaml — le dimensionnement par l’opérateur. Ils diffèrent par leur metadata.name et par server_instances, et tout autre champ est maintenu identique à dessein, afin qu’une ligne soit toute la différence.
  • .aggrega-config.yaml — nomme le registre hub depuis lequel se résout le catalogue de la bibliothèque standard. Cet exemple n’écrit aucune entité qui lui soit propre.

Générer l’exemple

Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example mysql-innodb-cluster

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :

Terminal window
cd mysql-innodb-cluster

Build

Terminal window
aggrega build --release release-single.yaml --auto-pull
aggrega build --release release-replicated.yaml --auto-pull

--auto-pull écrit pendant le build le lockfile qui manque à un clone récent. Chaque build écrit dans dist/, et un build ajoute ses fichiers au lieu d’effacer ce qu’un build précédent a laissé. Supprimez dist/ entre deux exécutions pour lire isolément la sortie d’une Release :

Terminal window
rm -rf dist && aggrega build --release release-replicated.yaml --auto-pull

Chaque Release rend cinq fichiers : la ressource personnalisée de la base de données, et les quatre qui mettent en place le plan de contrôle.

dist/stack/helm/db/innodbcluster.yaml
dist/stack/helm/mysql-operator/clusterrole.yaml
dist/stack/helm/mysql-operator/clusterrolebinding.yaml
dist/stack/helm/mysql-operator/deployment.yaml
dist/stack/helm/mysql-operator/serviceaccount.yaml

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier de l’espace de travail ne contient pas encore de dossier `mysql-innodb-cluster`, appelez une fois l’outil `scaffold` avec `example` défini sur `mysql-innodb-cluster` et sans `dir` : il écrit l’exemple dans un nouveau dossier `mysql-innodb-cluster`. Appelez ensuite l’outil `build` une fois pour chaque Release, dans cet ordre — `release-single.yaml` et `release-replicated.yaml` —, chaque fois avec `workspace_root` défini sur `mysql-innodb-cluster`, `release` défini sur ce fichier, `auto_pull` défini sur true et `write` défini sur true. Indiquez-moi quels fichiers chaque build a écrits ; ils se trouvent sous `mysql-innodb-cluster/dist/`.

Ce en quoi la base de données est rendue

# dist/stack/helm/db/innodbcluster.yaml — aggrega build --release release-single.yaml
apiVersion: mysql.oracle.com/v2
kind: InnoDBCluster
metadata:
[… omitted: the labels and annotations, described below]
name: db
spec:
instances: 1
router:
instances: 1
version: "8.4.0"
secretName: "mysql-root"
mycnf: |
[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_0900_ai_ci

Le fichier rendu porte aussi les labels et annotations qu’Aggrega place sur chaque artefact qu’il rend — de quel Aggregate il provient, quel composant, quelle Recipe, quelle frontière — omis ici pour garder la demande elle-même en vue.

Quatre de ces cinq entrées de spec remontent directement à quelque chose d’écrit : instances au server_instances de la Release, version à la valeur par défaut engine_version du Component, secretName au credentials_secret de la Release, et le bloc mycnf aux charset et collation du développeur. La cinquième, router.instances, est traitée plus bas.

La comparaison qui est l’essentiel

Toute la différence entre les deux arbres rendus :

--- dist/stack/helm/db/innodbcluster.yaml (single)
+++ dist/stack/helm/db/innodbcluster.yaml (replicated)
spec:
- instances: 1
+ instances: 3
router:
instances: 1

Une ligne, dans l’un des cinq fichiers. Les quatre fichiers du plan de contrôle sont identiques octet pour octet entre les deux Releases : le contrôleur qui réconcilie une demande à une instance et le contrôleur qui réconcilie une demande à trois instances sont le même contrôleur, si bien que rien en lui ne bouge.

Le nombre de routeurs ne bouge pas non plus, et ce n’est pas un réglage que ce composant offre librement. L’adresse que publie le composant est le Service sur lequel répondent les routeurs, si bien que le nombre est exposé à la valeur par défaut propre à la ressource personnalisée et jamais en dessous. C’est une borne sur ce qu’une Release peut demander plutôt qu’une taille que cet exemple fait varier, c’est pourquoi la ligne figure dans le diff ci-dessus sans changer.

Le plan de contrôle

dist/stack/helm/mysql-operator/deployment.yaml
[… omitted: the Deployment's metadata, selector and pod template up to the containers]
containers:
- name: controller
image: container-registry.oracle.com/mysql/community-operator:26.7.0-2.3.0
[… omitted: the controller's readiness probe]

Aucune Release ne nomme d’image. La référence provient de la valeur par défaut infra.image propre au Component, si bien qu’une Release qui ne définit rien rend tout de même un Deployment portant une version, au lieu d’un objet à compléter avant de pouvoir l’appliquer. Une cible qui tire depuis son propre miroir de registre définit infra.image dans la Release et obtient cette référence à la place.

Le plan de contrôle est déclaré dans l’Aggregate, à côté de la base de données, car une ressource personnalisée seule est inerte : elle ne devient un serveur en fonctionnement qu’une fois qu’un contrôleur la surveille. Les déclarer ensemble est ce qui permet de les appliquer comme une seule unité.

Le prérequis est affirmé, jamais découvert

Le compilateur s’exécute en amont et ne contacte jamais de cluster, il ne peut donc pas vérifier si le contrôleur est installé. Il le demande à la place. Laissez control_plane_present non défini et le build s’arrête :

[… omitted: the pull's lines, which carry the same halt]
[CATALOG_ERROR E0033]
Recipe/FeatureRecipe assertions
caused by: Recipe "mysql-innodb-cluster" instance "db" assertion "mysql_operator_prerequisite": assertion "Recipe/mysql-innodb-cluster/db/mysql_operator_prerequisite": template: Recipe/mysql-innodb-cluster/db/mysql_operator_prerequisite:1:48: executing "Recipe/mysql-innodb-cluster/db/mysql_operator_prerequisite" at <fail "the MySQL Operator control plane must be installed in the target cluster before this realization emits its InnoDBCluster custom resource; once the control plane is present, affirm the prerequisite by setting infra.control_plane_present to true in the Release">: error calling fail: assertion failed: the MySQL Operator control plane must be installed in the target cluster before this realization emits its InnoDBCluster custom resource; once the control plane is present, affirm the prerequisite by setting infra.control_plane_present to true in the Release

Rien n’est écrit. Une ressource personnalisée que personne ne réconcilie n’est pas un succès moindre qu’une ressource qui fonctionne — c’est un artefact qui s’applique proprement puis reste là, si bien que le build refuse de le produire et nomme la clé qui dirait le contraire.

Le compte root

Les deux Releases pointent ici le cluster vers un Secret qui existe déjà dans le cluster cible :

db:
infra:
credentials_secret: mysql-root

Rien n’est rendu pour ce Secret et aucun mot de passe n’atteint la sortie — la ressource personnalisée porte le nom et le contrôleur y lit le compte. Définir plutôt infra.credentials à generated rend le Secret à côté de la ressource personnalisée à partir d’une information d’identification rattachée au slot root_password du composant, ce qui place le mot de passe dans la sortie rendue et constitue le bon choix lorsque c’est la sortie qui provisionne le cluster.

Ce que cette réalisation ne crée pas, c’est une base de données logique ou un utilisateur applicatif. Le contrôleur établit le compte root du cluster et rien en dessous, si bien que les schémas et comptes dont une application a besoin sont créés par la personne qui détient root.

Quelle réalisation choisir

Choisissez core/datastore/mysql et sa Recipe synthétisée lorsque rien ne doit nécessiter d’installation préalable — elle n’a besoin d’aucun contrôleur dans le cluster ni d’aucun dépôt de charts à atteindre, elle se compile donc sans rien récupérer, et elle crée la base de données logique et le rôle de connexion que demande une application. Choisissez core/datastore/mysql-innodb-cluster lorsque la cible exécute déjà le plan de contrôle du MySQL Operator, ou l’installe comme le fait cet exemple, et que l’application a besoin d’un accès root à un cluster à une adresse interne au cluster.

La forme à serveur unique de la réalisation synthétisée est détaillée dans ../mysql-standalone/, et n’est pas répétée ici.

Où se trouve la jointure

Le document du développeur n’a pas été touché par le choix entre une instance et trois, pas plus que le mappage d’Ops. C’est la séparation que cet exemple existe pour rendre concrète :

  • le développeur dit ce dont l’application a besoin d’une base de données ;
  • Ops dit de quoi est faite une base de données — quelle Recipe la réalise ;
  • l’opérateur dit quelle est la taille de celle-ci.

Changez server_instances pour toute valeur qu’accepte la ressource personnalisée, et le aggregate.yaml de ce répertoire ne bouge pas.