自动为项目创建连接器

概述

在 ACP 集群中创建新的项目命名空间时,需要为该项目配置 Harbor、Nexus、GitLab 和 SonarQube 的连接器。connectors-autocreate 通过监视命名空间事件并触发 Tekton PipelineRun 来自动完成此操作,该流程会协调项目的 Connectors。

架构

系统包含两个组件:

  • Adapter(ns-event-source):监视 Kubernetes 命名空间事件,并将其作为 CloudEvents 转发到 Tekton EventListener。
  • EventListener + Pipeline:接收事件、提取项目上下文,并运行连接器协调任务。

这两个组件可以运行在同一集群中,也可以跨集群运行:

单集群模式

当项目命名空间和管理自动化位于同一集群时使用此模式。

Management cluster
┌─────────────────────────────────────────────────────┐
│ ns-event-source ──CloudEvent──▶ EventListener       │
│ (watches namespaces)            autocreate-el        │
│                                   │                  │
│                                   ▼                  │
│                              PipelineRun             │
│                         connector-auto-create        │
└─────────────────────────────────────────────────────┘

多集群模式

当项目命名空间位于不同的业务集群中,而只有管理自动化组件(EventListener、Pipeline、管理员 Connectors)位于管理集群中时使用此模式。

管理集群中会为每个业务集群创建一个 EventListener。每个 EventListener 的 NodePort(或 Ingress)地址会作为对应业务集群上 Adapter 的 K_SINK。TriggerTemplate 中的 target-kubeconfig 工作区在安装时固定,以指向该业务集群的凭证。

Business cluster A                    Management cluster
┌──────────────────────┐             ┌──────────────────────────────────┐
│ ns-event-source      │──CloudEvent─▶ EventListener autocreate-el-a   │
│ K_SINK = EL-A:port   │             │  TriggerTemplate                 │
└──────────────────────┘             │    workspace: target-kubeconfig-a│
                                     ├──────────────────────────────────┤
Business cluster B                   │ EventListener autocreate-el-b    │
┌──────────────────────┐             │  TriggerTemplate                 │
│ ns-event-source      │──CloudEvent─▶   workspace: target-kubeconfig-b│
│ K_SINK = EL-B:port   │             └──────────────────────────────────┘
└──────────────────────┘

前提条件


单集群安装

当项目命名空间和管理自动化位于同一个集群中时,使用本节。

首先导出这些变量——以下步骤中的 envsubst 会引用它们:

export REGISTRY=<your-registry>
export TARGET_NS=<auto-create-namespace>
kubectl config set-context --current --namespace="$TARGET_NS"
export HARBOR_ADMIN=<harbor-admin-connector-name>
export NEXUS_ADMIN=<nexus-admin-connector-name>
export GITLAB_ADMIN=<gitlab-admin-connector-name>
export SONARQUBE_ADMIN=<sonarqube-admin-connector-name>

步骤 1 — 安装 adapter

应用命名空间 watcher 和接收 adapter:

