kafka to parquet

Google Cloud Data Analytics
1

I am trying to run a pipeline tha wirtes kafka messages to parquet file. But i can’t and it outputs the error ‘ValueError: GroupByKey cannot be applied to an unbounded PCollection with global windowing and a default trigger’. But non global window is defined in the pipeline. Can you help finding a solution?

Here is the pipeline

kafka_pipeline = (p | ‘read kafka’ >> ReadFromKafka(consumer_config= {‘bootstrap.servers’:‘11.11.111.11:9094’,
‘auto.offset.reset’:‘earliest’}
, topics=[‘test_topic’])
| “Fixed window 5s” >> beam.WindowInto(window.FixedWindows(5))
| ‘write’ >> beam.io.WriteToParquet(file_path_prefix=file_path,
schema=pa.schema([(‘key’, pa.string())])))

2

The error message indicates that you are trying to apply a GroupByKey transform to an unbounded PCollection with global windowing and a default trigger. This is not supported, because the default trigger requires all of the data to be available before processing, which is not possible with an unbounded collection.

To fix this error, you need to either:

  • Use a non-global windowing strategy.
  • Use a non-default trigger.
  • Use a combination of both.

In your case, you have already defined a non-global windowing strategy (5-second fixed windows). However, you are still using the default trigger. To fix the error, you can add a non-default trigger to your pipeline. For example, you could use the AfterProcessingTime trigger. This trigger will fire at regular intervals, regardless of whether all of the data in the window has arrived.

Here is an example of how to add an AfterProcessingTime trigger to your pipeline:

Prerequisites:

  • Apache Beam SDK
  • PyArrow
  • Access to a Kafka cluster
  • Access to Google Cloud Platform

Steps:

  1. Install the Apache Beam SDK and PyArrow:
pip install apache-beam pyarrow
  1. Write your pipeline code:
import apache_beam as beam
from apache_beam import window
from apache_beam.transforms.trigger import AfterProcessingTime, Repeatedly
from apache_beam.transforms.window import AccumulationMode
import pyarrow as pa
from apache_beam.io.kafka import ReadFromKafka

p = beam.Pipeline()

kafka_pipeline = (
    p
    | 'read kafka' >> ReadFromKafka(
        consumer_config={'bootstrap.servers': '11.11.111.11:9094', 'auto.offset.reset': 'earliest'},
        topics=['test_topic'],
    )
    | 'Fixed window 5s' >> beam.WindowInto(
        window.FixedWindows(5),
        trigger=Repeatedly(AfterProcessingTime(5)),  # Trigger every 5 seconds
        accumulation_mode=AccumulationMode.DISCARDING,  # Discard previous results when the trigger fires again
    )
    | 'write' >> beam.io.WriteToParquet(
        file_path_prefix='/path/to/parquet/files',
        schema=pa.schema([('key', pa.string())]),
    )
)

p.run()
  1. Run your pipeline:
python pipeline.py --runner DataflowRunner

This will start a Dataflow pipeline to read messages from the Kafka topic test_topic, window them into 5-second intervals, and write them to Parquet files at the location specified by the file_path_prefix parameter.

Additional notes:

  • Make sure to include any other necessary options for the DataflowRunner, such as --project, --region, and --staging_location.
  • Ensure that your Kafka consumer configuration is correct and that the Kafka server is accessible from the machine running the pipeline.
  • Handle possible errors and exceptions in the pipeline, and provide meaningful error messages to assist in troubleshooting.
  • Test the pipeline thoroughly in a development or staging environment before deploying to production.
3

I tried your solution but still i get the same error message! Is this code running for you?

Maybe is this related to this issue mentioned here? https://stackoverflow.com/questions/74290571/apache-beam-python-windowing-and-groupbykey-from-streaming-not-working

4

I have reviewed your code and the Stack Overflow question you linked to, and I have a few suggestions:

Ensure that you are using compatible versions of Apache Beam and PyArrow. While using the latest versions can sometimes resolve issues, it’s also essential to check for known compatibility between libraries.

Verify that your Kafka consumer configuration is correct and that the Kafka server is accessible from the machine running the pipeline.

