无服务器应用程序

流程

1. 在 OpenShift Container Platform web 控制台中导航至 Operators → OperatorHub 页。

2. 滚动页面，或在 Filter by keyword 框中输入关键字 Serverless 以查找 OpenShift Serverless Operator。

   

3. 查看 Operator 信息并单击 Install。

   

4. 在 Create Operator Subscription 页面：

   
   1. Installation Mode 是 All namespaces on the cluster (default)。选择该项会将 Operator 安装至默认openshift-operators 命名空间，以便供集群中的所有命名空间监视和使用。
   2. Installed Namespaces 为 openshift-operators。
   3. 选择 4.4 频道作为 更新频道。4.4 频道将启用 OpenShift Serverless Operator 最新稳定版本的安装。
   4. 选择 Automatic 或 Manual 批准策略。
5. 单击 Subscribe，以便该 Operator 可供 OpenShift Container Platform 集群上的所选命名空间使用。

6. 在 Catalog → Operator Management 页面中，您可以监控 OpenShift Serverless Operator 订阅的安装和升级进度。

   1. 如果选择了 Manual 批准策略，订阅的升级状态将会一直保持在 Upgrading，直到您审阅并批准了它的安装计划。在 Install Plan 页面批准后，订阅的升级状态将变为 Up to date。
   2. 如果选择了 Automatic 批准策略，升级状态会在不用人工参与的情况下变为 Up to date。

1. 切换到 Catalog → Operator Management 页，检查 Operator Subscriptions 和 Install Plans 页中的 Status 是否有错误。
2. 检查 Workloads → Pods 页中的 openshift-operators 项目中的 pod 的日志信息以便进行故障排除。

流程

1. 在 OpenShift Container Platform web 控制台的 Administrator 视角中，进入 Operators → Installed Operators。
2. 检查页面顶部的 Project 下拉菜单是否已设置为 Project: knative-serving。

3. 点击 OpenShift Serverless Operator 的 Provided APIs 列表中的 Knative Serving 来进入 Knative Serving 选项卡。

   

4. 点击 Create Knative Serving 按钮。

   

5. 在 Create Knative Serving 页中，您可以使用默认设置安装 Knative Serving。点 Create。

   您还可以使用提供的表单或编辑 YAML 来修改 KnativeServing 对象来修改 Knative Serving 安装的设置。

   • 建议您在不需要完全控制 KnativeServing 对象创建的简单配置中使用该表单。

   • 对于更复杂的配置，建议编辑 YAML，这可以完全控制 KnativeServing 对象的创建。您可以通过点击 Create Knative Serving 页右上角的 edit YAML 链接来访问 YAML。

     完成表单后，或者完成对 YAML 的修改后，点 Create。

     注意

     如需有关 KnativeServing 自定义资源定义的配置选项的更多信息，请参阅 高级安装配置选项。

     
     

6. 安装 Knative Serving 后，将创建 KnativeServing 对象，并将自动定向到 Knative Serving 选项卡。

   

   您可以在资源列表中看到 knative-serving。

验证步骤

1. 在 Knative Serving 选项卡中点击 knative-serving。

2. 您将被自动定向到 Knative Serving Overview 页面。

   
3. 向下滚动查看条件列表。

4. 您应该看到一个状况为 True的条件列表，如示例镜像所示。

   
   注意

   创建 Knative Serving 资源可能需要几秒钟时间。您可以在 Resources 选项卡中查看其状态。

5. 如果条件状态为 Unknown 或 False，请等待几分钟，然后在确认已创建资源后再重新检查。

流程

1. 创建名为 serving.yaml 的文件。

2. 将以下示例 YAML 复制到 service.yaml中：

   apiVersion: operator.knative.dev/v1alpha1
   kind: KnativeServing
   metadata:
       name: knative-serving
       namespace: knative-serving

3. 应用 service.yaml 文件：

   $ oc apply -f serving.yaml

验证步骤

1. 使用以下命令校验安装是否完成：

   $ oc get knativeserving.operator.knative.dev/knative-serving -n knative-serving --template='{{range .status.conditions}}{{printf "%s=%s\n" .type .status}}{{end}}'

   输出应类似于：

   DependenciesInstalled=True
   DeploymentsAvailable=True
   InstallSucceeded=True
   Ready=True

   注意

   创建 Knative Serving 资源可能需要几秒钟时间。

2. 如果条件状态为 Unknown 或 False，请等待几分钟，然后在确认已创建资源后再重新检查。

