TOC

Einrichten von Continuous Integration Pipelines mit Concourse CI unter Ubuntu 16.04

Einführung

Concourse CI ist ein modernes, skalierbares kontinuierliches Integrationssystem, mit dem das Testen von Pipelines mit einer zusammensetzbaren deklarativen Syntax automatisiert werden kann. In früheren Handbüchern haben wir https://www.digitalocean.com/community/tutorials/how-to-install-concourse-ci-on-ubuntu-16-04 Concourse auf einem Ubuntu 16.04-Server installiert] und https: // www.digitalocean.com/community/tutorials/how-to-secure-concourse-ci-with-ssl-using-nginx-on-ubuntu-16-04 hat die Web-Benutzeroberfläche mit einem SSL-Zertifikat von Let’s Encrypt gesichert.

In diesem Handbuch wird gezeigt, wie Sie Concourse verwenden, um die Testsuite Ihres Projekts automatisch auszuführen, wenn neue Änderungen in das Repository übernommen werden. Zur Veranschaulichung konfigurieren wir eine kontinuierliche Integrationspipeline für eine "Hallo Welt" -Anwendung, die mit Hapi.js, einem Node.js-Webframework, geschrieben wurde.

Um sicherzustellen, dass die Erstellungs- und Testprozeduren immer mit dem Code synchronisiert sind, mit dem sie verknüpft sind, fügen wir die CI-Definitionen dem Anwendungsrepository selbst hinzu. Anschließend laden wir die Pipeline mit dem Concourse-Kommandozeilen-Tool "+ fly +" in Concourse. Schließlich werden wir unsere Änderungen zurück in das Repository übertragen, um sie dauerhafter zu speichern und einen neuen Test im neuen CI-Workflow zu starten.

Voraussetzungen

Bevor Sie beginnen, benötigen Sie einen Ubuntu 16.04-Server * mit mindestens 1 GB RAM *. Befolgen Sie die folgenden Anleitungen, um einen Benutzer ohne Rootberechtigung einzurichten, Concourse zu installieren und zu konfigurieren, Nginx zu installieren, ein TLS / SSL-Zertifikat zu erhalten und einen sicheren Reverse-Proxy für die Concourse-Webbenutzeroberfläche einzurichten. Sie benötigen einen * Domainnamen *, der auf Ihren Concourse-Server verweist, um ihn ordnungsgemäß zu sichern:

In diesem Lernprogramm werden die meisten Arbeiten auf Ihrem lokalen Computer und nicht auf dem Concourse-Server ausgeführt. Aus diesem Grund müssen Sie auch sicherstellen, dass einige Tools auf Ihrem lokalen Computer verfügbar sind. Sie benötigen einen Texteditor (einige Beispiele, die Sie unter verschiedenen Betriebssystemen finden können, sind "+ nano ", " vim +", "TextEdit", "Sublime Text", "Atom" oder "Notepad"), um Dateien im Repository zu erstellen und zu ändern. Sie müssen Git auch auf Ihrem lokalen System installieren und einrichten. Dies können Sie unter https://www.digitalocean.com/community/tutorials/contributing-to-open-source-getting-started-with- tun. Handbuch zu git [Beitrag zu Open Source: Erste Schritte mit Git].

Wenn Sie Ihren Concourse-Server eingerichtet und Git und einen Texteditor auf Ihrem lokalen Computer installiert haben, fahren Sie unten fort.

Das Fly Command Line Tool lokal installieren

Als wir Concourse unter den Voraussetzungen auf dem Server installiert haben, haben wir das Befehlszeilentool "+ fly " auf dem Server installiert, damit wir die Concourse-Instanz von der Befehlszeile aus verwalten können. Für den täglichen Gebrauch ist es jedoch bequemer, eine Kopie der ` fly +` - Binärdatei auf Ihrem lokalen System zu installieren, auf dem Ihre üblichen Entwicklungstools und der Quellcode verfügbar sind.

Um eine lokale Kopie von "+ fly +" zu erhalten, die Ihrer Serverversion entspricht, besuchen Sie Ihre Concourse-Instanz in Ihrem Webbrowser:

https://

Wenn Sie abgemeldet sind oder keine Pipeline konfiguriert ist, werden in der Mitte des Fensters Links zum Herunterladen von "+ fly +" für verschiedene Plattformen angezeigt:

Bild: https://assets.digitalocean.com/articles/concourse_usage_1604/big_download_link.png [Concourse fly big download link]

