跳到主要内容

Continuous Integration for Ent Projects

· 阅读时间 7 分钟
Rotem Tamir

To ensure the quality of their software, teams often apply Continuous Integration workflows, commonly known as CI. With CI, teams continuously run a suite of automated verifications against every change to the code-base. During CI, teams may run many kinds of verifications:

  • Compilation or build of the most recent version to make sure it isn't broken.
  • Linting to enforce any accepted code-style standards.
  • Unit tests that verify individual components work as expected and that changes to the codebase do not cause regressions in other areas.
  • Security scans to make sure no known vulnerabilities are introduced to the codebase.
  • And much more!

From our discussions with the Ent community, we have learned that many teams using Ent already use CI and would like to enforce some Ent-specific verifications into their workflows.

To support the community with this effort, we added a new guide to the docs which documents common best practices to verify in CI and introduces ent/contrib/ci: a GitHub Action we maintain that codifies them.

In this post, I want to share some of our initial suggestions on how you might incorporate CI to you Ent project. Towards the end of this post I will share insights into projects we are working on and would like to get the community's feedback for.

Verify all generated files are checked in​

Ent heavily relies on code generation. In our experience, generated code should always be checked into source control. This is done for two reasons:

  • If generated code is checked into source control, it can be read along with the main application code. Having generated code present when the code is reviewed or when a repository is browsed is essential to get a complete picture of how things work.
  • Differences in development environments between team members can easily be spotted and remedied. This further reduces the chance of "it works on my machine" type issues since everyone is running the same code.

If you're using GitHub for source control, it's easy to verify that all generated files are checked in with the ent/contrib/ci GitHub Action. Otherwise, we supply a simple bash script that you can integrate in your existing CI flow.

Simply add a file named .github/workflows/ent-ci.yaml in your repository:

name: EntCI
on:
  push:
  # Run whenever code is changed in the master.
    branches:
      - master
  # Run on PRs where something changed under the `ent/` directory.
  pull_request:
    paths:
      - 'ent/*'
jobs:
  ent:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3.0.1
      - uses: actions/setup-go@v3
        with:
          go-version: 1.18
      - uses: ent/contrib/ci@master

Lint migration files​

Changes to your project's Ent schema almost always result in a modification of your database. If you are using Versioned Migrations to manage changes to your database schema, you can run migration linting as part of your continuous integration flow. This is done for multiple reasons:

  • Linting replays your migration directory on a database container to make sure all SQL statements are valid and in the correct order.
  • Migration directory integrity is enforced - ensuring that history wasn't accidentally changed and that migrations that are planned in parallel are unified to a clean linear history.
  • Destructive changes are detected, notifying you of any potential data loss that may be caused by your migrations way before they reach your production database.
  • Linting detects data-dependent changes that may fail upon deployment and require more careful review from your side.

If you're using GitHub, you can use the Official Atlas Action to run migration linting during CI.

Add .github/workflows/atlas-ci.yaml to your repo with the following contents:

name: Atlas CI
on:
  # Run whenever code is changed in the master branch,
  # change this to your root branch.
  push:
    branches:
      - master
  # Run on PRs where something changed under the `ent/migrate/migrations/` directory.
  pull_request:
    paths:
      - 'ent/migrate/migrations/*'
jobs:
  lint:
    services:
      # Spin up a mysql:8.0.29 container to be used as the dev-database for analysis.
      mysql:
        image: mysql:8.0.29
        env:
          MYSQL_ROOT_PASSWORD: pass
          MYSQL_DATABASE: test
        ports:
          - 3306:3306
        options: >-
          --health-cmd "mysqladmin ping -ppass"
          --health-interval 10s
          --health-start-period 10s
          --health-timeout 5s
          --health-retries 10
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3.0.1
        with:
          fetch-depth: 0 # Mandatory unless "latest" is set below.
      - uses: ariga/atlas-action@v0
        with:
          dir: ent/migrate/migrations
          dir-format: golang-migrate # Or: atlas, goose, dbmate
          dev-url: mysql://root:pass@localhost:3306/test

Notice that running atlas migrate lint requires a clean dev-database which is provided by the services block in the example code above.

What's next for Ent CI​

To add to this modest beginning, I want to share some features that we are experimenting with at Ariga with hope to get the community's feedback on them.

  • Linting for Online Migrations - many Ent projects use the automatic schema migration mechanism that is available in Ent (using ent.Schema.Create when applications start). Assuming a project's source code is managed in a version control system (such as Git), we compare the schema in the mainline branch (master/main/etc.) with the one in the current feature branch and use Atlas's schema diff capability to calculate the SQL statements that are going to be run against the database. We can then use Atlas's linting capability to provide insights about possible dangers the arise from the proposed change.
  • Change visualization - to assist reviewers in understanding the impact of changes proposed in a specific pull request we generate a visual diff (using an ERD similar to entviz) reflect the changes to a project's schema.
  • Schema Linting - using the official go/analysis package to create linters that analyze an Ent schema's Go code and enforce policies (such as naming or indexing conventions) on the schema definition level.

Wrapping up​

In this post, we presented the concept of CI and discussed ways in which it can be practiced for Ent projects. Next, we presented CI checks we are experimenting with internally. If you would like to see these checks become a part of Ent or have other ideas for providing CI tools for Ent, ping us on the Ent Discord Server.

For more Ent news and updates: