{"slug":"databases-replicas","title":"Database Replicas","description":"Database replicas provide high availability, improved read performance, and disaster recovery capabilities for your managed databases. DanubeData makes it easy to create and manage read replicas for P...","section":"Features","url":"https://docs.danubedata.ro/databases-replicas","markdown_url":"https://docs.danubedata.ro/databases-replicas.md","breadcrumbs":[{"title":"Features","slug":null},{"title":"Databases","slug":"databases-overview"},{"title":"Replicas","slug":"databases-replicas"}],"headings":[{"level":1,"title":"Database Replicas","id":"database-replicas"},{"level":2,"title":"Overview","id":"overview"},{"level":2,"title":"How Replicas Work","id":"how-replicas-work"},{"level":3,"title":"Replication Architecture","id":"replication-architecture"},{"level":3,"title":"Replication Process","id":"replication-process"},{"level":3,"title":"Replication Lag","id":"replication-lag"},{"level":2,"title":"Creating a Replica","id":"creating-a-replica"},{"level":3,"title":"Prerequisites","id":"prerequisites"},{"level":3,"title":"Via Dashboard","id":"via-dashboard"},{"level":3,"title":"Replica Configuration","id":"replica-configuration"},{"level":4,"title":"Replica Placement","id":"replica-placement"},{"level":2,"title":"Connecting to Replicas","id":"connecting-to-replicas"},{"level":3,"title":"Connection Details","id":"connection-details"},{"level":3,"title":"Read-Only Access","id":"read-only-access"},{"level":3,"title":"Application Configuration","id":"application-configuration"},{"level":4,"title":"Direct Connection","id":"direct-connection"},{"level":4,"title":"Python Example","id":"python-example"},{"level":4,"title":"Node.js Example","id":"nodejs-example"},{"level":3,"title":"SSL/TLS Connections to Replicas","id":"ssltls-connections-to-replicas"},{"level":4,"title":"MySQL/MariaDB with SSL","id":"mysqlmariadb-with-ssl"},{"level":4,"title":"PostgreSQL with SSL","id":"postgresql-with-ssl"},{"level":2,"title":"Load Balancing Across Replicas","id":"load-balancing-across-replicas"},{"level":3,"title":"Round-Robin","id":"round-robin"},{"level":3,"title":"Health-Based Routing","id":"health-based-routing"},{"level":3,"title":"Connection Pooling","id":"connection-pooling"},{"level":2,"title":"Managing Replication Lag","id":"managing-replication-lag"},{"level":3,"title":"Monitoring Lag","id":"monitoring-lag"},{"level":4,"title":"PostgreSQL","id":"postgresql"},{"level":4,"title":"MySQL/MariaDB","id":"mysqlmariadb"},{"level":3,"title":"Handling Lag in Applications","id":"handling-lag-in-applications"},{"level":4,"title":"Read-After-Write Consistency","id":"read-after-write-consistency"},{"level":4,"title":"Eventual Consistency","id":"eventual-consistency"},{"level":4,"title":"Wait for Replication","id":"wait-for-replication"},{"level":2,"title":"Failover and High Availability","id":"failover-and-high-availability"},{"level":3,"title":"Automatic Failover","id":"automatic-failover"},{"level":3,"title":"Manual Promotion","id":"manual-promotion"},{"level":3,"title":"Failover Best Practices","id":"failover-best-practices"},{"level":2,"title":"Replica Management","id":"replica-management"},{"level":3,"title":"Scaling Replicas","id":"scaling-replicas"},{"level":4,"title":"Add More Replicas","id":"add-more-replicas"},{"level":4,"title":"Resize Replicas","id":"resize-replicas"},{"level":3,"title":"Removing Replicas","id":"removing-replicas"},{"level":3,"title":"Rebuilding Replicas","id":"rebuilding-replicas"},{"level":2,"title":"Performance Optimization","id":"performance-optimization"},{"level":3,"title":"Replica Resource Sizing","id":"replica-resource-sizing"},{"level":3,"title":"Query Routing","id":"query-routing"},{"level":3,"title":"Caching","id":"caching"},{"level":2,"title":"Monitoring and Alerts","id":"monitoring-and-alerts"},{"level":3,"title":"Key Metrics","id":"key-metrics"},{"level":3,"title":"Setting Up Alerts","id":"setting-up-alerts"},{"level":2,"title":"Backup and Disaster Recovery","id":"backup-and-disaster-recovery"},{"level":3,"title":"Backups","id":"backups"},{"level":3,"title":"Disaster Recovery via Replicas","id":"disaster-recovery-via-replicas"},{"level":3,"title":"Recovery Time Objective (RTO)","id":"recovery-time-objective-rto"},{"level":3,"title":"Recovery Point Objective (RPO)","id":"recovery-point-objective-rpo"},{"level":2,"title":"Best Practices","id":"best-practices"},{"level":3,"title":"Application Design","id":"application-design"},{"level":3,"title":"Scaling Strategy","id":"scaling-strategy"},{"level":3,"title":"Cost Optimization","id":"cost-optimization"},{"level":2,"title":"Troubleshooting","id":"troubleshooting"},{"level":3,"title":"High Replication Lag","id":"high-replication-lag"},{"level":3,"title":"Replica Connection Errors","id":"replica-connection-errors"},{"level":3,"title":"Replica Out of Sync","id":"replica-out-of-sync"},{"level":2,"title":"Related Documentation","id":"related-documentation"}],"format":"markdown","word_count":2225,"content":"# Database Replicas\n\nDatabase replicas provide high availability, improved read performance, and disaster recovery capabilities for your managed databases. DanubeData makes it easy to create and manage read replicas for PostgreSQL, MySQL, and MariaDB databases.\n\n## Overview\n\nA database replica is a read-only copy of your primary database that automatically synchronizes data from the primary. Replicas can be used to:\n\n- **Scale Read Operations**: Distribute read queries across multiple replicas\n- **High Availability**: Automatic failover to replica if primary fails\n- **Disaster Recovery**: Maintain a standby database in case of a primary host failure\n- **Load Balancing**: Distribute reads across replicas via the reader endpoint\n- **Reporting and Analytics**: Run heavy queries without impacting production\n\n## How Replicas Work\n\n### Replication Architecture\n\n```\n┌─────────────┐        Async Replication        ┌─────────────┐\n│   Primary   │ ──────────────────────────────> │   Replica   │\n│  (Read/Write)│                                  │ (Read-Only) │\n└─────────────┘                                  └─────────────┘\n       │                                                  │\n       │                                                  │\n   Write Traffic                                    Read Traffic\n```\n\n### Replication Process\n\n1. **Write to Primary**: All write operations (INSERT, UPDATE, DELETE) go to primary\n2. **Binary Log**: Primary records changes in binary log (binlog)\n3. **Replication Stream**: Changes are streamed to replica\n4. **Apply Changes**: Replica applies changes to maintain synchronization\n5. **Read from Replica**: Applications can read from replica\n\n### Replication Lag\n\nReplicas are updated asynchronously, which means there can be a delay between primary and replica:\n\n- **Typical Lag**: < 1 second under normal load\n- **High Load**: Lag can increase during heavy write operations\n- **Monitoring**: Replication lag is monitored and displayed in dashboard\n- **Automatic Catch-Up**: Replicas automatically catch up when lag occurs\n\n## Creating a Replica\n\n### Prerequisites\n\n- An existing managed database (PostgreSQL, MySQL, or MariaDB)\n- Database must be in a healthy state\n- Sufficient account resources for additional instance\n\n### Via Dashboard\n\n1. Navigate to your database instance\n2. Click the **Replicas** tab\n3. Click **Create Replica**\n4. Configure replica settings:\n   - **Replica Name**: Descriptive name for the replica\n   - **Node**: Same or different host within the datacenter\n   - **Resource Profile**: Can match or differ from primary\n5. Click **Create Replica**\n\nThe replica will be created within 5-10 minutes. Initial synchronization time depends on database size.\n\n### Replica Configuration\n\n#### Replica Placement\n\nAll replicas run on a separate host within the same datacenter as the primary. Best for:\n- Load balancing read traffic\n- High availability via hardware isolation from the primary\n- Minimal replication lag\n\n## Connecting to Replicas\n\n### Connection Details\n\nEach replica has its own connection endpoint:\n\n```\nPrimary: db-primary-123456.danubedata.ro:5432\nReplica 1: db-replica-123456-01.danubedata.ro:5432\nReplica 2: db-replica-123456-02.danubedata.ro:5432\n```\n\n### Read-Only Access\n\nReplicas are read-only. Write operations will fail:\n\n```sql\n-- This works on replicas\nSELECT * FROM users WHERE status = 'active';\n\n-- This will fail on replicas\nINSERT INTO users (name, email) VALUES ('John', 'john@example.com');\n-- ERROR: cannot execute INSERT in a read-only transaction\n```\n\n### Application Configuration\n\n#### Direct Connection\n\nConfigure separate read and write connections:\n\n```php\n// PHP Example with Laravel\nreturn [\n    'database' => [\n        'connections' => [\n            'mysql' => [\n                'read' => [\n                    'host' => [\n                        'db-replica-123456-01.danubedata.ro',\n                        'db-replica-123456-02.danubedata.ro',\n                    ],\n                ],\n                'write' => [\n                    'host' => [\n                        'db-primary-123456.danubedata.ro',\n                    ],\n                ],\n                'port' => 3306,\n                'database' => 'myapp',\n                'username' => 'dbuser',\n                'password' => 'password',\n            ],\n        ],\n    ],\n];\n```\n\n#### Python Example\n\n```python\nfrom sqlalchemy import create_engine\n\n# Primary connection for writes\nprimary_engine = create_engine(\n    'postgresql://user:pass@db-primary-123456.danubedata.ro:5432/mydb'\n)\n\n# Replica connection for reads\nreplica_engine = create_engine(\n    'postgresql://user:pass@db-replica-123456-01.danubedata.ro:5432/mydb'\n)\n\n# Use primary for writes\nwith primary_engine.connect() as conn:\n    conn.execute(\"INSERT INTO users (name) VALUES ('John')\")\n\n# Use replica for reads\nwith replica_engine.connect() as conn:\n    result = conn.execute(\"SELECT * FROM users\")\n```\n\n#### Node.js Example\n\n```javascript\nconst { Pool } = require('pg');\n\n// Primary pool for writes\nconst primaryPool = new Pool({\n  host: 'db-primary-123456.danubedata.ro',\n  port: 5432,\n  database: 'mydb',\n  user: 'dbuser',\n  password: 'password',\n  max: 20,\n});\n\n// Replica pool for reads\nconst replicaPool = new Pool({\n  host: 'db-replica-123456-01.danubedata.ro',\n  port: 5432,\n  database: 'mydb',\n  user: 'dbuser',\n  password: 'password',\n  max: 20,\n});\n\n// Write to primary\nasync function createUser(name) {\n  const result = await primaryPool.query(\n    'INSERT INTO users (name) VALUES ($1) RETURNING *',\n    [name]\n  );\n  return result.rows[0];\n}\n\n// Read from replica\nasync function getUsers() {\n  const result = await replicaPool.query('SELECT * FROM users');\n  return result.rows;\n}\n```\n\n### SSL/TLS Connections to Replicas\n\n**Important:** All database replicas support SSL/TLS connections using the same certificates as the master database. SSL certificates are automatically provisioned to your VPS instances in `/etc/database-certs/`.\n\n#### MySQL/MariaDB with SSL\n\n**Command Line:**\n```bash\n# Connect to specific replica with SSL\nmysql -h mysql-db-replica-1.namespace.svc.cluster.local \\\n  -u root -p \\\n  --ssl-ca=/etc/database-certs/mysql-db-ca.pem \\\n  --ssl-cert=/etc/database-certs/mysql-db-client-cert.pem \\\n  --ssl-key=/etc/database-certs/mysql-db-client-key.pem\n\n# Connect to reader endpoint (load-balanced across all replicas)\nmysql -h mysql-db-read.namespace.svc.cluster.local \\\n  -u root -p \\\n  --ssl-ca=/etc/database-certs/mysql-db-ca.pem \\\n  --ssl-cert=/etc/database-certs/mysql-db-client-cert.pem \\\n  --ssl-key=/etc/database-certs/mysql-db-client-key.pem\n```\n\n**PHP (PDO):**\n```php\n// Connect to reader endpoint with SSL\n$dsn = \"mysql:host=mysql-db-read.namespace.svc.cluster.local;port=3306;dbname=mydb\";\n$options = [\n    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,\n    PDO::MYSQL_ATTR_SSL_CA => '/etc/database-certs/mysql-db-ca.pem',\n    PDO::MYSQL_ATTR_SSL_CERT => '/etc/database-certs/mysql-db-client-cert.pem',\n    PDO::MYSQL_ATTR_SSL_KEY => '/etc/database-certs/mysql-db-client-key.pem',\n    PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true,\n];\n$pdo = new PDO($dsn, 'root', $password, $options);\n```\n\n#### PostgreSQL with SSL\n\n**Command Line:**\n```bash\n# Connect to specific replica with SSL\npsql \"postgresql://postgres:password@postgresql-db-replica-1.namespace.svc.cluster.local:5432/mydb?sslmode=verify-ca&sslrootcert=/etc/database-certs/postgresql-db-ca.pem&sslcert=/etc/database-certs/postgresql-db-client-cert.pem&sslkey=/etc/database-certs/postgresql-db-client-key.pem\"\n\n# Connect to reader endpoint (load-balanced across all replicas)\npsql \"postgresql://postgres:password@postgresql-db-read.namespace.svc.cluster.local:5432/mydb?sslmode=verify-ca&sslrootcert=/etc/database-certs/postgresql-db-ca.pem\"\n```\n\n**Python (psycopg2):**\n```python\nimport psycopg2\n\n# Connect to reader endpoint with SSL\nconn = psycopg2.connect(\n    host='postgresql-db-read.namespace.svc.cluster.local',\n    port=5432,\n    user='postgres',\n    password='password',\n    database='mydb',\n    sslmode='verify-ca',\n    sslrootcert='/etc/database-certs/postgresql-db-ca.pem',\n    sslcert='/etc/database-certs/postgresql-db-client-cert.pem',\n    sslkey='/etc/database-certs/postgresql-db-client-key.pem'\n)\n```\n\n**Node.js (pg):**\n```javascript\nconst { Pool } = require('pg');\nconst fs = require('fs');\n\n// Replica pool with SSL\nconst replicaPool = new Pool({\n  host: 'postgresql-db-read.namespace.svc.cluster.local',\n  port: 5432,\n  user: 'postgres',\n  password: 'password',\n  database: 'mydb',\n  ssl: {\n    ca: fs.readFileSync('/etc/database-certs/postgresql-db-ca.pem').toString(),\n    cert: fs.readFileSync('/etc/database-certs/postgresql-db-client-cert.pem').toString(),\n    key: fs.readFileSync('/etc/database-certs/postgresql-db-client-key.pem').toString()\n  }\n});\n```\n\n**Key Points:**\n- Replicas use the same SSL certificates as the master database\n- Certificate files are automatically provisioned to VPS instances at `/etc/database-certs/{database-name}-*.pem`\n- Both individual replica endpoints and the reader endpoint (load-balanced) support SSL\n- Full certificate verification is enabled by default for maximum security\n- Master-replica replication traffic is unencrypted (internal cluster communication only)\n\n## Load Balancing Across Replicas\n\n### Round-Robin\n\nDistribute reads evenly across multiple replicas:\n\n```python\nimport random\n\nreplicas = [\n    'db-replica-123456-01.danubedata.ro',\n    'db-replica-123456-02.danubedata.ro',\n    'db-replica-123456-03.danubedata.ro',\n]\n\ndef get_replica_host():\n    return random.choice(replicas)\n\n# Use for read queries\nreplica_host = get_replica_host()\n```\n\n### Health-Based Routing\n\nRoute to healthy replicas only:\n\n```python\nhealthy_replicas = []\n\nfor replica in replicas:\n    if check_replica_health(replica):\n        healthy_replicas.append(replica)\n\nif healthy_replicas:\n    replica_host = random.choice(healthy_replicas)\nelse:\n    # Fallback to primary\n    replica_host = primary_host\n```\n\n### Connection Pooling\n\nUse connection pooling to manage multiple replica connections efficiently:\n\n- Maintain separate pools for primary and replicas\n- Set appropriate pool sizes based on workload\n- Configure connection timeouts and retry logic\n- Monitor pool utilization\n\n## Managing Replication Lag\n\n### Monitoring Lag\n\nCheck replication lag in the dashboard or via SQL:\n\n#### PostgreSQL\n\n```sql\n-- On primary\nSELECT \n    client_addr as replica_ip,\n    state,\n    sent_lsn,\n    write_lsn,\n    flush_lsn,\n    replay_lsn,\n    sync_state,\n    EXTRACT(EPOCH FROM (NOW() - pg_last_xact_replay_timestamp())) as lag_seconds\nFROM pg_stat_replication;\n```\n\n#### MySQL/MariaDB\n\n```sql\n-- On replica\nSHOW SLAVE STATUS\\G\n\n-- Look for:\n-- Seconds_Behind_Master: 0 (or higher if lagging)\n```\n\n### Handling Lag in Applications\n\n#### Read-After-Write Consistency\n\nFor critical reads after writes, read from primary:\n\n```php\n// Write to primary\nDB::connection('mysql')->table('users')->insert([\n    'name' => 'John Doe',\n    'email' => 'john@example.com',\n]);\n\n// Read from primary immediately after write\n$user = DB::connection('mysql')->table('users')\n    ->where('email', 'john@example.com')\n    ->first();\n\n// Later reads can use replica\n$users = DB::connection('mysql_replica')->table('users')->get();\n```\n\n#### Eventual Consistency\n\nFor non-critical reads, accept eventual consistency:\n\n```php\n// Write to primary\ncreateUser($userData);\n\n// Read from replica (may not include just-created user yet)\n$users = getUsersFromReplica();\n```\n\n#### Wait for Replication\n\nSome frameworks support waiting for replication:\n\n```python\n# Django example\nfrom django.db import transaction\n\nwith transaction.atomic():\n    user = User.objects.create(name='John')\n    \n# Wait for replication before reading\ntime.sleep(0.1)  # Small delay to allow replication\nusers = User.objects.using('replica').all()\n```\n\n## Failover and High Availability\n\n### Automatic Failover\n\nWhen enabled, automatic failover provides high availability:\n\n1. **Health Monitoring**: System continuously monitors primary health\n2. **Failure Detection**: Primary failure detected within 45 seconds\n3. **Promotion**: Replica automatically promoted to primary\n4. **DNS Update**: Connection endpoint updated to point to new primary\n5. **Application Reconnect**: Applications reconnect to new primary\n\n### Manual Promotion\n\nPromote a replica to primary manually:\n\n1. Navigate to database in dashboard\n2. Click **Replicas** tab\n3. Select replica to promote\n4. Click **Promote to Primary**\n5. Confirm promotion\n\n> **Warning**: Promoting a replica to primary will make the old primary a replica (if still healthy) or detach it if unhealthy.\n\n### Failover Best Practices\n\n- **Enable automatic failover** for production databases\n- **Configure application retries** to handle temporary connection failures\n- **Monitor replication lag** to ensure replicas are up-to-date\n- **Test failover** in staging environment before production\n- **Set up alerts** for failover events\n\n## Replica Management\n\n### Scaling Replicas\n\n#### Add More Replicas\n\nScale read capacity by adding more replicas:\n\n1. Create additional replicas as needed\n2. Update application configuration\n3. Distribute read traffic across all replicas\n\n#### Resize Replicas\n\nChange replica resource profile:\n\n1. Navigate to replica in dashboard\n2. Click **Resize**\n3. Select new profile\n4. Confirm resize\n\nReplicas can have different profiles than primary.\n\n### Removing Replicas\n\nDelete replicas when no longer needed:\n\n1. Navigate to replica in dashboard\n2. Click **Delete**\n3. Confirm deletion\n\n> **Note**: Deleting a replica does not affect the primary or other replicas.\n\n### Rebuilding Replicas\n\nIf a replica falls too far behind or has issues:\n\n1. Delete the problematic replica\n2. Create a new replica\n3. Initial sync will catch up to primary\n\n## Performance Optimization\n\n### Replica Resource Sizing\n\nSize replicas based on read workload:\n\n- **Light reads**: Smaller profile than primary\n- **Heavy reads**: Same or larger profile than primary\n- **Analytics**: Larger profile with more RAM for complex queries\n\n### Query Routing\n\nRoute queries intelligently:\n\n```python\nclass DatabaseRouter:\n    def db_for_read(self, model, **hints):\n        \"\"\"Route reads to replica\"\"\"\n        return 'replica'\n    \n    def db_for_write(self, model, **hints):\n        \"\"\"Route writes to primary\"\"\"\n        return 'default'\n```\n\n### Caching\n\nCombine replicas with caching:\n\n```python\ndef get_user(user_id):\n    # Check cache first\n    user = cache.get(f'user:{user_id}')\n    if user:\n        return user\n    \n    # Read from replica\n    user = User.objects.using('replica').get(id=user_id)\n    \n    # Cache for future reads\n    cache.set(f'user:{user_id}', user, timeout=300)\n    \n    return user\n```\n\n## Monitoring and Alerts\n\n### Key Metrics\n\nMonitor these metrics for replicas:\n\n- **Replication Lag**: Time difference between primary and replica\n- **Replica Health**: Overall replica status\n- **Connection Count**: Active connections to replica\n- **Query Performance**: Slow queries on replica\n- **Resource Usage**: CPU, RAM, disk I/O\n\n### Setting Up Alerts\n\nConfigure alerts for critical events:\n\n- Replication lag > 5 seconds\n- Replica disconnected\n- Replica storage > 80% full\n- High CPU usage (> 80%)\n- Failover events\n\n## Backup and Disaster Recovery\n\n### Backups\n\nBackups are taken from the primary database:\n\n- Replicas do not create separate backups\n- Restoring from backup creates a new primary\n- Replicas must be recreated after restoration\n\n### Disaster Recovery via Replicas\n\nUse replicas for host-level failover:\n\n1. Create a replica on a separate host\n2. Monitor replication health\n3. In case of primary host failure, promote replica to primary\n4. Update application DNS/configuration\n\n### Recovery Time Objective (RTO)\n\n- **Automatic failover**: ~1-2 minutes\n- **Manual promotion**: ~5 minutes\n- **Restore from backup**: 15-60 minutes (depending on size)\n\n### Recovery Point Objective (RPO)\n\n- **Synchronous replication**: 0 data loss (not supported)\n- **Asynchronous replication**: Minimal data loss (typically < 1 second)\n- **Backup restore**: Up to 24 hours (depending on backup schedule)\n\n## Best Practices\n\n### Application Design\n\n- **Separate read/write connections** in application configuration\n- **Handle replication lag** in application logic\n- **Implement connection retry logic** for failover scenarios\n- **Use read replicas for reporting** and analytics\n- **Monitor both primary and replicas** for performance issues\n\n### Scaling Strategy\n\n- **Start with one replica** for high availability\n- **Add more replicas** as read traffic grows\n- **Use the reader endpoint** to load-balance across replicas automatically\n- **Size replicas appropriately** based on workload\n- **Monitor and adjust** as traffic patterns change\n\n### Cost Optimization\n\n- **Delete unused replicas** to save costs\n- **Right-size replica profiles** to match workload\n- **Use smaller profiles** for replicas with light read traffic\n- **Consider replica placement** (same-region is cheaper)\n\n## Troubleshooting\n\n### High Replication Lag\n\n**Symptoms**: Replica falling behind primary\n\n**Causes**:\n- Heavy write load on primary\n- Slow network between primary and replica\n- Undersized replica resources\n- Long-running transactions\n\n**Solutions**:\n- Upgrade replica to larger profile\n- Optimize write queries on primary\n- Check network connectivity\n- Split large transactions into smaller ones\n\n### Replica Connection Errors\n\n**Symptoms**: Cannot connect to replica\n\n**Solutions**:\n- Check replica status in dashboard\n- Verify connection details\n- Check firewall rules\n- Ensure SSL/TLS configuration is correct\n- Test with mysql/psql CLI client\n\n### Replica Out of Sync\n\n**Symptoms**: Data inconsistencies between primary and replica\n\n**Solutions**:\n- Check replication status\n- Review replication logs\n- Rebuild replica if necessary\n- Contact support if issue persists\n\n## Related Documentation\n\n- [PostgreSQL](https://docs.danubedata.ro/databases-postgresql)\n- [MySQL](https://docs.danubedata.ro/databases-mysql)\n- [MariaDB](https://docs.danubedata.ro/databases-mariadb)\n- [Database Overview](https://docs.danubedata.ro/databases-overview)\n- [Database Backups](https://docs.danubedata.ro/databases-backups)\n- [Monitoring Overview](https://docs.danubedata.ro/monitoring-overview)\n\n","prev":{"title":"MariaDB","slug":"databases-mariadb","url":"https://docs.danubedata.ro/databases-mariadb","markdown_url":"https://docs.danubedata.ro/databases-mariadb.md","json_url":"https://docs.danubedata.ro/databases-mariadb.json"},"next":{"title":"Backups","slug":"databases-backups","url":"https://docs.danubedata.ro/databases-backups","markdown_url":"https://docs.danubedata.ro/databases-backups.md","json_url":"https://docs.danubedata.ro/databases-backups.json"},"index_url":"https://docs.danubedata.ro/index.json"}