Wenn Sie angemeldet sind und eine Pipeline konfiguriert haben, stehen in der unteren rechten Ecke des Bildschirms Download-Links für "+ fly +" zur Verfügung:

image: https: //assets.digitalocean.com/articles/concourse_usage_1604/small_download_link.png [Concourse fly small download link]

Klicken Sie auf das Symbol für das Betriebssystem Ihres lokalen Computers, um die + fly + - Binärdatei herunterzuladen.

Folgen Sie dann den plattformspezifischen Anweisungen, um "+ fly +" auf Ihrem lokalen System einzurichten.

Linux oder macOS

Wenn auf Ihrem lokalen Computer Linux oder macOS ausgeführt wird, befolgen Sie diese Anweisungen, nachdem Sie die entsprechende Binärdatei heruntergeladen haben.

Markieren Sie zuerst die heruntergeladene Binärdatei als ausführbar. Wir gehen davon aus, dass Sie die Datei in Ihr "+ ~ / Downloads +" -Verzeichnis heruntergeladen haben. Passen Sie daher gegebenenfalls den Download-Speicherort an:

chmod +x ~/Downloads/fly

Installieren Sie als Nächstes die Binärdatei an einem Speicherort in Ihrem PATH, indem Sie Folgendes eingeben:

sudo install ~/Downloads/fly /usr/local/bin

Sie können überprüfen, ob die ausführbare Datei verfügbar ist, indem Sie Folgendes eingeben:

fly --version
Output3.3.1

Wenn Sie die Version anzeigen können, wurde + fly + erfolgreich installiert.

Windows

Wenn auf Ihrem lokalen Computer Windows ausgeführt wird, drücken Sie die * Windows-Taste * auf Ihrer Tastatur, geben Sie * Powershell * ein und drücken Sie * EINGABE *.

Erstellen Sie im angezeigten Fenster einen Ordner "+ bin +", indem Sie Folgendes eingeben:

mkdir bin

Verschieben Sie als Nächstes die Datei + fly.exe + aus Ihrem Ordner + Downloads + in den neuen Ordner + bin +, indem Sie Folgendes eingeben:

mv Downloads/fly.exe bin

Überprüfen Sie, ob bereits ein PowerShell-Profil verfügbar ist:

Test-Path $profile

Wenn die Antwort "+ True +" ist, haben Sie bereits ein Profil.

Wenn die Antwort "+ False +" ist, müssen Sie eine erstellen, indem Sie Folgendes eingeben:

New-Item -path $profile -type file -force
Output
   Directory: C:\User\Sammy\Documents\WindowsPowerShell

Mode              LastWriteTime       Length Name
----              -------------       ------ ----
-a----       7/9/2017   5:46 PM            0 Microsoft.PowerShell_profile.ps1

Sobald Sie ein Profil haben, bearbeiten Sie es mit Ihrem Editor:

notepad.exe $profile

Fügen Sie im Editorfenster (das leer ist, wenn Sie Ihr Profil erstellen mussten) die folgende Zeile hinzu:

Microsoft.PowerShell_profile.ps1

$env:path += ";C:\Users\Sammy\bin"

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Legen Sie als Nächstes die Ausführungsrichtlinie für den aktuellen Benutzer auf "RemoteSigned" fest, damit PowerShell das Profil lesen kann:

Set-ExecutionPolicy -scope CurrentUser RemoteSigned

Geben Sie als letztes das PowerShell-Profil ein:

. $profile

Sie sollten nun in der Lage sein, die ausführbare Datei "+ fly.exe +" von jedem Ort aus aufzurufen. Testen Sie dies, indem Sie die Binärdatei ihre Version drucken lassen:

fly.exe --version
Output3.3.1

In diesem Handbuch müssen Sie jede Instanz des Befehls "+ fly " durch " fly.exe +" ersetzen, damit sie mit dem Windows-Befehl übereinstimmt.

Authentifizierung beim Concourse Server

Melden Sie sich nach der Installation von "+ fly " bei Ihrem Remote-Concourse-Server an, damit Sie Ihre CI-Umgebung lokal verwalten können. Eine einzelne " fly +" - Binärdatei kann verwendet werden, um mehrere Concourse-Server zu kontaktieren und zu verwalten. Der Befehl verwendet daher das Konzept "Ziele" als Bezeichnung, um den Server zu identifizieren, an den Sie Befehle senden möchten.

