Alauda DevOps Connectors Docs
  • 简体中文

    • ConnectorClass

    目录

    概述地址信息参数认证信息认证类型认证参数可选认证存活探针通过 HTTP 请求探测通过 ConnectorClass API 探测认证探针通过 HTTP 请求探测通过 ConnectorClass API 探测自定义认证验证参数认证验证表达式基于 Rego 的认证逻辑配置Rego 中可用变量Rego 策略示例高级 Rego 技巧ConnectorClass API配置 API 地址API 地址解析OpenAPI 描述配置能力配置类型自定义配置可读性展示的元数据信息ConnectorClass 代理使用 Rego 从请求中提取令牌解析器类型状态信息兼容性更多示例更多

    概述

    ConnectorClass 是一个集群级别的资源，用于定义特定类型工具的访问模式和行为规范。

    以下示例定义了一个支持基本认证的 hello-git 类型连接器：

    apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: hello-git
spec:
  address:
    type: string  # 地址为字符串格式
  auth:
    types:
      - name: basicAuth
        secretType: kubernetes.io/basic-auth  # 使用 Basic Auth 进行认证

    在 ConnectorClass 中，通过描述以下信息定义连接工具到平台的访问模式和行为规范：

    • 工具访问地址的格式
    • 支持的认证方式
    • 如何检查工具的可访问性
    • 如何验证认证的有效性
    • 工具如何提供 API 能力
    • 工具提供哪些配置能力
    • 用于可读性展示的元数据

    本文档还提供示例，帮助读者更好地理解如何自定义 ConnectorClass。示例

    地址信息

    地址信息定义了访问工具的格式。目前支持字符串类型的地址配置。该地址信息限制了当前类型工具必须满足的字段类型约束。

    spec:
  address:
    type: string  # 目前仅支持字符串类型

    此时表示连接工具到平台的地址信息必须为 string 类型。

    参数

    参数用于定义创建连接器时的额外参数。

    你可以通过 connectorclass 的 spec.params 字段定义连接器创建时的必需参数。

    • spec.params[].name - 参数名称。
    • spec.params[].type - 参数类型。目前仅支持 string 类型。
    • spec.params[].default - 默认参数值（可选）。提供默认值时，用户创建连接器时可省略该参数。
    • spec.params[].description - 参数描述（可选）。

    例如，以下定义允许用户在创建 git 类型连接器时提供一个 sslVerify 参数，默认值为 true。

    kind: ConnectorClass
metadata:
  name: git
spec:
  params:
    - name: sslVerify
      type: string
      default: "true"

    关于创建 Connector 时的参数配置，请参考 Connector 文档。

    结合 connectors-csi-driver 的能力，可以实现更灵活的配置。这在需要提供参数化配置时非常有用。例如，创建 git 类型连接器时，用户可以提供 sslVerify 参数来控制 SSL 证书验证。详情请参考 ConnectorClass 配置能力 文档。

    认证信息

    认证类型

    认证类型定义了用于工具认证的凭证类型。一个工具可以支持多种认证类型，允许用户在使用时选择其中一种。

    用户可以通过以下方式为当前认证类型命名唯一标识：

    • spec.auth.types[].name，必须唯一且不可重复。
    • spec.auth.types[].secretType，指定认证所需的 Secret 类型，对应 Kubernetes Secret 类型。

    示例：

    spec:
  auth:
    types:
      - name: basicAuth  # 认证类型名称
        secretType: kubernetes.io/basic-auth  # 对应 Secret 类型
      - name: sshAuth
        secretType: kubernetes.io/ssh-auth

    在内置的 K8S Secret 类型中，除 Opaque 外所有类型都有字段约束。提供 Secret 时，用户必须确保 Secret 的字段符合类型约束。

    使用 Opaque 类型时，必须声明认证参数。

    同样，你也可以使用自定义的 Secret 类型，此时必须声明认证参数。

    认证参数

    认证凭证所需的参数由 spec.auth.types[].params 定义。

    对于字段明确的标准 Kubernetes Secret 类型，可以省略参数。例如：

    • kubernetes.io/basic-auth：用户名和密码认证
    • kubernetes.io/ssh-auth：SSH 密钥认证

    对于自定义认证类型，可以定义所需的认证参数，此时 secretType 标记为 Opaque 或自定义名称。

    例如，GitLab 的个人访问令牌（PAT）认证：

    spec:
  auth:
    types:
      - name: privateToken
        secretType: Opaque
        params:
          - name: username
            type: string
          - name: private-token
            type: string
      - name: oauth2
        secretType: example.com/oauth2
        params:
          - name: clientID
            type: string
          - name: clientSecret
            type: string

    该定义要求工具连接器使用的凭证包含 params 中指定的字段。

    可选认证

    部分工具支持无认证访问，通过 optional 字段标记认证是否可选：

    例如，以下表示 basicAuth 的凭证为可选，而 sshAuth 凭证为必需。

    spec:
  auth:
    types:
      - name: basicAuth
        optional: true  # 标记认证为可选
        secretType: kubernetes.io/basic-auth
      - name: sshAuth
        secretType: kubernetes.io/basic-auth

    此时，连接该类型工具到平台时，可以省略 basicAuth 类型的认证。

    存活探针

    可访问性检查用于验证工具是否能正常访问。该类型的配置通过 livenessProbe 字段完成。

    存活检查可以通过 HTTP 请求或 ConnectorClass API 进行。

    通过 HTTP 请求探测

    你可以配置 spec.livenessProbe.http 使用 HTTP 请求进行存活检查。

    示例

    以下片段表示使用 HTTP 请求进行检测。

    spec:
  livenessProbe:
    http:
      path: /

    当工具返回 200 状态时，视为可访问。

    详情请参考认证探针中的 HTTP 请求探测，配置完全相同，仅字段路径不同。

    通过 ConnectorClass API 探测

    你可以配置 spec.livenessProbe.api 使用 ConnectorClass API 进行存活检查。

    示例

    以下片段表示使用 ConnectorClass API 进行检测。

    spec:
  livenessProbe:
    api:
      path: /

    详情请参考认证探针中的 ConnectorClass API 探测，配置完全相同，仅字段路径不同。

    认证探针

    认证验证用于校验该类型工具的认证凭证有效性。如果不需要认证验证，可以省略 authProbes 字段。

    • spec.authProbes[].authName 指定被验证的认证类型，必须匹配 spec.auth.types[].name 中定义的名称之一。

    认证验证可以通过 HTTP 请求或 ConnectorClass API 进行。

    通过 HTTP 请求探测

    你可以配置 spec.authProbes[].probe.http 使用 HTTP 请求进行认证验证。

    • spec.authProbes[].probe.http.host 指定认证验证的目标主机，默认为连接器地址中的主机。
    • spec.authProbes[].probe.http.path 指定认证验证的请求路径。该路径为绝对路径，执行探针时会追加到从连接器 spec.address 解析的主机 URI 后。如果 spec.address 包含路径前缀，认证验证时会忽略该路径前缀。若需包含路径前缀，请使用“认证检查表达式”动态获取。
    • spec.authProbes[].probe.http.method 指定认证验证的 HTTP 方法，支持 GET 和 POST，默认为 GET。
    • spec.authProbes[].probe.http.disableRedirect 指定认证验证时是否禁用 HTTP 重定向，默认为 false（允许自动重定向）。
    • spec.authProbes[].probe.http.httpHeaders 指定认证验证请求中包含的 HTTP 头。
    • spec.authProbes[].probe.http.scheme 指定认证验证的 URI 协议，默认为连接器地址中的协议。

    示例

    以下 YAML 配置表示认证验证时，系统会向连接器地址发送 GET https://example.com/ HTTP/1.1 请求，并带有 Authorization: abc 头。

    kind: ConnectorClass
metadata:
  name: example-class
spec:
  authProbes:
    - authName: basicAuth  # 对应认证类型
      probe:
        http:
          httpHeaders:
            Authorization: abc
          path: /
          method: GET # 默认为 GET，支持 POST 和 GET 方法
          disableRedirect: false # 默认为 false，允许自动重定向