3. 使用以下命令检查是否已创建了 Knative Serving 资源：

   $ oc get pods -n knative-serving

   输出应类似于：

   NAME                               READY   STATUS    RESTARTS   AGE
   activator-5c596cf8d6-5l86c         1/1     Running   0          9m37s
   activator-5c596cf8d6-gkn5k         1/1     Running   0          9m22s
   autoscaler-5854f586f6-gj597        1/1     Running   0          9m36s
   autoscaler-hpa-78665569b8-qmlmn    1/1     Running   0          9m26s
   autoscaler-hpa-78665569b8-tqwvw    1/1     Running   0          9m26s
   controller-7fd5655f49-9gxz5        1/1     Running   0          9m32s
   controller-7fd5655f49-pncv5        1/1     Running   0          9m14s
   kn-cli-downloads-8c65d4cbf-mt4t7   1/1     Running   0          9m42s
   webhook-5c7d878c7c-n267j           1/1     Running   0          9m35s

流程

1. 在 OpenShift Container Platform web 控制台的 Administrator 视角中，进入 Operators → Installed Operators。
2. 检查页面顶部的 Project 下拉菜单是否已设置为 Project: knative-eventing。

3. 点击 OpenShift Serverless Operator 的 Provided APIs 列表中的 Knative Eventing 来进入 Knative Eventing 选项卡。

   

4. 点击 Create Knative Eventing 按钮。

   

5. 在 Create Knative Eventing 页面中，您可以选择使用提供的默认表单或编辑 YAML 来配置 KnativeEventing 对象。

   • 建议您在不需要完全控制 KnativeEventing 对象创建的简单配置中使用该表单。

     可选。如果您要使用表单配置 KnativeEventing 对象，请为您的 Knative Eventing 部署进行任何要实现的更改。

6. 点击 Create。

   

   • 对于更复杂的配置，建议编辑 YAML，这可以完全控制 KnativeEventing 对象的创建。您可以通过点击 Create Knative Eventing 页右上角的 edit YAML 链接来访问 YAML。

     可选。如果您要通过编辑 YAML 配置 KnativeEventing 对象，请对您希望用于 Knative Eventing 部署的 YAML 进行更改。

7. 点击 Create。

   

8. 安装 Knative Eventing 后，将创建 KnativeEventing 对象，并将自动定向到 Knative Eventing 选项卡。

   

   您可以在资源列表中看到 knative-eventing。

验证步骤

1. 在 Knative Eventing 选项卡中点击 knative-eventing。

2. 您将被自动定向到 Knative Eventing Overview 页面。

   
3. 向下滚动查看条件列表。

4. 您应该看到一个状况为 True的条件列表，如示例镜像所示。

   
   注意

   创建 Knative Eventing 资源可能需要几秒钟时间。您可以在 Resources 选项卡中查看其状态。

5. 如果条件状态为 Unknown 或 False，请等待几分钟，然后在确认已创建资源后再重新检查。

流程

1. 创建名为 eventing.yaml 的文件。

2. 将以下示例 YAML 复制到 eventing.yaml中：

   apiVersion: operator.knative.dev/v1alpha1
   kind: KnativeEventing
   metadata:
       name: knative-eventing
       namespace: knative-eventing

3. 可选。根据您的 Knative Eventing 部署，对 YAML 进行相应的更改。

4. 输入以下内容来应用 eventing.yaml 文件：

   $ oc apply -f eventing.yaml

验证步骤

1. 使用以下命令校验安装是否完成：

   $ oc get knativeeventing.operator.knative.dev/knative-eventing \
     -n knative-eventing \
     --template='{{range .status.conditions}}{{printf "%s=%s\n" .type .status}}{{end}}'

   输出应类似于：

   InstallSucceeded=True
   Ready=True

   注意

   创建 Knative Eventing 资源可能需要几秒钟时间。

2. 如果条件状态为 Unknown 或 False，请等待几分钟，然后在确认已创建资源后再重新检查。

3. 使用以下命令检查是否已创建 Knative Eventing 资源：

   $ oc get pods -n knative-eventing

   输出应类似于：

   NAME                                   READY   STATUS    RESTARTS   AGE
   broker-controller-58765d9d49-g9zp6     1/1     Running   0          7m21s
   eventing-controller-65fdd66b54-jw7bh   1/1     Running   0          7m31s
   eventing-webhook-57fd74b5bd-kvhlz      1/1     Running   0          7m31s
   imc-controller-5b75d458fc-ptvm2        1/1     Running   0          7m19s
   imc-dispatcher-64f6d5fccb-kkc4c        1/1     Running   0          7m18s

流程

1. 在 OpenShift Container Platform web 控制台中，选择 openshift-operators 命名空间。
2. 导航到 Operators → Installed Operators 页面。
3. 选择 OpenShift Serverless Operator Operator。
4. 点 Subscription → Channel。
5. 在 Change Subscription Update Channel 窗口中，选择 4.4 并点 Save。
6. 等待 knative-serving 命名空间中的所有 Pod 都已升级，KnativeServing 自定义资源 (CR) 报告了最新的 Knative Serving 版本。

1. 运行以下命令，检查 pod 的状态：

   $ oc get knativeserving.operator.knative.dev knative-serving -n knative-serving -o=jsonpath='{.status.conditions[?(@.type=="Ready")].status}'

   以上命令应该返回 True 状态。

