So führen Sie kontinuierliche Integrationstests mit Drone.io unter CoreOS und Docker durch

Einführung

Möchten Sie eine kontinuierliche Integrationslösung mit minimalem Setup? Wer würde nicht! https://drone.io [Drone.io] verwendet Docker-Container zum Ausführen Ihrer Tests und funktioniert mit https://github.com [GitHub], https://about.gitlab.com [GitLab] (selbst gehostet) und service based) und https://bitbucket.org [Bitbucket].

Drohne wird mit Go gebaut und nutzt Docker. Es kann in einem Container selbst mit sehr geringer Konfiguration ausgeführt werden.

Continuous Integration ist die Entwicklungspraxis, häufige Commits für Ihre Codebasis durchzuführen und diese zu erstellen und zu testen, während Sie fortfahren. Dies bedeutet, dass neuer Code (hoffentlich) Ihre vorhandene Codebasis schnell und einfach integriert. Da für die fortlaufende Integration das häufige Erstellen und Testen des Codes erforderlich ist, wird der Entwicklungsprozess beschleunigt, wenn Sie den Code automatisch erstellen und testen können. Drohne macht das; Es automatisiert den Prozess des Bauens und Testens.

Drone ruft automatisch Code aus einem gehosteten Git-Repository ab und führt dann die von Ihnen definierten Skripts aus. Sie können jede Testsuite ausführen und sich per E-Mail darüber informieren lassen oder den Status mit einem Badge in Ihrer README-Datei anzeigen lassen. Durch die Integration von Drone in Docker werden eine Vielzahl von Sprachen unterstützt, darunter PHP, Node, Ruby, Go und Python, um nur einige zu nennen. Bei jedem Test wird ein neuer Container erstellt, der auf bestimmten Bildern aus der öffentlichen Docker-Registrierung basiert. Dies bedeutet, dass die Unterstützung für Sprachen und Entwicklungsstapel nur zunimmt, wenn mehr Bilder erstellt werden. Sie können sogar Ihre eigenen erstellen, um sie an Ihre spezifische Anwendung anzupassen!

In diesem Tutorial sehen wir uns an, wie wir Drone.io so komprimieren können, dass es mit der minimalen Linux-Distribution CoreOS ausgeführt werden kann.

Bedarf

Mindestens ein SSH-Schlüssel wurde Ihrem Konto hinzugefügt
Ein einzelnes CoreOS Beta-Droplet (512 MB RAM funktionieren problemlos)

Es wird empfohlen, diese Einführung in CoreOS zu lesen, bevor Sie fortfahren, wenn Sie das Betriebssystem noch nie zuvor verwendet haben.

Wenn Sie sich nicht sicher sind, wie Sie CoreOS mithilfe einer Cloud-Konfigurationsdatei konfigurieren sollen, finden Sie weitere Informationen sowie eine Beispielkonfigurationsdatei unter https://www.digitalocean.com/community/tutorials/how-to-set -up-a-coreos-cluster-on-digitalocean [hier]! Die Beispielkonfigurationsdatei funktioniert für dieses Lernprogramm.

Erster Schritt - Bereiten Sie GitHub vor

Bevor wir beginnen, müssen wir den Zugriff auf unsere GitHub-Konten über oAuth aktivieren. Wir werden ein Tokenpaar generieren, das im nächsten Schritt des Einrichtens des Drone-Containers verwendet wird.

Wir müssen diese Werte aus Ihrem GitHub-Konto generieren. Klicken Sie hier, um die entsprechende Einstellungsseite auf GitHub mit dem Namen * Applications * aufzurufen.

Klicken Sie oben rechts auf die Schaltfläche * Neue Anwendung registrieren *. Daraufhin wird ein neues Formular zum Ausfüllen angezeigt:

image: https://assets.digitalocean.com/articles/drone/register.png [OAuth-Registrierung]

Fügen Sie Ihren * Anwendungsnamen * hinzu. Die * Homepage URL * sollte + http: // YOUR_DROPLET_IP: 8080 / + lauten. Fügen Sie Ihre * Anwendungsbeschreibung * hinzu.

