How to Connect Ent to PlanetScale in a Go Application | by Manato Kuroda | May, 2022

The MySQL serverless database platform

Picture by Joshua Woronieckion on Unsplash.

PlanetScale is a serverless database platform for MySQL. Ent is an ORM framework with a 100% statically typed API. This put up will stroll you thru tips on how to join Ent to PlanetScale in a Go utility.

Earlier than starting, go to the PlanetScale and join Free.


Right here is the ultimate codebase on GitHub.

Required dependencies are as follows:

The steps of the implementation are as follows:

  • Arrange ent
  • Arrange PlanetScale

After signing up, go to the dashboard and create a brand new database.


And fill in your database title.

After creating, click on a New department.

Create a department known as staging.

Now that the database and the department have been created, our schema and information may be imported.

With a purpose to import our schema to ScalePlanet, let’s arrange ent subsequent.

First, introduce the ent package deal to our utility and configure the database.

Allow us to set up it:

$ go get -d

And create a person schema.

$ ent init Consumer

Then, the generated listing ought to appear to be this:

├── generate.go
└── schema
└── person.go

Open up the ent/schema/person.go and add some fields as follows:

And run the generator:

$ go generate ./ent

Database Migration

Now that we’re able to migrate our schema to PlanetScale. However first, add the viper package deal for simple entry to a shared configuration.

$ go get

And create the config/config.go like so:

This can learn a YAML file and means that you can use its values completely throughout the applying. The MySQL configurations must be included on this file.

To entry PlanetScale’s database, we have to get their configuration. Go to Settings and Passwords and create a brand new password:

Create a password known as staging and duplicate the connection strings.

Return to our code and make a config/config.staging.yml like so:

create the cmd/migration/essential.go and write this:

And add datastore/datastore.go :

Run the migration by the command:

$ APP_ENV=staging go run ./cmd/migration/essential.go

After that, the schema within the staging department ought to appear to be this:



Seed information may be created with the Ent package deal.

First, allow the template characteristic for codegen.

Create a brand new file named, ent/entc.goand add this code:

After which, open up ent/generate.go file and alter the code to:

And add ent/template/mutation_input.tmpl :

To execute the SQL in Ent, create ent/template/exterior.tmpl :

Run codegen:

go generate ./ent

This generates a struct for enter and replace of every schema. On this case, CreateUserInput and UpdateUserInput are generated within the file.

Subsequent, create cmd/seed/person.go and write this:

This perform imports information into the person desk utilizing bulk inserts.

Create a cmd/seed/seed.go and name the Consumer perform right here:

And create cmd/seed/essential.go :

Run the script:

$ APP_ENV=staging go run ./cmd/seed/essential.go

Seed information has been created and the console shows the inserted information as follows:

Now that we’ve created the staging department and outlined our schema. The staging department is now prepared for manufacturing, migrate it to the principle department.

Go to the overview part and click on the Promote a department to manufacturing in the principle department.

And change to the staging department, and create a deploy request to the principle department.

If the change is okay, hit the Deploy modifications.

In the principle department, the schema has been created like so:

We’ve lined tips on how to deploy a database schema by way of Ent and PlanetScale. The manufacturing department must be modified by way of deploy requests in PlanetScale in order that this workflow permits us to make it protected to deploy schema and replace database tables with out locking or inflicting downtime.

More Posts