InfluxData Blog - Jameelah Mercer

Ingest, Explore, Validate: A Quickstart with InfluxDB 3 Enterprise and Explorer UI

Jameelah Mercer (InfluxData) — Tue, 22 Jul 2025 08:00:00 +0000

Great observability doesn’t just collect metrics—it tells you exactly what’s broken, why it’s broken, and what to do about it.

InfluxDB 3 Enterprise delivers this through real-time ingestion, fast queries, and scalable storage. InfluxDB 3 Explorer provides the intuitive interface your team needs for database management, data ingestion, querying, and visualization without the usual complexity.

This tutorial shows you how to deploy Enterprise and Explorer as a unified platform that transforms raw metrics into actionable insights your organization needs.

What you’re building

By the end of this tutorial, you’ll have:

InfluxDB 3 Enterprise: A high-performance time series database running locally
Explorer UI: A preconfigured web interface for your teams
Sample Data Pipeline: System metrics demonstrating real-world ingestion patterns
Production Readiness: Clear scaling considerations and next steps

This setup mirrors what you’d deploy in staging or production environments, scaled for local development.

Prerequisites

To follow this tutorial, you’ll need:

Required:

Docker installed on your local machine
A dedicated working directory for your InfluxDB 3 project

Create a working directory on your local machine by running the following in your command line:

mkdir influxdb-enterprise-demo && cd influxdb-enterprise-demo

Deploy InfluxDB 3 Enterprise

The fastest way to get started with InfluxDB 3 Enterprise locally is by running it in a Docker container using a file-based object store. This ensures your data and configuration persist across restarts, which is ideal for local development, plugin testing, and working with the Explorer UI.

Tip: For production deployments, you can configure cloud object stores (such as S3, Azure Blob Storage, or Google Cloud Storage) for enhanced durability and scalability. Learn more about production storage configuration here.

Download and Install

Run the following command to download and execute the installation script:

curl -O https://www.influxdata.com/d/install_influxdb3.sh \
  && sh install_influxdb3.sh enterprise

You’ll see a prompt like:

Select Installation Type
1) Docker Image  
2) Simple Download

Choose:

Select 1 to install using Docker. The download and setup typically complete in under 30 seconds.

Create Persistent Directories

If you plan to work with the Processing Engine plugins or want your data to persist between restarts, create the following directories in your working directory:

mkdir -p data plugins

data/ stores InfluxDB 3 catalog, WAL, and Parquet data:
- Catalog: Metadata about your databases, tables, and schema information
- WAL (Write-Ahead Log): Incoming data is written for recovery before being persisted to permanent Parquet files
- Parquet data: Your actual time series data stored in compressed, columnar format for fast queries
plugins/ is optional and used for custom Python plugins

Tip: These directories ensure your data and configuration survive container restarts. In production deployments, you’d typically mount these to persistent volumes or use cloud object storage for the Parquet files.

Start the InfluxDB 3 Enterprise Container

Start the container manually using this Docker command:

docker run -it \
  -p 8181:8181 \
  -v $PWD/data:/data \
  -v $PWD/plugins:/plugins \
  influxdb3-enterprise influxdb3 serve \
  --node-id node0 \
  --cluster-id cluster0 \
  --object-store file \
  --data-dir /data \
  --plugin-dir /plugins

This command mounts your local directories for persistent storage and exposes InfluxDB’s API on port 8181.

Configure License

On the first run, the container prompts you to choose a license type:

To get started, please select a license type:
1) FREE TRIAL  
2) COMMERCIAL  
3) HOME USE
Choose:

For this tutorial, select Option 1 (FREE TRIAL). The free trial provides access to all InfluxDB 3 Enterprise capabilities for 30 days, making it ideal for proof-of-concept deployments, team evaluation, and production planning.

Provide your email address when prompted. InfluxDB will send a verification link. Once verified, the server will complete initialization and begin serving requests.

Important: When InfluxDB starts, it will display your admin token in the console output. Copy this token immediately and store it securely. You will need it for Explorer configuration.

You’ll see a confirmation log like:

valid license found, happy data crunching  
startup time: XXXXXms address=0.0.0.0:8181

Your InfluxDB 3 Enterprise instance is now running locally at: http://localhost:8181

Set up Explorer UI

InfluxDB 3 Explorer provides a browser-based interface for database management, data ingestion, and SQL queries. You’ll deploy it in admin mode and preconfigure it to automatically connect to your InfluxDB instance for seamless user access.

