update

Author: Yancey0623

doc/design.md

@@ -202,127 +202,97 @@ def build_docker_image_from_git_source(
 
 A Pipeline object is like function declaration.
 
-A Pipeline in Tekton defined an ordered series of Tasks. A valid Pipeline declaration
-must include a reference to at last one `Task`, The `Pipeline Tasks` in a Pipeline can be connected and run as a Directed Acyclic Graph(DAG), each of the Pipeline Tasks is a node, which can be connected with:
+A Pipeline in Tekton defined an ordered series of Tasks. Users can specify whether
+the output of a `Task` is used as an input for the next `Task` using `from` property on `PipelineResources`
 
-- `runAfter` clauses on the `Pipeline Tasks`.
-- `from` clauses on the `PipelineResources` needed by a `Task`.
-
-The following example `Pipeline` spec comes from [Tekton's Pipeline tutorial](https://github.com/tektoncd/pipeline/blob/master/docs/pipelines.md):
+As the following example comes from [Tekton's tutorial](https://github.com/tektoncd/pipeline/blob/master/docs/tutorial.md#creating-and-running-a-pipeline)
 
 ``` yaml
-- name: lint-repo
-  taskRef:
-    name: pylint
-  resources:
-    inputs:
-      - name: workspace
-        resource: my-repo
-- name: test-app
-  taskRef:
-    name: make-test
-  resources:
-    inputs:
-      - name: workspace
-        resource: my-repo
-- name: build-app
-  taskRef:
-    name: kaniko-build-app
-  runAfter:
-    - test-app
-  resources:
-    inputs:
-      - name: workspace
-        resource: my-repo
-    outputs:
-      - name: image
-        resource: my-app-image
-- name: build-frontend
-  taskRef:
-    name: kaniko-build-frontend
-  runAfter:
-    - test-app
-  resources:
-    inputs:
-      - name: workspace
-        resource: my-repo
-    outputs:
-      - name: image
-        resource: my-frontend-image
-- name: deploy-all
-  taskRef:
-    name: deploy-kubectl
+apiVersion: tekton.dev/v1beta1
+kind: Pipeline
+metadata:
+  name: tutorial-pipeline
+spec:
   resources:
-    inputs:
-      - name: my-app-image
-        resource: my-app-image
-        from:
-          - build-app
-      - name: my-frontend-image
-        resource: my-frontend-image
-        from:
-          - build-frontend
-```
-
-This will result the following execution graph:
-
-``` text
-        |            |
-        v            v
-     test-app    lint-repo
-    /        \
-   v          v
-build-app  build-frontend
-   \          /
-    v        v
-    deploy-all
+    - name: source-repo
+      type: git
+    - name: web-image
+      type: image
+  tasks:
+    - name: build-skaffold-web
+      taskRef:
+        name: build-docker-image-from-git-source
+      params:
+        - name: pathToDockerFile
+          value: Dockerfile
+        - name: pathToContext
+          value: /workspace/docker-source/examples/microservices/leeroy-web #configure: may change according to your source
+      resources:
+        inputs:
+          - name: docker-source
+            resource: source-repo
+        outputs:
+          - name: builtImage
+            resource: web-image
+    - name: deploy-web
+      taskRef:
+        name: deploy-using-kubectl
+      resources:
+        inputs:
+          - name: source
+            resource: source-repo
+          - name: image
+            resource: web-image
+            from:
+              - build-skaffold-web
+      params:
+        - name: path
+          value: /workspace/source/examples/microservices/leeroy-web/kubernetes/deployment.yaml #configure: may change according to your source
+        - name: yamlPathToImage
+          value: "spec.template.spec.containers[0].image"
 ```
 
-In Python, a function is like a node of the DAG, which connected by the input
-and of output of the functions.
-
-We hope Fluid users can write the following program to express a DAG with `fluid.pipeline` as the following code:
+We hope Fluid users can write the following program to express the above YAML file:
 
 ``` python
-
-WORKSPACE = fluid.git_resource(
-    url="https://github.com/GoogleContainerTools/skaffold",
-    revision="master")
-
-APP_IMAGE = fluid.image_resource()
-
-FRONTED_IMAGE = fluid.image_resource()
-
-@fluid.task
-def pylint(workspace:"input,git"):
-    fluid.step(image="ubuntu", cmd=["pylint"])
-
-@fluid.task
-def make_test(workspace:"input,git"):
-    fluid.step(image="ubuntu", cmd=["make"], args=["test"])
-
 @fluid.task
-def kaniko_build_app(workflow:"input,git", image:"output,image"):
-    fluid.step(...)
-
-@fluid.task
-def kaniko_build_frontend(workflow:"input,git", image:"output,image"):
-    fluid.step(...)
+def build_docker_image_from_git_source(
+        docker_source: "input,git",
+        built_image: "output,image",
+        path_to_dockerfile="/workspace/docker-source/Dockerfile",
+        path_to_context="/workspace/docker-source"):
+    '''Define a Tekton Task that builds a Docker image from a Git repo'''
+    couler.step(image="gcr.io/kaniko-project/executor:v0.14.0",
+               cmd=["/kaniko/executor"],
+               args=[f"--dockerfile={path_to_dockerfile}",
+                     f"--destination={built_image.url}",
+                     f"--context={path_to_context}"],
+               env={"DOCKER_CONFIG": "/tekton/home/.docker/"})
 
 @fluid.task
-def deploy_kubectl(my_frontend_image:"input,image", my_app_image:"input,image"):
-    fluid.step(...)
+def deploy_using_kubectl(
+      docker_source:"input,git",
+      web_image:"input,image",
+      path_to_deployment="/workspace/source/examples/microservices/leeroy-web/kubernetes/deployment.yaml"):
+    fluid.step(image="mikefarah/yq",
+               cmd=["yq"],
+               args=["w",
+                     "-i",
+                     f"{path_to_deployment}",
+                     "spec.template.spec.containers[0].image",
+                     f"{web_image.url}"])
+    fluid.step(image="lachlanevenson/k8s-kubectl",
+               cmd=["kubectl"],
+               args=["--apply",
+                    "-f",
+                    f"{path_to_deployment}"])
 
 @fluid.pipeline
-def dag_demo():
-    lint_repo = pylint(WORKSPACE)
-    test_app = make_test(WORKSPACE)
-    build_app = kaniko_build_app(WORKSPACE, APP_IMAGE).run_after(test_app)
-    build_frontend = kaniko_build_frontend(WORKSPACE, FRONTEND_IMAGE).run_after(test_app)
-
-    deploy_all = deploy_kubectl(APP_IMAGE, FRONTEND_IMAGE)
-    deploy_all.my_frontend_image.from(build_app)
-    deploy_all.my_app_image.from(build_frontend)
+def tutorial(source_repo:"resource,git", web_image="resource,image"):
+    build_skaffold_web = build_docker_image_from_git_source(source_repo, web_image)
+
+    deploy_web = deploy_using_kubectl(source_repo, web_image)
+    deploy_web.web_image.from(build_skaffold_web)
 ```
 
 ### PipelineRun