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

Un datastore sottoposto a backup su ogni destinazione: un’unica associazione core/backup

Un database PostgreSQL sottoposto a backup su Kubernetes tramite Velero e tramite CloudNativePG, e su AWS tramite i backup automatici propri di Amazon RDS, su Terraform e su CloudFormation, e tramite AWS Backup, a partire da un’unica associazione core/backup che l’operatore scrive in ogni Release, con il rifiuto su una destinazione che non ha alcun prodotto di backup.

core/backup dice che un datastore viene sottoposto a backup secondo una pianificazione e che ogni backup viene conservato per un certo numero di giorni. Non dice nulla sul come: il Manifest di ciascuna destinazione vincola la FeatureRecipe che lo realizza lì, e ciascuna scrive il backup nei termini del proprio prodotto — una pianificazione Velero, un backup pianificato CloudNativePG, le impostazioni di un’istanza RDS, un piano AWS Backup. Una destinazione priva di un prodotto che lo realizzi rifiuta l’associazione per nome, quindi il build si arresta anziché distribuire il datastore senza il backup scritto per esso.

Questo workspace esegue il build di un Aggregate tramite sei Releases, ciascuna delle quali associa lo stesso backup: ogni giorno alle 02:30, ogni backup conservato per 14 giorni. La pagina mostra che cosa renderizza per esso ciascuna destinazione nelle cinque che vanno a buon fine, e cita ciò che stampa la sesta, che è destinata ad arrestarsi.

Che cosa costruisce

istanzaComponent del catalogodove viene eseguito
dbcore/datastore/postgresogni Release
backupscore/storage/s3-object-storele due Releases Kubernetes: il bucket in cui finiscono i backup
velerocore/storage/velerola Release Velero
barman-cloudcore/storage/barman-cloud-pluginla Release CloudNativePG

L’Aggregate dichiara il database e ciò di cui ha bisogno un suo backup su Kubernetes: un bucket e i due controller di backup. Un controller di backup viene installato una volta per cluster anziché insieme al database, quindi è un componente a sé; su AWS i backup restano nello storage proprio del servizio gestito, e lì nessuno dei tre serve. Un unico parametro, backup_controller, li attiva e disattiva, tramite l’interruttore active: di ciascun componente:

