13 minute read · March 28, 2024

From Postgres to Dashboards with Dremio and Apache Iceberg

Alex Merced

Alex Merced · Senior Tech Evangelist, Dremio

Moving data from source systems like Postgres to a dashboard traditionally involves a multi-step process: transferring data to a data lake, moving it into a data warehouse, and then building BI extracts and cubes for acceleration. This process can be tedious and costly. However, this entire workflow is simplified with Dremio, the Data Lakehouse Platform. Dremio enables direct serving of BI dashboards from Postgres or leveraging Apache Iceberg tables in your data lake. This post will explore how Dremio's data lakehouse platform simplifies your data delivery for business intelligence by creating a prototype version that can run on your laptop.

Setting Up Our Environment

To run this exercise on your laptop, you will need Docker Desktop to run Docker Compose files and spin up our environment. In an empty folder, create a docker-compose.yml file with the following:

version: "3"

  # Nessie Catalog Server Using In-Memory Store
    image: projectnessie/nessie:latest
    container_name: nessie
      - 19120:19120
  # Minio Storage Server
    image: minio/minio:latest
    container_name: minio
      - MINIO_ROOT_USER=admin
      - MINIO_ROOT_PASSWORD=password
      - MINIO_DOMAIN=storage
      - MINIO_REGION_NAME=us-east-1
      - MINIO_REGION=us-east-1
      - 9001:9001
      - 9000:9000
    command: ["server", "/data", "--console-address", ":9001"]
  # Dremio
    platform: linux/x86_64
    image: dremio/dremio-oss:latest
      - 9047:9047
      - 31010:31010
      - 32010:32010
      - 45678:45678
    container_name: dremio
      - DREMIO_JAVA_SERVER_EXTRA_OPTS=-Dpaths.dist=file:///opt/dremio/data/dist
  # Postgres
    image: postgres:latest
    container_name: postgres
      POSTGRES_DB: mydb
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
      - "5435:5432"
    image: alexmerced/dremio-superset
    container_name: superset
      - 8080:8088

This Docker Compose file sets up a development environment for integrating Postgres with a BI dashboard through Dremio and Apache Iceberg, leveraging additional tools like Nessie and MinIO. Here's what each service in the file represents:

  • Nessie: Acts as a catalog server using an in-memory store, helping to manage and version data in the data lake. It runs on port 19120 and is part of the dremio-pg-superset network, facilitating integration with Dremio and Postgres for table cataloging and version control.
  • MinIO: Serves as a storage server, mimicking a cloud storage environment locally. It's configured with essential security and region settings and exposes ports 9000 for API access and 9001 for the console. MinIO provides the storage layer for the data lake, where data from Postgres can be stored and managed for processing with Dremio.
  • Dremio: This is the core component of the data lakehouse platform, providing the ability to directly query and manage data across different sources like Postgres and the data stored in MinIO. It exposes several ports for different purposes, such as the Dremio UI (9047), and data communication (31010 and 32010).
  • Postgres: Represents the source database, configured with basic credentials and a database name (mydb). It exposes container port 5432 to localhost:5435 (to avoid collision if you already have Postgres installed), making it accessible to other services in the environment, particularly Dremio, for data extraction and loading.
  • Superset: A business intelligence tool configured to connect with Dremio, allowing users to create and view dashboards and reports. It runs on port 8088 but is mapped to 8080 on the host machine for easy access.

The networks section defines a custom network named dremio-pg-superset, ensuring these services can communicate seamlessly within this isolated network environment.

In the context of our blog, this Docker Compose setup illustrates how to create a local development environment that mirrors the process of moving data from Postgres to a BI dashboard using Dremio and Apache Iceberg, with Nessie for table cataloging and MinIO for simulating a cloud storage environment.

To spin up the environment, simply run the command:

docker compose up

Populating Data in Our Postgres Database

To access the Postgres database shell and populate it with data to simulate data in operational databases, run the following command in another terminal window or tab:

docker exec -it postgres psql -U myuser -d mydb

From the Postgres shell run the following queries:

CREATE TABLE sales_data (
    sale_date DATE NOT NULL,
    product_id INT NOT NULL,
    quantity INT NOT NULL,
    total_amount NUMERIC(10, 2) NOT NULL

INSERT INTO sales_data (sale_date, product_id, quantity, total_amount) VALUES
('2023-01-01', 101, 3, 450.00),
('2023-01-02', 102, 2, 300.00),
('2023-01-03', 103, 1, 150.00),
('2023-01-04', 104, 5, 750.00),
('2023-01-05', 105, 2, 200.00),
('2023-01-06', 106, 4, 400.00),
('2023-01-07', 107, 3, 350.00),
('2023-01-08', 108, 1, 180.00),
('2023-01-09', 109, 6, 900.00),
('2023-01-10', 110, 2, 220.00);

To quit the Postgres shell run the following command:


Connecting Postgres, Nessie, and Minio to Dremio

Open MinIO in the browser at localhost:9000 and log in with username “admin” and password “password”. Once you log in, create a new bucket called “warehouse”. Remember that Nessie is always running in the background and is accessed by a REST API which is how the Dremio connector communicates with the catalog.

Now, head to localhost:9047 in your browser to set up your Dremio admin account. Once set up, click “add a Source” and select a “Nessie” as the source. Enter in the following settings:

  • General settings tab
  • Storage settings tab
    • AWS Root Path: warehouse
    • AWS Access Key: admin
    • AWS Secret Key: password
    • Uncheck “Encrypt Connection” Box (since we aren’t using SSL)
    • Connection Properties
      • Key: fs.s3a.path.style.access | Value: true
      • Key: fs.s3a.endpoint | Value: minio:9000
      • Key: dremio.s3.compat | Value: true

Click on “Save,” and the source will be added to Dremio. You can then run full DDL and DML SQL against it. Dremio turns your data lake into a data warehouse—a data lakehouse!

Now let’s add a Postgres source with the following settings:

  • Name: postgres
  • Host: postgres
  • Port: 5432 (Dremio and Postgres will communicate directly so we use the native port on the Postgres container, 5432, not the port we mapped it to on our host machine 5435)
  • Database Name: mydb
  • Username: myuser
  • Password: mypassword

Once you save the source, you can see both sources on the Dremio dashboard and begin working with them.

Moving Our Postgres Data to Our Data Lake

Historically, moving data from our databases into our data lake as Apache Iceberg tables would require spinning up an Apache Spark cluster and writing complex jobs in Python, Java, or Scala. But with Dremio, we can move our data to our data lake with simple SQL.

Head over to the SQL Runner in the Dremio UI and run the following query to ingest the table in Postgres as an Apache Iceberg table in our Nessie source:

CREATE TABLE nessie.sales_data AS SELECT * FROM postgres.public."sales_data";

This is a great way to initially move the table to your data lake. To update the table, you can use the INSERT INTO SELECT statement, adding all records with a higher ID value to the highest ID value in the destination. This will ensure only new records are added to the table.

INSERT INTO nessie.sales_data
FROM postgres.public."sales_data"
WHERE sale_id > (SELECT COALESCE(MAX(sale_id), 0) FROM nessie.sales_data);

Now we have the data in our data lakehouse. While we could choose not to move the data and operate with the data directly from Postgres using Dremio, we could run into competition for resources as the growing number of analytical queries compete with existing operational queries sent to our Postgres database directly. To avoid this, we can either create a data reflection, which creates a Dremio-managed materialization on your data lake that Dremio substitutes when the table is queried, or ingest the data into our data lakehouse as we did above. Either option allows analytical queries to utilize Dremio’s infinite horizontal and vertical scaling capabilities fully.

Connecting Superset to Dremio

Dremio can be used with most existing BI tools, with one-click integrations in the user interface for tools like Tableau and Power BI. We will use an open-source option in Superset for this exercise, but any BI tool would have a similar experience.

We need to initialize Superset, so open another terminal and run this command:

docker exec -it superset superset init

This may take a few minutes to finish initializing but once it is done you can head over to localhost:8080 and log in to Superset with the username “admin” and password “admin”. Once you are in, click on “Settings” and select “Database Connections”.

  • Add a New Database
  • Select “Other”
  • Use the following connection string (make sure to include Dremio username and password in URL):

  • Test connection
  • Save connection

The next step is to add a dataset by clicking on the + icon in the upper right corner and selecting “create dataset”. From here, choose the table you want to add to Superset, which is, in this case, our sales_data table.

We can then click the + to add charts based on the datasets we’ve added. Once we create the charts we want we can add them to a dashboard, and that’s it! You’ve now taken data from an operational database, ingested it into your data lake, and served a BI dashboard using the data.

Deploy Dremio into production to make delivering data for analytics easier for your data engineering team.

Ready to Get Started?

Bring your users closer to the data with organization-wide self-service analytics and lakehouse flexibility, scalability, and performance at a fraction of the cost. Run Dremio anywhere with self-managed software or Dremio Cloud.