cat <<'EOF' | envsubst '$TARGET_NS $REGISTRY' | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: ns-event-source
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: ns-event-source
rules:
  - apiGroups: [""]
    resources: ["namespaces"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ns-event-source
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: ns-event-source
subjects:
  - kind: ServiceAccount
    name: ns-event-source
    namespace: $TARGET_NS
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ns-event-source
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ns-event-source
  template:
    metadata:
      labels:
        app: ns-event-source
    spec:
      serviceAccountName: ns-event-source
      enableServiceLinks: false
      containers:
        - name: receive-adapter
          image: ${REGISTRY}/alauda-connectors/connectors-extensions/apiserver-receive-adapter:v1.22.0-alauda.3
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
            limits:
              cpu: 200m
              memory: 200Mi
          env:
            - name: K_SINK
              value: http://el-autocreate-el:8080
            - name: K_SOURCE_CONFIG
              value: '{"allNamespaces":true,"resources":[{"gvr":{"Group":"","Version":"v1","Resource":"namespaces"},"selector":"cpaas.io/project"}],"mode":"Resource"}'
            - name: NAME
              value: ns-event-source
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: ["ALL"]
            runAsNonRoot: true
            seccompProfile:
              type: RuntimeDefault
EOF

注意:adapter 的 K_SINK 指向步骤 3 中创建的 EventListener 服务。 adapter pod 会立即启动,但在应用步骤 3 之前无法连接;服务可用后,它会自动重新连接。

步骤 2 — 安装 pipeline

应用 pipeline RBAC 和 Tekton Pipeline:

cat <<'EOF' | envsubst '$TARGET_NS $REGISTRY' | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: connector-auto-create-pipeline
  namespace: $TARGET_NS
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    app.kubernetes.io/component: connector-auto-create
    app.kubernetes.io/name: connectors-operator
    connectors.alauda.io/install-flag: auto-create
  name: connector-auto-create-pipeline
rules:
  - apiGroups: [""]
    resources: ["namespaces"]
    verbs: ["get", "list"]
  - apiGroups: [""]
    resources: ["secrets"]
    verbs: ["get", "create", "patch"]
  - apiGroups: ["connectors.alauda.io"]
    resources: ["connectors"]
    verbs: ["get", "create", "patch"]
  - apiGroups: [""]
    resources: ["serviceaccounts"]
    verbs: ["get", "patch"]
  - apiGroups: ["coordination.k8s.io"]
    resources: ["leases"]
    verbs: ["get", "create", "delete", "patch"]
  - apiGroups: ["tekton.dev"]
    resources: ["pipelineruns"]
    verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: connector-auto-create-pipeline
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: connector-auto-create-pipeline
subjects:
  - kind: ServiceAccount
    name: connector-auto-create-pipeline
    namespace: $TARGET_NS
---
# The four <tool>-connector-automatic-creation Tasks are provided by
# connectors-{harbor,nexus,gitlab,sonarqube} and must be installed in the run namespace.
apiVersion: tekton.dev/v1
kind: Pipeline
metadata:
  annotations:
    skip-sync: "true"
  labels:
    connectors.alauda.io/install-flag: auto-create
  name: connector-auto-create
spec:
  params:
  - name: namespace
    description: Business namespace whose creation or update triggered this reconciliation
    type: string
  - name: project
    description: ACP project name used as the tenant and generated Connector name prefix
    type: string
  - name: harborAdmin
    description: Name of the Harbor administrator Connector mounted in the harbor-admin workspace
    type: string
  - name: nexusAdmin
    description: Name of the Nexus administrator Connector used to resolve the base URL
    type: string
  - name: gitlabAdmin
    description: Name of the GitLab administrator Connector used to resolve the base URL
    type: string
  - name: sonarqubeAdmin
    description: Name of the SonarQube administrator Connector used to resolve the base URL
    type: string
  - default: "true"
    description: Whether to reconcile the project Harbor Connector and image pull credentials
    name: enableHarbor
    type: string
  - default: "true"
    description: Bind each generated Harbor image pull Secret to the ServiceAccount selected by serviceAccountName in every namespace in the project
    name: bindImagePullSecretToSA
    type: string
  - default: default
    description: Name of the existing ServiceAccount that receives Harbor image pull Secrets when bindImagePullSecretToSA is true; the same name is used in every namespace in the project
    name: serviceAccountName
    type: string
  - default: "false"
    description: Whether to reconcile the project Nexus Connector when it does not already exist
    name: enableNexus
    type: string
  - default: "false"
    description: Whether to reconcile the project GitLab Connector when it does not already exist
    name: enableGitLab
    type: string
  - default: "false"
    description: Whether to reconcile the project SonarQube Connector when it does not already exist
    name: enableSonarQube
    type: string
  - default: "30"
    description: Validity period, in whole days, for the GitLab group access token and SonarQube user token
    name: tokenDurationDays
    type: string
  - default: ""
    description: GitLab parent group path under which the project group is created; required when GitLab reconciliation is enabled
    name: gitlabParentGroup
    type: string
  - default: ""
    description: Optional regular-expression fragment inserted before the project name in the SonarQube permission-template project-key pattern
    name: sonarPatternPrefix
    type: string
  - default: ""
    description: Optional regular-expression fragment inserted after the project name in the SonarQube permission-template project-key pattern
    name: sonarPatternSuffix
    type: string
  - default: ""
    description: Optional Nexus base URL override; empty resolves the URL from the mounted nexus-admin Connector
    name: nexusUrl
    type: string
  - default: ""
    description: Optional GitLab base URL override; empty resolves the URL from the mounted gitlab-admin Connector
    name: gitlabUrl
    type: string
  - default: "300"
    description: Duration in seconds after which a project reconciliation Lease is considered expired
    name: lockDurationSeconds
    type: string
  - default: "600"
    description: Maximum time in seconds to wait for another reconciliation of the same project to release its lock
    name: lockWaitSeconds
    type: string
  results:
  - description: Namespace in which the generated project Connectors are stored
    name: inner-namespace
    value: $(tasks.prepare-project-context.results.innerNs)
  tasks:
  - name: prepare-project-context
    params:
    - name: namespace
      value: $(params.namespace)
    - name: project
      value: $(params.project)
    - name: holder
      value: $(context.pipelineRun.name)
    - name: runNamespace
      value: $(context.pipelineRun.namespace)
    - name: nexusUrl
      value: $(params.nexusUrl)
    - name: gitlabUrl
      value: $(params.gitlabUrl)
    - name: nexusAdmin
      value: $(params.nexusAdmin)
    - name: gitlabAdmin
      value: $(params.gitlabAdmin)
    - name: sonarqubeAdmin
      value: $(params.sonarqubeAdmin)
    - name: enableNexus
      value: $(params.enableNexus)
    - name: enableGitLab
      value: $(params.enableGitLab)
    - name: enableHarbor
      value: $(params.enableHarbor)
    - name: enableSonarQube
      value: $(params.enableSonarQube)
    - name: lockDurationSeconds
      value: $(params.lockDurationSeconds)
    - name: lockWaitSeconds
      value: $(params.lockWaitSeconds)
    taskSpec:
      metadata: {}
      params:
      - name: namespace
        type: string
      - name: project
        type: string
      - name: holder
        type: string
      - name: runNamespace
        type: string
      - name: nexusUrl
        type: string
      - name: gitlabUrl
        type: string
      - name: enableNexus
        type: string
      - name: enableGitLab
        type: string
      - name: enableHarbor
        type: string
      - name: enableSonarQube
        type: string
      - name: lockDurationSeconds
        type: string
      - name: lockWaitSeconds
        type: string
      results:
      - name: innerNs
        type: string
      - name: needsNexus
        type: string
      - name: needsGitlab
        type: string
      - name: needsSonarqube
        type: string
      - name: nexusUrl
        type: string
      - name: gitlabUrl
        type: string
      - name: harborImagePullSecrets
        type: array
      steps:
      - name: resolve-context
        image: ${REGISTRY}/alauda-connectors/kubectl:v1.33
        computeResources: {}
        env:
        - name: TARGET_NAMESPACE
          value: $(params.namespace)
        - name: PROJECT
          value: $(params.project)
        securityContext: &restrictedStepSecurityContext
          allowPrivilegeEscalation: false
          capabilities:
            drop:
            - ALL
          runAsNonRoot: true
          seccompProfile:
            type: RuntimeDefault
        script: |
          #!/usr/bin/env sh
          set -eu

          log() { printf '[%s] [context] %s\n' "$1" "$2"; }
          [ -n "$PROJECT" ] || { log ERROR "project must not be empty"; exit 1; }

          log INFO "resolving project context for ${TARGET_NAMESPACE}"
          actual_project="$(kubectl get namespace "$TARGET_NAMESPACE" -o jsonpath='{.metadata.labels.cpaas\.io/project}')"
          [ "$actual_project" = "$PROJECT" ] || {
            log ERROR "namespace project label '${actual_project}' does not match '${PROJECT}'"
            exit 1
          }
          inner_ns="$(kubectl get namespace "$TARGET_NAMESPACE" -o jsonpath='{.metadata.annotations.cpaas\.io/project-inner-namespace}')"
          [ -n "$inner_ns" ] || { log ERROR "missing cpaas.io/project-inner-namespace annotation"; exit 1; }
          printf '%s' "$inner_ns" > "$(results.innerNs.path)"
          log INFO "inner namespace: ${inner_ns}"

      - name: acquire-project-lock
        image: ${REGISTRY}/alauda-connectors/kubectl:v1.33
        computeResources: {}
        env:
        - name: HOLDER
          value: $(params.holder)
        - name: RUN_NAMESPACE
          value: $(params.runNamespace)
        - name: LOCK_DURATION_SECONDS
          value: $(params.lockDurationSeconds)
        - name: LOCK_WAIT_SECONDS
          value: $(params.lockWaitSeconds)
        securityContext: *restrictedStepSecurityContext
        script: |
          #!/usr/bin/env sh
          set -eu

          lock_name=connector-autocreate
          retry_seconds=5
          wait_log_interval_seconds=15
          holder="$HOLDER"
          run_ns="$RUN_NAMESPACE"
          duration="$LOCK_DURATION_SECONDS"
          wait_seconds="$LOCK_WAIT_SECONDS"
          inner_ns="$(cat "$(results.innerNs.path)")"

          log() { printf '[%s] [%s] %s\n' "$1" "$2" "$3"; }

          validate_inputs() {
            case "$duration:$wait_seconds" in
              *[!0-9:]*|:*) log ERROR lock "lock durations must be positive integers"; return 1 ;;
            esac
            if [ "$duration" -le 0 ] || [ "$wait_seconds" -le 0 ]; then
              log ERROR lock "lock durations must be greater than zero"
              return 1
            fi
          }

          discover_lease_resource() {
            response="$(mktemp)"
            error="$(mktemp)"
            if kubectl get --raw /apis/coordination.k8s.io/v1 >"$response" 2>"$error"; then
              if grep -Eq '"name"[[:space:]]*:[[:space:]]*"leases"' "$response"; then
                rm -f "$response" "$error"
                return 0
              fi
            elif ! grep -Eq 'NotFound|404|the server could not find the requested resource' "$error"; then
              cat "$error" >&2
              rm -f "$response" "$error"
              log ERROR lock "failed to discover coordination.k8s.io/v1 Lease resource"
              return 1
            fi
            rm -f "$response" "$error"
            log WARN lock "coordination.k8s.io/v1 Lease resource is not served; continuing without project-level concurrency protection"
            return 2
          }

          create_lock() {
            create_error="$(mktemp)"
            if cat <<EOF | kubectl create -f - >/dev/null 2>"$create_error"
          apiVersion: coordination.k8s.io/v1
          kind: Lease
          metadata:
            name: ${lock_name}
            namespace: ${inner_ns}
            labels:
              app.kubernetes.io/component: connector-auto-create
          spec:
            holderIdentity: ${holder}
            leaseDurationSeconds: ${duration}
            acquireTime: "$(date -u +%Y-%m-%dT%H:%M:%S.000000Z)"
            renewTime: "$(date -u +%Y-%m-%dT%H:%M:%S.000000Z)"
          EOF
            then
              rm -f "$create_error"
              return 0
            fi
            if grep -q 'AlreadyExists' "$create_error"; then
              rm -f "$create_error"
              return 2
            fi
            cat "$create_error" >&2
            rm -f "$create_error"
            return 1
          }

          read_lock_state() {
            if ! state="$(kubectl get lease "$lock_name" -n "$inner_ns" \
                -o jsonpath='{.spec.holderIdentity}{"|"}{.spec.renewTime}{"|"}{.spec.leaseDurationSeconds}{"|"}{.metadata.resourceVersion}')"; then
              log ERROR lock "failed to inspect project provisioning lock ${inner_ns}/${lock_name}"
              return 1
            fi
            old_ifs="$IFS"
            IFS='|'
            read -r current_holder renew_time lease_duration resource_version <<EOF
          $state
          EOF
            IFS="$old_ifs"
          }

          holder_is_terminal() {
            holder_state=""
            holder_exists=false
            [ -n "$current_holder" ] || return 1
            if kubectl get pipelinerun "$current_holder" -n "$run_ns" >/dev/null 2>&1; then
              holder_exists=true
              holder_state="$(kubectl get pipelinerun "$current_holder" -n "$run_ns" \
                -o jsonpath='{.status.conditions[-1].status}' 2>/dev/null || true)"
            fi
            [ "$holder_state" = "True" ] || [ "$holder_state" = "False" ]
          }

          lease_is_expired() {
            [ -n "$renew_time" ] && [ -n "$lease_duration" ] || return 1
            normalized="$(printf '%s\n' "$renew_time" | sed 's/\.[0-9][0-9]*Z$/Z/')"
            if ! renew_epoch="$(date -D '%Y-%m-%dT%H:%M:%SZ' -d "$normalized" +%s 2>/dev/null)"; then
              log ERROR lock "cannot parse Lease renewTime: ${renew_time}"
              return 2
            fi
            [ $((renew_epoch + lease_duration)) -le "$(date +%s)" ]
          }

          lock_is_reclaimable() {
            [ -z "$current_holder" ] && return 0
            holder_is_terminal && return 0
            if [ "$holder_exists" = false ]; then
              if lease_is_expired; then return 0; else expired_status=$?; fi
              [ "$expired_status" -ne 2 ] || return 2
            fi
            return 1
          }

          take_over_lock() {
            now="$(date -u +%Y-%m-%dT%H:%M:%S.000000Z)"
            kubectl patch lease "$lock_name" -n "$inner_ns" --type=json \
              -p="[{\"op\":\"test\",\"path\":\"/metadata/resourceVersion\",\"value\":\"${resource_version}\"},{\"op\":\"add\",\"path\":\"/spec/holderIdentity\",\"value\":\"${holder}\"},{\"op\":\"add\",\"path\":\"/spec/acquireTime\",\"value\":\"${now}\"},{\"op\":\"add\",\"path\":\"/spec/renewTime\",\"value\":\"${now}\"}]" \
              >/dev/null 2>&1
          }

          acquire_lock() {
            waited=0
            last_logged_holder=""
            while true; do
              if create_lock; then return 0; else create_status=$?; fi
              if [ "$create_status" -ne 2 ]; then
                log ERROR lock "failed to create project provisioning lock ${inner_ns}/${lock_name}"
                return "$create_status"
              fi
              read_lock_state || return 1
              [ "$current_holder" = "$holder" ] && return 0
              if lock_is_reclaimable; then
                take_over_lock && return 0
              else
                reclaim_status=$?
                [ "$reclaim_status" -ne 2 ] || return 1
              fi
              if [ "$current_holder" != "$last_logged_holder" ] || [ $((waited % wait_log_interval_seconds)) -eq 0 ]; then
                log INFO lock "waiting for lock ${inner_ns}/${lock_name} holder=${current_holder:-<empty>} waited=${waited}s timeout=${wait_seconds}s; retrying in ${retry_seconds}s"
                last_logged_holder="$current_holder"
              fi
              waited=$((waited + retry_seconds))
              if [ "$waited" -ge "$wait_seconds" ]; then
                log ERROR lock "timed out waiting for lock held by ${current_holder}"
                return 1
              fi
              sleep "$retry_seconds"
            done
          }

          validate_inputs
          if discover_lease_resource; then
            acquire_lock
            if [ "$waited" -gt 0 ]; then
              log INFO lock "acquired ${inner_ns}/${lock_name} holder=${holder} after waiting ${waited} seconds; duration=${duration}s"
            else
              log INFO lock "acquired ${inner_ns}/${lock_name} holder=${holder} duration=${duration}s"
            fi
          else
            discovery_status=$?
            [ "$discovery_status" -eq 2 ] || exit "$discovery_status"
          fi

      - name: inspect-project
        image: ${REGISTRY}/alauda-connectors/kubectl:v1.33
        computeResources: {}
        env:
        - name: PROJECT
          value: $(params.project)
        - name: RUN_NAMESPACE
          value: $(params.runNamespace)
        - name: ENABLE_NEXUS
          value: $(params.enableNexus)
        - name: ENABLE_GITLAB
          value: $(params.enableGitLab)
        - name: ENABLE_HARBOR
          value: $(params.enableHarbor)
        - name: ENABLE_SONARQUBE
          value: $(params.enableSonarQube)
        - name: NEXUS_URL_OVERRIDE
          value: $(params.nexusUrl)
        - name: GITLAB_URL_OVERRIDE
          value: $(params.gitlabUrl)
        - name: NEXUS_ADMIN
          value: $(params.nexusAdmin)
        - name: GITLAB_ADMIN
          value: $(params.gitlabAdmin)
        - name: SONARQUBE_ADMIN
          value: $(params.sonarqubeAdmin)
        securityContext: *restrictedStepSecurityContext
        script: |
          #!/usr/bin/env sh
          set -eu

          log() { printf '[%s] [%s] %s\n' "$1" "$2" "$3" >&2; }
          inner_ns="$(cat "$(results.innerNs.path)")"
          run_ns="$RUN_NAMESPACE"
          nexus_url="$NEXUS_URL_OVERRIDE"
          if [ "$ENABLE_NEXUS" = "true" ] && [ -z "$nexus_url" ]; then
            nexus_url="$(kubectl get connector.connectors.alauda.io "$NEXUS_ADMIN" -n "$run_ns" \
              -o jsonpath='{.spec.address}')"
          fi
          if [ "$ENABLE_NEXUS" = "true" ] && [ -z "$nexus_url" ]; then
            echo "$NEXUS_ADMIN Connector has no spec.address" >&2
            exit 1
          fi
          printf '%s' "$nexus_url" > "$(results.nexusUrl.path)"

          gitlab_url="$GITLAB_URL_OVERRIDE"
          if [ "$ENABLE_GITLAB" = "true" ] && [ -z "$gitlab_url" ]; then
            gitlab_url="$(kubectl get connector.connectors.alauda.io "$GITLAB_ADMIN" -n "$run_ns" \
              -o jsonpath='{.spec.address}')"
          fi
          if [ "$ENABLE_GITLAB" = "true" ] && [ -z "$gitlab_url" ]; then
            echo "$GITLAB_ADMIN Connector has no spec.address" >&2
            exit 1
          fi
          printf '%s' "$gitlab_url" > "$(results.gitlabUrl.path)"

          sonar_url=""
          if [ "$ENABLE_SONARQUBE" = "true" ]; then
            sonar_url="$(kubectl get connector.connectors.alauda.io "$SONARQUBE_ADMIN" -n "$run_ns" \
              -o jsonpath='{.spec.address}')"
            sonar_url="${sonar_url%/}"
            if [ -z "$sonar_url" ]; then
              echo "$SONARQUBE_ADMIN Connector has no spec.address" >&2
              exit 1
            fi
          fi

          needs_connector() {
            suffix="$1"
            expected_address="$2"
            connector="${PROJECT}-${suffix}"
            expected_secret="${connector}-secret"
            if ! kubectl get connector.connectors.alauda.io "$connector" -n "$inner_ns" >/dev/null 2>&1; then
              log INFO connector "connector=${connector} exists=false expectedAddress=${expected_address} expectedSecret=${expected_secret} reconcile=true"
              printf true
              return
            fi

            ready="$(kubectl get connector.connectors.alauda.io "$connector" -n "$inner_ns" \
              -o jsonpath='{range .status.conditions[?(@.type=="Ready")]}{.status}{end}' 2>/dev/null || true)"
            actual_address="$(kubectl get connector.connectors.alauda.io "$connector" -n "$inner_ns" \
              -o jsonpath='{.spec.address}' 2>/dev/null || true)"
            secret_name="$(kubectl get connector.connectors.alauda.io "$connector" -n "$inner_ns" \
              -o jsonpath='{.spec.auth.secretRef.name}' 2>/dev/null || true)"
            secret_ns="$(kubectl get connector.connectors.alauda.io "$connector" -n "$inner_ns" \
              -o jsonpath='{.spec.auth.secretRef.namespace}' 2>/dev/null || true)"
            secret_exists=false
            if kubectl get secret "$expected_secret" -n "$inner_ns" >/dev/null 2>&1; then
              secret_exists=true
            fi
            reconcile=true
            if [ "$ready" = "True" ] && [ "$actual_address" = "$expected_address" ] \
                && [ "$secret_name" = "$expected_secret" ] && [ "$secret_ns" = "$inner_ns" ] \
                && [ "$secret_exists" = "true" ]; then
              reconcile=false
            fi
            log INFO connector "connector=${connector} expectedAddress=${expected_address} actualAddress=${actual_address} expectedSecret=${inner_ns}/${expected_secret} actualSecret=${secret_ns}/${secret_name} ready=${ready:-missing} secretExists=${secret_exists} reconcile=${reconcile}"
            if [ "$reconcile" = "false" ]; then
              printf false
            else
              printf true
            fi
          }

          needs_connector nexus "$nexus_url" > "$(results.needsNexus.path)"
          needs_connector gitlab "$gitlab_url" > "$(results.needsGitlab.path)"
          needs_connector sonarqube "$sonar_url" > "$(results.needsSonarqube.path)"
          pull_secret_name="${PROJECT}-harbor-pull"
          namespace_names="$(kubectl get namespaces -l "cpaas.io/project=${PROJECT}" \
            -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{end}')"
          harbor_target_count="$(printf '%s\n' "$namespace_names" | awk 'NF { count++ } END { print count + 0 }')"
          printf '%s\n' "$namespace_names" | awk -v secret="$pull_secret_name" '
            BEGIN { printf "["; separator = "" }
            NF { printf "%s\"%s/%s\"", separator, $0, secret; separator = "," }
            END { print "]" }
          ' > "$(results.harborImagePullSecrets.path)"
          log INFO summary "harborEnabled=${ENABLE_HARBOR} harborPullSecretTargets=${harbor_target_count} nexus=$(cat "$(results.needsNexus.path)") gitlab=$(cat "$(results.needsGitlab.path)") sonarqube=$(cat "$(results.needsSonarqube.path)")"
  - name: harbor-connector-automatic-creation
    params:
    - name: connector
      value: $(tasks.prepare-project-context.results.innerNs)/$(params.project)-harbor
    - name: harborProjects
      value:
      - $(params.project)
    - name: permissions
      value:
      - repository:pull,push
    - name: robotTokenPolicy
      value: reuse
    - name: bindImagePullSecretToSA
      value: $(params.bindImagePullSecretToSA)
    - name: serviceAccountName
      value: $(params.serviceAccountName)
    - name: imagePullSecrets
      value: $(tasks.prepare-project-context.results.harborImagePullSecrets[*])
    runAfter:
    - prepare-project-context
    taskRef:
      kind: Task
      name: harbor-connector-automatic-creation
    when:
    - input: $(params.enableHarbor)
      operator: in
      values:
      - "true"
    workspaces:
    - name: harbor-config
      workspace: harbor-admin
  - name: nexus-connector-automatic-creation
    params:
    - name: connector
      value: $(tasks.prepare-project-context.results.innerNs)/$(params.project)-nexus
    - name: nexusUrl
      value: $(tasks.prepare-project-context.results.nexusUrl)
    - name: nexusRepositories
      value: |
        provision:
          - name: $(params.project)-maven-hosted
            format: maven2
            type: hosted
            actions: [read, browse, add, edit]
    runAfter:
    - prepare-project-context
    taskRef:
      kind: Task
      name: nexus-connector-automatic-creation
    when:
    - input: $(params.enableNexus)
      operator: in
      values:
      - "true"
    - input: $(tasks.prepare-project-context.results.needsNexus)
      operator: in
      values:
      - "true"
    workspaces:
    - name: nexus-secret
      workspace: nexus-admin
  - name: gitlab-connector-automatic-creation
    params:
    - name: connector
      value: $(tasks.prepare-project-context.results.innerNs)/$(params.project)-gitlab
    - name: tenantGroup
      value: $(params.gitlabParentGroup)
    - name: gitlabUrl
      value: $(tasks.prepare-project-context.results.gitlabUrl)
    - name: tokenDuration
      value: $(params.tokenDurationDays)
    runAfter:
    - prepare-project-context
    taskRef:
      kind: Task
      name: gitlab-connector-automatic-creation
    when:
    - input: $(params.enableGitLab)
      operator: in
      values:
      - "true"
    - input: $(tasks.prepare-project-context.results.needsGitlab)
      operator: in
      values:
      - "true"
    workspaces:
    - name: gitlabconfig
      workspace: gitlab-admin
  - name: sonarqube-auto-create
    params:
    - name: connector
      value: $(tasks.prepare-project-context.results.innerNs)/$(params.project)-sonarqube
    - name: projectPattern
      value: ^$(params.sonarPatternPrefix)$(params.project)$(params.sonarPatternSuffix).*
    - name: tenant
      value: $(params.project)
    - name: tokenDuration
      value: $(params.tokenDurationDays)
    runAfter:
    - prepare-project-context
    taskRef:
      kind: Task
      name: sonarqube-connector-automatic-creation
    when:
    - input: $(params.enableSonarQube)
      operator: in
      values:
      - "true"
    - input: $(tasks.prepare-project-context.results.needsSonarqube)
      operator: in
      values:
      - "true"
    workspaces:
    - name: sonarqube-config
      workspace: sonar-admin
  finally:
  - name: release-project-lock
    params:
    - name: namespace
      value: $(params.namespace)
    - name: holder
      value: $(context.pipelineRun.name)
    taskSpec:
      metadata: {}
      params:
      - name: namespace
        type: string
      - name: holder
        type: string
      steps:
      - name: release
        image: ${REGISTRY}/alauda-connectors/kubectl:v1.33
        securityContext: *restrictedStepSecurityContext
        computeResources: {}
        script: |
          #!/usr/bin/env sh
          set -eu
          inner_ns="$(kubectl get namespace "$(params.namespace)" \
            -o jsonpath='{.metadata.annotations.cpaas\.io/project-inner-namespace}' 2>/dev/null || true)"
          [ -n "$inner_ns" ] || exit 0
          current_holder="$(kubectl get lease connector-autocreate -n "$inner_ns" \
            -o jsonpath='{.spec.holderIdentity}' 2>/dev/null || true)"
          if [ "$current_holder" = "$(params.holder)" ]; then
            kubectl delete lease connector-autocreate -n "$inner_ns" --ignore-not-found
            echo "released project provisioning lock ${inner_ns}/connector-autocreate"
          fi
  workspaces:
  - name: harbor-admin
    description: Harbor administrator configuration mounted by the harbor-admin Connector
  - name: nexus-admin
    description: Nexus administrator credentials and connection configuration mounted by the nexus-admin Connector
  - name: gitlab-admin
    description: GitLab administrator token and connection configuration mounted by the gitlab-admin Connector
  - name: sonar-admin
    description: SonarQube administrator credentials and connection configuration mounted by the sonarqube-admin Connector
  - name: target-kubeconfig
    description: Reserved optional kubeconfig workspace; current tasks reconcile resources in the PipelineRun cluster
    optional: true
