
<!DOCTYPE html>
<html lang="en" dir=ZgotmplZ>

<head>
  


<link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
<script src="/bootstrap/js/bootstrap.bundle.min.js"></script>
<link rel="stylesheet" type="text/css" href="/font-awesome/css/font-awesome.min.css">
<script src="/js/anchor.min.js"></script>
<script src="/js/flink.js"></script>
<link rel="canonical" href="https://flink.apache.org/2021/09/29/apache-flink-1.14.0-release-announcement/">

  <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="description" content="The Apache Software Foundation recently released its annual report and Apache Flink once again made it on the list of the top 5 most active projects! This remarkable activity also shows in the new 1.14.0 release. Once again, more than 200 contributors worked on over 1,000 issues. We are proud of how this community is consistently moving the project forward.
This release brings many new features and improvements in areas such as the SQL API, more connector support, checkpointing, and PyFlink.">
<meta name="theme-color" content="#FFFFFF"><meta property="og:title" content="Apache Flink 1.14.0 Release Announcement" />
<meta property="og:description" content="The Apache Software Foundation recently released its annual report and Apache Flink once again made it on the list of the top 5 most active projects! This remarkable activity also shows in the new 1.14.0 release. Once again, more than 200 contributors worked on over 1,000 issues. We are proud of how this community is consistently moving the project forward.
This release brings many new features and improvements in areas such as the SQL API, more connector support, checkpointing, and PyFlink." />
<meta property="og:type" content="article" />
<meta property="og:url" content="https://flink.apache.org/2021/09/29/apache-flink-1.14.0-release-announcement/" /><meta property="article:section" content="posts" />
<meta property="article:published_time" content="2021-09-29T08:00:00+00:00" />
<meta property="article:modified_time" content="2021-09-29T08:00:00+00:00" />
<title>Apache Flink 1.14.0 Release Announcement | Apache Flink</title>
<link rel="manifest" href="/manifest.json">
<link rel="icon" href="/favicon.png" type="image/x-icon">
<link rel="stylesheet" href="/book.min.22eceb4d17baa9cdc0f57345edd6f215a40474022dfee39b63befb5fb3c596b5.css" integrity="sha256-IuzrTRe6qc3A9XNF7dbyFaQEdAIt/uObY777X7PFlrU=">
<script defer src="/en.search.min.2698f0d1b683dae4d6cb071668b310a55ebcf1c48d11410a015a51d90105b53e.js" integrity="sha256-Jpjw0baD2uTWywcWaLMQpV688cSNEUEKAVpR2QEFtT4="></script>
<!--
Made with Book Theme
https://github.com/alex-shpak/hugo-book
-->

  <meta name="generator" content="Hugo 0.124.1">

    
    <script>
      var _paq = window._paq = window._paq || [];
       
       
      _paq.push(['disableCookies']);
       
      _paq.push(["setDomains", ["*.flink.apache.org","*.nightlies.apache.org/flink"]]);
      _paq.push(['trackPageView']);
      _paq.push(['enableLinkTracking']);
      (function() {
        var u="//analytics.apache.org/";
        _paq.push(['setTrackerUrl', u+'matomo.php']);
        _paq.push(['setSiteId', '1']);
        var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
        g.async=true; g.src=u+'matomo.js'; s.parentNode.insertBefore(g,s);
      })();
    </script>
    
</head>

<body dir=ZgotmplZ>
  


