Share
Het dagelijkse leven van een ontwikkelaar is gevuld met monotone en repetitieve taken. Gelukkig leven we in een pre-artificial intelligence-tijdperk, wat betekent dat computers geweldig zijn in het omgaan met saaie klusjes en ze nauwelijks ooit klagen erover! Dus laten we wat automatisering instellen om onze dagelijkse sleur een beetje minder grindig te maken.
Testen en inzetten zijn twee integrale elementen van webontwikkeling. Als er enige automatisering wordt ingemengd, worden dit oplossingen die gewoonlijk "continuous integration" (CI) en "continuous deployment" (CD) worden genoemd. Het "continue" aspect van deze oplossingen betekent dat uw projecten automatisch worden getest en geïmplementeerd, zodat u zich meer kunt richten op het schrijven van code en minder op het aanschaffen ervan op servers.
In deze zelfstudie zullen we een populaire continue integratieserver met de naam Jenkins opzetten en deze met GitHub synchroniseren, zodat deze elke keer dat nieuwe code wordt gepusht, tests uitvoert. Daarna maken we een oplossing om die code automatisch naar onze app-server te pushen, waardoor we niet meer handmatig hoeven in te zetten.
We zullen DigitalOcean gebruiken om snel en eenvoudig cloud-gebaseerde virtual private servers (VPS's) te maken om onze app en Jenkins te hosten.
Opmerking: in deze zelfstudie wordt ervan uitgegaan dat u een basiskennis hebt van het werken op de opdrachtregel en dat op uw machine zowel Git als Node.js is geïnstalleerd.
Voordat we iets kunnen testen of implementeren, hebben we dat nodig iets testen en implementeren. Sta mij toe u kennis te laten maken met onze vriendelijke tutorial-test-app, toepasselijk genaamd "hallo-jenkins."
We gaan een eenvoudige Node.js-app schrijven die geschikt is voor onze doeleinden. Het zal niet veel meer doen dan een regel tekst weergeven in de browser, maar dat is net voldoende functionaliteit om ervoor te zorgen dat we een doorlopende integratie en continue implementatie goed hebben ingesteld.
Omdat we ons project op GitHub zullen opslaan, laten we daar beginnen. Log in op (of creëer) je GitHub-account en maak een nieuwe repository aan. Noem het "hallo-jenkins" en geef het de volgende beschrijving:
Mijn superstalen app om Jenkins uit te testen.
Laten we voor de eenvoud de repo behouden Openbaar. Ga je gang en controleer de Initialiseer deze repository met een README optie en selecteer de Knooppunt optie van de Voeg .gitignore toe keuzelijst.
Klik op de Maak een repository knop, en onze repo is klaar.
Laten we nu onze nieuwe repository naar onze lokale computer klonen en er naartoe navigeren:
git clone [email protected]:/hello-jenkins.git cd hello-jenkins
Dit is wat de uiteindelijke structuur van onze app zal zijn:
├── .gitignore ├── app.js ├── package.json ├── README.md ├── script │ ├── deploy │ └── test └── test └── test.js
Laten we dit een voor een aanpakken. De eerste stap bij het bouwen van een Node.js-app is het maken van een package.json het dossier. Hier is de onze:
"name": "hello-jenkins", "description": "hello jenkins test app", "version": "0.0.1", "private": true, "dependencies": "express": "3.12. 0 "," devDependencies ": " mokka ":" 1.20.1 "," supertest ":" 0.13.0 "
Onder afhankelijkheden we hebben toegevoegd uitdrukken, die we zullen gebruiken om onze Node.js-app te maken. Onder devDependencies we hebben toegevoegd mokka en Supertest, beide zullen ons helpen onze tests te schrijven.
Nu dat onze package.json is gedefinieerd, installeer onze app-afhankelijkheden door het uitvoeren van:
npm installeren
Het is tijd om onze app-code te schrijven. Maak een bestand met de naam app.js en voeg het volgende toe:
Accentsconagua
var express = require ('express'); var app = express (); app.get ('/', functie (req, res) res.send ('hallo wereld');); app.listen (process.enVINGPORT || 5000); module.exports = app;Laten we onze eenvoudige Node.js-app analyseren:
uitdrukken lib hebben we in onze package.json.uitdrukken om een nieuw te maken app. app om te reageren op alle verzoeken die de root van onze site raken (/) met de tekst "Hallo wereld."app op welke poort om te luisteren naar verzoeken (process.env.PORT verwijst naar de omgevingsvariabele genaamd "PORT", en als deze niet bestaat, zullen we in plaats daarvan standaard naar poort 5000 gaan).app beschikbaar voor andere Node.js-modules module.exports (dit zal later van pas komen als we tests toevoegen).Dat is het! Onze app is klaar - laten we het uitvoeren:
knooppunt app.js
Open uw favoriete browser en ga naar http: // localhost: 5000, en je zou het moeten zien Hallo Wereld zittend in al zijn glorieuze eenvoud.
Het is niet de meest opwindende test-app, maar het werkt! Ga je gang en sluit onze Node.js-app af met Ctrl-C, en laten we verder gaan.
Het is tijd om een test voor onze app te schrijven. Immers, als we niets te testen hebben, dan heeft Jenkins niets te doen!
Maak een map met de naam test, en maak hierin een bestand met de naam test.js. Voeg de volgende code toe aan test / test.js:
var request = require ('supertest'); var app = require ('... /app.js'); beschrijven ('GET /', functie () it ('reageer met Hello World', functie (gereed) request (app) .get ('/'). expect ('Hello World', done);); );Hoe werkt onze test? Eerst importeren we beide Supertest lib en onze app. Vervolgens voegen we een enkele test toe, waarin wordt beschreven wat er moet gebeuren als een KRIJGEN aanvraag treft de root van onze site. We vertellen onze test om te verwachten dat de reactie "hallo wereld" is en als dat zo is, gaat de test voorbij.
Om de test uit te voeren, gebruiken we de Mocha-bibliotheek. We hebben Mocha geïnstalleerd als onderdeel van onze devDependencies, dus we zullen gewoon een commando uitvoeren dat ons testbestand doorgeeft aan Mocha en Mocha voert onze testen uit:
./node_modules/.bin/mocha ./test/test.js
Als u klaar bent, ziet u een groene stip en informatie die zegt dat één test is geslaagd. Dat betekent dat onze test succesvol was! Maar als je dat commando steeds opnieuw typt, krijg je binnenkort krampen en oogkrampen, dus laten we een helper-script maken om het voor ons te doen (vergeet niet dat computers zich niet vervelen!).
Maak een nieuwe map genaamd script, en maak hierin een bestand met de naam test (let op dat er geen extensie is). Voeg het volgende toe aan script / test:
#! / bin / sh ./node_modules/.bin/mocha ./test/test.js
Daar - nu hebben we een shellscript om die gnarly regel voor ons uit te voeren. Maar voordat we het kunnen gebruiken, moeten we het uitvoerbare rechten verlenen:
chmod + x script / test
Laten we het testen! Rennen:
./ Script / test
... en je zou dezelfde voorbijgaande test als voorheen moeten zien.
Oké, we hebben een werkende app en een werktest, dus laten we onze nieuwe code pushen naar GitHub:
git add. git commit -m 'Add node app' git push origin master
En dat is het - onze app is klaar en op GitHub!
We hebben een boeiende en boeiende app ('Hallo wereld' heeft een soort van poëzie, vind je niet?), Maar niemand kan het zien! Laten we daar verandering in brengen en onze app op een server laten draaien.
Voor onze hostingbehoeften wenden we ons tot DigitalOcean. DigitalOcean biedt een snelle en eenvoudige manier om VPS-cloudinstanties te laten draaien, waardoor het de perfecte host is voor onze CI / CD-speelplaats.
Log in op (of meld je aan voor) DigitalOcean en klik op de Maak druppel knop. Voor de hostnaam, noem het "hallo-jenkins". De instantie met de laagste grootte (512/1 / 20GB) voldoet aan onze behoeften en selecteert de geografische regio die het dichtst bij u in de buurt ligt. Vervolgens moeten we de afbeelding kiezen die is gebruikt om de druppel te maken. DigitalOcean biedt een ruime keuze aan besturingssystemen om uit te kiezen, maar wat echt heel leuk is, is dat ze ook afbeeldingen bieden die specifiek zijn afgestemd op bepaalde soorten toepassingen.
Klik op de toepassingen tab en selecteer de node-v0.10.29 op Ubuntu 14.04 optie - dit zal een server creëren die netjes is opgestart voor onze Node.js-app.
Klik nu Maak druppel, en DigitalOcean begint met het initialiseren van onze server.
Binnen een minuut zou onze nieuwe server klaar moeten zijn en zou u een e-mail moeten hebben ontvangen met de rootreferenties van uw server. Laten we die info gebruiken om in te loggen:
ssh [email protected]
U wordt gevraagd naar het wachtwoord in de e-mail en vervolgens onmiddellijk gedwongen om een nieuw wachtwoord te maken (maak het iets heel sterks en bewaar het op een veilige locatie, zoals een KeePass-database).
Op dit moment zijn we ingelogd als wortel, dat is de almachtige halfgod van Linuxland. Maar zwaar is het hoofd dat de kroon draagt en opereert zoals wortel is over het algemeen een slecht idee. Dus het eerste wat we willen doen is een nieuwe gebruiker maken - laten we het "app" noemen:
adduser-app
U moet een wachtwoord opgeven (a verschillendsterk wachtwoord, veilig opgeslagen) en dan zal het een reeks optionele vragen stellen.
We willen overschakelen naar onze app gebruiker, maar voordat we uitloggen, moeten we onze nieuwe gebruiker toestaan sudo privileges, zodat het de mogelijkheid heeft om administratieve acties uit te voeren:
usermod -a -G sudo app
Sluit nu de verbinding met Uitgang, en dan verbinden als app:
ssh [email protected]
U wordt gevraagd voor de app gebruikerswachtwoord, en dan zou je ingelogd moeten zijn en goed om te gaan.
Laten we onze app op de machine zetten. Dankzij de applicatie-images van DigitalOcean wordt onze machine geleverd met Node.js en npm vooraf geïnstalleerd, maar we moeten Git nog steeds installeren:
sudo apt-get install git
U wordt om uw wachtwoord gevraagd (aangezien u gebruikt sudo) en u zult de installatie moeten bevestigen met Y. Zodra Git is geïnstalleerd, kunnen we het gebruiken om onze app van GitHub te krijgen.
Kopieer de HTTPS-kloon-URL van de GitHub-pagina van het project en klop de repository vervolgens naar uw thuismap op de server:
cd git clone https://github.com//hello-jenkins.git
Nu staat onze app op onze server, in een map genaamd "hello-jenkins." Laten we daarin navigeren:
cd hello-jenkins
Het eerste wat we moeten doen is de app-afhankelijkheden installeren:
npm install - productie
Zodra dat is gebeurd, kunnen we onze app gebruiken! Draai het om met:
knooppunt app.js
... en navigeer naar het IP-adres van uw server in uw browser.
Maar wacht, het werkt niet! Wat is er aan de hand?
Laten we deze code herhalen in onze app.js:
app.listen (process.enVINGPORT || 5000);
Op dit moment hebben we geen HAVEN omgevingsvariabele ingesteld, dus onze app gaat standaard naar poort 5000 en u moet de poort toevoegen aan het IP-adres in de browser (http: //YOUR.SERVER.IP.ADDRESS: 5000).
Dus hoe zorgen we ervoor dat onze app werkt zoals verwacht, zonder de poort op te geven? Welnu, wanneer een browser een HTTP-verzoek doet, is deze standaard ingesteld op poort 80. We moeten dus alleen onze instellen HAVEN omgevingsvariabele naar 80.
We zullen onze omgevingsvariabelen in de / Etc / environment bestand op de server - dit bestand wordt geladen bij inloggen en de ingestelde variabelen zullen globaal beschikbaar zijn voor alle applicaties. Open het bestand:
sudo nano / etc / environment
Dat zie je nu meteen PAD wordt ingesteld in dit bestand. Voeg de volgende regel erna toe:
PORT = 80
Typ dan Ctrl-X, Y, en invoeren opslaan en afsluiten. Uitloggen van de server (Uitgang) en SSH terug in (hierdoor wordt de nieuwe omgevingsvariabele geladen).
Nog een klein klusje - een app uitvoeren op poort 80 vereist rootprivileges, maar het uitvoeren ervan sudo node app.js zal de omgevingsvariabelen die we hebben ingesteld niet bewaren. Om dit te omzeilen, zullen we inschakelen knooppunt om de mogelijkheid te hebben om te draaien op poort 80 zonder sudo:
sudo setcap cap_net_bind_service = + ep / usr / local / bin / node
Dat zou het moeten doen. Nu uitvoeren:
knooppunt app.js
Navigeren naar http: //YOUR.SERVER.IP.ADDRESS, en je zult het zien Hallo Wereld!
Op dit moment wordt onze app alleen uitgevoerd terwijl we het proces uitvoeren. Als we het afsluiten, is onze site niet langer beschikbaar. Wat we nodig hebben, is een manier om onze Node.js-app op de achtergrond te houden. Daar zullen we voor altijd gebruik van maken. De eerste stap is om het wereldwijd te installeren:
sudo npm install -g voor altijd
Nu, in plaats van onze app te starten met knooppunt app.js, we zullen gebruiken:
start voor altijd app.js
Merk op dat in plaats van dat het proces vastloopt bij uitvoering, het onmiddellijk wordt afgesloten en u de controle weergeeft. Dit komt omdat de Node.js-server op de achtergrond wordt uitgevoerd. Nu hoeven we ons geen zorgen te maken dat onze server wordt afgesloten wanneer we uitloggen van de server. voor altijd zal onze app zelfs automatisch opnieuw starten als deze toevallig crasht!
Om onze app te stoppen, kunnen we het volgende uitvoeren:
voor altijd stop
Laten we het voorlopig draaien en verdergaan naar Jenkins.
We zullen onze Jenkins-server hosten op een aparte druppel DigitalOcean. Laten we dat nu op gang brengen.
Maak een nieuwe droplet met de hostnaam "jenkins-box". Kiezen 512/1 / 20GB nogmaals, samen met dezelfde locatie en hetzelfde applicatietype (node-v0.10.29 op Ubuntu 14.04) zoals bij de vorige druppel.
Klik Maak druppel en als het eenmaal klaar is, gebruik dan de inloggegevens die u per e-mail hebt ontvangen om in te loggen via SSH (u zult een nieuw wachtwoord moeten instellen, net als voorheen).
Zoals eerder, moeten we een nieuwe gebruiker maken voordat we iets anders doen. Laten we het deze keer noemen beheerder:
adduser admin usermod -a -G sudo admin
Meld u af als wortel en log in als het nieuw gecreëerde beheerder.
Omdat het doel van Jenkins is om ons project op te halen en de tests uit te voeren, moet onze machine alle afhankelijkheden van het project hebben geïnstalleerd. We hebben dit exemplaar gecentrifugeerd met de Node.js-toepassing van DigitalOcean, dus Node.js en npm zijn al geïnstalleerd. Maar we moeten Git nog steeds installeren:
sudo apt-get install git
De volgende is Jenkins. Jenkins installeren is vrij eenvoudig - we zullen hebben apt-get doe al het zware werk. De enige vangst is dat we een nieuwe moeten toevoegen geneigd repository voor het starten van de installatie:
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
Nu kunnen we Jenkins installeren:
sudo apt-get install jenkins
Eenmaal voltooid, zal Jenkins worden uitgevoerd en beschikbaar zijn op poort 8080. Navigeer in uw browser naar de jenkins-box IP-adres op poort 8080 en je ziet de Jenkins-bestemmingspagina.
Klik op de Beheer Jenkins link en vervolgens de Beheer plug-ins link. Schakel over naar de Beschikbaar tab en zoek naar de GitHub-plug-in. Klik op de Installeren selectievakje en vervolgens de Download nu en installeer na opnieuw opstarten knop.
Hiermee start u de installatievolgorde. De GitHub-plug-in heeft verschillende afhankelijkheden, dus er zullen meerdere plug-ins worden geïnstalleerd. Onderaan de pagina vinkt u het selectievakje aan Start Jenkins opnieuw op wanneer de installatie is voltooid en er geen taken worden uitgevoerd - dit zal Jenkins ertoe aanzetten om opnieuw te starten zodra de installaties voltooid zijn.
Nadat Jenkins opnieuw is opgestart, is het tijd om ons project toe te voegen. Klik op de Nieuw item knop. Gebruik "hello-jenkins" voor de itemnaam, selecteer Bouw een free-style softwareproject, en klik op de knop met het label OK.
Zodra het project is ingesteld, bevindt u zich op de pagina met projectinstellingen. Voeg de GitHub-URL van ons project toe aan de GitHub-project doos:
https://github.com// Hello-Jenkins
Selecteer vervolgens de Git optie onder Broncodebeheer. Voeg in de nieuw verschenen velden de URL toe aan onze GitHub-projectrepo naar de Repository-URL veld:
https://github.com//hello-jenkins.git
Scroll iets verder naar beneden en klik op het vakje om in te schakelen Build wanneer een verandering naar GitHub wordt gepusht. Als deze optie is ingeschakeld, wordt ons project elke keer dat we naar onze GitHub-repo pushen, gemaakt. Natuurlijk hebben we Jenkins nodig om te weten wat hij moet doen als hij een build uitvoert. Klik op de Voeg de buildstap toe drop-down en selecteer Shell uitvoeren. Dit zal een maken Commando dialoog beschikbaar, en wat we in deze dialoog plaatsen zal worden uitgevoerd wanneer een build wordt gestart. Voeg het volgende toe:
npm install ./script/test
Onze build bestaat uit twee stappen. Ten eerste worden onze app-afhankelijkheden geïnstalleerd. Daarna wordt het uitgevoerd ./ Script / test om onze testen uit te voeren.
Klik "Opslaan".
Om het instellen van de integratie te voltooien, gaat u naar de GitHub-repo en klikt u op instellingen. Klik op de Webhooks & Services tab en vervolgens de Service toevoegen laten vallen. Selecteer de Jenkins (GitHub-plug-in) service.
Voeg het volgende toe als de Jenkins hook-URL:
http: //JENKINS.SERVER.IP.ADDRESS: 8080 / GitHub-webhook /
Klik Service toevoegen. Ons project is nu klaar voor de eerste doorlopende integratietest!
Laten we het iets geven om te testen. Doe open app.js lokaal en verander deze regel:
res.send ('hallo wereld');... dit:
res.send ('hallo jenkins');Sla de wijziging op en commit het:
git add. git commit -m 'Schakel over naar hallo jenkins'
Houd Jenkins nu in de gaten terwijl je je wijzigingen naar GitHub pusht:
git push origin master
Na een seconde of twee moet u zien dat er een nieuwe taak is gestart voor onze hello-jenkins project in Jenkins - onze continue integratie werkt!
Maar ... het werk mislukt! Waarom?
Wel, onthoud dat onze test verwacht dat de roep om "Hello World" terug te keren, maar we hebben het veranderd in "Hallo Jenkins". Dus laten we de verwachtingen van onze test veranderen. Wissel deze regel:
request (app) .get ('/'). expect ('Hello World', done);... met deze regel:
request (app) .get ('/'). expect ('hallo jenkins', klaar);Opslaan, vastleggen en opnieuw pushen:
git add. git commit -m 'Wissel test naar hello jenkins' git push origin master
Bekijk Jenkins - je ziet opnieuw dat een build automatisch wordt gestart en deze keer is het gelukt!
Dit is de stroom van continue integratie. De testserver test voortdurend elke nieuwe code die u pusht, zodat u snel op de hoogte bent van eventuele falende tests.
Oké, dus we testen onze wijzigingen automatisch, maar hoe zit het met het implementeren van die wijzigingen? Geen probleem!
Als je goed hebt gevolgd, heb je ongetwijfeld gemerkt dat er tot nu toe iets ontbreekt in ons project. In de projectstructuur aan het begin van de tutorial bestaat er een script / deploy bestand, maar we moeten zo'n bestand nog maken. Welnu, nu zullen we dat doen!
Maar laten we eerst eens bespreken hoe de implementatie werkt. Ons script (uitgevoerd door de buildstap van Jenkin) logt via SSH in op de app-server, navigeert naar onze app-map, werkt de app bij en start de server opnieuw. Voordat we ons implementatiescript schrijven, moeten we afrekenen hoe onze Jenkins-server SSH zal worden in onze app-server.
Tot nu toe hebben we toegang tot onze servers gekregen door handmatig wachtwoorden in te voeren, maar deze aanpak zal niet werken voor geautomatiseerde scripts. In plaats daarvan maken we een SSH-sleutel die de Jenkins-server gebruikt om zichzelf te verifiëren bij de app-server.
Wanneer Jenkins wordt geïnstalleerd, wordt een nieuwe gebelde gebruiker gemaakt jenkins. Jenkins voert alle opdrachten met deze gebruiker uit, dus we moeten onze sleutel genereren met de jenkins gebruiker zodat deze de juiste toegang heeft.
Terwijl ingelogd als beheerder op de jenkins-box, voer het volgende uit:
sudo su
Geef uw beheerder wachtwoord, en het zal u naar de schakelen wortel gebruiker. Voer vervolgens uit:
su jenkins
Nu gedraag je je als de jenkins gebruiker. Genereer een SSH-sleutel:
ssh-keygen -t rsa
Sla het bestand op de standaardlocatie op (/var/lib/jenkins/.ssh/id_rsa), en zorg ervoor geen wachtwoordzin te gebruiken (anders vereist SSH-toegang een wachtwoord en werkt het niet als het wordt geautomatiseerd).
Vervolgens moeten we de openbare sleutel kopiëren die is gemaakt. Voer dit uit:
cat ~ / .ssh / id_rsa.pub
... en kopieer de uitvoer. Het zou een lange string moeten zijn beginnend met "ssh-rsa" en eindigend met "jenkins @ jenkins-box".
Uitloggen jenkins-box en log opnieuw in op onze app-server (hello-jenkins) als de app gebruiker. We moeten een bestand met de naam maken authorized_keys in onze app gebruiker.ssh map:
mkdir ~ / .ssh nano ~ / .ssh / authorized_keys
Plak de openbare sleutel die u hebt gekopieerd en vervolgens Ctrl-X/Y/invoeren opslaan en afsluiten. Om ervoor te zorgen dat dit bestand correct werkt, moeten er strikte rechten op zijn ingesteld:
chmod 700 ~ / .ssh chmod 600 ~ / .ssh / *
Ga terug naar de jenkins box, schakel over naar jenkins gebruiker en controleer of u zich bij onze app-server kunt aanmelden zonder een wachtwoord in te voeren:
ssh [email protected]
U moet zich met succes aanmelden bij de app-server zonder het wachtwoord in te voeren. Als dat is vastgesteld, kunnen we ons nu wenden tot inzet.
Maak een bestand in de script map met de naam inzetten (let op dat er geen extensie is). Voeg het volgende toe aan script / deploy:
#! / bin / sh ssh [email protected] <Laten we dit eens doorlopen:
- Eerst loggen we in op de app-server als de
appgebruiker.- Vervolgens navigeren we naar onze app-map en werken we bij naar de nieuwste versie van GitHub.
- Daarna installeren we onze afhankelijkheden.
- Eindelijk, wanneer onze app-code is bijgewerkt, starten we onze server opnieuw op
voor altijd herstart.Maak ons nieuwe uitvoerbare scriptbestand:
chmod + x script / deployVoeg dit nieuwe bestand toe en maak het vast:
git add. git commit -m 'Add deploy script'Maar laten we niet helemaal pushen. Ga eerst terug naar onze projectconfiguratie in Jenkins en scrol omlaag naar de opdracht build. Voeg deze nieuwe regel aan het einde toe:
./ Script / implementerenRed het Jenkins-project.
Ga nu door en druk op GitHub en kijk hoe Jenkins automatisch bouwt. Zodra de build is voltooid (het zou moeten lukken), navigeert u uw browser naar het IP-adres van onze app-server. Presto! Onze opwindende "Hallo wereld" is vervangen door een opwindende "Hallo Jenkins"!
Onze app wordt nu continu ingezet!
Alles is goed dat automatiseert goed
Oef. Dat was best de rit!
Uiteindelijk hebben we met succes beide continue integratie opgezet en continue implementatie, wat een zeer mooi niveau van automatisering biedt in het leven van onze dagelijkse ontwikkelaars. Vergeet niet dat computers zich niet vervelen, dus terwijl ze met testen en implementeren bezig zijn, ben je vrij om belangrijke dingen te doen, zoals jezelf een broodje maken. Dus ga die boterham maken en eet het als een automaker-kampioen!