EOF

步骤 3 — 安装 Triggers

应用 EventListener RBAC、TriggerBinding、TriggerTemplate 和 EventListener:

cat <<'EOF' | envsubst '$TARGET_NS $REGISTRY $HARBOR_ADMIN $NEXUS_ADMIN $GITLAB_ADMIN $SONARQUBE_ADMIN' | kubectl apply -f -
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: autocreate-el-sa
  namespace: $TARGET_NS
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: autocreate-el-sa-binding
  namespace: $TARGET_NS
  labels:
    connectors.alauda.io/install-flag: auto-create
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: tekton-triggers-eventlistener-roles
subjects:
  - kind: ServiceAccount
    name: autocreate-el-sa
    namespace: $TARGET_NS
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: autocreate-el-sa-clusterbinding
  labels:
    connectors.alauda.io/install-flag: auto-create
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: tekton-triggers-eventlistener-clusterroles
subjects:
  - kind: ServiceAccount
    name: autocreate-el-sa
    namespace: $TARGET_NS
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: autocreate-el-sa-pipelinerun-creator
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: tekton-triggers-eventlistener-roles
subjects:
  - kind: ServiceAccount
    name: autocreate-el-sa
    namespace: $TARGET_NS
---
apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerBinding
metadata:
  name: autocreate-binding