aggregate.yaml
spec:
parameters:
[… omitted: the comment above the parameter]
backup_controller:
type: string
default: none
[… omitted: the parameter's description]
components:
[… omitted: the comment above each component]
db:
type: core/datastore/postgres
backups:
type: core/storage/s3-object-store
active: '{{ ne .parameters.backup_controller "none" }}'
values:
bucket: db-backups
velero:
type: core/storage/velero
active: '{{ eq .parameters.backup_controller "velero" }}'
barman-cloud:
type: core/storage/barman-cloud-plugin
active: '{{ eq .parameters.backup_controller "cloudnative-pg" }}'

Un componente il cui interruttore vale false viene rimosso prima che si esegua il build di qualsiasi cosa, quindi le Releases AWS e Docker Compose, che lasciano il parametro a none, eseguono il build del solo database.

L’associazione

Lo sviluppatore non scrive nulla per il backup: db non porta alcuna associazione nell’Aggregate. L’operatore associa core/backup a esso in ogni Release, sotto le features del componente, e lì indica quando viene eseguito il backup e per quanto tempo viene conservato ciascuno. Su Kubernetes l’associazione nomina anche dove finiscono i backup, tramite la sua connessione store al bucket:

release-helm-velero.yaml
components:
db:
annotations:
aggrega.ai/namespace: orders
[… omitted: the comment above the attachment]
features:
backup:
type: core/backup
infra:
schedule: "30 2 * * *"
retention_days: 14
uses:
store:
bucket:
target: backups

Le Releases AWS scrivono la stessa associazione senza alcuna connessione store, perché RDS e AWS Backup conservano i loro backup in uno storage proprio, e le realizzazioni lì rifiutano una connessione a un bucket su cui nulla scriverebbe. La Release AWS Backup aggiunge infra.role_arn, il ruolo IAM con cui AWS Backup esegue ogni backup.

Le sei Releases

ReleaseManifestcore/backup realizzata dail build
release-helm-velero.yamlmanifest-helm-velero.yamlhelm/backup-velerova a buon fine
release-helm-cloudnative-pg.yamlmanifest-helm-cloudnative-pg.yamlhelm/backup-cloudnative-pgva a buon fine
release-terraform.yamlmanifest-terraform.yamlterraform/backup-nativeva a buon fine
release-cloudformation.yamlmanifest-cloudformation.yamlcloudformation/backup-nativeva a buon fine
release-terraform-aws-backup.yamlmanifest-terraform-aws-backup.yamlterraform/backup-aws-backupva a buon fine
release-compose.yamlmanifest-compose.yamlnullasi arresta

Il Manifest decide quale prodotto esegue il backup del database. I due Manifests Kubernetes eseguono il database in due modi — helm/postgres, uno StatefulSet, per Velero, e helm/postgres-cloudnative-pg, un Cluster CloudNativePG, per il plugin — e vincolano la realizzazione del backup per ciascuno. manifest-terraform.yaml e manifest-terraform-aws-backup.yaml mappano il database sulla stessa Recipe e differiscono nella FeatureRecipe che vincolano a core/backup, e le Releases ottenute da essi differiscono, oltre che per il Manifest che ciascuna nomina, soltanto per il ruolo.

Le Releases Kubernetes associano anche la coppia di chiavi del bucket stesso, e il file delle credenziali con cui Velero firma le sue richieste, come associazioni core/referenced-secret che nominano Secret già presenti nel cluster, così nessuna chiave viene scritta in alcun file renderizzato. Ogni valore specifico dell’account nelle Releases AWS è un segnaposto.

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 datastore-backup

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

Terminal window
cd datastore-backup

Build

Il workspace legge il catalogo della libreria standard dal registry dell’hub nominato da .aggrega-config.yaml. Velero e il plugin Barman Cloud vengono installati tramite i chart dei rispettivi progetti, quindi le due Releases Kubernetes richiedono che i repository dei chart di quei progetti siano raggiungibili dal build; ogni altra Release viene renderizzata dal solo catalogo.

Terminal window
aggrega build --release release-helm-velero.yaml --auto-pull # one Release

In un checkout del repository della documentazione, che contiene lo script di supporto al build condiviso che una copia scritta da aggrega scaffold --example non porta con sé, ./check.sh esegue il build di tutte e sei le Releases e controlla l’esito di ciascuna. Stampa una riga per Release ed esce con 0 solo quando ciascuna si è conclusa come descrive questa pagina:

RELEASE EXIT EXPECTED VERDICT
----------------------------------------------------------------------------------------------------
release-helm-velero.yaml 0 complete OK: completed, the backup the README shows
release-helm-cloudnative-pg.yaml 0 complete OK: completed, the backup the README shows
release-terraform.yaml 0 complete OK: completed, the backup the README shows
release-cloudformation.yaml 0 complete OK: completed, the backup the README shows
release-terraform-aws-backup.yaml 0 complete OK: completed, the backup the README shows
release-compose.yaml 1 halt OK: halted with the expected refusal
check: every build ended as expected.

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 dell’area di lavoro non contiene ancora una cartella `datastore-backup`, chiama una volta lo strumento `scaffold` con `example` impostato a `datastore-backup` e senza `dir`: scrive l’esempio in una nuova cartella `datastore-backup`. Poi chiama lo strumento `build` con `workspace_root` impostato a `datastore-backup`, `release` impostato a `release-helm-velero.yaml`, `auto_pull` impostato a true e `write` impostato a true. Dimmi quali file ha scritto la build; si trovano in `datastore-backup/dist/`.

Kubernetes, con Velero

release-helm-velero.yaml scrive lo StatefulSet e i Service del database, quelli del bucket, gli oggetti che renderizza il chart di Velero stesso e un file per l’associazione, che contiene una posizione di archiviazione Velero e una pianificazione:

dist/helm/db--backup--backup.yaml
apiVersion: velero.io/v1
kind: BackupStorageLocation
metadata:
[… omitted: the labels and annotations the build writes on every resource]
name: "orders-db-backup"
namespace: velero
spec:
provider: velero.io/aws
objectStorage:
bucket: "db-backups"
prefix: "orders-db-backup"
config:
region: "us-east-1"
s3Url: "http://backups-default.orders:8333"
s3ForcePathStyle: "true"
---
apiVersion: velero.io/v1
kind: Schedule
metadata:
[… omitted: the labels and annotations, as on the storage location]
name: "orders-db-backup"
namespace: velero
spec:
schedule: "30 2 * * *"
template:
includedNamespaces:
- "orders"
orLabelSelectors:
- matchLabels:
"app": "db"
storageLocation: "orders-db-backup"
ttl: "336h0m0s"
snapshotVolumes: false
defaultVolumesToFsBackup: true

Entrambe si trovano nel namespace velero, l’unico da cui Velero legge le sue pianificazioni, e prendono il nome dal namespace del database, dal suo nome e da quello dell’associazione, poiché ogni Release sul cluster scrive in quell’unico namespace. La pianificazione seleziona i pod del database in base alle label dello StatefulSet che il database renderizza, nel namespace in cui è collocato, e il node agent di Velero copia i file dei loro volumi nel bucket. L’indirizzo del bucket è quello che pubblica il componente backups, con il nome del suo Service qualificato dal namespace in cui gira, perché Velero gira in un altro, e anche la regione è quella del bucket: SeaweedFS, che qui lo esegue, non ne legge alcuna e pubblica us-east-1. I 14 giorni sono il time to live di Velero, espresso in ore.

Kubernetes, con CloudNativePG

release-helm-cloudnative-pg.yaml scrive il database come Cluster CloudNativePG, il bucket, gli oggetti che renderizza il chart del plugin e il file dell’associazione, che contiene l’object store del plugin e un backup pianificato, accanto al Cluster nel suo namespace:

dist/helm/db--backup--backup.yaml
apiVersion: barmancloud.cnpg.io/v1
kind: ObjectStore
metadata:
[… omitted: the labels and annotations the build writes on every resource]
name: "db-backup"
namespace: "orders"
spec:
configuration:
destinationPath: "s3://db-backups/orders/db-backup"
endpointURL: "http://backups-default.orders:8333"
s3Credentials:
accessKeyId:
name: "db-backup"
key: "ACCESS_KEY_ID"
secretAccessKey:
name: "db-backup"
key: "ACCESS_SECRET_KEY"
retentionPolicy: "14d"
instanceSidecarConfiguration:
env:
- name: "AWS_DEFAULT_REGION"
value: "us-east-1"
---
apiVersion: postgresql.cnpg.io/v1
kind: ScheduledBackup
metadata:
[… omitted: the labels and annotations, as on the object store]
name: "db-backup"
namespace: "orders"
spec:
schedule: "0 30 2 * * *"
cluster:
name: "db"
method: "plugin"
pluginConfiguration:
name: "barman-cloud.cloudnative-pg.io"

Una pianificazione CloudNativePG ha sei campi, il primo per i secondi, quindi il 30 2 * * * dell’associazione viene scritto preceduto da 0. Il plugin firma le sue richieste con la coppia di chiavi nel Secret che l’object store nomina, qui db-backup, dal nome dell’object store stesso, poiché l’associazione non imposta alcun infra.credentials_secret.

Anche la Recipe del database legge l’associazione, e nomina il plugin come archiviatore del write-ahead log del Cluster:

dist/helm/db/cluster.yaml
[… omitted: apiVersion, kind and metadata]
spec:
[… omitted: the instance count, the image, the storage and the resources]
plugins:
- name: "barman-cloud.cloudnative-pg.io"
isWALArchiver: true
parameters:
barmanObjectName: "db-backup"
[… omitted: the bootstrap settings]

Così il log viene archiviato nel bucket in modo continuo, tra i backup di base giornalieri, e un ripristino può raggiungere qualsiasi momento dei 14 giorni: il point-in-time recovery di CloudNativePG, che questa realizzazione mantiene attivo.

Terraform

release-terraform.yaml scrive il modulo del database e nient’altro. La realizzazione dell’associazione, terraform/backup-native, non renderizza alcun file: il backup è un’impostazione dell’istanza RDS, quindi la Recipe del database legge l’associazione e la scrive dove viene scritta l’istanza:

dist/terraform/modules/db/main.tf
[… omitted: the provenance comment, the provider requirement, and the instance's engine, compute, storage, database and HA arguments]
## ── Backup ───────────────────────────────────────────────
backup_retention_period = 14
backup_window = "02:30-03:00"
[… omitted: the subnet group and security groups, and the address output]

RDS accetta un unico orario di inizio giornaliero anziché un’espressione cron, quindi 30 2 * * * diventa una finestra di backup che si apre alle 02:30 UTC e dura 30 minuti, la più breve che RDS accetta.

CloudFormation

release-cloudformation.yaml scrive un unico template di stack che contiene l’istanza, con le stesse due impostazioni sotto i nomi delle loro proprietà CloudFormation:

dist/cloudformation/cloudformation-stack.json
[… omitted: the template's format version, the outputs carrying what the database publishes, and the opening of its resources]
"Db": {
[… omitted: the deletion policy and the provenance metadata]
"Properties": {
"AllocatedStorage": 10,
"BackupRetentionPeriod": 14,
"DBInstanceClass": "db.t3.small",
[… omitted: the database name, the subnet group, the engine and the credentials settings]
"MultiAZ": false,
"Port": 5432,
"PreferredBackupWindow": "02:30-03:00",
[… omitted: the storage type and the security groups]
},
"Type": "AWS::RDS::DBInstance"
}
[… omitted: the closing of the resources and of the template]

AWS Backup

release-terraform-aws-backup.yaml si basa invece su un Manifest che vincola terraform/backup-aws-backup. Questa realizzazione scrive un modulo proprio dell’associazione accanto a quello del database, che contiene un backup vault, un piano e una selezione che nomina l’istanza:

dist/terraform/modules/db--backup/backup.tf
[… omitted: the provenance comment, the provider requirement, and the partition, Region and account lookups]
resource "aws_backup_vault" "backup" {
name = "db-backup"
}
resource "aws_backup_plan" "backup" {
name = "db-backup"
rule {
rule_name = "db-backup"
target_vault_name = aws_backup_vault.backup.name
schedule = "cron(30 2 * * ? *)"
start_window = 60
lifecycle {
delete_after = 14
}
}
}
resource "aws_backup_selection" "backup" {
name = "db-backup"
plan_id = aws_backup_plan.backup.id
iam_role_arn = "arn:aws:iam::123456789012:role/example-backup"
resources = [
"arn:${data.aws_partition.current.partition}:rds:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:db:db",
]
}

La pianificazione è scritta nella forma cron propria di AWS, letta in UTC, e un backup che non è partito entro un’ora dal suo orario non viene avviato. L’ARN dell’istanza è un’espressione Terraform composta da ciò per cui il provider AWS è configurato quando pianifica e dal nome dell’istanza; il ruolo è quello che nomina la Release, passato così come è scritto.

L’istanza conserva i propri backup automatici accanto a quelli di AWS Backup, come fa senza alcuna associazione: per 7 giorni, in una finestra scelta da RDS, poiché la pianificazione dell’associazione è quella di AWS Backup e non quella dell’istanza:

dist/terraform/modules/db/main.tf
[… omitted: the provenance comment, the provider requirement, and the instance's engine, compute, storage, database and HA arguments]
## ── Backup ───────────────────────────────────────────────
backup_retention_period = 7
[… omitted: the subnet group and security groups, and the address output]

infra.keep_automated_backups: false sull’associazione li disattiva e lascia quelli di AWS Backup come unici backup dell’istanza.

Che cosa non fa il build

Il build scrive file e si ferma. Non esegue alcun backup e non raggiunge alcun cluster, alcun bucket né alcuna API AWS. Non risolve alcun ARN, account o regione: su AWS ciascuno è un’espressione o un valore scritto dalla Release, che Terraform, CloudFormation o AWS legge quando i file vengono applicati. Non controlla nemmeno nulla nel cluster:

  • La pianificazione di Velero viene eseguita solo dove Velero è distribuito, e i backup del plugin solo dove girano il plugin, l’operatore CloudNativePG (1.26 o successivo) e cert-manager. Questo workspace distribuisce Velero e il plugin; si presume che l’operatore e cert-manager siano già presenti.
  • I Secret che nominano le Releases Kubernetes sono a carico del cluster, nel namespace da cui ciascuno viene letto: backup-store-access-key-id e backup-store-secret-access-key accanto al bucket, velero-cloud-credentials in velero, che contiene un file di credenziali condivise AWS, e db-backup accanto al database, che contiene la coppia di chiavi sotto ACCESS_KEY_ID e ACCESS_SECRET_KEY. Il build non ne renderizza nessuno.

La Release che si arresta

release-compose.yaml associa lo stesso backup al database su Docker Compose. Lì nessuna FeatureRecipe realizza core/backup, quindi manifest-compose.yaml non ne vincola alcuna, e aggrega build --release release-compose.yaml --auto-pull si arresta nominando l’associazione anziché distribuire un database senza backup:

[… omitted: what resolving the lockfile prints, the same halt among it]
[OPS_ERROR E0099]
recipe resolution
caused by (1):
no recipe resolved for component/feature instance: add an explicit Manifest mapping for its type: feature "backup" (type "core/backup"); no feature recipe the lockfile pins implements core/backup:1.0.0 for capability "compose", the capability its component's Recipe binds to; with no catalog directory, the feature recipes searched are only those the lockfile pins, not a registry's; pin one a registry publishes in the Manifest, where one for another capability renders as its own output beside the component's, or write one for "compose", then map the type to it

Il workspace non nomina alcuna directory di catalogo, quindi la build può cercare solo tra le FeatureRecipes fissate dal suo lockfile, e un Manifest che non ne vincola nessuna per core/backup non ne fissa nessuna; il messaggio lo dice anziché affermare che l’hub non ne contiene nessuna. Con un checkout del catalogo della libreria standard indicato come directory di catalogo, lo stesso arresto dice che nessuna FeatureRecipe nel catalogo implementa core/backup:1.0.0 per compose, ed elenca le dieci che lo implementano per altre destinazioni: cloudformation/backup-aws-backup, cloudformation/backup-native, helm/backup-cloudnative-pg, helm/backup-k8up, helm/backup-kasten, helm/backup-kubestash, helm/backup-mariadb-operator, helm/backup-velero, terraform/backup-aws-backup e terraform/backup-native.

Il catalogo della libreria standard non contiene alcuna FeatureRecipe per core/backup su questa destinazione. Ciascuna di esse si vincola a un’altra destinazione, quindi, se la si fissa qui, viene renderizzata come un output a sé stante accanto al file Compose, per una destinazione su cui questa Release non distribuisce. Le strade possibili sono rimuovere l’associazione dalla Release, distribuendo lì il database senza backup, oppure distribuirlo tramite un Manifest per una destinazione che dispone di un prodotto di backup, come fanno le altre cinque Releases.