Borealis Isolated Postgres

This add-on is operated by Boreal Information Systems Inc.

A PostgreSQL database add-on that takes security seriously.

Borealis Isolated Postgres

Last updated November 26, 2022

The Borealis Isolated Postgres add-on provides PostgreSQL-compatible database clusters as a service on Amazon RDS. PostgreSQL is a powerful open-source relational database that is well suited to a variety of transactional workloads. Amazon RDS provides a highly optimized and reliable platform for managed database clusters.

Borealis Isolated Postgres isolates each database cluster within its own virtual private cloud to block all direct connection attempts from the open internet. Instead, a client connects to an add-on database via a secure tunnel with strong authentication and encryption. Such secure tunnels are maintained automatically and transparently for a Heroku app by a provided buildpack.

All PostgreSQL-compatible client libraries work with Borealis Isolated Postgres for the languages supported by Heroku (Ruby, Python, Java, Node.js, Go, PHP, Clojure, and Scala).

Getting Started

Installing the Add-on

You can attach the Borealis Isolated Postgres add-on to an app using the CLI:

See a list of all available plans here.

$ heroku addons:create borealis-pg
Creating borealis-pg on ⬢ example-app... free
borealis-pg-example-addon is being created in the background. The app will restart when complete...

Several versions of PostgreSQL are supported (11, 12, 13 and 14). The default version is PostgreSQL 14. To request a specific major version of PostgreSQL, specify it with the --version option in the CLI:

$ heroku addons:create borealis-pg --version 13
Creating borealis-pg on ⬢ example-app... free
borealis-pg-example-addon is being created in the background. The app will restart when complete...

Provisioning of a Borealis Isolated Postgres add-on is asynchronous and can take several minutes. To wait for an add-on to finish provisioning via the CLI:

$ heroku addons:wait
Creating borealis-pg-example-addon...

After you provision Borealis Isolated Postgres, three config vars are available in your app’s settings: DATABASE_URL, DATABASE_READONLY_URL and DATABASE_SSH_TUNNEL_BPG_CONNECTION_INFO. However, if your app already has a Heroku Postgres add-on and you then provision a Borealis Isolated Postgres add-on, Borealis Isolated Postgres’s config vars fall back to the format BOREALIS_PG_<COLOR>_URL, BOREALIS_PG_<COLOR>_READONLY_URL and BOREALIS_PG_<COLOR>_SSH_TUNNEL_BPG_CONNECTION_INFO, respectively, to prevent a config vars naming collision. The following documentation assumes the add-on config vars are called DATABASE_URL, DATABASE_READONLY_URL and DATABASE_SSH_TUNNEL_BPG_CONNECTION_INFO in your app.

Use the DATABASE_URL config var in your application code to connect with read and write access to the primary node in the add-on database cluster. Use the DATABASE_READONLY_URL config var in your application code to connect with read-only access to a node in the add-on database cluster.

In a database cluster with multiple nodes, the DATABASE_READONLY_URL config var always connects to one of the read replica nodes rather than the primary node. Because there may be a small replication delay (typically less than a second) from the primary node to replica nodes, DATABASE_READONLY_URL should be treated as eventually consistent. Queries that require strong consistency or write access should always use DATABASE_URL.

You can confirm the DATABASE_URL config var contains the canonical URL for read and write connections to the database cluster with the heroku config:get command:

$ heroku config:get DATABASE_URL
postgres://user:pass@host:port/dbname

Finally, the DATABASE_SSH_TUNNEL_BPG_CONNECTION_INFO config var contains internal connection information required to establish a secure tunnel. It’s used by the companion buildpack (borealis/postgres-ssh). You don’t need it in your application code.

Installing the Buildpack

Apps require the companion buildpack (borealis/postgres-ssh) to connect to an add-on database. After installation, the buildpack automatically uses the connection information in the add-on’s config vars to establish a secure tunnel to the corresponding database cluster. Any client processes that connect using the DATABASE_URL or DATABASE_READONLY_URL config vars automatically send their database traffic through the secure tunnel.

The following sections describe how to apply the buildpack using either a slug (the standard option) or a Docker container (via Cloud Native Buildpacks or a Dockerfile).

Standard Deploy (Slug)

If you’re using a standard deployment, you can add the buildpack using the following CLI command:

$ heroku buildpacks:add --index 1 borealis/postgres-ssh

After adding a buildpack to a slug app, you must deploy a new version of the app (for example, by pushing with git) for the buildpack to take effect.

Cloud Native Buildpack Deploy (Docker)

You can build an image using Cloud Native Buildpacks. To build an image, you must install Pack, a tool that supports the use of Cloud Native Buildpacks.

The following example shows how to build an image with the borealis/postgres-ssh, heroku/ruby, and heroku/procfile buildpacks. These buildpacks include support for the Borealis Isolated Postgres add-on, the Ruby language, and a Procfile, respectively:

$ pack build --buildpack https://buildpack-registry.heroku.com/cnb/borealis/postgres-ssh --buildpack heroku/ruby --buildpack heroku/procfile --builder heroku/buildpacks example-app

The heroku/procfile buildpack is necessary if your app has a Procfile. Don’t include it otherwise.

There’s a Cloud Native Buildpack for every supported language. You can include a language’s Cloud Native Buildpack using the same name as its standard buildpack in a pack build command. For a list of buildpacks for supported languages, see Buildpacks.

To include other standard buildpacks as Cloud Native Buildpacks, you can use the Cloud Native Buildpacks shim. Simply append the buildpack’s name to the end of the URL https://buildpack-registry.heroku.com/cnb/ (for example, to include jincod/dotnetcore-buildpack, use https://buildpack-registry.heroku.com/cnb/jincod/dotnetcore-buildpack in the pack build command).

Next, tag and push the image to Heroku’s Docker registry:

$ docker tag example-app registry.heroku.com/example-app/web
$ docker push registry.heroku.com/example-app/web

Finally, release the app on Heroku:

$ heroku container:release --app example-app web

For more information about deploying and running Docker containers, see Container Registry & Runtime (Docker Deploys).

Dockerfile Deploy (Docker)

You can define your app’s Docker image manually in a Dockerfile. The following Dockerfile for Heroku’s python-getting-started app shows how to set up a secure tunnel:

FROM python:3.11

# Download, build, and move the autossh executable to the location expected by
# the buildpack's secure tunnel startup script (the /usr/bin directory)
WORKDIR /tmp
RUN wget https://www.harding.motd.ca/autossh/autossh-1.4g.tgz && \
  tar -x --file autossh-1.4g.tgz && \
  cd autossh-1.4g && \
  ./configure && \
  make && \
  mv autossh /usr/bin && \
  cd .. && \
  rm -rf autossh-1.4g autossh-1.4g.tgz

# Copy the app's files and install its dependencies
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt

# Download the secure tunnel startup script from the borealis/postgres-ssh
# buildpack
RUN wget https://raw.githubusercontent.com/OldSneerJaw/heroku-buildpack-borealis-pg-ssh/main/profile.d/borealis-pg-init-ssh-tunnel.sh && \
  chmod u+x borealis-pg-init-ssh-tunnel.sh

# Set the command that establishes the SSH tunnel and launches the app when
# the container starts
CMD ./borealis-pg-init-ssh-tunnel.sh && gunicorn gettingstarted.wsgi

Follow the Container Registry & Runtime (Docker Deploys) documentation to build the image and deploy to Heroku using the heroku container:push and heroku container:release commands.

A heroku.yml file is a convenient way to manage building, deploying, and running a Dockerfile-based app on Heroku.

Connecting to the Database

Connecting with Ruby

Use the pg gem to connect to a PostgreSQL database in Ruby. Add it to the project’s Gemfile, then install all dependencies using bundler:

$ bundle install

Pass the DATABASE_URL config var directly to the PG.connect method to connect to the database:

require 'pg'

db_conn = PG.connect(connection_string: ENV["DATABASE_URL"])

Modern versions of the Rails framework have built-in support for the DATABASE_URL config var, so you don’t need to configure it to use it with Active Record.

For more information about using this gem, see pg.

Connecting with Python

Use the psycopg package to connect to a PostgreSQL database in Python. Add it to the project’s requirements.txt, then install all dependencies using pip:

$ pip install -r requirements.txt

Pass the DATABASE_URL config var directly to psycopg’s connect function:

import os
import psycopg

db_conn = psycopg.connect(os.environ["DATABASE_URL"])

If you’re using Django, install the dj-database-url package. Configure the database used by Django’s ORM from the DATABASE_URL config var.

For more information, see psycopg.

Connecting with Java

Use the PostgreSQL JDBC driver to connect to a PostgreSQL database in Java. The official Java buildpack automatically creates JDBC_DATABASE_URL and SPRING_DATASOURCE_URL environment variables when it detects a DATABASE_URL config var. These environment variables are suitable for many common situations. The JDBC connection info can be parsed directly from the DATABASE_URL config var when they aren’t supported.

For example, pass the JDBC_DATABASE_URL environment variable directly to the DriverManager‘s getConnection method:

var dbConn = DriverManager.getConnection(System.getenv("JDBC_DATABASE_URL"));

Connecting with Node.js

Use the pg package to connect to a PostgreSQL database in Node.js. Add it to the project’s package.json and install it in one command:

$ npm install --save pg

Pass the DATABASE_URL config var to the Client constructor:

const {Client} = require('pg');

const dbClient = new Client({connectionString: process.env.DATABASE_URL});
await dbClient.connect();

For more information, see node-postgres.

Connecting with Go

Use the pq database driver to connect to a PostgreSQL database in Go. Add it to the project’s go.mod and install it in one command:

$ go get github.com/lib/pq

Pass the DATABASE_URL config var to the sql.Open method:

import (
    "database/sql"

    _ "github.com/lib/pq"
)

func main() {
    dbConn, dbErr := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if dbErr != nil {
        log.Fatalf("Error connecting to database: %q", dbErr)
    }
}

For more information, see Go pq.

Connecting with PHP

Use the pgsql extension to connect to a PostgreSQL database in PHP:

$db_conn = pg_connect(getenv("DATABASE_URL"));

You can also use PHP Data Objects (PDO) for a slightly higher-level abstraction, which requires the use of the parse_url function to retrieve connection info:

$dbinfo = parse_url(getenv("DATABASE_URL"));
$dbname = ltrim($dbinfo["path"], "/")
$dbconn = new PDO("pgsql:host=" . $dbinfo["host"] . ";port=" . $dbinfo["port"] . ";dbname=" . $dbname . ";user=" . $dbinfo["user"] . ";password=" . $dbinfo["pass"]);

Local Connections

You can connect to a Borealis Isolated Postgres add-on database cluster locally on the command line by using the borealis-pg-cli plugin for the Heroku CLI.

Install the plugin:

$ heroku plugins:install borealis-pg-cli

Next, open a secure tunnel and submit SQL queries to the database using a tool like psql or pgAdmin:

$ heroku borealis-pg:tunnel --addon DATABASE

You can use the borealis-pg-cli plug-in to add and remove PostgreSQL extensions, start ad hoc secure sessions, and execute database migration scripts through a secure tunnel to a database cluster. For more information about specific borealis-pg-cli commands, see borealis-pg-cli.

Troubleshooting

A missing borealis/postgres-ssh buildpack causes most connection issues. The buildpack is required in order to establish a secure tunnel between your app and the database server. Without the buildpack installed you are likely to encounter an error similar to the following:

connection to server at "pg-tunnel.borealis-data.com" (127.0.0.1), port 65535 failed: Connection refused
Is the server running on that host and accepting TCP/IP connections?

You can verify your buildpack using the following CLI command:

$ heroku buildpacks
=== example-app Buildpack URLs
1. borealis/postgres-ssh
2. heroku/java

If it’s missing, see Installing the Buildpack for more information about how to add it to the app.

If the buildpack isn’t missing, verify that you’ve deployed a new version of the app. Pushing a code change forces Heroku to use the new buildpack. If problems persist, make sure you’ve configured the app to use the correct language-specific PostgreSQL connection URL config var.

Finally, verify that you’re using the correct Borealis Isolated Postgres add-on attachment name. Check the name in your config vars and remember that you can rename attachments with heroku addons:rename.

Dashboard

To access the add-on dashboard, open the Heroku Dashboard, choose an application that has the add-on attached, and then select Borealis Isolated Postgres from the Installed Add-ons section.

The dashboard allows you to review details of an add-on, including storage usage, PostgreSQL version, a list of active database user roles and which PostgreSQL extensions are installed, among others. You can also fully reset add-on database credentials from the Users tab as needed.

Encryption

All connections to a Borealis Isolated Postgres database cluster use a secure tunnel. Data is automatically encrypted in transit. All data stored in the database cluster is encrypted when at rest. For an added layer of transport security, ensure that your app connects with the sslmode connection parameter set to require.

Data Storage Limits

Each add-on plan has a database storage limit. As an add-on’s database size approaches the storage limit for the plan, you will be sent a courtesy notice at the email address associated with your Heroku user account. Any add-on database that persistently exceeds its storage limit will eventually be made read-only (although rest assured that no pre-existing data will be lost in such cases) until it is upgraded to a plan with enough storage available.