WICHTIG *: Stellen Sie sicher, dass die * Autorisierungs-Rückruf-URL * auf + http: // YOUR_DROPLET_IP: 8080 / api / auth / github.com + eingestellt ist, um eine ordnungsgemäße Authentifizierung zu gewährleisten!

Wenn Sie damit fertig sind, klicken Sie auf "Anwendung registrieren", um zur Informationsseite der neuen Anwendung zu gelangen.

Von hier aus benötigen Sie zwei Informationen, die * Client ID * und * Client Secret *. (Halten Sie den Kunden geheim!) Dies ist NICHT etwas, das du mit jemandem teilen solltest!)

Diese Token werden verwendet, um unsere eigene Drone-Anwendung zu autorisieren, Webhooks zu jedem GitHub-Repository hinzuzufügen, das wir über das * Dashboard * -Panel zu Drone hinzufügen. Die Webhooks werden bei jedem neuen Commit ausgelöst, das wir an GitHub senden, und dies veranlasst Drone, die neuen Änderungen zu klonen und den Build auszuführen.

Notieren Sie sich diese Token, da wir sie im nächsten Schritt benötigen.

Schritt Zwei - Schreiben Sie die Docker-Datei

Sobald Sie Ihr CoreOS Droplet fertig haben, stellen Sie über SSH eine Verbindung her:

ssh -A core@YOUR_DROPLET_IP

Erstellen Sie ein neues Verzeichnis mit dem Namen "+ droneio +":

mkdir droneio
cd droneio

Aufgrund des schreibgeschützten Charakters des CoreOS-Root-Dateisystems können wir Drone.io nicht direkt installieren. Wir müssen es zuerst mit Docker containerisieren. Wir werden eine Docker-Datei einrichten, die Anweisungen zur Installation von Drone.io enthält, so wie wir es auf einem normalen Ubuntu-System tun würden.

In diesem Abschnitt verwenden wir den terminalbasierten Texteditor + vim +. Dies ist der Standard-Texteditor unter CoreOS. Es ist daher wichtig, dass Sie sich mit ihm vertraut machen. Wir zeigen Ihnen Schritt für Schritt, wie Sie die Datei öffnen und bearbeiten können.

Jetzt ist es an der Zeit, mit vim unser Dockerfile zu erstellen. Führen Sie den Befehl aus:

vim Dockerfile

Dadurch wird vim geöffnet und eine neue Datei mit dem Namen "+ Dockerfile +" in Ihrem aktuellen Verzeichnis erstellt.

Rufen Sie nun den Einfügemodus auf. Drücken Sie dazu die Taste + i +. In der unteren linken Ecke des Terminals sollte jetzt "+ - INSERT - +" angezeigt werden. Jetzt können Sie den Dockerfile-Inhalt eingeben oder einfügen.

Hier ist das Dockerfile in seiner Gesamtheit. Kommentare sind für jeden Abschnitt in der Zeile enthalten. Sie können diese Datei genau kopieren:

# Pull from base Ubuntu image
FROM ubuntu

# Do system updates and install dependencies
RUN apt-get update
RUN apt-get -y upgrade
RUN sudo apt-get -y install git wget
RUN apt-get clean

# Download Drone.io
RUN wget http://downloads.drone.io/master/drone.deb
RUN dpkg -i drone.deb

# Expose the Drone.io port
EXPOSE 8080

ENV DRONE_SERVER_PORT 0.0.0.0:8080
ENV DRONE_DATABASE_DATASOURCE /var/lib/drone/drone.sqlite

# Define our GitHub oAuth keys below
ENV DRONE_GITHUB_CLIENT <CLIENT_TOKEN_HERE>
ENV DRONE_GITHUB_SECRET <CLIENT_SECRET_HERE>

# The command we'll be running when the container starts
CMD /usr/local/bin/droned

Ersetzen Sie die Zeichen + <CLIENT_TOKEN_HERE> + und + <CLIENT_SECRET_HERE> + durch die Zeichen aus dem obigen Schritt.

Geben Sie den folgenden Befehl ein, um die vorgenommenen Änderungen zu speichern. Das + w + weist vim an, den Text in die Datei zu schreiben, und + q + bewirkt, dass vim beendet wird.

:wq

Eine sehr schnelle Übersicht für diejenigen, die mit Dockerfiles nicht vertraut sind:

+ FROM - Das Bild, das wir für Ihren Container verwenden werden
+ RUN + - Führt während des Erstellungsprozesses einen Befehl im Container aus
+ EXPOSE + - Ermöglicht den Zugriff auf die angegebenen Ports außerhalb des Containers
+ CMD + - Der Befehl, der ausgeführt wird, wenn der Container gestartet wird
+ ENV + - Legt den Wert einer Umgebungsvariablen im Container fest, der hier für die Drone-Konfiguration verwendet wird

Weitere Informationen zu den Aussagen, die Sie in Docker-Dateien machen können, finden Sie in der official Docker documentation.

Zu diesem Zeitpunkt können wir das Image mit dem folgenden Befehl erstellen:

docker build -t my_drone .

Dies dauert einige Minuten. Sobald es erfolgreich erstellt wurde, können wir einen Container mit unserem neuen Image drehen.

Schritt Zwei - Starten Sie den Drohnencontainer

Drone.io benötigt einen Speicherort für Informationen, daher verwenden wir eine SQLite-Datenbankdatei. Erstellen Sie zunächst eine leere Datei:

touch drone.sqlite

Diese Datei wird von Drone mit Daten gefüllt, sobald der Container in Betrieb ist.

Das Starten von Drone ist recht einfach, aber wir müssen ein paar zusätzliche Schritte ausführen, um sicherzustellen, dass Drone auf den Docker-Server unseres Hosts zugreifen kann. Dies ist die einfachste Möglichkeit, ein Volume zu verwenden, um die Host-Socket-Datei an den Speicherort zu binden, an dem sich die Socket-Datei des Containers befinden würde. Der Befehl zum ordnungsgemäßen Starten des Containers lautet wie folgt:

docker run -d --name="drone-ci" \
   -p 8080:8080 \
   -v /var/lib/drone/ \
   -v /var/run/docker.sock:/var/run/docker.sock \
   -v /home/core/droneio/drone.sqlite:/var/lib/drone/drone.sqlite \
   my_drone

Nehmen wir Zeile für Zeile auseinander, was genau vor sich geht:

+ docker run -d --name =" drone-ci "+ - In diesem Teil des Befehls weisen wir Docker an, diesen Container im Hintergrund auszuführen, damit wir uns keine Sorgen machen müssen, dass er stirbt, wenn wir sterben Verbindung zur SSH-Sitzung trennen. Wir geben ihm auch einen Anzeigenamen, * drone-ci *, damit wir ihn mit dem Befehl + docker + verwalten können.
+ -p 8080: 8080 + - Hier binden wir den Port 8080 von unserem Host an denselben Port im Container. Auf diese Weise können wir außerhalb des Netzwerks des laufenden Containers auf die Drone-Benutzeroberfläche zugreifen.
+ -v / var / lib / drone + - Legt ein Volume für die Speicherung im Container fest.
+ -v /var/run/docker.sock: /var / run / docker.sock + - Mit diesem Trick kann der Drone.io-Container das Docker-System des Hosts steuern. Wir binden den Standort des Containers, an dem sich ein Docker UNIX-Socket befinden würde, an den Docker UNIX-Socket des tatsächlichen Hosts. Mit anderen Worten, wir weisen Drone an, die Docker-Installation auf unserem Host-CoreOS zu verwenden, nicht in dem Container, in dem Drone ausgeführt wird. Dies liegt daran, dass auf dem Host Docker installiert ist und auf dem Container nicht (d. H., Auf dem Docker-Container wird keine verschachtelte Docker-Installation ausgeführt).
+ -v /home/core/droneio/drone.sqlite:/var/lib/drone/drone.sqlite \ + - Binden Sie die leere Speicherdatei an die Datenbank im Container, damit die darin gespeicherten Daten erhalten bleiben. Diese Datei befindet sich außerhalb des Containers, falls Daten wiederhergestellt werden müssen oder die Datenbank aus irgendeinem Grund extern geändert werden muss.
+ my_drone + - Wir verwenden das zuvor erstellte Image, um diesen Container auszuführen.

Wenn nach Ausführung dieses Befehls Fehler auftreten, müssen Sie überprüfen, ob Sie die leere Datenbankdatei erstellt haben und alle Pfade korrekt eingegeben wurden.

