Przejdź do głównej zawartości
AggregaAggrega
Wybierz język: Polski
Ta strona została przetłumaczona maszynowo. Przeczytaj oryginał w języku angielskim.

Magazyn danych z kopią zapasową na każdym celu: jedno dołączenie core/backup

Baza danych PostgreSQL z kopią zapasową tworzoną na Kubernetes przez Velero i przez CloudNativePG, na AWS przez własne automatyczne kopie zapasowe Amazon RDS, w Terraform i w CloudFormation, oraz przez AWS Backup — wszystko z jednego dołączenia core/backup, które operator zapisuje w każdej encji Release, wraz z odmową na celu, który nie ma produktu do kopii zapasowych.

core/backup określa, że magazyn danych jest archiwizowany według harmonogramu i że każda kopia zapasowa jest przechowywana przez określoną liczbę dni. Nie mówi nic o tym, jak: encja Manifest każdego celu wiąże encję FeatureRecipe, która to tam realizuje, a każda z nich zapisuje kopię zapasową w kategoriach własnego produktu — harmonogram Velero, zaplanowana kopia zapasowa CloudNativePG, ustawienia instancji RDS, plan AWS Backup. Cel bez produktu, który mógłby to zrealizować, odrzuca dołączenie, wskazując je z nazwy, więc kompilacja zostaje zatrzymana, zamiast wdrażać magazyn danych bez zapisanej dla niego kopii zapasowej.

Ten obszar roboczy kompiluje jedną encję Aggregate przez sześć encji Releases, z których każda dołącza tę samą kopię zapasową: codziennie o 02:30, każda kopia przechowywana przez 14 dni. Strona pokazuje, co każdy cel renderuje na jej potrzeby w pięciu, które kończą się powodzeniem, i cytuje to, co wypisuje szósta, która zgodnie z oczekiwaniami zostaje zatrzymana.

Co powstaje

instancjaencja Component z katalogugdzie działa
dbcore/datastore/postgreskażda encja Release
backupscore/storage/s3-object-storedwie encje Releases dla Kubernetes: zasobnik, do którego trafiają kopie zapasowe
velerocore/storage/veleroencja Release dla Velero
barman-cloudcore/storage/barman-cloud-pluginencja Release dla CloudNativePG

Encja Aggregate deklaruje bazę danych oraz to, czego wymaga jej kopia zapasowa na Kubernetes: zasobnik i dwa kontrolery kopii zapasowych. Kontroler kopii zapasowych instaluje się raz na klaster, a nie razem z bazą danych, więc jest osobnym komponentem; na AWS kopie zapasowe pozostają we własnym magazynie usługi zarządzanej i żaden z tych trzech nie jest tam potrzebny. Jeden parametr, backup_controller, przełącza je za pomocą przełącznika active: każdego komponentu:

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" }}'

Komponent, którego przełącznik ma wartość false, jest usuwany przed skompilowaniem czegokolwiek, więc encje Releases dla AWS i Docker Compose, które pozostawiają parametr z wartością none, kompilują samą bazę danych.

Dołączenie

Programista nie pisze niczego na potrzeby kopii zapasowej: db nie ma w encji Aggregate żadnego dołączenia. Operator dołącza do niego core/backup w każdej encji Release, w sekcji features komponentu, i określa tam, kiedy kopia zapasowa jest wykonywana i jak długo przechowywana jest każda z nich. Na Kubernetes dołączenie wskazuje też, dokąd trafiają kopie zapasowe, za pomocą swojego połączenia store z zasobnikiem:

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

Encje Releases dla AWS zapisują to samo dołączenie bez połączenia store, ponieważ RDS i AWS Backup przechowują kopie zapasowe we własnym magazynie, a tamtejsze realizacje odrzucają połączenie z zasobnikiem, do którego nic by nie zapisywało. Encja Release dla AWS Backup dodaje infra.role_arn, rolę IAM, w ramach której AWS Backup wykonuje każdą kopię zapasową.

