Crossplane

    云服务是应用程序的一部分。

    可以考虑以下做法:

    • 使用 ComponentDefinition 的场景:
      • 你想要允许最终用户明确声明云服务的实例并使用它，并在删除应用程序时释放该实例。
    • 使用 TraitDefinition 的场景:
      • 你不想让最终用户拥有声明或发布云服务的任何控制权，而只想给他们消费云服务，甚至可以由其他系统管理的云服务的方式。在这种情况下，会广泛使用 Service Binding 特性。

    在本文档中，我们将以阿里云的 RDS（关系数据库服务）和阿里云的 OSS（对象存储服务）为例。在单个应用程序中，它们是 Traits，在多个应用程序中，它们是 Components。此机制与其他云提供商相同。

    如果你想配置任何其他 Crossplane providers，请参阅 Crossplane Select a Getting Started Configuration。

    provider.yaml 如下。

    1. apiVersion: v1
    2. kind: Namespace
    3. metadata:
    4.   name: crossplane-system
    7. ---
    8. apiVersion: alibaba.crossplane.io/v1alpha1
    9. kind: ProviderConfig
    10. metadata:
    11.   name: default
    12. spec:
    13.   credentials:
    14.     source: Secret
    15.     secretRef:
    16.       namespace: crossplane-system
    17.       name: alibaba-account-creds
    18.       key: credentials
    19.   region: cn-beijing

    注意：我们目前仅使用阿里提供的 Crossplane。但是在不久的将来，我们将使用 作为 Kubernetes 的云资源供应商。

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: ComponentDefinition
    3. metadata:
    4.   name: alibaba-oss
    5.   namespace: vela-system
    6.   annotations:
    7.     definition.oam.dev/description: "Alibaba Cloud RDS Resource"
    8. spec:
    9.   workload:
    10.       apiVersion: oss.alibaba.crossplane.io/v1alpha1
    11.       kind: Bucket
    12.   schematic:
    14.       template: |
    15.         output: {
    16.             apiVersion: "oss.alibaba.crossplane.io/v1alpha1"
    17.             kind:       "Bucket"
    18.             spec: {
    19.                 name:               parameter.name
    20.                 acl:                parameter.acl
    21.                 storageClass:       parameter.storageClass
    22.                 dataRedundancyType: parameter.dataRedundancyType
    23.                 writeConnectionSecretToRef: {
    24.                     namespace: context.namespace
    25.                     name:      parameter.secretName
    26.                 }
    27.                 providerConfigRef: {
    28.                     name: "default"
    29.                 }
    30.                 deletionPolicy: "Delete"
    31.             }
    32.         }
    33.         parameter: {
    34.             // +usage=OSS bucket name
    35.             name: string
    36.             // +usage=The access control list of the OSS bucket
    37.             acl: *"private" | string
    38.             // +usage=The storage type of OSS bucket
    39.             storageClass: *"Standard" | string
    40.             // +usage=The data Redundancy type of OSS bucket
    41.             dataRedundancyType: *"LRS" | string
    42.             // +usage=Secret name which RDS connection will write to
    43.             secretName: string
    44.         }

    关键词是 annotation // + insertSecretTo = dbConn，KubeVela 将知道该参数是 K8s 的 secret，它将解析该 secret 并将数据绑定到 CUE 接口 dbConn 中。

    output 可以引用 dbConn 获取数据。dbConn 的名称没有限制。 关键词是 +insertSecretTo，它定义了数据绑定机制。以上只是一个例子。

    至于应用程序中的数据绑定，KubeVela 建议定义一个 trait 以完成工作。我们已经准备了一个方便的 trait。此 trait 非常适合将资源的信息绑定到 pod spec 的环境变量中.

    1. apiVersion: core.oam.dev/v1beta1
    2. kind: TraitDefinition
    3. metadata:
    5.   name: service-binding
    6. spec:
    7.   appliesToWorkloads:
    8.     - webservice
    9.     - worker
    10.   schematic:
    11.     cue:
    12.       template: |
    13.         patch: {
    14.             spec: template: spec: {
    15.                 // +patchKey=name
    16.                 containers: [{
    17.                     name: context.name
    18.                     // +patchKey=name
    19.                     env: [
    20.                         for envName, v in parameter.envMappings {
    21.                             name: envName
    22.                             valueFrom: {
    23.                                 secretKeyRef: {
    24.                                     name: v.secret
    25.                                     if v["key"] != _|_ {
    26.                                         key: v.key
    27.                                     }
    28.                                     if v["key"] == _|_ {
    29.                                         key: envName
    30.                                     }
    31.                                 }
    32.                             }
    33.                         },
    34.                     ]
    35.                 }]
    36.             }
    37.         }
    40.         parameter: {
    41.             // +usage=The mapping of environment variables to secret
    42.             envMappings: [string]: [string]: string
    43.         }

    你可以通过查看 the end user usage workflow 了解其使用方式。