Die erweiterte Nutzung von Pipeline-YAML ist da! Reduzieren Sie doppelten Code erheblich und organisieren Sie Multitasks flexibel

Das Open-Source-Community-Team China machte seine erste Live-Übertragung und erzählte im Namen des Teilens die Geschichte hinter der Open-Source-Community China.“

Autor: Mu Yan

Treten bei der Konfiguration der YAML-Pipeline die folgenden Probleme auf?

Wenn ähnliche Aufgabenszenarien stapelweise in einer einzelnen Pipeline ausgeführt werden, müssen mehrere Jobs mit ähnlicher Logik in YAML definiert werden. Je mehr Jobs vorhanden sind, desto länger ist die Pipeline-YAML-Konfiguration, desto mehr wiederholter Code in YAML ist die Code-Wiederverwendbarkeit ist niedrig und die Lesbarkeit ist schlecht;
Administratoren verwalten mehrere Pipelines auf einheitliche Weise. Die Architektur mit mehreren Anwendungen ähnelt dem F&E-Prozess. Wenn nur wenige Konstruktions- und Bereitstellungsparameter inkonsistent sind, muss jede Pipeline die differenzierten Parameter unabhängig ändern, was zu hohen Konfigurationskosten führt Jede Pipeline ist unabhängig konfiguriert, eine einheitliche Verwaltung und Kontrolle ist nicht möglich und die Wartbarkeit ist schlecht.
Die Pipeline-YAML ist eine statische Datei und die Aufgabenausführungslogik wird beim Speichern der Pipeline festgelegt. Der Pipeline-Ausführungsprozess einiger F&E-Szenarien muss jedoch zur Laufzeit geklärt werden und kann nicht im Voraus konfiguriert werden. Gewöhnliches Pipeline-YAML kann dieses Szenario nicht erfüllen.

In diesem Zusammenhang führt Yunxiao Flow Pipeline YAML eine Vorlagensyntax ein, die die Verwendung von Vorlagensprachen zum dynamischen Rendern von Pipeline YAML unterstützt, die die Stapelkonfigurationsszenarien mehrerer Jobs mit derselben oder ähnlicher Logik erfüllen und die dynamische Generierung erfüllen können Szenarios mit mehreren Jobs auf Abruf und helfen, die Duplizierung von Pipeline-YAML-Code zu reduzieren und Multitasking flexibel zu orchestrieren.

Was ist Vorlagensyntax?

Vorlage ist eine Vorlagensprache, die zum Definieren und Rendern von Text verwendet wird. Sie kann mit Variablen, bedingten Anweisungen, Schleifenstrukturen usw. kombiniert werden, sodass YAML-Dateien basierend auf Kontext oder externen Datenquellen vielfältige Konfigurationsausgaben generieren können zur Laufzeit. .

Die Cloud Effect Pipeline führt die Template-Engine ein und template=truegibt den Template-Modus über die erste Zeile der YAML-Kommentare in der Pipeline an. Sie unterstützt die Verwendung der {{ }}definierten Template-Sprache und folgt go templateder nativen Syntax. Sie unterstützt die Verwendung von variablesVariablen, die als Parameter für definiert sind Rendering-Pipeline. Typische anwendbare Szenarien sind wie folgt.

Kernverwendungsszenarien der Vorlagensyntax

Szenario 1: Kompatibilitätstestszenario mit mehreren Betriebssystemen und mehreren SDK-Versionen

Wenn Sie in einigen Kompatibilitätstestszenarien Ihren Code auf n verschiedenen Betriebssystemen und m verschiedenen SDK-Versionen testen müssen, müssen Sie n * m Jobs in Ihrer Pipeline definieren. Die Ausführungslogik jedes Jobs ist tatsächlich dieselbe. Wenn in diesem Szenario viele Szenarien Kompatibilitätstests erfordern, ist die Pipeline-YAML sehr lang und enthält viele wiederholte Codes, was die Wartung erschwert. Wenn die Jobausführungslogik geändert wird, muss sie geändert werden n*m mal.