2. 运行以下命令，检查 KnativeServing CR 的版本：

   $ oc get knativeserving.operator.knative.dev knative-serving -n knative-serving -o=jsonpath='{.status.version}'

   以上命令应该返回最新 Knative Serving 版本。您可在 OpenShift Serverless Operator 发行注记中查看最新版本。

流程

1. 要移除 Knative Serving，请使用以下命令：

   $ oc delete knativeservings.operator.knative.dev knative-serving -n knative-serving

2. 在该命令运行完成且已从 knative-serving 命名空间中移除所有 Pod 后，使用以下命令移除命名空间：

   $ oc delete namespace knative-serving

流程

1. 要移除 Knative Eventing，请使用以下命令：

   $ oc delete knativeeventings.operator.knative.dev knative-eventing -n knative-eventing

2. 在该命令运行完成且已从 knative-eventing 命名空间中移除所有 Pod 后，使用以下命令移除命名空间：

   $ oc delete namespace knative-eventing

流程

1. 运行以下命令删除 OpenShift Serverless CRD：

   $ oc get crd -oname | grep 'knative.dev' | xargs oc delete

流程

1. 从 Command Line Tools 页下载 kn CLI。

2. 解包存档：

   $ tar -xf <file>

3. 将 kn 二进制文件迁移至 PATH 上的目录中。

4. 要查看路径，请运行：

   $ echo $PATH

   注意

   如果不使用 RHEL 或 Fedora，请确保将 libc 安装在库路径的目录中。如果 libc 不可用，您在运行 CLI 命令时可能会看到以下错误：

   $ kn: No such file or directory

流程

1. 下载 CLI。

2. 解包存档：

   $ tar -xf <file>

3. 将 kn 二进制文件迁移至 PATH 上的目录中。

4. 要查看路径，请运行：

   $ echo $PATH

   注意

   如果不使用 RHEL 或 Fedora，请确保将 libc 安装在库路径的目录中。如果 libc 不可用，您在运行 CLI 命令时可能会看到以下错误：

   $ kn: No such file or directory

流程

1. 下载 CLI。
2. 解包和解压存档。
3. 将 kn 二进制文件迁移至 PATH 上的目录中。

4. 要查看 PATH，请打开终端窗口并运行：

   $ echo $PATH

流程

1. 下载 CLI。
2. 使用 ZIP 程序解压存档。
3. 将 kn 二进制文件迁移至 PATH 上的目录中。

4. 要查看您的 PATH，请打开命令提示并运行以下命令：

   C:\> path

流程

1. 导航到 Serverless → Services 页面。

   
2. 点 Create Service。

3. 手动输入 YAML 或 JSON 定义，或者将文件拖放到编辑器中。

   
4. 点击 Create。

流程

1. 通过一个镜像，在 default 命名空间内创建一个服务：

   $ kn service create hello --image docker.io/openshift/hello-openshift --env RESPONSE="Hello Serverless!"

   输出示例

   Creating service 'hello' in namespace 'default':
   
     0.085s The Route is still working to reflect the latest desired specification.
     0.101s Configuration "hello" is waiting for a Revision to become ready.
    11.590s ...
    11.650s Ingress has not yet been reconciled.
    11.726s Ready to serve.
   
   Service 'hello' created with latest revision 'hello-gsdks-1' and URL:
   http://hello-default.apps-crc.testing

2. 列出服务：

   $ kn service list

   输出示例

   NAME    URL                                     LATEST          AGE     CONDITIONS   READY   REASON
   hello   http://hello-default.apps-crc.testing   hello-gsdks-1   8m35s   3 OK / 3     True

3. 使用 curl 服务端点命令检查该服务是否正在工作：

   $ curl http://hello-default.apps-crc.testing

   输出示例

   Hello Serverless!

4. 更新服务：

   $ kn service update hello --env RESPONSE="Hello OpenShift!"

   输出示例

   Updating Service 'hello' in namespace 'default':
   
    10.136s Traffic is not yet migrated to the latest revision.
    10.175s Ingress has not yet been reconciled.
    10.348s Ready to serve.
   
   Service 'hello' updated with latest revision 'hello-dghll-2' and URL:
   http://hello-default.apps-crc.testing

   该服务的环境变量 RESPONSE 现在设置为 "Hello OpenShift!"。

5. 描述该服务。

   $ kn service describe hello

   输出示例

   Name:       hello
   Namespace:  default
   Age:        13m
   URL:        http://hello-default.apps-crc.testing
   
   Revisions:
     100%  @latest (hello-dghll-2) [2] (1m)
           Image:  docker.io/openshift/hello-openshift (pinned to 5ea96b)
   
   Conditions:
     OK TYPE                   AGE REASON
     ++ Ready                   1m
     ++ ConfigurationsReady     1m
     ++ RoutesReady             1m

6. 删除服务：

   $ kn service delete hello

   输出示例

   Service 'hello' successfully deleted in namespace 'default'.