<header>
  <nav class="navbar navbar-expand-xl">
    <div class="container-fluid">
      <a class="navbar-brand" href="/">
        <img src="/img/logo/png/100/flink_squirrel_100_color.png" alt="Apache Flink" height="47" width="47" class="d-inline-block align-text-middle">
        <span>Apache Flink</span>
      </a>
      <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
          <i class="fa fa-bars navbar-toggler-icon"></i>
      </button>
      <div class="collapse navbar-collapse" id="navbarSupportedContent">
        <ul class="navbar-nav">
          





    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">About</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/flink-architecture/">Architecture</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/flink-applications/">Applications</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/flink-operations/">Operations</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/use-cases/">Use Cases</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/powered-by/">Powered By</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/roadmap/">Roadmap</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/community/">Community & Project Info</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/security/">Security</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/what-is-flink/special-thanks/">Special Thanks</a>
  

          </li>
        
      </ul>
    </li>
  

    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">Getting Started</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-stable/docs/try-flink/local_installation/">With Flink<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-kubernetes-operator-docs-stable/docs/try-flink-kubernetes-operator/quick-start/">With Flink Kubernetes Operator<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-cdc-docs-stable/docs/get-started/introduction/">With Flink CDC<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-ml-docs-stable/docs/try-flink-ml/quick-start/">With Flink ML<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-statefun-docs-stable/getting-started/project-setup.html">With Flink Stateful Functions<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-stable/docs/learn-flink/overview/">Training Course<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
      </ul>
    </li>
  

    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">Documentation</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-stable/">Flink 1.19 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-docs-master/">Flink Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-kubernetes-operator-docs-stable/">Kubernetes Operator 1.8 (latest)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-kubernetes-operator-docs-main">Kubernetes Operator Main (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-cdc-docs-stable">CDC 3.0 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-cdc-docs-master">CDC Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-ml-docs-stable/">ML 2.3 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-ml-docs-master">ML Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-statefun-docs-stable/">Stateful Functions 3.3 (stable)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="https://nightlies.apache.org/flink/flink-statefun-docs-master">Stateful Functions Master (snapshot)<i class="link fa fa-external-link title" aria-hidden="true"></i>
    </a>
  

          </li>
        
      </ul>
    </li>
  

    
      
  
    <li class="nav-item dropdown">
      <a class="nav-link dropdown-toggle" href="#" role="button" data-bs-toggle="dropdown" aria-expanded="false">How to Contribute</a>
      <ul class="dropdown-menu">
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/overview/">Overview</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/contribute-code/">Contribute Code</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/reviewing-prs/">Review Pull Requests</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/code-style-and-quality-preamble/">Code Style and Quality Guide</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/contribute-documentation/">Contribute Documentation</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/documentation-style-guide/">Documentation Style Guide</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/improve-website/">Contribute to the Website</a>
  

          </li>
        
          <li>
            
  
    <a class="dropdown-item" href="/how-to-contribute/getting-help/">Getting Help</a>
  

          </li>
        
      </ul>
    </li>
  

    


    
      
  
    <li class="nav-item">
      
  
    <a class="nav-link" href="/posts/">Flink Blog</a>
  

    </li>
  

    
      
  
    <li class="nav-item">
      
  
    <a class="nav-link" href="/downloads/">Downloads</a>
  

    </li>
  

    


    









        </ul>
        <div class="book-search">
          <div class="book-search-spinner hidden">
            <i class="fa fa-refresh fa-spin"></i>
          </div>
          <form class="search-bar d-flex" onsubmit="return false;"su>
            <input type="text" id="book-search-input" placeholder="Search" aria-label="Search" maxlength="64" data-hotkeys="s/">
            <i class="fa fa-search search"></i>
            <i class="fa fa-circle-o-notch fa-spin spinner"></i>
          </form>
          <div class="book-search-spinner hidden"></div>
          <ul id="book-search-results"></ul>
        </div>
      </div>
    </div>
  </nav>
  <div class="navbar-clearfix"></div>
</header>
 
  
      <main class="flex">
        <section class="container book-page">
          
<article class="markdown">
    <h1>
        <a href="/2021/09/29/apache-flink-1.14.0-release-announcement/">Apache Flink 1.14.0 Release Announcement</a>
    </h1>
    


  September 29, 2021 -



  Stephan Ewen

  <a href="https://twitter.com/StephanEwen">(@StephanEwen)</a>
  

  Johannes Moser

  <a href="https://twitter.com/joemoeAT">(@joemoeAT)</a>
  



    <p><p>The Apache Software Foundation recently released its annual report and Apache Flink once again made