spec:
  params:
    - name: namespace
      value: $(body.metadata.name)
    - name: project
      value: $(extensions.project)
---
apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerTemplate
metadata:
  name: autocreate-template
spec:
  params:
    - name: namespace
    - name: project
    - default: connector-auto-create
      name: pipelineRef
    - default: connector-auto-create-pipeline
      name: pipelineSA
    - default: $HARBOR_ADMIN
      name: harborAdmin
    - default: $NEXUS_ADMIN
      name: nexusAdmin
    - default: $GITLAB_ADMIN
      name: gitlabAdmin
    - default: $SONARQUBE_ADMIN
      name: sonarqubeAdmin
  resourcetemplates:
    - apiVersion: tekton.dev/v1
      kind: PipelineRun
      metadata:
        generateName: autocreate-triggered-
        labels:
          autocreate.connectors.alauda.io/project: $(tt.params.project)
      spec:
        params:
          - name: namespace
            value: $(tt.params.namespace)
          - name: project
            value: $(tt.params.project)
          - name: harborAdmin
            value: $(tt.params.harborAdmin)
          - name: nexusAdmin
            value: $(tt.params.nexusAdmin)
          - name: gitlabAdmin
            value: $(tt.params.gitlabAdmin)
          - name: sonarqubeAdmin
            value: $(tt.params.sonarqubeAdmin)
          - name: enableHarbor
            value: "true"
          - name: enableNexus
            value: "true"
          - name: enableGitLab
            value: "true"
          - name: enableSonarQube
            value: "true"
          - name: tokenDurationDays
            value: "30"
          - name: lockDurationSeconds
            value: "300"
          - name: lockWaitSeconds
            value: "600"
          - name: gitlabParentGroup
            value: $(tt.params.project)
        pipelineRef:
          name: $(tt.params.pipelineRef)
        taskRunTemplate:
          podTemplate:
            securityContext:
              fsGroup: 65532
              runAsNonRoot: true
              seccompProfile:
                type: RuntimeDefault
          serviceAccountName: $(tt.params.pipelineSA)
        workspaces:
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                configuration.names: harbor-cli-config
                connector.name: $HARBOR_ADMIN
            name: harbor-admin
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                connector.name: $NEXUS_ADMIN
            name: nexus-admin
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                configuration.names: gitlabconfig
                connector.name: $GITLAB_ADMIN
            name: gitlab-admin
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                configuration.names: sonar-scanner
                connector.name: $SONARQUBE_ADMIN
            name: sonar-admin
