TOC

So installieren und konfigurieren Sie Drone unter Ubuntu 16.04

Einführung

Drone ist eine beliebte, in Go integrierte Plattform für kontinuierliche Integration und Bereitstellung. Es lässt sich in viele gängige Versionskontroll-Repository-Dienste wie GitHub, GitLab und Bitbucket integrieren, um nach Codeänderungen zu suchen und Änderungen automatisch zu erstellen und zu testen, wenn sie festgeschrieben werden.

In diesem Handbuch wird gezeigt, wie Sie eine vollständige Drone Continuous Integration-Umgebung für Ihre Infrastruktur einrichten. Wir installieren Drone und konfigurieren es für die Integration in Ihr Quellcode-Repository. Auf dem Weg werden wir Nginx, geschützt durch Let’s Encrypt, als Frontend für Drone konfigurieren. Dadurch werden Anforderungen an die Drone-Weboberfläche verschlüsselt, und der CI-Server kann sicher in den Quellcodeserver integriert werden.

Voraussetzungen

Damit Sie loslegen können, sollten Sie einen Ubuntu 16.04-Server mit einem Benutzer ohne Rootberechtigung, + sudo +, für administrative Aufgaben konfigurieren. Der Server sollte auch eine Firewall haben, um eingehende Verbindungen zu filtern. Informationen zum Konfigurieren dieser Elemente finden Sie unter Ubuntu 16.04 Einrichtungsanleitung für den Server.

Sie müssen einige zusätzliche Schritte ausführen, um die anderen Anforderungen für unser Setup zu erfüllen. Da Drone hauptsächlich als Docker-Image verteilt wird, werden wir Docker Compose zum Verwalten der CI-Server-Container verwenden. Aus Sicherheits- und Leistungsgründen leiten wir Anfragen an Drone über eine Nginx-Instanz weiter, die durch Let’s Encrypt geschützt ist. Sie benötigen einen Domänennamen, der an Ihren CI-Server angehängt ist, um dies ordnungsgemäß einzurichten.

Bevor Sie beginnen, verwenden Sie die folgenden Artikel, um diese zusätzlichen Anforderungen einzurichten:

Wenn Sie die obigen Anleitungen abgeschlossen haben, sollte Ihr Drone-Server Folgendes haben:

  • Ein "+ sudo +" - Benutzer, der für administrative Aufgaben konfiguriert ist

  • Eine UFW-Firewall ist aktiviert. Es sollte alle Verbindungen mit Ausnahme von SSH-, HTTP- und HTTPS-Anforderungen an den Ports 22, 80 und 443 blockieren.

  • Docker und Docker Compose installiert.

  • Ein Nginx-Server, der mit einem SSL-Zertifikat konfiguriert ist, das von Let’s Encrypt bereitgestellt wird

Fahren Sie unten fort, wenn Sie bereit sind, zu beginnen.

Fügen Sie Ihrem Quellcode-Repository eine Anwendung hinzu

Um Codeänderungen zu überwachen, um Build- und Testphasen auszulösen, benötigt Drone Zugriff auf Ihr Quellcode-Repository. Drone kann in GitHub, GitLab, http: // docs integriert werden. drone.io/install-for-gogs/[Gogs], Bitbucket Cloud und http://docs.drone.io/install- für-bitbucket-server / [Bitbucket Server].

In diesem Handbuch konzentrieren wir uns auf die Integration in ein GitHub-Repository, der Prozess sollte jedoch für andere Systeme ähnlich sein. Wenn Sie ein anderes Quellcode-Repository verwenden, folgen Sie dem entsprechenden Link oben, um mehr über die Software-spezifische Konfiguration zu erfahren, die Sie benötigen.

Beginnen Sie mit dem Besuch Ihres https://github.com [GitHub] -Kontos. Klicken Sie oben rechts auf Ihr Benutzersymbol und wählen Sie im Dropdown-Menü die Option * Einstellungen *:

image: https://assets.digitalocean.com/articles/drone_install_1604/github_settings.png [Drone GitHub-Einstellungen]

Suchen Sie als Nächstes das Element * OAuth-Anwendungen * im Abschnitt * Entwicklereinstellungen * auf der linken Seite des Bildschirms:

image: https://assets.digitalocean.com/articles/drone_install_1604/oauth_apps.png [Drone OAuth-Anwendungen]

Klicken Sie auf der folgenden Seite auf * Neue Anwendung registrieren *:

image: https://assets.digitalocean.com/articles/drone_install_1604/new_app.png [Neue App für Drohnen]

Als Nächstes wird das Registrierungsformular für OAuth-Anwendungen angezeigt:

image: https: //assets.digitalocean.com/articles/drone_install_1604/define_new_app.png [Drone registriert eine neue App]

Sie müssen die folgenden Felder ausfüllen (diese Felder sind auf GitHub vorhanden). Andere Repository-Anbieter haben möglicherweise andere Eingabeaufforderungen:

  • * Anwendungsname *: Ein Name, den Sie auswählen, um die Integration zu identifizieren. "Drone" ist eine gute Wahl, wenn Sie keine besonderen Bedürfnisse haben.

  • * Homepage-URL *: Der Domain-Name Ihres Drone-Servers. Verwenden Sie hier "+ https: // +", da wir eine gesicherte Domain verwenden.

  • * Anwendungsbeschreibung *: Eine einfache Beschreibung der Drohne und ihres Zwecks.

  • * Autorisierungs-Rückruf-URL *: Dies muss der Schema-Bezeichner "+ https: // " sein, gefolgt vom Domain-Namen Ihres Drone-Servers, gefolgt von " / authorize ". Wenn Ihr Domainname "+" ist, lautet diese Datei "+ https: /// authorize".

Wenn Sie fertig sind, klicken Sie auf * Anmeldung registrieren *.

Auf der folgenden Seite sehen Sie die Details für Ihre neue Anwendung. Die zwei Elemente, die wir benötigen, sind die * Client ID * und das * Client Secret *:

image: https://assets.digitalocean.com/articles/drone_install_1604/client_info.png [Informationen zum Drone-Client]

Kopieren Sie diese beiden Werte für später. Diese werden benötigt, um Drone mit Ihrem GitHub-Konto zu verbinden.

Ziehen Sie das Drone Docker-Image und bereiten Sie die Konfiguration vor

Nachdem Sie Ihren Drone-Server bei einem Repository-Anbieter registriert haben, können Sie Drone auf Ihrem Server installieren und konfigurieren.

Drone wird als Docker-Container vertrieben, sodass es automatisch heruntergeladen wird, wenn wir es in einer Docker Compose-Datei verwenden. Um den Vorgang jedoch etwas zu beschleunigen, können wir das Bild vorzeitig herunterziehen:

docker pull drone/drone:0.7

Das Drone Docker-Image ist ein einheitlicher Container, der auf verschiedene Arten ausgeführt werden kann. Wir werden einen Container ausführen, der als Drone-Server fungiert, der den Repository-Zugriff koordiniert, die Web-Benutzeroberfläche hostet und die API bereitstellt. Mit demselben Image und unterschiedlichen Einstellungen führen wir einen weiteren Container als Drone-Agent aus, der für das Erstellen und Testen von Software aus den konfigurierten Repositorys verantwortlich ist.

Wir werden beide Container mit Docker Compose auf dem Drone-Host ausführen. Erstellen Sie zunächst ein Konfigurationsverzeichnis, in dem die benötigten Dateien gespeichert werden:

sudo mkdir /etc/drone

Als Nächstes erstellen wir einige Dateien innerhalb von, um unsere Dienste zu konfigurieren.

Erstellen Sie eine Docker Compose-Datei für Drone

Erstellen Sie zunächst eine Docker Compose-Datei im Konfigurationsverzeichnis:

sudo nano /etc/drone/docker-compose.yml

Im Inneren markieren wir das Docker Compose-Dateiformat als Version “3”. Anschließend definieren wir Services für beide oben beschriebenen Services.

Der Dienst + drone-server + startet den Drone-Server-Hauptcontainer, der auf Port 8000 lauscht. Wir werden das + / var / lib / drone + -Verzeichnis des Hosts innerhalb des Containers mounten, damit Drone seine Daten beibehalten kann. Wir werden den Dienst so konfigurieren, dass er automatisch neu startet und detailliertere Konfigurationsanweisungen in Form von Umgebungsvariablen liest, die in einer Datei definiert sind, die wir unter "+ / etc / drone / server.env +" erstellen.

