Salta ai contenuti
AggregaAggrega
Seleziona lingua: Italiano
Questa pagina è stata tradotta automaticamente. Leggi l’originale in inglese.

Un Aggregate, due dimensioni di cluster MySQL

Un MySQL InnoDB Cluster e il control plane che lo riconcilia, compilati due volte a partire da un unico Aggregate invariato: una volta chiedendo una singola istanza del server, una volta chiedendone tre.

La lezione è dove risiede la dimensione. Quanti server stanno dietro il database non è qualcosa che lo sviluppatore ha scritto né qualcosa che la Recipe ha deciso — è una riga di dimensionamento dell’operatore nella Release, ed è tutto ciò che differisce tra i due alberi renderizzati.

Cosa scrive il compilatore, e cosa no

Questa realizzazione emette una risorsa personalizzata InnoDBCluster. Non emette server, Services o router: il MySQL Operator for Kubernetes li crea all’interno del cluster di destinazione dopo che la risorsa personalizzata è stata applicata, un lavoro che avviene molto dopo che il compilatore ha finito.

Quindi tutto ciò che segue descrive ciò che la risorsa personalizzata renderizzata chiede. Ciò che un cluster in esecuzione finisce per contenere è la risposta del controller a quella richiesta, in un momento che il compilatore non vede mai — e il compilatore non afferma nulla al riguardo, perché non ha modo di guardare.

L’unica cosa che varia

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

Entrambe le Releases selezionano lo stesso Component e la stessa Recipe, quindi c’è un solo Manifest, non uno per Release. Quando due Releases differiscono solo nel dimensionamento, la mappatura di Ops non ha nulla da dire sulla differenza, e una sua seconda copia sarebbe una seconda cosa da mantenere allineata senza alcun guadagno.

File

  • aggregate.yaml — intento dello sviluppatore, e lo stesso documento per entrambe le Releases: un componente mysql-operator per il control plane, un componente db di tipo core/datastore/mysql-innodb-cluster, e il set di caratteri che lo sviluppatore vuole che il server parli. Nulla qui dice quanti server ci sono.
  • manifest.yaml — la mappatura di Ops, condivisa da entrambe le Releases. Due righe: quale Recipe realizza il control plane, e quale realizza il database.
  • release-single.yaml, release-replicated.yaml — il dimensionamento dell’operatore. Differiscono nel loro metadata.name e in server_instances, e ogni altro campo è tenuto uguale di proposito, così che una riga sia l’intera differenza.
  • .aggrega-config.yaml — nomina il registry hub da cui si risolve il catalogo della libreria standard. Questo esempio non scrive alcuna entità propria.

Generare l’esempio

Puoi eseguire la build di questo esempio con i comandi qui sotto, oppure farla eseguire al tuo assistente IA.

Scrivi l’esempio in una nuova cartella che porta il suo nome:

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

Poi stampa i prossimi comandi da eseguire. Il primo ti porta nella nuova cartella:

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 scrive durante il build il lockfile che manca a un clone appena creato. Ogni build scrive in dist/, e un build aggiunge i suoi file anziché ripulire ciò che uno precedente ha lasciato. Rimuovi dist/ tra un’esecuzione e l’altra per leggere da solo l’output di una Release:

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

Ogni Release renderizza cinque file: la risorsa personalizzata del database e i quattro che mettono in piedi il control plane.

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

Con un assistente AI

Un assistente IA configurato con gli strumenti di Aggrega può fare lo stesso: incolla questo prompt nell’assistente.

Usa solo gli strumenti di Aggrega e non creare tu alcuna cartella. Se la cartella del workspace non contiene ancora una cartella `mysql-innodb-cluster`, chiama una volta lo strumento `scaffold` con `example` impostato su `mysql-innodb-cluster` e senza `dir`: scrive l’esempio in una nuova cartella `mysql-innodb-cluster`. Poi chiama lo strumento `build` una volta per ogni Release, in questo ordine — `release-single.yaml` e `release-replicated.yaml` — ogni volta con `workspace_root` impostato su `mysql-innodb-cluster`, `release` impostato su quel file, `auto_pull` impostato su true e `write` impostato su true. Dimmi quali file ha scritto ciascuna build; si trovano in `mysql-innodb-cluster/dist/`.

In cosa si renderizza il database

# 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

Il file renderizzato porta anche le etichette e le annotazioni che Aggrega mette su ogni artefatto che renderizza — da quale Aggregate proviene, quale componente, quale Recipe, quale confine — omesse qui per tenere in vista la richiesta stessa.