Nachdem die Vorlagensyntax eingeführt wurde, können Kompatibilitätsszenarien in Variablen extrahiert werden, und die Bereichssyntax kann zum Durchlaufen der Szenarien und zum Generieren mehrerer Jobs in Stapeln verwendet werden, wodurch die Menge an YAML-Code erheblich reduziert wird, wenn die Jobausführungslogik geändert wird. Es ist nur eine Änderung erforderlich.

Im folgenden Code durchlaufen wir beispielsweise zwei Betriebssysteme [„Linux“, „Windows“] und drei JDK-Versionen [„10“, „11“, „17“] und verwenden dabei die Bereichsschleife der Vorlage Praktischerweise werden 6 Jobs mit der gleichen Logik generiert.

# template=true
variables:
  - key: osList
    type: Object
    value: ["linux", "windows"]
  - key: jdkVersionList
    type: Object
    value: ["10", "11", "17"]

stages:
  build_stage:
    name: 兼容性测试
    jobs:                             # 双层循环，生成 2*3 个Job
      {{ range $os := .osList}}
        {{ range $jdk := $.jdkVersionList}}
        {{ $os }}_JDK{{ $jdk }}_job:
                   name: 测试-{{ $os }}-JDK{{ $jdk }}
                   my_step:
                     name: 执行命令
                     step: Command
                     with:
                       run: |
                         echo 'test on {{ $os }}-JDK{{ $jdk }}"
        {{ end }}
        {{ end }}

Der laufende Effekt der Pipeline ist wie folgt:

Szenario 2: Dynamisches Erstellen und Bereitstellen mehrerer Anwendungen nach Bedarf

Im Szenario der gemeinsamen Veröffentlichung mehrerer Anwendungen unter einem System betrifft eine Änderung der Geschäftsanforderungen nur einige Anwendungen unter dem System, und jede Veröffentlichung löst nur die Erstellung und Bereitstellung einiger Anwendungen aus. In diesem Fall kann die Verwendung einer statischen YAML-Dateikonfiguration die dynamische Generierung von Anwendungskonstruktions- und Bereitstellungsjobszenarien nicht erfüllen.

Nachdem die Vorlagensyntax eingeführt wurde, kann die Anwendung in Variablen extrahiert und die Bereichssyntax zum Durchlaufen der Konfiguration verwendet werden. Entsprechend der Anwendungslisteneingabe während der Pipeline-Laufzeit können mehrere Anwendungskonstruktions- und Bereitstellungsaufgaben dynamisch generiert werden Nachfrage.

Wie im folgenden Beispiel gezeigt, haben wir mehrere Anwendungscodequellen, mehrere Anwendungserstellungsaufgaben und mehrere Anwendungsbereitstellungsaufgaben entsprechend der Anwendung konfiguriert. Basierend auf den App-Namen der Laufzeiteingabeumgebungsvariablen können mehrere Anwendungen dynamisch für die Bereitstellung bestimmt werden.

# template=true
variables:
  - key: appnames
    type: Object
    value: ["app1", "app2", "app3"]

sources:
  {{ range $app := .appnames }}
  repo_{{ $app }}:
    type: codeup
    name: 代码源名称-{{ $app }}
    endpoint: https://yunxiao-test.devops.aliyun.com/codeup/07880db8-fd8d-4769-81e5-04093aaf7b2b/c{{ $app }}.git
    branch: master
    certificate:
      type: serviceConnection
      serviceConnection: wwnbrqpihykbiko4
  {{ end }}

defaultWorkspace: repo_app1

