Kontinuerlig integration med Jenkins

Ser jeg tilbage på, hvordan software blev bygget og implementeret selv for 15 år siden, ser det ud til at være overraskende, at vores applikationer faktisk fungerede. I disse dage bestod en softwareudviklingslivscyklus af at køre builds på en lokal maskine, manuelt kopiere artefakterne til en staging-server og manuelt teste hver applikation gennem flere iterationer. Når dev-teamet var tilfreds med buildet, implementerede vi applikationen manuelt i produktion. Det mest konsekvente ved denne udviklingsstil var inkonsekvens - i proces og i resultater.

For over et årti siden begyndte agile udviklere at omfavne og fremme testdrevet udvikling og kontinuerlig integration (CI). Med disse teknikker kunne vi automatisk oprette kildekode, hver gang en udvikler tjekkede den i et kildelager og udførte en udtømmende enhedstestsuite for at sikre, at et program fungerede korrekt. Mange testdrevne udviklere begyndte også at foretage integrationstest og performance-test i en sekundær CI-proces.

Med kontinuerlig integration kunne vi registrere fejl hurtigere og frigive kode meget hurtigere, end vi havde gjort i tidligere år. Det er ingen overdrivelse at sige, at CI tæmmet "build" -siden af build-and-deploy-cyklussen. Disse dage er mange dev-hold flyttet ud over CI til CD, hvilket står for enten kontinuerlig levering eller kontinuerlig implementering. Uanset betegnelse er CD en proces, der flytter software fra kodeindtjekning til iscenesættelse eller endda produktionsinstallationer.

Denne rate af Open source Java-projekter introducerer kontinuerlig integration med Jenkins, en førende automatiseringsserver til CI / CD. Vi begynder med en oversigt over CI- og CD-processen og konfigurerer derefter et Java-webprojekt ved hjælp af Maven og Jenkins. Du lærer, hvordan du bygger og enhedstest projektet i Jenkins med JUnit, samt hvordan du foretager fejlfinding af byggefejl. Du installerer og kører også en håndfuld populære Jenkins-plugins til test og rapportering af statisk kodeanalyse.

Introduktion til CI / CD

I en kontinuerlig integrationsproces kan kode, der er kontrolleret i et kildekodedepot, automatisk tjekkes ud, bygges, testes på en række forskellige måder og offentliggøres til et arkiv. For at kontinuerlig integration skal fungere, har du brug for en CI-server som Jenkins, som er i stand til at overvåge dit kildekodelager for nye ændringer og reagere på konfigurerbare måder.

Tag et Java-program bygget med Maven som et eksempel. Ved registrering af kodeændringer kan din CI-server reagere ved at udføre en mvn ren installation. I en typisk Maven-buildkonfiguration udførte den et nyt sæt enhedstests som en del af build-kommandoen. Mens kildekoden blev bygget, kunne serveren udføre et vilkårligt antal yderligere handlinger:

Flet din funktionsgren tilbage til din hoved- eller hovedfilial, når den forpligtede kode bestod enhedstesten.
Udfør statisk kodeanalyse, såsom kodedækning, kodekompleksitet, kontrol af almindelige fejl osv.
Udgiv dine build-artefakter til et lager, såsom Artifactory eller Sonatype Nexus
Distribuer din applikation til et integrationstestmiljø
Udfør integrationstest
Distribuer din applikation til et præstationstestmiljø
Udfør en belastningstest mod din applikation
Distribuer din ansøgning til et UAT (User Acceptance Testing Environment)
Implementér din applikation til produktion

Disse trin er alle typer aktiviteter, som du muligvis udfører som en del af en CI / CD-proces. CI omfatter typisk bygnings- og testfaserne i udviklingslivscyklussen, mens CD udvider denne proces til at implementere en build-artefakt til en server til test. I nogle miljøer går CD hele vejen til produktion.

Kontinuerlig integration udføres typisk ved hjælp af et værktøj som Jenkins, Bamboo eller TeamCity, som orkestrerer dine byggetrin til en integrationspipeline. Jenkins er sandsynligvis det mest populære CI / CD-produkt, og det passer godt sammen med Docker.

Download og installer Jenkins

Jenkins er en kontinuerlig integrationsserver og mere. Den består af en automatiseringsmotor og et plugin-økosystem, der understøtter kontinuerlig integration, automatiseret test og kontinuerlig levering. Du tilpasser leveringsrørledningen afhængigt af dit behov.

Der er mange måder at køre Jenkins på:

Download en WAR-fil og installer den på en servletbeholder på din lokale computer.
Opsæt en virtuel maskine i en offentlig sky som AWS og vær Jenkins der.
Udnyt en Jenkins cloud-udbyder såsom CloudBees.
Opsæt Jenkins i en testinstallation ved hjælp af Docker.

