Programmering

Kontinuerlig integrasjon med Jenkins

Ser jeg tilbake på hvordan programvare ble bygget og distribuert til og med for 15 år siden, virker det overraskende at programmene våre faktisk fungerte. I disse dager besto en livssyklus for programvareutvikling av å kjøre bygger på en lokal maskin, manuelt kopiere gjenstandene til en iscenesetterserver, og teste hvert program manuelt gjennom flere iterasjoner. Når dev-teamet var fornøyd med bygningen, distribuerte vi applikasjonen manuelt i produksjon. Det mest konsistente med denne utviklingsstilen var inkonsekvens - i prosess og i resultater.

For over et tiår siden begynte smidige utviklere å omfavne og fremme testdrevet utvikling og kontinuerlig integrasjon (CI). Med disse teknikkene kunne vi automatisk bygge kildekode når en utvikler sjekket den inn i et kildedepot, og utførte en uttømmende enhetstestsuite for å sikre at et program fungerte som det skal. Mange testdrevne utviklere begynte også å gjøre integrasjonstesting og ytelsestesting i en sekundær CI-prosess.

Med kontinuerlig integrasjon kunne vi oppdage feil raskere og gi ut koden mye raskere enn vi hadde gjort tidligere år. Det er ingen overdrivelse å si at CI temmet "build" -siden av build-and-deploy-syklusen. I disse dager har mange team utviklet seg utover CI til CD, som står for kontinuerlig levering eller kontinuerlig distribusjon. Uansett betegnelse, er CD en prosess som flytter programvare fra kodeinnsjekking til iscenesettelse, eller til og med produksjonsutrulling.

Denne delen av Åpen kildekode Java-prosjekter introduserer kontinuerlig integrasjon med Jenkins, en ledende automatiseringsserver for CI / CD. Vi begynner med en oversikt over CI- og CD-prosessen, og konfigurerer deretter et Java-webprosjekt ved hjelp av Maven og Jenkins. Du lærer hvordan du bygger og enhetstest prosjektet i Jenkins med JUnit, samt hvordan du feilsøker byggfeil. Du vil også installere og kjøre en håndfull populære Jenkins-plugins for testing og rapportering av statisk kodeanalyse.

Introduksjon til CI / CD

I en kontinuerlig integreringsprosess kan kode som er sjekket inn i et kildekodedepot automatisk sjekkes ut, bygges, testes på en rekke måter og publiseres til et depot. For kontinuerlig integrering for å fungere trenger du en CI-server som Jenkins, som er i stand til å overvåke kildekodedepotet ditt for nye endringer og svare på konfigurerbare måter.

Ta et Java-program bygget med Maven som et eksempel. Når du oppdager kodeendringer, kan CI-serveren din svare ved å utføre en mvn ren installasjon. I en typisk Maven-byggekonfigurasjon vil den utføre et nytt sett med enhetstester som en del av build-kommandoen. Mens kildekoden ble bygget, kunne serveren utføre et hvilket som helst antall ekstra handlinger:

  • Slå sammen funksjonen din til hoved- eller hovedgrenen din når den forpliktede koden besto enhetstesten.
  • Utfør statisk kodeanalyse, for eksempel kodedekning, kodekompleksitet, kontroller for vanlige feil osv.
  • Publiser byggeartefaktene dine i et depot, for eksempel Artifactory eller Sonatype Nexus
  • Distribuer søknaden din til et integrasjonstestmiljø
  • Utfør integrasjonstester
  • Distribuer søknaden din til et ytelsestestmiljø
  • Utfør en belastningstest mot søknaden din
  • Distribuer søknaden din til et UAT (User Acceptance Testing Environment)
  • Distribuer søknaden din til produksjon

Disse trinnene er alle typer aktiviteter du kan utføre som en del av en CI / CD-prosess. CI inkluderer vanligvis bygnings- og testfasene i utviklingslivssyklusen, mens CD utvider prosessen til å distribuere en byggeartefakt til en server for testing. I noen miljøer går CD helt til produksjon.

Kontinuerlig integrasjon gjøres vanligvis ved hjelp av et verktøy som Jenkins, Bamboo eller TeamCity, som orkestrerer byggetrinnene dine til en integrasjonsrørledning. Jenkins er sannsynligvis det mest populære CI / CD-produktet, og det passer godt sammen med Docker.

Last ned og installer Jenkins

Jenkins er en kontinuerlig integreringsserver og mer. Den består av en automatiseringsmotor og et plugin-økosystem som støtter kontinuerlig integrasjon, automatisert testing og kontinuerlig levering. Du tilpasser leveringsrørledningen avhengig av ditt behov.