---
apiVersion: triggers.tekton.dev/v1beta1
kind: EventListener
metadata:
  name: autocreate-el
spec:
  namespaceSelector: {}
  resources: {}
  serviceAccountName: autocreate-el-sa
  triggers:
    - bindings:
        - kind: TriggerBinding
          ref: autocreate-binding
      interceptors:
        - params:
            - name: filter
              value: (header.match('ce-type', 'dev.knative.apiserver.resource.add') || header.match('ce-type', 'dev.knative.apiserver.resource.update')) && body.metadata.labels['cpaas.io/project'] != ''
            - name: overlays
              value:
                - expression: body.metadata.labels['cpaas.io/project']
                  key: project
          ref:
            kind: ClusterInterceptor
            name: cel
      name: autocreate-trigger
      template:
        ref: autocreate-template
EOF

多集群安装

当项目命名空间位于不同的业务集群中时,使用本节。 为每个业务集群重复步骤 1–3,每次使用不同的 CLUSTER_NAME。

步骤 2 和步骤 3(Pipeline + Pipeline RBAC)与单集群安装相同——如果尚未完成,请在管理集群中应用一次。

步骤 1 — 准备目标集群凭证

首先导出 CLUSTER_NAME——整个过程中都会重复使用同一个值:

export CLUSTER_NAME=<cluster-name>   # e.g. prod-biz-01
export TARGET_NS=<auto-create-namespace>