Wir verwenden in diesem Handbuch * main * als Zielnamen für unseren Concourse-Server, Sie können jedoch jeden gewünschten Zielnamen ersetzen. Geben Sie den Domänennamen Ihres Concourse-Servers zusammen mit der Protokollspezifikation "+ https: // " nach der Option " -c +" ein, um Ihren Serverstandort anzugeben:

fly -t main login -c https://

Sie werden aufgefordert, den Benutzernamen und das Kennwort einzugeben, die Sie in der Datei "+ / etc / concourse / web_environment +" auf dem Concourse-Server konfiguriert haben:

Outputlogging in to team 'main'

username: sammy
password:

target saved

Nach der Authentifizierung erstellt das Tool "+ fly " eine Konfigurationsdatei mit dem Namen " ~ / .flyrc +", in der Ihre Anmeldeinformationen für zukünftige Befehle gespeichert werden.

Forking und Klonen des Beispiel-Repository

Nachdem Sie "+ fly +" auf Ihrem System eingerichtet haben, können wir mit dem Einrichten des Repository fortfahren, das wir zur Demonstration von Concourse-Pipelines verwenden werden.

Besuchen Sie in Ihrem Webbrowser die Anwendung ´hello hapi´ auf GitHub, die wir als unser Beispiel verwenden werden. Diese Anwendung ist ein einfaches "Hallo Welt" -Programm mit einigen Unit- und Integrationstests, die mit Hapi.js, einem Node.js-Webframework, geschrieben wurden.

Da dieses Beispiel zur Veranschaulichung einer Vielzahl von Continuous Integration-Systemen verwendet wird, stellen Sie möglicherweise fest, dass einige Dateien zum Definieren von Pipelines für andere Systeme verwendet werden. Für Concourse erstellen wir die kontinuierliche Integrationspipeline in unserer eigenen Verzweigung des Repositorys.

Melden Sie sich bei GitHub an und navigieren Sie zum project repository, um Ihren Fork des Repository zu erstellen. Klicken Sie oben rechts auf die Schaltfläche * Fork *, um eine Kopie des Repositorys in Ihrem Konto zu erstellen:

image: https://assets.digitalocean.com/articles/concourse_usage_1604/fork_repository.png [Hallo Hapi-Gabel-Repository]

Wenn Sie Mitglied einer GitHub-Organisation sind, werden Sie möglicherweise gefragt, wo Sie das Repository aufteilen möchten. Sobald Sie ein Konto oder eine Organisation ausgewählt haben, wird Ihrem Konto eine Kopie des Repository hinzugefügt.

Wechseln Sie anschließend in einem Terminal auf Ihrem lokalen Computer in Ihr Ausgangsverzeichnis:

cd $HOME

Klonen Sie das Repository mit dem folgenden Befehl auf Ihren lokalen Computer und ersetzen Sie Ihren eigenen GitHub-Benutzernamen:

git clone [email protected]:/hello_hapi

Ein neues Verzeichnis mit dem Namen "+ hello_hapi +" wird in Ihrem Home-Verzeichnis erstellt. Geben Sie das neue Verzeichnis ein, um zu beginnen:

cd hello_hapi

Wir werden eine kontinuierliche Integrationspipeline für das Beispielprojekt in diesem Repository definieren. Bevor Sie Änderungen vornehmen, empfiehlt es sich, einen neuen Zweig in Git zu erstellen und zu wechseln, um unsere Änderungen zu isolieren:

git checkout -b pipeline
OutputSwitched to a new branch 'pipeline'

Jetzt, da wir eine neue Niederlassung haben, können wir beginnen, unsere kontinuierliche Integrationspipeline zu definieren.

Festlegen des kontinuierlichen Integrationsprozesses für die Anwendung

Wir werden unsere Pipeline und alle zugehörigen Dateien im Projekt-Repository selbst definieren. Auf diese Weise wird sichergestellt, dass die kontinuierlichen Integrationsprozesse immer mit dem zu testenden Code synchron bleiben.

Die Testsuite ist bereits in einem Verzeichnis mit dem Namen "+ test " definiert. Es umfasst einen Komponententest und zwei grundlegende Integrationstests. Der Befehl zum Ausführen der Tests ist in der Datei " package.json" unter dem Namen "+ test" im Objekt "+ script" definiert. In einer Umgebung mit "+ npm " und "Node.js" können Sie die Tests ausführen, indem Sie " npm test " eingeben (nachdem Sie die Projektabhängigkeiten mit " npm install +" installiert haben). Dies sind die Verfahren, die wir in unserer Pipeline replizieren müssen.