Sześć encji Releases

ReleaseManifestcore/backup realizowane przezbudowanie
release-helm-velero.yamlmanifest-helm-velero.yamlhelm/backup-velerokończy się powodzeniem
release-helm-cloudnative-pg.yamlmanifest-helm-cloudnative-pg.yamlhelm/backup-cloudnative-pgkończy się powodzeniem
release-terraform.yamlmanifest-terraform.yamlterraform/backup-nativekończy się powodzeniem
release-cloudformation.yamlmanifest-cloudformation.yamlcloudformation/backup-nativekończy się powodzeniem
release-terraform-aws-backup.yamlmanifest-terraform-aws-backup.yamlterraform/backup-aws-backupkończy się powodzeniem
release-compose.yamlmanifest-compose.yamlniczostaje zatrzymane

To encja Manifest decyduje, który produkt tworzy kopię zapasową bazy danych. Dwie encje Manifests dla Kubernetes uruchamiają bazę danych na dwa sposoby — helm/postgres, StatefulSet, dla Velero, oraz helm/postgres-cloudnative-pg, Cluster CloudNativePG, dla wtyczki — i wiążą realizację kopii zapasowej odpowiednią dla każdego z nich. manifest-terraform.yaml i manifest-terraform-aws-backup.yaml mapują bazę danych na tę samą encję Recipe i różnią się encją FeatureRecipe, którą wiążą z core/backup, a encje Releases kompilowane na ich podstawie różnią się, poza wskazaną przez każdą encją Manifest, wyłącznie rolą.

Encje Releases dla Kubernetes dołączają także własną parę kluczy zasobnika oraz plik poświadczeń, którym Velero podpisuje swoje żądania, jako dołączenia core/referenced-secret wskazujące obiekty Secret, które klaster już przechowuje, więc żaden klucz nie jest zapisywany w żadnym renderowanym pliku. Każda wartość specyficzna dla konta w encjach Releases dla AWS jest symbolem zastępczym.

Generowanie przykładu

Ten przykład można zbudować za pomocą poniższych poleceń albo zlecić jego zbudowanie asystentowi AI.

Należy zapisać przykład w nowym folderze nazwanym tak jak on:

Terminal window
aggrega scaffold --example datastore-backup

Następnie wypisuje polecenia do uruchomienia w dalszej kolejności. Pierwsze przechodzi do nowego folderu:

Terminal window
cd datastore-backup

Kompilacja

Obszar roboczy wczytuje katalog biblioteki standardowej z rejestru hub wskazanego w .aggrega-config.yaml. Velero i wtyczka Barman Cloud są instalowane za pomocą własnych chartów tych projektów, więc dwie encje Releases dla Kubernetes wymagają, aby repozytoria chartów tych projektów były osiągalne z kompilacji; każda inna encja Release renderuje się wyłącznie z katalogu.

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

W kopii roboczej repozytorium dokumentacji, która zawiera wspólny skrypt pomocniczy budowania, którego nie ma kopia zapisana przez aggrega scaffold --example, ./check.sh buduje wszystkie sześć encji Releases i sprawdza każdy wynik. Wypisuje jeden wiersz na encję Release i kończy działanie z kodem 0 tylko wtedy, gdy każda zakończyła się tak, jak opisuje ta strona:

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.

Z asystentem AI

Asystent AI skonfigurowany z narzędziami Aggrega może zrobić to samo: wystarczy wkleić mu ten prompt.

Używaj wyłącznie narzędzi Aggrega i nie twórz samodzielnie żadnego folderu. Jeśli folder obszaru roboczego nie zawiera jeszcze folderu `datastore-backup`, wywołaj raz narzędzie `scaffold` z `example` ustawionym na `datastore-backup` i bez `dir`: zapisuje ono przykład w nowym folderze `datastore-backup`. Następnie wywołaj narzędzie `build` z `workspace_root` ustawionym na `datastore-backup`, `release` ustawionym na `release-helm-velero.yaml`, `auto_pull` ustawionym na true i `write` ustawionym na true. Podaj mi, które pliki zapisała kompilacja; znajdują się w `datastore-backup/dist/`.