Quattro di quelle cinque voci di spec risalgono direttamente a qualcosa di scritto da qualcuno: instances al server_instances della Release, version al valore predefinito engine_version del Component, secretName al credentials_secret della Release, e il blocco mycnf a charset e collation dello sviluppatore. La quinta, router.instances, è discussa più avanti.

Il confronto che è il nocciolo

L’intera differenza tra i due alberi renderizzati:

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

Una riga, in uno dei cinque file. I quattro file del control plane sono identici byte per byte tra le due Releases: il controller che riconcilia una richiesta a un’istanza e il controller che riconcilia una richiesta a tre istanze sono lo stesso controller, quindi nulla di esso si sposta.

Nemmeno il numero di router si sposta, e non è una manopola che questo componente offre liberamente. L’indirizzo che il componente pubblica è il Service su cui rispondono i router, quindi il numero è esposto al valore predefinito della risorsa personalizzata stessa e mai al di sotto. Questo è un limite a ciò che una Release può chiedere anziché una dimensione che questo esempio fa variare, ed è per questo che la riga compare nel diff qui sopra senza cambiare.

Il control plane

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]

Nessuna Release nomina un’immagine. Il riferimento proviene dal valore predefinito infra.image del Component stesso, quindi una Release che non imposta nulla renderizza comunque un Deployment con una versione già indicata, anziché uno che debba essere completato prima di poter essere applicato. Una destinazione che scarica dal proprio mirror di registry imposta infra.image nella Release e ottiene invece quel riferimento.

Il control plane è dichiarato nell’Aggregate, accanto al database, perché una risorsa personalizzata da sola è inerte: diventa un server in esecuzione solo quando un controller la sta osservando. Dichiararli entrambi insieme è ciò che permette di applicarli come un’unica unità.

Il prerequisito viene affermato, mai scoperto

Il compilatore lavora in anticipo e non contatta mai un cluster, quindi non può verificare se il controller è installato. Invece lo chiede. Lascia control_plane_present non impostato e il build si ferma:

[… 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

Non viene scritto nulla. Una risorsa personalizzata che nessuno riconcilia non è un successo minore di una funzionante — è un artefatto che si applica senza errori e poi resta lì, quindi il build si rifiuta di produrlo e nomina la chiave che direbbe il contrario.

L’account root

Entrambe le Releases qui puntano il cluster a un Secret che esiste già nel cluster di destinazione:

db:
infra:
credentials_secret: mysql-root

Per quel Secret non viene renderizzato nulla e nessuna password raggiunge l’output — la risorsa personalizzata porta il nome e il controller ne legge l’account. Impostare invece infra.credentials su generated renderizza il Secret accanto alla risorsa personalizzata a partire da una credenziale associata allo slot root_password del componente, il che mette la password nell’output renderizzato ed è la scelta giusta quando è l’output a effettuare il provisioning del cluster.

Ciò che questa realizzazione non crea è un database logico o un utente applicativo. Il controller stabilisce l’account root del cluster e nulla al di sotto di esso, quindi gli schemi e gli account di cui un’applicazione ha bisogno vengono creati da chi detiene root.

Quale realizzazione scegliere

Scegli core/datastore/mysql e la sua Recipe sintetizzata quando nulla può aver bisogno di essere installato prima — non richiede alcun controller nel cluster né alcun repository di chart da raggiungere, quindi si compila senza scaricare nulla, e crea il database logico e il ruolo di login che un’applicazione richiede. Scegli core/datastore/mysql-innodb-cluster quando la destinazione esegue già il control plane del MySQL Operator, o lo installa come fa questo esempio, e ciò di cui l’applicazione ha bisogno è l’accesso root a un cluster a un indirizzo interno al cluster.

La forma a server singolo della realizzazione sintetizzata è trattata in ../mysql-standalone/, e non viene ripetuta qui.

Dov’è la giuntura

Il documento dello sviluppatore non è stato toccato dalla scelta tra un’istanza e tre, e neppure la mappatura di Ops. Questa è la separazione che questo esempio esiste per rendere concreta:

  • lo sviluppatore dice di cosa l’applicazione ha bisogno da un database;
  • Ops dice di cosa è fatto un database — quale Recipe lo realizza;
  • l’operatore dice quanto è grande questo.

Cambia server_instances con qualsiasi valore accettato dalla risorsa personalizzata e l’aggregate.yaml in questa directory non si sposta.