选项 A — kubeconfig Secret

在管理命名空间中创建一个 Secret,用于保存业务集群的 kubeconfig:

kubectl create secret generic target-kubeconfig-${CLUSTER_NAME} \
  --from-file=kubeconfig=<path-to-cluster-kubeconfig> \
  -n "$TARGET_NS"

选项 B — Kubernetes Connector

如果希望通过 Connectors 系统管理集群凭证,则改为为业务集群创建 Kubernetes Connector。请参阅 Kubernetes Connector 快速入门,了解如何创建 Connector,然后使用下方 TriggerTemplate workspace 中所示的 CSI 卷形式。

步骤 2 — 创建 TriggerBinding 和 TriggerTemplate

应用管理集群中的 Tekton Trigger 资源:

export HARBOR_ADMIN=<harbor-admin-connector-name>
export NEXUS_ADMIN=<nexus-admin-connector-name>
export GITLAB_ADMIN=<gitlab-admin-connector-name>
export SONARQUBE_ADMIN=<sonarqube-admin-connector-name>

cat <<'EOF' | envsubst | kubectl apply -f -
---
apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerBinding
metadata:
  name: autocreate-binding-$CLUSTER_NAME
  namespace: $TARGET_NS
spec:
  params:
    - name: namespace
      value: $(body.metadata.name)
    - name: project
      value: $(extensions.project)
---
apiVersion: triggers.tekton.dev/v1beta1
kind: TriggerTemplate
metadata:
  name: autocreate-template-$CLUSTER_NAME
  namespace: $TARGET_NS
spec:
  params:
    - name: namespace
    - name: project
    - default: connector-auto-create
      name: pipelineRef
    - default: connector-auto-create-pipeline
      name: pipelineSA
  resourcetemplates:
    - apiVersion: tekton.dev/v1
      kind: PipelineRun
      metadata:
        generateName: autocreate-triggered-
        labels:
          autocreate.connectors.alauda.io/project: $(tt.params.project)
          autocreate.connectors.alauda.io/cluster: $CLUSTER_NAME
      spec:
        params:
          - name: namespace
            value: $(tt.params.namespace)
          - name: project
            value: $(tt.params.project)
          - name: enableHarbor
            value: "true"
          - name: enableNexus
            value: "true"
          - name: enableGitLab
            value: "true"
          - name: enableSonarQube
            value: "true"
          - name: tokenDurationDays
            value: "30"
          - name: lockDurationSeconds
            value: "300"
          - name: lockWaitSeconds
            value: "600"
          - name: gitlabParentGroup
            value: $(tt.params.project)
        pipelineRef:
          name: $(tt.params.pipelineRef)
        taskRunTemplate:
          podTemplate:
            securityContext:
              fsGroup: 65532
              runAsNonRoot: true
              seccompProfile:
                type: RuntimeDefault
          serviceAccountName: $(tt.params.pipelineSA)
        workspaces:
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                configuration.names: harbor-cli-config
                connector.name: $HARBOR_ADMIN
            name: harbor-admin
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                connector.name: $NEXUS_ADMIN
            name: nexus-admin
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                configuration.names: gitlabconfig
                connector.name: $GITLAB_ADMIN
            name: gitlab-admin
          - csi:
              driver: connectors-csi
              readOnly: true
              volumeAttributes:
                configuration.names: sonar-scanner
                connector.name: $SONARQUBE_ADMIN
            name: sonar-admin
          # Option A — kubeconfig Secret (matches step 1 Option A)
          - name: target-kubeconfig
            secret:
              secretName: target-kubeconfig-$CLUSTER_NAME
          # Option B — Kubernetes Connector (matches step 1 Option B)
          # Replace the entry above with the block below when using a
          # Kubernetes Connector instead of a plain kubeconfig Secret:
          #
          # - name: target-kubeconfig
          #   csi:
          #     driver: connectors-csi
          #     readOnly: true
          #     volumeAttributes:
          #       connector.name: <k8s-connector-name>
EOF

步骤 3 — 创建 EventListener

根据网络设置选择 NodePort 或 Ingress。EventListener RBAC(autocreate-el-sa)是共享的——如果尚未完成,请从单集群安装的步骤 3 中应用一次。

选项 A — NodePort

直接在 EventListener 对象上设置 serviceType: NodePort。修补 生成的 Service 不会生效,因为 controller 会将其重置。