Migrating Between Plans

Application owners must carefully manage the migration timing to ensure proper application function during the migration process.

Since migrations happen in place there is no need to wait for long data copy operations, but when switching to a different database node size, the migration process can take several minutes (typically no more than 20 minutes) as the new node(s) are prepared. In such cases, near the end of the migration process, your app may experience a brief period of downtime (usually less than a minute) as the database cluster switches over to the new database node(s). However, if you are simply adding or removing replica nodes of the same size in a cluster, expect zero downtime. The plan-change-started and plan-change-completed log events can be used to track progress.

The plan migration is asynchronous. The app config vars for the add-on update after the migration completes.

Use the heroku addons:upgrade command to migrate to a new plan:

$ heroku addons:upgrade borealis-pg:newplan
Upgrading borealis-pg-example-addon to borealis-pg:newplan on ⬢ example-app... done
Your plan has been updated to: borealis-pg:newplan

Event Logging

Borealis Isolated Postgres automatically records events to your Heroku app’s logs. Every entry includes at least a source attribute with the add-on’s name and an event attribute with the event’s type, along with some number of context-specific attributes. For example:

2022-11-23T03:04:24.141698+00:00 app[borealis-pg]: source=borealis-pg-cubic-14331 event=app-ssh-user-session-started client_address=ec2-54-172-16-90.compute-1.amazonaws.com ssh_username=g0lfs2tna65h5nbwpfr8lc192g

The following event types are supported once an add-on has been provisioned:

  • app-ssh-user-session-started: A Heroku app dyno has connected to the add-on database via a secure tunnel.
  • app-ssh-user-session-ended: A Heroku app dyno has closed its secure tunnel to the add-on database.
  • db-credentials-full-reset: A user has triggered a full reset of all add-on database user credentials via the add-on dashboard or borealis-pg-cli.
  • db-failover-started: An automatic failover of the primary DB node has begun. This occurs when there is a failure of the current primary DB node and the add-on has at least one read replica node that is being promoted to primary automatically. Downtime is typically less than a minute.
  • db-failover-completed: An automatic failover of the primary DB node has finished.
  • db-storage-limit-violated: The add-on database has exceeded the plan’s data storage limit.
  • db-storage-limit-violation-resolved: The add-on database no longer exceeds the plan’s data storage limit.
  • db-write-access-revoked: The add-on database has been made read-only. Generally this is due to a persistent data storage limit violation.
  • db-write-access-restored: Write access for the add-on database has been restored.
  • personal-db-password-rotated: The password for a personal database user (i.e. a database user role that is associated with a specific Heroku user account) has been changed. This happens automatically whenever a user executes certain commands via the add-on CLI.
  • personal-db-user-created: A new personal database user has been created.
  • personal-ssh-user-configured: The credentials for a personal SSH/secure tunnel user have been modified/created. This happens automatically whenever a user executes certain commands via the add-on CLI.
  • personal-ssh-user-session-started: A personal user has connected to the add-on database via an ad hoc secure tunnel.
  • personal-ssh-user-session-ended: A personal user has closed their ad hoc secure tunnel to the add-on database.
  • postgresql-extension-installed: A user has installed a PostgreSQL extension.
  • postgresql-extension-removed: A user has uninstalled a PostgreSQL extension.
  • plan-change-started: An add-on plan change has begun.
  • plan-change-completed: An add-on plan change has finished.

Removing the Add-on

You can remove Borealis Isolated Postgres via the CLI:

This action destroys all associated data and can’t be undone!

$ heroku addons:destroy borealis-pg
Destroying borealis-pg-example-addon on ⬢ example-app... done

Before removing Borealis Isolated Postgres, you can export your data using any standard PostgreSQL data export tool (for example, pg_dump).

Support

Submit all Borealis Isolated Postgres support and runtime issues using one of the Heroku Support channels (see the Add-ons page on Heroku Help to create a support ticket, for example). Any non-support related issues or product feedback is welcome at support@borealis-data.com.

Attribution

Postgres, PostgreSQL, and the Slonik Logo are trademarks or registered trademarks of the PostgreSQL Community Association of Canada.

Amazon Web Services and the “Powered by AWS” logo are trademarks of Amazon.com, Inc. or its affiliates in the United States and/or other countries.

Icons are provided by Icons8.

Feedback

Log in to submit feedback.