Der Dienst "+ drone-agent" verwendet dasselbe Image, das mit dem Befehl "+ agent" gestartet wurde. Er erhält Anweisungen von der Haupt-Drone-Serverinstanz, sodass er keinen allgemeinen Netzwerkzugriff benötigt, sondern erst nach dem Drone-Dienst gestartet werden muss. Es benötigt auch Zugriff auf die Docker-Socket-Datei, um Container hochzufahren und die eigentlichen Build- und Testschritte auszuführen. Wie der Dienst "+ drone-server " startet auch dieser Dienst automatisch neu und liest eine Umgebungsdatei unter " /etc/drone/agent.env +" zur zusätzlichen Konfiguration.

Verwenden Sie die folgende Docker Compose-Datei, um diese beiden Dienste zu konfigurieren. Achten Sie genau auf die YAML-Formatierung der Datei, da Fehler beim Einrücken oder Formatieren zu Fehlern führen können:

/etc/drone/docker-compose.yml

version: '3'

services:
 drone-server:
   image: drone/drone:0.7
   ports:
     - 127.0.0.1:8000:8000
   volumes:
     - /var/lib/drone:/var/lib/drone
   restart: always
   env_file:
     - /etc/drone/server.env

 drone-agent:
   image: drone/drone:0.7
   command: agent
   depends_on:
     - drone-server
   volumes:
     - /var/run/docker.sock:/var/run/docker.sock
   restart: always
   env_file:
     - /etc/drone/agent.env

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

Konfigurieren Sie die Umgebungsvariablendatei des Drone Servers

Als nächstes müssen wir die Umgebungsvariablendatei des Drone-Servers erstellen, auf die wir in der Docker Compose-Datei oben verwiesen haben.

Bevor wir die Datei öffnen, sollten wir einen starken Schlüssel generieren, um die Agenten- und Serverkomponenten zu authentifizieren. Obwohl sich in unserem Setup beide Komponenten auf demselben Server befinden, ist ein starker Schlüssel von entscheidender Bedeutung, da Ihre Testinfrastruktur skaliert. Generieren Sie in der Befehlszeile einen Schlüssel, indem Sie Folgendes eingeben:

LC_ALL=C </dev/urandom tr -dc A-Za-z0-9 | head -c 65 && echo

Mit diesem Befehl wird die Sprache in der Shell vorübergehend auf einen begrenzten Zeichenbereich festgelegt. Es nimmt dann einen Strom von zufälligen Bytes aus "+ / dev / urandom +" und filtert alle nicht-alphanumerischen Zeichen weiter heraus. Wir nehmen die ersten 65 Zeichen als unseren Schlüssel.

Die Ausgabe sieht ungefähr so ​​aus (* Kopieren Sie den folgenden Wert nicht! Generieren Sie Ihre eigenen! *):

OutputERmA7xubDvTa8i0wYBlljc9yjT1NJPG7xOlZBwAdMAmBYL4RZE4QngxWcCLowk9KN

Kopieren Sie den generierten Schlüssel zur Verwendung in der Serverumgebungsdatei.

Erstellen Sie eine neue Datei unter + / etc / drone / server.env + und öffnen Sie sie in Ihrem Texteditor:

sudo nano /etc/drone/server.env

Im Folgenden werden die Umgebungsvariablen definiert, mit denen Drone eine Verbindung herstellt, um den Dienst zu starten, eine Verbindung zum Repository-Anbieter herzustellen und Richtlinien für die Kontoberechtigung festzulegen. Sie benötigen die Werte, die Sie zuvor von Ihrem Repository-Anbieter kopiert haben, um die Werte korrekt auszufüllen.

Stellen Sie zunächst die Werte "+ DRONE_HOST " und " DRONE_SECRET " ein. Setzen Sie " DRONE_SECRET " auf den Schlüssel, den Sie in der Befehlszeile generiert haben. Die Einstellung " DRONE_HOST " informiert Drone über seine öffentlich zugängliche Adresse. Dies sollte Ihre Let’s Encrypt-geschützte Domain sein, der der Schema-Bezeichner " https: // +" vorangestellt ist:

/etc/drone/server.env

# Service settings
DRONE_SECRET=
DRONE_HOST=https://

Als Nächstes konfigurieren wir die Integration mit unserem VCS-Provider, in unserem Fall GitHub. Die für Ihr Projekt geeigneten Einstellungen können sich je nach Ihren Anforderungen und der Organisation Ihrer GitHub-Assets unterscheiden.

Wir werden unsere Drone-Installation sperren und die offene Registrierung deaktivieren, indem wir "+ DRONE_OPEN " auf " false " setzen. Dies bedeutet, dass sich nur die in ` DRONE_ADMIN +` angegebenen GitHub-Kontonamen anmelden können.

