Schweitzer Fachinformationen
Wenn es um professionelles Wissen geht, ist Schweitzer Fachinformationen wegweisend. Kunden aus Recht und Beratung sowie Unternehmen, öffentliche Verwaltungen und Bibliotheken erhalten komplette Lösungen zum Beschaffen, Verwalten und Nutzen von digitalen und gedruckten Medien.
Bitte beachten Sie
Von Mittwoch, dem 12.11.2025 ab 23:00 Uhr bis Donnerstag, dem 13.11.2025 bis 07:00 Uhr finden Wartungsarbeiten bei unserem externen E-Book Dienstleister statt. Daher bitten wir Sie Ihre E-Book Bestellung außerhalb dieses Zeitraums durchzuführen. Wir bitten um Ihr Verständnis. Bei Problemen und Rückfragen kontaktieren Sie gerne unseren Schweitzer Fachinformationen E-Book Support.
"Architecting High-Scale Metrics with Thanos" "Architecting High-Scale Metrics with Thanos" is an authoritative guide to designing, deploying, and scaling modern metrics architectures using Thanos and Prometheus. The book opens with a rigorous exploration of distributed metrics systems, dissecting the evolution from monolithic solutions to cloud-native, highly dynamic environments. Readers will gain deep insight into the unique challenges of time-series data, the interplay between metrics, logs, and traces, and the operational complexities of high cardinality, security, and rapid service discovery. Each foundational concept is carefully unpacked to prepare readers for architecting robust observability solutions in today's rapidly changing infrastructures. Central to this work is a comprehensive treatment of Thanos itself, including its component architecture, deployment topologies, and the motivations for its adoption in environments demanding high scalability, availability, and cost-efficiency. The book provides clear guidance on Prometheus's limitations at scale, and systematically demonstrates how Thanos extends Prometheus with global querying, long-term object storage, deduplication, and advanced aggregation. Chapters on deploying and operating Thanos offer best practices for Kubernetes-native environments, zero-downtime migrations, cost optimization, and multi-tenancy-equipping engineering teams with real-world strategies for resilient, future-proof observability. Finally, the text offers advanced chapters on securing and automating large Thanos deployments, integrating with a diverse observability ecosystem, and innovating with emerging trends. Topics such as machine learning for anomaly detection, AI-driven retention policies, edge and IoT architectures, cross-cloud observability, and OpenTelemetry integration ensure the book remains at the forefront of the field. Whether you are an engineer, DevOps practitioner, or architect, "Architecting High-Scale Metrics with Thanos" delivers the rigorous technical depth and proven methodologies essential for mastering observability at enterprise scale.
Prometheus has become synonymous with cloud-native monitoring, yet its architecture is not without boundaries-especially when confronting the relentless growth in scale, complexity, and availability demanded by modern infrastructure. This chapter dissects the inner mechanics of Prometheus, exposes its performance ceilings, and critically evaluates the architectural trade-offs engineers face as they push beyond single-cluster limits. By unraveling how Prometheus performs under pressure, readers are primed to architect systems that are both observant and resilient at scale.
Prometheus is a highly modular and efficient monitoring system designed to operate in dynamic, cloud-native environments. Its core architecture comprises four primary components: the scrape engine, the time series database (TSDB), the query layer, and the alerting mechanism. Each of these components plays a distinctive role in ensuring robust and scalable metric collection, storage, querying, and notification workflows.
At the forefront of data acquisition is the scrape engine, responsible for continuously retrieving metrics from configured targets via HTTP endpoints. Targets expose metrics in a standardized text-based exposition format, enabling Prometheus to collect not only infrastructure metrics but also application-specific insights. The scrape engine operates under a pull model, which contrasts with the push-based modalities of traditional monitoring systems. This design decision enhances reliability, as Prometheus controls when and how metrics are gathered, allowing for adaptation to target availability and network conditions. Scrape configurations define which endpoints to collect from, the intervals at which collection occurs, and parameters such as timeout periods. The engine performs metric discovery either through static configurations or via dynamic service discovery integrations with systems like Kubernetes, Consul, or DNS, facilitating automatic adjustments within ephemeral cloud environments.
Once scraped, metrics are ingested into the time series database. Internally, Prometheus stores data as streams of timestamped value samples, each identified by a unique metric name and a set of key-value pairs called labels. This multi-dimensional label model allows Prometheus to represent complex systems and their relationships with rich metadata, enabling powerful and flexible querying. The TSDB is optimized for writes at the typical scrape frequency (e.g., every 15 seconds), employing an append-only architecture to minimize disk seek overhead and ensure high write throughput.
The internal storage utilizes a custom block format designed to balance compression efficiency and query performance. Each block, usually containing samples from a two-hour time window, comprises a sequence of chunks encoded with delta-of-delta compression for timestamps and simple integer compression for sample values. Index files within these blocks facilitate rapid label matching and retrieval of relevant series without scanning the entire dataset. Historical data is retained on disk, with configurable retention policies, ensuring cost-effective storage without compromising data fidelity.
Data retention housekeeping and compaction processes organize stored blocks, merging smaller segments to improve query efficiency. Prometheus also supports local caching to reduce expensive disk loads during query execution. This storage model facilitates both long-term retrieval and near-real-time analysis, critical for operational monitoring and post-mortem investigations.
Above the storage layer sits the query layer, exposing the PromQL (Prometheus Query Language) interface. PromQL is a domain-specific language that empowers users to select and aggregate time series data using expression matching on metric names, labels, and temporal operators. It supports a variety of aggregation functions such as rate calculations, histograms, and statistical summaries, essential for measuring dynamic system behaviors.
The query engine resolves PromQL expressions by translating label matchers and operators into efficient read operations against the TSDB, retrieving and combining data streams as specified. Queries can be performed via an HTTP API or the interactive web UI, enabling flexible integration with dashboards and other visualization tools. The query range requests support Prometheus's use cases of troubleshooting, alert evaluation, and capacity forecasting.
The architectural data flow can be summarized as follows: the scrape engine continuously polls configured endpoints, feeding recently collected metrics into the TSDB. Retained data blocks serve user queries and drive alert evaluations. Alerts, which are defined using PromQL expressions with specified thresholds or conditions, are periodically evaluated against the current datastore during rule intervals. When conditions trigger, alerts pass to the alert manager, a separate component responsible for deduplicating, grouping, and routing notifications to external systems such as email, PagerDuty, or Slack.
This end-to-end data pipeline ensures resilient and near real-time observability, despite the ephemeral and distributed nature of modern cloud-native applications. The modularity inherent in Prometheus's architecture enables scalability by horizontally sharding scrape targets and vertically scaling query and storage resources as needed. Furthermore, integration with remote storage backends permits offloading older data or handling increased ingestion workloads beyond local capacity.
The interplay between the scrape engine, TSDB, query processing, and alert handling forms a cohesive architecture. The scrape engine's controlled data acquisition prevents overloads and missing data, the TSDB's label-based model ensures rich multi-dimensional indexing and efficient storage, the query layer's expressive language facilitates comprehensive analysis, and the alert subsystem enables rapid and automated issue detection. Collectively, these components empower Prometheus to deliver a robust monitoring framework tailored for highly dynamic and scalable cloud environments.
Prometheus's local storage is fundamentally centered around a custom time series database (TSDB) optimized for high ingestion rates and efficient querying of recent metrics. The design priorities include compact on-disk storage, fast writes, and the ability to retain data over configurable time windows. At the core, the Prometheus TSDB organizes time series data into blocks that are sequentially written and periodically compacted to reduce overhead and maintain query performance.
Time series ingestion proceeds through an append-only write path. Each unique time series, identified by its metric name and label set, is mapped to an in-memory series object. Samples are appended sequentially to a write-ahead log (WAL) to ensure durability against process or system crashes. The WAL is segmented and written to disk in relatively small increments, balancing data safety with write amplification.
Simultaneously, samples are buffered in memory and periodically flushed into immutable disk blocks known as chunks. These chunks represent continuous time intervals-typically two hours in Prometheus's default configuration-and store samples encoded in a highly efficient format. Each block also includes extensive metadata, such as label indexes and chunk summaries, facilitating rapid label-based queries and time range selection. This architecture supports a predominantly write- and prune-heavy workload, where new data arrives continuously, and old data must be efficiently discarded.
Prometheus employs a multi-level compaction strategy similar in spirit to Log-Structured Merge Trees (LSM-trees), adapted for time series data. Newly created blocks are compacted in stages, merging smaller blocks into larger ones while discarding overwritten or obsolete entries. Compaction serves several purposes:
The compaction process occurs in the background and is designed to be I/O-friendly, avoiding excessive latency spikes. However, excessive compaction or poor tuning can still introduce write amplification and increased disk activity, which are critical factors for storage performance and reliability.
Retention is implemented through a time-based pruning mechanism that deletes blocks older than the configured retention period. By default, Prometheus supports retention times ranging from hours to several months, adjusted via the -storage.tsdb.retention.time configuration. When a block passes...
Dateiformat: ePUBKopierschutz: Adobe-DRM (Digital Rights Management)
Systemvoraussetzungen:
Das Dateiformat ePUB ist sehr gut für Romane und Sachbücher geeignet – also für „fließenden” Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Mit Adobe-DRM wird hier ein „harter” Kopierschutz verwendet. Wenn die notwendigen Voraussetzungen nicht vorliegen, können Sie das E-Book leider nicht öffnen. Daher müssen Sie bereits vor dem Download Ihre Lese-Hardware vorbereiten.Bitte beachten Sie: Wir empfehlen Ihnen unbedingt nach Installation der Lese-Software diese mit Ihrer persönlichen Adobe-ID zu autorisieren!
Weitere Informationen finden Sie in unserer E-Book Hilfe.
Dateiformat: ePUBKopierschutz: ohne DRM (Digital Rights Management)
Das Dateiformat ePUB ist sehr gut für Romane und Sachbücher geeignet – also für „glatten” Text ohne komplexes Layout. Bei E-Readern oder Smartphones passt sich der Zeilen- und Seitenumbruch automatisch den kleinen Displays an. Ein Kopierschutz bzw. Digital Rights Management wird bei diesem E-Book nicht eingesetzt.