Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Brasil)
Esta página foi traduzida automaticamente. Leia o original em inglês.

Um datastore com backup em todo destino: uma única vinculação core/backup

Um banco de dados PostgreSQL com backup no Kubernetes por meio do Velero e do CloudNativePG, e na AWS por meio dos backups automatizados do próprio Amazon RDS, no Terraform e no CloudFormation, e por meio do AWS Backup, a partir de uma única vinculação core/backup que o operador escreve em cada Release, com a recusa em um destino que não tem nenhum produto de backup.

core/backup diz que um datastore tem backup feito segundo um agendamento e que cada backup é mantido por um número de dias. Não diz nada sobre como: o Manifest de cada destino vincula a FeatureRecipe que a realiza ali, e cada uma escreve o backup nos termos do seu próprio produto — um agendamento do Velero, um backup agendado do CloudNativePG, as configurações de uma instância do RDS, um plano do AWS Backup. Um destino sem produto para realizá-la recusa a vinculação pelo nome, então o build é interrompido em vez de implantar o datastore sem o backup escrito para ele.

Este espaço de trabalho compila um Aggregate por meio de seis Releases, cada uma vinculando o mesmo backup: todos os dias às 02:30, cada backup mantido por 14 dias. A página mostra o que cada destino renderiza para ele nas cinco que são concluídas, e cita o que imprime a sexta, que deve ser interrompida.

O que ele constrói

instânciaComponent do catálogoonde é executado
dbcore/datastore/postgrestoda Release
backupscore/storage/s3-object-storeas duas Releases do Kubernetes: o bucket para onde vão os backups
velerocore/storage/veleroa Release do Velero
barman-cloudcore/storage/barman-cloud-plugina Release do CloudNativePG

O Aggregate declara o banco de dados e o que um backup dele precisa no Kubernetes: um bucket e os dois controladores de backup. Um controlador de backup é instalado uma vez por cluster, e não junto com o banco de dados, então é um componente próprio; na AWS os backups ficam no armazenamento do próprio serviço gerenciado, e nenhum dos três é desejado ali. Um único parâmetro, backup_controller, os liga e desliga, por meio do interruptor active: de cada 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" }}'

Um componente cujo interruptor vale false é removido antes de qualquer coisa ser compilada, então as Releases da AWS e do Docker Compose, que deixam o parâmetro em none, compilam apenas o banco de dados.

A vinculação

O desenvolvedor não escreve nada para o backup: db não traz nenhuma vinculação no Aggregate. O operador vincula core/backup a ele em cada Release, sob as features do componente, e diz ali quando o backup é executado e por quanto tempo cada um é mantido. No Kubernetes, a vinculação também nomeia para onde vão os backups, por meio da sua conexão store com o 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

As Releases da AWS escrevem a mesma vinculação sem conexão store, porque o RDS e o AWS Backup mantêm os seus backups em armazenamento próprio, e as realizações ali recusam uma conexão com um bucket no qual nada escreveria. A Release do AWS Backup adiciona infra.role_arn, a função do IAM sob a qual o AWS Backup executa cada backup.

As seis Releases

ReleaseManifestcore/backup realizada poro build
release-helm-velero.yamlmanifest-helm-velero.yamlhelm/backup-veleroé concluído
release-helm-cloudnative-pg.yamlmanifest-helm-cloudnative-pg.yamlhelm/backup-cloudnative-pgé concluído
release-terraform.yamlmanifest-terraform.yamlterraform/backup-nativeé concluído
release-cloudformation.yamlmanifest-cloudformation.yamlcloudformation/backup-nativeé concluído
release-terraform-aws-backup.yamlmanifest-terraform-aws-backup.yamlterraform/backup-aws-backupé concluído
release-compose.yamlmanifest-compose.yamlnadaé interrompido

O Manifest decide qual produto faz o backup do banco de dados. Os dois Manifests do Kubernetes executam o banco de dados de duas formas — helm/postgres, um StatefulSet, para o Velero, e helm/postgres-cloudnative-pg, um Cluster do CloudNativePG, para o plugin — e vinculam a realização do backup para cada uma. manifest-terraform.yaml e manifest-terraform-aws-backup.yaml mapeiam o banco de dados para a mesma Recipe e diferem na FeatureRecipe que vinculam a core/backup, e as Releases compiladas a partir deles diferem, além do Manifest que cada uma nomeia, apenas na função.