Erstellen Sie zunächst ein Verzeichnis mit dem Namen "+ ci " im Repository, in dem die fortlaufenden Integrationsressourcen für das Projekt gespeichert werden. Außerdem erstellen wir zwei Unterverzeichnisse mit den Namen " ci / tasks " und " ci / scripts +", um die einzelnen Taskdefinitionen zu speichern, auf die die Pipeline verweist, und die Skripts, die die Tasks aufrufen.

Erstellen Sie die erforderliche Verzeichnisstruktur, indem Sie Folgendes eingeben:

mkdir -p ci/{tasks,scripts}

Als nächstes können wir damit beginnen, die einzelnen Dateien zu erstellen, die Concourse verwenden wird.

Pipeline definieren

Erstellen und öffnen Sie eine Datei mit dem Namen "+ pipeline.yml " im Verzeichnis " ci " mit Ihrem Texteditor (wir zeigen den " nano +" - Editor in diesem Handbuch, Sie sollten jedoch den Texteditor für Ihr System ersetzen). Wie die Erweiterung angibt, werden Concourse-Dateien unter Verwendung des YAML-Datenserialisierungsformats definiert:

nano ci/pipeline.yml

Jetzt können wir mit dem Aufbau unserer Pipeline beginnen.

Definieren Sie den NPM-Cache-Ressourcentyp

In der Datei definieren wir zunächst einen neuen Ressourcentyp:

ci / pipeline.yml

---
resource_types:
 - name: npm-cache
   type: docker-image
   source:
     repository: ymedlop/npm-cache-resource
     tag: latest

Um die Prozesse bei der kontinuierlichen Integration von den Daten zu trennen, die das System durchlaufen, werden in Concourse alle Statusinformationen in Abstraktionen mit der Bezeichnung * resources * abgelegt. Ressourcen sind externe Datenquellen, aus denen Concourse Informationen abrufen oder an die Informationen senden kann. Auf diese Weise gelangen alle Daten in das kontinuierliche Integrationssystem und werden von Jobs gemeinsam genutzt. Concourse bietet keinen Mechanismus zum internen Speichern oder Übergeben von Status zwischen Jobs.

In der Überschrift * resource_types * können Sie neue Arten von Ressourcen definieren, die Sie in Ihrer Pipeline verwenden können, z. B. E-Mail-Benachrichtigungen, Twitter-Integrationen oder RSS-Feeds. Der neue Ressourcentyp, den wir definieren, enthält Informationen zur Verwendung von npm-cache-resource, einer Ressource, die als Docker-Image bereitgestellt wird und Concourse die Installation der Abhängigkeiten von ermöglicht ein Node.js-Projekt und teile sie zwischen Jobs.

Definieren Sie das Repository und die Caching-Ressourcen

Als nächstes müssen wir die tatsächlichen Ressourcen für die Pipeline definieren:

ci / pipeline.yml

. . .

resources:
 - name: hello_hapi
   type: git
   source: &repo-source
     uri: https://github.com//hello_hapi
     branch: master
 - name: dependency-cache
   type: npm-cache
   source:
     <<: *repo-source
     paths:
       - package.json

In diesem Abschnitt werden zwei Ressourcen definiert, die die Concourse-CI-Jobs zum Ausführen ihrer Aufgaben benötigen. Concourse verwendet Ressourcendefinitionen, um vorgelagerte Systeme auf Änderungen zu überwachen und zu verstehen, wie die Ressource abgerufen werden kann, wenn Jobs dies erfordern. Standardmäßig überprüft Concourse jede Ressource einmal pro Minute auf neue Versionen. Jobs, bei denen für die Ressource die Option "Auslöser" festgelegt ist, starten automatisch einen neuen Build, wenn eine neue Version verfügbar ist.

Die erste Ressource repräsentiert Ihren Fork des Repositorys + hello_hapi + auf GitHub. Die "source" -Zeile enthält einen YAML-Anker mit dem Namen "repo-source", der das Element als zukünftige Referenz kennzeichnet. Auf diese Weise können wir den Inhalt des Elements (die Definitionen "uri" und "branch") an einer anderen Stelle später im Dokument einfügen.