Create Required Directories

To persist Explorer session data and optionally preconfigure connections, create the following directories in your project root:

mkdir -m 700 db
mkdir -m 755 config
mkdir -m 755 ssl

Configure Connection (Optional)

To streamline the user experience, you can preconfigure Explorer to connect to your InfluxDB 3 Enterprise instance automatically. This provides your users with preset connection details, reducing manual setup steps.

Create a config file in your project root to set these defaults for all users:

File: config/config.json

{
  "DEFAULT_INFLUX_SERVER": "http://host.docker.internal:8181",
  "DEFAULT_INFLUX_DATABASE": "",
  "DEFAULT_API_TOKEN": "your_admin_token_from_step_1",
  "DEFAULT_SERVER_NAME": "Local Enterprise"
}

Replace your_admin_token_from_step_1 with the actual admin token from step 1.

Launch Explorer Container

Run the following command to launch the Explorer UI in admin mode, enabling full access to create tokens, databases, and more:

docker run --detach \
  --name influxdb3-explorer \
  --publish 8888:80 \
  --publish 8889:8888 \
  --volume $(pwd)/config:/app-root/config:ro \
  --volume $(pwd)/db:/db:rw \
  --volume $(pwd)/ssl:/etc/nginx/ssl:ro \
  influxdata/influxdb3-ui:1.0.0 \
  --mode=admin

Check that it’s running with:

docker ps

Now, we are ready to launch Explorer’s graphical interface. Visit the UI at: http://localhost:8888.

If you preconfigure config.json correctly, you’ll see “Local Enterprise” preloaded as a connected server. If not, click “Add server” and enter the connection info manually:

Server Name: Local Enterprise
URL: http://host.docker.internal:8181
Token: Paste your admin token from step 1

Security Best Practice: Store the admin token securely. Anyone with this token has full control over your InfluxDB instance.

Create your first database

With Explorer running and connected to your InfluxDB 3 Enterprise instance, create a database to store your organization’s time series data.

Database Setup

In the Explorer UI at: http:localhost:8888
In the left-hand sidebar, click Manage Databases
Click + Create New in the top right
Enter a database name (e.g., observability)
(Optional) Set a retention period:
- Enter a number (e.g., 30)
- Select a unit (e.g., days)
- Leave blank for indefinite retention
Click Create Database

Ingest Sample Data

Now, let’s populate your database with sample data. We’ll use a CSV containing system metrics with tags, fields, and Unix nanosecond timestamps.

Prepare Sample CSV

Create a file named system_metrics.csv in your project directory:

time,cpu,host,usage_user,usage_system
1752274800000000000,cpu0,hostA,19.8,7.2
1752274860000000000,cpu0,hostA,20.1,7.3
1752274920000000000,cpu0,hostA,18.9,6.9
1752274980000000000,cpu0,hostA,21.2,7.5
1752275040000000000,cpu0,hostA,22.4,7.1
1752275100000000000,cpu0,hostA,19.7,6.8
1752275160000000000,cpu0,hostA,20.3,7.0
1752275220000000000,cpu0,hostA,18.5,6.6
1752275280000000000,cpu0,hostA,21.0,7.4
1752275340000000000,cpu0,hostA,20.7,7.2

Important: Timestamps must be in Unix nanoseconds (UTC). cpu and host columns will be treated as tags, usage_user and usage_system as fields.

Upload via Explorer

Open the Explorer UI at http://localhost:8888
In the left-hand side bar, click Data Ingest
Select Import CSV or JSON data
Choose your database from the dropdown (e.g., observability)
Paste your CSV data directly into the text area or drag in your system_metrics.csv

Click Parse Data to proceed to field mapping
Configure the data mapping
Set Measurement Name to “system_metrics” (or your preferred name)
Confirm timestamp is selected as the TimeStamp Column
In the Field Mappings section, ensure:
- host and region are marked as Tags
- cpu_usage, mem_used, disk,io, network_in, network_out are marked as Fields

6. Click Convert to Line Protocol to complete the upload

Verify with SQL

Navigate to the Data Explorer in the sidebar and run:

SELECT * FROM system_metrics LIMIT 10

You should see the records you uploaded.

Troubleshooting: If no data appears, confirm you selected the correct database, verify timestamps are formatted as Unix nanoseconds, and ensure there are no trailing characters or line breaks in the CSV.