Führen Sie eine schnelle Statusprüfung durch, um sicherzustellen, dass der Container ausgeführt wird:

docker ps

Ihre Ausgabe sollte ungefähr so aussehen:

CONTAINER ID        IMAGE               COMMAND               CREATED             STATUS              PORTS                             NAMES
6eddddd09900        my_drone:latest    "/bin/sh -c '/usr/lo   1 seconds ago       Up 1 seconds        0.0.0.0:8080->8080/tcp            drone-ci

Mein Container hat nicht angefangen!

Wenn Sie "+ docker ps " ausgeführt haben und keine Ergebnisse erhalten haben, überprüfen Sie den langen Befehl " docker run " von oben und stellen Sie sicher, dass Sie ihn genau eingegeben haben. Sie können versuchen, es ohne Zeilenumbrüche auszuführen. Stellen Sie außerdem sicher, dass Sie die leere Datei ` drone.sqlite +` im richtigen Verzeichnis erstellt haben.

Um den Container neu zu erstellen und es erneut zu versuchen, müssen wir den beschädigten Container aus Docker entfernen. Andernfalls werden doppelte benannte Container beanstandet.

Entfernen Sie den alten Container mit + docker rm drone-ci + (beachten Sie, dass wir den Namen verwendet haben, den wir dem Container im obigen Befehl gegeben haben). Versuchen Sie dann erneut, den langen Befehl + docker run + aus dem vorherigen Abschnitt auszuführen.

Wenn der Container gestartet wurde, Sie jedoch nicht auf die Installationsseite zugreifen können, sollten Sie versuchen, ihn neu zu starten. Stoppen Sie den Container mit + docker stop drone-ci +. Oder verwenden Sie für einen aggressiveren Stopp "+ docker kill drone-ci ". Dann versuchen Sie es erneut mit ` docker start drone-ci +`.

Wenn Sie in den Container-Protokollen etwas graben möchten, können Sie den Docker-Befehl log verwenden: + docker logs drone-ci +.

Schritt Drei - Richten Sie die Drohne ein

Jetzt können wir Drone mit dem ersten Konto einrichten. Öffnen Sie Ihren Webbrowser und navigieren Sie zu: "+ http: // YOUR_DROPLET_IP: 8080 / login". Sie sollten einen Anmeldebildschirm wie den folgenden sehen:

Bild: https://assets.digitalocean.com/articles/drone/login.png [Drone.io Login]

Wir sehen GitHub nur, weil es der einzige Dienst ist, den wir in der Docker-Datei eingestellt haben.

Klicken Sie nun auf die Schaltfläche * GitHub * und anschließend auf die Schaltfläche * Anwendung autorisieren *, um den Anmelde- und Synchronisierungsvorgang zu starten.

image: https://assets.digitalocean.com/articles/drone/dash.png [Repo-Liste]

Dies ist das Haupt-Dashboard für Drone. Sie können die drei neuesten Repositorys in Ihrem GitHub-Konto anzeigen und die Liste erweitern, indem Sie auf „ALLE DURCHSUCHEN“ klicken. Wenn nicht alle deine Repos angezeigt werden, klicke einfach auf "SYNC" in der oberen rechten Ecke.

Fühlen Sie sich frei, um das Dashboard zu erkunden.

Als nächstes müssen wir den Zugriff auf Ihre verschiedenen Git-Repository-Quellen erlauben.

Fünfter Schritt - Builds von GitHub ausführen

Suchen Sie den Namen des Repositorys, das Sie zu Drone CI hinzufügen möchten, und wählen Sie es aus. Dies aktiviert Drone und fügt Ihrem Repository Webhooks hinzu.

Nach der Aktivierung wird die leere Repository-Statusseite angezeigt:

image: https://assets.digitalocean.com/articles/drone/commitStream.png [Stream übertragen]

Sie können einige der erweiterten Einstellungen für das Repository mithilfe der Schaltfläche in der oberen rechten Ecke untersuchen.

Die .drone.yml-Datei

Wir müssen eine neue Datei im Repository erstellen, die "+ .drone.yml +" heißt. Dadurch wird Drone angewiesen, den Code im GitHub-Repository zu erstellen und zu testen. Hier ist eine sehr einfache Datei, mit der wir testen werden, ob Drone richtig eingerichtet ist.