it on the list of the top 5 most active projects! This remarkable
activity also shows in the new 1.14.0 release. Once again, more than 200 contributors worked on
over 1,000 issues. We are proud of how this community is consistently moving the project forward.</p>
<p>This release brings many new features and improvements in areas such as the SQL API, more connector support, checkpointing, and PyFlink.
A major area of changes in this release is the integrated streaming &amp; batch experience. We believe
that, in practice, unbounded stream processing goes hand-in-hand with bounded- and batch processing tasks,
because many use cases require processing historic data from various sources alongside streaming data.
Examples are data exploration when developing new applications, bootstrapping state for new applications, training
models to be applied in a streaming application, or re-processing data after fixes/upgrades.</p>
<p>In Flink 1.14, we finally made it possible to <strong>mix bounded and unbounded streams in an application</strong>:
Flink now supports taking checkpoints of applications that are partially running and partially finished (some
operators reached the end of the bounded inputs). Additionally, <strong>bounded streams now take a final checkpoint</strong>
when reaching their end to ensure smooth committing of results in sinks.</p>
<p>The <strong>batch execution mode now supports programs that use a mixture of the DataStream API and the SQL/Table API</strong>
(previously only pure Table/SQL or DataStream programs).</p>
<p>The unified Source and Sink APIs have gotten an update, and we started <strong>consolidating the connector ecosystem around the unified APIs</strong>. We added a new <strong>hybrid source</strong> that can bridge between multiple storage systems.
You can now do things like read old data from Amazon S3 and then switch over to Apache Kafka.</p>
<p>In addition, this release furthers our initiative in making Flink more self-tuning and
easier to operate, without necessarily requiring a lot of Stream-Processor-specific knowledge.
We started this initiative in the previous release with <a href="/news/2021/05/03/release-1.13.0.html#reactive-scaling">reactive scaling</a>
and are now adding <strong>automatic network memory tuning</strong> (<em>a.k.a. Buffer Debloating</em>).
This feature speeds up checkpoints under high load while maintaining high throughput and without
increasing checkpoint size. The mechanism continuously adjusts the network buffers to ensure the best
throughput while having minimal in-flight data. See the <a href="#buffer-debloating">Buffer Debloating section</a>
for more details.</p>
<p>There are many more improvements and new additions throughout various components, as we discuss below.
We also had to say goodbye to some features that have been superceded by newer ones in recent releases,
most prominently we are <strong>removing the old SQL execution engine</strong> and are
<strong>removing the active integration with Apache Mesos</strong>.</p>
<p>We hope you like the new release and we&rsquo;d be eager to learn about your experience with it, which yet
unsolved problems it solves, what new use-cases it unlocks for you.</p>
<h1 id="the-unified-batch-and-stream-processing-experience">
  The Unified Batch and Stream Processing Experience
  <a class="anchor" href="#the-unified-batch-and-stream-processing-experience">#</a>
</h1>
<p>One of Flink&rsquo;s unique characteristics is how it integrates stream- and batch processing,
using unified APIs and a runtime that supports multiple execution paradigms.</p>
<p>As motivated in the introduction, we believe that stream- and batch processing always go hand in hand. This quote from
a <a href="https://research.fb.com/wp-content/uploads/2016/11/realtime_data_processing_at_facebook.pdf">report on Facebook&rsquo;s streaming infrastructure</a>
echos this sentiment nicely.</p>
<blockquote>
<p>Streaming versus batch processing is not an either/or decision. Originally, all data warehouse
processing at Facebook was batch processing. We began developing Puma and Swift about five years
ago. As we showed in Section [&hellip;], using a mix of streaming and batch processing can speed up
long pipelines by hours.</p>
</blockquote>
<p>Having both the real-time and the historic computations in the same engine also ensures consistency
between semantics and makes results well comparable. Here is an <a href="https://www.ververica.com/blog/apache-flinks-stream-batch-unification-powers-alibabas-11.11-in-2020">article by Alibaba</a>
about unifying business reporting with Apache Flink and getting consistent reports that way.</p>
<p>While unified streaming &amp; batch are already possible in earlier versions, this release brings
some features that unlock new use cases, as well as a series of quality-of-life improvements.</p>
<h2 id="checkpointing-and-bounded-streams">
  Checkpointing and Bounded Streams
  <a class="anchor" href="#checkpointing-and-bounded-streams">#</a>
</h2>
<p>Flink&rsquo;s checkpointing mechanism could originally only create checkpoints when all tasks in an application&rsquo;s
DAG were running. This meant that applications using both bounded and unbounded data sources were not really possible.
In addition, applications on bounded inputs that were executed in a streaming way (not in a batch way)
stopped checkpointing towards the end of the processing, when some tasks finished. Without checkpoints, the
latest output data was not committed, resulting in lingering data for exactly-once sinks.</p>
<p>With <a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-147%3A&#43;Support&#43;Checkpoints&#43;After&#43;Tasks&#43;Finished">FLIP-147</a>
Flink now supports checkpoints after tasks are finished, and takes a final checkpoint at the end of a
bounded stream, ensuring that all sink data is committed before the job ends (similar to how
<em>stop-with-savepoint</em> behaves).</p>
<p>To activate this feature, add <code>execution.checkpointing.checkpoints-after-tasks-finish.enabled: true</code>
to your configuration. Keeping with the opt-in tradition for big and new features,
this is not activated by default in Flink 1.14. We expect it to become the default mode in the next release.</p>
<p>Background: While the batch execution mode is often the preferrable way to run applications over bounded streams,
there are various reasons to use streaming execution mode over bounded streams. For example, the sink being used
might only support streaming execution (i.e. Kafka sink) or you may want to exploit the streaming-inherent
quasi-ordering-by-time in your application, such as motivated by the <a href="https://youtu.be/4qSlsYogALo?t=666">Kappa+ Architecture</a>.</p>
<h2 id="batch-execution-for-mixed-datastream-and-tablesql-applications">
  Batch Execution for mixed DataStream and Table/SQL Applications
  <a class="anchor" href="#batch-execution-for-mixed-datastream-and-tablesql-applications">#</a>