Die zweite Ressource namens "Abhängigkeits-Cache" verwendet den von uns definierten Ressourcentyp "npm-Cache", um die Abhängigkeiten des Projekts herunterzuladen. In der "Quell" -Spezifikation dieser Ressource verwenden wir die Zeile "+ <<: * repo-source", um auf die Elemente zu verweisen, auf die der Anker "+ & repo-source " zeigt. Dadurch werden die Einstellungen für uri und branch aus unserer Anwendungsrepository-Ressource in diese zweite Ressource eingefügt. Ein zusätzliches Element mit dem Namen "path" verweist auf die Datei " package.json", in der die Projektabhängigkeiten definiert sind.

Definieren Sie die Aufträge zum Sammeln und Testen von Abhängigkeiten

Schließlich definieren wir die tatsächlichen kontinuierlichen Integrationsprozesse mit Hilfe von Concourse * jobs *:

ci / pipeline.yml

. . .

jobs:
 - name: Install dependencies
   plan:
     - get: hello_hapi
       trigger: true
     - get: dependency-cache
 - name: Run tests
   plan:
     - get: hello_hapi
       trigger: true
       passed: [Install dependencies]
     - get: dependency-cache
       passed: [Install dependencies]
     - task: run the test suite
       file: hello_hapi/ci/tasks/run_tests.yml

In diesem Abschnitt definieren wir zwei Jobs, die jeweils aus einem Namen und einem Plan bestehen. Jeder unserer Pläne enthält wiederum "get" - und "task" -Elemente. Die Elemente * task * geben an, wie eine Aktion ausgeführt werden soll, während die Elemente * get * die Ressourcenabhängigkeiten der Aufgabe angeben.

Der erste Job enthält keine Aufgabenanweisungen. Dies ist etwas ungewöhnlich, aber sinnvoll, wenn wir uns ansehen, was es tut und wie es verwendet werden kann. Die erste get-Anweisung erfordert die Ressource "+ hello_hapi " und gibt die Option " trigger: true " an. Dies weist Concourse an, das Repository automatisch abzurufen und jedes Mal einen neuen Build dieses Jobs zu starten, wenn ein neues Commit im Repository ` hello_hapi +` festgestellt wird.

Die zweite get-Anweisung im ersten Job (+ get: dependency-cache +) erfordert die von uns definierte Ressource, die die Abhängigkeiten von Node.j des Projekts herunterlädt und zwischenspeichert. Diese Anweisung bewertet die Anforderungen in der Datei "+ package.json +" und lädt sie herunter. Wenn für diesen Job keine Aufgaben definiert sind, werden keine weiteren Aktionen ausgeführt, die heruntergeladenen Abhängigkeiten stehen jedoch für nachfolgende Jobs zur Verfügung.

Der zweite Job (+ name: Run tests +) beginnt mit der Deklaration derselben Abhängigkeiten mit einem bemerkenswerten Unterschied. Die Einschränkung „bestanden“ bewirkt, dass die get-Anweisungen nur mit Ressourcen übereinstimmen, die die vorherigen Schritte in der Pipeline erfolgreich durchlaufen haben. Auf diese Weise werden Abhängigkeiten zwischen Jobs gebildet, um Pipelineprozesse miteinander zu verketten.

Nach den get-Anweisungen wird eine Task mit dem Namen "Test-Suite ausführen" definiert. Anstatt die Schritte zu definieren, die inline ausgeführt werden sollen, weist es Concourse an, die Definition aus einer Datei in dem von ihm abgerufenen Repository abzurufen. Wir werden diese Datei als nächstes erstellen.

Wenn Sie fertig sind, sollte die gesamte Pipeline folgendermaßen aussehen:

ci / pipeline.yml

---
resource_types:
 - name: npm-cache
   type: docker-image
   source:
     repository: ymedlop/npm-cache-resource
     tag: latest

resources:
 - name: hello_hapi
   type: git
   source: &repo-source
     uri: https://github.com//hello_hapi
     branch: master
 - name: dependency-cache
   type: npm-cache
   source:
     <<: *repo-source
     paths:
       - package.json

jobs:
 - name: Install dependencies
   plan:
     - get: hello_hapi
       trigger: true
     - get: dependency-cache
 - name: Run tests
   plan:
     - get: hello_hapi
       trigger: true
       passed: [Install dependencies]
     - get: dependency-cache
       passed: [Install dependencies]
     - task: run the test suite
       file: hello_hapi/ci/tasks/run_tests.yml

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Testaufgabe definieren