---
kind: Connector
metadata:
  name: example
spec:
  connectorClassName: example-class
  address: https://example.com

    通过 ConnectorClass API 探测

    你可以配置 spec.authProbes[].probe.api 使用 ConnectorClass API 进行认证验证。需先在 ConnectorClass 规范中配置 spec.api。返回 200 表示认证成功，返回 401 或 403 表示认证失败。更多 ConnectorClass API 说明。

    • spec.authProbes[].probe.api.path 指定认证验证的 API 端点路径。该路径为相对路径，会追加到从 ConnectorClass 的 spec.api 配置解析的 API 地址后。如果 spec.api 包含路径前缀，认证验证时会包含该路径前缀。

    示例

    以下 YAML 配置表示认证验证时，系统会向 ConnectorClass API 发送 GET https://example-api.default.svc.cluster.local/api/auth/check HTTP/1.1 请求。

    kind: ConnectorClass
metadata:
  name: example-class
spec:
  api:
    ref:
      kind: Service
      name: example-api
      namespace: default
    uri: /api
  authProbes:
    - authName: basicAuth
      probe:
        api:
          path: /auth/check # 相对于 connectorclass 的 `spec.api` 解析的 API 地址的相对路径
---
kind: Connector
metadata:
  name: example
spec:
  connectorClassName: example-class
  address: https://example.com

    自定义认证验证参数

    某些认证验证场景可能需要额外参数，例如验证访问 Git 仓库时指定仓库名称。可通过 spec.authProbes[].params 定义这些参数。

    kind: ConnectorClass
metadata:
  name: example-class
spec:
  authProbes:
    - authName: basicAuth  # 对应认证类型
      params:
        - name: repository
          type: string

    认证验证表达式

    配置 authProbes 时，可以使用表达式动态获取凭证信息或连接器元数据。

    例如：

    spec:
  authProbes:
    - authName: basicAuth  # 对应认证类型
      probe:
        http:
          httpHeaders:
            Authorization: {{ .Secret.StringData.token }}
          path: /
      params:
        - name: repository
          type: string
    • 表达式可用于 probe.http.httpHeaders、probe.http.path 和 probe.api.path 字段。
    • 表达式格式遵循 Go 模板 语法。
    • 支持的顶层字段包括：
      • .Connector：包含连接器资源自身信息
      • .Secret：包含用于连接器认证的 Secret 数据
    • 表达式中可用的方法记录在 sprig 库中：
      • 例如：b64enc 用于字符串 Base64 编码，trimPrefix 用于去除字符串前缀

    示例

    基本认证验证：

    spec:
  authProbes:
    - authName: basicAuth
      params:
        - name: repository
          type: string
      probe:
        http:
          path: /{{- range .Connector.Spec.Auth.Params }}{{- if eq .Name "repository" }}{{ .Value.StringVal }}{{ end }}{{- end }}/info/refs?service=git-upload-pack
          httpHeaders:
          - name: Authorization
            value: >-
              {{- if .Secret }}Basic {{ printf "%s:%s" .Secret.StringData.username .Secret.StringData.password | b64enc }} {{- end }}

    连接器将根据 ConnectorClass 中定义的配置执行认证验证。

    上述 YAML 展示了基本认证验证：

    • path：使用连接器 auth.params 中的 repository 值，构造路径为 /<repository>/info/refs?service=git-upload-pack
    • Authorization：当连接器配置了 Secret 时，将 username 和 password 字段进行 Base64 编码，并包含在 Basic 认证头中。

    基于 Rego 的认证逻辑配置

    当工具连接器需要更复杂的认证逻辑时，可以使用基于 Rego 的认证逻辑配置。

    Rego 是一种声明式策略语言，允许定义认证逻辑。在 ConnectorClass 中，Rego 策略通过 auth.types[].generator.rego 字段指定：

    apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: example
