AMAZON RDS → POSTGRESQL FLEX

Amazon RDS und Aurora zu STACKIT PostgreSQL Flex

StackToIT macht aus Aurora und RDS PostgreSQL eine STACKIT-PostgreSQL-Flex-Instanz mit Benutzern und Datenbanken, setzt die Zugriffsliste aus den Workloads, die die Datenbank wirklich aufrufen, und überführt Aurora MySQL nach STACKIT MariaDB.

Aurora PostgreSQL: Benutzer und Datenbank übernommen

Aus dem veröffentlichten Lauf der AWS Retail Store Sample App. Links die AWS-Quelle genau so, wie AWS sie veröffentlicht, rechts die Ressourcenblöcke, die StackToIT geschrieben hat; die Prüfkommentare über jedem Block in der Datei sind hier ausgelassen.

AWS-Quelleterraform/lib/dependencies/orders_rds.tf
module "orders_rds" {
  source  = "terraform-aws-modules/rds-aurora/aws"
  version = "7.7.1"

  name           = "${var.environment_name}-orders"
  engine         = "aurora-postgresql"
  engine_version = "15.10"
  instance_class = "db.t3.medium"

  instances = {
    one = {}
  }

  vpc_id  = var.vpc_id
  subnets = var.subnet_ids

  allowed_security_groups = concat(var.allowed_security_group_ids, [var.orders_security_group_id])

  master_password        = random_string.orders_db_master.result
  create_random_password = false
  database_name          = "orders"
  storage_encrypted      = true
  apply_immediately      = true
  skip_final_snapshot    = true

  create_db_parameter_group = true
  db_parameter_group_name   = "${var.environment_name}-orders"
  db_parameter_group_family = "aurora-postgresql15"

  create_db_cluster_parameter_group = true
  db_cluster_parameter_group_name   = "${var.environment_name}-orders"
  db_cluster_parameter_group_family = "aurora-postgresql15"

  tags = var.tags
}
STACKIT-Terraform von StackToITterraform/data.tf
resource "stackit_postgresflex_user" "dependencies_orders_rds_this" {
  project_id  = var.project_id
  instance_id = stackit_postgresflex_instance.dependencies_orders_rds_this.instance_id
  username    = "root"
  roles       = var.orders_rds_admin_roles
}

output "dependencies_orders_rds_this_admin_password" {
  description = "The password STACKIT generated for the master user created by stackit_postgresflex_user for module.dependencies.module.orders_rds.aws_rds_cluster.this. Sensitive: tofu output hides it from the plan, the state holds it in plain text."
  value       = stackit_postgresflex_user.dependencies_orders_rds_this.password
  sensitive   = true
}

resource "stackit_postgresflex_database" "dependencies_orders_rds_this_orders" {
  project_id  = var.project_id
  instance_id = stackit_postgresflex_instance.dependencies_orders_rds_this.instance_id
  name        = "orders"
  owner       = stackit_postgresflex_user.dependencies_orders_rds_this.username
}
  • Aus dem Master-User wird ein Flex-User

    Der STACKIT-Benutzer startet mit der Rolle login, dem geringsten Recht, als Variable. Sie entscheiden, ob er createdb oder createrole braucht.

  • Passwort von STACKIT erzeugt

    Das Quellpasswort wird nicht kopiert. STACKIT erzeugt es, und eine sensible Ausgabe übergibt es vor dem Cutover an Ihre Clients.

  • Datenbank und Eigentümer

    Die Datenbank orders entsteht auf der Instanz, mit dem erzeugten Benutzer als Eigentümer.

  • Instanz dimensioniert und versioniert

    Die Instanz behält PostgreSQL 15 und erhält einen Flavor mit 2 vCPU und 4 GiB. Ihr vollständiger Block steht auf der Seite zu AWS Terraform.

Aurora MySQL zu STACKIT MariaDB

STACKIT bietet keinen MySQL-Dienst. StackToIT überführt Aurora MySQL nach MariaDB, der nächstliegenden Engine auf STACKIT, und hält fest, dass die Anwendung einen Kompatibilitätstest braucht.

AWS-Quelleterraform/lib/dependencies/catalog_rds.tf
module "catalog_rds" {
  source  = "terraform-aws-modules/rds-aurora/aws"
  version = "7.7.1"

  name                        = "${var.environment_name}-catalog"
  engine                      = "aurora-mysql"
  engine_version              = "8.0"
  instance_class              = "db.t3.medium"
  allow_major_version_upgrade = true

  instances = {
    one = {}
  }

  vpc_id  = var.vpc_id
  subnets = var.subnet_ids

  allowed_security_groups = concat(var.allowed_security_group_ids, [var.catalog_security_group_id])

  master_password        = random_string.catalog_db_master.result
  create_random_password = false
  database_name          = "catalog"
  storage_encrypted      = true
  apply_immediately      = true
  skip_final_snapshot    = true

  create_db_parameter_group = true
  db_parameter_group_name   = "${var.environment_name}-catalog"
  db_parameter_group_family = "aurora-mysql8.0"

  create_db_cluster_parameter_group = true
  db_cluster_parameter_group_name   = "${var.environment_name}-catalog"
  db_cluster_parameter_group_family = "aurora-mysql8.0"