Während die Pipeline-Definition die Struktur unseres kontinuierlichen Integrationsprozesses umriss, wurde die Definition der eigentlichen Testaufgabe auf eine andere Datei verschoben. Durch das Extrahieren von Aufgaben wird die Pipeline-Definition übersichtlich und übersichtlicher. Sie müssen jedoch mehrere Dateien lesen, um den gesamten Prozess zu verstehen.

Öffnen Sie eine neue Datei im Verzeichnis "+ ci / tasks " mit dem Namen " run_tests.yml +":

nano ci/tasks/run_tests.yml

Um eine Aufgabe zu definieren, müssen Sie den Typ des Betriebssystems angeben, das der Worker haben muss, das Image definieren, das zum Ausführen der Aufgaben verwendet wird, alle Eingaben oder Ausgaben benennen, die die Aufgabe verwenden soll, und den auszuführenden Befehl angeben.

Fügen Sie die folgenden Inhalte ein, um unsere Testaufgabe einzurichten:

ci / tasks / run_tests.yml

---
platform: linux

image_resource:
 type: docker-image
 source:
   repository: node
   tag: latest

inputs:
 - name: hello_hapi
 - name: dependency-cache

run:
 path: hello_hapi/ci/scripts/run_tests.sh

In der obigen Konfiguration geben wir an, dass für diese Aufgabe ein Linux-Worker erforderlich ist. Der Concourse-Server selbst kann diese Anforderung ohne zusätzliche Konfiguration erfüllen.

Als Nächstes geben wir ein Bild an, das vom Worker zum Ausführen der Aufgabe verwendet wird. Obwohl Sie Ihre eigenen Bildtypen erstellen und verwenden können, handelt es sich in der Praxis fast immer um ein Docker-Bild. Da unser Repository eine Node.js-Anwendung ist, wählen wir das neueste "Node" -Image aus, um unsere Tests auszuführen, da das entsprechende Tool bereits installiert ist.

Concourse-Tasks können Eingaben und Ausgaben angeben, um anzugeben, auf welche Ressourcen und Artefakte zugegriffen werden muss. Die Eingaben entsprechen den Ressourcen, die zuvor auf der Ebene „Job“ abgebaut wurden. Der Inhalt dieser Ressourcen wird der Taskumgebung als oberstes Verzeichnis zur Verfügung gestellt, das während der Taskausführung bearbeitet werden kann. Hier ist das Anwendungs-Repository im Verzeichnis + hello_hapi + und die Abhängigkeiten von Node.j in einem Verzeichnis mit dem Namen + dependency-cache + verfügbar. In Ihrem Ausführungsschritt müssen möglicherweise Dateien oder Verzeichnisse zu Beginn der Aufgaben an den erwarteten Speicherort verschoben und Artefakte am Ende der Aufgaben an den Ausgabespeicherorten abgelegt werden.

Schließlich listet das Element * run * den * Pfad * zu dem auszuführenden Befehl auf. Jede Aufgabe kann nur ein einziger Befehl mit Argumenten sein. Während es also möglich ist, einen Befehl inline durch Zusammensetzen einer Bash-Zeichenfolge zu erstellen, ist es üblicher, die Aufgabe auf eine Skriptdatei zu verweisen. In diesem Fall verweisen wir auf ein Skript im Eingabeverzeichnis "+ hello_hapi " unter " hello_hapi / ci / scripts / run_tests.sh +". Wir werden dieses Skript als nächstes erstellen.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Definieren des Testskripts

Schließlich müssen wir das Skript erstellen, das die Aufgabe ausführen wird. Öffnen Sie eine neue Datei mit dem Namen "+ run_tests.sh " unter " ci / scripts / run_tests.sh +":

nano ci/scripts/run_tests.sh

Dieses Skript bearbeitet die Eingaben der Testumgebung, um Elemente an den richtigen Speicherort zu verschieben. Anschließend wird die im Repository definierte Testsuite ausgeführt, indem "+ npm test" ausgeführt wird.

Fügen Sie Folgendes in die neue Datei ein:

ci / scripts / run_tests.sh

#!/usr/bin/env bash

set -e -u -x

mv dependency-cache/node_modules hello_hapi
cd hello_hapi && npm test

