能否用Liquibase/Flyway实现类似Terraform的数据库自动更新？

Great question! When you're in the early phases of a project where your database schema is still evolving rapidly—adding columns, dropping tables, tweaking constraints left and right—the imperative, script-based approach of tools like Liquibase or Flyway can feel like unnecessary overhead. Writing a new ALTER script every time you make a small change gets tedious fast.

The good news is there are several tools that let you manage your database in the same declarative, "define desired state" style as Terraform, where you specify what your schema should look like, and the tool handles comparing it to the current state, generating the necessary changes, and applying them automatically. Here are the top options to consider:

Top Declarative Database Tools #

1. Terraform (with Database Providers) #

You might not realize it, but Terraform has robust support for managing database schemas directly through its official and community providers. For most major databases (PostgreSQL, MySQL, SQL Server, even cloud-native options like AWS RDS), you can define tables, columns, indexes, and constraints as Terraform resources—just like you would define a server or storage bucket.

Example PostgreSQL table definition in HCL:

resource "postgresql_table" "users" {
  name   = "users"
  schema = "public"

  column {
    name          = "id"
    type          = "uuid"
    primary_key   = true
    default_value = "gen_random_uuid()"
  }

  column {
    name      = "email"
    type      = "varchar(255)"
    nullable  = false
    unique    = true
  }

  column {
    name      = "created_at"
    type      = "timestamp"
    nullable  = false
    default_value = "now()"
  }
}

When you modify this definition (say, add a profile_picture_url column), running terraform plan will show you exactly what changes will be made, and terraform apply will auto-execute the necessary ALTER TABLE commands behind the scenes.

2. Atlas #

Atlas is a purpose-built declarative database schema tool from Ariga, designed specifically for this use case. It supports most popular databases (PostgreSQL, MySQL, SQLite, SQL Server) and lets you define your desired schema using either HCL or raw SQL.

Example schema definition in HCL (schema.hcl):

schema "public" {
  table "users" {
    column "id" {
      type           = int
      primary_key    = true
      auto_increment = true
    }
    column "username" {
      type      = varchar(50)
      nullable  = false
      unique    = true
    }
    column "bio" {
      type     = text
      nullable = true
    }
  }
}

To apply changes, you run:

atlas schema apply --url "postgres://user:password@host:port/dbname" --to file://schema.hcl

Atlas will generate a diff between your defined schema and the live database, show you the proposed changes, and apply them once you confirm. It also supports features like schema linting, drift detection, and even migration script generation if you want to review changes first.

3. Pulumi #

Pulumi is another infrastructure-as-code tool that supports declarative database management, but with the twist of letting you use general-purpose programming languages (Python, TypeScript, Go, C#) instead of HCL. This can be a big plus if your team is more comfortable with code than configuration files.

Example MySQL table definition in Python:

import pulumi
import pulumi_mysql as mysql

# Create a database
app_db = mysql.Database("app-database")

# Define the users table
users_table = mysql.Table("users",
    database=app_db.name,
    columns=[
        mysql.TableColumnArgs(
            name="id",
            type="INT",
            primary_key=True,
            auto_increment=True
        ),
        mysql.TableColumnArgs(
            name="email",
            type="VARCHAR(255)",
            nullable=False,
            unique=True
        ),
        mysql.TableColumnArgs(
            name="last_login",
            type="DATETIME",
            nullable=True
        )
    ])

Like Terraform, Pulumi will track the state of your schema, and updates to your code will trigger automatic diffs and apply operations.

Key Considerations for Early-Stage Projects #

• State Management: Just like Terraform, these tools rely on state to track what's been applied. For team collaboration, use a remote state store (e.g., Terraform Cloud, Pulumi Cloud, or an S3 bucket with versioning) to avoid conflicts.
• Safety First: Even in early stages, always review the proposed changes before applying them. Tools like Atlas and Terraform let you preview changes with plan or diff commands—take advantage of this to avoid accidental data loss.
• Database Support: Make sure the tool you choose supports your target database. Most tools cover the big ones, but double-check if you're using something niche (like CockroachDB or MongoDB).

内容的提问来源于stack exchange，提问作者Phate