Come creare la tua prima pipeline Jenkins?

Una guida passo passo alla creazione della pipeline Jenkins


Perché Jenkins Pipeline?

La consegna continua (CD) è una parte essenziale del ciclo di vita di DevOps.

Si assicura che gli sviluppatori di software / applicazioni che stanno creando sia sempre pronto per la produzione. Perché ciò avvenga, ogni volta che il codice viene aggiornato, deve essere creato, testato e distribuito continuamente. È qui che entra in scena Jenkins Pipeline.

In DevOps, l’integrazione continua e la consegna continua (CI / CD) vengono raggiunte tramite la pipeline Jenkins. L’uso di Jenkins Pipeline per CD aiuta a distribuire il software con versioni più veloci e frequenti. Questo aiuta a incorporare il feedback in ogni versione successiva.

Cos’è la pipeline Jenkins?

Jenkins Pipeline è una combinazione di lavori per fornire software in modo continuo utilizzando Jenkins.

Presumo tu sappia cos’è Jenkins. In caso contrario, dai un’occhiata a questo Corso Udemy per padroneggiare Jenkins.

Una pipeline Jenkins è composta da diversi stati o fasi e vengono eseguiti in sequenza uno dopo l’altro. JenkinsFile è un semplice file di testo utilizzato per creare una pipeline come codice in Jenkins. Contiene codice in Groovy Domain Specific Language (DSL), che è semplice da scrivere e leggibile dall’uomo.

È possibile eseguire JenkinsFile separatamente oppure eseguire anche il codice della pipeline dall’interfaccia utente Web di Jenkins. Esistono due modi per creare una pipeline usando Jenkins.

  • Dichiarativo: un nuovo modo di creare la pipeline Jenkins. Qui scrivi il codice groovy contenente i blocchi “pipeline”, che viene registrato in un SCM (Source Code Management)
  • Script – modo di scrivere codice groovy in cui il codice è definito all’interno di blocchi “nodo”.

Prima di entrare nella demo, se non hai installato Jenkins, installalo prima. Assicurati di avere Jenkins attivo e funzionante sul tuo sistema.

Crea una pipeline Jenkins

Ecco come appare un flusso di pipeline Jenkins, che consiste in più fasi tra gli sviluppatori che creano un software (codifica) e software distribuito in produzione.

Pipeline Jenkins

Creiamo una pipeline dichiarativa.

Nella dashboard di Jenkins, fai clic su Nuovo elemento. Quindi inserisci il nome di un articolo, ad esempio “Prima pipeline” e seleziona il progetto “Pipeline”. Quindi fare clic su OK.

Nuovo oggetto: pipeline Jenkins

Fare clic sulla scheda Pipeline come mostrato nell’immagine seguente e inserire qui il codice JenkinsFile (codice Groovy).

Codice file Jenkins

tubatura {
agente qualsiasi
fasi {
stage (‘Build’) {
passaggi {
echo ‘Ciao, GeekFlare. Avvio della creazione dell’app “.
}
}
stage (‘Test’) {
passaggi {
input (‘Vuoi procedere?’)
}
}
stage (‘Distribuisci’) {
parallelo {
stage (‘Distribuisci inizio’) {
passaggi {
eco "Inizia la distribuzione .."
}
}
stage (“Distribuzione ora”) {
agente {
docker {
reuseNode true
immagine “nginx”
}
}

passaggi {
eco "Docker creato"
}
}
}
}
stage (‘Prod’) {
passaggi {
eco "L’app è Prod Ready"
}

}
}
}

Lasciami spiegare i blocchi sopra.

  • Il tubatura Il blocco comprende tutte le istruzioni per compilare, testare e distribuire software. È il componente chiave di una pipeline Jenkins.
  • Un agente è assegnato per eseguire la pipeline su un nodo e allocare un’area di lavoro per la pipeline.
  • UN palcoscenico è un blocco che prevede passaggi per compilare, testare e distribuire l’applicazione. Le fasi vengono utilizzate per visualizzare i processi della pipeline Jenkins.
  • UN passo è una singola attività da eseguire, ad esempio creare una directory, eseguire un’immagine docker, eliminare un file, ecc.

Il codice Groovy sopra, sto usando per il file Jenkins. Qualsiasi agente disponibile viene assegnato alla pipeline. Quindi sto definendo il livello Build ed eseguendo un semplice passaggio di eco. Quindi ho definito la fase Test in cui il passaggio chiede se si desidera procedere o meno. Successivamente, ho creato una fase di distribuzione, che contiene altre due fasi in esecuzione in parallelo. La fase iniziale di distribuzione ha un passaggio con il comando echo e la distribuzione ora ha un passaggio che estrae un’immagine docker di Nginx sul nodo. Infine, c’è una fase Prod con un semplice passo di eco.

La pipeline sopra spiegata ha fasi che hanno semplici passaggi per capire come funziona. Dopo aver appreso come creare una pipeline, è possibile aggiungere più complessità e creare anche pipeline complesse.

Una volta che hai il codice nella scheda Pipeline, fai clic su Applica e salva. Infine, fai clic su Crea ora per iniziare a costruire la pipeline Jenkins che hai appena creato.