Production considerations

Uploading a CSV is ideal for quick validation. However, in production environments, data is ingested continuously and requires different approaches for scale and reliability.

For production workloads, consider these ingestion methods:

Telegraf: A lightweight agent for collecting system, container, and service metrics
HTTP Write API: Send raw records directly using REST endpoint
InfluxDB 3 client libraries: Write from your application code in Python, Go, Java, or other supported languages

These pipelines provide durable and scalable ingestion tailored for observability workloads. Learn more in the InfluxDB 3 Write Data docs.

What’s next?

You now have a complete InfluxDB 3 Enterprise and Explorer setup ready for your organization. For production deployment, focus on configuring cloud object storage (S3, Azure Blob, GCS), setting up TLS/SSL certificates, and implementing proper backup and monitoring procedures.

For your users, create fine-grained database tokens for different teams, integrate with your existing authentication system, and set Grafana dashboards for advanced visualization. To scale your data pipeline, deploy Telegraf agents across your infrastructure for automated collection, integrate with your existing observability stack, and implement automated retention policies to manage storage costs.

Additional Resources

We hope this guide helps you successfully deploy InfluxDB 3 Enterprise and Explorer to collect actionable insights. As you begin using this tool, we’d love to hear about your experience. Share your thoughts and feedback with our development team on our Community Forums, Slack, or our Community Site.

InfluxDB 3 Core and Enterprise Architecture Highlights

Jameelah Mercer (InfluxData) — Thu, 27 Feb 2025 07:00:00 +0000

Introduction

Time series data innovators and open source community members following us will know that we recently released two new products: InfluxDB 3 Core and InfluxDB Enterprise. InfluxDB 3 Core is a high-performance recent data engine optimized for real-time monitoring, data collection, and streaming analytics use cases. InfluxDB 3 Enterprise builds on Core’s foundation by integrating historical analysis and data compaction, enabling efficient querying over extended time ranges. It also adds enterprise-grade features like high availability, scalability, and enhanced security.

Currently in alpha, the response to both products has been overwhelmingly positive, and we have received valuable feedback from the community, guiding our path forward. In response to the excitement and requests for a deeper dive, this blog explores the architecture and operational capabilities of InfluxDB3 Core and Enterprise. Let’s dig in!

Single Node/Single Process

InfluxDB 3 Core and InfluxDB 3 Enterprise feature a straightforward, single-node and single-process architecture. You can run them as a single executable or deploy them in a Docker container. This streamlined design allows you to download, install, and launch a fully operational database and Python-based Processing Engine in under a minute.

FDAP Stack

Next, it’s important to highlight that InfluxDB 3 Core and Enterprise are built on the FDAP stack, which is designed to optimize data storage, processing, and interoperability. FDAP stands for Flight, DataFusion, Arrow, and Parquet—four key technologies that power the InfluxDB 3 product line.

Flight enables efficient data transfer for large datasets.
DataFusion provides a powerful query engine with SQL and InfluxQL support.
Arrow ensures fast in-memory data processing.
Parquet serves as the columnar storage format, allowing integration with a wide range of analytics tools.

Leveraging the FDAP stack, InfluxDB 3 offers enhanced interoperability with external tools and libraries, SQL compatibility, and lightning-fast data transfer.

I recommend checking out my colleague Andrew Lamb’s blog for a deeper dive into this topic.

Diskless architecture

Core and Enterprise offer flexible storage options, including memory, disk, and object storage. When using object storage, the system operates in a diskless architecture where the object store serves as the sole persistence layer, prioritizing simplicity and storage efficiency.

Here is how data moves through the system before reaching object storage:

Writes are buffered in memory and flushed to a Write-Ahead-Log (WAL) file every second.
Flushed data moves to a queryable buffer in Arrow format, enabling fast, in-memory analytics.
Every ten minutes, WAL snapshots are converted into Parquet files, ensuring efficient data storage, rapid retrieval, and interoperability with external analytics tools.

To optimize write performance:

Parallel writes can be used to minimize the impact of the one-second delay.
Single-threaded clients are limited to one write request once per second, maintaining a consistent ingestion rate.

Processing Engine/Plug-In System