spec:
  address:
    name: address
    type: string
  auth:
    types:
    - name: rego-auth
      secretType: Opaque
      generator:
        rego: |
          package proxy
          auth = {
            "position": "header",
            "auth": {
              "Authorization": concat(" ", ["Bearer", input.data.token])
            }
          }

    Rego 策略必须遵循以下规则：

    • 在 proxy 包下定义规则
    • 产生一个结构如下的 auth 对象：
      • position：注入认证的位置，如 "header"、"query" 或 "body"
      • contentType：body 注入时的内容类型（可选，配合 "body" 使用）
      • auth：认证键值对映射

    Rego 中可用变量

    变量类型描述
    input.datamap[string]string用于连接器的 Secret 数据
    input.request.headersmap[string][]string发送给后端工具的请求头
    input.request.bodyobject发送给后端工具的请求体
    input.request.querymap[string][]string发送给后端工具的查询参数
    input.request.methodstring发送给后端工具的 HTTP 方法
    input.request.pathstring发送给后端工具的请求路径
    input.request.hoststring发送给后端工具的请求主机

    Rego 策略示例

    基本认证
    spec:
  auth:
    types:
    - name: basic-rego-auth
      secretType: Opaque
      generator:
        rego: |
          package proxy
          auth = {
            "position": "header",
            "auth": {
              "Authorization": concat(" ", ["Basic", base64.encode(concat(":", [input.data.username, input.data.password]))])
            }
          }
    API Key 认证
    spec:
  auth:
    types:
    - name: apikey-rego-auth
      secretType: Opaque
      generator:
        rego: |
          package proxy
          auth = {
            "position": "query",
            "auth": {
              "api_key": input.data.apikey
            }
          }
    JSON Body 认证
    spec:
  auth:
    types:
    - name: body-rego-auth
      secretType: Opaque
      generator:
        rego: |
          package proxy
          auth = {
            "position": "body",
            "contentType": "application/json",
            "auth": {
              "username": input.data.username,
              "password": input.data.password,
              "client_id": input.data.client_id
            }
          }

    高级 Rego 技巧

    你可以使用 Rego 的条件逻辑实现不同的认证方式：

    条件认证
    spec:
  auth:
    types:
    - name: conditional-auth
      secretType: Opaque
      generator:
        rego: |
          package proxy

          # 默认使用 API key
          auth = {
            "position": "header",
            "auth": {
              "X-API-Key": input.data.apikey
            }
          }

          # 如果存在 OAuth token，则使用 OAuth token
          auth = {
            "position": "header",
            "auth": {
              "Authorization": concat(" ", ["Bearer", input.data.oauth_token])
            }
          } {
            input.data.oauth_token != ""
          }
    基于时间的认证
    spec:
  auth:
    types:
    - name: time-based-auth
      secretType: Opaque
      generator:
        rego: |
          package proxy

          import time

          # 获取当前时间
          current_time := time.now_ns() / 1000000000

          auth = {
            "position": "header",
            "auth": {
              "X-Timestamp": sprintf("%d", [current_time]),
              "X-Signature": hmac.sha256(input.data.api_secret, sprintf("%d", [current_time]))
            }
          }

    更多 Rego 语言详情，请参考：

    ConnectorClass API

    ConnectorClass API 允许开发者通过额外的 HTTP API 服务扩展 ConnectorClass 的 API 能力。它为 ConnectorClass 提供了一个 RESTful API，使客户端在使用连接器时能方便地访问工具内的资源。

    如果不需要为工具提供自定义 API 能力，spec.api 可以不定义。

    配置 API 地址

    ConnectorClass API 在 spec.api 字段配置。你可以通过三种方式指定 API 服务：

    1. 通过 Kubernetes Service 引用：

    spec:
  api:
    ref:
      kind: Service
      name: git
      namespace: default

    2. 通过带 URI 路径前缀的 Service 引用：

    如果 API 地址有固定路径前缀，可以通过 spec.api.uri 指定：

    spec:
  api:
    ref:
      kind: Service
      name: git
      namespace: default
    uri: /api

    3. 通过绝对 URI：

    也可以使用 spec.api.uri 指定 API 的绝对路径：

    spec:
  api:
    uri: https://git.example.com/api

    API 地址解析

    无论使用哪种配置方式，最终解析出的 API 地址会存储在 status.api.address.url 中。例如：

    spec:
  api:
    ref:
      kind: Service
      name: git
      namespace: default
    uri: /prefix