Jeg viser dig, hvordan du opsætter både den lokale installation og Docker-testinstallationen.

Download og installer Jenkins lokalt

Start med at downloade Jenkins og vælge frigivelsen Long-Term Support (LTS) fra Jenkins-hjemmesiden. Fordi jeg er på en Mac, downloadede installationen automatisk a pkg fil, som placerede en jenkins.war i min Ansøgning / Jenkins folder. WAR-filen kan distribueres til enhver servletcontainer.

Du vil også gerne downloade og installere Apache Tomcat. I skrivende stund er den nyeste version af Tomcat 8.5.4, men du skal kunne køre enhver nyere version. Download lynlås eller tar.gz fil og dekomprimerer den til din harddisk. Kopier jenkins.war-filen til Tomcats webapps mappen, og kør derefter bin / startup.sh eller bin / startup.bat fil. Du kan teste, at den kører ved at åbne din browser til: // localhost: 8080.

For at starte Jenkins skal du åbne en browser til URL: // localhost: 8080 / jenkins.

Du skal få en skærm, der ligner figur 1.

Steven Haines

Dernæst opretter Jenkins et administrationsadgangskode og skriver det begge til Tomcats logs / catalina.out logfil og til følgende hjemmekatalog: .jenkins / secrets / initialAdminPassword. Hent adgangskoden, indtast den i formularelementet Administrationskode (vist i figur 1), og tryk på Blive ved. Du bliver bedt om enten at installere foreslåede plugins eller vælge plugins, der skal installeres. Indtil videre anbefaler jeg at installere de foreslåede plugins.

Nu bliver du bedt om at oprette en administratorbruger. Indtast dine administratorbrugeroplysninger, og tryk på Gem og afslut. Til sidst skal du klikke på Begynd at bruge Jenkins. Du får nu vist Jenkins-hjemmesiden, som vist i figur 2.

Steven Haines

Konfigurer eksempelappen med Maven

Inden vi kan bruge Jenkins til at oprette et Java-webprojekt med Maven, skal vi opsætte begge disse teknologier. Under emhættet vil Jenkins tjekke kildekode fra et kildekodelager til en lokal mappe og udføre de Maven-mål, du angiver. For at det skal fungere, skal du installere en eller flere versioner af Maven, fortælle Jenkins, hvor de er installeret, og konfigurer den version af Maven, som du vil have Jenkins til at bruge, når du bygger din applikation.

Klik på på Jenkins-dashboardet Administrer Jenkins og vælg Global værktøjskonfiguration. Den første ting, vi gør, er at konfigurere en JDK. Klik på under JDK-sektionen Tilføj JDK, giv det et navn (min er "JDK8"), og lad standardindstillingen være Installer fra java.sun.com afkrydset. Accepter Oracle-licensaftalen, og klik derefter på linket "Indtast dit brugernavn / din adgangskode". Indtast dit Oracle-brugernavn og din adgangskode, og tryk på Tæt. Du får en skærm svarende til figur 3.

Steven Haines

Klik på ansøge for at gemme dit arbejde, rul derefter ned til sektionen Maven og klik på Tilføj Maven. Indtast et navn til Maven (min er "Maven 3.3.9"), lad "Installer automatisk" og "Installer fra Apache" være markeret. Klik på Gemme når du er klar. Du skal præsenteres for en skærm svarende til figur 4.

Steven Haines

Git kommer forudkonfigureret med Jenkins, så du skal nu have alle de værktøjer installeret, som du har brug for til checkout og opbygge et Java-projekt fra Git med Maven.

Installer Jenkins i en Docker-container

Hvis du ikke vil installere Jenkins på din lokale maskine, har du mulighed for at køre den i en Docker-container. Det officielle Jenkins Docker-billede lader dig køre og teste en installation af Jenkins uden faktisk at konfigurere det på en lokal maskine.

Installation af Docker

Se min introduktion til Docker for en begyndervejledning til Docker, inklusive installations- og installationsinstruktioner.

Forudsat at du allerede har Docker-opsætning i dit udviklingsmiljø, kan du starte Jenkins fra Docker kommandolinjen:

 docker køre -p 8080: 8080 -p 50000: 50000 -v / dit / hjem / jenkins: / var / jenkins_home -d jenkins

Denne kommando fortæller Docker at køre den seneste udgave af jenkins med følgende muligheder:

-p 8080: 8080: Kort port 8080 på Docker-containeren til port 8080 på Docker-værten, så du kan oprette forbindelse til Jenkins-webappen på port 8080.
-p 50000: 50000: Tilknytter port 50000 på Docker-containeren til port 50000 på Docker-værten. Jenkins bruger denne port internt til at tillade build slave-eksekutører at oprette forbindelse til master Jenkins-serveren.
-v / dit / hjem / jenkins: / var / jenkins_home: Kortlægger Jenkins-datalagring til dit lokale bibliotek, så du kan genstarte din Docker-container uden at miste dine data.
-d: Giver dig mulighed for at køre Docker-containeren i en løsrevet tilstand eller som en dæmonproces.

Følgende viser output til kørsel af disse kommandoer:

 $ docker run -p 8000: 8080 -v / Brugere / shaines / jenkins /: / var / jenkins_home -d jenkins cc16573ce71ae424d4122e9e4afd3a294fda6606e0333838fe332fc4e11d0d53

Fordi vi kører vores Docker-container i løsrevet tilstand, er vi nødt til at følge de logfiler, der udføres af Jenkins. Du kan gøre det med docker-logfiler -f kommando. Indsend bare de første par hexadecimale tal i container-ID'et, i dette tilfælde cc16573ce71ae424d4122e9e4afd3a294fda6606e0333838fe332fc4e11d0d53:

 $ docker-logfiler -f cc1 Kører fra: /usr/share/jenkins/jenkins.war webroot: EnvVars.masterEnvVars.get ("JENKINS_HOME") ... **************** ********************************************** ************************************************* ****** ******************************************* ***************** Jenkins første opsætning er påkrævet. En administratorbruger er oprettet, og en adgangskode er genereret. Brug følgende adgangskode for at fortsætte med installationen: 205be6fe69c447dd933a3c9ce7420496 Dette kan også findes på: / var / jenkins_home / secrets / initialAdminPassword ************************* ************************************* ************ ************************************************ ** ************************************************** *********

Opsæt Jenkins CI til en Java-webapp

Dernæst opretter vi et enkelt Java-webapplikationsjob i Jenkins. Da applikationen ikke er vigtig for denne tutorial, bruger vi min enkle Hello, World Servlet-eksempelapp, som jeg har vært på GitHub.

For at teste Jenkins skal du være i stand til at begå ændringer til et kildekodedepot, så du skal oprette det arkiv nu. Klik på Jenkins-hjemmesiden Opret nye job knappen, og indtast navnet på dit projekt. Du bliver bedt om at vælge projekttypen som vist i figur 5.

Steven Haines

Vi vælger Freestyle-projekttypen til dette projekt, men du skal være opmærksom på dine muligheder:

Freestyle-projekt: Denne mest almindelige type projekt giver dig mulighed for at overvåge et kildekodedepot og bruge ethvert build-system, såsom Maven og Ant.
Pipeline: Vælg denne projekttype til komplicerede projekter med bevægelige dele, som du har brug for at koordinere på tværs af flere slaver.
Eksternt job: Brug dette til at konfigurere et automatisk eksternt job, som du vil spore i Jenkins som en del af din build.
Multikonfigurationsprojekt: Dette er jobtypen for projekter, der kræver forskellige konfigurationer til forskellige miljøer, såsom produktion, iscenesættelse og test.
Mappe: Når du har en kompliceret build, vil du måske organisere ting i mapper, hver med deres eget særskilte navneområde.
Multi-branch pipeline: Opret automatisk et sæt pipeline-projekter baseret på kodegrenene, der er defineret i dit kildekodedepot

Indtast et projektnavn, i dette tilfælde "hello-world-servlet", og vælg "OK". Vælg derefter GitHub-projekt, indtast derefter GitHub-URL'en til dit projekt: //github.com/ligado/hello-world-servlet.

Vælg under Source Code Management Git og indtast den samme projekt-URL.

I sektionen Byg udløsere skal du vælge Byg, når en ændring skubbes til GitHub så Jenkins vil opbygge din kode når som helst du skubber en ændring til GitHub.

I afsnittet Bygg tilføj et nyt byggetrin, vælg Påkald Maven-mål på øverste niveau, vælg den Maven-forekomst, som du tidligere har konfigureret (såsom "Maven 3.3.9"), og indtast ren installation i målfeltet. Lad post-build-handlingerne være tomme for nu. Når du er færdig, skal du trykke på Gemme.

Når du vender tilbage til instrumentbrættet, skal du se en skærm, der ligner figur 6.

Steven Haines

Tryk på for at teste din konfiguration Byg nu -knappen ved siden af hello-world-servlet-projektet. Du skal se en build udført med succes i Build History på venstre side af projektsiden, vist i figur 7.

Steven Haines

For at se nøjagtigt hvad der skete, skal du klikke på build og derefter klikke på Konsol output, som viser dig alle de trin, Jenkins udførte, og deres resultater. Konsoludgangen er under.