update go sample to declarative function and add multiple functions sample (#78)

* update hello-world-go to declarative function, add a multiple functions sample

Signed-off-by: Lize Cai <lize.cai@sap.com>

* update go ff to v0.2.4

Signed-off-by: Lize Cai <lize.cai@sap.com>

* update go-builder to v2.3.0, update go-ff to v0.3.0 in http sample

Signed-off-by: Lize Cai <lize.cai@sap.com>

* update ff-go to v0.3.0 in knative go function samples

Signed-off-by: Lize Cai <lize.cai@sap.com>

* add suffix for builder-go -> builder-go:v2.3.0-1.16

Signed-off-by: Lize Cai <lize.cai@sap.com>

Author: lizzzcai

functions-framework/golang/Knative/http/go.mod

@@ -3,7 +3,7 @@ module main.go
 go 1.16
 
 require (
-	github.com/OpenFunction/functions-framework-go v0.2.2
+	github.com/OpenFunction/functions-framework-go v0.3.0
 	github.com/fatih/structs v1.1.0
 	k8s.io/klog/v2 v2.30.0
 )

functions/knative/hello-world-go/README.md

@@ -6,6 +6,27 @@
 
 You can refer to the [Installation Guide](https://github.com/OpenFunction/OpenFunction#install-openfunction) to setup OpenFunction.
 
+## Run it locally
+
+Build the function locally
+
+```sh
+pack build func-helloworld-go --builder openfunction/builder-go:v2.3.0-1.16 --env FUNC_NAME="HelloWorld"  --env FUNC_CLEAR_SOURCE=true
+```
+
+Run the function
+
+```sh
+docker run --rm --env="FUNC_CONTEXT={\"name\":\"HelloWorld\",\"version\":\"v1.0.0\",\"port\":\"8080\",\"runtime\":\"Knative\"}" --env="CONTEXT_MODE=self-host" --name func-helloworld-go -p 8080:8080 func-helloworld-go
+```
+
+Send a request
+
+```sh
+curl http://localhost:8080/OpenFunction
+# Hello, OpenFunction!
+```
+
 ## Deployment
 
 1. Create secret

functions/knative/hello-world-go/go.mod

@@ -1,3 +1,5 @@
 module example.com/hello
 
 go 1.16
+
+require github.com/OpenFunction/functions-framework-go v0.3.0

functions/knative/hello-world-go/hello.go

@@ -3,8 +3,14 @@ package hello
 import (
 	"fmt"
 	"net/http"
+
+	"github.com/OpenFunction/functions-framework-go/functions"
 )
 
+func init() {
+	functions.HTTP("HelloWorld", HelloWorld)
+}
+
 func HelloWorld(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, "Hello, %s!\n", r.URL.Path[1:])
 }

functions/knative/multiple-functions-go/README.md

@@ -0,0 +1,136 @@
+# Sample Function Go
+
+## Prerequisites
+
+### OpenFunction
+
+You can refer to the [Installation Guide](https://github.com/OpenFunction/OpenFunction#install-openfunction) to setup OpenFunction.
+
+## Run it locally
+
+Build the function locally
+
+```sh
+pack build multiple-functions-go --builder openfunction/builder-go:v2.3.0-1.16 --env FUNC_NAME="MultipleFunctions"  --env FUNC_CLEAR_SOURCE=true
+```
+
+Run the function
+
+```sh
+docker run --rm --env="FUNC_CONTEXT={\"name\":\"MultipleFunctions\",\"version\":\"v1.0.0\",\"port\":\"8080\",\"runtime\":\"Knative\"}" --env="CONTEXT_MODE=self-host" --name multiple-functions-go -p 8080:8080 multiple-functions-go
+```
+
+Send a request
+
+```sh
+curl http://localhost:8080/bar
+# hello, bar!
+
+curl http://localhost:8080/foo
+# {"hello":"foo!"}%  
+```
+
+
+## Deployment
+
+1. Create secret
+
+Generate a secret to access your container registry, such as one on [Docker Hub](https://hub.docker.com/) or [Quay.io](https://quay.io/).
+You can create this secret by editing the ``REGISTRY_SERVER``, ``REGISTRY_USER`` and ``REGISTRY_PASSWORD`` fields in following command, and then run it.
+
+  ```bash
+  REGISTRY_SERVER=https://index.docker.io/v1/ REGISTRY_USER=<your_registry_user> REGISTRY_PASSWORD=<your_registry_password>
+  kubectl create secret docker-registry push-secret \
+      --docker-server=$REGISTRY_SERVER \
+      --docker-username=$REGISTRY_USER \
+      --docker-password=$REGISTRY_PASSWORD
+  ```
+
+2. Create function
+
+   For sample function below, modify the ``spec.image`` field in ``function-sample.yaml`` to your own container registry address:
+
+    ```yaml
+    apiVersion: core.openfunction.io/v1beta1
+    kind: Function
+    metadata:
+      name: function-sample
+    spec:
+      image: "<your registry name>/sample-go-multi-func:latest"
+    ```
+
+   Use the following command to create this Function:
+
+    ```shell
+    kubectl apply -f function-sample.yaml
+    ```
+
+3. Access function
+
+   You can observe the process of a function with the following command:
+
+    ```shell
+   kubectl get functions.core.openfunction.io
+   
+   NAME              BUILDSTATE   SERVINGSTATE   BUILDER         SERVING         URL                                              AGE
+   function-sample   Succeeded    Running        builder-jgnzp   serving-q6wdp   http://openfunction.io/default/function-sample   22m
+    ```
+
+   The `URL` is the address provided by the OpenFunction Domain that can be accessed. To access the function via this URL address, you need to make sure that DNS can resolve this address.
+
+   > You can use the following command to create a pod in the cluster and access the function from the pod:
+   >
+   > ```shell
+   > kubectl run curl --image=radial/busyboxplus:curl -i --tty
+   > ```
+   
+   Access the function via `URL`:
+   
+   ```shell
+   [ root@curl:/ ]$ curl http://openfunction.io.svc.cluster.local/default/function-sample/foo
+   {"hello":"foo!"}%
+   
+   [ root@curl:/ ]$ curl http://openfunction.io.svc.cluster.local/default/function-sample/bar
+   hello, bar!
+   ```
+   
+   There is also an alternative way to trigger the function via the access address provided by the Knative Services:
+
+    ```shell
+    kubectl get ksvc
+     
+    NAME                       URL                                                            LATESTCREATED                   LATESTREADY                     READY   REASON
+    serving-q6wdp-ksvc-wk6mv   http://serving-q6wdp-ksvc-wk6mv.default.<external-ip>.sslip.io   serving-q6wdp-ksvc-wk6mv-v100   serving-q6wdp-ksvc-wk6mv-v100   True
+    ```
+   
+   Or get the service address directly with the following command:
+   
+   > where` <external-ip> `indicates the external address of your gateway service.
+   >
+   > You can do a simple configuration to use the node ip as the `<external-ip>` as follows  (Assuming you are using Kourier as network layer of Knative). Where `1.2.3.4` can be replaced by your node ip.
+   >
+   > ```shell
+    > kubectl patch svc -n kourier-system kourier \
+    >   -p '{"spec": {"type": "LoadBalancer", "externalIPs": ["1.2.3.4"]}}'
+    > 
+    > kubectl patch configmap/config-domain -n knative-serving \
+    >   --type merge --patch '{"data":{"1.2.3.4.sslip.io":""}}'
+    > ```
+   
+    ```shell
+    kubectl get ksvc serving-q6wdp-ksvc-wk6mv -o jsonpath={.status.url}
+     
+    http://serving-q6wdp-ksvc-wk6mv.default.<external-ip>.sslip.io
+    ```
+   
+   Access the above service address via commands such as ``curl``:
+   
+    ```shell
+    curl http://serving-q6wdp-ksvc-wk6mv.default.<external-ip>.sslip.io/foo
+     
+    {"hello":"foo!"}%
+    
+    curl http://serving-q6wdp-ksvc-wk6mv.default.<external-ip>.sslip.io/bar
+     
+    hello, bar!
+    ```

functions/knative/multiple-functions-go/function-sample.yaml

@@ -0,0 +1,25 @@
+apiVersion: core.openfunction.io/v1beta1
+kind: Function
+metadata:
+  name: function-sample
+spec:
+  version: "v2.0.0"
+  image: "openfunctiondev/sample-go-multi-func:latest"
+  imageCredentials:
+    name: push-secret
+  port: 8080 # default to 8080
+  build:
+    builder: openfunction/builder-go:latest
+    env:
+      FUNC_NAME: "MultipleFunctions"
+      FUNC_CLEAR_SOURCE: "true"
+    srcRepo:
+      url: "https://github.com/OpenFunction/samples.git"
+      sourceSubPath: "functions/knative/multiple-functions-go"
+      revision: "main"
+  serving:
+    template:
+      containers:
+        - name: function
+          imagePullPolicy: Always
+    runtime: "knative"

functions/knative/multiple-functions-go/go.mod

@@ -0,0 +1,5 @@
+module example.com/hello
+
+go 1.16
+
+require github.com/OpenFunction/functions-framework-go v0.3.0

functions/knative/multiple-functions-go/http.go

@@ -0,0 +1,28 @@
+package hello
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	"github.com/OpenFunction/functions-framework-go/functions"
+)
+
+func init() {
+	functions.HTTP("Foo", Foo, functions.WithFunctionPath("/foo"))
+	functions.HTTP("Bar", Bar, functions.WithFunctionPath("/bar"))
+
+}
+
+func Foo(w http.ResponseWriter, r *http.Request) {
+	response := map[string]string{
+		"hello": "foo!",
+	}
+	responseBytes, _ := json.Marshal(response)
+	w.Header().Set("Content-type", "application/json")
+	w.Write(responseBytes)
+}
+
+func Bar(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintln(w, "hello, bar!\n")
+}