status:
  api:
    address:
      url: https://git.default.svc/prefix

    更多信息请参考：

    OpenAPI 描述

    OpenAPI 描述是可选配置，主要用于两个目的：

    • 标记该 API 是自定义 API 还是通过 Connector Proxy 访问工具原生 API
    • 提供 API 定义，支持客户端动态表单中的 API 引用

    你可以通过 spec.api.openapi 定义 OpenAPI 描述，结构遵循 OpenAPI 3.0 规范。例如：

    spec:
  api:
    openapi:
      openapi: "3.0.1"
      info:
        title: Git API
        version: "1.0.0"

    你可以在 API 路径中定义扩展字段 x-provider-type，标记该 API 是自定义 API 还是通过 Proxy 访问工具原生 API。有效值为 api 或 proxy。

    x-provider-type 扩展定义为：api.openapi.paths[<path>].<verb>[x-provider-type]

    示例：

    spec:
  api:
    openapi:
      openapi: "3.0.1"
      info:
        title: Gitlab API
        version: "1.0.0"
      paths:
        /git/api:
          get:
            summary: Get Git API
            x-provider-type: api  # 使用自定义 API
        /api/v4/projects:
          get:
            summary: Get Gitlab Projects API
            x-provider-type: proxy  # 使用 Proxy 访问工具原生 API
    Info

    当客户端请求 Connector API 时，Connectors 系统会根据当前连接器对应的 ConnectorClass 中 x-provider-type 的值，决定使用自定义 API 还是直接使用 Connectors Proxy 访问工具原生 API。若未提供该信息或未匹配到 API 路径，系统默认使用 Connectors Proxy 访问工具原生 API。

    当需要在动态表单中引用 API 时，需在 spec.api.openapi 中做额外配置。详情请参考 动态表单中使用 Connectors API。

    配置能力

    配置能力定义了 ConnectorClass 向客户端提供的配置文件，这些文件可以通过 Connectors-CSI Driver 挂载到 Pod 中。

    配置类型

    • 自定义配置：通过 spec.configurations 定义
    • 内置配置：由 Connectors-CSI Driver 自动提供（详见：内置配置）

    自定义配置

    通过 spec.configurations 指定配置：

    kind: ConnectorClass
metadata:
  name: git
