Integrazione continua con Jenkins

Guardando indietro a come il software è stato creato e distribuito anche 15 anni fa, sembra sorprendente che le nostre applicazioni funzionassero davvero. A quei tempi, un ciclo di vita dello sviluppo del software consisteva nell'esecuzione di build su una macchina locale, nella copia manuale degli artefatti su un server di staging e nel test manuale di ciascuna applicazione attraverso più iterazioni. Quando il team di sviluppo era soddisfatto della build, distribuivamo manualmente l'applicazione in produzione. La cosa più coerente di questo stile di sviluppo è stata l'incoerenza, nel processo e nei risultati.

Oltre un decennio fa, gli sviluppatori agili hanno iniziato ad abbracciare e promuovere lo sviluppo guidato dai test e l'integrazione continua (CI). Con queste tecniche potevamo creare automaticamente il codice sorgente ogni volta che uno sviluppatore lo controllava in un repository di sorgenti, eseguendo una suite esaustiva di unit test per garantire che un'applicazione funzionasse correttamente. Molti sviluppatori basati sui test hanno anche iniziato a eseguire test di integrazione e test delle prestazioni in un processo CI secondario.

Con l'integrazione continua abbiamo potuto rilevare gli errori più rapidamente e rilasciare il codice molto più velocemente di quanto avessimo fatto negli anni precedenti. Non è esagerato affermare che CI ha addomesticato il lato "build" del ciclo build-and-deploy. In questi giorni molti team di sviluppo sono passati da CI a CD, che sta per distribuzione continua o distribuzione continua. Qualunque sia la designazione, il CD è un processo che sposta il software dal check-in del codice allo staging o persino alle distribuzioni di produzione.

Questa puntata di progetti Java open source introduce l'integrazione continua con Jenkins, un server di automazione leader per CI / CD. Inizieremo con una panoramica del processo CI e CD, quindi configureremo un progetto Web Java utilizzando Maven e Jenkins. Imparerai come creare e testare l'unità del progetto in Jenkins con JUnit, nonché come risolvere gli errori di compilazione. Installerai ed eseguirai anche una manciata di plugin Jenkins popolari per test e report di analisi statica del codice.

Introduzione a CI / CD

In un processo di integrazione continua, il codice che è stato archiviato in un repository di codice sorgente può essere automaticamente estratto, creato, testato in vari modi e pubblicato in un repository. Affinché l'integrazione continua funzioni, è necessario un server CI come Jenkins, in grado di monitorare il repository del codice sorgente per rilevare nuove modifiche e rispondere in modi configurabili.

Prendi un'applicazione Java creata usando Maven come esempio. Al rilevamento delle modifiche al codice, il server CI potrebbe rispondere eseguendo un file mvn clean install. In una tipica configurazione di build Maven, eseguirà una nuova serie di unit test come parte del comando build. Durante la creazione del codice sorgente, il server poteva eseguire un numero qualsiasi di azioni aggiuntive:

  • Unisci nuovamente il ramo delle funzionalità nel ramo principale o principale una volta che il codice sottoposto a commit ha superato lo unit test.
  • Eseguire analisi statiche del codice, come copertura del codice, complessità del codice, controlli per bug comuni, ecc.
  • Pubblica i tuoi artefatti di build in un repository, come Artifactory o Sonatype Nexus
  • Distribuisci la tua applicazione in un ambiente di test di integrazione
  • Esegui test di integrazione
  • Distribuisci la tua applicazione in un ambiente di test delle prestazioni
  • Esegui un test di carico sulla tua applicazione
  • Distribuisci la tua applicazione in un ambiente di test di accettazione utente (UAT)
  • Distribuisci la tua applicazione alla produzione

Questi passaggi sono tutti i tipi di attività che potresti eseguire come parte di un processo CI / CD. CI in genere comprende le fasi di creazione e test del ciclo di vita di sviluppo, mentre CD estende tale processo alla distribuzione di un artefatto di build su un server per il test. In alcuni ambienti, il CD arriva fino alla produzione.

L'integrazione continua viene in genere eseguita utilizzando uno strumento come Jenkins, Bamboo o TeamCity, che orchestra le fasi di creazione in una pipeline di integrazione. Jenkins è probabilmente il prodotto CI / CD più popolare e si abbina bene a Docker.

Scarica e installa Jenkins

