Develop fearlessly against your anonymised production PostgreSQL database

Unlimited clones of your production PostgreSQL database

Run a single command to connect to a fresh copy of your entire production database.
Test database migrations, run queries and develop against a realistic dataset.

Fully anonymised

Ringer automatically anonymises all data, so you don't have to worry about exposing sensitive information.
Set custom anonymisation rules for specific columns.
For complex use cases, make use of dynamic generators to generate arbitrary fake data.

In under a second

Ringer uses a copy-on-write file system, so cloning is fast and cheap.
Create as many clones as you want without worrying about disk space.

# Fetch, anonymise and upload your database $ ringer admin fetch --to /tmp/my-db Exporting database from Google Cloud SQL... Database extracted to /tmp/my-db $ ringer admin anonymise /tmp/my-db Anonymising my-db... $ ringer base upload my-db /tmp/my-db Uploading my-db... # Instantly create unlimited clones of it. All data is anonymised by default. $ ringer clone create my-db --run psql -c "select * from users limit 2" | id | first_name | last_name | email | |----|------------|-----------|----------------------| | 1 | Erica | Jones | [email protected] | | 2 | Germaine | Fawcett | [email protected] | $ CLONE=$(ringer clone create my-db) # Add, update, delete data with great abandon $ ringer clone connect $CLONE --run psql -c "insert into users (first_name, last_name, email) values ('a', 'b', [email protected]')" $ ringer clone connect $CLONE --run psql -c "select * from users where first_name = 'a'" | id | first_name | last_name | email | |-----|------------|-----------|----------------------| | 99 | a | b | [email protected] | # Each clone is a completely separate, fresh database $ ringer clone create my-db --run psql -c "select * from users where first_name = 'a'" | id | first_name | last_name | email | |-----|------------|-----------|----------------------|

Ringer helps you develop faster, with more confidence

Database migrations

$ ringer clone create my-db --run rails db:migrate == 20230125064806 AddEmailToUsers: migrating =========== -- add_column(:users, :email, :string) -> 0.0022s == 20230125064806 AddEmailToUsers: migrated (0.0024s) ==

Database migrations are a common source of pain. A bad migration can lock your database and take down your application, sometimes for hours. These issues often don't surface when testing aginst a small development or test database. Use ringer to test your migration against a production-sized database, and catch issues early.

Development

$ ringer clone create my-db --run rails server * Listening on http://127.0.0.1:3000 * Listening on http://[::1]:3000 Use Ctrl-C to stop

Run your app against realistic data, instantly. No need to manually create content or keep a seed file up to date. See how your app behaves for real users by running against realistic data sizes. Give every delevoper on your team an unlimited number of realistic test environments.

Performance testing

$ ringer clone create my-db --run ./scripts/perf-test ...

Performance problems often aren't spotted before they arise in production, because the size of data is so different between environments. By running performance tests against Ringer, you can be confident that your change won't cause issues when it hits production.

How it works

First, the Ringer CLI fetches a backup of your production database and anonymises it to protect your sensitive data. Next, it securely pushes the anonymised database to the Ringer server.

The Ringer server takes a snapshot of the anonymised database, which serves as a base for all future clones.

Using our user-friendly dashboard, CLI, or API, you can easily create clones on-demand whenever you need them. Ringer starts a dedicated PostgreSQL instance for you and provides the TLS credentials required to connect to it securely.

When you're done with the clone, simply delete it. You can also configure an expiry policy to automatically delete clones to save resources and ensure your data stays secure.

Zero infrastructure

Ringer is fully managed, so you don't need to maintain any new infrastructure. If you do want to host Ringer yourself, we can support that too - just contact us.

Private

Your data is anonymised before it leaves your network - sensitive data never reaches us. Everything is anonymised by default, allowing you to choose which columns to preserve. This ensures that future database changes don't cause data leaks.

Secure

Clones are only accessible over TLS, and each clone is issued with its own certificate. Only your team members can access them. Clones are also isolated from each other, so data cannot leak between them. Ringer has built-in support for common single-sign-on providers such as Google and GitHub. The Ringer API is only available over HTTPS.

Powerful

Ringer's anonymisation supports defining custom generators (based on polygen). This allows you to generate arbitrary data for any PostgreSQL type. Moreover, Ringer exposes an API, so you can build your own tools on top of it, making it a powerful tool for your database needs.

Any PostgreSQL database

Ringer works with any PostgreSQL database, whether it is self-hosted or cloud-based, including AWS, GCP, Azure, DigitalOcean, and Heroku. Regardless of your database environment, Ringer is here to help.

Many authentication providers

Ringer supports several popular authentication systems, such as Google and GitHub, and we are continually adding support for more. If you need support for a particular authentication provider, don't hesitate to contact us.

Our philosophy

Ringer is built on a consistent software philosophy: that tools should be simple, composable and well-behaved. You can expect Ringer to behave predictably and integrate well with your environment.

It is a static binary
Offers a consistent CLI interface
Configurable via a single, standard format configuration file
Automatically discovers configuration settings
Uses structured logging for easy analysis
Exposes metrics for monitoring and observability
Uses very little memory for efficiency
Handles signals gracefully
Offers simple upgrades