  tags = var.tags
}
STACKIT-Terraform von StackToITterraform/data.tf
resource "stackit_mariadb_instance" "dependencies_catalog_rds_this" {
  project_id = var.project_id
  name       = "retail-store-ecs-catalog"
  version    = var.catalog_rds_version
  plan_name  = var.catalog_rds_plan_name
  parameters = {
    sgw_acl = join(",", coalescelist(var.catalog_rds_allowed_cidrs, stackit_ske_cluster.retail_app_ecs_cluster.egress_address_ranges))
  }
}

resource "stackit_mariadb_credential" "dependencies_catalog_rds_this" {
  project_id  = var.project_id
  instance_id = stackit_mariadb_instance.dependencies_catalog_rds_this.instance_id
}
  • Nächstliegende Engine, klar benannt

    Die Klasse ist Replatform, und der Code verlangt vor dem Umzug einen Kompatibilitätstest.

  • Zugriff aus den Workloads

    Standardmäßig stammt die Zugriffsliste aus den Egress-Bereichen des SKE-Clusters, der die ECS-Dienste ersetzt.

  • Backups durch STACKIT

    STACKIT MariaDB erstellt alle 4 Stunden ein Backup und hält es 14 Tage. Die 7-tägige Aufbewahrung der Quelle wird zur Prüfung festgehalten.

  • Zugangsdaten erzeugt

    Ein STACKIT-Credential ersetzt das zufällige Master-Passwort und wird als sensible Ausgabe bereitgestellt.

Was sich für die beiden Aurora-Cluster ändert

Einstellungen, die der Lauf für die PostgreSQL-Flex- und MariaDB-Ziele der veröffentlichten AWS Retail Store Sample App als nicht übernommen benennt.

Aurora-EinstellungBei STACKITWas Sie tun
Master-PasswortNicht kopiert; STACKIT erzeugt esDas neue Credential an die Anwendung geben
Master-BenutzernameEin Flex-User bei PostgreSQL; bei MariaDB nimmt das Credential keinen Benutzernamen entgegen, und STACKIT berechnet ihnClients erhalten neue Zugangsdaten
Subnet GroupKein Attribut; die Instanz hat den Endpunkt, den STACKIT vergibtClients auf den neuen Endpunkt zeigen lassen
Wartungsfenster, Upgrade-Richtlinie, Parameter GroupsKein Attribut im fixierten ProviderNach dem Umzug die Einstellungen prüfen, auf die sich Ihre Anwendung stützt
Cluster-MitgliederKeine eigenen Ressourcen; der Flavor (single oder replica) oder der Plan bestimmt die KnotenFlavor oder Plan wählen
Übersprungener Final SnapshotDie Instanz wird sofort gelöscht, wenn Terraform sie zerstörtDaten vorher exportieren, wenn sie den Cutover überstehen müssen

Der Lauf benennt 12 Eigenschaften des orders-Clusters und 16 des catalog-Clusters als nicht übernommen.

Entscheidungen vor dem Pilotprojekt

Beide Cluster stehen in Welle 4 der Abhängigkeitsfolge, nach ihrem Subnetz und ihrer Security Group.

  • Wie die Daten umziehen (Data Architect)

    Je Datenspeicher stehen Export und Import mit den Clients der Engine, Replikation mit der Replikation der Engine oder ein eigenes Werkzeug zur Wahl. Eine Methode wird nicht gewählt, und Recovery Point und tolerierte Ausfallzeit stammen aus Ihrer Anwendungsdatei, nicht aus einem Standardwert.

  • Die Größe ist ein Vorschlag (Platform Architect)

    Der Flavor der PostgreSQL-Instanz ist aus der Größe abgeleitet, die die Quelle nennt. Die Quelle nennt die Größe ihres eigenen Angebots, nicht die Last; Sie bestätigen sie oder setzen eine andere.

  • Öffentlicher Endpunkt (Security Architect)

    Ein Endpunkt, der in der Quelle privat ist, wird bei STACKIT öffentlich und durch die Zugriffsliste geschützt. Zur Wahl stehen: akzeptieren, nur den Network-Area-Bereich nutzen oder den Endpunkt neu entwerfen.

Bewiesen an einer echten AWS-Umgebung

Die AWS Retail Store Sample App, ein öffentliches Terraform-Projekt von AWS, von StackToIT bewertet und vollständig veröffentlicht, genau so, wie der Lauf es geschrieben hat.

Fallstudie ansehen (Englisch)
282
Terraform-Ressourcendefinitionen analysiert
44
Migrationseinheiten identifiziert
38
Zieleinheiten erzeugt, von 52 betrachteten
331
Planschritte erstellt

Fragen, die Datenbankteams stellen

Überträgt StackToIT die Daten?

Nein. StackToIT ändert in keiner Cloud etwas. Es schreibt das Ziel und einen Ausführungsplan mit den Schritten für den Datenumzug, und Ihr Team führt sie aus.

Ist die Datenbank aus dem Internet erreichbar?

Ein PostgreSQL-Flex-Endpunkt wird über eine Zugriffsliste erreicht. StackToIT füllt sie mit den Egress-Adressen des Clusters, auf dem die Clients laufen, und hält das als Entscheidung zur Bestätigung fest.

Welche PostgreSQL-Version läuft im Ziel?

Im veröffentlichten Lauf wurde aus Aurora PostgreSQL 15 eine PostgreSQL-Flex-Instanz in Version 15.

Quellen

Ihr nächster Schritt: STACKIT.

Erzählen Sie uns von Ihrer Umgebung. Wir zeigen Ihnen, was StackToIT dafür liefert: Zielarchitektur, Terraform-Artefakte und einen strukturierten Migrationsplan.