spec:
  configurations:
  - name: gitconfig
    data:
      .gitconfig: |
        [http]
            extraHeader = Authorization: Basic {{ .context.token | b64enc }}
        [url "{{ .connector.status.proxyAddress }}"]
            insteadOf = {{ .connector.spec.address }}

    详情请参见：配置文件渲染

    注意： spec.configurations 为可选字段，未定义时仅提供内置配置。

    可读性展示的元数据信息

    ConnectorClass 是标准的 k8s 资源，可以通过 labels 和 annotations 打标签，添加自定义信息。

    例如：

    键描述
    ui.cpaas.io/iconConnectorClass 的图标，可选。格式为 data:image/svg+xml;base64,PD94bWwgdmVyc2...
    cpaas.io/display-nameConnectorClass 的显示名称，可选。
    cpaas.io/descriptionConnectorClass 的描述，可选。
    connectors.cpaas.io/readmeConnectorClass 的使用说明，可选。通常用于自定义场景，无法提供 docs-link 时使用。支持 Markdown 格式。
    connectors.cpaas.io/docs-linkConnectorClass 的文档链接，可选。支持相对路径或绝对路径。

    示例：

    apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: git
  labels:
    connectors.cpaas.io/git: "true"
  annotations:
    ui.cpaas.io/icon: "data:image/svg+xml;base64,PD94bWwgdmVyc2..."
    cpaas.io/display-name: Git
    cpaas.io/description: "Connect to any Git tool"
    connectors.cpaas.io/readme: "this is readme..."
    connectors.cpaas.io/docs-link: "/alauda-devops-connectors/concepts/connectorclass/git"

    ConnectorClass 代理

    ConnectorClass 代理用于配置 ConnectorClass 的代理地址。

    ConnectorClass 代理通过 spec.proxy 配置。例如：

    spec:
  proxy:
    ref:
      kind: Service
      name: proxy
      namespace: default
    # uri: https://proxy.example.com

    连接器将使用代理地址将请求代理到 ConnectorClass。更多信息

    使用 Rego 从请求中提取令牌

    使用内置反向代理时，可以通过 spec.proxy.authExtractor 配置 Rego 规则，从客户端请求中提取令牌，使内置反向代理能使用提取的令牌验证客户端认证。

    例如：

    spec:
  proxy:
    authExtractor:
      rego: |
        package proxy
        auth = {
          "token": input.request.headers["Private-Token"][0]
        }

    Rego 规则必须满足以下要求：

    • 规则必须定义在 proxy 包中
    • 使用 auth 变量返回令牌，令牌为字符串类型，例如：auth = { "token": "abcd1234" }
    • 如果无法提取令牌，返回空字符串，例如：auth = { "token": "" }

    Rego 中可用变量：

    键类型描述示例
    request.headersmap[string][]string发送给内置反向代理的请求头input.request.headers["X-Token"][0]
    request.bodyobject发送给内置反向代理的请求体input.request.body.token
    request.querymap[string][]string发送给内置反向代理的查询参数input.request.query["token"][0]
    request.methodstring发送给内置反向代理的 HTTP 方法input.request.method
    request.pathstring发送给内置反向代理的请求路径input.request.path
    request.hoststring发送给内置反向代理的请求主机input.request.host

    注意：

    • headers 中的 Header 键使用 Canonical MIME Header Key 格式（首字母大写）
    • 编写 Rego 规则时请保证逻辑健壮，例如当 input.request.headers 为 null 或空时返回空字符串。

    示例

    spec:
  proxy:
    authExtractor:
      rego: |
        package proxy

        default auth = {
          "token": ""
        }

        auth = {
          "token": input.request.headers["Private-Token"][0]
        } if {
          input.request.headers != null
          input.request.headers["Private-Token"] != null
          count(input.request.headers["Private-Token"]) > 0
        }

    该示例通过以下方式实现了健壮的令牌提取：

    • 定义默认规则返回空令牌字符串
    • 访问前检查 headers 是否存在且不为 null
    • 检查指定的 Header 键是否存在且至少有一个值

    更多高级 Rego 规则请参考 Rego 策略语言 文档。 关于内置反向代理的更多信息，请参见 Connectors Proxy。

    解析器类型

    ConnectorClass 的代理地址将根据指定的 resolver 类型进行解析。

    resolver 类型通过注解 connectors.cpaas.io/proxy-resolver 配置。例如：

    apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: oci
  annotations:
    connectors.cpaas.io/proxy-resolver: "path"

    该字段是 ConnectorClass-Proxy 与 Connector 之间的约定，非必需。

    支持的值：host、path。默认值为 host。

    • host 格式：http://{.ConnectorClass.Status.ProxyAddress.URL}
    • path 格式：http://{.ConnectorClass.Status.ProxyAddress.URL}/namespaces/{namespace}/connectors/{connector-name}

    状态信息

    定义 ConnectorClass 资源后，资源的状态信息会存储在 status 中。

    status.conditions 类型包括：

    • APIReady：API 能力的状态信息
    • ProxyReady：代理能力的状态信息
    • Ready：标记当前 ConnectorClass 的整体状态

    Ready Condition

    Ready Condition 用于标记当前 ConnectorClass 的状态。它聚合其他条件的状态。

    • 当其他条件均为 True 时，当前条件为 True。
    • 当任一其他条件为 False 时，当前条件为 False。
    • 当任一其他条件为 Unknown 时，当前条件为 Unknown。

    APIReady Condition

    表示 ConnectorClass 配置的 API 服务的状态信息。API 服务通过 ConnectorClass 的 spec.api 配置。

    状态原因描述
    TrueNonAPI未配置 spec.api，当前 ConnectorClass 无 API 能力
    True配置了 spec.api，API 服务正常
    False配置了 spec.api，API 能力异常或检测本身异常
    UnknownAPI 能力检测中

    注意：

    • API 检测仅尝试请求链接，不对 HTTP 返回值做判断。API 服务健康检查应依赖 API 服务自身的健康检查机制。
    • 由于 API 服务可能随时变更，API 状态信息无法反映实时信息，建议客户端将其作为提示而非阻断依据。

    ProxyReady Condition

    表示 ConnectorClass 配置的代理服务的状态信息。代理服务通过 ConnectorClass 的 spec.proxy 配置。

    状态原因描述
    TrueNonProxy未配置 spec.proxy，当前 ConnectorClass 无代理能力
    True配置了 spec.proxy，代理服务正常
    False配置了 spec.proxy，代理能力异常或检测本身异常
    Unknown代理能力检测中

    兼容性

    更新 ConnectorClass 可能影响已有的连接器。如果 ConnectorClass 存在不兼容的变更，可能导致之前创建的连接器失效。以下是可能导致不兼容的变更示例：

    1. 认证信息变更：如果 ConnectorClass 修改了支持的认证类型或方式，可能导致使用旧认证方式的连接器异常。

    2. 配置信息变更：如果 ConnectorClass 的配置信息发生变化，例如移除已有配置，可能导致依赖旧配置的 Kubernetes 工作负载异常。

    建议在更新 ConnectorClass 时确认影响范围，必要时创建新的 ConnectorClass。

    更多示例

    • 支持 basic-auth 认证类型的 ConnectorClass

      apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: git