Det er mange måter å kjøre Jenkins på:

  1. Last ned en WAR-fil og installer den på en servletbeholder på din lokale datamaskin.
  2. Sett opp en virtuell maskin i en offentlig sky som AWS og vert Jenkins der.
  3. Utnytt en Jenkins-skyleverandør som CloudBees.
  4. Konfigurer Jenkins i en testinstallasjon ved hjelp av Docker.

Jeg viser deg hvordan du konfigurerer både den lokale installasjonen og Docker-testinstallasjonen.

Last ned og installer Jenkins lokalt

Start med å laste ned Jenkins og velge Long-Term Support (LTS) -utgivelsen fra Jenkins-hjemmesiden. Fordi jeg bruker Mac, lastet installasjonen automatisk ned pkg fil, som plasserte en jenkins.war i min Søknad / Jenkins mappe. WAR-filen kan distribueres til en hvilken som helst servletcontainer.

Du vil også laste ned og installere Apache Tomcat. I skrivende stund er den nyeste versjonen av Tomcat 8.5.4, men du bør kunne kjøre hvilken som helst ny versjon. Last ned glidelås eller tar.gz fil og dekomprimerer den til harddisken. Kopier jenkins.war-filen til Tomcats webapps mappen og kjør deretter bin / startup.sh eller bin / startup.bat fil. Du kan teste at den kjører ved å åpne nettleseren din til: // lokal vert: 8080.

For å starte Jenkins, åpne en nettleser til URL: // localhost: 8080 / jenkins.

Du bør få en skjerm som ser ut som figur 1.

Steven Haines

Deretter oppretter Jenkins et administrasjonspassord og skriver det både til Tomcat logger / catalina.out loggfil og til følgende hjemmekatalog: .jenkins / secrets / initialAdminPassword. Hent passordet, skriv det inn Administrasjonspassord skjemaelement (vist i figur 1), og trykk på Fortsette. Du blir bedt om å enten installere foreslåtte plugins eller velge plugins som skal installeres. For nå anbefaler jeg å installere de foreslåtte pluginene.

Nå blir du bedt om å opprette en administratorbruker. Skriv inn administratorbrukerinformasjonen din og trykk Lagre og fullfør. Til slutt klikker du Begynn å bruke Jenkins. Du vil nå se Jenkins-hjemmesiden, som vist i figur 2.

Steven Haines

Konfigurer eksempelappen med Maven

Før vi kan bruke Jenkins til å bygge et Java-webprosjekt med Maven, må vi sette opp begge disse teknologiene. Under panseret vil Jenkins kasse kildekoden fra et kildekodedepot til en lokal katalog og utføre Maven-målene du spesifiserer. For at det skal fungere, må du installere en eller flere versjoner av Maven, fortelle Jenkins hvor de er installert, og konfigurere den versjonen av Maven du vil at Jenkins skal bruke når du bygger applikasjonen.

Klikk på Jenkins-dashbordet Administrer Jenkins og velg Global Tool Configuration. Det første vi skal gjøre er å konfigurere en JDK. Klikk på under JDK-delen Legg til JDK, gi den et navn (min er "JDK8"), og la standardverdien være Installer fra java.sun.com sjekket. Godta Oracle-lisensavtalen, og klikk deretter på lenken "Vennligst skriv inn brukernavnet / passordet ditt". Skriv inn Oracle brukernavn og passord og trykk Lukk. Du får en skjerm som ligner på figur 3.

Steven Haines

Klikk Søke om for å lagre arbeidet ditt, rull deretter ned til Maven-delen og klikk Legg til Maven. Skriv inn et navn for Maven (min er "Maven 3.3.9"), la "Installer automatisk" og "Installer fra Apache" krysset av. Klikk Lagre når du er klar. Du bør få en skjerm som ligner på figur 4.

Steven Haines

Git kommer forhåndskonfigurert med Jenkins, så du bør nå ha alle verktøyene installert som du trenger for å kasse og bygge et Java-prosjekt fra Git med Maven.

Installer Jenkins i en Docker-container

Hvis du ikke vil installere Jenkins på din lokale maskin, har du muligheten til å kjøre den i en Docker-container. Det offisielle Jenkins Docker-bildet lar deg kjøre og teste en installasjon av Jenkins uten å konfigurere det på en lokal maskin.

Installerer Docker

Se min introduksjon til Docker for en nybegynnerveiledning til Docker, inkludert installasjons- og installasjonsinstruksjoner.

Forutsatt at du allerede har Docker-oppsett i utviklingsmiljøet ditt, kan du starte Jenkins fra Docker kommandolinjen:

 docker kjøre -p 8080: 8080 -p 50000: 50000 -v / ditt / hjem / jenkins: / var / jenkins_home -d jenkins 

