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

Um datastore com cópia de segurança em cada destino: um único anexo core/backup

Uma base de dados PostgreSQL com cópia de segurança no Kubernetes através do Velero e do CloudNativePG, e na AWS através das cópias de segurança automatizadas do próprio Amazon RDS, no Terraform e no CloudFormation, e através do AWS Backup, a partir de um único anexo core/backup que o operador escreve em cada Release, com a recusa num destino que não tem nenhum produto de cópia de segurança.

core/backup diz que é feita uma cópia de segurança de um datastore segundo um agendamento e que cada cópia de segurança é mantida durante um número de dias. Nada diz sobre o como: o Manifest de cada destino vincula a FeatureRecipe que a realiza aí, e cada uma escreve a cópia de segurança nos termos do seu próprio produto — um agendamento do Velero, uma cópia de segurança agendada do CloudNativePG, as definições de uma instância do RDS, um plano do AWS Backup. Um destino sem produto para a realizar recusa o anexo pelo nome, pelo que a compilação é interrompida em vez de implementar o datastore sem a cópia de segurança escrita para ele.

Este espaço de trabalho compila um Aggregate através de seis Releases, cada uma a anexar a mesma cópia de segurança: todos os dias às 02:30, cada cópia de segurança mantida durante 14 dias. A página mostra o que cada destino renderiza para ela nas cinco que são concluídas, e cita o que imprime a sexta, que se espera que seja interrompida.

O que constrói

instânciaComponent do catálogoonde é executado
dbcore/datastore/postgrescada Release
backupscore/storage/s3-object-storeas duas Releases do Kubernetes: o bucket para onde vão as cópias de segurança
velerocore/storage/veleroa Release do Velero
barman-cloudcore/storage/barman-cloud-plugina Release do CloudNativePG

O Aggregate declara a base de dados e aquilo de que uma cópia de segurança dela precisa no Kubernetes: um bucket e os dois controladores de cópia de segurança. Um controlador de cópia de segurança é instalado uma vez por cluster, e não com a base de dados, pelo que é um componente próprio; na AWS as cópias de segurança ficam no armazenamento do próprio serviço gerido, e nenhum dos três é pretendido aí. Um único parâmetro, backup_controller, liga-os e desliga-os, através 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, pelo que as Releases da AWS e do Docker Compose, que deixam o parâmetro em none, compilam apenas a base de dados.

O anexo

O programador não escreve nada para a cópia de segurança: db não traz nenhum anexo no Aggregate. O operador anexa-lhe core/backup em cada Release, sob as features do componente, e indica aí quando a cópia de segurança é executada e durante quanto tempo cada uma é mantida. No Kubernetes, o anexo nomeia também para onde vão as cópias de segurança, através da sua ligação store ao 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 o mesmo anexo sem ligação store, porque o RDS e o AWS Backup guardam as suas cópias de segurança num armazenamento próprio, e as realizações aí recusam uma ligação a um bucket no qual nada escreveria. A Release do AWS Backup acrescenta infra.role_arn, a função do IAM sob a qual o AWS Backup executa cada cópia de segurança.

As seis Releases

ReleaseManifestcore/backup realizada pora compilação
release-helm-velero.yamlmanifest-helm-velero.yamlhelm/backup-veleroé concluída
release-helm-cloudnative-pg.yamlmanifest-helm-cloudnative-pg.yamlhelm/backup-cloudnative-pgé concluída
release-terraform.yamlmanifest-terraform.yamlterraform/backup-nativeé concluída
release-cloudformation.yamlmanifest-cloudformation.yamlcloudformation/backup-nativeé concluída
release-terraform-aws-backup.yamlmanifest-terraform-aws-backup.yamlterraform/backup-aws-backupé concluída
release-compose.yamlmanifest-compose.yamlnadaé interrompida

O Manifest decide que produto faz a cópia de segurança da base de dados. Os dois Manifests do Kubernetes executam a base 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 da cópia de segurança para cada uma. manifest-terraform.yaml e manifest-terraform-aws-backup.yaml mapeiam a base 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 anexam também o próprio par de chaves do bucket, e o ficheiro de credenciais com que o Velero assina os seus pedidos, como anexos core/referenced-secret que nomeiam Secrets que o cluster já detém, pelo que nenhuma chave é escrita em nenhum ficheiro renderizado. Todos os valores específicos da conta nas Releases da AWS são marcadores de posição.

Gerar o exemplo

É possível compilar este exemplo com os comandos abaixo, ou pedir ao assistente de IA que o compile.

Escreva o exemplo numa nova pasta com o nome dele:

Terminal window
aggrega scaffold --example datastore-backup

Depois, imprime os próximos comandos a executar. O primeiro entra na nova pasta:

Terminal window
cd datastore-backup

Compilação

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

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

Num checkout do repositório da documentação, que contém o script auxiliar de compilação partilhado que uma cópia escrita por aggrega scaffold --example não traz, ./check.sh compila as seis Releases e verifica cada resultado. Imprime uma linha por Release e termina com 0 apenas 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-lhe este prompt.