7. 通过列出 hello 服务来验证 hello 服务是否已被删除：

   $ kn service list hello

   输出示例

   No services found.

流程

1. 要访问 Kibana UI（Elasticsearch 的可视化工具），请使用以下命令获取 Kibana 路由：

   $ oc -n openshift-logging get route kibana

2. 使用路由的 URL 导航到 Kibana 仪表板并登录。
3. 确保将索引设置为 .all。如果索引未设置为 .all，则只会列出 OpenShift Container Platform 系统日志。

4. 您可使用 knative-serving 命名空间来过滤日志。在搜索框中输入 kubernetes.namespace_name:knative-serving 以过滤结果。

   注意

   Knative Serving 默认使用结构化日志记录。您可以通过自定义集群日志记录 Fluentd 设置来启用这些日志的解析。这允许在日志级别过滤来快速发现问题。

流程

1. 查找 Kibana URL：

   $ oc -n cluster-logging get route kibana

2. 在浏览器中输入 URL 以打开 Kibana UI。
3. 确保将索引设置为 .all。如果索引未设置为 .all，则只会列出 OpenShift Container Platform 系统日志。

4. 通过使用服务部署到的 Kubernetes 命名空间来过滤日志。添加过滤条件以识别服务本身：kubernetes.namespace_name:default AND kubernetes.labels.serving_knative_dev\/service:{SERVICE_NAME}。

   注意

   除此之外还可使用 /configuration 或 /revision 来过滤。

5. 您可使用 kubernetes.container_name:<user-container> 来缩小搜索范围，只显示由您的应用程序生成的日志。否则，会显示来自 queue-proxy 的日志。

   注意

   在应用程序中使用基于 JSON 的结构化日志记录，以便在生产环境中快速过滤这些日志。

1. 点击由四边形表示的无服务器资源服务，在侧面面板中查看其概述信息。

2. 点 Resources 选项卡，查看服务的 Revisions 和 Routes 列表。

   图 9.1. 无服务器应用程序

   
3. 点侧边面板顶部的由 S 图标代表的服务，查看服务详情概述。
4. 点 YAML 选项卡，在 YAML 编辑器中修改服务配置，然后点 Save。例如，将 timeoutseconds 从 300 改为 301。这个配置更改会触发新修订版本。在 Topology 视图中会显示最新的修订，服务 Resources 选项卡现在会显示两个修订版本。

5. 在 Resources 选项卡中，点 Set Traffic distribution 按钮查看流量分布对话框：

   1. 在 Splits 字段中为两个修订版本添加流量百分比。
   2. 添加标签以便为这两个修订版本创建自定义 URL。

   3. 点 Save 查看两个节点，分别代表 Topology 视图中的两个修订版本。

      图 9.2. 无服务器应用程序修订

      

流程

1. 创建 ServiceAccount 对象。

   1. 输入以下命令来创建 eventing-broker-ingress 对象：

      $ oc -n <namespace> create serviceaccount eventing-broker-ingress

   2. 输入以下命令来创建 eventing-broker-filter 对象：

      $ oc -n <namespace> create serviceaccount eventing-broker-filter

2. 授予您创建 RBAC 权限的对象：

   $ oc -n default create rolebinding eventing-broker-ingress \
     --clusterrole=eventing-broker-ingress \
     --serviceaccount=default:eventing-broker-ingress

   $ oc -n default create rolebinding eventing-broker-filter \
     --clusterrole=eventing-broker-filter \
     --serviceaccount=default:eventing-broker-filter

3. 通过创建并应用包含以下内容的 YAML 文件来创建代理：

   apiVersion: eventing.knative.dev/v1beta1
   kind: Broker
   metadata:
     namespace: default
     name: default 1

   1

   这个示例使用 default名称，但您可以使用其他有效名称替换它。

流程

1. 输入以下命令来标注命名空间：

   $ oc label namespace default knative-eventing-injection=enabled 1
   $ oc -n default get broker default

   1

   使用所需命名空间名替换 default。

   本例中显示的行将在 default 命名空间内自动创建一个名为 default 的代理。

1. 从所选命名空间中（在这个示例中，是 default 命名空间）删除注入的代理:

   $ oc -n default delete broker default

流程

1. 通过创建一个包含以下内容的 YAML 文件，创建一个 Subscription 对象来连接频道到服务：

   apiVersion: messaging.knative.dev/v1beta1
   kind: Subscription
   metadata:
     name: my-subscription 1
     namespace: default
   spec:
     channel: 2
       apiVersion: messaging.knative.dev/v1beta1
       kind: Channel
       name: example-channel
     delivery: 3
       deadLetterSink:
         ref:
           apiVersion: serving.knative.dev/v1
           kind: Service
           name: error-handler
     subscriber: 4
       ref:
         apiVersion: serving.knative.dev/v1
         kind: Service
         name: event-display

   1

   订阅的名称。

   2

   订阅连接的频道的配置设置。

   3

   事件交付的配置设置。这会告诉订阅无法发送给订阅者的事件。配置后，消耗的事件会发送到 deadLetterSink。事件将被丢弃，不会尝试重新发送该事件，并在系统中记录错误。deadLetterSink 的值需要是一个 Destination。

   4

   订阅用户的配置设置。这是事件从频道发送的事件 sink。