Jenkins è un server di integrazione continua e altro ancora. Consiste in un motore di automazione e un ecosistema di plug-in che supporta l'integrazione continua, i test automatizzati e la consegna continua. Personalizzi la pipeline di consegna in base alle tue necessità.

Esistono molti modi per eseguire Jenkins:

  1. Scarica un file WAR e installalo su un servlet container sul tuo computer locale.
  2. Configura una macchina virtuale in un cloud pubblico come AWS e ospita Jenkins lì.
  3. Sfrutta un provider cloud Jenkins come CloudBees.
  4. Configura Jenkins in un'installazione di prova utilizzando Docker.

Ti mostrerò come configurare sia l'installazione locale che l'installazione di prova Docker.

Scarica e installa Jenkins localmente

Inizia scaricando Jenkins e selezionando la versione Long-Term Support (LTS) dalla home page di Jenkins. Poiché sono su un Mac, l'installazione ha scaricato automaticamente un pkgfile, che ha inserito un jenkins.warnella mia Application/Jenkinscartella. Il file WAR può essere distribuito a qualsiasi contenitore servlet.

Dovrai anche scaricare e installare Apache Tomcat. Al momento della stesura di questo articolo, la versione più recente di Tomcat è la 8.5.4, ma dovresti essere in grado di eseguire qualsiasi versione recente. Scarica il file zipo tar.gze decomprimilo sul tuo disco rigido. Copia il file jenkins.war nella cartella di Tomcat webappse quindi esegui il file bin/startup.sho bin/startup.bat. È possibile verificare che è in esecuzione aprendo il browser a: //localhost:8080.

Per avviare Jenkins, apri un browser all'URL: // localhost: 8080 / jenkins.

Dovresti ottenere una schermata simile alla Figura 1.

Steven Haines

Avanti, Jenkins crea una password di amministrazione e scrive che sia di Tomcat logs/catalina.outfile di log e nella seguente directory home: .jenkins/secrets/initialAdminPassword. Recuperare la password, immetterla nell'elemento del modulo Password di amministrazione (mostrato nella Figura 1) e premere Continua . Ti verrà chiesto di installare i plug-in suggeriti o di selezionare i plug-in da installare. Per ora consiglio di installare i plugin suggeriti.

Ora ti verrà chiesto di creare un utente amministratore. Immettere le informazioni sull'utente amministratore e premere Salva e Fine . Infine, fai clic su Inizia a usare Jenkins . Ora vedrai la home page di Jenkins, come mostrato nella Figura 2.

Steven Haines

Configura l'app di esempio con Maven

Prima di poter utilizzare Jenkins per creare un progetto Web Java con Maven, è necessario configurare entrambe queste tecnologie. Sotto il cofano, Jenkins effettuerà il checkout del codice sorgente da un repository di codice sorgente a una directory locale ed eseguirà i target Maven specificati. Affinché funzioni, è necessario installare una o più versioni di Maven, indicare a Jenkins dove sono installate e configurare la versione di Maven che si desidera venga utilizzata da Jenkins durante la creazione dell'applicazione.

Dal dashboard di Jenkins, fai clic su Gestisci Jenkins e scegli Configurazione strumento globale . La prima cosa che faremo è configurare un JDK. Nella sezione JDK, fai clic su Aggiungi JDK , dagli un nome (il mio è "JDK8") e lascia selezionata l'opzione Installa predefinita da java.sun.com . Accetta il contratto di licenza Oracle, quindi fai clic sul link "Immettere nome utente / password". Immettere il nome utente e la password Oracle e premere Chiudi . Ti verrà presentata una schermata simile alla Figura 3.

Steven Haines

Fare clic su Applica per salvare il lavoro, quindi scorrere verso il basso fino alla sezione Maven e fare clic su Aggiungi Maven . Inserisci un nome per Maven (il mio è "Maven 3.3.9"), lascia "Installa automaticamente" e "Installa da Apache" selezionato. Fai clic su Salva quando sei pronto. Dovrebbe essere presentata una schermata simile alla Figura 4.

Steven Haines

Git è preconfigurato con Jenkins, quindi ora dovresti avere tutti gli strumenti installati di cui hai bisogno per effettuare il checkout e creare un progetto Java da Git con Maven.

Installa Jenkins in un container Docker

If you don't want to install Jenkins on your local machine, you have the option of running it in a Docker container. The official Jenkins Docker image lets you run and test an installation of Jenkins without actually configuring it on a local machine.

Installing Docker

See my introduction to Docker for a beginner's guide to Docker, including installation and setup instructions.

