jenkins Handledning
Komma igång med jenkins

Anmärkningar

versioner

Installation

För apt-get-baserade system som Ubuntu

Lägg till Jenkins-förvaret:

wget -q -O - https://jenkins-ci.org/debian/ Jenkins-ci.org.key | sudo apt-key

sudo sh -c 'echo deb http://pkg.jenkins-ci.org/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

Uppdatera källor och installera Jenkins:

sudo apt-get update

sudo apt-get install jenkins

En jenkins-användare skapas nu och som standard körs Jenkins på port 8080.

För RPM-baserade distributioner som Red Hat Enterprise Linux (RHEL), CentOS, Fedora eller Scientific Linux

Så här laddar du ner arkivfilen för den stabila versionen:

sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat-stable/jenkins.repo

Eller om du vill ha de senaste veckovisningarna:

sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.repo

Importera den offentliga nyckeln:

sudo rpm --import https://jenkins-ci.org/redhat/jenkins-ci.org.key

Installera Jenkins med yum:

sudo yum install jenkins

Jenkins kräver java för att köra, för att installera det:

sudo yum install java

För att starta / stoppa / starta om jenkins använder du:

sudo service jenkins start/stop/restart

Uppgradering av jenkins (RPM-installationer)

1. Backup jenkins hemkatalog
2. Byt ut jenkins.war på följande plats med ny WAR-fil. / Usr / lib / jenkins / jenkins.war`
3. Starta om Jenkins
4. Kontrollera fästade plugins och lossa om det behövs
5. Ladda om konfigurationen från disken

Obs: För Jenkins 2-uppgraderingar för den paketerade bryggan-appservern, avaktivera AJP-porten (ställ JENKINS_AJP_PORT="-1" ) i /etc/sysconfig/jenkins .

Ställa in Nginx Proxy

Naturligtvis kör Jenkins på hamn 8080. Vi kan skapa en proxy från hamn 80 -> 8080 så att Jenkins kan nås via:

http://<url>.com

istället för standard

http://<url>.com:8080

Börja med att installera Nginx.

sudo aptitude -y install nginx

Ta bort standardinställningarna för Nginx

cd /etc/nginx/sites-available

sudo rm default ../sites-enabled/default

Skapa den nya konfigurationsfilen

sudo touch jenkins

Kopiera följande kod till den nyligen skapade jenkins filen.

upstream app_server {
  server 127.0.0.1:8080 fail_timeout=0;
}

server {
  listen 80;
  listen [::]:80 default ipv6only=on;
  server_name ;

  location / {
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;
    proxy_redirect off;

    if (!-f $request_filename) {
        proxy_pass http://app_server;
        break;
    }
  }
}

Skapa en symbolisk länk mellan webbplatser-tillgängliga och webbplatsaktiverade:

sudo ln -s /etc/nginx/sites-available/jenkins /etc/nginx/sites-enabled/

Starta om Nginx-proxytjänsten

sudo service nginx restart

Jenkins kommer nu att vara tillgängligt från hamn 80.

Installera plugin från extern källa

java -jar [Path to client JAR] -s [Server address] install-plugin [Plugin ID]

Klienten JAR måste vara CLI JAR-filen, inte samma JAR / WAR som kör Jenkins själv. Unika ID kan hittas på respektive plugins-sida på Jenkins CLI wiki ( https://wiki.jenkins-ci.org/display/JENKINS/Plugins)

Flytta Jenkins från en PC till en annan

Detta fungerade för mig att gå från Ubuntu 12.04 (Jenkins ver. 1.628) till Ubuntu 16.04 (Jenkins ver. 1.651.2). Jag installerade först Jenkins från förvaren .

1. Stoppa båda Jenkins-servrarna

2. Kopiera JENKINS_HOME (t.ex. / var / lib / jenkins) från den gamla servern till den nya. Från en konsol på den nya servern:

   rsync -av username@old-server-IP:/var/lib/jenkins/ /var/lib/jenkins/

3. Starta din nya Jenkins-server

Du kanske inte behöver detta, men jag var tvungen att göra det

• Manage Jenkins och Reload Configuration from Disk .
• Koppla bort och anslut alla slavar igen.
• Kontrollera att Jenkins URL är korrekt tilldelad den nya Jenkins-servern i Configure System > Jenkins Location .

Konfigurera ett projekt i Jenkins

Här kommer vi att kolla in den senaste kopian av vårt projektkod, köra testerna och göra applikationen levande. För att uppnå det, följ stegen nedan:

1. Öppna Jenkins i webbläsaren.
2. Klicka på länken Nytt jobb .
3. Ange projektnamn och välj länken Bygg ett projekt med fri programvara .
4. Klicka på Ok- knappen.
5. Under avsnittet Källkodshantering väljer du radiorutan bredvid källkodshanteringsverktyget. I mitt fall har jag valt Git .

Ange url till git repo som git://github.com/example/example.git

6. Markera radiorutan bredvid Poll SCM under Build triggers .
7. Ange ***** i rutan Schema . Denna ruta är ansvarig för att trigga byggandet med regelbundna intervall. ***** specificerar att jobbet kommer att trigga varje minut för ändringar i git repo.
8. Under Build klickar du på Lägg till Build Step-knappen och välj sedan alternativet med vilken du vill bygga projektet. Jag har valt Execute Shell . Skriv kommandot att bygga, köra testerna och distribuera det i kommandorutan för att skapa.
9. Rulla ner och Spara .

Så ovan har vi konfigurerat ett grundläggande projekt i Jenkins som kommer att utlösa byggandet varje minut för att ändra ditt gitförråd. Obs: För att konfigurera det komplexa projektet kanske du måste installera några plugins i Jenkins.

Jenkins full introduktion på ett ställe

1. Jenkins:

Jenkins är ett kontinuerligt integrationsverktyg med öppen källkod skriven i Java. Projektet gick från Hudson efter en tvist med Oracle.

Kort sagt är Jenkins den ledande open source-automatiseringsservern. Den är byggd med Java och erbjuder hundratals plugins för att stödja byggande, testning, distribution och automatisering för praktiskt taget alla projekt.

Funktioner: Jenkins erbjuder följande huvudfunktioner ur lådan, och många fler kan läggas till via plugins:

Enkel installation: Kör bara java -jar jenkins.war, distribuera den i en servletbehållare. Ingen ytterligare installation, ingen databas. Föredrar du ett installationsprogram eller ett eget paket? Vi har de också. Enkel konfiguration: Jenkins kan konfigureras helt från dess vänliga webbgränssnitt med omfattande felkontroller och inline-hjälp. Ekosystem med rikt plugin: Jenkins integreras med praktiskt taget varje SCM eller byggverktyg som finns. Visa plugins. Utdragbarhet: De flesta delar av Jenkins kan utökas och modifieras, och det är enkelt att skapa nya Jenkins-plugins. Detta gör att du kan anpassa Jenkins efter dina behov. Distribuerade builds: Jenkins kan distribuera build / testlaster till flera datorer med olika operativsystem. Bygga programvara för OS X, Linux och Windows? Inga problem.

Installation :

$ wget -q -O - https://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
$ sudo apt-get install jenkins
to do more refer link :

Ref: https://wiki.jenkins-ci.org/display/JENKINS/Installing+Jenkins+on+Ubuntu

Ref: http://www.vogella.com/tutorials/Jenkins/article.html

Ref: https://wiki.jenkins-ci.org/display/JENKINS/Meet+Jenkins

JENKINS_HOME- katalog Jenkins behöver lite diskutrymme för att utföra builds och behålla arkiv. Du kan kontrollera den här platsen från konfigurationsskärmen för Jenkins. Som standard är detta inställt på ~ / .jenkins, men du kan ändra detta på något av följande sätt: Ställ in "JENKINS_HOME" miljövariabel till den nya hemkatalogen innan du startar servletcontainern. Ställ in "JENKINS_HOME" systemegenskap till servletbehållaren. Ställ in JNDI-miljöposten "JENKINS_HOME" till den nya katalogen. Se den behållarspecifika dokumentationssamlingen för mer information om hur du gör detta för din container. Du kan ändra den här platsen efter att du har använt Jenkins också ett tag. För att göra detta, stoppa Jenkins helt, flytta innehållet från gamla JENKINS_HOME till det nya hemmet, ställ in det nya JENKINS_HOME och starta om Jenkins. JENKINS_HOME har en ganska uppenbar katalogstruktur som ser ut enligt följande:

JENKINS_HOME

+- config.xml     (jenkins root configuration)
 +- *.xml          (other site-wide configuration files)
 +- userContent    (files in this directory will be served under your http://server/userContent/)
 +- fingerprints   (stores fingerprint records)
 +- plugins        (stores plugins)
 +- workspace (working directory for the version control system)
     +- [JOBNAME] (sub directory for each job)
 +- jobs
     +- [JOBNAME]      (sub directory for each job)
         +- config.xml     (job configuration file)
         +- latest         (symbolic link to the last successful build)
         +- builds
             +- [BUILD_ID]     (for each build)
                 +- build.xml      (build result summary)
                 +- log            (log file)
                 +- changelog.xml  (change log)

Jenkins Build Jobs:

Att skapa ett nytt byggjobb i Jenkins är enkelt: klicka bara på menyalternativet “Nytt jobb” på Jenkins instrumentbräda. Jenkins stöder flera olika typer av byggjobb som presenteras för dig när du väljer att skapa ett nytt jobb

Freestyle-program

Freestyle-byggjobb är generella jobb, vilket ger maximal flexibilitet.

Maven-projekt ”Maven2 / 3-projektet” är ett byggjobb som är specialanpassat för Maven-projekt. Jenkins förstår Maven pom-filer och projektstrukturer och kan använda den information som samlas in från pom-filen för att minska det arbete du behöver göra för att ställa in ditt projekt.

Workflow

Orkestrerar långvariga aktiviteter som kan spänna över flera byggda slavar. Lämplig för att bygga rörledningar och / eller organisera komplexa aktiviteter som inte lätt passar in i fri stil jobbtyp.

Övervaka ett externt jobb "Skapa ett externt jobb" -byggandejobb låter dig hålla ett öga på icke-interaktiva processer, till exempel cronjobb.

Multikonfigurationsjobb "Multikonfigurationsprojektet" (även känt som ett "matrisprojekt") låter dig köra samma byggjobb i många olika konfigurationer. Den här kraftfulla funktionen kan vara användbar för att testa en applikation i många olika miljöer, med olika databaser eller till och med på olika byggmaskiner.

1. Bygga ett mjukvaruprojekt (gratis stil)

Jenkins kan användas för att utföra det typiska build-serverarbetet, som att göra kontinuerliga / officiella / nattliga byggningar, köra tester eller utföra några upprepande batchuppgifter. Detta kallas "fri stil mjukvaruprojekt" i Jenkins. Ställa in projektet Gå till Jenkins översida, välj "Nytt jobb" och välj sedan "Bygg ett fristils mjukvaruprojekt". Den här jobbtypen består av följande element: SCM, till exempel CVS eller Subversion där din källkod finns. valfria triggers för att kontrollera när Jenkins ska utföra builds. någon form av build-skript som utför build (ant, maven, shell-skript, batch-fil, etc.) där det verkliga arbetet händer valfria steg för att samla information ur byggnaden, såsom arkivering av artefakter och / eller inspelning av javadoc och test resultat. valfria steg för att meddela andra personer / system med byggresultatet, till exempel skicka e-post, chattmeddelanden, uppdatering av tracker etc.

Bygg för projekt som inte är källkontroll Det finns ibland behov av att bygga ett projekt helt enkelt för demonstrationsändamål eller tillgång till ett SVN / CVS-arkiv är inte tillgängligt. Genom att välja att konfigurera projektet som "Ingen" under "Källkodshantering" måste du:

1. Bygg projektet minst en gång (det kommer att misslyckas), men Jenkins kommer att skapa strukturen jenkins / workspace / PROJECTNAME /
2. Kopiera projektfilerna till jenkins / workspace / PROJECTNAME /
3. Bygg igen och konfigurera på rätt sätt

Jenkins ställer in miljövariabler

När ett Jenkins-jobb körs ställer det in vissa miljövariabler som du kan använda i ditt shell-skript, batchkommando, ant script eller Maven POM. Se variabelistan genom att klicka på ENVIRONMENT_VARIABLE

Konfigurera automatiska builds

Byggnader i Jenkins kan triggas periodiskt (enligt ett schema, specificerat i konfiguration), eller när källförändringar i projektet har upptäckts, eller de kan automatiskt utlösas genom att begära URL:

http: // YOURHOST / Jenkins / jobb / Projektnamn / build

Detta gör att du kan ansluta Jenkins till en mängd olika inställningar. För mer information (särskilt om du gör detta med säkerhet aktiverad), se API för fjärråtkomst.

Byggs efter källförändringar

Du kan låta Jenkins undersöka ditt Revision Control System för ändringar. Du kan ange hur ofta Jenkins undersöker ditt revisionskontrollsystem med samma syntax som crontab på Unix / Linux. Men om din pollingperiod är kortare än den tar för att undersöka ditt revisionskontrollsystem, kan du sluta med flera builds för varje ändring. Du bör antingen justera din pollingperiod så att den är längre än den tid det tar att undersöka ditt revisionskontrollsystem eller använda en trigger efter åtagande. Du kan granska pollingloggen för varje bygg för att se hur lång tid det tog att polla ditt system.

Alternativt kan du använda en URL-trigger (beskrivet ovan), men med / polling istället för / build i slutet av URL: en istället för att polla med ett fast intervall. Detta gör att Jenkins undersöker SCM för förändringar snarare än att bygga omedelbart. Detta förhindrar att Jenkins kör en byggnad utan några relevanta ändringar för åtaganden som påverkar moduler eller grenar som inte är relaterade till jobbet. När du använder / pollar måste jobbet konfigureras för polling, men schemat kan vara tomt.

Byggs via e-post (sendmail)

Om du har root-kontot för ditt system och använder sendmail, tyckte jag att det var lättast att justera / etc / alias och lägga till följande post: jenkins-foo: "| / bin / wget -o / dev / null

http: // YOURHOST / jenkins / job / PROJECTNAME / build "

och kör sedan kommandot "newaliases" för att meddela sendmail om förändringen. När någon skickar ett e-postmeddelande till "jenkins-foo @ yoursystem" kommer detta att utlösa en ny byggnad. Se detta för mer information om konfigurering av sendmail. Byggs via e-post (qmail) Med qmail kan du skriva /var/qmail/alias/.qmail-jenkins på följande sätt: | / bin / wget -o / dev / null http: // YOURHOST / jenkins / job / PROJECTNAME / bygg "

2. Bygga ett Maven-projekt

Jenkins tillhandahåller en jobbtyp dedicerad till Maven 2/3. Den här jobbtypen integrerar Jenkins djupt med Maven 2/3 och ger följande fördelar jämfört med det mer generiska program för fristil.

Jenkins analyserar Maven POMs för att få mycket av den information som behövs för att utföra sitt arbete. Som ett resultat reduceras mängden konfiguration drastiskt.

Jenkins lyssnar på Maven-avrättningen och räknar ut vad som ska göras när du själv. Till exempel kommer den automatiskt att spela in JUnit-rapporten när Maven kör testfasen. Eller om du kör javadoc-målet kommer Jenkins automatiskt att spela in javadoc.

Jenkins skapar automatiskt projektberoende mellan projekt som förklarar SNAPSHOT-beroende mellan varandra. Se nedan. Därför behöver du oftast bara konfigurera SCM-information och vilka mål du vill köra, och Jenkins kommer att räkna ut allt annat.

Denna projekttyp kan automatiskt tillhandahålla följande funktioner:

Arkivera artefakter producerade av en byggnad

Publicera testresultat

Trigger jobb för projekt som är nedströms beroende

Distribuera dina artefakter till ett Maven-arkiv

Testresultat för moduler

Alternativt kan du bygga om bara ändrade moduler och påskynda dina build

Automatisk byggkedja från modulberoenden

Jenkins läser beroenden av ditt projekt från din POM, och om de också är byggda på Jenkins, startas triggers på ett sådant sätt att en nybyggnad i ett av dessa beroenden automatiskt startar en ny byggnad av ditt projekt. Jenkins förstår alla slags beroenden i POM. Nämligen förälder POM

<dependencies> section of your project
<plugins> section of your project
<extensions> section of your project
<reporting> section of your project

Den här processen tar hänsyn till versioner, så att du kan ha flera versioner / grenar av ditt projekt på samma Jenkins och det kommer att bestämma beroenden korrekt. Observera att versioner för beroendeversion inte stöds, se [ https://issues.jenkins-ci.org/browse/JENKINS-2787????1] av anledningen.

Denna funktion kan avaktiveras på begäran - se konfigurationsalternativ Bygg närhelst ett SNAPSHOT-beroende byggs

Installation :

1. gå till Hantera Jenkins >> konfigurera System

2. i maven-fliken “Klicka på maven-installationen ......

Du kan antingen få Jenkins att installera en specifik version av Maven automatiskt eller ge en sökväg till en lokal Maven-installation (Du kan konfigurera så många versioner av Maven för dina byggprojekt som du vill, och använda olika versioner av Maven för olika projekt. Om du markerar kryssrutan Installera automatiskt kommer Jenkins att ladda ner och installera den begärda versionen av Maven för dig och installera den i verktygskatalogen i Jenkins hemkatalog.

Hur man använder det

Först måste du konfigurera en Maven-installation (detta steg kan hoppas över om du använder DEV @ cloud). Detta kan göras genom att gå till systemkonfigurationsskärmen (Hantera Jenkins-> Configure System). I avsnittet "Maven Installations", 1) klicka på Lägg till-knappen, 2) ge det ett namn som "Maven 3.0.3" och sedan 3) välj version från rullgardinsmenyn.

Nu kommer Jenkins automatiskt att installera den här versionen när som helst den behövs (till exempel på nya maskiner) genom att ladda ner den från Apache och packa upp den.

Skapa ett nytt Maven Job:

1. Klicka på "Nytt jobb / Nytt objekt" till vänster
2. Ge det ett namn
3. Välj projektet "Build a Maven 2/3"
4. Spara ditt jobb

Nu måste du konfigurera ditt jobb

1. Välj den SCM du vill använda (ex. Använda git)

2. Välj maven mål att ringa

3. lägg till lagringsadress och referens.

4. kolla användarens privata maven repo:

Du kan också definiera depåvägen för densamma.

5. Bygg projekt

Bygg ditt projekt genom att klicka på build nu och klicka på framstegsfältet i vänsterhand "Build Executor Status" för att se jenkins installera Maven, kolla in ditt projekt och bygga det med maven.

Skogsavverkning:

https://wiki.jenkins-ci.org/display/JENKINS/Logging

Skriptkonsol:

Användbart för felsökning, diagnostik eller batchuppdateringar av jobb Jenkins tillhandahåller en skriptkonsol som ger dig tillgång till alla Jenkins interna. Dessa skript är skrivna i Groovy och du hittar några exempel på dem på den här sidan .

Konfigurera ett enkelt byggprojekt med Jenkins 2 pipeline script

Här skapar vi en Groovy-pipeline i Jenkins 2 för att göra följande steg:

• Verifiera var 5: e minut om ny kod har kommit till vårt projekt
• Kassa från SCM repo
• Maven sammanställer vår Java-kod
• Kör våra integrationstester och publicera resultaten

Så här kommer vi att göra:

1. Se till att vi har minst en 2.0 Jenkins-version (du kan kontrollera det i nedre högra hörnet av din sida), till exempel:

   

2. Klicka på New Item på Jenkins hemsida

3. Ange projektnamn och välj Pipeline

4. I avsnittet Build Triggers väljer du alternativet Poll SCM och lägger till följande 5 minuter CRON-schema: */5 * * * *

5. I avsnittet Rörledning väljer du antingen Pipeline Script eller Pipeline Script från SCM

6. Om du valde Pipeline Script från SCM i föregående steg måste du nu ange ditt SCM-arkiv (Git, Mercurial, Subversion) URL i databasens URL , som http://github.com/example/example.git . Du måste också ange skriptvägen för din Groovy-skriptfil i ditt exempel.git-arkiv, t.ex. pipelines/example.groovy

7. Kopiera följande Groovy-kod, antingen direkt i Groovy-skriptfönstret om du tidigare klickat på Pipeline-skript eller i ditt example.groovy om du valde Pipeline-script från SCM

node('remote') {
    // Note : this step is only needed if you're using direct Groovy scripting
    stage 'Checkout Git project'
    git url: 'https://github.com/jglick/simple-maven-project-with-tests.git'
    def appVersion = version()
    if (appVersion) {
        echo "Building version ${appVersion}"
    }

    stage 'Build Maven project'
    def mvnHome = tool 'M3'
    sh "${mvnHome}/bin/mvn -B -Dmaven.test.failure.ignore verify"
    step([$class: 'JUnitResultArchiver', testResults: '**/target/surefire-reports/TEST-*.xml'])
}
def version() {
    def matcher = readFile('pom.xml') =~ '<version>(.+)</version>'
    matcher ? matcher[0][1] : null
}

Här ska du nu kunna kompilera och testa ditt första Jenkins-projekt med Jenkins 2 Groovy pipeline.