Zunächst geben wir an, dass dieses Skript vom Docker-Container-Interpreter "+ bash" ausgeführt werden soll. Die "+ set +" - Optionen ändern das Standardverhalten der Shell, sodass Fehler oder nicht gesetzte Variablen die Skriptausführung anhalten und jeden Befehl während der Ausführung drucken. Diese helfen dabei, das Skript sicherer zu machen und die Sichtbarkeit für Debugging-Zwecke zu verbessern.

Der erste Befehl, den wir ausführen, verschiebt die zwischengespeicherten Abhängigkeiten, die sich im Verzeichnis "+ node_modules " befinden, aus dem Verzeichnis " dependency-cache " in das Verzeichnis " hello_hapi ". Denken Sie daran, dass beide Verzeichnisse verfügbar sind, da wir sie als Eingaben in der Aufgabendefinition angegeben haben. An diesem neuen Ort sucht ` npm +` nach den heruntergeladenen Abhängigkeiten, die es benötigt.

Danach ziehen wir in das Application Repository und führen "+ npm test +" aus, um die definierte Testsuite auszuführen.

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Markieren Sie das neue Skript als ausführbar, bevor Sie fortfahren, damit es direkt ausgeführt werden kann:

chmod +x ci/scripts/run_tests.sh

Unsere Pipeline und alle zugehörigen Dateien sind jetzt definiert.

Einrichten der Pipeline in Concourse

Bevor wir den Zweig + pipeline + wieder in + main + zusammenführen und zu GitHub hochschieben, sollten wir unsere Pipeline in Concourse laden. Concourse überwacht unser Repository auf neue Commits und führt unsere kontinuierlichen Integrationsverfahren durch, wenn Änderungen festgestellt werden.

Während wir die Pipeline manuell laden müssen, liest Concourse beim Ausführen der Pipeline die Tasks und Skripts aus den Verzeichnissen im Repository. Alle Änderungen an der Pipeline selbst müssen erneut in Concourse geladen werden, damit sie wirksam werden. Da wir jedoch nicht alles inline definiert haben, werden Änderungen an Aufgaben oder Skripten automatisch bemerkt, wenn sie als Teil eines Commits hochgeladen werden.

Um eine neue Pipeline einzurichten, richten Sie den Befehl fly mit der Aktion + set-pipeline + auf Ihren Concourse-Server. Wir müssen den Namen der neuen Pipeline mit der Option "+ -p " übergeben und die Pipeline-Konfigurationsdatei mit der Option " -c +" übergeben:

fly -t main set-pipeline -p hello_hapi -c ci/pipeline.yml

Sie werden aufgefordert, die Konfiguration zu bestätigen, bevor Sie fortfahren. Tippe * y * und drücke * ENTER *:

Output. . .

apply configuration? [yN]:
pipeline created!
you can view your pipeline here: https://example.com/teams/main/pipelines/hello_hapi

the pipeline is currently paused. to unpause, either:
 - run the unpause-pipeline command
 - click play next to the pipeline in the web ui

Wie die Ausgabe anzeigt, wurde die Pipeline akzeptiert, ist jedoch derzeit angehalten. Sie können die Pipeline entweder mit "+ fly +" oder der Web-Benutzeroberfläche anhalten. Wir werden die Web-Benutzeroberfläche verwenden.

Besuchen Sie in Ihrem Webbrowser Ihren Concourse-Server und melden Sie sich an. Sie sollten Ihre neue Pipeline visuell definiert sehen:

image: https: //assets.digitalocean.com/articles/concourse_usage_1604/inactive_pipeline.png [Concourse inactive pipeline]

Die ausstehenden Jobs werden durch graue Kästchen dargestellt und die Ressourcen sind kleinere, dunkle Blöcke. Jobs, die durch Ressourcenänderungen ausgelöst werden, sind durch durchgezogene Linien verbunden, während nicht auslösende Ressourcen unterbrochene Linien verwenden. Ressourcen, die aus Aufträgen fließen, zeigen an, dass für den nächsten Auftrag eine Bedingung "+ bestanden +" festgelegt wurde.

Der blaue Header zeigt an, dass die Pipeline derzeit angehalten ist. Klicken Sie auf das * Menüsymbol * (drei übereinanderliegende horizontale Linien) in der oberen linken Ecke, um das Menü zu öffnen. Sie sollten einen Eintrag für Ihre Pipeline sehen (Sie müssen sich möglicherweise abmelden und wieder anmelden, wenn die Pipeline nicht sichtbar ist). Klicken Sie auf das blaue Symbol * play * neben der Pipeline, um die Pause aufzuheben:

image: https: //assets.digitalocean.com/articles/concourse_usage_1604/unpause_pipeline.png

Die Pipeline sollte jetzt nicht angehalten sein und in Betrieb genommen werden.

Zu Beginn werden verschiedene Ressourcen und Jobs möglicherweise orange angezeigt, was darauf hinweist, dass Fehler aufgetreten sind. Dies geschieht, weil verschiedene Docker-Images heruntergeladen werden müssen und der Zweig "+ pipeline " weiterhin mit dem Zweig " main +" unseres Repositorys zusammengeführt werden muss, um die Task- und Skriptdateien verfügbar zu machen.

Übernehmen der Änderungen in Git

Nachdem der kontinuierliche Integrationsprozess definiert wurde, können wir ihn in unser Repository "+ git +" übertragen und in Concourse hinzufügen.

Fügen Sie das neue "+ ci +" - Verzeichnis zum Staging-Bereich hinzu, indem Sie Folgendes eingeben:

git add ci

Überprüfen Sie die Dateien, die festgeschrieben werden sollen, indem Sie den Status überprüfen:

git status
OutputOn branch pipeline
Changes to be committed:
 (use "git reset HEAD <file>..." to unstage)

   new file:   ci/pipeline.yml
   new file:   ci/scripts/run_tests.sh
   new file:   ci/tasks/run_tests.yml

Übernehmen Sie die Änderungen, indem Sie Folgendes eingeben:

git commit -m 'Add Concourse pipeline'

Die Änderungen werden nun in unserem Zweig "+ pipeline " übernommen. Wir können den Zweig wieder in den Zweig " master +" zusammenführen, indem wir den Zweig wechseln und zusammenführen:

git checkout master
git merge pipeline

Verschiebe nun den + master + Zweig mit den neuen Änderungen zurück nach GitHub:

git push origin master

Das Commit startet innerhalb von 60 Sekunden einen neuen Build, und Concourse hat nach dem Abrufen der Änderungen Zugriff auf die Pipeline-Tasks und -Skripts.

Anzeigen des neuen Builds

Zurück in der Concourse-Web-Benutzeroberfläche wird in der nächsten Minute ein neuer Build über die Pipeline ausgeführt:

image: https: //assets.digitalocean.com/articles/concourse_usage_1604/running_test.png [Concourse führt die Testsuite aus]

Die gelbe Umrandung zeigt an, dass der Auftrag gerade ausgeführt wird. Um den Fortschritt zu überwachen, klicken Sie auf den Job * Tests ausführen *, um die aktuelle Ausgabe anzuzeigen. Sobald der Auftrag abgeschlossen ist, ist die vollständige Ausgabe verfügbar und der Auftrag sollte grün werden:

image: https://assets.digitalocean.com/articles/concourse_usage_1604/successful_tests.png [Erfolgreiche Tests zusammentragen]

Klicken Sie auf das Symbol * home *, um zum Hauptbildschirm der Pipeline zurückzukehren. Der grüne Status jedes Jobs zeigt an, dass der letzte Commit alle Phasen der Pipeline durchlaufen hat:

image: https: //assets.digitalocean.com/articles/concourse_usage_1604/passed_all_jobs.png [Concourse hat alle Jobs bestanden]

Die Pipeline überwacht das Repository weiterhin und führt automatisch neue Tests durch, wenn Änderungen festgeschrieben werden.

Fazit

In diesem Handbuch richten wir eine Concourse-Pipeline ein, um ein Repository automatisch auf Änderungen zu überwachen. Wenn Änderungen erkannt werden, ruft Concourse die neueste Version des Repositorys ab und verwendet einen Docker-Container, um die Projektabhängigkeiten zu installieren und zwischenzuspeichern. Der Build fährt dann mit der Testphase fort, in der die Abhängigkeiten kopiert werden und die Testsuite des Repositorys ausgeführt wird, um zu überprüfen, ob wichtige Änderungen vorgenommen wurden.

Concourse bietet viel Flexibilität und Kraft, um isolierte Testverfahren zu definieren und diese im Repository selbst zu speichern. Wenn Sie mehr darüber erfahren möchten, wie Sie Concourse für Ihre eigenen Projekte nutzen können, besuchen Sie check out the official documentation.

Related