stages:
  build_stage:
    name: 构建阶段
    jobs:
      {{ range $app := .appnames }}
      build_job_{{ $app }}:
        name: 构建任务-{{ $app }}
        sourceOption: ['repo_{{ $app }}']
        steps:
          build_{{ $app }}:
            step: Command
            name: 构建-{{ $app }}
            with:
              run: "echo start build {{ $app }}\n"
      {{ end }}
  deploy_stage:
    name: 部署阶段
    jobs:
      {{ range $app := .appnames }}
      deploy_job_{{ $app }}:
        name: 部署任务-{{ $app }}
        needs: build_stage.build_job_{{ $app }}
        steps:
          build_{{ $app }}:
            step: Command
            name: 部署-{{ $app }}
            with:
              run: "echo start deploy {{ $app }}\n"
      {{ end }}

Der laufende Effekt der Pipeline ist wie folgt:

So verwenden Sie die Vorlagensyntax in Yunxiao

1) Rufen Sie die YAML-Bearbeitungsseite der Pipeline auf und wechseln Sie in den Vorlagenmodus, indem Sie in der ersten Zeile #template=true kommentieren.

2) Nach dem Wechsel in den Vorlagenmodus wird die Pipeline zur Definition der Vorlagensprache {{ }} unterstützt.

Verwenden Sie durch Variablen definierte Umgebungsvariablen als Rendering-Parameter: Verwenden Sie durch Variablen definierte Umgebungsvariablen als Vorlagen-Rendering-Parameter und unterstützen Sie mehrere Umgebungsvariablentypen wie String, Number, Boolean und Object. Unterstützt das Überschreiben von Umgebungsvariablen mit demselben Namen zur Laufzeit.
Befolgen Sie die native Go-Vorlagensyntax: Der Yunxiao Flow-Pipeline-Vorlagenmodus folgt der nativen Go-Vorlagensyntax. Weitere Informationen finden Sie unter: https://pkg.go.dev/text/template. Die häufig verwendete Syntax lautet wie folgt:

{{/* a comment */}}  // 注释
{{pipeline}}         // 引用
{{if pipeline}} T1 {{end}}   // 条件判断
{{if pipeline}} T1 {{else}} T0 {{end}}
{{if pipeline}} T1 {{else if pipeline}} T0 {{end}}
{{range pipeline}} T1 {{end}}          // 循环
{{range pipeline}} T1 {{else}} T0 {{end}}
{{break}}
{{continue}}

Darüber hinaus unterstützt die Syntax der Yunxiao Flow-Pipeline-Vorlage die folgenden Erweiterungsfunktionen, um flexiblere Orchestrierungsszenarien zu ermöglichen.

# add：整数相加函数，参数接收两个及两个以上 Integer
{{ add 1 2 }} // 示例返回：3
{{ add 1 2 2 }} // 示例返回：5

# addf：浮点数相加函数，参数接收两个及两个以上 Number
{{ add 1.2 2.3 }} // 示例返回：3.5
{{ add 1.2 2.3 5 }} // 示例返回：8.5

# replace：字符串替换函数，接收三个参数：源字符串、待替换字符串、替换为字符串
{{ "Hallo World" | replace "a" "e" }}  // 示例返回：Hello World
{{ "I Am Henry VIII" | replace " " "-" }}  // 示例返回：I-Am-Henry-VIII

3) Konfigurieren Sie Umgebungsvariablen, wenn die Pipeline ausgeführt wird, die zum dynamischen Rendern von YAML verwendet werden, bevor die Pipeline ausgeführt wird.

4) Klicken Sie auf „Vorschaumodus“, um die Verwendung von Variablen für das Vorrendering zu unterstützen und zu überprüfen, ob die Pipeline den Erwartungen entspricht.

5) Nachdem Sie die Richtigkeit bestätigt haben, speichern Sie die Pipeline und lösen Sie sie aus. Sie können Laufzeitvariablen nach Bedarf ändern, Pipeline-YAML basierend auf Laufzeitumgebungsvariablen dynamisch rendern und Jobs dynamisch generieren. Wenn die JDK-Version auf [„17“, „21“] geändert wird und das Betriebssystem [„linux“, „windows“] bleibt, werden 4 Jobs dynamisch generiert.

Klicken Sie hier , um Cloud Effect Pipeline Flow kostenlos zu nutzen oder mehr zu erfahren.