awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
apache avatar

apache/flink

0
View on GitHub↗
26,086 estrellas·13,961 forks·Java·Apache-2.0·10 vistasflink.apache.org↗

Flink

Apache Flink is a distributed processing engine designed for both high-throughput, low-latency data streams and finite batch workloads. It functions as a stateful stream processor and a SQL stream processing engine, providing a unified runtime to execute relational queries and event-based transformations.

The system is distinguished by its ability to manage persistent operator state to ensure exactly-once processing guarantees and consistency during failures. It features specialized capabilities for complex event processing to detect temporal patterns and handles out-of-order events using event-time windowing.

Beyond its core engine, the project covers a broad surface of data integration, including pluggable connectors for message brokers, databases, and cloud storage. It provides tools for relational query optimization, adaptive memory management, and execution flow visualization for monitoring job progress.

The project includes a Python interface for defining distributed data processing pipelines and a command-line interface for submitting queries to a processing cluster.

Features

  • Unified Batch and Stream Processing Engines - Provides a unified runtime that executes both unbounded streaming and bounded batch workloads with consistent semantics.
  • Stream Processing - Provides a distributed framework for the continuous ingestion, transformation, and analysis of high-velocity data streams.
  • Data Pipelines and ETL - Enables the creation of scalable batch and streaming workloads for analytics and ETL processes.
  • Streaming SQL - Provides a SQL interface for executing relational queries and table-based transformations on live data streams.
  • Complex Event Processing Engines - Detects temporal patterns and sequences within data streams to trigger real-time actions.
  • Data Ingestion Pipelines - Automates the extraction, transformation, and loading of data between brokers, databases, and cloud storage.
  • Exactly-Once Processing Semantics - Guarantees that every event is processed exactly once even during system failures through built-in fault tolerance.
  • Stream Processing Engines - Executes high-throughput, low-latency computations on real-time data streams with built-in fault tolerance.
  • Stateful - Manages persistent operator state to ensure exactly-once processing and consistency during failures.
  • Operator State Management - Manages low-level state and time building blocks to implement custom logic for streaming applications.
  • Data Serialization Formats - Encodes and decodes data across multiple formats including JSON, CSV, Avro, Parquet, and Protobuf.
  • Query Optimizers - Parses SQL and applies optimization rules to generate efficient execution code for faster data retrieval.
  • Distributed SQL Querying - Executes relational queries and table-based transformations on live data streams using a distributed SQL engine.
  • Event-Time Processing - Groups data using timestamps embedded in records to accurately process out-of-order events.
  • External Data Connectors - Provides pluggable connectors to read from and write to message brokers, databases, and cloud storage.
  • Local State Stores - Supports pluggable state backends for storing operator state in local memory or remote key-value stores.
  • Event-Time Processing - Processes data based on event time rather than arrival time to ensure accuracy with out-of-order streams.
  • Persistent State Management - The system stores operator state in pluggable backends to ensure fault tolerance and state recovery.
  • Query Processing - Processes data streams and batches using a language-integrated API for selections, filters, and joins.
  • Real-Time Analytics - Performs low-latency processing and querying of streaming datasets to provide immediate operational insights.
  • Stream Analytics Processing - Groups streaming data into time, count, or session windows to calculate rolling aggregates and metrics.
  • Event Pattern Detection - Implements declarative rules to detect temporal patterns and sequences of events within data streams.
  • Distributed Consistency Snapshots - Implements Chandy-Lamport snapshotting to ensure exactly-once processing guarantees and consistent recovery from failures.
  • Directed Acyclic Graph Engines - Represents computations as a distributed directed acyclic graph of operators executed across a cluster.
  • Relational-to-Graph Compilers - Translates relational queries into optimized physical execution graphs of streaming or batch operators.
  • Back-pressure Handling - Throttles data ingestion automatically when downstream operators cannot keep up with the processing rate.
  • Cluster Query Interfaces - Enables writing and submitting processing queries directly to a cluster via a command-line interface.
  • Advanced Analytics Functions - Provides built-in operations for complex data transformations, including graph processing and machine learning libraries.
  • Relational Model Extensions - Allows extending the relational model through custom catalogs, formats, connectors, and user-defined functions.
  • Python Scripting Environments - Provides a Python interface and runtime to define and execute distributed data processing pipelines.
  • Managed Cluster Orchestration - Orchestrates the deployment and maintenance of distributed clusters across managed environments to execute jobs.
  • Object Storage Integration - Integrates cloud object storage for scalable and stateless data persistence and as a sink/source.
  • Adaptive - Automatically switches between in-memory and out-of-core processing to handle datasets that exceed available physical memory.
  • Cluster Resource Managers - Orchestrates the allocation of compute slots and memory across various cluster managers for workload execution.
  • Task Progress Monitors - Tracks live execution progress and accumulators through a web-based interface to provide real-time status.
  • Job Monitoring Tools - Retrieves the current state and metrics of individual jobs via a REST API.
  • Pipeline Execution Visualizers - Displays a graphical representation of the data processing pipeline as it executes to help analyze job flow.
  • System Metrics - Reports performance data and system-level telemetry to external monitoring systems to track health and throughput.
  • End-to-End Testing - Executes comprehensive tests across the entire architecture to verify system-wide functional correctness before deployment.
  • Frameworks de Machine Learning - Distributed stream and batch processing framework for data pipelines.
  • Big Data - Distributed stream and batch processing engine.
  • Big Data Frameworks - Stream and batch processing framework for big data.
  • Stream Processing - Processes streams and batches with high performance.
  • Data Engineering - Framework for stateful stream and batch processing.
  • Data Infrastructure Management - Stream and batch processing framework for large-scale data pipelines.
  • Streaming Engines - System for high-throughput, low-latency stateful stream processing.

