AMAZON RDS → POSTGRESQL FLEX

Amazon RDS en Aurora naar STACKIT PostgreSQL Flex

StackToIT zet Aurora en RDS PostgreSQL om naar STACKIT PostgreSQL Flex met de bijbehorende gebruikers en databases, stelt de toegangslijst samen uit de workloads die de database echt aanroepen en brengt Aurora MySQL over naar STACKIT MariaDB.

Aurora PostgreSQL: gebruiker en database overgenomen

Uit de gepubliceerde run van de AWS Retail Store. Links: de AWS-bron precies zoals AWS die publiceert. Rechts: de resourceblokken die StackToIT schreef; de reviewopmerkingen boven elk blok in het bestand zijn hier weggelaten.

AWS-bronterraform/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 van 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
}
  • Mastergebruiker wordt Flex-gebruiker

    De STACKIT-gebruiker begint met de rol login, het minimaal vereiste privilege, als variabele. U beslist of createdb of createrole nodig is.

  • Wachtwoord door STACKIT gegenereerd

    Het wachtwoord van de bron wordt niet gekopieerd. STACKIT genereert het en een gevoelige output geeft het vóór de cutover door aan uw clients.

  • Database en eigenaar

    De database orders wordt aangemaakt op de instance, met de gegenereerde gebruiker als eigenaar.

  • Omvang en versie van de instance

    De instance behoudt PostgreSQL 15 en krijgt een flavor van 2 vCPU en 4 GiB. Het volledige blok staat op de pagina AWS-Terraform.

Aurora MySQL naar STACKIT MariaDB

STACKIT heeft geen MySQL-dienst. StackToIT brengt Aurora MySQL over naar MariaDB, de dichtstbijzijnde engine op STACKIT, en meldt dat de applicatie een compatibiliteitstest nodig heeft.

AWS-bronterraform/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 van 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
}
  • Dichtstbijzijnde engine, helder benoemd

    De klasse is Replatform en de code vraagt vóór de migratie om een compatibiliteitstest.

  • Toegang vanuit de workloads

    Standaard komt de toegangslijst uit de egressbereiken van het SKE-cluster dat de ECS-services vervangt.

  • Back-ups door STACKIT

    STACKIT MariaDB maakt elke 4 uur een back-up en bewaart die 14 dagen. De bewaartermijn van 7 dagen in de bron wordt vastgelegd ter beoordeling.

  • Credential gegenereerd

    Een STACKIT-credential vervangt het willekeurige masterwachtwoord en wordt als gevoelige output beschikbaar gesteld.

Wat verandert voor de twee Aurora-clusters

Instellingen die de run als niet overgenomen benoemt voor de doelen PostgreSQL Flex en MariaDB in de gepubliceerde run van de AWS Retail Store.

Aurora-instellingOp STACKITWat u doet
MasterwachtwoordNiet gekopieerd; STACKIT genereert hetGeef de nieuwe credential aan de applicatie
Naam van de mastergebruikerEen Flex-gebruiker op PostgreSQL; op MariaDB kent de credential geen gebruikersnaam en berekent STACKIT dieClients krijgen nieuwe inloggegevens
Subnet groupGeen attribuut; de instance heeft het endpoint dat STACKIT toewijstLaat de clients naar het nieuwe endpoint wijzen
Onderhoudsvenster, upgradebeleid, parametergroepenGeen attribuut in de vastgezette providerControleer na de migratie de instellingen waar uw applicatie van afhangt
ClusterledenGeen afzonderlijke resources; de flavor (single of replica) of het plan bepaalt de nodesKies de flavor of het plan
Overgeslagen laatste snapshotDe instance wordt direct verwijderd wanneer Terraform de instance verwijdertExporteer eerst de data als die de cutover moet overleven

De run noemt 12 eigenschappen van het cluster orders en 16 van het cluster catalog als niet overgenomen.

Beslissingen vóór de pilot

Beide clusters staan in golf 4 van de afhankelijkheidsvolgorde, na hun subnet en security group.

  • Hoe de data verhuist (Data Architect)

    De opties per store zijn export en import met de clients van de engine, replicatie met de eigen replicatie van de engine, of een eigen tool. Er wordt geen methode gekozen, en herstelpunt en toegestane downtime komen uit uw applicatiebestand, niet uit een standaardwaarde.

  • Omvang is een voorstel (Platform Architect)

    De flavor van de PostgreSQL-instance wordt afgeleid van de omvang die de bron noemt. De bron noemt de omvang van zijn eigen aanbod, niet de belasting, dus u bevestigt die of stelt een andere in.

  • Openbaar endpoint (Security Architect)

    Een endpoint dat in de bron privé is, wordt op STACKIT openbaar, beschermd door de toegangslijst. De opties zijn dat te accepteren, alleen de scope van de Network Area te gebruiken of het endpoint opnieuw te ontwerpen.

Bewezen op een echte AWS-omgeving

De AWS Retail Store Sample App, een openbaar Terraform-project van AWS, door StackToIT beoordeeld en volledig gepubliceerd, precies zoals de run het heeft opgeleverd.

Casestudy bekijken (Engels)
282
Terraform-resourcedeclaraties geanalyseerd
44
migratie-eenheden geïdentificeerd
38
doeleenheden gegenereerd, van de 52 onderzochte eenheden
331
planstappen uitgeschreven

Vragen van databaseteams

Verplaatst StackToIT de data?

Nee. StackToIT wijzigt niets in een cloud. StackToIT schrijft het doel en een uitvoeringsplan met de stappen voor de dataverplaatsing, en uw team voert die uit.

Is de database bereikbaar vanaf internet?

Een PostgreSQL Flex-endpoint is bereikbaar via een toegangslijst. StackToIT vult die met de egressadressen van het cluster waarop de clients draaien en legt dat vast als beslissing die u bevestigt.

Welke PostgreSQL-versie draait het doel?

In de gepubliceerde run werd Aurora PostgreSQL 15 een PostgreSQL Flex-instance op versie 15.

Bronnen

Uw volgende stap: STACKIT.

Vertel ons over uw omgeving, dan laten wij zien wat StackToIT daarvoor oplevert: doelarchitectuur, Terraform-artefacten en een gestructureerd migratieplan.

Laat uw gegevens achter, onze specialisten nemen contact met u op.

Liever zelf een e-mail sturen? connect@stacktoit.com

Wij gebruiken uw gegevens alleen om dit verzoek te beantwoorden en een mogelijke pilot te bespreken. Privacyverklaring