Merge pull request #184 from fnproject/mww-190814-node-notrig

Update node tutorial to use invoke endpoint instead of http trigger

Author: michael-w-williams

node/intro/README.md

@@ -4,7 +4,7 @@ your laptop, server, or cloud.  In this introductory tutorial we'll walk through
 developing a function using the JavaScript programming language and Node.js
 (without installing any Node.js tools!) and deploying that function to a local
 Fn server.  We'll also learn about the core Fn concepts like applications and
-triggers.
+invoke endpoints.
 
 ### Before you Begin
 * Set aside about 15 minutes to complete this tutorial.
@@ -29,7 +29,7 @@ In the terminal type the following.
 
 ![user input](images/userinput.png)
 >```
-> fn init --runtime node --trigger http nodefn
+> fn init --runtime node nodefn
 >```
 
 The output will be
@@ -43,9 +43,8 @@ func.yaml created.
 The `fn init` command creates a simple function with a bit of boilerplate to get
 you started. The `--runtime` option is used to indicate that the function we're
 going to develop will be written in Node. A number of other runtimes are also
-supported.  The `--trigger` option creates an HTTP trigger for the function
-allowing you to invoke the function from a URL. Fn creates the simple function
-along with several supporting files in the `/nodefn` directory.
+supported.  Fn creates the simple function along with several supporting files
+in the `/nodefn` directory.
 
 ### Review your Function File
 
@@ -107,10 +106,6 @@ name: nodefn
 version: 0.0.1
 runtime: node
 entrypoint: node func.js
-triggers:
-- name: nodefn
-  type: http
-  source: /nodefn
 ```
 
 The generated `func.yaml` file contains metadata about your function and
@@ -123,7 +118,6 @@ declares a number of properties including:
 in `--runtime`.
 * entrypoint--the name of the Docker execution command to invoke when your function is called,
 in this case `node func.js`.
-* triggers--identifies the automatically generated trigger name and source. For example, this function would be requested from the URL `http://localhost:8080/t/appname/nodefn`. Where `appname` is the name of the app chosen for your function when it is deployed.
 
 There are other user specifiable properties but these will suffice for
 this example.  Note that the name of your function is taken from the containing
@@ -202,57 +196,34 @@ FN_REGISTRY:  fndemouser
 Current Context:  default
 Sending build context to Docker daemon   5.12kB
 Step 1/9 : FROM fnproject/node:dev as build-stage
-dev: Pulling from fnproject/node
-bdf0201b3a05: Already exists 
-ed514f6061af: Already exists 
-bc8940a76c7f: Already exists 
-Digest: sha256:c77966d42f46328662978a68ecd5b3b3b26cf9e4c29a91c6064f07f59f97621a
-Status: Downloaded newer image for fnproject/node:dev
  ---> b557a05fec78
 Step 2/9 : WORKDIR /function
- ---> Running in 62a348f4d39b
-Removing intermediate container 62a348f4d39b
+ ---> Using cache
  ---> ea3ae80dbec2
 Step 3/9 : ADD package.json /function/
+ ---> Using cache
  ---> e7d319e022d2
 Step 4/9 : RUN npm install
- ---> Running in c963c8b1f699
-npm notice created a lockfile as package-lock.json. You should commit this file.
-npm WARN [email protected] No repository field.
-
-added 1 package from 2 contributors and audited 1 package in 0.935s
-found 0 vulnerabilities
-
-Removing intermediate container c963c8b1f699
+ ---> Using cache
  ---> bf5b6313c055
 Step 5/9 : FROM fnproject/node
-latest: Pulling from fnproject/node
-bdf0201b3a05: Already exists 
-ed514f6061af: Already exists 
-bc8940a76c7f: Already exists 
-f93406d580f9: Already exists 
-Digest: sha256:2ee8e9e4b1de3a29cde6fa957e3d7aaf6d2486f46926863e42af92c9d4a02404
-Status: Downloaded newer image for fnproject/node:latest
  ---> c8da69259495
 Step 6/9 : WORKDIR /function
- ---> Running in 128681aed76f
-Removing intermediate container 128681aed76f
+ ---> Using cache
  ---> 1fe19c6ca66c
 Step 7/9 : ADD . /function/