As Releases do Kubernetes também vinculam o próprio par de chaves do bucket, e o arquivo de credenciais com o qual o Velero assina as suas requisições, como vinculações core/referenced-secret que nomeiam Secrets que o cluster já mantém, de modo que nenhuma chave é escrita em nenhum arquivo renderizado. Todo valor específico da conta nas Releases da AWS é um espaço reservado.

Gerar o exemplo

Você pode fazer o build deste exemplo com os comandos abaixo, ou pedir ao seu assistente de IA que faça o build por você.

Escreva o exemplo em uma nova pasta com o nome dele:

Terminal window
aggrega scaffold --example datastore-backup

Em seguida ele imprime os próximos comandos a executar. O primeiro entra na pasta nova:

Terminal window
cd datastore-backup

Build

O espaço de trabalho lê o catálogo da biblioteca padrão a partir do registro do hub que .aggrega-config.yaml nomeia. O Velero e o plugin Barman Cloud são instalados pelos charts dos próprios projetos, então as duas Releases do Kubernetes precisam que os repositórios de charts desses projetos estejam acessíveis a partir do build; qualquer outra Release é renderizada apenas a partir do catálogo.

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

Em um checkout do repositório da documentação, que contém o script auxiliar de build compartilhado que uma cópia escrita por aggrega scaffold --example não traz, ./check.sh compila as seis Releases e verifica cada resultado. Ele imprime uma linha por Release e sai com 0 somente quando cada uma terminou como esta página descreve:

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.

Com um assistente de IA

Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole este prompt nele.

Use somente as ferramentas do Aggrega e não crie nenhuma pasta por conta própria. Se a pasta do espaço de trabalho ainda não contém uma pasta `datastore-backup`, chame uma vez a ferramenta `scaffold` com `example` definido como `datastore-backup` e sem `dir`: ela grava o exemplo em uma nova pasta `datastore-backup`. Em seguida, chame a ferramenta `build` com `workspace_root` definido como `datastore-backup`, `release` definido como `release-helm-velero.yaml`, `auto_pull` definido como true e `write` definido como true. Diga-me quais arquivos o build gravou; eles ficam em `datastore-backup/dist/`.

Kubernetes, com Velero

release-helm-velero.yaml escreve o StatefulSet e os Services do banco de dados, os do bucket, os objetos que o próprio chart do Velero renderiza, e um arquivo para a vinculação, contendo um local de armazenamento do Velero e um agendamento:

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

Ambos ficam no namespace velero, o único do qual o Velero lê os seus agendamentos, e são nomeados a partir do namespace do banco de dados, do seu nome e do nome da vinculação, já que toda Release no cluster escreve nesse único namespace. O agendamento seleciona os pods do banco de dados pelos labels do StatefulSet que o banco de dados renderiza, no namespace em que ele é colocado, e o agente de nó do Velero copia os arquivos dos volumes deles para o bucket. O endereço do bucket é o que o componente backups publica, com o nome do seu Service qualificado pelo namespace em que ele é executado, porque o Velero é executado em outro, e a região também é a do bucket: o SeaweedFS, que o executa aqui, não lê nenhuma e publica us-east-1. Os 14 dias são o time to live do Velero, em horas.

Kubernetes, com CloudNativePG

release-helm-cloudnative-pg.yaml escreve o banco de dados como um Cluster do CloudNativePG, o bucket, os objetos que o chart do plugin renderiza, e o arquivo da vinculação, contendo o armazenamento de objetos do plugin e um backup agendado, ao lado do Cluster no seu próprio 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"

Um agendamento do CloudNativePG tem seis campos, o primeiro para os segundos, então o 30 2 * * * da vinculação é escrito com 0 antes. O plugin assina as suas requisições com o par de chaves no Secret que o armazenamento de objetos nomeia, aqui db-backup, com o nome do próprio armazenamento de objetos, já que a vinculação não define nenhum infra.credentials_secret.

A própria Recipe do banco de dados também lê a vinculação, e nomeia o plugin como arquivador do write-ahead log do 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]

Assim, o log é arquivado no bucket continuamente, entre os backups base diários, e uma restauração pode chegar a qualquer momento dos 14 dias: a recuperação point-in-time do CloudNativePG, que esta realização mantém ativada.