Stellen Sie sicher, dass "+ DRONE_ADMIN +" Ihren GitHub-Kontonamen enthält.

Aktivieren Sie anschließend das GitHub-Integrations-Plugin, indem Sie "+ DRONE_GITHUB " auf " true " setzen. Wir werden dann die ` DRONE_GITHUB_CLIENT ` und ` DRONE_GITHUB_SECRET +` auf die Schlüssel setzen, die wir von der GitHub OAuth-Anwendungsseite kopiert haben, als wir unsere Drone-Anwendung registriert haben:

/etc/drone/server.env

# Service settings
DRONE_SECRET=
DRONE_HOST=https://

# Registration settings
DRONE_OPEN=false
DRONE_ADMIN=

# GitHub Settings
DRONE_GITHUB=true
DRONE_GITHUB_CLIENT=
DRONE_GITHUB_SECRET=

Wir sind mit der Konfiguration der Serverkomponente fertig. Kopieren Sie vor dem Verlassen den Wert + DRONE_SECRET + aus der Datei. Diesen Schlüssel müssen wir im nächsten Abschnitt festlegen, wenn wir den Agenten konfigurieren. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Konfigurieren Sie die Umgebungsvariablendatei des Drone-Agenten

Als Nächstes erstellen wir eine Umgebungsdatei für die Drone-Agentenkomponente.

Öffnen Sie eine neue Datei, um die Umgebungsvariablen des Agenten festzulegen:

sudo nano /etc/drone/agent.env

Im Inneren müssen wir nur zwei Werte definieren. Das + DRONE SECRET stimmt mit der Konfiguration in der Datei` + server.env` überein.

Mit der Einstellung "+ DRONE_SERVER " wird konfiguriert, wie der Agent eine Verbindung zur Drone-Serverkomponente herstellen soll. Es beginnt mit einem " wss: // " - Protokollpräfix, das angibt, dass die Verbindung ein verschlüsseltes Web-Socket verwendet, gefolgt vom Domainnamen des Drone-Servers mit dem an das Ende angehängten " / ws / broker +" -URI:

/etc/drone/agent.env

DRONE_SECRET=
DRONE_SERVER=wss:///ws/broker

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

Konfigurieren Sie die Drone Systemd Unit-Datei

Nachdem unsere Konfigurationsdateien vorhanden sind, können wir eine System-Unit-Datei definieren, um den Drone-Dienst zu verwalten.

Öffnen Sie eine neue Datei "+ .service" im Verzeichnis "+ / etc / systemd / system", um den Dienst zu konfigurieren:

sudo nano /etc/systemd/system/drone.service

Fügen Sie im Inneren den folgenden Inhalt ein:

/etc/systemd/system/drone.service

[Unit]
Description=Drone server
After=docker.service nginx.service

[Service]
Restart=always
ExecStart=/usr/local/bin/docker-compose -f /etc/drone/docker-compose.yml up
ExecStop=/usr/local/bin/docker-compose -f /etc/drone/docker-compose.yml stop

[Install]
WantedBy=multi-user.target

Der erste Abschnitt weist systemd an, diesen Dienst zu starten, nachdem Docker und Nginx verfügbar sind. Der zweite Abschnitt weist das init-System an, den Dienst bei Fehlern automatisch neu zu starten. Anschließend werden die Befehle zum Starten und Stoppen des Drone-Dienstes mithilfe von Docker Compose und der zuvor erstellten Konfigurationsdatei definiert. Schließlich wird im letzten Abschnitt definiert, wie der Dienst beim Booten gestartet werden kann.

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

Bevor wir den Drone-Dienst starten, müssen wir Nginx konfigurieren. Der Drone-Agent muss in der Lage sein, eine Verbindung zum Drone-Server herzustellen, und die Verbindung setzt voraus, dass der Nginx-Proxy vorhanden ist.

Konfigurieren Sie Nginx für Proxy-Anforderungen an Drone

Als nächstes müssen wir die Konfiguration von Nginx so ändern, dass Proxy-Anfragen an unseren Drone-Server gesendet werden.

Suchen Sie zunächst die Serverblockkonfiguration, die Ihre mit Let’s Encrypt geschützte Domain verwaltet. Suchen Sie in allen aktivierten Serverblöcken nach dem Attribut "+ Servername +", indem Sie Folgendes eingeben:

grep -R server_name /etc/nginx/sites-enabled
Output/etc/nginx/sites-enabled/default:   server_name ;
/etc/nginx/sites-enabled/default:   return 301 https://$server_name$request_uri;
/etc/nginx/sites-enabled/default:   server_name ;
/etc/nginx/sites-enabled/default:#  server_name example.com;

In der obigen Ausgabe wird der Domänenname (in diesem Fall "+ example.com ") in der Datei " / etc / nginx / sites-enabled / default +" definiert. Sie möchten die Datei (die erste Spalte) bearbeiten, die Ihrem Domain-Namen zugeordnet ist.

Möglicherweise sehen Sie auch Folgendes:

Output/etc/nginx/sites-enabled/default:   server_name _;
/etc/nginx/sites-enabled/default:   return 301 https://$server_name$request_uri;
/etc/nginx/sites-enabled/default:   server_name _;
/etc/nginx/sites-enabled/default:#  server_name example.com;

In der obigen Ausgabe stellen die Zeilen "+ Servername ; +" Serverblöcke dar, die als Fallback-Mechanismen fungieren sollen. Der Host-Bezeichner "" ist ein ungültiger Host, daher wird er niemals alleine übereinstimmen.

In der Konfiguration werden diese mit den Anweisungen "+ listen " gepaart, die die Option " default_server " festlegen, sodass der Block als Standard fungiert, wenn der angeforderte Host keinem anderen definierten Serverblock entspricht. Wenn Sie keine " Servername +" - Definition finden, die Ihrem Domainnamen entspricht, sollten Sie stattdessen die Datei verwenden, die diese Fallback-Blöcke definiert.

Öffnen Sie die Ihrer Domain am besten zugeordnete Datei in Ihrem Texteditor:

sudo nano /etc/nginx/sites-enabled/default

Im Inneren werden wir beginnen, indem wir zwei Abschnitte außerhalb der vorhandenen "+ server +" - Blöcke hinzufügen:

/ etc / nginx / sites-enabled / default

