# Exoscale Documentation — Thanos > Managed Thanos: fully managed, high-availability Prometheus long-term storage and global query, ingesting metrics via Prometheus remote write. --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/ --- # Thanos Thanos extends Prometheus for long-term storage, global querying, and high availability, enabling scalable and resilient monitoring. - [Quick Start - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/quick-start/index.md) - Get started quickly with a guided setup to achieve your first successful use of the service, including the required steps and configuration. - [Overview - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/overview/index.md) - Terminology and key features at a glance, learn the core concepts, capabilities, and options of this service before you dive deeper. - [How-To - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/index.md) - Step-by-step guides to configure the service and use specific features, with clear instructions for common tasks and problem solving. - [Service Boundaries - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/service-boundaries/index.md) - Service boundaries: quotas, limits, and the guaranteed service levels (SLA) for this product, including key constraints to plan and operate reliably. - [Reference - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/reference/index.md) - Reference documentation for API, CLI, and tools, browse comprehensive details, parameters, commands, and integration notes. --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/quick-start/ --- # Quick Start - Thanos ## Specific Options for Thanos You can find all the specific options for Thanos by using the CLI help: ```bash exo dbaas create --help-thanos --thanos-ip-filter allow incoming connections from CIDR address block --thanos-settings Thanos configuration settings (JSON format) ``` ## Additional Configuration You can list all settings available for the database service by using the command: ```bash exo dbaas type show thanos --settings thanos ``` Output: ```bash ┼────────────────┼────────┼──────────────────────────────────────────────────┼ │ KEY │ TYPE │ DESCRIPTION │ ┼────────────────┼────────┼──────────────────────────────────────────────────┼ │ compactor │ object │ Configuration options for Thanos Compactor. │ │ query │ object │ Configuration options for Thanos Query. │ │ query-frontend │ object │ Configuration options for Thanos Query Frontend. │ ┼────────────────┼────────┼──────────────────────────────────────────────────┼ ``` ## Generic CLI Operations While Thanos-specific CLI commands are not available yet, you can use generic `exo x` commands for basic operations: ```bash # List all DBaaS services (including Thanos) exo x list-dbaas-services --zone ch-dk-2 # View service metrics echo '{"period":"hour"}' | exo x get-dbaas-service-metrics my-thanos --zone ch-dk-2 # View service logs echo '{"limit":10}' | exo x get-dbaas-service-logs my-thanos --zone ch-dk-2 # Delete a service exo x delete-dbaas-service my-thanos --zone ch-dk-2 ``` ## Service Integrations Once your Thanos service is running, you can connect it with other Exoscale services: - **Prometheus Instances**: Configure Prometheus remote write to send metrics to Thanos Receivers - **Grafana**: Integrate with Exoscale Managed Grafana or external Grafana instances for visualization - **OpenSearch**: Forward metrics to OpenSearch for advanced querying See the [How-To Guide](/product/dbaas/service-specific/thanos/how-to/index.md) for integration examples and connection details. ## Next Steps - [Configure Prometheus remote write](/product/dbaas/service-specific/thanos/how-to/prom-to-thanos/index.md) to send metrics to Thanos - [Connect Grafana](/product/dbaas/service-specific/thanos/how-to/integ-grafana/index.md) to query and visualize your metrics --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/overview/ --- # Overview - Thanos Exoscale **Managed Thanos** delivers a fully managed, high-availability deployment of the popular Prometheus long-term storage and global query solution. The service simplifies the management of large-scale metrics systems, allowing teams to focus on deriving insights from their data rather than operating complex infrastructure. It is designed for organizations that need scalable, cost-effective metric storage and querying across multiple Prometheus instances. ## Terminology - **Service** a running Thanos cluster managed by Exoscale DBaaS - **Plan** a sizing tier based on the number of Prometheus clusters to connect - **[Query](https://thanos.io/tip/components/query.md/)** component that aggregates and queries metrics from both real-time receivers and historical storage - **[Query Frontend](https://thanos.io/tip/components/query-frontend.md/)** caches query results and splits large queries into smaller sub-queries for efficient execution - **[Receiver](https://thanos.io/tip/components/receive.md/)** handles metrics ingestion via Prometheus remote write, collecting data in real-time - **[Store Gateway](https://thanos.io/tip/components/store.md/)** interfaces with object storage to provide access to historical metrics data - **[Compactor](https://thanos.io/tip/components/compact.md/)** downsamples and compacts metrics in object storage to optimize storage usage and query performance ## Features - **Managed Cluster Lifecycle** automated provisioning, patching and minor-version upgrades - **Unlimited Metric Retention** cost-effective long-term storage using object storage with automatic compaction - **Global Query View** query metrics across multiple Prometheus instances through a unified interface - **Prometheus Compatibility** fully compatible with Prometheus and standard tooling like Grafana - **Automatic Downsampling** reduces storage needs and improves query performance for historical data - **Query Caching** Query Frontend caches results to accelerate repeated and similar queries - **High Availability** deduplication across receivers ensures consistent data despite multiple collection points - **High SLA** 99.95 % on Startup, 99.99 % on Business plans - **Portal, CLI & API Access** manage services via [Exoscale Portal](https://portal.exoscale.com/), [REST API](https://community.exoscale.com/reference/api/dbaas/dbaas-thanos/index.md) and CLI ## Architecture Thanos combines multiple components into a unified cluster architecture with seamless data flow: - **Data Collection & Storage** Receivers ingest metrics in real-time via Prometheus remote write. After each Time Series Database (TSDB) block completes (typically every 2 hours), data is uploaded to object storage for long-term retention. - **Query Processing** The Query Frontend receives requests and forwards them to Query components, which retrieve real-time data from Receivers or historical data from the Store Gateway. Duplicate samples from multiple receivers are automatically removed to maintain data integrity. Query results are cached by the Query Frontend to accelerate subsequent requests. - **Storage Optimization** The Compactor runs in the background to downsample and compact historical data, reducing storage costs and improving query performance for older metrics. ## Plans ### Startup Plans (Single Node) Best for development, testing, or smaller production workloads. SLA: 99.95% | Plan | vCPU | RAM | Storage | Price | | ------ | ------ | ----- | --------- | ------- | | `startup-4` | 2 | 4 GB | 160 GB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `startup-8` | 4 | 8 GB | 320 GB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `startup-16` | 4 | 16 GB | 640 GB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `startup-32` | 8 | 32 GB | 1.28 TB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `startup-64` | 12 | 64 GB | 2.56 TB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | ### Business Plans (3-Node HA Cluster) For production workloads requiring high availability. SLA: 99.99% | Plan | vCPU/node | RAM/node | Storage (total) | Price | | ------ | ----------- | ---------- | ----------------- | ------- | | `business-4` | 2 | 4 GB | 480 GB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `business-8` | 4 | 8 GB | 960 GB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `business-16` | 4 | 16 GB | 1.92 TB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `business-32` | 8 | 32 GB | 3.84 TB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | | `business-64` | 12 | 64 GB | 7.68 TB | [See pricing](https://www.exoscale.com/pricing/#dbaas) | > For detailed configuration options, see the [Reference](/product/dbaas/service-specific/thanos/reference/index.md) section. ## Quick Links ### Exoscale Resources - [Exoscale Portal](https://portal.exoscale.com/) - Create and manage Thanos services - [REST API Documentation](https://community.exoscale.com/reference/api/dbaas/dbaas-thanos/index.md) - Full API reference - [Pricing](https://www.exoscale.com/pricing/#dbaas) - Current plan pricing ### Exoscale DBaaS General - [Backups and Restore](/product/dbaas/how-to/backups-restore/index.md) - [Maintenance Windows](/product/dbaas/how-to/maintenance-windows/index.md) - [Scaling Services](/product/dbaas/how-to/scaling/index.md) - [External Integrations](/product/dbaas/how-to/external-integrations/index.md) ### Thanos Service - [Retention Rules & Downsampling](/product/dbaas/service-specific/thanos/how-to/index.md) - Data retention and downsampling configuration ### External Resources - [Thanos Project](https://thanos.io/) - Official Thanos documentation - [Aiven for Metrics](https://aiven.io/docs/products/metrics) - Underlying platform documentation - [PromQL](https://prometheus.io/docs/prometheus/latest/querying/basics/) - Query language reference --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/ --- # How-To - Thanos Step-by-step guides to configure the service and use specific features, with clear instructions for common tasks and problem solving. - [Add Resources](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/add-resources/index.md) - Find documentation for scaling Managed Thanos resources, including Aiven concepts, storage planning, and external Thanos references. - [Backups](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/backups/index.md) - Learn about automatic daily backups for Managed Thanos services and where to find general backup and restore procedures. - [Deploy Prometheus to Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/prom-to-thanos/index.md) - Deploy Prometheus Operator and Agent on SKS to remote-write metrics to Managed Thanos and visualize them in Grafana. - [Integrate Grafana](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/integ-grafana/index.md) - Connect Exoscale Managed Grafana or external Grafana to Thanos, create a Prometheus data source, and build dashboards. - [Maintenance](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/maintenance/index.md) - Learn how Managed Thanos uses weekly maintenance windows for patches and minor-version upgrades, and where to configure them. - [Manage Lifecycle](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/lifecycle/index.md) - Learn Thanos service states and how to scale plans via the portal, API, or CLI with minimal interruption. - [Retention and Downsampling](https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/retention-downsampling/index.md) - Set Thanos retention via API and learn how automatic downsampling improves query performance for older metrics data. --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/add-resources/ --- # Add Resources ## Aiven Documentation Exoscale Managed Thanos is powered by Aiven. For platform-specific concepts, refer to the Aiven for Metrics documentation: - [Aiven for Metrics Overview](https://aiven.io/docs/products/metrics) - Architecture and core concepts - [Storage and Resource Scaling](https://aiven.io/docs/products/metrics/concepts/storage-resource-scaling) - Storage architecture and capacity planning > [!NOTE] > Some Aiven-specific features or interfaces (Console, billing model, Dynamic Disk Sizing) may differ or not be available on Exoscale. --- ## External Resources - [Thanos Project](https://thanos.io/) - Official Thanos documentation - [Prometheus Remote Write](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write) - Prometheus configuration reference - [Grafana Data Sources](https://grafana.com/docs/grafana/latest/datasources/prometheus/) - Grafana Prometheus integration - [PromQL](https://prometheus.io/docs/prometheus/latest/querying/basics/) - Query language reference --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/backups/ --- # Backups Thanos services include automatic daily backups depending on your plan. | Plan Type | Backup Interval | Recovery Mode | | ----------- | ----------------- | --------------- | | Startup | 24 hours | Basic | | Business | 24 hours | Basic | For general backup and restore procedures, see [Backups and Restore](/product/dbaas/how-to/backups-restore/index.md). --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/prom-to-thanos/ --- # Deploy Prometheus to Thanos ## Prerequisites - Deploy your SKS (Exoscale Kubernetes Managed Cluster) - Install [kubectl](https://kubernetes.io/docs/tasks/tools/#kubectl) and jq - Check you can access your cluster with kubectl (`kubectl get pods -A`) ## Deploying Prometheus on your SKS Cluster To deploy Prometheus, two components are needed: Prometheus Operator and Prometheus Agent. ### Deploy Prometheus Operator and Agent Copy below script into a file deploy-quick.sh > [!NOTE] > - After script copy, please change the values in **Create Thanos secret** to set your Thanos `Receiver remote-write URI` and user password to access the receiver. > - The URL you will use should look like: > `https://yyyyyy-exoscale-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.i.aivencloud.com:21706` > - The namespace used to deploy Prometheus is `monitoring`, you can change in the script. > -This example is a configuration proposal; you can adjust it as needed. ``` #!/bin/bash NAMESPACE=monitoring kubectl create namespace $NAMESPACE || true TMPDIR=$(mktemp -d) LATEST=$(curl -s https://api.github.com/repos/prometheus-operator/prometheus-operator/releases/latest | jq -cr .tag_name) curl -s "https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/refs/tags/$LATEST/bundle.yaml" > "$TMPDIR/bundle.yaml" # macOS: sed -i '' / Linux: sed -i sed -i'' "s/namespace: default/namespace: $NAMESPACE/g" "$TMPDIR/bundle.yaml" kubectl apply --server-side -f "$TMPDIR/bundle.yaml" kubectl apply -f - <<'CRDEOF' apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: name: prometheusagents.monitoring.coreos.com spec: group: monitoring.coreos.com scope: Namespaced names: kind: PrometheusAgent plural: prometheusagents versions: - name: v1alpha1 served: true storage: true schema: openAPIV3Schema: type: object properties: apiVersion: type: string kind: type: string metadata: type: object spec: type: object x-kubernetes-preserve-unknown-fields: true status: type: object x-kubernetes-preserve-unknown-fields: true CRDEOF kubectl apply -f - <<'RBACEOF' --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: prometheus-operator-extra-perms rules: - apiGroups: ["monitoring.coreos.com"] resources: ["prometheusagents", "prometheusagents/status", "prometheuses", "prometheuses/status"] verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] - apiGroups: [""] resources: ["namespaces", "nodes", "nodes/metrics", "configmaps", "secrets", "pods", "services", "endpoints"] verbs: ["get", "list", "watch"] - apiGroups: ["monitoring.coreos.com"] resources: ["servicemonitors", "podmonitors", "probes", "prometheusrules"] verbs: ["get", "list", "watch"] - apiGroups: ["apps"] resources: ["statefulsets", "deployments"] verbs: ["get", "list", "watch", "create", "update", "patch", "delete"] - apiGroups: [""] resources: ["events"] verbs: ["get", "list", "watch", "create", "patch"] --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: prometheus-operator-extra-perms roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: prometheus-operator-extra-perms subjects: - kind: ServiceAccount name: prometheus-operator namespace: monitoring RBACEOF kubectl rollout restart deployment prometheus-operator -n monitoring 2>/dev/null || true # Create Thanos secret kubectl create secret generic thanos-credentials \ --from-literal=url="https://yyyyyy-exoscale-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.i.aivencloud.com:21706" \ --from-literal=username="avnadmin" \ --from-literal=password="MyThanosPassword" \ -n monitoring \ --dry-run=client -o yaml | kubectl apply -f - sleep 20 kubectl apply -f - <<'AGENTEOF' apiVersion: monitoring.coreos.com/v1alpha1 kind: PrometheusAgent metadata: name: prometheus-agent namespace: monitoring spec: replicas: 1 serviceAccountName: prometheus-operator scrapeInterval: 30s podMonitorSelector: matchLabels: {} probeSelector: matchLabels: {} serviceMonitorSelector: matchLabels: {} prometheusRulesSelector: matchLabels: {} resources: requests: cpu: 50m memory: 64Mi limits: cpu: 200m memory: 256Mi storage: emptyDir: {} retention: 1h walCompression: true remoteWrite: - url: https://yyyyyy-exoscale-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.i.aivencloud.com:21706/api/v1/receive basicAuth: username: name: thanos-credentials key: username password: name: thanos-credentials key: password writeRelabelConfigs: - sourceLabels: [__name__] regex: up|process_.*|go_.* action: keep AGENTEOF # Create ServiceMonitor to scrape prometheus-operator kubectl apply -f - <<'MONITORF' apiVersion: monitoring.coreos.com/v1 kind: ServiceMonitor metadata: name: prometheus-operator namespace: monitoring spec: selector: matchLabels: app.kubernetes.io/name: prometheus-operator endpoints: - port: http interval: 30s MONITORF ``` Then launch the script ``` chmod 755 deploy-quick.sh export KUBECONFIG=my_path/kubeconfig ./deploy-quick.sh ``` ### Check Prometheus services and pods ``` % kubectl get svc -n monitoring NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE prometheus-agent-operated ClusterIP None 9090/TCP 3h9m prometheus-operator ClusterIP None 8080/TCP 3h9m ``` ``` % kubectl get pods -n monitoring NAME READY STATUS RESTARTS AGE prom-agent-prometheus-agent-0 2/2 Running 0 3h15m prometheus-operator-5dfd576fc9-jdxhb 1/1 Running 0 3h3m ``` ``` % kubectl get prometheusagent -n monitoring NAME AGE prometheus-agent 3h17m ``` > [!NOTE] > Now Prometheus is working and pushing the metrics to your Thanos DBaaS. > You can now integrate it with Grafana to see your metrics: > [Integrate with Grafana](/product/dbaas/service-specific/thanos/how-to/integ-grafana/index.md) --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/integ-grafana/ --- # Integrate Grafana Connect Exoscale Managed Grafana (or external Grafana) to query metrics from Thanos. ## Create your Data Source Connect to your Grafana Dashboard. > [!NOTE] > If you have an issue accessing it, verify on the Exoscale Console in your DBaaS Grafana Config > that you have an IP filter set (like 0.0.0.0/0 if you want it open to all IPs). In the Menu, go to Connections > Data sources Add new data source (on the top right) Choose Prometheus Click on Prometheus and configure it ![](grafana-thanos-datasource.png "Thanos datasource creation") > [!NOTE] > - Add your Data source name, here "Prometheus" > - Add your Prometheus server URL : `https://yyyyyy-exoscale-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.i.aivencloud.com:21700` > - Add your Basic Authentication with User and Password > - Then click on Save and test ## Create your Dashboard Just click on "Create dashboard" in Dashboards section and select your newly created Datasource. Then explore your metrics for your board. ![](grafana-create-dashboard.png) --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/maintenance/ --- # Maintenance Thanos services follow the standard DBaaS maintenance process. A weekly maintenance window is used to apply patches and minor-version upgrades. For details on configuring maintenance windows, see [Maintenance Windows](/product/dbaas/how-to/maintenance-windows/index.md). --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/lifecycle/ --- # Manage Lifecycle ## Service States Your Thanos service can be in the following states: | State | Description | | ------- | ------------- | | **Building** | Service is being provisioned | | **Running** | Service is operational and accepting connections | | **Rebuilding** | Service is being updated or scaled | | **Poweroff** | Service is stopped | ## Scaling Change your Thanos plan to scale resources up or down: 1. **Via [Portal](https://portal.exoscale.com/)**: DBaaS > Your Service > Change Plan 2. **Via [API](https://community.exoscale.com/reference/api/dbaas/dbaas-thanos/index.md)**: `PUT /dbaas-thanos/{name}` with new `plan` value 3. **Via CLI** Available plans range from `startup-4` to `business-64`. See [Overview](/product/dbaas/service-specific/thanos/overview/index.md) for plan details. > [!NOTE] > Scaling may cause brief service interruptions. Plan changes on Business plans benefit from high availability to minimize downtime. --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/how-to/retention-downsampling/ --- # Retention and Downsampling ## Retention Rules Retention rules define how long metrics data is stored. By default, **data is retained indefinitely**. The Thanos [Compactor](https://thanos.io/tip/components/compact.md/#enforcing-retention-of-data) manages retention through a single parameter: `compactor.retention.days`. This setting applies uniformly to all data resolutions: - Raw metrics - 5-minute downsampled data - 1-hour downsampled data ### Configure Retention via API > [!NOTE] > Retention configuration is currently only available via the REST API. The Exoscale Portal does not support this feature. Use the [Update Thanos Service API](https://community.exoscale.com/reference/api/dbaas/dbaas-thanos/index.md) to set the `compactor.retention.days` parameter: ```bash curl -X PUT "https://api-{zone}.exoscale.com/v2/dbaas-thanos/{service-name}" \ -H "Content-Type: application/json" \ -d '{ "thanos-settings": { "compactor.retention.days": 90 } }' ``` ### Retention Considerations - **Cost**: Longer retention periods increase storage costs - **Compliance**: Some regulations require specific retention periods - **Query performance**: Downsampled data (5-min and 1-hour intervals) improves query performance for older data --- ## Downsampling Thanos automatically [downsamples](https://thanos.io/tip/components/compact.md/#downsampling) metrics data to optimize query performance over large time ranges. The Compactor creates downsampled blocks based on the age of the data: - Raw metrics older than **40 hours** are downsampled to **5-minute** resolution - Metrics older than **10 days** are downsampled to **1-hour** resolution | Resolution | Description | Created After | Use Case | | --- | --- | --- | --- | | Raw | Original metric resolution | — | Recent data, detailed analysis | | 5-minute | Aggregated every 5 minutes | 40 hours | Medium-term queries | | 1-hour | Aggregated every hour | 10 days | Long-term trends, dashboards | Downsampling preserves essential aggregations (min, max, sum, count) to enable fast queries across months or years of data. > [!NOTE] > Downsampled blocks are stored alongside raw data, not in place of it. Reducing storage requires configuring [retention rules](#retention-rules). See the [official Thanos documentation](https://thanos.io/tip/components/compact.md/#-downsampling-note-about-resolution-and-retention-) for details on how retention interacts with downsampling. --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/service-boundaries/ --- # Service Boundaries - Thanos - [Limits and Quotas - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/service-boundaries/limits-and-quotas/index.md) - Managed Thanos Limitations and Quotas - [SLA - Thanos](https://community.exoscale.com/product/dbaas/service-specific/thanos/service-boundaries/sla/index.md) - Managed Thanos Service Level Agreement - [Pricing ↗︎](https://www.exoscale.com/pricing/#managed-thanos) --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/service-boundaries/limits-and-quotas/ --- # Limits and Quotas - Thanos ## Limits - **No Terraform Provider** Exoscale Terraform provider doesn't support Thanos yet - **No External Thanos Access** cannot connect Exoscale-managed services to external (non-Exoscale) Thanos endpoints; must use Exoscale Managed Thanos for integrations - **Single-Zone Clusters** services run within a single zone; cross-zone replication is not currently available Service Plans Restrictions : Access to certain plans (e.g., Business, Premium) requires activation by the support team. Requests can be made during service creation. Service Plans Restrictions : Access to certain plans (e.g., Business, Premium) requires activation by the support team. Requests can be made during service creation. ## Quotas | Usage | Quota | | -------------------------------------------------------- | ------------------------ | | DBaaS services overall | 10 | ## Availability Managed Thanos is available in all zones. --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/service-boundaries/sla/ --- # SLA - Thanos Refere to the overall [DBaaS SLA](https://community.exoscale.com/product/dbaas/service-boundaries/sla/index.md). --- url: https://community.exoscale.com/product/dbaas/service-specific/thanos/reference/ --- # Reference - Thanos - [API DBaaS](https://community.exoscale.com/reference/api/dbaas/dbaas-thanos/index.md) - All operations on DBaaS. (external) - [CLI DBaaS](https://community.exoscale.com/reference/cli/exo/dbaas/index.md) - All commands on DBaaS. (external)