# What Database Integrations Does OpenSRE Support? A Complete Guide to Built-In Connectors

> Explore OpenSRE database integrations. Discover built-in connectors for PostgreSQL, MySQL, MariaDB, MongoDB, ClickHouse, and Azure SQL. Get automatic configuration discovery and validation.

- Repository: [Tracer/opensre](https://github.com/Tracer-Cloud/opensre)
- Tags: how-to-guide
- Published: 2026-04-18

---

**OpenSRE supports seven production-grade database integrations including PostgreSQL, MySQL, MariaDB, MongoDB (self-hosted), MongoDB Atlas, ClickHouse, and Azure SQL, each implemented with automatic configuration discovery and validation.**

OpenSRE is an open-source platform designed to streamline reliability engineering workflows by providing standardized integrations with critical infrastructure components. The database integrations are a core capability of the project, enabling automatic discovery, configuration validation, and health monitoring across diverse data stores. Each integration follows a consistent architectural pattern defined in the `app/integrations/` directory, ensuring predictable behavior whether you are connecting to a self-hosted PostgreSQL instance or a managed MongoDB Atlas cluster.

## Supported Database Integrations in OpenSRE

OpenSRE ships with dedicated integration modules for seven major database systems. Each module resides in its own Python file under `app/integrations/` and exposes standardized configuration builders, environment variable parsers, and validation routines.

### PostgreSQL

The PostgreSQL integration handles connections to self-hosted or managed PostgreSQL instances. According to the OpenSRE source code, the integration is implemented in [`app/integrations/postgresql.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/postgresql.py) and provides the following core functions:

- `build_postgresql_config()` – Constructs a strongly-typed configuration object from raw parameters
- `postgresql_config_from_env()` – Parses environment variables (e.g., `POSTGRESQL_HOST`, `POSTGRESQL_DATABASE`, `POSTGRESQL_PORT`, `POSTGRESQL_USERNAME`, `POSTGRESQL_PASSWORD`, `POSTGRESQL_SSL_MODE`) into a config object
- `resolve_postgresql_config()` – Resolves final configuration from mixed sources
- `validate_postgresql_config()` – Returns a `ValidationResult` describing connection health or configuration errors

### MySQL

MySQL support is provided through [`app/integrations/mysql.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/mysql.py). The integration follows the same pattern as PostgreSQL with database-specific configuration parameters:

- `build_mysql_config()`, `mysql_config_from_env()`, `resolve_mysql_config()`, and `validate_mysql_config()` handle the full lifecycle of configuration management
- Environment variables use the `MYSQL_` prefix for host, database, port, username, and password settings

### MariaDB

MariaDB integration is implemented separately in [`app/integrations/mariadb.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/mariadb.py) despite its similarity to MySQL, ensuring explicit compatibility checks and dedicated configuration namespaces:

- `build_mariadb_config()`, `mariadb_config_from_env()`, `resolve_mariadb_config()`, and `validate_mariadb_config()` provide the standard interface
- Uses `MARIADB_` prefixed environment variables to avoid conflicts with MySQL settings

### MongoDB (Self-Hosted)

The self-hosted MongoDB integration in [`app/integrations/mongodb.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/mongodb.py) supports standalone instances and replica sets without Atlas-specific features:

- `build_mongodb_config()`, `mongodb_config_from_env()`, and `validate_mongodb_config()` manage connection string construction and credential handling
- Validates connection parameters before attempting client initialization

### MongoDB Atlas

MongoDB Atlas is treated as a distinct integration in [`app/integrations/mongodb_atlas.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/mongodb_atlas.py) to handle Atlas-specific connection strings, cluster tiers, and managed security features:

- `build_mongodb_atlas_config()`, `mongodb_atlas_config_from_env()`, and `validate_mongodb_atlas_config()` implement the standard pattern with Atlas-specific parameter validation
- Distinguishes between Atlas dedicated clusters and serverless instances during configuration resolution

### ClickHouse

ClickHouse column-store support is provided through [`app/integrations/clickhouse.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/clickhouse.py), enabling high-performance analytical queries:

- `build_clickhouse_config()`, `clickhouse_config_from_env()`, and `validate_clickhouse_config()` handle HTTP and native protocol configurations
- Supports validation of secure connection parameters and custom HTTP headers

### Azure SQL

Azure SQL Database and Azure SQL Managed Instance are supported via [`app/integrations/azure_sql.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/azure_sql.py), including Active Directory authentication options:

- `build_azure_sql_config()`, `azure_sql_config_from_env()`, `resolve_azure_sql_config()`, and `validate_azure_sql_config()` implement the standard interface
- Handles Azure-specific connection string formats and token-based authentication flows

## How OpenSRE Database Integrations Work

OpenSRE employs a consistent architectural pattern across all database integrations to ensure predictable behavior and maintainable code.

### Configuration Discovery and Resolution

Each integration provides three configuration helpers that form a pipeline from raw input to validated config:

1. **`build_<db>_config`** – Accepts explicit parameters (host, port, credentials) and returns a strongly-typed Pydantic model defined in [`app/integrations/models.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/models.py)
2. **`<db>_config_from_env`** – Loads configuration from environment variables using the database-specific prefix (e.g., `POSTGRESQL_`, `MYSQL_`)
3. **`resolve_<db>_config`** – Merges environment variables with explicit arguments, with explicit parameters taking precedence

### Validation and Health Checking

The `validate_<db>_config` function in each module performs deep connection validation:

- Returns a `ValidationResult` object indicating success or specific failure modes (authentication errors, network timeouts, SSL handshake failures)
- Performs lightweight connection tests without executing destructive operations
- Catches configuration errors early before expensive client initialization

### Unified Verification Flow

The [`app/integrations/verify.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/verify.py) module provides the `verify_integrations` function that orchestrates health checks across all registered databases:

```python
from app.integrations.verify import verify_integrations

results = verify_integrations(service="postgresql")  # Filter by specific DB

for r in results:
    print(f"{r['service']} – available: {r['available']}")

```

This routine:
- Imports all integration modules dynamically
- Invokes `is_configured` methods to check for environment presence
- Runs `validate_<db>_config` for configured services
- Returns a standardized JSON-serializable list suitable for CLI output, web UI dashboards, and automated testing

## Working with Database Integrations: Practical Examples

The following examples demonstrate common patterns for configuring and validating OpenSRE database integrations in production environments.

### Configuring PostgreSQL via Environment Variables

Create a `.env` file or export variables in your shell:

```bash
POSTGRESQL_HOST=pg.example.com
POSTGRESQL_DATABASE=mydb
POSTGRESQL_PORT=5432
POSTGRESQL_USERNAME=app_user
POSTGRESQL_PASSWORD=secure_password
POSTGRESQL_SSL_MODE=require

```

Then load the configuration in Python:

```python
from app.integrations.postgresql import postgresql_config_from_env

cfg = postgresql_config_from_env()

# cfg is a PostgreSQLConfig dataclass ready for consumption

```

### Resolving MySQL Configuration from Mixed Sources

When you need to override environment defaults with explicit parameters:

```python
from app.integrations.mysql import resolve_mysql_config

raw = {"host": "db.example.com", "database": "sales", "port": 3306}
cfg = resolve_mysql_config(**raw)   # returns MySQLConfig

# Explicit parameters take precedence over environment variables

```

### Running Health Checks Across All Databases

To verify which integrations are properly configured and accessible:

```python
from app.integrations.verify import verify_integrations

results = verify_integrations()
for r in results:
    status = "✓" if r['available'] else "✗"
    print(f"{status} {r['service']}: {r.get('details', r.get('error', 'N/A'))}")

```

### Using a Validated ClickHouse Client

After validation, instantiate the database-specific client:

```python
from app.integrations.clickhouse import ClickHouseClient, clickhouse_config_from_env

cfg = clickhouse_config_from_env()
if cfg:
    client = ClickHouseClient(cfg)
    result = client.run_query("SELECT count() FROM events")
    print(f"Event count: {result}")

```

## Summary

OpenSRE provides comprehensive out-of-the-box support for seven major database systems through a unified integration architecture:

- **Relational databases**: PostgreSQL, MySQL, MariaDB, and Azure SQL with full SSL and authentication support
- **Document stores**: MongoDB (self-hosted) and MongoDB Atlas with distinct handling for managed cluster configurations
- **Columnar analytics**: ClickHouse optimized for high-performance analytical workloads

Each integration in `app/integrations/` implements standardized configuration helpers (`build_<db>_config`, `<db>_config_from_env`, `resolve_<db>_config`), validation routines (`validate_<db>_config`), and health checking through the unified `verify_integrations` flow in [`app/integrations/verify.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/verify.py). This consistent pattern enables automatic discovery, environment-based configuration, and runtime health validation across all supported data stores.

## Frequently Asked Questions

### Does OpenSRE require manual configuration for each database integration?

No, OpenSRE automatically discovers and validates database integrations through environment variables. Each integration uses a standardized prefix (e.g., `POSTGRESQL_`, `MYSQL_`) to load configuration via functions like `postgresql_config_from_env()` or `mysql_config_from_env()`. The `verify_integrations()` routine in [`app/integrations/verify.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/verify.py) automatically checks all registered integrations without requiring manual enablement.

### Can I use both MongoDB self-hosted and MongoDB Atlas simultaneously?

Yes, OpenSRE treats these as distinct integrations. The [`app/integrations/mongodb.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/mongodb.py) module handles self-hosted instances and replica sets, while [`app/integrations/mongodb_atlas.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/mongodb_atlas.py) manages Atlas-specific connection strings and cluster configurations. Each has separate environment variable prefixes and validation logic, allowing you to configure both within the same OpenSRE deployment.

### How does OpenSRE validate database connections without exposing credentials?

OpenSRE uses the `validate_<db>_config` functions (such as `validate_postgresql_config` or `validate_clickhouse_config`) to perform lightweight connection tests that verify authentication and network connectivity without executing destructive operations. These functions return `ValidationResult` objects defined in [`app/integrations/models.py`](https://github.com/Tracer-Cloud/opensre/blob/main/app/integrations/models.py), which indicate success or specific failure modes (like SSL handshake errors or authentication failures) without logging sensitive credential values.

### What is the difference between `build_<db>_config` and `resolve_<db>_config`?

The `build_<db>_config` function (e.g., `build_postgresql_config`) creates a strongly-typed configuration object from explicit parameters passed as arguments. In contrast, `resolve_<db>_config` (e.g., `resolve_postgresql_config`) merges environment variables with any explicit parameters, with explicit arguments taking precedence. This allows flexible configuration management where you can override environment defaults programmatically when needed.