jerrypeng commented on a change in pull request #4725: [docs] Add
functions-develop file for Pulsar Functions(new)
URL: https://github.com/apache/pulsar/pull/4725#discussion_r303544514
##########
File path: site2/docs/functions-develop.md
##########
@@ -0,0 +1,570 @@
+---
+id: functions-develop
+title: Develop Pulsar Functions
+sidebar_label: Develop functions
+---
+
+This tutorial walks you through how to develop Pulsar Functions.
+
+## Available APIs
+In Java, Python, and Go, you have two options to write Pulsar Functions.
+
+Interface | Description | Use cases
+:---------|:------------|:---------
+Language-native interface | No Pulsar-specific libraries or special
dependencies required (only core libraries from Java/Python/Go). | Functions
that do not require access to the function [context](#context).
+Pulsar Function SDK for Java/Python/Go | Pulsar-specific libraries that
provide a range of functionality not provided by "native" interfaces. |
Functions that require access to the function [context](#context).
+
+<!--DOCUSAURUS_CODE_TABS-->
+<!--Java-->
+<!--Python-->
+In Python, the language-native function, which adds an exclamation point to
all incoming strings and publishes the resulting string to a topic, has no
external dependencies.
+
+```python
+def process(input):
+ return "{}!".format(input)
+```
+
+However, the function uses Pulsar Functions [SDK for
Python](#python-sdk-functions):
+
+```python
+from pulsar import Function
+
+class DisplayFunctionName(Function):
+ def process(self, input, context):
+ function_name = context.function_name()
+ return "The function processing this message has the name
{0}".format(function_name)
+```
+<!--Go-->
+The following example uses Pulsar Functions SDK.
+
+```
+import (
+ "context"
+ "fmt"
+
+ "github.com/apache/pulsar/pulsar-function-go/log"
+ "github.com/apache/pulsar/pulsar-function-go/pf"
+)
+
+func contextFunc(ctx context.Context) {
+ if fc, ok := pf.FromContext(ctx); ok {
+ tenant := fc.GetFuncTenant()
+ namespace := fc.GetFuncNamespace()
+ name := fc.GetFuncName()
+ log.Info("Function tenant/namespace/name: %s/%s/%s\n", tenant,
namespace, name)
+ }
+}
+
+func main() {
+ pf.Start(contextFunc)
+}
+
+```
+
+<!-- END_DOCUSAURUS_CODE_TABS -->
+
+## Schema registry
+Pulsar has a built in [Schema Registry](concepts-schema-registry) and comes
bundled with a variety of popular schema types(avro, json and protobuf). Pulsar
Functions can leverage existing schema information from input topics and derive
the input type. The schema registry applies for output topic as well.
+
+## SerDe
+SerDe stands for **Ser**ialization and **De**serialization. Pulsar Functions
use SerDe when publishing data to and consuming data from Pulsar topics. How
SerDe works by default depends on the language you use for a particular
function.
+
+<!--DOCUSAURUS_CODE_TABS-->
+<!--Java-->
+When you write Pulsar Functions in Java, the following basic Java types are
built in and supported by default:
+
+* `String`
+* `Double`
+* `Integer`
+* `Float`
+* `Long`
+* `Short`
+* `Byte`
+
+To customize Java types, you need to implement the following interface.
+
+```java
+public interface SerDe<T> {
+ T deserialize(byte[] input);
+ byte[] serialize(T input);
+}
+```
+
+### Example
+Imagine that you're writing Pulsar Functions in Java that are processing tweet
objects, you can refer to the following example of `Tweet` class.
+
+```java
+public class Tweet {
+ private String username;
+ private String tweetContent;
+
+ public Tweet(String username, String tweetContent) {
+ this.username = username;
+ this.tweetContent = tweetContent;
+ }
+
+ // Standard setters and getters
+}
+```
+
+To pass `Tweet` objects directly between Pulsar Functions, you need to provide
a custom SerDe class. In the example below, `Tweet` objects are basically
strings in which the username and tweet content are separated by a `|`.
+
+```java
+package com.example.serde;
+
+import org.apache.pulsar.functions.api.SerDe;
+
+import java.util.regex.Pattern;
+
+public class TweetSerde implements SerDe<Tweet> {
+ public Tweet deserialize(byte[] input) {
+ String s = new String(input);
+ String[] fields = s.split(Pattern.quote("|"));
+ return new Tweet(fields[0], fields[1]);
+ }
+
+ public byte[] serialize(Tweet input) {
+ return "%s|%s".format(input.getUsername(),
input.getTweetContent()).getBytes();
+ }
+}
+```
+
+To apply this customized SerDe to a particular Pulsar Function, you need to:
+
+* Package the `Tweet` and `TweetSerde` classes into a JAR.
+* Specify a path to the JAR and SerDe class name when deploying the function.
+
+The following is an example of [`create`](reference-pulsar-admin.md#create-1)
operation.
+
+```bash
+$ bin/pulsar-admin functions create \
+ --jar /path/to/your.jar \
+ --output-serde-classname com.example.serde.TweetSerde \
+ # Other function attributes
+```
+
+> #### Custom SerDe classes must be packaged with your function JARs
+> Pulsar does not store your custom SerDe classes separately from your Pulsar
Functions. So you need to include your SerDe classes in your function JARs. If
not, Pulsar returns an error.
+
+<!--Python-->
+In Python, the default SerDe is identity, meaning that the type is serialized
as whatever type the producer function returns.
+
+You can specify the SerDe when [creating](functions-deploying.md#cluster-mode)
or [running](functions-deploying.md#local-run-mode) functions.
+
+```bash
+$ bin/pulsar-admin functions create \
+ --tenant public \
+ --namespace default \
+ --name my_function \
+ --py my_function.py \
+ --classname my_function.MyFunction \
+ --custom-serde-inputs '{"input-topic-1":"Serde1","input-topic-2":"Serde2"}' \
+ --output-serde-classname Serde3 \
+ --output output-topic-1
+```
+
+This case contains two input topics: `input-topic-1` and `input-topic-2`, each
of which is mapped to a different SerDe class (the map must be specified as a
JSON string). The output topic, `output-topic-1`, uses the `Serde3` class for
SerDe. At the moment, all Pulsar Functions logic, include processing function
and SerDe classes, must be contained within a single Python file.
+
+When using Pulsar Functions for Python, you have three SerDe options:
+
+1. You can use the
[`IdentitySerde`](https://github.com/apache/pulsar/blob/master/pulsar-client-cpp/python/pulsar/functions/serde.py#L70),
which leaves the data unchanged. The `IdentitySerDe` is the **default**.
Creating or running a function without explicitly specifying SerDe means that
this option is used.
+2. You can use the
[`PickleSerDe`](https://github.com/apache/pulsar/blob/master/pulsar-client-cpp/python/pulsar/functions/serde.py#L62),
which uses Python [`pickle`](https://docs.python.org/3/library/pickle.html)
for SerDe.
+3. You can create a custom SerDe class by implementing the baseline
[`SerDe`](https://github.com/apache/pulsar/blob/master/pulsar-client-cpp/python/pulsar/functions/serde.py#L50)
class, which has just two methods:
[`serialize`](https://github.com/apache/pulsar/blob/master/pulsar-client-cpp/python/pulsar/functions/serde.py#L53)
for converting the object into bytes, and
[`deserialize`](https://github.com/apache/pulsar/blob/master/pulsar-client-cpp/python/pulsar/functions/serde.py#L58)
for converting bytes into an object of the required application-specific type.
+
+The table below shows when you should use each SerDe.
+
+SerDe option | When to use
+:------------|:-----------
+`IdentitySerde` | When you work with simple types like strings, Booleans,
integers.
+`PickleSerDe` | When you work with complex, application-specific types and are
comfortable with the "best effort" approach of `pickle`.
+Custom SerDe | When you require explicit control over SerDe, potentially for
performance or data compatibility purposes.
+
+### Example
+Imagine that you write Pulsar Functions in Python that are processing tweet
objects, you can refer to the following example of `Tweet` class.
+
+```python
+class Tweet(object):
+ def __init__(self, username, tweet_content):
+ self.username = username
+ self.tweet_content = tweet_content
+```
+
+In order to use this class in Pulsar Functions, you have two options:
+
+1. You can specify `PickleSerDe`, which applies the
[`pickle`](https://docs.python.org/3/library/pickle.html) library SerDe.
+2. You can create your own SerDe class. The following is an example.
+
+ ```python
+ from pulsar import SerDe
+
+ class TweetSerDe(SerDe):
+ def __init__(self, tweet):
+ self.tweet = tweet
+
+ def serialize(self, input):
+ return bytes("{0}|{1}".format(self.tweet.username,
self.tweet.tweet_content))
+
+ def deserialize(self, input_bytes):
+ tweet_components = str(input_bytes).split('|')
+ return Tweet(tweet_components[0], tweet_componentsp[1])
+ ```
+<!--Go-->
+
+<!--END_DOCUSAURUS_CODE_TABS-->
+
+
+In both languages, however, you can write custom SerDe logic for more complex,
application-specific types.
+
+## Context
+Both the [Java](#java-sdk-functions) and [Python](#python-sdk-functions) SDKs
provide access to a **context object** that can be used by a function. This
context object provides a wide variety of information and functionality to the
function.
+
+* The name and ID of a Pulsar Function.
+* The message ID of each message. Each Pulsar message is automatically
assigned with an ID.
+* The name of the topic to which the message is sent.
+* The names of all input topics as well as the output topic associated with
the function.
+* The name of the class used for
[SerDe](#serialization-and-deserialization-serde).
+* The [tenant](reference-terminology.md#tenant) and namespace associated with
the function.
+* The ID of the Pulsar Functions instance running the function.
+* The version of the function.
+* The [logger object](functions-overview.md#logging) used by the function,
which can be used to create function log messages.
+* Access to arbitrary [user configuration](#user-configuration) values
supplied via the CLI.
+* An interface for recording [metrics](functions-metrics.md).
+* An interface for storing and retrieving state in [state
storage](functions-overview.md#state-storage).
+
+<!--DOCUSAURUS_CODE_TABS-->
+<!--Java-->
+The {@inject: javadoc:Context:/client/org/apache/pulsar/functions/api/Context}
interface provides a number of methods that you can use to access the function
[context](#context). The various method signatures for the `Context` interface
are listed as follows.
+
+```java
+public interface Context {
+ Record<?> getCurrentRecord();
+ Collection<String> getInputTopics();
+ String getOutputTopic();
+ String getOutputSchemaType();
+ String getTenant();
+ String getNamespace();
+ String getFunctionName();
+ String getFunctionId();
+ String getInstanceId();
+ String getFunctionVersion();
+ Logger getLogger();
+ void incrCounter(String key, long amount);
+ long getCounter(String key);
+ void putState(String key, ByteBuffer value);
+ ByteBuffer getState(String key);
+ Map<String, Object> getUserConfigMap();
+ Optional<Object> getUserConfigValue(String key);
+ Object getUserConfigValueOrDefault(String key, Object defaultValue);
+ void recordMetric(String metricName, double value);
+ <O> CompletableFuture<Void> publish(String topicName, O object, String
schemaOrSerdeClassName);
+ <O> CompletableFuture<Void> publish(String topicName, O object);
+}
+```
+
+The following example uses several methods available via the `Context` object.
+
+```java
+import org.apache.pulsar.functions.api.Context;
+import org.apache.pulsar.functions.api.Function;
+import org.slf4j.Logger;
+
+import java.util.stream.Collectors;
+
+public class ContextFunction implements Function<String, Void> {
+ public Void process(String input, Context context) {
+ Logger LOG = context.getLogger();
+ String inputTopics =
context.getInputTopics().stream().collect(Collectors.joining(", "));
+ String functionName = context.getFunctionName();
+
+ String logMessage = String.format("A message with a value of \"%s\"
has arrived on one of the following topics: %s\n",
+ input,
+ inputTopics);
+
+ LOG.info(logMessage);
+
+ String metricName = String.format("function-%s-messages-received",
functionName);
+ context.recordMetric(metricName, 1);
+
+ return null;
+ }
+}
+```
+
+<!--Go-->
Review comment:
Should we provide some context that this is the GO API
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
With regards,
Apache Git Services