- ---> 3ca3886160d0
+ ---> 229045a70217
 Step 8/9 : COPY --from=build-stage /function/node_modules/ /function/node_modules/
- ---> 48940744e184
+ ---> 59b17163fe37
 Step 9/9 : ENTRYPOINT ["node", "func.js"]
- ---> Running in 50ac03eeaec7
-Removing intermediate container 50ac03eeaec7
- ---> 82e19d55d014
-Successfully built 82e19d55d014
+ ---> Running in b0d793dd39bb
+Removing intermediate container b0d793dd39bb
+ ---> 7160364dec30
+Successfully built 7160364dec30
 Successfully tagged fndemouser/nodefn:0.0.2
 
 Updating function nodefn using image fndemouser/nodefn:0.0.2...
 Successfully created function: nodefn with fndemouser/nodefn:0.0.2
-Successfully created trigger: nodefn
-Trigger Endpoint: http://localhost:8080/t/nodeapp/nodefn
 ```
 
 All the steps to load the current language Docker image are displayed.
@@ -270,64 +241,26 @@ let's us know that the function is packaged in the image
 
 Note that the containing folder name 'nodefn' was used as the name of the
 generated Docker container and used as the name of the function that
-container was bound to. By convention it is also used for the trigger name.
+container was bound to.
 
 Normally you deploy an application without the `--verbose` option. If you rerun the command a new image and version is created and loaded.
 
-
-## Invoke your Deployed Function
-
-There are two ways to call your deployed function.
-
-### Invoke with the CLI
-
-The first is using the `fn` CLI which makes invoking your function relatively
-easy.  Type the following:
-
-![user input](images/userinput.png)
->```sh
-> fn invoke nodeapp nodefn
->```
-
-which results in:
-
-```js
-{"message":"Hello World"}
-```
-
-When you invoked "nodeapp nodefn" the fn server looked up the
-"nodeapp" application and then looked for the Docker container image
-bound to the "nodefn" function and executed the code.
-
-You can also pass data to the run command. Note that you set the content type for the data passed. For example:
-
-![user input](images/userinput.png)
->```sh
-> echo -n '{"name":"Bob"}' | fn invoke nodeapp nodefn --content-type application/json
->```
-
-```js
-{"message":"Hello Bob"}
-```
-
-The JSON data was parsed and since `name` was set to "Bob", that value is passed
-in the output.
-
 ### Understand fn deploy
+
 If you have used Docker before the output of `fn --verbose deploy` should look
 familiar--it looks like the output you see when running `docker build`
 with a Dockerfile.  Of course this is exactly what's happening!  When
 you deploy a function like this Fn is dynamically generating a Dockerfile
 for your function, building a container, and then loading it for execution.
 
-> __NOTE__: Fn is actually using two images.  The first contains the language compiler
-and all the necessary build tools. The second image packages all dependencies
-and any necessary language runtime components. Using this strategy, the final
-function image size can be kept as small as possible.  Smaller Docker images are
-naturally faster to push and pull from a repository which improves overall
-performance.  For more details on this technique see [Multi-Stage Docker Builds
-for Creating Tiny Go
-Images](https://medium.com/travis-on-docker/multi-stage-docker-builds-for-creating-tiny-go-images-e0e1867efe5a).
+> __NOTE__: Fn is actually using two images.  The first contains the language
+> compiler and all the necessary build tools. The second image packages all
+> dependencies and any necessary language runtime components. Using this
+> strategy, the final function image size can be kept as small as possible.
+> Smaller Docker images are naturally faster to push and pull from a repository
+> which improves overall performance.  For more details on this technique see
+> [Multi-Stage Docker Builds for Creating Tiny Go
+> Images](https://medium.com/travis-on-docker/multi-stage-docker-builds-for-creating-tiny-go-images-e0e1867efe5a).
 
 When using `fn deploy --local`, fn server builds and packages your function
 into a container image which resides on your local machine.
@@ -365,33 +298,103 @@ NAME     ID
 nodeapp  01DHHSP6X3NG8G00GZJ0000001
 ```
 
-We can also see the functions that are defined by an application.  Since
-functions are exposed via triggers, the `fn list triggers <appname>` command
-is used.  To list the functions included in "nodeapp" we can type:
+The `fn list functions <app-name>` command lists all the functions associated with and app.
 
 ![user input](images/userinput.png)
 >```sh
-> fn list triggers nodeapp
+> fn list functions nodeapp
 >```
 