</h2>
<p>SQL and the Table API are becoming the default starting points for new projects. The declarative
nature and richness of built-in types and operations make it easy to develop applications fast.
It is not uncommon, however, for developers to eventually hit the limit of SQL&rsquo;s expressiveness for
certain types of event-driven business logic (or hit the point when it becomes grotesque to express
that logic in SQL).</p>
<p>At that point, the natural step is to blend in a piece of stateful DataStream API logic, before
switching back to SQL again.</p>
<p>In Flink 1.14, bounded batch-executed SQL/Table programs can convert their intermediate
Tables to a DataStream, apply some DataSteam API operations, and convert it back to a Table.
Under the hood, Flink builds a dataflow DAG mixing declarative optimized SQL execution with batch-executed DataStream logic.
Check out the <a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/docs/dev/table/data_stream_api/#converting-between-datastream-and-table">documentation</a> for details.</p>
<h2 id="hybrid-source">
  Hybrid Source
  <a class="anchor" href="#hybrid-source">#</a>
</h2>
<p>The new <a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/docs/connectors/datastream/hybridsource/">Hybrid Source</a>
produces a combined stream from multiple sources, by reading those sources one after the other,
seamlessly switching over from one source to the other.</p>
<p>The motivating use case for the Hybrid Source was to read streams from tiered storage setups as if there was one
stream that spans all tiers. For example, new data may land in Kafka and is eventually
migrated to S3 (typically in compressed columnar format, for cost efficiency and performance).
The Hybrid Source can read this as one contiguous logical stream, starting with the historic data on S3
and transitioning over to the more recent data in Kafka.</p>
<figure style="align-content: center">
  <img src="/img/blog/2021-09-25-release-1.14.0/hybrid_source.png" style="display: block; margin-left: auto; margin-right: auto; width: 600px"/>
</figure>
<p>We believe that this is an exciting step in realizing the full promise of logs and the <em>Kappa Architecture.</em>
Even if older parts of an event log are physically migrated to different storage
(for reasons such as cost, better compression, faster reads) you can still treat and process it as one
contiguous log.</p>
<p>Flink 1.14 adds the core functionality of the Hybrid Source. Over the next releases, we expect to add more
utilities and patterns for typical switching strategies.</p>
<h2 id="consolidating-sources-and-sink">
  Consolidating Sources and Sink
  <a class="anchor" href="#consolidating-sources-and-sink">#</a>
</h2>
<p>With the new unified (streaming/batch) source and sink APIs now being stable, we started the
big effort to consolidate all connectors around those APIs. At the same time, we are
better aligning connectors between DataStream and SQL/Table API. First are the <em>Kafka</em> and
<em>File</em> Soures and Sinks for the DataStream API.</p>
<p>The result of this effort (that we expect to span at least 1-2 futher releases) will be a much
smoother and more consistent experience for Flink users when connecting to external systems.</p>
<h1 id="improvements-to-operations">
  Improvements to Operations
  <a class="anchor" href="#improvements-to-operations">#</a>
</h1>
<h2 id="buffer-debloating">
  Buffer debloating
  <a class="anchor" href="#buffer-debloating">#</a>
</h2>
<p><em>Buffer Debloating</em> is a new technology in Flink that minimizes checkpoint latency and cost.
It does so by automatically tuning the usage of network memory to ensure high throughput,
while minimizing the amount of in-flight data.</p>
<p>Apache Flink buffers a certain amount of data in its network stack to be able to utilize the
bandwidth of fast networks. A Flink application running with high throughput uses some (or
all) of that memory. Aligned checkpoints flow with the data through the network buffers in milliseconds.</p>
<p>During (temporary) backpressure from a resource bottleneck such as an external system, data skew, or (temporarily)
increased load, Flink was buffering a lot more data inside its network buffers than necessary to utilize
enough network bandwidth for the application&rsquo;s current – backpressured – throughput. This actually has an adverse
effect because more buffered data means that the checkpoints need to do more work. Aligned checkpoint barriers
need to wait for more data to be processed, unaligned checkpoints need to persist more in-flight data.</p>
<p>This is where <em>Buffer Debloating</em> comes into play: It changes the network stack from keeping up to X bytes of data
to keeping data that is worth X milliseconds of receiver computing time. With the default setting
of 1000 milliseconds, that means the network stack will buffer as much data as the receiving task can
process in 1000 milliseconds. These values are constantly measured and adjusted, so the system keeps
this characteristic even under varying conditions. As a result, Flink can now provide
stable and predictable alignment times for aligned checkpoints under backpressure, and can vastly
reduce the amount of in-flight data stored in unaliged checkpoints under backpressure.</p>
<figure style="align-content: center">
  <img src="/img/blog/2021-09-25-release-1.14.0/buffer_debloating.svg" style="display: block; margin-left: auto; margin-right: auto; width: 600px"/>