cat <<'EOF' | envsubst | kubectl apply -f -
apiVersion: triggers.tekton.dev/v1beta1
kind: EventListener
metadata:
  name: autocreate-el-$CLUSTER_NAME
  namespace: $TARGET_NS
spec:
  serviceAccountName: autocreate-el-sa
  resources:
    kubernetesResource:
      serviceType: NodePort
  triggers:
    - name: autocreate-trigger-$CLUSTER_NAME
      interceptors:
        - ref:
            kind: ClusterInterceptor
            name: cel
          params:
            - name: filter
              value: >-
                (header.match('ce-type', 'dev.knative.apiserver.resource.add') ||
                 header.match('ce-type', 'dev.knative.apiserver.resource.update')) &&
                has(body.metadata.labels) &&
                body.metadata.labels['cpaas.io/project'] != ''
            - name: overlays
              value:
                - expression: body.metadata.labels['cpaas.io/project']
                  key: project
      bindings:
        - kind: TriggerBinding
          ref: autocreate-binding-$CLUSTER_NAME
      template:
        ref: autocreate-template-$CLUSTER_NAME
EOF

查询已分配的 NodePort——步骤 4 中会将其用作 K_SINK:

kubectl get svc el-autocreate-el-${CLUSTER_NAME} -n "$TARGET_NS" \
  -o jsonpath='{.spec.ports[0].nodePort}'

选项 B — Ingress

如果 NodePort 不可用,请使用 ClusterIP(默认值),并通过 Ingress 暴露 EventListener:

cat <<'EOF' | envsubst | kubectl apply -f -
apiVersion: triggers.tekton.dev/v1beta1
kind: EventListener
metadata:
  name: autocreate-el-$CLUSTER_NAME
  namespace: $TARGET_NS
spec:
  serviceAccountName: autocreate-el-sa
  resources:
    kubernetesResource:
      serviceType: ClusterIP
  triggers:
    - name: autocreate-trigger-$CLUSTER_NAME
      interceptors:
        - ref:
            kind: ClusterInterceptor
            name: cel
          params:
            - name: filter
              value: >-
                (header.match('ce-type', 'dev.knative.apiserver.resource.add') ||
                 header.match('ce-type', 'dev.knative.apiserver.resource.update')) &&
                has(body.metadata.labels) &&
                body.metadata.labels['cpaas.io/project'] != ''
            - name: overlays
              value:
                - expression: body.metadata.labels['cpaas.io/project']
                  key: project
      bindings:
        - kind: TriggerBinding
          ref: autocreate-binding-$CLUSTER_NAME
      template:
        ref: autocreate-template-$CLUSTER_NAME
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: autocreate-el-$CLUSTER_NAME
  namespace: $TARGET_NS
spec:
  rules:
    - host: autocreate-el-$CLUSTER_NAME.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: el-autocreate-el-$CLUSTER_NAME
                port:
                  number: 8080
EOF

在步骤 4 中将 http://autocreate-el-$CLUSTER_NAME.example.com 用作 K_SINK。

步骤 4 — 在业务集群上部署 adapter

切换到业务集群的 kubeconfig,然后部署命名空间 watcher adapter,并将 K_SINK 指向管理集群中的 EventListener:

# NodePort
export MGMT_NODE_IP=<management-cluster-node-ip>
export EL_NODE_PORT=<nodeport-from-step-3>
export K_SINK=http://$MGMT_NODE_IP:$EL_NODE_PORT

# Ingress (use instead of the two lines above)
# export K_SINK=http://autocreate-el-$CLUSTER_NAME.example.com

cat <<'EOF' | envsubst '$TARGET_NS $REGISTRY $K_SINK' | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  name: ns-event-source
  namespace: $TARGET_NS
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: ns-event-source
rules:
  - apiGroups: [""]
    resources: ["namespaces"]
    verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ns-event-source
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: ns-event-source
subjects:
  - kind: ServiceAccount
    name: ns-event-source
    namespace: $TARGET_NS
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ns-event-source
  namespace: $TARGET_NS
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ns-event-source
  template:
    metadata:
      labels:
        app: ns-event-source
    spec:
      serviceAccountName: ns-event-source
      enableServiceLinks: false
      containers:
        - name: receive-adapter
          image: ${REGISTRY}/alauda-connectors/connectors-extensions/apiserver-receive-adapter:v1.22.0-alauda.3
          resources:
            requests:
              cpu: 100m
              memory: 100Mi
            limits:
              cpu: 200m
              memory: 200Mi
          env:
            - name: K_SINK
              value: $K_SINK
            - name: K_SOURCE_CONFIG
              value: '{"allNamespaces":true,"resources":[{"gvr":{"Group":"","Version":"v1","Resource":"namespaces"},"selector":"cpaas.io/project"}],"mode":"Resource"}'
            - name: NAME
              value: ns-event-source
          securityContext:
            allowPrivilegeEscalation: false
            capabilities:
              drop: ["ALL"]
            runAsNonRoot: true
            seccompProfile:
              type: RuntimeDefault
EOF

为每个其他业务集群重复步骤 1–4,每次使用不同的 CLUSTER_NAME。


配置参考

调整要创建的 connector

默认情况下,TriggerTemplate 会启用全部四种 connector。要禁用其中一种,请编辑 TriggerTemplate,将对应的 enable* 参数设置为 "false",然后移除匹配的 workspace 条目:

Connector将此参数设置为以禁用要移除的 Workspace
HarborenableHarbor: "false"harbor-admin
NexusenableNexus: "false"nexus-admin
GitLabenableGitLab: "false"gitlab-admin
SonarQubeenableSonarQube: "false"sonar-admin

Pipeline 参数

以下参数可用于 connector-auto-create Pipeline。 在 TriggerTemplate 的 resourcetemplates[].spec.params 部分覆盖这些参数,即可更改行为,而无需修改 Pipeline 本身。

参数默认值描述
enableHarbor"true"协调项目 Harbor Connector 和镜像拉取凭证
bindImagePullSecretToSA"true"将生成的 Harbor 镜像拉取 Secret 绑定到 service account
serviceAccountName"default"接收 Harbor 镜像拉取 Secret 的 ServiceAccount
harborAdmin必需Harbor 管理员 Connector 名称
nexusAdmin必需Nexus 管理员 Connector 名称
gitlabAdmin必需GitLab 管理员 Connector 名称
sonarqubeAdmin必需SonarQube 管理员 Connector 名称
enableNexus"false"协调项目 Nexus Connector
enableGitLab"false"协调项目 GitLab Connector
enableSonarQube"false"协调项目 SonarQube Connector
tokenDurationDays"30"GitLab 和 SonarQube 令牌的有效期(天)
gitlabParentGroup""GitLab 父组路径;启用 GitLab 时必需
sonarPatternPrefix""SonarQube 权限模板项目密钥模式的正则前缀
sonarPatternSuffix""SonarQube 权限模板项目密钥模式的正则后缀
nexusUrl""Nexus URL 覆盖值;为空时从 nexus-admin Connector 解析
gitlabUrl""GitLab URL 覆盖值;为空时从 gitlab-admin Connector 解析
lockDurationSeconds"300"项目协调锁过期前的秒数
lockWaitSeconds"600"等待其他运行释放锁的最大秒数