2. 输入以下内容应用 YAML 文件：

   $ oc apply -f <FILENAME>

流程

1. 要检查 SinkBinding 是否已正确设置，请创建一个 Knative 事件显示服务或事件 sink，在日志中转储传入的信息：

   $ kn service create event-display --image quay.io/openshift-knative/knative-eventing-sources-event-display:latest

2. 创建一个 SinkBinding 把事件发送到服务：

   $ kn source binding create bind-heartbeat --subject Job:batch/v1:app=heartbeat-cron --sink svc:event-display

3. 创建 CronJob：

   1. 创建名为 heartbeats-cronjob.yaml 的文件，并将以下示例代码复制到其中：

      apiVersion: batch/v1beta1
      kind: CronJob
      metadata:
        name: heartbeat-cron
      spec:
      spec:
        # Run every minute
        schedule: "* * * * *"
        jobTemplate:
          metadata:
            labels:
              app: heartbeat-cron
          spec:
            template:
              spec:
                restartPolicy: Never
                containers:
                  - name: single-heartbeat
                    image: quay.io/openshift-knative/knative-eventing-sources-heartbeats:latest
                    args:
                      - --period=1
                    env:
                      - name: ONE_SHOT
                        value: "true"
                      - name: POD_NAME
                        valueFrom:
                          fieldRef:
                            fieldPath: metadata.name
                      - name: POD_NAMESPACE
                        valueFrom:
                          fieldRef:
                            fieldPath: metadata.namespace

   2. 在创建了 heartbeats-cronjob.yaml 文件后，请输入：

      $ oc apply --filename heartbeats-cronjob.yaml

4. 输入以下命令并检查输出，检查是否正确映射了控制器：

   $ kn source binding describe bind-heartbeat

   Name:         bind-heartbeat
   Namespace:    demo-2
   Annotations:  sources.knative.dev/creator=minikube-user, sources.knative.dev/lastModifier=minikub ...
   Age:          2m
   Subject:
     Resource:   job (batch/v1)
     Selector:
       app:      heartbeat-cron
   Sink:
     Name:       event-display
     Resource:   Service (serving.knative.dev/v1)
   
   Conditions:
     OK TYPE     AGE REASON
     ++ Ready     2m

流程

1. 要检查 SinkBinding 是否已正确设置，请创建一个 Knative 事件显示服务或事件挂起，从而在日志中转储传入的信息。

   1. 将以下示例 YAML 复制到一个名为 service.yaml 的文件中：

      apiVersion: serving.knative.dev/v1
      kind: Service
      metadata:
        name: event-display
      spec:
        template:
          spec:
            containers:
              - image: quay.io/openshift-knative/knative-eventing-sources-event-display:latest

   2. 创建 service.yaml 文件后，输入以下内容应用它：

      $ oc apply -f service.yaml

2. 创建将事件定向到该服务的 SinkBinding。

   1. 创建名为 sinkbinding.yaml 的文件，并将以下示例代码复制到其中：

      apiVersion: sources.knative.dev/v1alpha1
      kind: SinkBinding
      metadata:
        name: bind-heartbeat
      spec:
        subject:
          apiVersion: batch/v1
          kind: Job 1
          selector:
            matchLabels:
              app: heartbeat-cron
      
        sink:
          ref:
            apiVersion: serving.knative.dev/v1
            kind: Service
            name: event-display

   1

   在本例中，任何具有标签 app: heartbeat-cron 的作业都将被绑定到事件 sink。

   1. 创建 sinkbinding.yaml 文件后，输入以下内容应用它：

      $ oc apply -f sinkbinding.yaml

3. 创建 CronJob：

   1. 创建名为 heartbeats-cronjob.yaml 的文件，并将以下示例代码复制到其中：

      apiVersion: batch/v1beta1
      kind: CronJob
      metadata:
        name: heartbeat-cron
      spec:
      spec:
        # Run every minute
        schedule: "* * * * *"
        jobTemplate:
          metadata:
            labels:
              app: heartbeat-cron
          spec:
            template:
              spec:
                restartPolicy: Never
                containers:
                  - name: single-heartbeat
                    image: quay.io/openshift-knative/knative-eventing-sources-heartbeats:latest
                    args:
                      - --period=1
                    env:
                      - name: ONE_SHOT
                        value: "true"
                      - name: POD_NAME
                        valueFrom:
                          fieldRef:
                            fieldPath: metadata.name
                      - name: POD_NAMESPACE
                        valueFrom:
                          fieldRef:
                            fieldPath: metadata.namespace

   2. 在创建了 heartbeats-cronjob.yaml 文件后，请输入：

      $ oc apply -f heartbeats-cronjob.yaml