</figure>
<p>Buffer Debloating acts as a complementary feature, or even alternative, to unaligned checkpoints.
Checkout the <a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/docs/deployment/memory/network_mem_tuning/#the-buffer-debloating-mechanism">documentation</a>
to see how to activate this feature.</p>
<h2 id="fine-grained-resource-management">
  Fine-grained Resource Management
  <a class="anchor" href="#fine-grained-resource-management">#</a>
</h2>
<p><em>Fine-grained resource management</em> is an advanced new feature that increases the resource
utilization of large shared clusters.</p>
<p>Flink clusters execute various data processing workloads. Different data processing steps typically need
different resources such as compute resources and memory. For example, most <code>map()</code> functions are fairly
lightweight, but large windows with long retention can benefit from lots of memory.
By default, Flink manages resources in coarse-grained units called <em>slots</em>, which are slices
of a TaskManager&rsquo;s resources. Streaming pipelines fill a slot with one parallel
subtask of each operator, so each slot holds a pipeline of subtasks.
Through <em>&lsquo;slot sharing groups&rsquo;</em>, users can influence how subtasks are assigned to slots.</p>
<p>With fine-grained resource management, TaskManager slots can now be dynamically sized.
Transformations and operators specify what resource profiles they would like (CPU size,
memory pools, disk space) and Flink&rsquo;s Resource Manager and TaskManagers slice off that specific
part of a TaskManager&rsquo;s total resources. You can think of it as a minimal lightweight resource orchestration
layer within Flink. The figure below illustrates the difference between the current default mode of shared
fixed-size slots and the new fine-grained resource management feature.</p>
<figure style="align-content: center">
  <img src="/img/blog/2021-09-25-release-1.14.0/fine_grained_resource_management.svg" style="display: block; margin-left: auto; margin-right: auto; width: 600px"/>
</figure>
<p>You may be wondering why we implement such a feature in Flink, when we also integrate with full-fledged
resource orchestration frameworks like Kubernetes or YARN. There are several situations where the additional
resource management layer within Flink significantly increases the resource utilization:</p>
<ul>
<li>For many small slots, the overhead of dedicated TaskManagers is very high (JVM overhead, Flink control data structures).
Slot-sharing implicitly works around this by sharing the slots between all operator types, which means
sharing resources between lightweight operators (which need small slots) and heavyweight operators (which need large slots).
However, this only works well when all operators share the same parallelism, which is not aways optimal.
Furthermore, certain operators work better when run in isolation (for example ML training operators
that need dedicated GPU resources).</li>
<li>Kubernetes and YARN often take quite some time to fulfill requests, especially on loaded clusters.
For many batch jobs, efficiency gets lost while waiting for the requests to be fulfilled.</li>
</ul>
<p>So when should you use this feature? For most streaming and batch jobs the default resource management mechanism
are perfectly suitable. Fine-grained resourced management can help you increase resource efficiency if you have either long-running
streaming jobs, or fast batch jobs, where different stages have different resource requirements, and you may
have already tuned the parallelism of different operators to different values.</p>
<p>Alibaba&rsquo;s internal Flink-based platform has used this mechanism for some time now and the resource utilization
of the cluster has improved significantly.</p>
<p>Please refer to the <a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/docs/deployment/finegrained_resource/">Fine-grained Resource Management documentation</a>
for details on how to use this feature.</p>
<h1 id="connectors">
  Connectors
  <a class="anchor" href="#connectors">#</a>
</h1>
<h2 id="connector-metrics">
  Connector Metrics
  <a class="anchor" href="#connector-metrics">#</a>
</h2>
<p>Metrics for connectors have been standardized in this release (see <a href="https://cwiki.apache.org/confluence/display/FLINK/FLIP-33%3A&#43;Standardize&#43;Connector&#43;Metrics">FLIP-33</a>).
The community will gradually pull metrics through all connectors, as we rework them
onto the new unified APIs over the next releases. In Flink 1.14, we cover the Kafka connector
and (partially) the FileSystem connectors.</p>
<p>Connectors are the entry and exit points for data in a Flink job. If a job is not running as
expected, the connector telemetry is among the first parts to be checked. We believe this will become
a nice improvement when operating Flink applications in production.</p>
<h2 id="pulsar-connector">
  Pulsar Connector
  <a class="anchor" href="#pulsar-connector">#</a>