+The returns all the functions associated with the `nodeapp`.
+
+```
+NAME	IMAGE                    ID
+nodefn	fndemouser/nodefn:0.0.2	 01DJ900WFKNG8G00GZJ0000002	
 ```
-FUNCTION    NAME    ID                          TYPE  SOURCE   ENDPOINT
-nodefn      nodefn  01DHHSPYT9NG8G00GZJ0000003  http  /nodefn  http://localhost:8080/t/nodeapp/nodefn
+
+## Invoke your Deployed Function
+
+There are two ways to call your deployed function.
+
+### Invoke with the CLI
+
+The first is using the `fn` CLI which makes invoking your function relatively
+easy.  Type the following:
+
+![user input](images/userinput.png)
+>```sh
+> fn invoke nodeapp nodefn
+>```
+
+which results in:
+
+```js
+{"message":"Hello World"}
+```
+
+When you invoked "nodeapp nodefn" the fn server looked up the
+"nodeapp" application and then looked for the Docker container image
+bound to the "nodefn" function and executed the code.
+
+You can also pass data to the run command. Note that you set the content type for the data passed. For example:
+
+![user input](images/userinput.png)
+>```sh
+> echo -n '{"name":"Bob"}' | fn invoke nodeapp nodefn --content-type application/json
+>```
+
+```js
+{"message":"Hello Bob"}
+```
+
+The JSON data was parsed and since `name` was set to "Bob", that value is passed
+in the output.
+
+
+### Getting a Function's Invoke Endpoint
+
+In addition to using the Fn `invoke` command, we can call a function by using a
+URL. To do this, we must get the function's invoke endpoint. Use the command
+`fn inspect function <appname> <function-name>`.  To list the `nodefn` function's
+invoke endpoint we can type:
+
+![user input](images/userinput.png)
+>```sh
+> fn inspect function nodeapp nodefn
+>```
+
+```js
+{
+	"annotations": {
+		"fnproject.io/fn/invokeEndpoint": "http://localhost:8080/invoke/01DJ900WFKNG8G00GZJ0000002"
+	},
+	"app_id": "01DJ90077CNG8G00GZJ0000001",
+	"created_at": "2019-08-14T21:19:58.451Z",
+	"id": "01DJ900WFKNG8G00GZJ0000002",
+	"idle_timeout": 30,
+	"image": "fndemouser/nodefn:0.0.3",
+	"memory": 128,
+	"name": "nodefn",
+	"timeout": 30,
+	"updated_at": "2019-08-14T21:21:09.868Z"
+}
 ```
 
-The output confirms that nodeapp contains a `nodefn` function that can be called via this URL.
+The output confirms that `nodefn` functions invoke endpoint is:
+`http://localhost:8080/invoke/01DJ900WFKNG8G00GZJ0000002`. We can use this URL
+to call the function.
 
 ### Invoke with Curl
 
-The other way to invoke your function is via HTTP.  The Fn server exposes our
-deployed function at `http://localhost:8080/t/nodeapp/nodefn`, a URL
-that incorporates our application and function trigger as path elements.
+Once we have the invoke endpoint, the second method for invoking our function
+can be used, HTTP.  The Fn server exposes our deployed function at
+`http://localhost:8080/invoke/01DJ900WFKNG8G00GZJ0000002`.
 
 Use curl to invoke the function:
 
 ![user input](images/userinput.png)
 >```sh
-> curl -H "Content-Type: application/json" http://localhost:8080/t/nodeapp/nodefn
+> curl -X "POST" -H "Content-Type: application/json" http://localhost:8080/invoke/01DJ900WFKNG8G00GZJ0000002
 >```
 
 The result is once again the same.
@@ -405,7 +408,7 @@ function back.
 
 ![user input](images/userinput.png)
 >```sh
-> curl -H "Content-Type: application/json" -d '{"name":"Bob"}' http://localhost:8080/t/nodeapp/nodefn
+> curl -X "POST" -H "Content-Type: application/json" -d '{"name":"Bob"}' http://localhost:8080/invoke/01DJ900WFKNG8G00GZJ0000002
 >```
 
 The result is once again the same.