4. 输入以下命令并检查输出，检查是否正确映射了控制器：

   $ oc get sinkbindings.sources.knative.dev bind-heartbeat -oyaml

   spec:
     sink:
       ref:
         apiVersion: serving.knative.dev/v1
         kind: Service
         name: event-display
         namespace: default
     subject:
       apiVersion: batch/v1
       kind: Job
       namespace: default
       selector:
         matchLabels:
           app: heartbeat-cron

1. 您可以输入以下命令来查看消息转储程序功能日志：

   $ oc get pods

   $ oc logs $(oc get pod -o name | grep event-display) -c user-container

   ☁️  cloudevents.Event
   Validation: valid
   Context Attributes,
     specversion: 1.0
     type: dev.knative.eventing.samples.heartbeat
     source: https://knative.dev/eventing-contrib/cmd/heartbeats/#event-test/mypod
     id: 2b72d7bf-c38f-4a98-a433-608fbcdd2596
     time: 2019-10-18T15:23:20.809775386Z
     contenttype: application/json
   Extensions,
     beats: true
     heart: yes
     the: 42
   Data,
     {
       "id": 1,
       "label": ""
     }

流程

1. 为 ApiServerSource 对象创建服务帐户、角色和角色绑定。

   您可以创建名为 authentication.yaml 的文件并将以下示例代码复制到其中：

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: events-sa
     namespace: default 1
   
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: event-watcher
     namespace: default 2
   rules:
     - apiGroups:
         - ""
       resources:
         - events
       verbs:
         - get
         - list
         - watch
   
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: k8s-ra-event-watcher
     namespace: default 3
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: event-watcher
   subjects:
     - kind: ServiceAccount
       name: events-sa
       namespace: default 4

   1 2 3 4

   将这个命名空间更改为已选择安装 API 服务器源的命名空间。

   注意

   如果要重新使用具有适当权限的现有服务帐户，您必须修改该服务帐户的 authentication.yaml 文件。

   创建服务帐户、角色绑定和集群绑定：

   $ oc apply -f authentication.yaml

2. 创建使用代理作为事件接收器的 ApiServerSource 对象：

   $ kn source apiserver create <event_source_name> --sink broker:<broker_name> --resource "event:v1" --service-account <service_account_name> --mode Resource

3. 创建 Knative 服务，在日志中转储传入的信息：

   $ kn service create <service_name> --image quay.io/openshift-knative/knative-eventing-sources-event-display:latest

4. 创建触发器将事件从 default 代理过滤到服务：

   $ kn trigger create <trigger_name> --sink svc:<service_name>

5. 通过在 default 命名空间中启动 Pod 来创建事件：

   $ oc create deployment hello-node --image=quay.io/openshift-knative/knative-eventing-sources-event-display

6. 通过检查以下命令生成的输出来检查是否正确映射了控制器：

   $ kn source apiserver describe testevents

   输出示例

   Name:                testevents
   Namespace:           default
   Annotations:         sources.knative.dev/creator=developer, sources.knative.dev/lastModifier=developer
   Age:                 3m
   ServiceAccountName:  events-sa
   Mode:                Resource
   Sink:
     Name:       default
     Namespace:  default
     Kind:       Broker (eventing.knative.dev/v1alpha1)
   Resources:
     Kind:        event (v1)
     Controller:  false
   Conditions:
     OK TYPE                     AGE REASON
     ++ Ready                     3m
     ++ Deployed                  3m
     ++ SinkProvided              3m
     ++ SufficientPermissions     3m
     ++ EventTypesProvided        3m

1. 获取 pod:

   $ oc get pods

2. 查看 pod 的消息转储程序功能日志：

   $ oc logs $(oc get pod -o name | grep event-display) -c user-container

   输出示例

   ☁️  cloudevents.Event
   Validation: valid
   Context Attributes,
     specversion: 1.0
     type: dev.knative.apiserver.resource.update
     datacontenttype: application/json
     ...
   Data,
     {
       "apiVersion": "v1",
       "involvedObject": {
         "apiVersion": "v1",
         "fieldPath": "spec.containers{hello-node}",
         "kind": "Pod",
         "name": "hello-node",
         "namespace": "default",
          .....
       },
       "kind": "Event",
       "message": "Started container",
       "metadata": {
         "name": "hello-node.159d7608e3a3572c",
         "namespace": "default",
         ....
       },
       "reason": "Started",
       ...
     }

流程

1. 删除触发器：

   $ kn trigger delete <trigger_name>

2. 删除服务：

   $ kn service delete <service_name>

3. 删除 API 服务器源：

   $ kn source apiserver delete <source_name>

4. 删除服务帐户、集群角色和集群绑定：

流程

