Share
Das tägliche Leben eines Entwicklers ist mit monotonen und sich wiederholenden Aufgaben gefüllt. Glücklicherweise leben wir in einem Zeitalter vor der künstlichen Intelligenz, was bedeutet, dass Computer großartig sind und langweilige Aufgaben meistern können je beschwere dich darüber! Lassen Sie uns also eine Automatisierung einrichten, um den Alltag etwas weniger mühsam zu gestalten.
Testen und Bereitstellen sind zwei wesentliche Elemente der Webentwicklung. Mit ein wenig Automatisierung werden sie zu Lösungen, die allgemein als "Continuous Integration" (CI) und "Continuous Deployment" (CD) bezeichnet werden. Der "kontinuierliche" Aspekt dieser Lösungen bedeutet, dass Ihre Projekte automatisch getestet und bereitgestellt werden, sodass Sie sich mehr auf das Schreiben von Code konzentrieren können und weniger auf Server.
In diesem Lernprogramm richten wir einen beliebten Continuous-Integration-Server namens Jenkins ein und synchronisieren ihn mit GitHub, sodass er jedes Mal Tests durchführt, wenn neuer Code gepusht wird. Danach erstellen wir eine Lösung, mit der dieser Code automatisch auf unseren App-Server übertragen wird, sodass keine manuelle Bereitstellung erforderlich ist.
Wir werden DigitalOcean verwenden, um schnell und einfach Cloud-basierte virtuelle private Server (VPS) für unsere App und Jenkins zu erstellen.
Hinweis: In diesem Lernprogramm wird vorausgesetzt, dass Sie über Grundkenntnisse in der Befehlszeile verfügen und auf Ihrem Computer sowohl Git als auch Node.js installiert sind.
Bevor wir etwas testen oder einsetzen können, müssen wir es tun etwas testen und implementieren. Gestatten Sie mir, Ihnen unsere freundliche Testanwendung für Lernprogramme vorzustellen, die passenderweise als "Hallo Jenkins" bezeichnet wird.
Wir werden eine einfache Node.js-App schreiben, die zu unseren Zwecken passt. Es wird nicht viel mehr tun, als nur eine Textzeile im Browser anzuzeigen, aber das ist einfach genug Funktionalität, um sicherzustellen, dass wir die kontinuierliche Integration und die kontinuierliche Bereitstellung ordnungsgemäß eingerichtet haben.
Da wir unser Projekt auf GitHub speichern, beginnen wir dort. Melden Sie sich bei Ihrem GitHub-Konto an oder erstellen Sie ein neues Repository. Nennen Sie es "Hallo-Jenkins" und geben Sie folgende Beschreibung:
Meine super Beispiel-App zum Testen von Jenkins.
Lassen Sie uns der Einfachheit halber das Repo behalten Öffentlichkeit. Gehen Sie weiter und überprüfen Sie die Initialisieren Sie dieses Repository mit einer README Option und wählen Sie die Knoten Option aus der Fügen Sie .gitignore hinzu Dropdown-Liste.
Drücke den Repository erstellen Knopf und unser Repo wird fertig sein.
Nun klonen wir unser neues Repository auf unseren lokalen Rechner und navigieren dazu:
git clone [email protected]:/hello-jenkins.git cd hallo-jenkins
So sieht die endgültige Struktur unserer App aus:
G .gitignore ├── app.js ├── package.json ├── README.md ├── Skript ├── bereitstellen test └── test └── test.js
Lassen Sie uns dies einzeln angehen. Der erste Schritt zum Erstellen einer Node.js-App ist das Erstellen einer package.json Datei. Hier ist unser
"Name": "Hallo-Jenkins", "Beschreibung": "Hallo Jenkins-Test-App", "Version": "0.0.1", "Privat": "True", "Abhängigkeiten": "Express": "3.12. 0 "," devDependencies ": " mocha ":" 1.20.1 "," Supertest ":" 0.13.0 "
Unter Abhängigkeiten wir haben hinzugefügt ausdrücken, die wir verwenden werden, um unsere Node.js-App zu erstellen. Unter devDependencies wir haben hinzugefügt Mokka und Supertest, Beides hilft uns, unsere Tests zu schreiben.
Nun das unser package.json definiert ist, installieren Sie unsere App-Abhängigkeiten, indem Sie Folgendes ausführen:
npm installieren
Es ist Zeit, unseren App-Code zu schreiben. Erstellen Sie eine Datei mit dem Namen app.js und füge folgendes hinzu:
Accentsconagua
var express = erfordern ('express'); var app = express (); app.get ('/', Funktion (req, res) res.send ('hello world');); app.listen (process.env.PORT || 5000); module.exports = App;Lassen Sie uns unsere einfache Node.js-App aufschlüsseln:
ausdrücken lib haben wir in unserer angegeben package.json.ausdrücken ein neues erstellen App. App um auf alle Anfragen zu antworten, die auf root unserer Website gerichtet sind (/) mit dem Text "Hallo Welt".App an welchem Port auf Anfragen gewartet wird (process.env.PORT bezieht sich auf die Umgebungsvariable "PORT", und wenn diese nicht vorhanden ist, wird standardmäßig Port 5000 verwendet..App verfügbar für andere Node.js-Module durch modul.exporte (dies wird später nützlich, wenn wir Tests hinzufügen).Das ist es! Unsere App ist fertig - lass es laufen:
Knoten app.js
Öffnen Sie Ihren bevorzugten Browser und navigieren Sie zu http: // localhost: 5000, und du solltest sehen Hallo Welt in all seiner glorreichen Schlichtheit sitzen.
Es ist nicht die aufregendste Test-App, aber es funktioniert! Fahren Sie fort und beenden Sie unsere Node.js-App mit Strg-C, und lass uns weitergehen.
Es ist an der Zeit, einen Test für unsere App zu schreiben. Wenn wir nichts zu testen haben, hat Jenkins nichts zu tun!
Erstellen Sie einen Ordner mit dem Namen Prüfung, und darin eine Datei mit dem Namen erstellen test.js. Fügen Sie den folgenden Code hinzu test / test.js:
var request = required ('supertest'); var app = requir ('… /app.js'); beschreiben ('GET /', function () it ('antworten mit hallo Welt', Funktion (erledigt) request (app) .get ('/'). expect ('hallo Welt', erledigt);); );Wie funktioniert unser Test? Zuerst importieren wir beide Supertest lib und unser App. Dann fügen wir einen einzelnen Test hinzu und beschreiben, was passiert, wenn a ERHALTEN Anfrage trifft die Wurzel unserer Website. Wir sagen unseren Test, um zu erwarten, dass die Antwort "Hallo Welt" ist, und wenn ja, ist der Test bestanden.
Um den Test auszuführen, verwenden wir die Mocha-Bibliothek. Wir haben Mocha als Teil unseres installiert devDependencies, Also führen wir einfach einen Befehl aus, der unsere Testdatei an Mocha übergibt, und Mocha führt unsere Tests aus:
./node_modules/.bin/mocha ./test/test.js
Wenn Sie fertig sind, sollten Sie einen grünen Punkt mit Informationen sehen, die besagen, dass ein Test bestanden wurde. Das heißt, unser Test war erfolgreich! Wenn Sie diesen Befehl jedoch immer wieder eingeben, werden sich schnell Fingerkrämpfe und Augenzucken ergeben. Lassen Sie uns also ein Hilfsskript erstellen, das für uns erledigt wird (denken Sie daran, Computer werden nicht langweilig!).
Erstellen Sie ein neues Verzeichnis mit dem Namen Skript, und darin eine Datei mit dem Namen erstellen Prüfung (Beachten Sie, dass es keine Erweiterung gibt). Fügen Sie Folgendes zu hinzu Skript / Test:
#! / bin / sh ./node_modules/.bin/mocha ./test/test.js
Dort haben wir jetzt ein Shell-Skript, um diese gnarly Zeile für uns auszuführen. Aber bevor wir es verwenden können, müssen wir ihm ausführbare Berechtigungen gewähren:
chmod + x script / test
Lass es uns testen! Lauf:
./ script / test
… Und Sie sollten den gleichen Prüfungstest wie zuvor sehen.
Okay, wir haben eine funktionierende App und einen Funktionstest, also lassen Sie uns unseren neuen Code auf GitHub übertragen:
git add. git commit -m 'Knoten-App hinzufügen' git Push-Ursprungsmaster
Und das ist es - unsere App ist fertig und auf GitHub!
Wir haben eine packende und fesselnde App ("Hallo Welt" hat eine Art Poesie, sind Sie nicht einverstanden?), Aber niemand kann es sehen! Ändern wir das und bringen wir unsere App auf einem Server zum Laufen.
Für unsere Hosting-Anforderungen wenden wir uns an DigitalOcean. DigitalOcean bietet eine schnelle und einfache Möglichkeit, VPS-Cloud-Instanzen zu aktivieren, und ist damit der perfekte Host für unseren CI / CD-Spielplatz.
Melden Sie sich bei DigitalOcean an (oder melden Sie sich an) und klicken Sie auf Droplet erstellen Taste. Nennen Sie den Hostnamen "hallo-jenkins". Die kleinste Instanz (512 MB / 1/20 GB) wird unseren Bedürfnissen entsprechen und die Ihnen am nächsten gelegene geografische Region auswählen. Als Nächstes müssen wir das Bild auswählen, das zum Erstellen des Droplets verwendet wird. DigitalOcean bietet eine große Auswahl an Betriebssystemen zur Auswahl, aber es ist wirklich schön, dass sie auch Bilder enthalten, die speziell für bestimmte Anwendungstypen angepasst sind.
Drücke den Anwendungen Registerkarte und wählen Sie die node-v0.10.29 auf Ubuntu 14.04 Option - Dadurch wird ein Server erstellt, der für unsere Node.js-App gut bootbar ist.
Klicken Sie jetzt auf Droplet erstellen, und DigitalOcean beginnt mit der Initialisierung unseres Servers.
Innerhalb einer Minute sollte unser neuer Server bereit sein, und Sie sollten eine E-Mail mit den Root-Anmeldeinformationen Ihres Servers erhalten haben. Verwenden Sie diese Informationen, um sich anzumelden:
ssh [email protected]
Sie werden aufgefordert, das in der E-Mail angegebene Kennwort einzugeben, und müssen dann sofort ein neues Kennwort erstellen (machen Sie es sehr stark und speichern Sie es an einem sicheren Ort, beispielsweise in einer KeePass-Datenbank)..
Im Moment sind wir als angemeldet Wurzel, Das ist der allmächtige Halbgott des Linux-Landes. Aber schwer ist der Kopf, der die Krone trägt und so funktioniert Wurzel ist generell eine schlechte Idee. Als erstes wollen wir einen neuen Benutzer anlegen - nennen wir es "App":
adduser app
Sie müssen ein Kennwort angeben (a anderssicheres Passwort, sicher gespeichert), und dann wird eine Reihe optionaler Fragen gestellt.
Wir möchten zu unserem wechseln App Benutzer, aber bevor wir uns ausloggen, müssen wir unseren neuen Benutzer gewähren Sudo Privilegien, so dass es administrative Aktionen ausführen kann:
Usermod -a -G Sudo App
Schließen Sie nun die Verbindung mit Ausfahrt, und dann verbinden als App:
ssh [email protected]
Sie werden aufgefordert, die App Benutzerkennwort, und dann sollten Sie angemeldet sein und loslegen.
Lassen Sie uns unsere App auf die Maschine bringen. Dank der Anwendungsabbilder von DigitalOcean werden Node.js und npm bereits vorinstalliert. Wir müssen jedoch immer noch Git installieren:
sudo apt-get install git
Sie werden aufgefordert, Ihr Passwort einzugeben (seit Sie verwenden) Sudo), und Sie müssen die Installation mit bestätigen Y. Sobald Git installiert ist, können wir unsere App von GitHub herunterladen.
Kopieren Sie die HTTPS-Klon-URL von der GitHub-Seite des Projekts und klonen Sie das Repo in Ihren Home-Ordner auf dem Server:
CD-Git Klon https://github.com//hello-jenkins.git
Jetzt befindet sich unsere App auf unserem Server in einem Ordner namens "Hallo-Jenkins". Navigieren wir dahin:
CD Hallo-Jenkins
Als erstes müssen wir die App-Abhängigkeiten installieren:
npm install --production
Sobald dies erledigt ist, können wir unsere App ausführen! Dreh es mit:
Knoten app.js
… Und navigieren Sie in Ihrem Browser zur IP-Adresse Ihres Servers.
Aber warte, es geht nicht! Was ist das Problem?
Nun, lassen Sie uns diese Codezeile in unserer app.js:
app.listen (process.env.PORT || 5000);
Im Moment haben wir keine HAFEN Umgebungsvariable festgelegt, so dass unsere App standardmäßig auf Port 5000 gesetzt ist und Sie den Port an die IP-Adresse im Browser anhängen müssen (http: //YOUR.SERVER.IP.ADDRESS: 5000).
Wie können wir also erreichen, dass unsere App wie erwartet funktioniert, ohne dass der Port angegeben werden muss? Wenn ein Browser eine HTTP-Anforderung abschickt, wird standardmäßig Port 80 verwendet. Wir müssen also nur unsere festlegen HAFEN Umgebungsvariable zu 80.
Wir setzen unsere Umgebungsvariablen in der / etc / environment Datei auf dem Server - Diese Datei wird beim Anmelden geladen, und die gesetzten Variablen stehen allen Anwendungen global zur Verfügung. Öffnen Sie die Datei:
sudo nano / etc / environment
Sie werden das jetzt sehen PFAD wird in dieser Datei festgelegt. Fügen Sie danach die folgende Zeile hinzu:
PORT = 80
Dann tippen Sie Strg-X, Y, und Eingeben zu speichern und zu beenden. Abmeldung vom Server (Ausfahrt) und SSH wieder (dies lädt die neue Umgebungsvariable).
Eine letzte kleine Aufgabe - das Ausführen einer App auf Port 80 erfordert Root-Berechtigungen, die jedoch ausgeführt werden müssen Sudo-Knoten app.js behält die von uns eingerichteten Umgebungsvariablen nicht bei. Um dies zu umgehen, werden wir es aktivieren Knoten die Fähigkeit haben, auf Port 80 Sans zu laufen Sudo:
sudo setcap cap_net_bind_service = + ep / usr / local / bin / node
Das sollte es tun. Jetzt ausführen:
Knoten app.js
Navigiere zu http: //YOUR.SERVER.IP.ADDRESS, und du wirst sehen Hallo Welt!
Derzeit läuft unsere App nur, während wir den Prozess ausführen - wenn wir sie schließen, ist unsere Website nicht mehr verfügbar. Was wir brauchen, ist ein Weg, um unsere Node.js-App im Hintergrund laufen zu lassen. Dafür verwenden wir für immer. Der erste Schritt ist die globale Installation:
sudo npm install -g für immer
Jetzt, anstatt unsere App mit zu starten Knoten app.js, wir werden verwenden:
Für immer App.js starten
Beachten Sie, dass der Prozess nicht sofort an der Ausführung hängt, sondern sofort beendet wird und Ihnen die Kontrolle zurückgegeben wird. Dies liegt daran, dass der Node.js-Server im Hintergrund ausgeführt wird. Jetzt müssen wir uns keine Gedanken darüber machen, dass sich unser Server beim Abmelden vom Server herunterfährt. für immer startet unsere App sogar automatisch neu, wenn sie abstürzt!
Um unsere App zu stoppen, können wir Folgendes ausführen:
für immer Halt
Lassen Sie uns jetzt weiterlaufen und zu Jenkins übergehen.
Wir hosten unseren Jenkins-Server auf einem separaten DigitalOcean-Droplet. Lass uns das jetzt hochdrehen.
Erstellen Sie ein neues Droplet mit dem Hostnamen "jenkins-box". Wählen 512 MB / 1/20 GB zusammen mit demselben Standort und demselben Anwendungstyp (node-v0.10.29 auf Ubuntu 14.04) wie beim vorigen Tropfen.
Klicken Droplet erstellen und sobald es fertig ist, verwenden Sie die Anmeldeinformationen, die Sie per E-Mail erhalten haben, um sich über SSH anzumelden (Sie müssen wie zuvor ein neues Kennwort festlegen)..
Wie zuvor sollten wir einen neuen Benutzer anlegen, bevor wir etwas anderes tun. Lass es uns diesmal nennen Administrator:
adduser admin usermod -a -G sudo admin
Melden Sie sich als ab Wurzel und melden Sie sich als das neu erstellte an Administrator.
Da der Zweck von Jenkins darin besteht, unser Projekt abzurufen und seine Tests auszuführen, muss auf unserer Maschine alle Abhängigkeiten des Projekts installiert sein. Wir haben diese Instanz mit der DigitalOcean-Anwendung Node.js beschleunigt, sodass Node.js und npm bereits installiert sind. Aber wir müssen Git noch installieren:
sudo apt-get install git
Als nächstes ist Jenkins. Jenkins zu installieren ist ziemlich einfach - wir haben es apt-get all das schwere anheben. Der einzige Haken ist, dass wir ein neues hinzufügen müssen geeignet Repository vor dem Start der Installation:
sudo wget -q -O - http://pkg.jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add - sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian binary /> /etc/apt/sources.list.d/jenkins.list' sudo apt-get update
Jetzt können wir Jenkins installieren:
sudo apt-get install jenkins
Sobald der Vorgang abgeschlossen ist, wird Jenkins ausgeführt und ist an Port 8080 verfügbar. Navigieren Sie in Ihrem Browser zum Jenkins-Box IP-Adresse an Port 8080 und Sie sehen die Jenkins-Landing-Page.
Drücke den Jenkins verwalten Link und dann die Plugins verwalten Verknüpfung. Wechseln Sie zu Verfügbar und suchen Sie nach der GitHub Plugin. Drücke den Installieren Kontrollkästchen und dann die Jetzt herunterladen und nach Neustart installieren Taste.
Dadurch wird die Installationssequenz eingeleitet. Das GitHub-Plugin hat mehrere Abhängigkeiten, so dass mehrere Plugins installiert werden. Überprüfen Sie am unteren Rand der Seite die Starten Sie Jenkins neu, wenn die Installation abgeschlossen ist und keine Jobs ausgeführt werden - Dadurch wird Jenkins aufgefordert, nach Abschluss der Installation einen Neustart durchzuführen.
Nach dem Neustart von Jenkins ist es Zeit, unser Projekt hinzuzufügen. Drücke den Neuer Gegenstand Taste. Verwenden Sie "hallo-jenkins" für den Elementnamen, wählen Sie aus Erstellen Sie ein Free-Style-Softwareprojekt, und klicken Sie auf die Schaltfläche mit der Bezeichnung OK.
Sobald das Projekt eingerichtet ist, befinden Sie sich auf der Einstellungsseite des Projekts. Fügen Sie die GitHub-URL unseres Projekts zum hinzu GitHub-Projekt Box:
https://github.com// Hallo-Jenkins
Als nächstes wählen Sie die Git Option unter Quellcodeverwaltung. Fügen Sie in den neu angezeigten Feldern die URL zu unserem GitHub-Projekt-Repo zum hinzu Repository-URL Feld:
https://github.com//hello-jenkins.git
Scrollen Sie etwas weiter nach unten und klicken Sie auf das Kästchen, um es zu aktivieren Erstellen Sie, wenn eine Änderung an GitHub gesendet wird. Wenn diese Option aktiviert ist, wird unser Projekt jedes Mal erstellt, wenn wir zu unserem GitHub-Repo wechseln. Natürlich brauchen wir Jenkins, um zu wissen, was zu tun ist, wenn ein Build ausgeführt wird. Drücke den Build-Schritt hinzufügen Dropdown und wählen Sie Shell ausführen. Das wird ein Befehl Dialog zur Verfügung, und was wir in diesen Dialog setzen, wird ausgeführt, wenn ein Build initiiert wird. Fügen Sie Folgendes hinzu:
npm install ./script/test
Unser Build besteht aus zwei Schritten. Zunächst werden unsere App-Abhängigkeiten installiert. Dann führt es aus ./ script / test um unsere Tests durchzuführen.
Klicken "sparen".
Um die Einrichtung der Integration abzuschließen, wechseln Sie zum GitHub-Repo und klicken Sie auf die Einstellungen. Drücke den Webhooks & Dienstleistungen Tab und dann die Dienst hinzufügen Dropdown-Liste. Wähle aus Jenkins (GitHub-Plugin) Bedienung.
Fügen Sie Folgendes als das hinzu Jenkins-Hook-URL:
http: //JENKINS.SERVER.IP.ADDRESS: 8080 / github-webhook /
Klicken Dienst hinzufügen. Unser Projekt ist jetzt bereit für den ersten kontinuierlichen Integrationstest!
Lass es uns etwas zum Testen geben. Aufmachen app.js lokal und ändern Sie diese Zeile:
res.send ('Hallo Welt');… Dazu:
res.send ('Hallo Jenkins');Speichern Sie die Änderung und übernehmen Sie sie:
git add. git commit -m 'Zu Hallo Jenkins wechseln'
Behalten Sie jetzt Jenkins im Auge, während Sie Ihre Änderungen in GitHub verschieben:
git Push Ursprungsmaster
Nach ein oder zwei Sekunden sollten Sie sehen, dass ein neuer Job für uns geschaffen wurde Hallo-Jenkins Projekt in Jenkins - unsere kontinuierliche Integration funktioniert!
Aber… der Job schlägt fehl! Warum?
Denken Sie daran, dass unser Test erwartet, dass der Root-Aufruf "Hallo Welt" zurückgibt, aber wir haben ihn in "Hallo Jenkins" geändert. Ändern wir also die Erwartungen an unseren Test. Tauschen Sie diese Zeile aus:
request (app) .get ('/'). erwarten ('Hallo Welt', fertig);… Mit dieser Zeile:
request (app) .get ('/'). erwarten ('Hallo Jenkins', erledigt);Speichern, festschreiben und erneut drücken:
git add. git commit -m 'Test test to hallo jenkins' git Push-Ursprungsmaster
Sehen Sie sich Jenkins an - wieder einmal sehen Sie, dass ein Build automatisch gestartet wird und diesmal erfolgreich ist!
Dies ist der Fluss der kontinuierlichen Integration. Der Testserver testet ständig jeden neuen Code, den Sie senden, damit Sie schnell über fehlgeschlagene Tests informiert werden.
Okay, wir testen unsere Änderungen automatisch, aber wie sieht es mit der Bereitstellung dieser Änderungen aus? Kein Problem!
Wenn Sie genau hinschauen, haben Sie ohne Zweifel bemerkt, dass in unserem Projekt bisher etwas fehlt. In der Projektstruktur zu Beginn des Tutorials gibt es eine script / deploy Datei, aber wir müssen noch eine solche Datei erstellen. Nun, jetzt werden wir!
Lassen Sie uns zunächst die Funktionsweise der Bereitstellung besprechen. Unser Skript (ausgeführt von Jenkins Erstellungsschritt) meldet sich über SSH am App-Server an, navigiert zu unserem App-Ordner, aktualisiert die App und startet den Server neu. Bevor Sie unser Implementierungsskript schreiben, müssen Sie festlegen, wie unser Jenkins-Server SSH in unseren App-Server einbinden wird.
Bisher haben wir auf unsere Server durch manuelles Eingeben von Passwörtern zugegriffen. Dieser Ansatz funktioniert jedoch nicht für automatisierte Skripts. Stattdessen erstellen wir einen SSH-Schlüssel, mit dem sich der Jenkins-Server beim App-Server authentifiziert.
Bei der Installation von Jenkins wird ein neuer Benutzer mit dem Namen erstellt Jenkins. Jenkins führt alle Befehle mit diesem Benutzer aus, daher müssen wir unseren Schlüssel mit dem generieren Jenkins Benutzer, damit er den entsprechenden Zugriff hat.
Während angemeldet als Administrator auf der Jenkins-Box, führe folgendes aus:
Sudo Su
Geben Sie Ihre Administrator Passwort, und es wird Sie auf die Wurzel Nutzer. Dann führe aus:
su jenkins
Jetzt handeln Sie als Jenkins Nutzer. Generieren Sie einen SSH-Schlüssel:
ssh-keygen -t rsa
Speichern Sie die Datei am Standardspeicherort (/var/lib/jenkins/.ssh/id_rsa), und stellen Sie sicher, dass Sie keine Passphrase verwenden (Andernfalls erfordert der SSH-Zugriff ein Kennwort und funktioniert bei Automatisierung nicht).
Als Nächstes müssen wir den erstellten öffentlichen Schlüssel kopieren. Führen Sie das aus:
cat ~ / .ssh / id_rsa.pub
… Und kopieren Sie die Ausgabe. Es sollte eine lange Zeichenfolge sein, die mit "ssh-rsa" beginnt und mit "jenkins @ jenkins-box" endet..
Abmelden von Jenkins-Box und melden Sie sich wieder bei unserem App-Server an (Hallo-Jenkins) als die App Nutzer. Wir müssen eine Datei mit dem Namen erstellen authorized_keys in unserer App Benutzer.ssh Mappe:
mkdir ~ / .ssh nano ~ / .ssh / authorised_keys
Fügen Sie den kopierten öffentlichen Schlüssel und dann ein Strg-X/Y/Eingeben zu speichern und zu beenden. Damit diese Datei ordnungsgemäß funktioniert, müssen strikte Berechtigungen festgelegt sein:
chmod 700 ~ / .ssh chmod 600 ~ / .ssh / *
Geh zurück zum Jenkins Wechseln Sie in das Feld Jenkins Benutzer und vergewissern Sie sich, dass Sie sich ohne Eingabe eines Kennworts bei unserem App-Server anmelden können:
ssh [email protected]
Sie sollten sich erfolgreich am App-Server anmelden, ohne das Kennwort eingeben zu müssen. Nach dieser Feststellung können wir uns jetzt der Bereitstellung zuwenden.
Erstellen Sie eine Datei in der Skript Ordner benannt bereitstellen (Beachten Sie, dass es keine Erweiterung gibt). Fügen Sie Folgendes zu hinzu script / deploy:
#! / bin / sh ssh [email protected] <Gehen wir das durch:
- Zuerst loggen wir uns als
AppNutzer.- Dann navigieren wir in unseren App-Ordner und aktualisieren auf die neueste Version von GitHub.
- Danach installieren wir unsere Abhängigkeiten.
- Sobald unser App-Code aktualisiert wurde, starten wir unseren Server erneut mit
für immer neu starten.Machen Sie unsere neue Skriptdatei ausführbar:
chmod + x script / deployFügen Sie diese neue Datei hinzu und bestätigen Sie sie:
git add. git commit -m 'Implementierungsskript hinzufügen'Aber lass uns noch nicht drängen. Gehen Sie zuerst zu unserer Projektkonfiguration in Jenkins und scrollen Sie zum Build-Befehl. Fügen Sie diese neue Zeile am Ende hinzu:
./ script / deploySpeichern Sie das Jenkins-Projekt.
Fahren Sie jetzt mit GitHub fort und schauen Sie zu, wie Jenkins automatisch baut. Sobald der Build abgeschlossen ist (sollte erfolgreich sein), navigieren Sie mit Ihrem Browser zur IP-Adresse unseres App-Servers. Presto! Unsere aufregende "Hallo Welt" wurde durch ein aufregendes "Hallo Jenkins" ersetzt.!
Unsere App wird jetzt kontinuierlich eingesetzt!
Alles gut, das automatisiert sich gut
Puh. Das war ziemlich die Fahrt!
Am Ende haben wir beide kontinuierliche Integration erfolgreich eingerichtet und kontinuierliche Bereitstellung, die einen sehr guten Automatisierungsgrad in unserem täglichen Entwicklerleben ermöglicht. Denken Sie daran, dass Computer nicht langweilig werden. Während sie das Testen und Bereitstellen durchführen, können Sie wichtige Dinge erledigen, beispielsweise sich selbst ein Sandwich machen. Also mache dieses Sandwich und esse es wie ein Automatisierungschampion!