</h2>
<p>In this release, Flink added the <a href="https://pulsar.apache.org/">Apache Pulsar</a> connector.
The Pulsar connector reads data from Pulsar topics and supports both streaming and batch execution modes.
With the support of the transaction functionality (introduced in Pulsar 2.8.0), the Pulsar connector provides
exactly-once delivery semantic to ensure that a message is delivered exactly once to a consumer,
even if a producer retries sending that message.</p>
<p>To support the different message-ordering and scaling requirements of different use cases, the Pulsar
source connector exposes four subscription types:</p>
<ul>
<li><a href="https://pulsar.apache.org/docs/en/concepts-messaging/#exclusive">Exclusive</a></li>
<li><a href="https://pulsar.apache.org/docs/en/concepts-messaging/#shared">Shared</a></li>
<li><a href="https://pulsar.apache.org/docs/en/concepts-messaging/#failover">Failover</a></li>
<li><a href="https://pulsar.apache.org/docs/en/concepts-messaging/#key_shared">Key-Shared</a></li>
</ul>
<p>The connector currently supports the DataStream API. Table API/SQL bindings are expected to be
contributed in a future release. For details about how to use the Pulsar connector, see
<a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/docs/connectors/datastream/pulsar/#apache-pulsar-connector">Apache Pulsar Connector</a>.</p>
<h1 id="pyflink">
  PyFlink
  <a class="anchor" href="#pyflink">#</a>
</h1>
<h2 id="performance-improvements-through-chaining">
  Performance Improvements through Chaining
  <a class="anchor" href="#performance-improvements-through-chaining">#</a>
</h2>
<p>Similar to how the Java APIs chain transformation functions/operators within a task to avoid
serialization overhead, PyFlink now chains Python functions. In PyFlink&rsquo;s case, the
chaining not only eliminates serialization overhead, but also reduces RPC round trips
between the Java and Python processes. This provides a significant
boost to PyFlink&rsquo;s overall performance.</p>
<p>Python function chaining was already available for Python UDFs used in the Table API &amp; SQL.
In Flink 1.14, chaining is also exploited for the cPython functions in Python DataStream API.</p>
<h2 id="loopback-mode-for-debugging">
  Loopback Mode for Debugging
  <a class="anchor" href="#loopback-mode-for-debugging">#</a>
</h2>
<p>Python functions are normally executed in a separate Python process next to Flink&rsquo;s JVM.
This architecture makes it difficult to debug Python code.</p>
<p>PyFlink 1.14 introduces a <em>loopback mode</em>, which is activated by default for local deployments.
In this mode, user-defined Python functions will be executed in the Python process of the client,
which is the entry point process that starts the PyFlink program and contains the DataStream API and
Table API code that builds the dataflow DAG. Users can now easily debug their Python functions
by setting breakpoints in their IDEs when launching a PyFlink job locally.</p>
<h2 id="miscellaneous-improvements">
  Miscellaneous Improvements
  <a class="anchor" href="#miscellaneous-improvements">#</a>
</h2>
<p>There are also many other improvements to PyFlink, such as support for executing
jobs in YARN application mode and support for compressed tgz files as Python archives.
Check out the <a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/docs/dev/python/overview/">Python API documentation</a>
for more details.</p>
<h1 id="goodbye-legacy-sql-engine-and-mesos-support">
  Goodbye Legacy SQL Engine and Mesos Support
  <a class="anchor" href="#goodbye-legacy-sql-engine-and-mesos-support">#</a>
</h1>
<p>Maintaining an open source project also means sometimes saying good-bye to some beloved features.</p>
<p>When we added the Blink SQL Engine to Flink more than two years ago, it was clear that it would
eventually replace the previous SQL engine. Blink was faster and more feature-complete.
For a year now, Blink has been the default SQL engine. With Flink 1.14 we finally remove all
code from the previous SQL engine. This allowed us to drop many outdated interfaces and reduce
confusion for users about which interfaces to use when implementing custom connectors or functions.
It will also help us in the future to make faster changes to the SQL engine.</p>
<p>The active integration with Apache Mesos was also removed, because we saw little interest by
users in this feature and we could not gather enough contributors willing to help maintaining this
part of the system. Flink 1.14 can no longer run on Mesos without the help of projects like Marathon,
and the Flink Resource Manager can no longer request and release resources from Mesos for workloads
with changing resource requirements.</p>
<h1 id="upgrade-notes">
  Upgrade Notes
  <a class="anchor" href="#upgrade-notes">#</a>
