You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by bb...@apache.org on 2019/12/09 21:37:08 UTC
[kafka-site] branch asf-site updated: port paragraph (#244)
This is an automated email from the ASF dual-hosted git repository.
bbejeck pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/kafka-site.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 6aeacd2 port paragraph (#244)
6aeacd2 is described below
commit 6aeacd2b19e94fef060c3d1b2a7e46acfdfd9e64
Author: A. Sophie Blee-Goldman <so...@confluent.io>
AuthorDate: Mon Dec 9 13:37:02 2019 -0800
port paragraph (#244)
from apache/kafka#7808
Reviewers: Bill Bejeck <bb...@gmail.com>
---
0102/streams/architecture.html | 8 ++++++++
0110/streams/architecture.html | 8 ++++++++
10/architecture.html | 8 ++++++++
11/streams/architecture.html | 8 ++++++++
20/streams/architecture.html | 8 ++++++++
21/streams/architecture.html | 8 ++++++++
22/streams/architecture.html | 8 ++++++++
23/streams/architecture.html | 8 ++++++++
24/streams/architecture.html | 8 ++++++++
9 files changed, 72 insertions(+)
diff --git a/0102/streams/architecture.html b/0102/streams/architecture.html
index ee601f8..7754b9c 100644
--- a/0102/streams/architecture.html
+++ b/0102/streams/architecture.html
@@ -55,6 +55,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that “runs” anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/0110/streams/architecture.html b/0110/streams/architecture.html
index 0dbb1dc..5b5e59e 100644
--- a/0110/streams/architecture.html
+++ b/0110/streams/architecture.html
@@ -53,6 +53,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/10/architecture.html b/10/architecture.html
index efc01bd..0b16762 100644
--- a/10/architecture.html
+++ b/10/architecture.html
@@ -53,6 +53,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/11/streams/architecture.html b/11/streams/architecture.html
index 8bc3156..7efd7ea 100644
--- a/11/streams/architecture.html
+++ b/11/streams/architecture.html
@@ -66,6 +66,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/20/streams/architecture.html b/20/streams/architecture.html
index 8bc3156..7efd7ea 100644
--- a/20/streams/architecture.html
+++ b/20/streams/architecture.html
@@ -66,6 +66,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/21/streams/architecture.html b/21/streams/architecture.html
index 8bc3156..7efd7ea 100644
--- a/21/streams/architecture.html
+++ b/21/streams/architecture.html
@@ -66,6 +66,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/22/streams/architecture.html b/22/streams/architecture.html
index 8bc3156..7efd7ea 100644
--- a/22/streams/architecture.html
+++ b/22/streams/architecture.html
@@ -66,6 +66,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/23/streams/architecture.html b/23/streams/architecture.html
index 8bc3156..7efd7ea 100644
--- a/23/streams/architecture.html
+++ b/23/streams/architecture.html
@@ -66,6 +66,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned
diff --git a/24/streams/architecture.html b/24/streams/architecture.html
index 8bc3156..7efd7ea 100644
--- a/24/streams/architecture.html
+++ b/24/streams/architecture.html
@@ -66,6 +66,14 @@
</p>
<p>
+ Slightly simplified, the maximum parallelism at which your application may run is bounded by the maximum number of stream tasks, which itself is determined by
+ maximum number of partitions of the input topic(s) the application is reading from. For example, if your input topic has 5 partitions, then you can run up to 5
+ applications instances. These instances will collaboratively process the topic’s data. If you run a larger number of app instances than partitions of the input
+ topic, the “excess” app instances will launch but remain idle; however, if one of the busy instances goes down, one of the idle instances will resume the former’s
+ work.
+ </p>
+
+ <p>
It is important to understand that Kafka Streams is not a resource manager, but a library that "runs" anywhere its stream processing application runs.
Multiple instances of the application are executed either on the same machine, or spread across multiple machines and tasks can be distributed automatically
by the library to those running application instances. The assignment of partitions to tasks never changes; if an application instance fails, all its assigned