通过 TriggerTemplate 更改默认值

要永久更改所有未来 PipelineRun 的默认值,请编辑 autocreate-template(或 autocreate-template-$CLUSTER_NAME)TriggerTemplate:

kubectl edit triggertemplate autocreate-template -n "$TARGET_NS"

找到 spec.resourcetemplates[].spec.params 列表并更新相关 值。例如,要将 tokenDurationDays 更改为 60:

- name: tokenDurationDays
  value: "60"

通过 Pipeline 更改默认值

或者,直接编辑 connector-auto-create Pipeline,以更改其参数的 default 值。这会影响引用该 Pipeline 的每个 TriggerTemplate:

kubectl edit pipeline connector-auto-create -n "$TARGET_NS"

找到 spec.params 下的匹配条目,并更新其 default 字段。

工作原理

安装完成后,每当创建或更新 ACP 项目命名空间时,系统都会自动运行。

触发流程

  1. 在受监控集群上创建或更新带有 cpaas.io/project: <project-name> 标签的命名空间。
  2. ns-event-source adapter 检测到该事件,并向 EventListener POST 一个 CloudEvent。
  3. CEL interceptor 筛选带有 cpaas.io/project 标签的命名空间事件,并提取项目名称。
  4. TriggerTemplate 为 connector-auto-create Pipeline 创建一个 PipelineRun,并将命名空间名称和项目名称作为参数传递。
  5. Pipeline 协调项目的 Connectors — Harbor、Nexus、GitLab 和 SonarQube — 如果这些 Connector 不存在或不处于 Ready 状态,则创建它们。

创建的内容

对于每个项目,Pipeline 会在项目的内部命名空间(cpaas.io/project-inner-namespace)中为每个已启用的工具创建一个 Connector:

Connector资源名称在所提供的 TriggerTemplate 中启用Pipeline 默认值
Harbor<project>-harbor是"true"
Nexus<project>-nexus是¹"false"
GitLab<project>-gitlab是¹"false"
SonarQube<project>-sonarqube是¹"false"

¹ 本文档中的 TriggerTemplate 显式将 Pipeline 默认值覆盖为 "true"。 要禁用某个 Connector,请在 TriggerTemplate 中将相应的 enable* 参数设置为 "false"(请参阅配置参考)。

Pipeline 具有幂等性:如果 Connector 已存在、处于 Ready 状态,并且具有正确的地址和凭证,则协调任务会跳过它。项目级 Lease 锁可防止同一项目上的并发 PipelineRun 互相竞争。

调整特定于 Connector 的参数

每个任务都会公开其他参数,以便对其管理的 Connector 进行精细控制 — 例如,要包含哪些 Harbor 项目、要预配哪些 Nexus 仓库,或使用哪个 GitLab 父组路径。 在 TriggerTemplate 的 resourcetemplates[].spec.params 部分中添加或覆盖这些参数。

有关每个任务可用参数的完整列表,请参阅:

凭证轮换

connector-auto-create Pipeline 会创建项目凭证,但不会按计划轮换这些凭证。Nexus、GitLab 和 SonarQube 任务仅在项目 Connector 缺失、未处于 Ready 状态,或与预期的地址和 Secret 不匹配时运行。每次 PipelineRun 中,Harbor 任务都会在 enableHarbor 为 "true" 时运行,但 Pipeline 会设置 robotTokenPolicy: reuse,因此,只要 Harbor 项目集合未发生变化,且能从 Connector Secret 中读取有效令牌,就会保留现有 robot 令牌;否则,该运行会生成新令牌(请参阅表格下方的注释)。

每个工具的自动创建 Task 会在运行成功时轮换凭证(对于 Harbor,请参阅表格下方的注释),因此轮换间隔就是你自行运行该 Task 的间隔,例如通过 CronJob 运行。轮换因此取决于成功且不重叠的运行:SonarQube Connector 自动创建任务指南会在每次成功运行时轮换令牌(该 Task 自身的 tokenDuration 参数说明也表示,它会在每次运行时撤销并重新生成令牌),并警告同一租户的重叠运行会使较早运行所写入的令牌失效;GitLab Connector 自动创建任务指南则会在轮换 TaskRun 失败时发出警报。不要并发运行同一租户的 Task,监控失败的 TaskRun,并在当前凭证过期前重试失败的运行。请根据以下规则选择间隔:

  • 具有有效期的凭证:将连续运行的间隔设置为短于有效期减去安全裕量,以便在旧凭证过期前配置好新凭证。例如,对于有效期为 30 天的令牌,应每周运行一次 Task。
  • 永不过期的凭证:按照安全策略要求的间隔定期轮换。
工具凭证默认有效期参数
GitLab组访问令牌30 天,受 GitLab 实例策略限制此 Pipeline 中的 tokenDurationDays;Task 上的 tokenDuration
SonarQube用户令牌30 天此 Pipeline 中的 tokenDurationDays;Task 上的 tokenDuration
Harborrobot 账户永不过期("-1")Task 上的 robotAccountDuration;此 Pipeline 不设置该参数
Nexus有范围的用户密码Task 不设置;每次成功运行都会替换密码无

对于 Harbor,运行会使用 robotTokenPolicy: refresh 轮换令牌,这是 Task 的默认值。使用 reuse 时,如果无法从 Connector Secret 中读取有效的已存储令牌,运行仍会生成新令牌,因为此时 Task 会回退到 refresh;无论 robotTokenPolicy 如何设置,只要 Harbor 项目集合发生变化,就会始终重新创建 robot 账户并生成新令牌。获得新令牌后,请更新你自行分发的旧令牌副本;当运行生成新令牌时,Task 结果 robot-token-rotated 为 true。轮换令牌不会延长 robot 账户的过期时间。若要为 robot 账户设置有限的有效期,请在周期性运行所传递的参数中设置一个正数 robotAccountDuration,也就是将该参数添加到此 Pipeline 的 harbor-connector-automatic-creation task 中。仅在单独运行 Task 时设置的时长会持续到下一次此 Pipeline 运行;该 Pipeline 运行 Task 时不带此参数,因此会应用 Task 默认值 "-1",并将 robot 账户原地更新为再次永不过期。

有关如何单独运行每个 Task,请参阅上面列出的 Task 指南。

检查 Pipeline 运行结果

要查看为项目触发的 PipelineRun:

kubectl get pipelineruns -n "$TARGET_NS" \
  -l autocreate.connectors.alauda.io/project=<project-name>

要检查在项目内部命名空间中创建的 Connector:

kubectl get connectors -n <inner-namespace>