Jenkins Pipelines Fundamentals

# CHAPTER 5

Jenkins Pipelines Fundamentals #

1. Introduction #

2. Learning Objectives #

• Define "Pipeline as Code" and its benefits over Freestyle jobs.

• Understand the purpose of a Jenkinsfile.

• Differentiate between Declarative and Scripted Pipeline syntax.

• Understand the core building blocks: Pipeline, Agent, Stages, and Steps.

• Create your first basic Pipeline job in Jenkins.

3. Beginner-Friendly Explanation #

• Freestyle Job: The director verbally tells each actor where to stand right before the curtain opens. If the director gets sick, the actors have no idea what to do.

• Pipeline as Code: The director writes a comprehensive Script (The Jenkinsfile). The script is handed to the actors (Jenkins). It says:

• *Act 1 (Stage 1):* Build the set.

• *Act 2 (Stage 2):* Test the lighting.

• *Act 3 (Stage 3):* Perform the play.

4. The Jenkinsfile #

1. 1. Version Control: If someone breaks the deployment script, you can look at GitHub, see exactly who changed the Jenkinsfile, and instantly revert it to the previous working version.

1. 2. Portability: If your Jenkins server explodes, you just spin up a new empty Jenkins server, point it at your GitHub repo, and Jenkins automatically reads the Jenkinsfile and rebuilds your entire CI/CD process instantly.

5. Declarative vs. Scripted Syntax #

1. 1. Scripted Pipeline (The Old Way): Very flexible, but uses complex programming logic (if/else loops, try/catch blocks). It is harder for beginners to read.

1. 2. Declarative Pipeline (The Modern Standard): Introduced to make pipelines easier to read and write. It uses a strict, structured block format. It is essentially a configuration file. We will focus entirely on Declarative Pipelines as they are the industry best practice.

6. The Core Anatomy of a Declarative Pipeline #

1. 1. pipeline {}: The wrapper block containing the entire script.

1. 2. agent: Tells Jenkins *where* to run the code. (agent any means run on the Jenkins server itself. Later, we'll tell it to run inside a specific Docker container).

1. 3. stages {}: A wrapper that contains all the different phases of your process.

1. 4. steps {}: The actual commands you want to run (like echo or sh for shell commands) inside a specific stage.

7. Mini Project: Create First Jenkins Pipeline #

Step-by-Step Walkthrough:

1. 1. On the Jenkins dashboard, click New Item.

1. 2. Name it My-First-Pipeline, select Pipeline (not Freestyle), and click OK.

1. 3. Scroll down to the Pipeline section at the bottom.

1. 4. Ensure the Definition is set to "Pipeline script".

1. 5. In the large text box, type the following Declarative Pipeline code exactly:

pipeline {
    // Run on any available Jenkins server
    agent any 

    // Define the sequence of events
    stages {
        stage('Build') {
            steps {
                echo 'Compiling the application...'
            }
        }
        stage('Test') {
            steps {
                echo 'Running automated tests...'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying to staging server!'
            }
        }
    }
}

1. 6. Click Save.

1. 7. Click Build Now.

1. 8. Look at the "Stage View" on the project page. You will see beautiful green boxes indicating that the Build, Test, and Deploy stages all passed sequentially!

8. Real-World Scenarios #

9. Best Practices #

• Do NOT write the script in the UI long-term: In the mini-project above, we typed the code into the Jenkins UI text box for learning purposes. In the real world, you must change the definition from "Pipeline script" to "Pipeline script from SCM" (Source Control Management), telling Jenkins to pull the Jenkinsfile directly from GitHub.

10. Troubleshooting Tips #

• Missing Brackets: Declarative pipelines are highly structured. If you miss a single closing curly brace }, the entire pipeline will crash with a Groovy parsing error before it even starts. Pay close attention to indentation and bracket matching.

11. Exercises #

1. 1. List the three major benefits of using "Pipeline as Code" over configuring jobs manually in the Jenkins web UI.

1. 2. Identify the four mandatory blocks required in a valid Declarative Pipeline.

12. FAQs #

13. Interview Questions #

• Q: Contrast Declarative Pipelines with Scripted Pipelines in Jenkins. Why did the community shift heavily toward the Declarative model?

• Q: Explain the concept of "Infrastructure as Code" (IaC) and how "Pipeline as Code" aligns with that operational philosophy.

14. Summary #

15. Next Chapter Recommendation #