</h1>
<p>While we aim to make upgrades as smooth as possible, some of the changes require users
to adjust some parts of the program when upgrading to Apache Flink 1.14.
Please take a look at the <a href="https://nightlies.apache.org/flink/flink-docs-release-1.14/release-notes/flink-1.14/">release notes</a>
for a list of adjustments to make and issues to check during upgrades.</p>
<h1 id="list-of-contributors">
  List of Contributors
  <a class="anchor" href="#list-of-contributors">#</a>
</h1>
<p>The Apache Flink community would like to thank each one of the contributors that have made this
release possible:</p>
<p>adavis9592, Ada Wong, aidenma, Aitozi, Ankush Khanna, anton, Anton Kalashnikov, Arvid Heise, Ashwin
Kolhatkar, Authuir, bgeng777, Brian Zhou, camile.sing, caoyingjie, Cemre Mengu, chennuo, Chesnay
Schepler, chuixue, CodeCooker17, comsir, Daisy T, Danny Cranmer, David Anderson, David Moravek,
Dawid Wysakowicz, dbgp2021, Dian Fu, Dong Lin, Edmondsky, Elphas Toringepi, Emre Kartoglu, ericliuk,
Eron Wright, est08zw, Etienne Chauchot, Fabian Paul, fangliang, fangyue1, fengli, Francesco
Guardiani, FuyaoLi2017, fuyli, Gabor Somogyi, gaoyajun02, Gen Luo, gentlewangyu, GitHub, godfrey he,
godfreyhe, gongzhongqiang, Guokuai Huang, GuoWei Ma, Gyula Fora, hackergin, hameizi, Hang Ruan, Han
Wei, hapihu, hehuiyuan, hstdream, Huachao Mao, HuangXiao, huangxingbo, huxixiang, Ingo Bürk,
Jacklee, Jan Brusch, Jane, Jane Chan, Jark Wu, JasonLee, Jiajie Zhong, Jiangjie (Becket) Qin,
Jianzhang Chen, Jiayi Liao, Jing, Jingsong Lee, JingsongLi, Jing Zhang, jinxing64, junfan.zhang, Jun
Qin, Jun Zhang, kanata163, Kevin Bohinski, kevin.cyj, Kevin Fan, Kurt Young, kylewang, Lars
Bachmann, lbb, LB Yu, LB-Yu, LeeJiangchuan, Leeviiii, leiyanfei, Leonard Xu, LightGHLi, Lijie Wang,
liliwei, lincoln lee, Linyu, liuyanpunk, lixiaobao14, luoyuxia, Lyn Zhang, lys0716, MaChengLong,
mans2singh, Marios Trivyzas, martijnvisser, Matthias Pohl, Mayi, mayue.fight, Michael Li, Michal
Ciesielczyk, Mika, Mika Naylor, MikuSugar, movesan, Mulan, Nico Kruber, Nicolas Raga, Nicolaus
Weidner, paul8263, Paul Lin, pierre xiong, Piotr Nowojski, Qingsheng Ren, Rainie Li, Robert Metzger,
Roc Marshal, Roman, Roman Khachatryan, Rui Li, sammieliu, sasukerui, Senbin Lin, Senhong Liu, Serhat
Soydan, Seth Wiesman, sharkdtu, Shengkai, Shen Zhu, shizhengchao, Shuo Cheng, shuo.cs, simenliuxing,
sjwiesman, Srinivasulu Punuru, Stefan Gloutnikov, SteNicholas, Stephan Ewen, sujun, sv3ndk, Svend
Vanderveken, syhily, Tartarus0zm, Terry Wang, Thesharing, Thomas Weise, tiegen, Till Rohrmann, Timo
Walther, tison, Tony Wei, trushev, tsreaper, TsReaper, Tzu-Li (Gordon) Tai, wangfeifan, wangwei1025,
wangxianghu, wangyang0918, weizheng92, Wenhao Ji, Wenlong Lyu, wenqiao, WilliamSong11, wuren,
wysstartgo, Xintong Song, yanchenyun, yangminghua, yangqu, Yang Wang, Yangyang ZHANG, Yangze Guo,
Yao Zhang, yfhanfei, yiksanchan, Yik San Chan, Yi Tang, yljee, Youngwoo Kim, Yuan Mei, Yubin Li,
Yufan Sheng, yulei0824, Yun Gao, Yun Tang, yuxia Luo, Zakelly, zhang chaoming, zhangjunfan,
zhangmang, zhangzhengqi3, zhao_wei_nan, zhaown, zhaoxing, ZhiJie Yang, Zhilong Hong, Zhiwen Sun, Zhu
Zhu, zlzhang0122, zoran, Zor X. LIU, zoucao, Zsombor Chikan, 子扬, 莫辞</p>
</p>
</article>

          



  
    
    <div class="edit-this-page">
      <p>
        <a href="https://cwiki.apache.org/confluence/display/FLINK/Flink+Translation+Specifications">Want to contribute translation?</a>
      </p>
      <p>
        <a href="//github.com/apache/flink-web/edit/asf-site/docs/content/posts/2021-09-29-release-1.14.0.md">
          Edit This Page<i class="fa fa-edit fa-fw"></i> 
        </a>
      </p>
    </div>

        </section>
        
          <aside class="book-toc">
            