1. 要为 API 服务器源创建服务帐户、角色和角色绑定,请创建一个名为 authentication.yaml 的文件，并将以下示例代码复制到其中：

   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: events-sa
     namespace: default 1
   
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: event-watcher
     namespace: default 2
   rules:
     - apiGroups:
         - ""
       resources:
         - events
       verbs:
         - get
         - list
         - watch
   
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: k8s-ra-event-watcher
     namespace: default 3
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: Role
     name: event-watcher
   subjects:
     - kind: ServiceAccount
       name: events-sa
       namespace: default 4

   1 2 3 4

   将这个命名空间更改为已选择安装 API 服务器源的命名空间。

   注意

   如果要重新使用具有适当权限的现有服务帐户，您必须修改该服务帐户的 authentication.yaml。

   创建 authentication.yaml 文件后，应用该文件：

   $ oc apply -f authentication.yaml

2. 要创建 ApiServerSource 对象，请创建一个名为 k8s-events.yaml 的文件，并将以下示例代码复制到其中：

   apiVersion: sources.knative.dev/v1alpha1
   kind: ApiServerSource
   metadata:
     name: testevents
   spec:
     serviceAccountName: events-sa
     mode: Resource
     resources:
       - apiVersion: v1
         kind: Event
     sink:
       ref:
         apiVersion: eventing.knative.dev/v1beta1
         kind: Broker
         name: default

   创建 k8s-events.yaml 文件后，应用它：

   $ oc apply -f k8s-events.yaml

3. 要检查 API 服务器源是否已正确设置，请创建一个 Knative 服务，在日志中转储传入的信息。

   将以下示例 YAML 复制到一个名为 service.yaml 的文件中：

   apiVersion: serving.knative.dev/v1
   kind: Service
   metadata:
     name: event-display
     namespace: default
   spec:
     template:
       spec:
         containers:
           - image: quay.io/openshift-knative/knative-eventing-sources-event-display:v0.13.2

   创建 service.yaml 文件后应用它：

   $ oc apply -f service.yaml

4. 要从 default 代理创建触发器，将事件过滤到上一步中创建的服务，请创建一个名为 trigger.yaml 的文件，并将以下示例代码复制到其中：

   apiVersion: eventing.knative.dev/v1alpha1
   kind: Trigger
   metadata:
     name: event-display-trigger
     namespace: default
   spec:
     subscriber:
       ref:
         apiVersion: serving.knative.dev/v1
         kind: Service
         name: event-display

   创建 trigger.yaml 文件后，应用该文件：

   $ oc apply -f trigger.yaml

5. 要创建事件，请在 default 命名空间中启动 pod：

   $ oc create deployment hello-node --image=quay.io/openshift-knative/knative-eventing-sources-event-display

6. 要检查控制器是否已正确映射，请输入以下命令并检查输出：

   $ oc get apiserversource.sources.knative.dev testevents -o yaml

   输出示例

   apiVersion: sources.knative.dev/v1alpha1
   kind: ApiServerSource
   metadata:
     annotations:
     creationTimestamp: "2020-04-07T17:24:54Z"
     generation: 1
     name: testevents
     namespace: default
     resourceVersion: "62868"
     selfLink: /apis/sources.knative.dev/v1alpha1/namespaces/default/apiserversources/testevents2
     uid: 1603d863-bb06-4d1c-b371-f580b4db99fa
   spec:
     mode: Resource
     resources:
     - apiVersion: v1
       controller: false
       controllerSelector:
         apiVersion: ""
         kind: ""
         name: ""
         uid: ""
       kind: Event
       labelSelector: {}
     serviceAccountName: events-sa
     sink:
       ref:
         apiVersion: eventing.knative.dev/v1beta1
         kind: Broker
         name: default

1. 获取 pod:

   $ oc get pods

2. 查看 pod 的消息转储程序功能日志：

   $ oc logs $(oc get pod -o name | grep event-display) -c user-container

   输出示例

   ☁️  cloudevents.Event
   Validation: valid
   Context Attributes,
     specversion: 1.0
     type: dev.knative.apiserver.resource.update
     datacontenttype: application/json
     ...
   Data,
     {
       "apiVersion": "v1",
       "involvedObject": {
         "apiVersion": "v1",
         "fieldPath": "spec.containers{hello-node}",
         "kind": "Pod",
         "name": "hello-node",
         "namespace": "default",
          .....
       },
       "kind": "Event",
       "message": "Started container",
       "metadata": {
         "name": "hello-node.159d7608e3a3572c",
         "namespace": "default",
         ....
       },
       "reason": "Started",
       ...
     }

流程

1. 删除触发器：

   $ oc delete -f trigger.yaml

2. 删除服务：

   $ oc delete -f service.yaml

3. 删除 API 服务器源：

   $ oc delete -f k8s-events.yaml

4. 删除服务帐户、集群角色和集群绑定：

   $ oc delete -f authentication.yaml

流程

1. 要验证 ping 源是否可以工作，请创建一个简单的 Knative 服务，在服务日志中转储传入的信息：

   $ kn service create event-display \
       --image quay.io/openshift-knative/knative-eventing-sources-event-display:latest