Denne kommandoen ber Docker om å kjøre den siste versjonen av jenkins med følgende alternativer:

  • -p 8080: 8080: Kartfører port 8080 på Docker-beholderen til port 8080 på Docker-verten, slik at du kan koble til Jenkins-nettappen på port 8080.
  • -p 50000: 50000: Kartfører port 50000 på Docker-beholderen til port 50000 på Docker-verten. Jenkins bruker denne porten internt for å tillate build slave executors å koble til master Jenkins serveren.
  • -v / ditt / hjem / jenkins: / var / jenkins_home: Kartlegger Jenkins datalagring til din lokale katalog, slik at du kan starte Docker-containeren din på nytt uten å miste dataene dine.
  • -d: Lar deg kjøre Docker-beholderen i en frittliggende modus, eller som en demonprosess.

Følgende viser utdataene for å kjøre disse kommandoene:

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

Fordi vi kjører Docker-containeren vår i frittliggende modus, må vi følge loggene som sendes ut av Jenkins. Du kan gjøre det med docker-logger -f kommando. Bare skriv inn de første få heksadesimale tallene til container-ID-en, i dette tilfellet cc16573ce71ae424d4122e9e4afd3a294fda6606e0333838fe332fc4e11d0d53:

 $ docker-logger -f cc1 Kjører fra: /usr/share/jenkins/jenkins.war webroot: EnvVars.masterEnvVars.get ("JENKINS_HOME") ... ***************** ********************************************* ************************************************* ****** ******************************************* ***************** Jenkins første oppsett kreves. En administratorbruker er opprettet og et passord generert. Bruk følgende passord for å fortsette med installasjonen: 205be6fe69c447dd933a3c9ce7420496 Dette kan også bli funnet på: / var / jenkins_home / secrets / initialAdminPassword ************************ ************************************* ************ *********************************************** ** ************************************************* ********* 

Sett opp Jenkins CI for en Java-webapp

Deretter setter vi opp en enkel Java-applikasjon i Jenkins. Fordi applikasjonen ikke er viktig for denne opplæringen, bruker vi min enkle Hello, World Servlet eksempel-app, som jeg har vært vert på GitHub.

For å teste Jenkins må du være i stand til å begå endringer i et kildekodedepot, så du bør opprette det depotet nå. Klikk på på Jenkins-hjemmesiden Skape nye jobber og skriv inn navnet på prosjektet. Du blir bedt om å velge prosjekttype, som vist i figur 5.

Steven Haines

Vi velger Freestyle-prosjekttypen for dette prosjektet, men du bør være oppmerksom på alternativene dine:

  • Freestyle-prosjekt: Denne vanligste typen prosjekter lar deg overvåke et kildekodedepot og bruke hvilket som helst byggesystem, som Maven og Ant.
  • Rørledning: Velg denne prosjekttypen for kompliserte prosjekter med bevegelige deler som du trenger for å koordinere på tvers av flere byggeslaver.
  • Ekstern jobb: Bruk denne for å konfigurere en automatisert ekstern jobb som du vil spore i Jenkins som en del av bygningen din.
  • Multikonfigurasjonsprosjekt: Dette er jobbtypen for prosjekter som krever forskjellige konfigurasjoner for forskjellige miljøer, for eksempel produksjon, iscenesettelse og test.
  • Mappe: Når du har en komplisert konstruksjon, kan det være lurt å organisere ting i mapper, hver med sitt eget forskjellige navneområde.
  • Multi-branch pipeline: Opprett automatisk et sett med pipeline-prosjekter, basert på kodegrenene som er definert i kildekodedepotet ditt

Skriv inn et prosjektnavn, i dette tilfellet "hallo-world-servlet", og velg "OK". Velg deretter GitHub-prosjekt, skriv deretter inn GitHub-URL-en til prosjektet ditt: //github.com/ligado/hello-world-servlet.

Velg under Source Source Management Git og skriv inn samme prosjekt-URL.

I delen Bygg utløsere velger du Bygg når en endring blir presset til GitHub slik at Jenkins vil bygge koden din når som helst du skyver en endring til GitHub.

I delen Bygg, legg til et nytt byggetrinn, velg Påkalle toppnivå Maven-mål, velg Maven-forekomsten du konfigurerte tidligere (for eksempel "Maven 3.3.9") og skriv inn ren installasjon i målfeltet. La post-build-handlingene være tomme for nå. Når du er ferdig, trykker du på Lagre.

Når du kommer tilbake til dashbordet, bør du se en skjerm som ligner på figur 6.

Steven Haines

Trykk på for å teste konfigurasjonen Bygg nå knappen ved siden av Hello-world-servlet-prosjektet. Du bør se en build utført med suksess i Build History på venstre side av prosjektsiden, vist i figur 7.

Steven Haines

For å se nøyaktig hva som skjedde, klikk på build og klikk deretter Konsollutgang, som viser deg alle trinnene som Jenkins utførte og resultatene av dem. Konsollutgangen er under.

$config[zx-auto] not found$config[zx-overlay] not found