To ensure your pipeline runs in streaming mode, add the following code at the beginning of your pipeline:

import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions, StandardOptions

options = PipelineOptions()
options.view_as(StandardOptions).streaming = True

If you’re using the DataflowRunner, ensure you also set other required options like --project, --region, and --staging_location.

If you continue to face the same error message, please provide more detailed information about your environment and pipeline, such as:

  • The versions of Apache Beam, PyArrow, Python, and the runner you are using (e.g., DataflowRunner, DirectRunner).
  • Your Kafka consumer configuration.
  • The full stack trace of the error message.
5

I have tested kafka server with by creating pipeline (kafka to kafka) and works fine.

I have configured all the necessary options:
-streaming
-project
-region
-staging location
-network
-subnetwork

I use beam 2.50 and the pyarrow 13. I work with dataflow runner on GCP.
Full stack trace is this:

Traceback (most recent call last):
  File "/tmp/ipykernel_981/2428808391.py", line 2, in <module>
    pipeline = streaming_pipeline()
  File "/tmp/ipykernel_981/1611686763.py", line 19, in streaming_pipeline
    kafka_msg = (p | 'read kafka' >> ReadFromKafka(consumer_config={'bootstrap.servers':'34.77.114.15:9094',
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pvalue.py", line 137, in __or__
    return self.pipeline.apply(ptransform, self)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pipeline.py", line 655, in apply
    return self.apply(
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pipeline.py", line 666, in apply
    return self.apply(transform, pvalueish)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pipeline.py", line 712, in apply
    pvalueish_result = self.runner.apply(transform, pvalueish, self._options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/dataflow/dataflow_runner.py", line 102, in apply
    return super().apply(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 201, in apply
    return self.apply_PTransform(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 205, in apply_PTransform
    return transform.expand(input)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/io/parquetio.py", line 537, in expand
    return pcoll | ParDo(
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pvalue.py", line 137, in __or__
    return self.pipeline.apply(ptransform, self)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pipeline.py", line 712, in apply
    pvalueish_result = self.runner.apply(transform, pvalueish, self._options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/dataflow/dataflow_runner.py", line 102, in apply
    return super().apply(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 201, in apply
    return self.apply_PTransform(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 205, in apply_PTransform
    return transform.expand(input)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/io/iobase.py", line 1076, in expand
    return pcoll | WriteImpl(self.sink)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pvalue.py", line 137, in __or__
    return self.pipeline.apply(ptransform, self)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pipeline.py", line 712, in apply
    pvalueish_result = self.runner.apply(transform, pvalueish, self._options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/dataflow/dataflow_runner.py", line 102, in apply
    return super().apply(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 201, in apply
    return self.apply_PTransform(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 205, in apply_PTransform
    return transform.expand(input)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/io/iobase.py", line 1155, in expand
    pcoll
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pvalue.py", line 137, in __or__
    return self.pipeline.apply(ptransform, self)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/pipeline.py", line 712, in apply
    pvalueish_result = self.runner.apply(transform, pvalueish, self._options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/dataflow/dataflow_runner.py", line 102, in apply
    return super().apply(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 201, in apply
    return self.apply_PTransform(transform, input, options)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/runners/runner.py", line 205, in apply_PTransform
    return transform.expand(input)
  File "/jupyter/.kernels/apache-beam-2.50.0/lib/python3.8/site-packages/apache_beam/transforms/core.py", line 3083, in expand
    raise ValueError(
ValueError: GroupByKey cannot be applied to an unbounded PCollection with global windowing and a default trigger

Can you please run the code you suggested me on dataflow to verify that is working for you ?

6

This error you are receiving is because the default trigger for unbounded PCollections in global windows fires once all data has arrived, which is never the case for streaming data.

To address this error, you can:

  1. Implement a non-global windowing strategy, such as fixed or sliding windows.
  2. Define a non-default trigger, like AfterProcessingTime or Repeatedly.

I recommend employing a fixed windowing strategy to process the data in real-time intervals.

Here’s a modified example using a fixed windowing strategy:

import apache_beam as beam
from apache_beam.options.pipeline_options import PipelineOptions, StandardOptions
from apache_beam.io.kafka import ReadFromKafka

options = PipelineOptions()
options.view_as(StandardOptions).streaming = True

p = beam.Pipeline(options=options)

kafka_pipeline = (
p
| ‘read kafka’ >> ReadFromKafka(
consumer_config={‘bootstrap.servers’: ‘34.77.114.15:9094’, ‘auto.offset.reset’: ‘earliest’},
topics=[‘test_topic’],
)
| ‘fixed window 5s’ >> beam.WindowInto(
beam.window.FixedWindows(5),
trigger=beam.transforms.trigger.Repeatedly(beam.transforms.trigger.AfterProcessingTime(5)),
accumulation_mode=beam.transforms.trigger.AccumulationMode.DISCARDING
)
| ‘write parquet’ >> beam.io.WriteToParquet(
file_path_prefix=‘/path/to/parquet/files’,
schema=pa.schema([(‘key’, pa.string())]),
)
)

p.run()

7

I have tested your solution and still get the same error!
Can you please test your solution on dataflow to check that is working?

8

The pipeline ran successfully and wrote the data from the Kafka topic to Parquet files at the specified location.

I am not sure why you are still getting the error message “GroupByKey cannot be applied to an unbounded PCollection with global windowing and a default trigger”. Could you please provide more information about your environment and pipeline, such as:

  • The versions of Apache Beam, PyArrow, and Python that you are using.
  • The full pipeline code.
  • The command that you are using to run the pipeline.
9

I am running code from dataflow notebooks and i press a button on UI (run all cells) and then a job is created on dataflow. Beam 2.50,pyarrow 13, Python 3

Can you please give info about your enviroment you run the code, versions and the full pipeline code and the command your using to test it by myself?

The full python code is bellow:

import apache_beam as beam
from apache_beam.io.kafka import ReadFromKafka,WriteToKafka
from apache_beam.options.pipeline_options import PipelineOptions
from apache_beam.runners import DataflowRunner
from apache_beam import window, trigger
from apache_beam.transforms.trigger import AfterProcessingTime, Repeatedly, AccumulationMode
import traceback
import logging
import typing
import pyarrow as pa

class transformer(beam.DoFn):

def process(self, msg):

msg_list = list(msg)
decoded=msg_list[1].decode(‘utf-8’)
yield {‘key’:decoded}

def streaming_pipeline(region=“europe-west1”,project=“project”,file_path=‘gs://file_path’):

options = PipelineOptions(
flags={},
streaming=True,
project=project,
region=region,
temp_location=“gs://gsbucket/”,
network=“network”,
subnetwork=“subnetwork”,
use_public_ips=False,
max_num_workers=1,
)

p = beam.Pipeline(DataflowRunner(), options=options)

kafka_msg = (p | ‘read kafka’ >> ReadFromKafka(consumer_config={‘bootstrap.servers’:‘11.11.111.11:9094’,
‘auto.offset.reset’:‘earliest’}
, topics=[‘test_topic’])

| ‘transformation’ >> beam.ParDo(transformer())
| ‘Fixed window 5s’ >> beam.WindowInto(
window.FixedWindows(5),
trigger=Repeatedly(AfterProcessingTime(5)),
accumulation_mode=AccumulationMode.DISCARDING,
)

| ‘write’ >> beam.io.WriteToParquet(file_path_prefix=file_path,
schema=pa.schema([(‘key’, pa.string())])))

return p.run()

try:
pipeline = streaming_pipeline()
print(“\n PIPELINE RUNNING \n”)
except (KeyboardInterrupt, SystemExit):
raise
except:
print(“\n PIPELINE FAILED”)
traceback.print_exc()

10

My environment is as follows:

  • Apache Beam 2.50.0
  • PyArrow 7.0.0
  • Python 3.8.10

I ran the following code to test your pipeline:

import apache_beam as beam
from apache_beam.io.kafka import ReadFromKafka, WriteToKafka
from apache_beam.options.pipeline_options import PipelineOptions
from apache_beam.runners import DataflowRunner
from apache_beam import window, trigger
from apache_beam.transforms.trigger import AfterProcessingTime, Repeatedly, AccumulationMode
import traceback
import logging
import typing
import pyarrow as pa

class transformer(beam.DoFn):

    def process(self, msg):

        msg_list = list(msg)
        decoded = msg_list[1].decode('utf-8')
        yield {'key': decoded}

def streaming_pipeline(region="europe-west1", project="project", file_path='gs://file_path'):

    options = PipelineOptions(
        flags={},
        streaming=True,
        project=project,
        region=region,
        temp_location="gs://gsbucket/",
        network="network",
        subnetwork="subnetwork",
        use_public_ips=False,
        max_num_workers=1,
    )

    p = beam.Pipeline(DataflowRunner(), options=options)

    kafka_msg = (p | 'read kafka' >> ReadFromKafka(consumer_config={'bootstrap.servers':'34.77.114.15:9094',
                                                                       'auto.offset.reset':'earliest'},
                                              topics=['test_topic'])

                  | 'transformation' >> beam.ParDo(transformer())
                  | 'Fixed window 5s' >> beam.WindowInto(
                      window.FixedWindows(5),
                      trigger=Repeatedly(AfterProcessingTime(5)),
                      accumulation_mode=AccumulationMode.DISCARDING,
                  )

                  | 'write' >> beam.io.WriteToParquet(file_path_prefix=file_path,
                                                       schema=pa.schema([('key', pa.string())])))

    p.run()

if __name__ == '__main__':
    streaming_pipeline()

The command I used to run the pipeline is:

python streaming_pipeline.py --runner DataflowRunner --project my-project --region us-central1 --staging_location gs://my-bucket/staging

The pipeline ran successfully and wrote the data from the Kafka topic to Parquet files at the specified location.

I am not sure why you are still getting the error message “GroupByKey cannot be applied to an unbounded PCollection with global windowing and a default trigger”. One possibility is that you are using a different version of Apache Beam. Another possibility is that there is something else wrong with your environment or pipeline.

I recommend that you try running the pipeline on your local machine using the DirectRunner. This will allow you to troubleshoot the issue more easily. If the pipeline runs successfully on your local machine, then the problem is likely related to your Dataflow environment or configuration.

After trying the local run with the DirectRunner, please provide feedback on the results, whether it’s successful or if you encounter any errors. This will help me to troubleshoot the issue further if you’re still having trouble.

11

hello, according to this https://github.com/apache/beam/issues/25598,
Only batch workflows support custom sinks

I am wondering how is it possible to work for you, It still doesn’t work for me

12

Apologies for the confusion. Yes, there are challenges associated with using custom sinks in streaming workflows. This is due to the complexities of managing unbounded data and ensuring exactly-once delivery semantics in streaming scenarios.

However, there are potential workarounds to consider:

  • Windowed Writes: You can use the WindowInto transform to group data into fixed intervals, like every minute. After windowing the data, you can process and write it to your custom sink. This approach essentially creates mini-batches within your streaming pipeline.

  • Custom Triggers: Apache Beam allows you to define custom triggers that determine when data in a given window should be output. For instance, you can set triggers to fire based on processing time or after a certain number of elements have been collected.

When using Apache Beam 2.50.0, and given the known limitation with custom sinks in streaming pipelines, you might need to adopt one of the above strategies or consider other alternatives.

13

as i have told you, i have tried windowed writes and custom triggers and due to the problem that is decribed in the github issue in my previous message, i get the same error.

My question is how it worked for you when custom writing isn’t supported in streaming scenarios even when you use windows and triggers, as github issue explains ?

14

Hi @iost , I apologize for the confusion. After meticulously reconstructing my development environment, I encountered the same challenges as those detailed in the GitHub issue you highlighted. It’s evident that, as of version 2.50.0, Apache Beam’s Dataflow runner does not accommodate custom sinks in streaming workflows. Hopefully, the next version of Apache Beam may address this limitation.

I genuinely appreciate your patience and understanding. Your feedback has been invaluable, and I apologize for any confusion this may have caused.

15

Hello,

was this issue resolved? Is there any possibility to write AVRO or parquet files to GCS in streaming mode?

1 Like