<nav id="TableOfContents"><h3>On This Page <a href="javascript:void(0)" class="toc" onclick="collapseToc()"><i class="fa fa-times" aria-hidden="true"></i></a></h3>
  <ul>
    <li><a href="#the-unified-batch-and-stream-processing-experience">The Unified Batch and Stream Processing Experience</a>
      <ul>
        <li><a href="#checkpointing-and-bounded-streams">Checkpointing and Bounded Streams</a></li>
        <li><a href="#batch-execution-for-mixed-datastream-and-tablesql-applications">Batch Execution for mixed DataStream and Table/SQL Applications</a></li>
        <li><a href="#hybrid-source">Hybrid Source</a></li>
        <li><a href="#consolidating-sources-and-sink">Consolidating Sources and Sink</a></li>
      </ul>
    </li>
    <li><a href="#improvements-to-operations">Improvements to Operations</a>
      <ul>
        <li><a href="#buffer-debloating">Buffer debloating</a></li>
        <li><a href="#fine-grained-resource-management">Fine-grained Resource Management</a></li>
      </ul>
    </li>
    <li><a href="#connectors">Connectors</a>
      <ul>
        <li><a href="#connector-metrics">Connector Metrics</a></li>
        <li><a href="#pulsar-connector">Pulsar Connector</a></li>
      </ul>
    </li>
    <li><a href="#pyflink">PyFlink</a>
      <ul>
        <li><a href="#performance-improvements-through-chaining">Performance Improvements through Chaining</a></li>
        <li><a href="#loopback-mode-for-debugging">Loopback Mode for Debugging</a></li>
        <li><a href="#miscellaneous-improvements">Miscellaneous Improvements</a></li>
      </ul>
    </li>
    <li><a href="#goodbye-legacy-sql-engine-and-mesos-support">Goodbye Legacy SQL Engine and Mesos Support</a></li>
    <li><a href="#upgrade-notes">Upgrade Notes</a></li>
    <li><a href="#list-of-contributors">List of Contributors</a></li>
  </ul>
</nav>


          </aside>
          <aside class="expand-toc hidden">
            <a class="toc" onclick="expandToc()" href="javascript:void(0)">
              <i class="fa fa-bars" aria-hidden="true"></i>
            </a>
          </aside>
        
      </main>

      <footer>
        


<div class="separator"></div>
<div class="panels">
  <div class="wrapper">
      <div class="panel">
        <ul>
          <li>
            <a href="https://flink-packages.org/">flink-packages.org</a>
          </li>
          <li>
            <a href="https://www.apache.org/">Apache Software Foundation</a>
          </li>
          <li>
            <a href="https://www.apache.org/licenses/">License</a>
          </li>
          
          
          
            
          
            
          
          

          
            
              
            
          
            
              
                <li>
                  <a  href="/zh/">
                    <i class="fa fa-globe" aria-hidden="true"></i>&nbsp;中文版
                  </a>
                </li>
              
            
          
       </ul>
      </div>
      <div class="panel">
        <ul>
          <li>
            <a href="/what-is-flink/security">Security</a-->
          </li>
          <li>
            <a href="https://www.apache.org/foundation/sponsorship.html">Donate</a>
          </li>
          <li>
            <a href="https://www.apache.org/foundation/thanks.html">Thanks</a>
          </li>
       </ul>
      </div>
      <div class="panel icons">
        <div>
          <a href="/posts">
            <div class="icon flink-blog-icon"></div>
            <span>Flink blog</span>
          </a>
        </div>
        <div>
          <a href="https://github.com/apache/flink">
            <div class="icon flink-github-icon"></div>
            <span>Github</span>
          </a>
        </div>
        <div>
          <a href="https://twitter.com/apacheflink">
            <div class="icon flink-twitter-icon"></div>
            <span>Twitter</span>
          </a>
        </div>
      </div>
  </div>
</div>

<hr/>

<div class="container disclaimer">
  <p>The contents of this website are © 2024 Apache Software Foundation under the terms of the Apache License v2. Apache Flink, Flink, and the Flink logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.</p>
</div>



      </footer>
    
  </body>
</html>