Historial de estrellas

Gráfico del historial de estrellas de apache/flinkGráfico del historial de estrellas de apache/flink

Búsqueda con IA

Explora más repositorios increíbles

Describe lo que necesitas en lenguaje sencillo: la IA clasifica miles de proyectos open-source curados por relevancia.

Start searching with AI

Preguntas frecuentes

¿Qué hace apache/flink?

Apache Flink is a distributed processing engine designed for both high-throughput, low-latency data streams and finite batch workloads. It functions as a stateful stream processor and a SQL stream processing engine, providing a unified runtime to execute relational queries and event-based transformations.

¿Cuáles son las características principales de apache/flink?

Las características principales de apache/flink son: Unified Batch and Stream Processing Engines, Stream Processing, Data Pipelines and ETL, Streaming SQL, Complex Event Processing Engines, Data Ingestion Pipelines, Exactly-Once Processing Semantics, Stream Processing Engines.

¿Qué alternativas de código abierto existen para apache/flink?

Las alternativas de código abierto para apache/flink incluyen: hazelcast/hazelcast — Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to… apache/beam — Apache Beam is a distributed data pipeline framework and unified data processing model designed to handle both bounded… vonng/ddia — This project serves as a comprehensive technical reference for the architecture and design of data-intensive… arroyosystems/arroyo — Arroyo is a high-performance stream processing platform built in Rust. It executes continuous SQL queries on streaming… apache/pinot — Pinot is a distributed, columnar analytical database designed for high-concurrency, low-latency query processing. It… risingwavelabs/risingwave — RisingWave is a cloud-native streaming database and real-time analytics engine that uses standard SQL to process…

Alternativas open-source a Flink

Proyectos open-source similares, clasificados según cuántas características comparten con Flink.
  • hazelcast/hazelcastAvatar de hazelcast

    hazelcast/hazelcast

    6,570Ver en GitHub↗

    Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources. What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consis

    Javabig-datacachingdata-in-motion
    Ver en GitHub↗6,570
  • apache/beamAvatar de apache

    apache/beam

    8,612Ver en GitHub↗

    Apache Beam is a distributed data pipeline framework and unified data processing model designed to handle both bounded batch data and unbounded real-time streams. It provides a system for building scalable, data-parallel workflows that operate across compute clusters using a single programming model. The framework utilizes a cross-runner pipeline abstraction that decouples the data processing logic from the underlying execution backend, allowing the same pipeline to run on different distributed compute engines. It supports multi-language pipeline development by translating high-level code fro

    Java
    Ver en GitHub↗8,612
  • vonng/ddiaAvatar de Vonng

    Vonng/ddia

    22,648Ver en GitHub↗

    This project serves as a comprehensive technical reference for the architecture and design of data-intensive applications. It provides a structured analysis of the fundamental principles required to build reliable, scalable, and maintainable software systems, covering the core trade-offs inherent in modern data infrastructure. The repository explores the mechanics of distributed data management, including strategies for replication, partitioning, and achieving consensus across multiple nodes. It details the design of storage engines, indexing techniques, and transaction management models, whi

    Pythonbookdatabaseddia
    Ver en GitHub↗22,648
  • arroyosystems/arroyoAvatar de ArroyoSystems

    ArroyoSystems/arroyo

    4,819Ver en GitHub↗

    Arroyo is a high-performance stream processing platform built in Rust. It executes continuous SQL queries on streaming data with event-time semantics, enabling accurate windowed aggregations, joins, and stateful computations on unbounded event streams. The platform uses native Rust execution for high throughput and low latency, with periodic checkpointing for exactly-once fault tolerance and horizontal scaling across distributed workers. The system integrates deeply with Kafka for reading and writing topics with exactly-once delivery and supports change data capture (CDC) from MySQL and Postg

    Rustdatadata-stream-processingdev-tools
    Ver en GitHub↗4,819
Ver las 30 alternativas a Flink→