image: dockerfile/nginx
script:
 - echo hello world

+ image + definiert das Basis-Image, aus dem wir ziehen (das Image kann aus der öffentlichen Docker-Registrierung, einer privaten Registrierung oder lokal erstellt werden). In diesem Fall verwenden wir ein Nginx-Bild.
+ script a definiert einfach die Befehle, die Drone ausführen soll und in welcher Reihenfolge. Sie können mehr als einen Skriptbefehl mit einem anderen "+ - <Befehl hier> +" in einer neuen Zeile definieren. (Stellen Sie sicher, dass die Registerkarten ausgerichtet sind!)

In diesem Skript wird nur "Hallo Welt" wiedergegeben, um zu beweisen, dass Drone funktioniert. Es wird nichts an Ihrem Code getestet.

In einem realen Build- und Testszenario soll Drone ein Docker-Image verwenden, das Ihrer Produktionsumgebung entspricht, und die Skripts sollen den Code im Repository testen.

Übertragen Sie nun die Datei "+ .drone.yml " in Ihr Repository. Dieser Commit und alle anderen Commits, die Sie in Zukunft durchführen (nicht nur für die Datei ` .drone.yml +`), lösen den in Ihrem Repository platzierten Webhook Drone aus. Drone sollte nun hart daran arbeiten, das Basis-Image zu ziehen und Ihre Build-Skripte auszuführen!

Drone erkennt das neue Commit, klont alle am Code vorgenommenen Änderungen und befolgt die Anweisungen in der Datei + .drone.yml +. Unten auf der Seite wird eine Benachrichtigung angezeigt, die Sie darüber informiert, dass der Build ausgeführt wird. Klicken Sie darauf, um die Build-Statusseite anzuzeigen.

image: https://assets.digitalocean.com/articles/drone/statusPage.png [Drohnenarbeiter]

Der Build dauert einige Minuten, da Drone das Image aus der öffentlichen Docker-Registrierung ziehen muss.

Wenn der Build erfolgreich abgeschlossen wurde, können Sie auf das Festschreiben klicken, um weitere Details anzuzeigen. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

$ git clone --depth=50 --recursive --branch=master git://github.com/captainshar/dronetest.git /var/cache/drone/src/github.com/captainshar/dronetest
$ git checkout -qf 9908588ae4e4abcba8afb5029baad5c49a835ba4
$ echo hello world
hello world
$ exit 0

Möglicherweise werden auch einige Warnungen in Bezug auf Perl angezeigt. das ist gut.

Wenn Sie alle diese Schritte und Ihre Build-Pässe abgeschlossen haben, steht Ihnen jetzt Ihr persönlicher Drone.io-Worker zur Verfügung, mit dem Sie nahezu jedes sprachbasierte Projekt erstellen und testen können!

Drone unterstützt auch Bitbucket und GitLab, und die Setup-Prozesse mit OAuth sind vergleichbar mit denen von Github. Möglicherweise müssen Sie die Docker-Datei bearbeiten und den Container mit den richtigen Umgebungsvariablen neu erstellen:

DRONE_BITBUCKET_CLIENT
DRONE_BITBUCKET_SECRET
DRONE_GITLAB_URL
...

Nächste Schritte

Nachdem Sie Drone für die Ausführung von Builds vorbereitet haben, können Sie die Datei + .drone.yml + ändern, um erweiterte Tests durchzuführen.

Wenn Sie beispielsweise eine Node-Anwendung mit einem Testframework wie Karma oder Mocha testen möchten, können Sie den Abschnitt "+ image " in den offiziellen Abschnitt " node " ändern und den Skriptabschnitt so ändern, dass " npm +" ausgeführt wird und führen Sie die Tests! Sehen Sie sich in der Registrierung Docker nach Bildern um, die möglicherweise zu Ihrer Anwendung passen.

Wenn Sie wirklich ausgefallen werden möchten, können Sie in Drone Wall nachsehen, um eine Anzeigetafel mit all Ihren Build-Status bereitzustellen.

Viel Spaß beim Befehlen deiner Drohne!

TOC