2. 对于您要请求的每一组 ping 事件，请在与事件消费者相同的命名空间中创建一个 PingSource 对象：

   $ kn source ping create test-ping-source \
       --schedule "*/2 * * * *" \
       --data '{"message": "Hello world!"}' \
       --sink svc:event-display

3. 输入以下命令并检查输出，检查是否正确映射了控制器：

   $ kn source ping describe test-ping-source

   输出示例

   Name:         test-ping-source
   Namespace:    default
   Annotations:  sources.knative.dev/creator=developer, sources.knative.dev/lastModifier=developer
   Age:          15s
   Schedule:     */2 * * * *
   Data:         {"message": "Hello world!"}
   
   Sink:
     Name:       event-display
     Namespace:  default
     Resource:   Service (serving.knative.dev/v1)
   
   Conditions:
     OK TYPE                 AGE REASON
     ++ Ready                 8s
     ++ Deployed              8s
     ++ SinkProvided         15s
     ++ ValidSchedule        15s
     ++ EventTypeProvided    15s
     ++ ResourcesCorrect     15s

1. 查看新创建的 pod：

   $ watch oc get pods

2. 使用 Ctrl+C 取消查看 pod，然后查看所创建 pod 的日志：

   $ oc logs $(oc get pod -o name | grep event-display) -c user-container

   输出示例

   ☁️  cloudevents.Event
   Validation: valid
   Context Attributes,
     specversion: 1.0
     type: dev.knative.sources.ping
     source: /apis/v1/namespaces/default/pingsources/test-ping-source
     id: 99e4f4f6-08ff-4bff-acf1-47f61ded68c9
     time: 2020-04-07T16:16:00.000601161Z
     datacontenttype: application/json
   Data,
     {
       "message": "Hello world!"
     }

流程

1. 要验证 ping 源是否可以工作，请创建一个简单的 Knative 服务，在服务日志中转储传入的信息。

   1. 将 YAML 示例复制到名为 service.yaml的文件中：

      apiVersion: serving.knative.dev/v1
      kind: Service
      metadata:
        name: event-display
      spec:
        template:
          spec:
            containers:
              - image: quay.io/openshift-knative/knative-eventing-sources-event-display:latest

   2. 应用 service.yaml 文件：

      $ oc apply --filename service.yaml

2. 对于您要请求的每一组 ping 事件，请在与事件消费者相同的命名空间中创建一个 PingSource 对象。

   1. 将 YAML 示例复制到名为 ping-source.yaml 的文件中：

      apiVersion: sources.knative.dev/v1alpha2
      kind: PingSource
      metadata:
        name: test-ping-source
      spec:
        schedule: "*/2 * * * *"
        jsonData: '{"message": "Hello world!"}'
        sink:
          ref:
            apiVersion: serving.knative.dev/v1
            kind: Service
            name: event-display

   2. 应用 ping-source.yaml 文件：

      $ oc apply --filename ping-source.yaml

3. 输入以下命令并查看输出来检查是否正确映射了控制器：

   $ oc get pingsource.sources.knative.dev test-ping-source -oyaml

   输出示例

   apiVersion: sources.knative.dev/v1alpha2
   kind: PingSource
   metadata:
     annotations:
       sources.knative.dev/creator: developer
       sources.knative.dev/lastModifier: developer
     creationTimestamp: "2020-04-07T16:11:14Z"
     generation: 1
     name: test-ping-source
     namespace: default
     resourceVersion: "55257"
     selfLink: /apis/sources.knative.dev/v1alpha2/namespaces/default/pingsources/test-ping-source
     uid: 3d80d50b-f8c7-4c1b-99f7-3ec00e0a8164
   spec:
     jsonData: '{ value: "hello" }'
     schedule: '*/2 * * * *'
     sink:
       ref:
         apiVersion: serving.knative.dev/v1
         kind: Service
         name: event-display
         namespace: default

1. 查看新创建的 pod：

   $ watch oc get pods

2. 使用 Ctrl+C 取消查看 pod，然后查看所创建 pod 的日志：

   $ oc logs $(oc get pod -o name | grep event-display) -c user-container

   输出示例

   ☁️  cloudevents.Event
   Validation: valid
   Context Attributes,
     specversion: 1.0
     type: dev.knative.sources.ping
     source: /apis/v1/namespaces/default/pingsources/test-ping-source
     id: 042ff529-240e-45ee-b40c-3a908129853e
     time: 2020-04-07T16:22:00.000791674Z
     datacontenttype: application/json
   Data,
     {
       "message": "Hello world!"
     }

1. 通过以 YAML 文件的形式应用报告来运行报告：

   $ oc apply -f <report_name>.yaml

2. 检查报告：

   $ oc get report

   输出示例

   NAME                        QUERY                       SCHEDULE   RUNNING    FAILED   LAST REPORT TIME       AGE
   knative-service-cpu-usage   knative-service-cpu-usage              Finished            2019-06-30T23:59:59Z   10h