server {
   . . .

Der erste Block konfiguriert einen Upstream-Speicherort mit dem Namen "+ drone ", an dem wir Anfragen per Proxy senden können. Die Anweisung ` server +` definiert, wie eine Verbindung zu unserem Drone-Dienst hergestellt wird, der auf Port 8000 ausgeführt wird.

Der zweite Block setzt eine benutzerdefinierte Variable mit dem Namen "+ $ connection_upgrade " basierend auf dem Wert der Variablen " $ http_upgrade ", die Nginx setzt, wenn ein HTTP-Header "Upgrade" empfangen wird. Wenn ein Upgrade-Header empfangen wird, setzt Nginx die Variable " $ connection_upgrade" auf "+ upgrade". Wenn nicht, wird es auf "+ close +" gesetzt. Mit diesen Variablen können wir die richtigen Header festlegen, wenn wir WebSocket-Anforderungen weiterleiten.

Suchen Sie als Nächstes den Block "+ server " mit der Direktive " listen 443 ". Ersetzen Sie den Inhalt des " location / +" - Blocks durch die folgenden Anweisungen. Stellen Sie sicher, dass Sie alle vorhandenen Konfigurationen aus diesem Block auskommentieren oder entfernen, um Konflikte zu vermeiden:

/ etc / nginx / sites-enabled / default

. . .
server {
   listen 443 ssl;
   . . .
   location / {
        try_files $uri $uri/ =404;











   }
   . . .
}

Die Zeile "+ proxy_pass " weist Nginx an, den gesamten Verkehr aus diesem Block an den oben definierten " Upstream " weiterzuleiten. Als nächstes fügen wir einige Proxy-Header-Definitionen aus der Datei " proxy_params " hinzu und fügen die zusätzlichen Header hinzu, die auf unserer Einstellung " map +" aus früheren Versionen basieren.

Anschließend passen wir einige andere Proxy-spezifische Einstellungen an, um sicherzustellen, dass der WebSocket-Proxy ordnungsgemäß funktioniert und dass unsere Komponenten effektiv kommunizieren können.

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

Testen und starten Sie Nginx und Drone neu

Unsere Konfiguration ist nun abgeschlossen. Wir müssen nur unsere Dienste starten oder neu starten, um die Konfiguration zu implementieren.

Überprüfen Sie zunächst die Nginx-Konfiguration auf Syntaxfehler:

sudo nginx -t
Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Wenn die Ausgabe auf ein Konfigurationsproblem hinweist, überprüfen Sie die Nginx-Konfiguration erneut.

Wenn Sie fortfahren möchten, starten Sie Nginx neu:

sudo systemctl restart nginx

Jetzt, da Nginx für Proxy-Anfragen zwischen Agent und Server verfügbar ist, können wir Drone starten:

sudo systemctl start drone

Überprüfen Sie, ob der Dienst erfolgreich gestartet werden konnte:

sudo systemctl status drone
Output● drone.service - Drone server
  Loaded: loaded (/etc/systemd/system/drone.service; disabled; vendor preset: enabled)
  Active:  since Fri 2017-06-09 21:56:33 UTC; 2min 58s ago
Main PID: 15225 (docker-compose)
   Tasks: 5
  Memory: 37.7M
     CPU: 1.544s
  CGroup: /system.slice/drone.service
          ├─15225 /usr/local/bin/docker-compose -f /etc/drone/docker-compose.yml up
          └─15228 /usr/local/bin/docker-compose -f /etc/drone/docker-compose.yml up

. . .
Jun 09 21:56:35 drone docker-compose[15225]: drone-agent_1   | pipeline: request next execution

Wenn der Dienst als "+ aktiv (aktiv) +" markiert ist und keine Fehler im Protokoll vorhanden sind, ist Drone aktiv.

Wenn Sie auf Probleme stoßen, können Sie die Nginx-Protokolle überprüfen, indem Sie Folgendes eingeben:

sudo less /var/log/nginx/error.log

Sie können die Drone-Protokolle überprüfen, indem Sie Folgendes eingeben:

sudo journalctl -u drone

Wenn alles richtig läuft, aktivieren Sie Drone, um beim Booten zu starten, indem Sie Folgendes eingeben:

sudo systemctl enable drone

Der Drone-Dienst wird gestartet, nachdem die Docker- und Nginx-Dienste verfügbar sind.

Melden Sie sich bei Drone an, um den Zugriff auf Ihr Repository zu autorisieren

Jetzt, da Drone läuft, können wir uns bei der Weboberfläche anmelden und die Anwendung für die Verwendung unseres GitHub-Kontos autorisieren.

Besuchen Sie den Domainnamen Ihres Servers in Ihrem Webbrowser, um die Drone-Weboberfläche anzuzeigen:

https://

Bei Ihrem ersten Besuch werden Sie aufgefordert, sich anzumelden:

image: https://assets.digitalocean.com/articles/drone_install_1604/login_drone.png [Drohnen-Erstbesuch]

Klicken Sie auf "Anmelden", um sich mit OAuth bei Drone mit Ihrem GitHub-Konto zu authentifizieren. Wenn Sie derzeit nicht bei GitHub angemeldet sind, werden Sie aufgefordert, sich zuerst bei GitHub anzumelden.

Anschließend werden Sie aufgefordert, Drone den Zugriff auf Ihr GitHub-Konto zu erlauben:

image: https://assets.digitalocean.com/articles/drone_install_1604/authorize_app.png [Drone ermöglicht Zugriff über GitHub]

Klicken Sie nach dem Überprüfen der angeforderten Berechtigungen und dem Vornehmen von Anpassungen auf die Schaltfläche * Autorisieren *, um Drone zu autorisieren.

Sie werden zurück zu Ihrem Drone-Server geleitet:

image: https://assets.digitalocean.com/articles/drone_install_1604/logged_in.png [Drone angemeldet]

Von hier aus können Sie Ihre Repositorys aktivieren und konfigurieren, um Ihren Code automatisch zu testen.

Fazit

In diesem Handbuch richten wir Drone als kontinuierlichen Integrations- und Bereitstellungsserver für unsere GitHub-Projekte ein. Wir haben den Drone-Server als zentralen Hub konfiguriert, um die Arbeit zu delegieren, die Authentifizierung zu verwalten und auf Änderungen in unseren Repositorys zu achten. Wir haben auch einen Drone-Agenten konfiguriert, der Tests ausführen und Container verwalten kann. Vor diesem Hintergrund haben wir Nginx so konfiguriert, dass es als sicherer Reverse-Proxy fungiert.

Wenn Sie Drone so einrichten möchten, dass Tests für Ihre Repositorys automatisch ausgeführt werden, lesen Sie die Drone documentation, um zu erfahren, wie Sie eine `+ .drone.yml + definieren `Datei mit Ihren Testverfahren.

Related