# Amazon Managed Service for Apache Flink

Cloud service · AWS. Updated 2026-11-12. Page: https://blowstack.com/tools/cloud-services-hub/amazon-managed-service-for-apache-flink

> Amazon Managed Service for Apache Flink is a fully managed service that allows you to build and run applications that use Apache Flink - an open-source framework and engine for processing big data streams - without the need for infrastructure management.

Practice exams covering Amazon Managed Service for Apache Flink: [DEA-C01 AWS Certified Data Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-data-engineer-associate), [DOP-C02 AWS Certified DevOps Engineer - Professional](https://blowstack.com/practice-exams/aws-certified-devops-engineer-professional), [MLA-C02 (beta) AWS Certified Machine Learning Engineer - Associate](https://blowstack.com/practice-exams/aws-certified-machine-learning-engineer-associate), [SAA-C03 AWS Certified Solutions Architect - Associate](https://blowstack.com/practice-exams/aws-certified-solutions-architect-associate).

## 9 key features of Amazon Managed Service for Apache Flink

Amazon Managed Service for Apache Flink offers fully managed Apache Flink applications with features like automatic scaling, built-in monitoring and logging, AWS services integration, robust security, and cost-effective pricing.

1. **Fully Managed Service**: Amazon Managed Service for Apache Flink is a fully managed service that automatically manages the deployment, management, and scaling of Apache Flink applications, eliminating the need for infrastructure management.
2. **Automatic Scaling**: This service provides automatic scaling for Apache Flink applications, adjusting the resources as per the workload demands without manual intervention, ensuring efficient resource utilization and cost savings.
3. **Built-in Monitoring and Logging**: Amazon Managed Service for Apache Flink integrates with Amazon CloudWatch for metrics and logging, allowing users to easily monitor their Apache Flink applications and troubleshoot any issues quickly.
4. **Seamless Integration with AWS Services**: It offers seamless integration with other AWS services like Amazon S3, Amazon Kinesis, Amazon DynamoDB, and Amazon EMR, enabling complex and flexible data processing pipelines within the AWS ecosystem.
5. **Secure**: Provides robust security features that include encryption in transit and at rest, IAM for authentication and authorization, and VPC support to ensure that your data and applications are securely managed.
6. **Cost-Effective**: Charges are based on allocated resources rather than actual resource usage, at an hourly rate based on the maximum number of KPUs used to run the stream-processing application.
7. **Application Languages**: Applications can use Java, Scala, Python, or SQL to process and analyze streaming data.
8. **In-Place Flink Version Upgrades**: In-place version upgrades retain the application's ARN and its associated snapshots, logs, metrics, tags, and Flink configurations across Flink versions. This feature can be used with applications in RUNNING or READY state.
9. **Runtime Properties**: Runtime properties pass configuration parameters to an application without requiring its code to be modified and republished.

## Where Amazon Managed Service for Apache Flink is used

Amazon Managed Service for Apache Flink is utilized for real-time data processing, building event-driven applications, implementing complex event processing (CEP), and conducting machine learning model inference directly on data streams, enabling quick insights and adaptive application responses.

1. **Real-time Data Processing**: Amazon Managed Service for Apache Flink enables businesses to analyze and process data in real-time. By leveraging this service, organizations can process streaming data from sources like IoT devices, social media feeds, and website activity logs. This capability allows for the immediate identification of insights, trends, and patterns, enabling quick decision-making and instantaneous response to market dynamics.
2. **Event-driven Applications**: Utilizing Apache Flink's powerful event processing capabilities, businesses can build responsive, event-driven applications. Amazon Managed Service for Apache Flink facilitates the development of applications that can react to events in real-time, such as instant notifications, dynamic pricing models, and automated fraud detection systems, thus improving user experience and operational efficiency.
3. **Complex Event Processing (CEP)**: With Amazon Managed Service for Apache Flink, companies can implement complex event processing (CEP) to identify patterns and relationships across multiple streams of event data. This is particularly useful in sectors like finance for real-time fraud detection, telecommunications for network monitoring, and e-commerce for recommendation systems, offering the ability to act on complex events in real-time.
4. **Machine Learning Model Inference**: This service facilitates the deployment and execution of machine learning models in real-time data streams. Organizations can use Apache Flink to preprocess data, deploy models, and infer predictions directly on the stream of data, enabling adaptive and intelligent applications that evolve based on incoming data, from predictive maintenance in manufacturing to real-time personalization in retail.

## How Amazon Managed Service for Apache Flink is priced

Amazon Managed Service for Apache Flink pricing includes an On-Demand model based on vCPUs and memory usage, and Savings Plans for reduced rates with a commitment.

- **On-Demand Capacity**: Charged based on the virtual CPUs (vCPUs) and the amount of memory (measured in Gibibytes or GiB) allocated to your Flink application. This model offers flexibility without any upfront commitment.
- **Running Application Storage**: Running application storage is billed separately from compute, based on the storage provisioned for the application.
- **Durable Application Backups**: Durable application backups, including application snapshots, are billed according to the amount of backup data stored.

## Services Amazon Managed Service for Apache Flink works with

- **[Amazon Aurora](https://blowstack.com/tools/cloud-services-hub/amazon-aurora)**: Amazon Managed Service for Apache Flink applications can use JDBC connectors to write processed streaming data to Aurora MySQL-Compatible or Aurora PostgreSQL-Compatible databases. JDBC lookups can also enrich incoming events with data held in Aurora.
- **[Amazon Aurora Serverless](https://blowstack.com/tools/cloud-services-hub/amazon-aurora-serverless)**: Amazon Managed Service for Apache Flink applications can connect to Aurora Serverless databases through compatible JDBC drivers and connectors. Applications can write streaming aggregates to database tables or query reference data to enrich events.
- **[Amazon CloudWatch](https://blowstack.com/tools/cloud-services-hub/amazon-cloudwatch)**: Amazon Managed Service for Apache Flink publishes application metrics to CloudWatch and can send application logs to CloudWatch Logs. You can monitor checkpoint failures, processing latency, and resource utilization, and configure alarms for operational problems.
- **[Amazon Data Firehose](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-firehose)**: Amazon Managed Service for Apache Flink applications can use the Firehose sink connector to send processed records to Firehose delivery streams. Firehose then buffers and delivers those results to its configured destination.
- **[Amazon DocumentDB (with MongoDB compatibility)](https://blowstack.com/tools/cloud-services-hub/amazon-documentdb-(with-mongodb-compatibility))**: Amazon Managed Service for Apache Flink applications can use a MongoDB sink connector with DocumentDB-compatible connection settings to write processed records into DocumentDB collections. Connections must use settings supported by DocumentDB, including disabling retryable writes.
- **[Amazon DynamoDB](https://blowstack.com/tools/cloud-services-hub/amazon-dynamodb)**: Amazon Managed Service for Apache Flink applications can use the DynamoDB sink connector to write streaming results into DynamoDB tables. For example, an application can maintain a table containing the latest computed status for each device.
- **[Amazon ElastiCache](https://blowstack.com/tools/cloud-services-hub/amazon-elasticache)**: Amazon Managed Service for Apache Flink applications can use Redis connectors with compatible ElastiCache caches to publish processed streaming results. This can make frequently updated aggregates available to applications through low-latency cache reads.
- **[Amazon EventBridge](https://blowstack.com/tools/cloud-services-hub/amazon-eventbridge)**: Amazon Managed Service for Apache Flink API activity recorded by CloudTrail can be matched by EventBridge rules. Rules can route application-management events, such as application creation or deletion, to notification or automation targets.
- **[Amazon Keyspaces (for Apache Cassandra)](https://blowstack.com/tools/cloud-services-hub/amazon-keyspaces-(for-apache-cassandra))**: Amazon Managed Service for Apache Flink applications can use a Cassandra connector configured for Amazon Keyspaces to write processed records into Keyspaces tables. The connection uses the Keyspaces endpoint, TLS, and supported authentication settings.
- **[Amazon Kinesis Data Streams](https://blowstack.com/tools/cloud-services-hub/amazon-kinesis-data-streams)**: Amazon Managed Service for Apache Flink provides connectors for reading from and writing to Kinesis data streams. Applications can consume events, perform stateful transformations or windowed aggregations, and publish results to another stream.
- **[Amazon Managed Streaming for Apache Kafka](https://blowstack.com/tools/cloud-services-hub/amazon-managed-streaming-for-apache-kafka)**: Amazon Managed Service for Apache Flink applications can use Kafka source and sink connectors to consume from and publish to Amazon MSK topics. Applications can connect to private clusters through a VPC and use the cluster's supported authentication mechanism.
- **[Amazon Managed Workflows for Apache Airflow (Amazon MWAA)](https://blowstack.com/tools/cloud-services-hub/amazon-managed-workflows-for-apache-airflow-(amazon-mwaa))**: Amazon Managed Service for Apache Flink applications can be started and stopped from MWAA workflows using the Apache Airflow Amazon provider's dedicated Flink application operators. This lets a workflow coordinate application execution with upstream preparation or downstream processing.
- **[Amazon OpenSearch Service](https://blowstack.com/tools/cloud-services-hub/amazon-opensearch-service)**: Amazon Managed Service for Apache Flink applications can use an OpenSearch sink connector to index processed events and aggregates in Amazon OpenSearch Service. The indexed results can support near-real-time searches and operational dashboards.
- **[Amazon RDS](https://blowstack.com/tools/cloud-services-hub/amazon-rds)**: Amazon Managed Service for Apache Flink applications can use JDBC connectors with supported RDS database engines to write streaming results or perform reference-data lookups. For example, an application can enrich transaction events with customer information stored in an RDS database.
- **[Amazon Redshift](https://blowstack.com/tools/cloud-services-hub/amazon-redshift)**: Amazon Managed Service for Apache Flink applications can use a JDBC sink with the appropriate driver to write processed streaming results into Amazon Redshift tables. Batching writes helps accommodate the warehouse's ingestion characteristics.
- **[Amazon S3](https://blowstack.com/tools/cloud-services-hub/amazon-s3)**: Amazon Managed Service for Apache Flink loads application artifacts from S3 and supports S3 file sources and sinks. Applications can read stored datasets and continuously write processed records into data-lake files.
- **[Amazon Simple Queue Service (Amazon SQS)](https://blowstack.com/tools/cloud-services-hub/amazon-simple-queue-service-(amazon-sqs))**: Amazon Managed Service for Apache Flink applications can use the SQS sink connector to send processed records to SQS queues. Downstream workers can then consume the resulting messages independently of the streaming application.
- **[Amazon Timestream](https://blowstack.com/tools/cloud-services-hub/amazon-timestream)**: Amazon Managed Service for Apache Flink applications can use the Timestream for LiveAnalytics sample connector to write processed time-series records. For example, an application can aggregate telemetry from Kinesis Data Streams before storing it in Timestream.
- **[Amazon VPC](https://blowstack.com/tools/cloud-services-hub/amazon-vpc)**: Amazon Managed Service for Apache Flink can create network interfaces in selected VPC subnets so applications can reach private resources such as MSK clusters and relational databases. Security groups and subnet routing control the application's network access.
- **[AWS CloudFormation](https://blowstack.com/tools/cloud-services-hub/aws-cloudformation)**: Amazon Managed Service for Apache Flink applications can be provisioned through CloudFormation using AWS::KinesisAnalyticsV2::Application and related resource types. Templates can define application code locations, runtime configuration, logging options, and VPC settings.
- **[AWS CloudTrail](https://blowstack.com/tools/cloud-services-hub/aws-cloudtrail)**: Amazon Managed Service for Apache Flink records supported control-plane API activity in CloudTrail. These records identify who created, updated, started, or otherwise managed an application and when the action occurred.
- **[AWS Config](https://blowstack.com/tools/cloud-services-hub/aws-config)**: Amazon Managed Service for Apache Flink applications can be recorded by AWS Config as AWS::KinesisAnalyticsV2::Application resources. Configuration history helps track changes to application settings and supports configuration-compliance evaluation.
- **[AWS Glue](https://blowstack.com/tools/cloud-services-hub/aws-glue)**: Amazon Managed Service for Apache Flink integrates with Glue Schema Registry to serialize and deserialize streaming records using centrally managed schemas. Managed Service for Apache Flink Studio also uses the Glue Data Catalog to store table metadata for SQL processing.
- **[AWS Identity and Access Management (IAM)](https://blowstack.com/tools/cloud-services-hub/aws-identity-and-access-management-(iam))**: Amazon Managed Service for Apache Flink assumes an IAM service execution role to access application artifacts, streaming sources, destinations, and logging resources. IAM policies also control which users and roles can create, update, or operate Flink applications.
- **[AWS Key Management Service (AWS KMS)](https://blowstack.com/tools/cloud-services-hub/aws-key-management-service-(aws-kms))**: Amazon Managed Service for Apache Flink uses KMS-backed encryption to protect application data at rest. An application's execution role also needs appropriate KMS permissions when accessing customer-encrypted resources such as S3 application artifacts or Kinesis streams.
- **[AWS PrivateLink](https://blowstack.com/tools/cloud-services-hub/aws-privatelink)**: Amazon Managed Service for Apache Flink supports interface VPC endpoints through PrivateLink for private access to its service API. Management requests can stay on the AWS network without requiring an internet gateway or NAT gateway.
- **[AWS Security Token Service (AWS STS)](https://blowstack.com/tools/cloud-services-hub/aws-security-token-service-(aws-sts))**: Amazon Managed Service for Apache Flink uses temporary credentials obtained through role assumption for its execution role. Supported AWS connector credential configurations can also assume another role, allowing an application to access resources such as Kinesis streams in another account.
- **[AWS Step Functions](https://blowstack.com/tools/cloud-services-hub/aws-step-functions)**: Amazon Managed Service for Apache Flink applications can be managed from Step Functions through its AWS SDK integrations for Kinesis Analytics V2. A state machine can orchestrate operations such as starting an application, checking its status, and creating an application snapshot.

## What is Amazon Managed Service for Apache Flink

Amazon Managed Service for Apache Flink is a fully managed service that simplifies the process of building and running applications that process large streams of data in real time. Apache Flink is an open-source framework and distributed processing engine designed for high-performance, accurate, and stateful computations over unbounded and bounded data streams. With the service provided by Amazon Web Services (AWS), users can leverage the powerful features of Apache Flink without the operational overhead of managing the infrastructure, configuring the software, or tuning the performance.

This service is especially beneficial for developers and data engineers who work with applications that require complex time-windowed computations, event-driven processing, or need to perform real-time analytics on streaming data.

Typical use cases include real-time financial fraud detection, log and event stream processing, and real-time analytics on customer data. Amazon Managed Service for Apache Flink is designed with scalability and reliability at its core. It manages the provisioning of compute resources, automatically scales to meet the demands of the application, and ensures high availability with fault-tolerance mechanisms, such as checkpointing, that enable consistent state management and recovery in the event of a failure.

Application resources are allocated in Kinesis Processing Units (KPUs). Each KPU provides one CPU core, 4 GB of memory split into 1 GB of native memory and 3 GB of heap memory, and 50 GB of disk space. The number of KPUs available to an application equals its Parallelism setting divided by its ParallelismPerKPU setting.

The default KPU quota is 64. A quota increase can be requested for the applicable application prefix.

Users of this service can focus on their application logic and data processing algorithms without worrying about the underlying infrastructure. They can easily deploy their Flink applications and integrate with other AWS services for storage, database, and analytics capabilities, providing a seamless data processing pipeline from ingestion to analysis.

For applications using Flink 2.2, Java 17 is the default and recommended runtime, and Java 11 support has been removed. Python 3.12 is supported, while Python 3.8 support has been removed.

Java applications must be packaged with their external dependencies, including required Flink connectors, in a fat JAR for deployment to the service.

Amazon Managed Service for Apache Flink Studio provides an interactive notebook environment powered by Apache Zeppelin for developing and running stream-processing code using SQL and Python.

Moreover, the service offers robust monitoring and logging features through integration with Amazon CloudWatch, allowing developers to keep a close eye on their applications' performance and troubleshoot issues swiftly.

When upgrading to Flink 2.2, update monitoring and alarms to use numRestarts instead of the removed fullRestarts metric. The uptime and downtime metrics are deprecated in favor of state-specific metrics, and bytesRequestedPerFetch has been removed for Kinesis Data Streams connector 6.0.0.

Security is also a key focus, with Amazon Managed Service for Apache Flink offering encryption in transit and at rest, identity and access management, and network isolation through Amazon VPC.

In the fast-evolving landscape of data processing, Amazon Managed Service for Apache Flink stands out by offering a managed environment that combines the power of Apache Flink with the scalability, reliability, and security of the AWS cloud. It frees up developers to innovate and experiment with their streaming applications while significantly reducing the operational burden and costs associated with infrastructure management. This service highlights Amazon's commitment to providing robust tools and services that empower businesses to harness the full potential of real-time analytics and event-driven architecture.

## Concepts related to Amazon Managed Service for Apache Flink

- [Backpressure](https://blowstack.com/tools/cloud-concepts-hub/backpressure): Backpressure is feedback from a constrained downstream component that causes upstream components to slow or pause production.
- [Checkpointing](https://blowstack.com/tools/cloud-concepts-hub/checkpointing): Checkpointing is the practice of durably saving processing progress and any required execution state so work can resume from a known recovery point.
- [Distributed Processing](https://blowstack.com/tools/cloud-concepts-hub/distributed-processing): Distributed processing divides computational work across multiple networked machines that coordinate to produce a result.
- [Event Streaming](https://blowstack.com/tools/cloud-concepts-hub/event-streaming): Event streaming is the continuous publication, retention, and consumption of event records so independent applications can react to changes and replay event history.
- [Event-Time Processing](https://blowstack.com/tools/cloud-concepts-hub/event-time-processing): Event-time processing transforms and aggregates data according to when events occurred rather than when a processing system receives or handles them.
- [Fan-In](https://blowstack.com/tools/cloud-concepts-hub/fan-in): Fan-in is a many-to-one data-flow pattern in which multiple producers or streams feed a shared destination or processing stage.
- [Joins](https://blowstack.com/tools/cloud-concepts-hub/joins): Joins combine records from two or more datasets using a condition that defines how the records relate.
- [Latency](https://blowstack.com/tools/cloud-concepts-hub/latency): Latency is the elapsed time between a defined starting event and the corresponding response, completion, or availability of a result.
- [Stateful Processing](https://blowstack.com/tools/cloud-concepts-hub/stateful-processing): Stateful processing retains information across records, requests, or events so that earlier activity can influence later results.
- [Temporal Aggregation](https://blowstack.com/tools/cloud-concepts-hub/temporal-aggregation): Temporal aggregation combines timestamped observations within defined time intervals into summary values such as counts, sums, averages, or percentiles.
- [Windowed Aggregation](https://blowstack.com/tools/cloud-concepts-hub/windowed-aggregation): Windowed aggregation computes summaries over bounded groups of events, typically defined by time, so continuously arriving data can become usable metrics and machine-learning features.