Utilize apenas as ferramentas do Aggrega e não crie nenhuma pasta por si. Se a pasta da área de trabalho ainda não contiver uma pasta `datastore-backup`, chame uma vez a ferramenta `scaffold` com `example` definido como `datastore-backup` e sem `dir`: esta escreve o exemplo numa 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. Indique-me que ficheiros o build escreveu; encontram-se em `datastore-backup/dist/`.

Kubernetes, com Velero

release-helm-velero.yaml escreve o StatefulSet e os Services da base de dados, os do bucket, os objetos que o próprio chart do Velero renderiza, e um ficheiro para o anexo, que contém uma localização 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 a partir do qual o Velero lê os seus agendamentos, e têm o nome do namespace da base de dados, do seu nome e do nome do anexo, já que cada Release no cluster escreve nesse único namespace. O agendamento seleciona os pods da base de dados pelas labels do StatefulSet que a base de dados renderiza, no namespace em que é colocada, e o agente de nó do Velero copia os ficheiros 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 é executado, porque o Velero é executado noutro, 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 tempo de vida do Velero, em horas.

Kubernetes, com CloudNativePG

release-helm-cloudnative-pg.yaml escreve a base de dados como um Cluster do CloudNativePG, o bucket, os objetos que o chart do plugin renderiza, e o ficheiro do anexo, que contém o armazenamento de objetos do plugin e uma cópia de segurança agendada, 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, pelo que o 30 2 * * * do anexo é escrito com 0 antes. O plugin assina os seus pedidos 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 o anexo não define nenhum infra.credentials_secret.

A própria Recipe da base de dados lê também o anexo, 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 registo é arquivado no bucket de forma contínua, entre as cópias de segurança base diárias, e um restauro pode alcançar 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 da base de dados e nada mais. A realização do anexo, terraform/backup-native, não renderiza nenhum ficheiro: a cópia de segurança é uma definição da instância do RDS, pelo que a Recipe da base de dados lê o anexo e escreve-o 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 uma única hora de início diária em vez de uma expressão cron, pelo que 30 2 * * * se torna uma janela de cópia de segurança 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 que contém a instância, com as mesmas duas definiçõ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, em vez disso, terraform/backup-aws-backup. Esta realização escreve um módulo próprio do anexo ao lado do da base de dados, que contém um cofre de cópias de segurança, 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 uma cópia de segurança que não tenha começado no espaço de uma hora após a sua hora não é iniciada. O ARN da instância é uma expressão do Terraform composta a partir daquilo para que o fornecedor da AWS está configurado quando planeia, e do nome da instância; a função é a que a Release nomeia, passada tal como está escrita.

A instância mantém as suas próprias cópias de segurança automatizadas ao lado das do AWS Backup, como faz sem nenhum anexo: durante 7 dias, numa janela que o RDS escolhe, já que o agendamento do anexo é 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 no anexo desativa-as e deixa as do AWS Backup como as únicas cópias de segurança da instância.

O que a compilação não faz

A compilação escreve ficheiros e para. Não executa nenhuma cópia de segurança e não alcança nenhum cluster, nenhum bucket nem nenhuma API da AWS. 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 ficheiros são aplicados. Também não verifica nada no cluster:

  • O agendamento do Velero só é executado onde o Velero está implementado, e as cópias de segurança do plugin só onde são executados o plugin, o operador do CloudNativePG (1.26 ou posterior) e o cert-manager. Este espaço de trabalho implementa o Velero e o plugin; pressupõe-se que o operador e o cert-manager já lá estejam.
  • Os Secrets que as Releases do Kubernetes nomeiam cabem ao cluster, 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, que contém um ficheiro de credenciais partilhadas da AWS, e db-backup ao lado da base de dados, que contém o par de chaves sob ACCESS_KEY_ID e ACCESS_SECRET_KEY. A compilação não renderiza nenhum deles.

A Release que é interrompida

release-compose.yaml anexa a mesma cópia de segurança à base de dados no Docker Compose. Nenhuma FeatureRecipe realiza aí core/backup, pelo que manifest-compose.yaml não vincula nenhuma, e aggrega build --release release-compose.yaml --auto-pull é interrompido, nomeando o anexo, em vez de implementar uma base de dados sem cópia de segurança:

[… 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 indica nenhum diretório de catálogo, pelo que a compilação só pode pesquisar entre as FeatureRecipes que o seu lockfile fixa, e um Manifest que não vincula nenhuma para core/backup não fixa nenhuma; a mensagem di-lo em vez de afirmar que o hub não contém nenhuma. Com um checkout do catálogo da biblioteca standard indicado como diretório de catálogo, a mesma interrupção indica que nenhuma FeatureRecipe no catálogo implementa core/backup:1.0.0 para compose, e enumera 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 standard não contém nenhuma FeatureRecipe para core/backup neste destino. Cada uma delas vincula-se a outro destino, pelo que, fixada aqui, é renderizada como uma saída própria ao lado do ficheiro do Compose, para um destino no qual esta Release não implementa. Os caminhos possíveis são remover o anexo da Release, implementando aí a base de dados sem cópia de segurança, ou implementá-la através de um Manifest para um destino que tenha um produto de cópia de segurança, como fazem as outras cinco Releases.