The document provides a comprehensive guide on Jenkins Pipeline scripting, explaining its definition, benefits, installation steps, and plugin management. It covers the creation of Jenkinsfiles, the two types of pipeline scripting (declarative and scripted), and various programming concepts such as variable declaration, operators, decision-making, loops, and methods. Additionally, it discusses the CI/CD process, Docker integration, and a sample application deployment process using a custom Docker image.
The document provides a comprehensive guide on Jenkins Pipeline scripting, explaining its definition, benefits, installation steps, and plugin management. It covers the creation of Jenkinsfiles, the two types of pipeline scripting (declarative and scripted), and various programming concepts such as variable declaration, operators, decision-making, loops, and methods. Additionally, it discusses the CI/CD process, Docker integration, and a sample application deployment process using a custom Docker image.
The document provides a comprehensive guide on Jenkins Pipeline scripting, explaining its definition, benefits, installation steps, and plugin management. It covers the creation of Jenkinsfiles, the two types of pipeline scripting (declarative and scripted), and various programming concepts such as variable declaration, operators, decision-making, loops, and methods. Additionally, it discusses the CI/CD process, Docker integration, and a sample application deployment process using a custom Docker image.
The document provides a comprehensive guide on Jenkins Pipeline scripting, explaining its definition, benefits, installation steps, and plugin management. It covers the creation of Jenkinsfiles, the two types of pipeline scripting (declarative and scripted), and various programming concepts such as variable declaration, operators, decision-making, loops, and methods. Additionally, it discusses the CI/CD process, Docker integration, and a sample application deployment process using a custom Docker image.
Download as DOCX, PDF, TXT or read online from Scribd
Download as docx, pdf, or txt
You are on page 1/ 18
Jenkins Pipeline Scripting ::
What is Jenkins Pipeline:
A Pipeline which provides an extensible set of tools for modeling simple-to-complex delivery of application. Pipelines are defined in Domain Specific Language (DSL) syntax . Typically, the definition of a Jenkins Pipeline is written into a text file (called a Jenkinsfile) which in turn is checked into a project’s source control repository. This is the foundation of "Pipeline- as-Code" which is stored in the git and helps us to version and review it like any other code.
Creating a Jenkinsfile provides a number of immediate benefits:
• Automatically create Pipelines for all Branches and Pull Requests
• Code review/iteration on the Pipeline • Audit trail for the Pipeline • Single source of truth
Note: generally considered best practice to define the Pipeline in a Jenkinsfile and check that in to source control.
#Once you are done with the installation of plugins execute the below. systemctl start jenkins systemctl enable jenkins
There are two ways of pipeline scripting they are as follows.
1. Declarative 2. scripted
Examples :
Examples ::
// Declarative //
pipeline { agent any ① stages { stage('Build') { ② steps { ③ sh 'make' ④ } } stage('Test'){ steps { sh 'make check' junit 'reports/**/*.xml' ⑤ } } stage('Deploy') { steps { sh 'make publish' } } } } // Script //
node { stage('Build') { sh 'make' } stage('Test') { sh 'make check' junit 'reports/**/*.xml' } stage('Deploy') { sh 'make publish' } }
Explain about journey example then explain below
Explain about application deployment process what term should be used where checkout & etc ...
Explain about each and every things like,
agent,stages,stage,steps,node
Teach them about pipeline-syntax & blueocean plugin and use cases
2. Declaring Variables :
Variable initialization & accessing variable.
def & println
Note: need to give inside script
Global Variables:
You will get all the globla variables as below from your jenkins https://<ipaddress:8080>/pipeline-syntax/globals
Accessing varibales using env:
examples for global variables
currentBuild.result, currentBuild.displayName, etc. Consult the built-in Global Variable
Reference for a complete, and up to date, list of properties available on currentBuild.
Defining Variables using environment:
Defining Variables using parameters:
Just use the pipeline syntax generator to generate the syntax like below. https://<jenkins:8080>/directive-generator/
Note: parameter variables can be accessible via "${params.ENV_VARIABLE}", with out params it will not work.
3. Using Operators :
Jenkins supports multiple operators like
arithmetic operators: +,-,/,%,*
unary operators: +,-
Assignment arithmetic operators:
+=,-=,*=,%=,/=
Relational operators: ==,!=,<,<=,>,>=
Logical operators:
&&,||,!
Bitwise operators: &,|,^,~
Conditional operators: not operator - !
4. Using Decision Making:
simple if statement: if-else statement: nested-if statement: switch statement: Note: Try to use input for taking the userinput. myval1.toInteger()
5. Using Loops:
while loop: for loop: for-in loop: break statement: Continue Statement:
6. Using Methods:
simple method: method with arguments/parameters: method with default parameters/arguments: method with return values:
7. Using I/O operations on files:
Reading files: Reading the Contents of a File as an Entire String: note: text = file.getText('UTF-8') write a new file: Note: If already file exists then the content will be lost. append the text to a file: Other fn()'s related to the file operations: - isFile() - isDirectory() - length() Creating a Directory: Delete a file/directory: Copying files: dstfile << srcfile.text
8. Explain about CI & CD process
Note: make sure you are installing dockers in the jenkins server. ###### yum install docker -y systemctl enable docker systemctl start docker Run jenkins as root user to avoid permission issues
Configure the Pipeline via Git SCM and show them the execution. Note: Don't forget to create the credentials
9. Explanation of total structure with dockers
pipeline { agent any/none/label/node/docker/dockerfile /* rest of the syntax */ }
Here if you are observing you can use agent part for running your code as part of the execution. We have ample of options like below, you can choose them as per your requirement.
- agent:
This "agent" should be added to the pipeline code. This tell us where our code should run, which means a server/container where code should run.
It accepts diff parameters some of them are below.
You can use any of the below parameters for passing to the agent like below.
Parameters:
- any Execute the Pipeline, or stage, on any available agent. For example: agent any
- none When applied at the top-level of the pipeline block no global agent will be allocated for the entire Pipeline run and each stage section will need to contain its own agent section. For
example: agent none
- label Execute the Pipeline, or stage, on an agent available in the Jenkins environment with the provided label. For example: agent { label 'my-defined-label' }
- node agent { node { label 'labelName' } } behaves the same as agent { label 'labelName' }, but node allows for additional options (such as customWorkspace).
- docker
helps in dynamically create the contianer from the respective image.
Execute the Pipeline, or stage, with a container built from a Dockerfile contained in the source repository. In order to use this option, the Jenkinsfile must be loaded from either a Multibranch Pipeline, or a "Pipeline from SCM." Conventionally this is the Dockerfile in the root of the source repository: agent { dockerfile true }. If building a Dockerfile in another directory, use the dir option: agent { dockerfile { dir 'someSubDir' } }. You can pass additional arguments to the docker build … command with the additionalBuildArgs option, like agent { dockerfile { additionalBuildArgs '--build-arg foo=bar' } }.
Note: make sure that you are giving {agent any } in the first section other wise you cannot declare agent in the subsequent stages !
CI & CD Design & Implementation ::
1. Java Web based Application Deployment Process ::
In this project we need to have one image with java,maven,tomcat installed and configured. Hence we are creating our own customised image using below docker file.
Base Image::
[root@jenkins myweb]# cat ../Dockerfile
FROM centos:7 # Installing Java ENV JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk ENV PATH=$PATH:$JAVA_HOME RUN yum install java-1.8.0-openjdk-devel wget git -y EXPOSE 8080
<!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> <Context antiResourceLocking="false" privileged="true" > <Manager sessionAttributeValueClassNameFilter="java\.lang\.(?:Boolean|Integer|Long| Number|String)|org\.apache\.catalina\.filters\.CsrfPreventionFilter\$LruCache(?:\$1)?|java\.util\. (?:Linked)?HashMap"/> </Context>