Kubernetes z Velero

release-helm-velero.yaml zapisuje StatefulSet i obiekty Service bazy danych, odpowiednie obiekty zasobnika, obiekty renderowane przez własny chart Velero oraz jeden plik dla dołączenia, zawierający lokalizację magazynu Velero i harmonogram:

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

Oba znajdują się w przestrzeni nazw velero, jedynej, z której Velero wczytuje swoje harmonogramy, i są nazwane według przestrzeni nazw bazy danych, jej nazwy oraz nazwy dołączenia, ponieważ każda encja Release w klastrze zapisuje do tej jednej przestrzeni nazw. Harmonogram wybiera pody bazy danych według etykiet StatefulSet renderowanego przez bazę danych, w przestrzeni nazw, w której jest umieszczona, a agent węzła Velero kopiuje pliki ich woluminów do zasobnika. Adres zasobnika to adres publikowany przez komponent backups, z nazwą obiektu Service kwalifikowaną przestrzenią nazw, w której działa, ponieważ Velero działa w innej; region również pochodzi od zasobnika: SeaweedFS, który go tu obsługuje, nie wczytuje żadnego i publikuje us-east-1. 14 dni to czas życia (TTL) w Velero, wyrażony w godzinach.

Kubernetes z CloudNativePG

release-helm-cloudnative-pg.yaml zapisuje bazę danych jako Cluster CloudNativePG, zasobnik, obiekty renderowane przez chart wtyczki oraz plik dołączenia, zawierający magazyn obiektów wtyczki i zaplanowaną kopię zapasową, obok obiektu Cluster w jego własnej przestrzeni nazw:

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"

Harmonogram CloudNativePG ma sześć pól, z których pierwsze oznacza sekundy, więc 30 2 * * * z dołączenia jest zapisywane z 0 na początku. Wtyczka podpisuje swoje żądania parą kluczy z obiektu Secret wskazanego przez magazyn obiektów, tu db-backup, nazwanego od samego magazynu obiektów, ponieważ dołączenie nie ustawia infra.credentials_secret.

Własna encja Recipe bazy danych również wczytuje dołączenie i wskazuje wtyczkę jako archiwizator dziennika zapisu z wyprzedzeniem (WAL) obiektu 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]

Dziennik jest więc archiwizowany do zasobnika w sposób ciągły, między codziennymi bazowymi kopiami zapasowymi, a przywracanie może sięgnąć dowolnego momentu z tych 14 dni: jest to odzyskiwanie do punktu w czasie CloudNativePG, które ta realizacja pozostawia włączone.

Terraform

release-terraform.yaml zapisuje moduł bazy danych i nic więcej. Realizacja dołączenia, terraform/backup-native, nie renderuje żadnego pliku: kopia zapasowa jest ustawieniem instancji RDS, więc encja Recipe bazy danych wczytuje dołączenie i zapisuje je tam, gdzie zapisywana jest instancja:

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 przyjmuje jedną dzienną godzinę rozpoczęcia zamiast wyrażenia cron, więc 30 2 * * * staje się oknem kopii zapasowej otwieranym o 02:30 UTC i trwającym 30 minut, najkrócej, ile przyjmuje RDS.

CloudFormation

release-cloudformation.yaml zapisuje jeden szablon stosu zawierający instancję, z tymi samymi dwoma ustawieniami pod ich nazwami właściwości 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 jest natomiast kompilowany z encji Manifest wiążącej terraform/backup-aws-backup. Ta realizacja zapisuje własny moduł dołączenia obok modułu bazy danych, zawierający magazyn kopii zapasowych (vault), plan i wybór wskazujący instancję:

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",
]
}