Costruisci ora

Ecco come apparirà l’interfaccia utente quando viene eseguita la pipeline. Se hai seguito tutti i passaggi correttamente, la tua build avrà esito positivo e mostrerà un colore blu per la build (# 27). Se ci sono errori nella build, questo darà colore rosso alla build (# 27).

Jenkins Build 27

Ora fai clic su build # 27 e quindi fai clic su Output console per verificare cosa è esattamente accaduto nel back-end durante l’esecuzione.

Jenkins Build

Ecco come apparirà l’output che termina con un messaggio SUCCESSO.

Uscita console di successo

Iniziato dall’utente geekflare
In esecuzione nel livello di durabilità: MAX_SURVIVABILITY
[Pipeline] Inizio della pipeline
Nodo [Pipeline]
In esecuzione su Jenkins in / var / lib / jenkins / workspace / First Pipeline
[Tubatura] {
Fase [Pipeline]
[Pipeline] {(Build)
[Pipeline] echo
Ciao, GeekFlare. Avvio della creazione dell’app.
[Tubatura] }
[Pipeline] // stage
Fase [Pipeline]
[Pipeline] {(Test)
Input [Pipeline]
Vuoi procedere?
Procedi o Annulla
Approvato da geekflare
[Tubatura] }
[Pipeline] // stage
Fase [Pipeline]
[Pipeline] {(Distribuisci)
[Pipeline] parallelo
[Pipeline] {(Branch: distribuire inizio)
[Pipeline] {(Branch: distribuzione ora)
Fase [Pipeline]
[Pipeline] {(inizio distribuzione)
Fase [Pipeline]
[Pipeline] {(Distribuzione ora)
[Pipeline] getContext
[Pipeline] isUnix
[Pipeline] sh
[Pipeline] echo
Inizia la distribuzione ..
[Tubatura] }
+ finestra mobile ispezionare -f. nginx
[Pipeline] // stage
[Tubatura] }

Errore: nessun oggetto del genere: nginx
[Pipeline] isUnix
[Pipeline] sh
+ docker pull nginx
Utilizzo del tag predefinito: più recente
ultimo: estrazione dalla libreria / nginx
8d691f585fa8: pulling fs layer
5b07f4e08ad0: pulling fs layer
abc291867bca: pulling fs layer
abc291867bca: verifica checksum
abc291867bca: download completato
5b07f4e08ad0: verifica checksum
5b07f4e08ad0: download completato
8d691f585fa8: verifica checksum
8d691f585fa8: download completato
8d691f585fa8: pull completato
5b07f4e08ad0: pull completato
abc291867bca: pull completato
Digest: sha256: 922c815aa4df050d4df476e92daed4231f466acc8ee90e0e774951b0fd7195a4
Stato: immagine più recente scaricata per nginx: ultima
[Pipeline] withDockerContainer
Jenkins non sembra correre all’interno di un container
$ docker run -t -d -u 125: 131 -w "/ var / lib / jenkins / workspace / First Pipeline" -v "/ var / lib / jenkins / workspace / First Pipeline: / var / lib / jenkins / workspace / First Pipeline: rw, z" -v "/ Var / lib / Jenkins / lavoro / First [Email protected]: / Var / lib / Jenkins / lavoro / First [Email protected]: Rw, z" -e ******** -e ******** -e ******** -e ******** -e ******** – e ******** -e ******** -e ******** -e ******** -e ******** – e ******** -e ******** -e ******** -e ******** -e ******** – e ******** -e ******** -e ******** -e ******** -e ******** – e ******** -e ******** -e ******** nginx cat
$ docker top 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943 -eo pid, comm
[Tubatura] {
[Pipeline] echo
Docker creato
[Tubatura] }
$ docker stop –time = 1 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943
$ docker rm -f 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943
[Pipeline] // withDockerContainer
[Tubatura] }
[Pipeline] // stage
[Tubatura] }
[Pipeline] // parallel
[Tubatura] }
[Pipeline] // stage
Fase [Pipeline]
[Pipeline] {(Prod)
[Pipeline] echo
L’app è Prod Ready
[Tubatura] }
[Pipeline] // stage
[Tubatura] }
[Pipeline] // nodo
[Pipeline] End of Pipeline
Finito: SUCCESSO

La pipeline Jenkins sopra ha creato un’immagine docker di Nginx. Puoi verificarlo eseguendo il comando seguente. Puoi vedere l’immagine della finestra mobile Nginx elencata.

[Email protected]: ~ $ docker image ls
DIMENSIONE IMMAGINE TAG IMMAGINE REPOSITORIA
nginx latest 540a289bab6c 2 settimane fa 126MB
httpd latest 7d85cc3b2d80 2 mesi fa 154MB
redis latest f7302e4ab3a8 2 mesi fa 98.2MB
geekflare_mongodb latest 095d17727ca0 3 mesi fa 325MB

Conclusione

Spero che questo ti dia un’idea Gasdotto Jenkins vantaggi e come è possibile crearne uno. Quanto sopra è una semplice dimostrazione e il modo migliore per imparare è provare a costruire condutture complesse.

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map