Another key component of the architecture is the built-in Processing Engine, which brings a new level of extensibility and control to both InfluxDB 3 Core and Enterprise. Check out this blog that shows you how to leverage the Processing Engine. For users familiar with Kapacitor with 1.x or Flux Tasks with 2.x, the Processing Engine is a more powerful and fully integrated engine for acting on data as it arrives, on-demand, or on a schedule—with multiple trigger types. The Processing Engine empowers you to transform and normalize data, combine multiple sources, trigger alerts and notifications, downsample, replicate data, and more—all through powerful plugins. Imagine running a Python script on incoming data without the need for a separate server. Now, picture doing it seamlessly, with no network transfers in or out of the database. That’s the Processing Engine, and we think you are going to love it!

Enterprise Architecture Enhancements

InfluxDB 3 Core and InfluxDB 3 Enterprise can be installed on edge devices as small as a Raspberry Pi, making them ideal for embedded systems and sensor-based workloads. At the same time, they scale vertically to handle very large workloads. But what if you need to scale horizontally or ensure high availability without relying on a single node? That is where InfluxDB 3 Enterprise can take you even further.

InfluxDB 3 Enterprise includes all of Core’s features while offering a seamless upgrade for commercial deployments. Unlike Core, it is optimized for long-range historical queries through its use of a compaction process that organizes and catalogs Parquet file data.

High Availability

InfluxDB 3 Enterprise is built for stability across diverse workloads, from running on bare metal or VMs to Kubernetes. It delivers high availability, read replicas, and a dedicated compactor, making it ideal for enterprise-scale applications that require reliability and scalability.

Enterprise achieves high availability through its diskless architecture by leveraging the object store to enable high availability.

Nodes can act as readers and/or writers, allowing concurrent writes to object storage for horizontal ingestion.
Nodes write to dedicated areas, while downstream readers can pick up writes from multiple nodes and compacted Parquet files across all nodes.

If a node fails, another node can continue reading from the failed node’s storage and compacted Parquet files, ensuring uninterrupted access to data and maintaining system reliability.

Read Replications

In InfluxDB 3 Enterprise architecture, read replication enables virtually unlimited read replicas, capped only by object storage request capacity.

A few nodes handle writes, while unlimited read replicas scale query performance.
Read replicas function as Processing Engines, providing flexibility in cluster setups.
Replicas pull data from all designated write nodes, compacting Parquet files for efficient queries.

Recommended setups

When deploying InfluxDB 3 Enterprise, choosing the right cluster setup depends on workload size, availability requirements, and performance goals. Below are three recommended configurations.

Simplest High Availability: Two-Node Setup

The simplest setup is a two-node approach, where both nodes act as readers and writers, and one also runs the compactor. This design ensures fault tolerance- if one node goes down, the system keeps running without immediate downtime. Since the compactor operates on a read/write node, this setup is perfect for smaller workloads that prioritize cost efficiency while maintaining resilience.

Both nodes leverage the same object storage, allowing long-term storage and providing a cost-efficient, high-availability solution for production environments.

Three-Node Setup: Dedicated Compactor for Scalability

A three-node setup is the recommended approach for optimized performance and scalability. Two nodes handle reads and writes, while a third node is dedicated to compaction, preventing resource competition and ensuring efficient data processing.

This configuration allows the compactor to scale independently, enabling resource allocation based on real-time workload demands. With two read-write nodes operating at full capacity, queries and writes remain high-performing, while compaction runs in isolation without impacting other nodes.

This setup is ideal for workloads requiring consistent performance across reads and writes, ensuring reliability regardless of which node persists a request. It also facilitates vertical scaling of compaction resources to meet evolving data needs.

Five-Node+ Cluster: High-Throughput Scaling

A 5-node+ InfluxDB 3 Enterprise cluster extends the three-node setup by adding dedicated write nodes, increasing ingest capacity, and ensuring efficient data persistence to object storage. Downstream, a dedicated compactor optimizes storage by compacting files while read nodes handle queries.

Read nodes can function as query servers or processing engines, enabling flexible, isolated query and processing workloads. This separation allows for arbitrary query and processing setups without interference.

With multiple write nodes for high-ingest throughput, multiple read nodes for scalable query performance, and a dedicated compactor for isolated processing, this setup is ideal for large-scale workloads that require horizontal scaling, query isolation, and high-performance processing.

We hope you enjoyed learning a little bit more about some of the highlights of the Core and Enterprise architectures. Let us know what you think! Check out our Getting Started Guide for Core and Enterprise, and share your feedback with our development team on Discord in the #influxdb3_core channel, on Slack in the #influxdb3_core channel, or on our Community Forums.