Harmonogram jest zapisywany we własnej formie cron AWS, interpretowanej w UTC, a kopia zapasowa, która nie rozpoczęła się w ciągu godziny od swojej pory, nie jest uruchamiana. ARN instancji to wyrażenie Terraform złożone z tego, na co skonfigurowany jest dostawca AWS w chwili planowania, oraz z nazwy instancji; rola jest tą, którą wskazuje encja Release, przekazywaną w niezmienionej postaci.

Instancja zachowuje własne automatyczne kopie zapasowe obok kopii AWS Backup, tak jak bez dołączenia: przez 7 dni, w oknie wybieranym przez RDS, ponieważ harmonogram dołączenia należy do AWS Backup, a nie do instancji:

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 w dołączeniu wyłącza je i pozostawia kopie AWS Backup jako jedyne kopie zapasowe instancji.

Czego kompilacja nie robi

Kompilacja zapisuje pliki i się zatrzymuje. Nie wykonuje żadnej kopii zapasowej i nie łączy się z żadnym klastrem, zasobnikiem ani API AWS. Nie rozwiązuje żadnego ARN, konta ani regionu: na AWS każde z nich jest wyrażeniem lub wartością zapisaną przez encję Release, którą Terraform, CloudFormation lub AWS odczytuje przy stosowaniu plików. Nie sprawdza też niczego w klastrze:

  • Harmonogram Velero działa tylko tam, gdzie wdrożono Velero, a kopie zapasowe wtyczki tylko tam, gdzie działają wtyczka, operator CloudNativePG (1.26 lub nowszy) i cert-manager. Ten obszar roboczy wdraża Velero i wtyczkę; zakłada się, że operator i cert-manager już tam są.
  • Obiekty Secret wskazywane przez encje Releases dla Kubernetes ma przechowywać klaster, w przestrzeni nazw, z której każdy jest odczytywany: backup-store-access-key-id i backup-store-secret-access-key obok zasobnika, velero-cloud-credentials w velero, zawierający współdzielony plik poświadczeń AWS, oraz db-backup obok bazy danych, zawierający parę kluczy pod ACCESS_KEY_ID i ACCESS_SECRET_KEY. Kompilacja nie renderuje żadnego z nich.

Encja Release, która się zatrzymuje

release-compose.yaml dołącza tę samą kopię zapasową do bazy danych na Docker Compose. Żadna encja FeatureRecipe nie realizuje tam core/backup, więc manifest-compose.yaml nie wiąże żadnej, a aggrega build --release release-compose.yaml --auto-pull zatrzymuje się, wskazując dołączenie, zamiast wdrażać bazę danych bez kopii zapasowej:

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

Obszar roboczy nie wskazuje żadnego folderu katalogu, więc kompilacja ma do przeszukania tylko encje FeatureRecipes przypięte w jej pliku lockfile, a encja Manifest, która nie wiąże żadnej dla core/backup, żadnej nie przypina; komunikat to zaznacza, zamiast twierdzić, że hub nie zawiera żadnej. Gdy jako folder katalogu wskazano kopię roboczą katalogu biblioteki standardowej, to samo zatrzymanie informuje, że żadna encja FeatureRecipe w katalogu nie implementuje core/backup:1.0.0 dla compose, i wymienia dziesięć, które implementują go dla innych celów: 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 i terraform/backup-native.

Katalog biblioteki standardowej nie zawiera encji FeatureRecipe dla core/backup na tym celu. Każda z nich wiąże się z innym celem, więc przypięta tutaj jest renderowana jako osobne wyjście obok pliku Compose, dla celu, na który ta encja Release nie wdraża. Dalsze możliwości to usunięcie dołączenia z encji Release i wdrożenie tam bazy danych bez kopii zapasowej albo wdrożenie jej przez encję Manifest dla celu, który ma produkt do kopii zapasowych, tak jak robi to pozostałych pięć encji Releases.