spec:
  address:
    type: string
  auth:
    types:
      - name: basicAuth
        secretType: kubernetes.io/basic-auth
        optional: true

    • 自定义认证类型 ConnectorClass

      apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: sample
spec:
  address:
    type: string
  auth:
    types:
      - name: patAuth
        optional: true
        secretType: Opaque
        params:
        - name: username
        - name: privateToken

    • 配置了 liveness probe 的 ConnectorClass

      apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: git
spec:
  address:
    type: string
  auth:
    types:
      - name: basicAuth
        optional: true
        secretType: kubernetes.io/basic-auth
  livenessProbe:
    http:
      path: /

    • 配置了 auth probe 的 ConnectorClass

      apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: git
  labels:
    connectors.cpaas.io/git: "true"
spec:
  address:
    type: string
  auth:
    types:
      - name: basicAuth
        secretType: kubernetes.io/basic-auth
        optional: true
  livenessProbe:
    http:
      path: /
  authProbes:
    - authName: basicAuth
      params:
        - name: repository
          type: string
      probe:
        http:
          path: /{{- range .Connector.Spec.Auth.Params }}{{- if eq .Name "repository" }}{{ .Value.StringVal }}{{ end }}{{- end }}/info/refs?service=git-upload-pack
          httpHeaders:
          - name: Authorization
            value: >-
              {{- if .Secret }}Basic {{ printf "%s:%s" .Secret.StringData.username .Secret.StringData.password | b64enc }} {{- end }}

    • 完整的 Git 连接器配置示例：

      apiVersion: connectors.alauda.io/v1alpha1
kind: ConnectorClass
metadata:
  name: git
spec:
  address:
    name: address
    type: string
  auth:
    types:
      - name: basicAuth
        secretType: kubernetes.io/basic-auth
        optional: true
  livenessProbe:
    http:
      path: /
  authProbes:
    - authName: basicAuth
      params:
        - name: repository
          type: string
      probe:
        http:
          path: /{{- range .Connector.Spec.Auth.Params }}{{- if eq .Name "repository" }}{{ .Value.StringVal }}{{ end }}{{- end }}/info/refs?service=git-upload-pack
          httpHeaders:
          - name: Authorization
            value: >-
              {{- if .Secret }}Basic {{ printf "%s:%s" .Secret.StringData.username .Secret.StringData.password | b64enc }} {{- end }}

    更多