Terraform

release-terraform.yaml escreve o módulo do banco de dados e nada mais. A realização da vinculação, terraform/backup-native, não renderiza nenhum arquivo: o backup é uma configuração da instância do RDS, então a Recipe do banco de dados lê a vinculação e a escreve onde a instância é escrita:

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]

O RDS aceita um único horário de início diário em vez de uma expressão cron, então 30 2 * * * se torna uma janela de backup que se abre às 02:30 UTC e dura 30 minutos, a mais curta que o RDS aceita.

CloudFormation

release-cloudformation.yaml escreve um único template de stack contendo a instância, com as mesmas duas configurações sob os nomes das suas propriedades do 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 é compilada a partir de um Manifest que vincula terraform/backup-aws-backup em vez disso. Esta realização escreve um módulo próprio da vinculação ao lado do módulo do banco de dados, contendo um cofre de backup, um plano e uma seleção que nomeia a instância:

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

O agendamento é escrito na forma cron própria da AWS, lida em UTC, e um backup que não começou dentro de uma hora do seu horário não é iniciado. O ARN da instância é uma expressão do Terraform composta a partir daquilo para o qual o provedor da AWS está configurado quando planeja, e do nome da instância; a função é aquela que a Release nomeia, repassada como está escrita.

A instância mantém os seus próprios backups automatizados ao lado dos do AWS Backup, como faz sem nenhuma vinculação: por 7 dias, em uma janela que o RDS escolhe, já que o agendamento da vinculação é o do AWS Backup e não o da instância:

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 na vinculação os desativa e deixa os do AWS Backup como os únicos backups da instância.

O que o build não faz

O build escreve arquivos e para. Ele não executa nenhum backup e não alcança nenhum cluster, nenhum bucket e nenhuma API da AWS. Ele não resolve nenhum ARN, conta ou região: na AWS, cada um é uma expressão ou um valor que a Release escreveu, que o Terraform, o CloudFormation ou a AWS lê quando os arquivos são aplicados. Ele também não verifica nada no cluster:

  • O agendamento do Velero só é executado onde o Velero está implantado, e os backups do plugin só onde o plugin, o operador do CloudNativePG (1.26 ou posterior) e o cert-manager são executados. Este espaço de trabalho implanta o Velero e o plugin; supõe-se que o operador e o cert-manager já estejam lá.
  • Os Secrets que as Releases do Kubernetes nomeiam cabem ao cluster manter, no namespace a partir do qual cada um é lido: backup-store-access-key-id e backup-store-secret-access-key ao lado do bucket, velero-cloud-credentials em velero, contendo um arquivo de credenciais compartilhadas da AWS, e db-backup ao lado do banco de dados, contendo o par de chaves sob ACCESS_KEY_ID e ACCESS_SECRET_KEY. O build não renderiza nenhum deles.

A Release que é interrompida

release-compose.yaml vincula o mesmo backup ao banco de dados no Docker Compose. Nenhuma FeatureRecipe realiza core/backup ali, então manifest-compose.yaml não vincula nenhuma, e aggrega build --release release-compose.yaml --auto-pull é interrompido nomeando a vinculação em vez de implantar um banco de dados sem 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

O espaço de trabalho não nomeia nenhum diretório de catálogo, então o build só pode pesquisar entre as FeatureRecipes que seu lockfile fixa, e um Manifest que não vincula nenhuma para core/backup não fixa nenhuma; a mensagem diz isso em vez de afirmar que o hub não contém nenhuma. Com um checkout do catálogo da biblioteca padrão indicado como diretório de catálogo, a mesma interrupção diz que nenhuma FeatureRecipe no catálogo implementa core/backup:1.0.0 para compose, e lista as dez que o implementam para outros destinos: 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.

O catálogo da biblioteca padrão não contém nenhuma FeatureRecipe para core/backup neste destino. Cada uma delas se vincula a outro destino, então, fixada aqui, ela é renderizada como uma saída própria ao lado do arquivo do Compose, para um destino no qual esta Release não implanta. Os caminhos possíveis são remover a vinculação da Release, implantando ali o banco de dados sem backup, ou implantá-lo por meio de um Manifest para um destino que tenha um produto de backup, como fazem as outras cinco Releases.