Assuming you already have Docker setup in your development environment, you can launch Jenkins from the Docker the command line:

 docker run -p 8080:8080 -p 50000:50000 -v /your/home/jenkins:/var/jenkins_home -d jenkins 

This command tells Docker to run the latest release of jenkins with the following options:

  • -p 8080:8080: Maps port 8080 on the Docker container to port 8080 on the Docker host, so that you can connect to the Jenkins web app on port 8080.
  • -p 50000:50000: Maps port 50000 on the Docker container to port 50000 on the Docker host. Jenkins uses this port internally to allow build slave executors to connect to the master Jenkins server.
  • -v /your/home/jenkins:/var/jenkins_home: Maps Jenkins data storage to your local directory, so that you can restart your Docker container without losing your data.
  • -d: Lets you run the Docker container in a detached mode, or as a daemon process.

The following shows the output for running these commands:

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

Because we're running our Docker container in detached mode, we need to follow the logs that are output by Jenkins. You can do so with the docker logs -f command. Just pass in the first few hexadecimal numbers of the container ID, in this case cc16573ce71ae424d4122e9e4afd3a294fda6606e0333838fe332fc4e11d0d53:

 $ docker logs -f cc1 Running from: /usr/share/jenkins/jenkins.war webroot: EnvVars.masterEnvVars.get("JENKINS_HOME") ... ************************************************************* ************************************************************* ************************************************************* Jenkins initial setup is required. An admin user has been created and a password generated. Please use the following password to proceed to installation: 205be6fe69c447dd933a3c9ce7420496 This may also be found at: /var/jenkins_home/secrets/initialAdminPassword ************************************************************* ************************************************************* ************************************************************* 

Setup Jenkins CI for a Java web app

Successivamente configureremo un semplice lavoro di applicazione web Java in Jenkins. Poiché l'applicazione non è importante per questo tutorial, utilizzeremo la mia semplice app di esempio Hello, World Servlet, che ho ospitato su GitHub.

Per testare Jenkins dovrai essere in grado di eseguire il commit delle modifiche a un repository di codice sorgente, quindi dovresti creare quel repository ora. Nella home page di Jenkins, fai clic sul pulsante Crea nuovi lavori e inserisci il nome del tuo progetto. Ti verrà chiesto di scegliere il tipo di progetto, come mostrato nella Figura 5.

Steven Haines

Sceglieremo il tipo di progetto Freestyle per questo progetto, ma dovresti essere consapevole delle tue opzioni:

  • Progetto Freestyle: questo tipo più comune di progetto consente di monitorare un repository di codice sorgente e utilizzare qualsiasi sistema di compilazione, come Maven e Ant.
  • Pipeline: Choose this project type for complicated projects with moving parts that you need to coordinate across multiple build slaves.
  • External job: Use this to configure an automated external job that you want to track in Jenkins as part of your build.
  • Multi-configuration project: This is the job type for projects that require different configurations for different environments, such as production, staging, and test.
  • Folder: When you have a complicated build then you might want to organize things into folders, each with their own distinct namespace.
  • Multi-branch pipeline: automatically create a set of pipeline projects, based on the code branches that are defined in your source code repository

Enter a project name, in this case "hello-world-servlet", and choose "OK". Next, choose GitHub project, then enter the GitHub URL of your project: //github.com/ligado/hello-world-servlet.

Under Source Code Management, choose Git and enter the same project URL.

In the Build Triggers section, choose Build when a change is pushed to GitHub so that Jenkins will build your code anytime you push a change to GitHub.

Nella sezione Build, aggiungi un nuovo passaggio di build, scegli Invoca target Maven di primo livello , scegli l'istanza Maven che hai configurato in precedenza (come "Maven 3.3.9") e inserisci clean install nel campo degli obiettivi. Lascia vuote le azioni post-compilazione per ora. Quando hai finito, premi Salva .

Quando torni alla dashboard dovresti vedere una schermata simile alla Figura 6.

Steven Haines

Per testare la tua configurazione, premi il pulsante Build Now accanto al progetto hello-world-servlet. Dovresti vedere una compilazione eseguita con successo nella Cronologia build sul lato sinistro della pagina del progetto, mostrato nella Figura 7.

Steven Haines

Per vedere esattamente cosa è successo, fai clic sulla build e quindi su Console output , che ti mostrerà tutti i passaggi eseguiti da Jenkins ei loro risultati. L'output della console è di seguito.