{"id":1819,"date":"2026-10-29T09:35:13","date_gmt":"2026-10-29T09:35:13","guid":{"rendered":"https:\/\/devopsschool.org\/blog\/?p=1819"},"modified":"2026-10-29T09:35:15","modified_gmt":"2026-10-29T09:35:15","slug":"jenkins-for-students-how-to-automate-software-builds-and-tests","status":"publish","type":"post","link":"https:\/\/devopsschool.org\/blog\/jenkins-for-students-how-to-automate-software-builds-and-tests\/","title":{"rendered":"Jenkins for Students: How to Automate Software Builds and Tests"},"content":{"rendered":"\n
\"\"<\/figure>\n\n\n\n

1. Introduction<\/h2>\n\n\n\n

Every developer remembers the anxiety of working on a group programming project where everyone\u2019s code worked fine on their personal laptop, but everything shattered into cryptic errors once merged together the night before submission. One teammate used an outdated Java version, another modified an interface without telling anyone, and a third forgot to commit a critical dependency.<\/p>\n\n\n\n

Software engineering teams in the tech industry face this exact challenge every day, but on a massive scale. To solve it, engineering organizations rely on automated, repeatable processes that build, test, and validate software every single time an engineer pushes a code change. Instead of guessing whether an application compiles or passes its test suite, teams use automated continuous feedback loops. At the center of this industry-standard practice sits Jenkins<\/strong>, an open-source automation server that powers modern Continuous Integration and Continuous Delivery (CI\/CD) workflows. For university students, recent graduates, and aspiring engineers learning through educational platforms like DevOpsSchool<\/strong>, mastering Jenkins bridges the gap between writing simple code assignments and understanding real-world software delivery pipelines. Learning Jenkins for students<\/strong> is not merely about clicking buttons on a dashboard; it provides foundational insight into build automation, regression testing, pipeline design, configuration management, and the collaborative operational culture known as DevOps. By learning to automate builds and tests early in your academic journey, you develop the disciplined habits top software engineering teams expect from junior hires.<\/p>\n\n\n\n

2. What Is Jenkins?<\/h2>\n\n\n\n

Jenkins is a self-contained, open-source automation server designed to coordinate and automate tasks throughout the software development lifecycle. Written in Java, it acts as an orchestration engine that watches your code repositories for updates, triggers execution routines, runs test suites, packages binary distributions, and reports the status back to the engineering team.<\/p>\n\n\n\n

Manual vs. Automated Builds<\/h3>\n\n\n\n

To understand why Jenkins is essential, consider the contrast between manual and automated workflows:<\/p>\n\n\n\n

Aspect<\/strong><\/td>Manual Build Process<\/strong><\/td>Automated Build Process (Jenkins)<\/strong><\/td><\/tr><\/thead>
Execution Trigger<\/strong><\/td>Developer manually types commands in a local terminal<\/td>Automatically triggered by a Git push, pull request, or schedule<\/td><\/tr>
Environment Consistency<\/strong><\/td>Highly variable; depends on local machine state and configurations<\/td>Standardized across reproducible build environments<\/td><\/tr>
Test Verification<\/strong><\/td>Easily skipped, forgotten, or executed incompletely<\/td>Enforced automatically before code is accepted or packaged<\/td><\/tr>
Feedback Loop<\/strong><\/td>Slow; bugs often discovered days or weeks later<\/td>Fast; failures reported within minutes of a code push<\/td><\/tr>
Human Effort<\/strong><\/td>Repetitive, prone to human error, and time-consuming<\/td>“Set and forget” pipeline definition executed automatically<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

How Jenkins Supports CI\/CD<\/h3>\n\n\n\n

Jenkins fundamentally supports two stages of modern software delivery:<\/p>\n\n\n\n

    \n
  1. Continuous Integration (CI):<\/strong> Developers integrate their code into a shared repository frequently\u2014often multiple times a day. Jenkins verifies each check-in by automatically building the application and running automated tests. This detects bugs early and pinpoints the exact commit that introduced a defect.<\/li>\n\n\n\n
  2. Continuous Delivery (CD):<\/strong> Once the build and test stages pass, Jenkins can automatically stage the packaged application for release or deploy it directly to staging or production environments.<\/li>\n<\/ol>\n\n\n\n

    The Role of an Orchestrator<\/h3>\n\n\n\n

    A common misconception among beginners is that Jenkins compiles your code or executes unit tests natively. In reality, Jenkins is an orchestrator, not a compiler.<\/strong> Jenkins does not inherently know how to compile Java, package Python, or transpile TypeScript.<\/p>\n\n\n\n

    Instead, Jenkins coordinates specialized tools and plugins. It uses a Version Control System (VCS) like Git to fetch code, hands the code over to a build tool like Apache Maven or Gradle to compile and test it, runs test runners like JUnit, and parses the resulting test reports to determine if the pipeline passed or failed. Jenkins provides the environment, schedules the tasks, records the output, and signals success or failure.<\/p>\n\n\n\n

    3. Understanding Builds, Automated Tests, and CI<\/h2>\n\n\n\n

    Before configuring an automated server, you must understand the core concepts behind the lifecycle of an automated run.<\/p>\n\n\n\n

    +---------------+      Git Push      +--------------------+\n|   Developer   | -----------------> |  Code Repository   |\n| (Local Code)  |                    |      (GitHub)      |\n+---------------+                    +--------------------+\n                                               |\n                                        Webhook Event\n                                               v\n+---------------------------------------------------------+\n|                    Jenkins Controller                   |\n|                                                         |\n|  +----------------+   +----------------+   +---------+  |\n|  | 1. Checkout Git|-->| 2. Maven Build |-->| 3. Test |  |\n|  +----------------+   +----------------+   +---------+  |\n|                                                 |       |\n|                                            JUnit XML    |\n|                                                 v       |\n|  +----------------+                       +----------+  |\n|  | Fast Feedback  |<----------------------| 4. Report|  |\n|  | (Pass \/ Fail)  |                       +----------+  |\n|  +----------------+                                     |\n+---------------------------------------------------------+\n<\/code><\/pre>\n\n\n\n
    What Is a Software Build?<\/h3>\n\n\n\n
    A software build transforms source code files written by humans into executable machine code, bytecode, or deployable software packages (such as .jar<\/code>, .war<\/code>, or .zip<\/code> files).<\/p>\n\n\n\n
    A build process includes:<\/p>\n\n\n\n
      \n
    • Dependency Management:<\/strong> Downloading and linking external libraries, frameworks, and packages specified by the project (for example, via Maven’s pom.xml<\/code> or Node’s package.json<\/code>).<\/li>\n\n\n\n
    • Compilation:<\/strong> Converting human-readable source code into machine-executable formats while verifying syntax and interface contracts.<\/li>\n\n\n\n
    • Resource Processing:<\/strong> Copying and formatting static assets, configuration files, and properties.<\/li>\n\n\n\n
    • Packaging:<\/strong> Assembling the compiled code and resources into an archive ready for execution or distribution.<\/li>\n<\/ul>\n\n\n\n
      The Testing Pyramid<\/h3>\n\n\n\n
      Automated testing evaluates software behavior against expected outcomes without requiring human testers to click through an application manually. Automated tests fall into three primary categories:<\/p>\n\n\n\n
        \n
      • Unit Tests:<\/strong> These verify the smallest testable parts of an application\u2014such as a single function, class, or method\u2014in complete isolation from databases, networks, or file systems. They execute in milliseconds and should make up the majority of your test suite.<\/li>\n\n\n\n
      • Integration Tests:<\/strong> These verify that distinct components, modules, or services function correctly together (for example, verifying that an authentication class interacts properly with a test database).<\/li>\n\n\n\n
      • End-to-End (E2E) \/ System Tests:<\/strong> These exercise the entire application flow from start to finish, mimicking real user journeys through user interfaces or public API endpoints.<\/li>\n<\/ul>\n\n\n\n
        The Cost of Build and Test Failures<\/h3>\n\n\n\n
        In a manual setup, if a developer breaks a calculation inside a core helper function, that defect might go unnoticed until another teammate pulls the changes days later\u2014or worse, after the software is handed to a customer.<\/p>\n\n\n\n
        Continuous Integration enforces early feedback<\/strong>. Suppose a student updates a discount calculation in an e-commerce class:<\/p>\n\n\n\n
          \n
        1. The student commits and pushes the code change to Git.<\/li>\n\n\n\n
        2. Jenkins detects the push and immediately starts an automated build.<\/li>\n\n\n\n
        3. Jenkins invokes the build tool to run all unit tests.<\/li>\n\n\n\n
        4. An existing test checks: calculateDiscount(100, 0.20)<\/code> and expects 80<\/code>. The new code returns 20<\/code>.<\/li>\n\n\n\n
        5. The test runner registers an assertion error and terminates with an exit code indicating failure.<\/li>\n\n\n\n
        6. Jenkins halts the pipeline, marks the build as Failed (Red)<\/strong>, and notifies the developer within minutes.<\/li>\n\n\n\n
        7. The developer reviews the test failure output, fixes the logic error, pushes the correction, and Jenkins turns Healthy (Green)<\/strong>.<\/li>\n<\/ol>\n\n\n\n
          4. How Jenkins Works: Architecture and Core Components<\/h2>\n\n\n\n
          Jenkins uses a distributed, modular architecture capable of scaling from a single laptop to thousands of servers across enterprise data centers.<\/p>\n\n\n\n
                               +---------------------------------------+\n                     |          Jenkins Controller           |\n                     |  - Web UI & HTTP Dashboard            |\n                     |  - Configuration & Plugin Engine      |\n                     |  - Build Job Scheduler                |\n                     |  - Credentials Vault                  |\n                     +---------------------------------------+\n                                  \/            \\\n                      Work Request \/              \\ Work Request\n                                  \/                \\\n                                 v                  v\n                 +----------------------+    +----------------------+\n                 |     Agent Node 1     |    |     Agent Node 2     |\n                 |  (Build Environment) |    |  (Build Environment) |\n                 |  - Git, JDK, Maven   |    |  - Docker, Python    |\n                 |  - Executes Tasks    |    |  - Executes Tasks    |\n                 +----------------------+    +----------------------+\n<\/code><\/pre>\n\n\n\n
          Core Components<\/h3>\n\n\n\n
            \n
          • Controller (formerly Master):<\/strong> The brain of the Jenkins installation. The controller provides the web UI, manages plugins, schedules build jobs, stores job definitions and build history, handles credentials, and assigns work tasks.<\/li>\n\n\n\n
          • Agents (formerly Slaves):<\/strong> Worker machines or containers that connect to the controller and carry out the physical execution of build steps. Agents keep heavy compilation tasks off the controller. In small learning environments, Jenkins provides a built-in node<\/strong> directly on the controller to run jobs locally. However, production environments assign workloads to isolated agents for security and performance.<\/li>\n\n\n\n
          • Jobs and Pipelines:<\/strong> A job<\/em> (or item) is any automated task sequence managed by Jenkins. A pipeline<\/em> is an advanced, user-defined model of a continuous delivery path, structured into sequential stages such as Build, Test, and Deploy.<\/li>\n\n\n\n
          • Workspaces:<\/strong> An isolated directory on the file system of the machine executing the build. Jenkins creates a workspace for each job, checks out your project’s source code into it, runs tools against it, and cleans it up when instructed.<\/li>\n\n\n\n
          • Plugins:<\/strong> Jenkins is built on an extensible plugin system. The base installation has minimal features; plugins provide integration with tools like Git, GitHub, Docker, Maven, Slack, and JUnit reporting.<\/li>\n\n\n\n
          • Build History and Console Output:<\/strong> Every time a job runs, Jenkins creates an immutable historical record labeled with a sequential build number (#1<\/code>, #2<\/code>, #3<\/code>). Jenkins captures the full terminal standard output (stdout<\/code>) and standard error (stderr<\/code>) logs, allowing you to debug exactly what happened during execution.<\/li>\n\n\n\n
          • Credentials Management:<\/strong> A centralized, encrypted vault inside Jenkins that lets you store API keys, SSH private keys, and passwords. Jobs reference these secrets securely via IDs without ever hardcoding sensitive tokens into your project source code.<\/li>\n<\/ul>\n\n\n\n
            5. Setting Up Jenkins for Learning<\/h2>\n\n\n\n
            To learn Jenkins step by step, you need a local sandbox environment.<\/p>\n\n\n\n
            System Requirements<\/h3>\n\n\n\n
            Before beginning, confirm your machine meets these basic requirements:<\/p>\n\n\n\n
              \n
            • Operating System:<\/strong> Linux (Ubuntu\/Debian, CentOS\/RHEL), macOS, or Windows 10\/11 (with WSL2 recommended).<\/li>\n\n\n\n
            • Memory (RAM):<\/strong> Minimum 2 GB to 4 GB allocated for Jenkins and your build tools.<\/li>\n\n\n\n
            • Disk Space:<\/strong> At least 10 GB free for Jenkins, runtime logs, dependencies, and local git clones.<\/li>\n\n\n\n
            • Runtime:<\/strong> A supported Java Development Kit (JDK) or Java Runtime Environment (JRE). Modern versions of Jenkins require Java 17 or Java 21<\/strong>.<\/li>\n<\/ul>\n\n\n\n
              Setup Methods: Native vs. Docker<\/h3>\n\n\n\n
              Students typically choose between two setups:<\/p>\n\n\n\n
                \n
              1. Docker Container (Recommended for Students):<\/strong> Running Jenkins inside an official container isolates the automation server from your local operating system, avoids dependency conflicts, and allows you to tear down and recreate environments in seconds.<\/li>\n\n\n\n
              2. Native Host Installation:<\/strong> Installing Java and the Jenkins package directly on your operating system using package managers (apt<\/code>, brew<\/code>, or native installers).<\/li>\n<\/ol>\n\n\n\n
                Method A: Running Jenkins via Docker<\/h4>\n\n\n\n
                If you have Docker Desktop installed, run this command in your terminal:<\/p>\n\n\n\n
                Bash<\/p>\n\n\n\n
                docker run -d \\\n  --name jenkins-learning \\\n  -p 8080:8080 \\\n  -p 50000:50000 \\\n  -v jenkins_home:\/var\/jenkins_home \\\n  jenkins\/jenkins:lts-jdk17\n<\/code><\/pre>\n\n\n\n
                  \n
                • -p 8080:8080<\/code>: Exposes the Jenkins web dashboard on port 8080<\/code>.<\/li>\n\n\n\n
                • -p 50000:50000<\/code>: Allows external Jenkins agents to communicate with the controller.<\/li>\n\n\n\n
                • -v jenkins_home:...<\/code>: Mounts a persistent Docker volume so your pipeline configurations, job history, and plugin settings survive container restarts.<\/li>\n<\/ul>\n\n\n\n
                  Method B: Native Installation on Ubuntu\/Debian Linux<\/h4>\n\n\n\n
                  For a native install on Linux, verify that Java 17 is present:<\/p>\n\n\n\n
                  Bash<\/p>\n\n\n\n
                  # Update repositories and install OpenJDK 17\nsudo apt-get update\nsudo apt-get install -y openjdk-17-jdk\n\n# Verify Java version\njava -version\n<\/code><\/pre>\n\n\n\n
                  Next, add the official Jenkins Debian repository key, register the repository sources list, update your packages, and install Jenkins:<\/p>\n\n\n\n
                  Bash<\/p>\n\n\n\n
                  sudo wget -O \/usr\/share\/keyrings\/jenkins-keyring.asc \\\n  https://pkg.jenkins.io\/debian-stable\/jenkins.io-2023.key\n\necho \"deb [signed-by=\/usr\/share\/keyrings\/jenkins-keyring.asc] \\\n  https:\/\/pkg.jenkins.io\/debian-stable binary\/\" | sudo tee \\\n  \/etc\/apt\/sources.list.d\/jenkins.list > \/dev\/null\n\nsudo apt-get update\nsudo apt-get install -y jenkins\n\n# Enable and start the Jenkins service\nsudo systemctl enable jenkins\nsudo systemctl start jenkins\n<\/code><\/pre>\n\n\n\n
                  Initial Administrator Setup<\/h3>\n\n\n\n
                  Once Jenkins starts, complete the setup wizard:<\/p>\n\n\n\n
                    \n
                  1. Open a browser and navigate to http:\/\/localhost:8080<\/code>.<\/li>\n\n\n\n
                  2. Unlock Jenkins:<\/strong> The browser displays a screen asking for an initial administrator password.\n
                      \n
                    • If running natively on Linux:Bashsudo cat \/var\/lib\/jenkins\/secrets\/initialAdminPassword<\/code><\/li>\n\n\n\n
                    • If running via Docker:Bashdocker exec jenkins-learning cat \/var\/jenkins_home\/secrets\/initialAdminPassword<\/code><\/li>\n<\/ul>\n<\/li>\n\n\n\n
                    • Copy the 32-character alphanumeric string, paste it into the setup screen, and click Continue<\/strong>.<\/li>\n\n\n\n
                    • Customize Jenkins:<\/strong> Click Install suggested plugins<\/strong>. This installs the default plugins for Git, Pipeline support, credentials, and common dashboard utilities.<\/li>\n\n\n\n
                    • Create First Admin User:<\/strong> Fill out the form with a username, password, full name, and email address (for example, studentadmin<\/code>). Avoid relying on the temporary admin<\/code> account.<\/li>\n\n\n\n
                    • Instance Configuration:<\/strong> Confirm the default URL (http:\/\/localhost:8080<\/code>) and select Save and Finish<\/strong>. Your Jenkins dashboard is ready.<\/li>\n<\/ol>\n\n\n\n
                      6. Prepare a Sample Application for Automation<\/h2>\n\n\n\n
                      To understand Jenkins build automation<\/strong>, you need an application project to build and test. We will use a standard Java application configured with Apache Maven.<\/p>\n\n\n\n
                      Standard Maven Project Directory Structure<\/h3>\n\n\n\n
                      Maven relies on a standard directory layout. Create this structure locally on your workstation or in a new Git repository:<\/p>\n\n\n\n
                      Plaintext<\/p>\n\n\n\n
                      simple-java-app\/\n\u251c\u2500\u2500 pom.xml\n\u2514\u2500\u2500 src\n    \u251c\u2500\u2500 main\n    \u2502   \u2514\u2500\u2500 java\n    \u2502       \u2514\u2500\u2500 com\n    \u2502           \u2514\u2500\u2500 devopsschool\n    \u2502               \u2514\u2500\u2500 Calculator.java\n    \u2514\u2500\u2500 test\n        \u2514\u2500\u2500 java\n            \u2514\u2500\u2500 com\n                \u2514\u2500\u2500 devopsschool\n                    \u2514\u2500\u2500 CalculatorTest.java\n<\/code><\/pre>\n\n\n\n
                        \n
                      • pom.xml<\/code>: The Project Object Model file containing project configuration, dependencies, and build plugins.<\/li>\n\n\n\n
                      • src\/main\/java<\/code>: Stores your application’s production source code.<\/li>\n\n\n\n
                      • src\/test\/java<\/code>: Stores automated test suites, such as unit tests.<\/li>\n<\/ul>\n\n\n\n
                        1. The Build Configuration (pom.xml<\/code>)<\/h3>\n\n\n\n
                        This minimal pom.xml<\/code> configures a Java project with the modern JUnit 5 (Jupiter) testing framework and the Maven Surefire plugin for running tests:<\/p>\n\n\n\n
                        XML<\/p>\n\n\n\n
                        <project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\"\n         xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n         xsi:schemaLocation=\"http:\/\/maven.apache.org\/POM\/4.0.0 \n         https:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\n    <modelVersion>4.0.0<\/modelVersion>\n\n    <groupId>com.devopsschool<\/groupId>\n    <artifactId>simple-java-app<\/artifactId>\n    <version>1.0.0<\/version>\n    <packaging>jar<\/packaging>\n\n    <properties>\n        <maven.compiler.source>17<\/maven.compiler.source>\n        <maven.compiler.target>17<\/maven.compiler.target>\n        <project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\n        <junit.version>5.10.2<\/junit.version>\n    <\/properties>\n\n    <dependencies>\n        <!-- JUnit Jupiter API & Test Engine -->\n        <dependency>\n            <groupId>org.junit.jupiter<\/groupId>\n            <artifactId>junit-jupiter<\/artifactId>\n            <version>${junit.version}<\/version>\n            <scope>test<\/scope>\n        <\/dependency>\n    <\/dependencies>\n\n    <build>\n        <plugins>\n            <!-- Maven Surefire Plugin to execute tests during the build lifecycle -->\n            <plugin>\n                <groupId>org.apache.maven.plugins<\/groupId>\n                <artifactId>maven-surefire-plugin<\/artifactId>\n                <version>3.2.5<\/version>\n            <\/plugin>\n        <\/plugins>\n    <\/build>\n<\/project>\n<\/code><\/pre>\n\n\n\n
                        2. The Application Code (Calculator.java<\/code>)<\/h3>\n\n\n\n
                        Place this file in src\/main\/java\/com\/devopsschool\/Calculator.java<\/code>:<\/p>\n\n\n\n
                        Java<\/p>\n\n\n\n
                        package com.devopsschool;\n\npublic class Calculator {\n\n    public int add(int a, int b) {\n        return a + b;\n    }\n\n    public int subtract(int a, int b) {\n        return a - b;\n    }\n\n    public int multiply(int a, int b) {\n        return a * b;\n    }\n\n    public double divide(int a, int b) {\n        if (b == 0) {\n            throw new IllegalArgumentException(\"Division by zero is not allowed.\");\n        }\n        return (double) a \/ b;\n    }\n}\n<\/code><\/pre>\n\n\n\n
                        3. The Unit Test Suite (CalculatorTest.java<\/code>)<\/h3>\n\n\n\n
                        Place this file in src\/test\/java\/com\/devopsschool\/CalculatorTest.java<\/code>:<\/p>\n\n\n\n
                        Java<\/p>\n\n\n\n
                        package com.devopsschool;\n\nimport org.junit.jupiter.api.BeforeEach;\nimport org.junit.jupiter.api.DisplayName;\nimport org.junit.jupiter.api.Test;\n\nimport static org.junit.jupiter.api.Assertions.assertEquals;\nimport static org.junit.jupiter.api.Assertions.assertThrows;\n\npublic class CalculatorTest {\n\n    private Calculator calculator;\n\n    @BeforeEach\n    void setUp() {\n        calculator = new Calculator();\n    }\n\n    @Test\n    @DisplayName(\"Test addition of two integers\")\n    void testAdd() {\n        assertEquals(15, calculator.add(10, 5), \"10 + 5 should equal 15\");\n    }\n\n    @Test\n    @DisplayName(\"Test subtraction of two integers\")\n    void testSubtract() {\n        assertEquals(5, calculator.subtract(10, 5), \"10 - 5 should equal 5\");\n    }\n\n    @Test\n    @DisplayName(\"Test division by zero throws exception\")\n    void testDivideByZero() {\n        assertThrows(IllegalArgumentException.class, () -> {\n            calculator.divide(10, 0);\n        }, \"Dividing by zero must throw IllegalArgumentException\");\n    }\n}\n<\/code><\/pre>\n\n\n\n
                        Initialize a local Git repository, commit these files, and push them to a Git hosting provider such as GitHub, GitLab, or Gitea:<\/p>\n\n\n\n
                        Bash<\/p>\n\n\n\n
                        git init\ngit add .\ngit commit -m \"Initial commit of student calculator project with unit tests\"\ngit branch -M main\n# Add your remote and push\n# git remote add origin https:\/\/github.com\/<your-username>\/simple-java-app.git\n# git push -u origin main\n<\/code><\/pre>\n\n\n\n
                        7. Create Your First Jenkins Job<\/h2>\n\n\n\n
                        Before jumping into code-based pipelines, it helps to understand what a Jenkins job looks like under the hood.<\/p>\n\n\n\n
                        Freestyle Jobs vs. Pipeline Jobs<\/h3>\n\n\n\n
                        When creating a job in Jenkins, you will see several options:<\/p>\n\n\n\n
                          \n
                        • Freestyle Project:<\/strong> The legacy, UI-driven way to configure builds in Jenkins. You configure Git repositories, shell commands, and post-build actions using forms and dropdown menus in the browser. While easy for beginners to understand, Freestyle jobs cannot be version-controlled, reviewed, or easily migrated.<\/li>\n\n\n\n
                        • Pipeline Project:<\/strong> The modern, production-standard approach. The entire workflow is written as code using a domain-specific language (DSL) and stored directly in your Git repository alongside your application code.<\/li>\n<\/ul>\n\n\n\n
                          Exploring a Basic Freestyle Build (Walkthrough)<\/h3>\n\n\n\n
                          To understand how Jenkins interacts with tools on the underlying host, create a temporary Freestyle job:<\/p>\n\n\n\n
                            \n
                          1. On the Jenkins dashboard, click New Item<\/strong>.<\/li>\n\n\n\n
                          2. Enter the name my-first-freestyle-job<\/code>, select Freestyle project<\/strong>, and click OK<\/strong>.<\/li>\n\n\n\n
                          3. Under General<\/strong>, add a short description: Testing basic shell execution<\/em>.<\/li>\n\n\n\n
                          4. Scroll to the Build Steps<\/strong> section, click Add build step<\/strong>, and select Execute shell<\/strong> (or Execute Windows batch command<\/em> if running natively on Windows).<\/li>\n\n\n\n
                          5. Enter a simple command:Bashecho \"Running build on agent: $(hostname)\" echo \"Current workspace directory: $(pwd)\" java -version<\/code><\/li>\n\n\n\n
                          6. Click Save<\/strong>.<\/li>\n<\/ol>\n\n\n\n
                            Running the Job and Inspecting Output<\/h3>\n\n\n\n
                              \n
                            1. On the left navigation sidebar of your new job, click Build Now<\/strong>.<\/li>\n\n\n\n
                            2. Notice that a new item appears in the Build History<\/strong> box: #1<\/code>.<\/li>\n\n\n\n
                            3. Click the #1<\/code> link, then select Console Output<\/strong>.<\/li>\n<\/ol>\n\n\n\n
                              Plaintext<\/p>\n\n\n\n
                              Started by user studentadmin\nRunning as SYSTEM\nBuilding in workspace \/var\/jenkins_home\/workspace\/my-first-freestyle-job\n[my-first-freestyle-job] $ \/bin\/sh -xe \/tmp\/jenkins847291048293.sh\n+ echo 'Running build on agent: jenkins-learning'\nRunning build on agent: jenkins-learning\n+ echo 'Current workspace directory: \/var\/jenkins_home\/workspace\/my-first-freestyle-job'\nCurrent workspace directory: \/var\/jenkins_home\/workspace\/my-first-freestyle-job\n+ java -version\nopenjdk version \"17.0.10\" 2024-01-16\nOpenJDK Runtime Environment Temurin-17.0.10+7 (build 17.0.10+7)\nOpenJDK 64-Bit Server VM Temurin-17.0.10+7 (build 17.0.10+7, mixed mode)\nFinished: SUCCESS\n<\/code><\/pre>\n\n\n\n
                              The console output shows every command executed by Jenkins, along with its standard output, standard error, and exit status. An exit code of 0<\/code> results in Finished: SUCCESS<\/code> (represented by a blue<\/strong> or green<\/strong> ball depending on your UI theme). Any non-zero exit code stops execution and marks the job as Finished: FAILURE<\/code> (red<\/strong> ball).<\/p>\n\n\n\n
                              8. Build a Jenkins Pipeline Using a Jenkinsfile<\/h2>\n\n\n\n
                              Freestyle jobs work for quick experiments, but modern DevOps relies on Pipeline as Code<\/strong>. By defining your build, test, and release logic in a text file named Jenkinsfile<\/code> and committing it to your Git repository, your automation pipeline is versioned, reviewed, and audited just like your application code.<\/p>\n\n\n\n
                              Declarative vs. Scripted Pipelines<\/h3>\n\n\n\n
                              Jenkins supports two pipeline syntaxes:<\/p>\n\n\n\n
                                \n
                              • Declarative Pipeline:<\/strong> A structured, opinionated format with clear syntax blocks (pipeline<\/code>, agent<\/code>, stages<\/code>, steps<\/code>). It is easy to read, catches configuration errors early, and is the industry-standard syntax for nearly all modern CI pipelines.<\/li>\n\n\n\n
                              • Scripted Pipeline:<\/strong> An older, Groovy-based programming style that offers full programmatic flexibility at the cost of higher complexity and maintenance overhead.<\/li>\n<\/ul>\n\n\n\n
                                As a student, focus on mastering Declarative Pipelines<\/strong>.<\/p>\n\n\n\n
                                Anatomy of a Jenkinsfile<\/h3>\n\n\n\n
                                Here is a practical, production-ready Jenkinsfile<\/code> for our Java and Maven project:<\/p>\n\n\n\n
                                Groovy<\/p>\n\n\n\n
                                pipeline {\n    agent any\n\n    tools {\n        \/\/ References a Maven installation configured in Global Tool Configuration\n        maven 'Maven-3.9'\n        \/\/ References a JDK installation configured in Global Tool Configuration\n        jdk 'JDK-17'\n    }\n\n    options {\n        \/\/ Automatically stop the build if it takes longer than 20 minutes\n        timeout(time: 20, unit: 'MINUTES')\n        \/\/ Print timestamps in the console output for easier debugging\n        timestamps()\n    }\n\n    stages {\n        stage('Checkout') {\n            steps {\n                echo 'Checking out source code from Git repository...'\n                checkout scm\n            }\n        }\n\n        stage('Compile & Package') {\n            steps {\n                echo 'Compiling source files and packaging JAR...'\n                \/\/ Run Maven compile while skipping tests during this initial compilation stage\n                sh 'mvn clean compile'\n            }\n        }\n\n        stage('Run Automated Tests') {\n            steps {\n                echo 'Executing automated unit tests via Maven Surefire...'\n                \/\/ Executes tests and compiles the JAR artifact\n                sh 'mvn test'\n            }\n        }\n\n        stage('Archive Artifacts') {\n            steps {\n                echo 'Archiving built application packages...'\n                \/\/ Package the application into a target\/*.jar file\n                sh 'mvn package -DskipTests=true'\n                \/\/ Store the resulting binary within Jenkins build records\n                archiveArtifacts artifacts: 'target\/*.jar', fingerprint: true, allowEmptyArchive: false\n            }\n        }\n    }\n\n    post {\n        always {\n            echo 'Collecting test execution results...'\n            \/\/ Parse JUnit XML files produced by the Maven Surefire plugin\n            junit 'target\/surefire-reports\/*.xml'\n        }\n        success {\n            echo 'Pipeline completed successfully! All stages and tests passed.'\n        }\n        failure {\n            echo 'Pipeline failed! Investigate the console output and test reports above.'\n        }\n    }\n}\n<\/code><\/pre>\n\n\n\n
                                Explaining the Pipeline Sections<\/h3>\n\n\n\n
                                  \n
                                • pipeline<\/code>:<\/strong> The root container that tells Jenkins to parse the block as a Declarative Pipeline.<\/li>\n\n\n\n
                                • agent any<\/code>:<\/strong> Tells Jenkins to run this pipeline on any available executor node or agent.<\/li>\n\n\n\n
                                • tools<\/code>:<\/strong> Informs Jenkins which pre-configured compilers or build tools to automatically inject into the operating system PATH<\/code> for this build.<\/li>\n\n\n\n
                                • stages<\/code>:<\/strong> Houses the sequence of tasks that describe your software delivery lifecycle.<\/li>\n\n\n\n
                                • stage('Name')<\/code>:<\/strong> A distinct logical segment of the pipeline. In the Jenkins UI, each stage renders as an independent column, showing you exactly how long each phase took and whether it succeeded or failed.<\/li>\n\n\n\n
                                • steps<\/code>:<\/strong> The actual commands executed within a stage (such as running shell commands with sh<\/code>, or batch scripts with bat<\/code>).<\/li>\n\n\n\n
                                • post<\/code>:<\/strong> Executes steps conditionally after all stages finish:\n
                                    \n
                                  • always<\/code>: Runs regardless of the build outcome (ideal for collecting test reports or cleaning temporary directories).<\/li>\n\n\n\n
                                  • success<\/code>: Runs only if every stage finished without error.<\/li>\n\n\n\n
                                  • failure<\/code>: Runs if any stage or test suite threw an error (ideal for sending alerts).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                    Setting Up the Pipeline Job in Jenkins<\/h3>\n\n\n\n
                                      \n
                                    1. On the Jenkins home screen, click New Item<\/strong>.<\/li>\n\n\n\n
                                    2. Enter the name calculator-ci-pipeline<\/code>, select Pipeline<\/strong>, and click OK<\/strong>.<\/li>\n\n\n\n
                                    3. Under the Pipeline<\/strong> configuration tab at the bottom:\n
                                        \n
                                      • Change Definition<\/strong> to Pipeline script from SCM<\/strong>.<\/li>\n\n\n\n
                                      • Under SCM<\/strong>, select Git<\/strong>.<\/li>\n\n\n\n
                                      • Enter your Repository URL<\/strong> (e.g., your GitHub repository URL).<\/li>\n\n\n\n
                                      • Under Branches to build<\/strong>, specify *\/main<\/code>.<\/li>\n\n\n\n
                                      • Under Script Path<\/strong>, ensure it reads Jenkinsfile<\/code>.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                      • Click Save<\/strong>.<\/li>\n\n\n\n
                                      • Click Build Now<\/strong>. Jenkins will clone your Git repository, locate the Jenkinsfile<\/code> in the project root, parse its instructions, and execute each stage.<\/li>\n<\/ol>\n\n\n\n
                                        9. Automating Tests with Jenkins<\/h2>\n\n\n\n
                                        Automated testing is the primary safety net of Continuous Integration. Without testing, a CI pipeline is just an automated compiler that packages broken code faster.<\/p>\n\n\n\n
                                        How Maven and Surefire Produce Test Data<\/h3>\n\n\n\n
                                        When Jenkins runs the command mvn test<\/code>, the Maven lifecycle invokes the Maven Surefire Plugin<\/strong>. Surefire discovers all test classes ending in Test<\/code> or TestCase<\/code> under src\/test\/java<\/code>, runs each test method, and writes the results to standardized XML files in the target\/surefire-reports\/<\/code> directory:<\/p>\n\n\n\n
                                        Plaintext<\/p>\n\n\n\n
                                        target\/surefire-reports\/\n\u251c\u2500\u2500 TEST-com.devopsschool.CalculatorTest.xml\n\u2514\u2500\u2500 com.devopsschool.CalculatorTest.txt\n<\/code><\/pre>\n\n\n\n
                                        Inside TEST-com.devopsschool.CalculatorTest.xml<\/code>, Surefire writes structured data detailing the execution:<\/p>\n\n\n\n
                                        XML<\/p>\n\n\n\n
                                        <?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<testsuite name=\"com.devopsschool.CalculatorTest\" tests=\"3\" skipped=\"0\" failures=\"0\" errors=\"0\" time=\"0.045\">\n  <testcase name=\"testAdd()\" classname=\"com.devopsschool.CalculatorTest\" time=\"0.021\"\/>\n  <testcase name=\"testSubtract()\" classname=\"com.devopsschool.CalculatorTest\" time=\"0.003\"\/>\n  <testcase name=\"testDivideByZero()\" classname=\"com.devopsschool.CalculatorTest\" time=\"0.004\"\/>\n<\/testsuite>\n<\/code><\/pre>\n\n\n\n
                                        Publishing Test Results in Jenkins<\/h3>\n\n\n\n
                                        The post<\/code> block in our Jenkinsfile<\/code> includes this instruction:<\/p>\n\n\n\n
                                        Groovy<\/p>\n\n\n\n
                                        junit 'target\/surefire-reports\/*.xml'\n<\/code><\/pre>\n\n\n\n
                                        This step uses the Jenkins JUnit plugin to parse the XML output files. Instead of requiring developers to dig through thousands of lines of terminal logs to find why a build failed, Jenkins generates an interactive graphical Test Result<\/strong> dashboard directly on the job\u2019s page.<\/p>\n\n\n\n
                                        The dashboard displays:<\/p>\n\n\n\n
                                          \n
                                        • Total Tests Executed:<\/strong> The total number of individual assertions evaluated.<\/li>\n\n\n\n
                                        • Failures and Errors:<\/strong> The exact test methods that failed, complete with stack traces, expected vs. actual values, and code line numbers.<\/li>\n\n\n\n
                                        • Test Duration:<\/strong> How long individual tests took to complete, helping you spot performance regressions.<\/li>\n\n\n\n
                                        • Test Trends:<\/strong> An interactive historical graph charting passing, failing, and skipped tests over time across all builds.<\/li>\n<\/ul>\n\n\n\n
                                          What Happens When a Test Fails?<\/h3>\n\n\n\n
                                          To see this in action, imagine a developer changes the add<\/code> method in Calculator.java<\/code> to an incorrect implementation:<\/p>\n\n\n\n
                                          Java<\/p>\n\n\n\n
                                          public int add(int a, int b) {\n    return a + b + 1; \/\/ Intentional logic bug\n}\n<\/code><\/pre>\n\n\n\n
                                          When this change is pushed to Git and Jenkins executes mvn test<\/code>:<\/p>\n\n\n\n
                                          Plaintext<\/p>\n\n\n\n
                                          [INFO] Running com.devopsschool.CalculatorTest\n[ERROR] Tests run: 3, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.052 s <<< FAILURE! -- in com.devopsschool.CalculatorTest\n[ERROR] com.devopsschool.CalculatorTest.testAdd -- Time elapsed: 0.022 s <<< FAILURE!\norg.opentest4j.AssertionFailedError: 10 + 5 should equal 15 ==> expected: <15> but was: <16>\n\tat org.junit.jupiter.api.AssertionUtils.fail(AssertionUtils.java:55)\n\tat org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)\n\tat org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:150)\n\tat com.devopsschool.CalculatorTest.testAdd(CalculatorTest.java:21)\n<\/code><\/pre>\n\n\n\n
                                            \n
                                          1. Maven detects an assertion failure and exits with status code 1<\/code>.<\/li>\n\n\n\n
                                          2. Jenkins notices the non-zero exit code and halts pipeline execution before reaching the Archive Artifacts<\/code> stage. This prevents a broken application package from ever being created.<\/li>\n\n\n\n
                                          3. The post<\/code> block activates, executing the junit<\/code> step, which captures the failure details from the Surefire XML report.<\/li>\n\n\n\n
                                          4. The build is marked as UNSTABLE<\/strong> or FAILED<\/strong> (Red).<\/li>\n\n\n\n
                                          5. The Jenkins UI highlights the exact failure: com.devopsschool.CalculatorTest.testAdd - expected <15> but was <16><\/code>.<\/li>\n<\/ol>\n\n\n\n
                                            10. Triggering Builds Automatically<\/h2>\n\n\n\n
                                            Manually clicking Build Now<\/strong> is helpful while writing and testing your pipeline, but true Continuous Integration requires builds to run automatically whenever code changes.<\/p>\n\n\n\n
                                            +------------------+         Git Push          +---------------------+\n| Student commits  | ------------------------> | GitHub Repository   |\n| code on laptop   |                           +---------------------+\n+------------------+                                      |\n                                             Webhook HTTP POST request\n                                                          v\n                                               +---------------------+\n                                               | Jenkins Controller  |\n                                               | (Starts Pipeline)   |\n                                               +---------------------+\n<\/code><\/pre>\n\n\n\n
                                            Jenkins supports several build triggers:<\/p>\n\n\n\n
                                            1. Webhooks (Industry Best Practice)<\/h3>\n\n\n\n
                                            A Webhook<\/strong> is an automated HTTP POST<\/code> payload sent from your Git host (such as GitHub or GitLab) to Jenkins whenever an event occurs\u2014such as a developer pushing a commit or opening a pull request.<\/p>\n\n\n\n
                                              \n
                                            • How it works:<\/strong> When you push code, GitHub immediately calls http:\/\/<your-jenkins-ip>:8080\/github-webhook\/<\/code>. Jenkins receives the notification, determines which job monitors that repository and branch, and starts the build immediately.<\/li>\n\n\n\n
                                            • Network Requirement:<\/strong> The Git host must be able to reach your Jenkins server over the network. If you are running Jenkins locally on localhost<\/code> behind a home router, GitHub cannot reach it directly without an HTTP tunnel (such as ngrok) or a public IP address.<\/li>\n<\/ul>\n\n\n\n
                                              2. Polling SCM (Beginner Fallback)<\/h3>\n\n\n\n
                                              If your Jenkins installation is running on a local private network or laptop without public internet ingress, you can use Poll SCM<\/strong>.<\/p>\n\n\n\n
                                                \n
                                              • How it works:<\/strong> Jenkins periodically checks your remote Git repository on a schedule (defined using Cron syntax) to see if any new commits have appeared. If new commits exist, Jenkins triggers a build; if not, it does nothing.<\/li>\n\n\n\n
                                              • Configuration:<\/strong> Inside your Jenkinsfile<\/code>, add a triggers block:<\/li>\n<\/ul>\n\n\n\n
                                                Groovy<\/p>\n\n\n\n
                                                pipeline {\n    agent any\n    triggers {\n        \/\/ Poll the Git repository every 15 minutes for changes\n        pollSCM('H\/15 * * * *')\n    }\n    \/\/ ... stages continue below\n}\n<\/code><\/pre>\n\n\n\n
                                                The H<\/code> symbol stands for “Hash” and spreads out the polling load across your Jenkins controller to avoid sudden spikes in activity.<\/em><\/p>\n\n\n\n
                                                3. Scheduled Builds<\/h3>\n\n\n\n
                                                Some builds do not need to run on every commit. For example, long-running end-to-end test suites or performance benchmarks can be scheduled to run during off-peak hours:<\/p>\n\n\n\n
                                                Groovy<\/p>\n\n\n\n
                                                triggers {\n    \/\/ Run every night at midnight\n    cron('H 0 * * *')\n}\n<\/code><\/pre>\n\n\n\n
                                                11. Understanding Build Failures and Troubleshooting<\/h2>\n\n\n\n
                                                Encountering errors is an unavoidable part of engineering. Knowing how to diagnose and resolve build failures will save you hours of frustration.<\/p>\n\n\n\n
                                                Here is a quick-reference troubleshooting matrix for common beginner issues:<\/p>\n\n\n\n
                                                Symptom \/ Error Message<\/strong><\/td>Root Cause<\/strong><\/td>Where to Look<\/strong><\/td>Practical Fix<\/strong><\/td><\/tr><\/thead>
                                                mvn: command not found<\/code> or java: not found<\/code><\/td>The tool is not installed, or its executable directory is missing from the system PATH<\/code>.<\/td>Console Output & System Configuration<\/td>Configure the tool in Manage Jenkins > Tools<\/strong>, or use the tools<\/code> directive in your Jenkinsfile<\/code>.<\/td><\/tr>
                                                Fatal: Authentication failed for 'https:\/\/...'<\/code><\/td>Jenkins lacks valid credentials to access a private Git repository.<\/td>Job Configuration & Credentials Vault<\/td>Add an SSH key or Personal Access Token in Manage Jenkins > Credentials<\/strong>, and link it to the SCM configuration.<\/td><\/tr>
                                                Non-resolvable parent POM<\/code> or Could not resolve dependencies<\/code><\/td>Maven cannot reach the internet to download dependencies, or repository proxy settings are incorrect.<\/td>Console Output (mvn<\/code> logs)<\/td>Verify your network connection, inspect DNS inside your Docker container, or configure Maven’s settings.xml<\/code> file with proper proxy settings.<\/td><\/tr>
                                                Compilation failure: [ERROR] cannot find symbol<\/code><\/td>Syntax error, missing import, or a Java language version mismatch.<\/td>Console Output (Compiler section)<\/td>Check that your local JDK version matches the compiler target defined in pom.xml<\/code> and Jenkins tool settings.<\/td><\/tr>
                                                FAILURE: There are test failures<\/code><\/td>One or more unit tests failed their assertions.<\/td>Test Result<\/strong> tab on the Build page<\/td>Click into the failed test in the Jenkins UI to view the stack trace and pinpoint the logic error in your code.<\/td><\/tr>
                                                Recording test results... No test report files were found<\/code><\/td>The path specified in the junit<\/code> step does not match where Maven generated the XML reports.<\/td>Pipeline post<\/code> block & Workspace filesystem<\/td>Confirm that the pattern target\/surefire-reports\/*.xml<\/code> matches your project layout. Ensure the test stage actually ran.<\/td><\/tr>
                                                Permission denied<\/code> when creating directories<\/td>The user account running Jenkins (jenkins<\/code>) does not own the workspace folder on the host machine.<\/td>Controller host file permissions<\/td>Run chown -R jenkins:jenkins \/var\/jenkins_home<\/code> on the host machine hosting your storage volumes.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                                                12. Jenkins Best Practices for Students<\/h2>\n\n\n\n
                                                Following these simple best practices will keep your pipelines reliable, readable, and easy to maintain:<\/p>\n\n\n\n
                                                1. Treat Pipelines as Code<\/h3>\n\n\n\n
                                                Always define your build instructions in a version-controlled Jenkinsfile<\/code> rather than using the Jenkins UI to configure Freestyle jobs. Your pipeline definitions should be reviewed, tested, and tracked in version control right alongside your application code.<\/p>\n\n\n\n
                                                2. Never Hardcode Secrets<\/h3>\n\n\n\n
                                                Never commit passwords, database credentials, API tokens, or private keys directly into a repository or Jenkinsfile<\/code>. Use Jenkins’ built-in Credentials Provider and access secrets securely within your pipeline:<\/p>\n\n\n\n
                                                Groovy<\/p>\n\n\n\n
                                                environment {\n    API_KEY = credentials('my-secret-api-token')\n}\n<\/code><\/pre>\n\n\n\n
                                                3. Fail Fast<\/h3>\n\n\n\n
                                                Order your pipeline stages logically. Run fast, lightweight tasks first (such as static linting, compilation, and unit tests) before triggering slower, resource-intensive operations (such as end-to-end UI tests or container builds). If a simple unit test fails, there is no reason to spend twenty minutes building a Docker image.<\/p>\n\n\n\n
                                                4. Keep Build Environments Clean and Disposable<\/h3>\n\n\n\n
                                                Avoid manually installing software packages inside an active build workspace. Rely on versioned tools, package managers, or containerized execution nodes. If an agent machine is destroyed, your pipeline should run smoothly on a brand-new agent without manual intervention.<\/p>\n\n\n\n
                                                5. Keep Test Suites Deterministic<\/h3>\n\n\n\n
                                                Flaky tests\u2014tests that pass on one run and fail on the next without any code changes\u2014erode trust in your CI\/CD pipeline. Tests should be isolated, avoid external network dependencies, clean up after themselves, and produce predictable results every time.<\/p>\n\n\n\n
                                                13. Extending the Pipeline Beyond Builds and Tests<\/h2>\n\n\n\n
                                                Once your basic build-and-test pipeline is running smoothly, you can expand it with additional automated checks used in professional software delivery.<\/p>\n\n\n\n
                                                +-----------+   +----------+   +----------+   +---------------+   +------------+\n|  Compile  |-->|   Unit   |-->| Quality  |-->| Build & Push  |-->| Deploy to  |\n|  Package  |   |  Tests   |   | Analysis |   | Docker Image  |   | Staging VM |\n+-----------+   +----------+   +----------+   +---------------+   +------------+\n<\/code><\/pre>\n\n\n\n
                                                1. Static Code Analysis and Quality Gates<\/h3>\n\n\n\n
                                                Integrate tools like SonarQube<\/strong> or SpotBugs<\/strong> to inspect your source code for bugs, anti-patterns, and vulnerabilities without running it. You can define a Quality Gate that halts the pipeline if code coverage drops below an agreed threshold (e.g., 80%).<\/p>\n\n\n\n
                                                2. Dependency Vulnerability Scanning<\/h3>\n\n\n\n
                                                Use security plugins such as OWASP Dependency-Check<\/strong> or Snyk<\/strong> to scan your project dependencies (pom.xml<\/code>) against national vulnerability databases, alerting you to known security vulnerabilities in third-party libraries.<\/p>\n\n\n\n
                                                3. Containerization with Docker<\/h3>\n\n\n\n
                                                Extend your pipeline to package your application into an immutable Docker image and publish it to an artifact registry such as Docker Hub:<\/p>\n\n\n\n
                                                Groovy<\/p>\n\n\n\n
                                                stage('Build Docker Image') {\n    steps {\n        script {\n            dockerImage = docker.build(\"myusername\/simple-java-app:${env.BUILD_NUMBER}\")\n        }\n    }\n}\n<\/code><\/pre>\n\n\n\n
                                                4. Automated Deployment<\/h3>\n\n\n\n
                                                Add a deployment stage that transfers your packaged artifacts to a cloud server, testing environment, or staging Kubernetes cluster whenever a build on your main<\/code> branch succeeds.<\/p>\n\n\n\n
                                                5. Automated Notifications<\/h3>\n\n\n\n
                                                Configure the post<\/code> block to send notifications to Discord, Slack, or email channels, letting your team know immediately when a build succeeds or requires attention.<\/p>\n\n\n\n
                                                14. A Mini Project: Build and Test Automation from Start to Finish<\/h2>\n\n\n\n
                                                Put your new knowledge into practice with this step-by-step hands-on exercise.<\/p>\n\n\n\n
                                                       PROJECT ROADMAP\nStep 1: Write Java code & JUnit tests\n                 |\nStep 2: Commit & push to your Git repo\n                 |\nStep 3: Point Jenkins to your repository\n                 |\nStep 4: Run the pipeline & see Green\n                 |\nStep 5: Introduce an intentional bug\n                 |\nStep 6: Watch Jenkins catch the failure\n                 |\nStep 7: Fix the bug & restore to Green\n<\/code><\/pre>\n\n\n\n
                                                Step 1: Create the Project<\/h3>\n\n\n\n
                                                Create a new directory named student-ci-demo<\/code> containing the pom.xml<\/code>, Calculator.java<\/code>, and CalculatorTest.java<\/code> files detailed in Section 6<\/strong>.<\/p>\n\n\n\n
                                                Step 2: Add the Jenkinsfile<\/h3>\n\n\n\n
                                                Create a file named Jenkinsfile<\/code> in the root of your project directory using the Declarative Pipeline code from Section 8<\/strong>.<\/p>\n\n\n\n
                                                Step 3: Push to Git<\/h3>\n\n\n\n
                                                Initialize Git, commit your project files, create a new repository on your preferred Git host, and push your commits to the main<\/code> branch:<\/p>\n\n\n\n
                                                Bash<\/p>\n\n\n\n
                                                git init\ngit add .\ngit commit -m \"feat: complete initial project setup with pipeline\"\ngit branch -M main\ngit remote add origin <your-git-repo-url>\ngit push -u origin main\n<\/code><\/pre>\n\n\n\n
                                                Step 4: Configure Jenkins<\/h3>\n\n\n\n
                                                  \n
                                                1. Open Jenkins at http:\/\/localhost:8080<\/code>.<\/li>\n\n\n\n
                                                2. Click New Item<\/strong>, choose Pipeline<\/strong>, and name it student-mini-project<\/code>.<\/li>\n\n\n\n
                                                3. In the configuration under Pipeline<\/strong>, set Definition<\/strong> to Pipeline script from SCM<\/strong>.<\/li>\n\n\n\n
                                                4. Set SCM<\/strong> to Git<\/strong>, provide your repository URL, and set the branch to *\/main<\/code>.<\/li>\n\n\n\n
                                                5. Click Save<\/strong>, then click Build Now<\/strong>.<\/li>\n<\/ol>\n\n\n\n
                                                  Step 5: Verify the Passing Build<\/h3>\n\n\n\n
                                                    \n
                                                  • Watch the Stage View<\/strong> dashboard. The stages\u2014Checkout<\/em>, Compile & Package<\/em>, Run Automated Tests<\/em>, and Archive Artifacts<\/em>\u2014will turn green one by one.<\/li>\n\n\n\n
                                                  • Click into the build, select Test Result<\/strong>, and confirm that 3 tests ran with 0 failures<\/strong>.<\/li>\n<\/ul>\n\n\n\n
                                                    Step 6: Break a Test Intentionally<\/h3>\n\n\n\n
                                                    Simulate a developer error. Open Calculator.java<\/code> and modify the subtract<\/code> method:<\/p>\n\n\n\n
                                                    Java<\/p>\n\n\n\n
                                                    public int subtract(int a, int b) {\n    return a - b - 10; \/\/ Intentional defect\n}\n<\/code><\/pre>\n\n\n\n
                                                    Commit and push this change to your repository:<\/p>\n\n\n\n
                                                    Bash<\/p>\n\n\n\n
                                                    git commit -am \"refactor: tweak subtraction logic\"\ngit push origin main\n<\/code><\/pre>\n\n\n\n
                                                    Step 7: Observe the Failure<\/h3>\n\n\n\n
                                                      \n
                                                    1. Return to Jenkins and click Build Now<\/strong> (or wait for your webhook or polling trigger to run).<\/li>\n\n\n\n
                                                    2. The pipeline will stop at the Run Automated Tests<\/strong> stage, turning Red<\/strong>.<\/li>\n\n\n\n
                                                    3. Click the failed build number, open the Test Result<\/strong> page, and review the error:PlaintextCalculatorTest.testSubtract: expected: <5> but was: <-5><\/code><\/li>\n\n\n\n
                                                    4. Notice that the Archive Artifacts<\/em> stage was skipped completely, preventing a broken application binary from being created.<\/li>\n<\/ol>\n\n\n\n
                                                      Step 8: Fix and Verify<\/h3>\n\n\n\n
                                                      Correct the calculation in Calculator.java<\/code>, commit the fix, and push it to Git. Run the pipeline one more time to see your pipeline return to a clean, passing Green<\/strong> state.<\/p>\n\n\n\n
                                                      15. Frequently Asked Questions (FAQ)<\/h2>\n\n\n\n
                                                      What is Jenkins used for?<\/h3>\n\n\n\n
                                                      Jenkins is an open-source automation server used primarily to implement Continuous Integration (CI) and Continuous Delivery (CD). It automates repetitive tasks throughout the software lifecycle, including code checkout, compilation, unit and integration testing, code analysis, packaging, and deployment to hosting environments.<\/p>\n\n\n\n
                                                      Is Jenkins suitable for beginners?<\/h3>\n\n\n\n
                                                      Yes. While Jenkins offers powerful features for enterprise use, its core concepts\u2014automating builds, running commands, and displaying test results\u2014are straightforward to learn. Starting with a basic Declarative Pipeline on a single project is an approachable, hands-on way for students to learn CI\/CD fundamentals.<\/p>\n\n\n\n
                                                      What is the difference between a Jenkins job and a Jenkins pipeline?<\/h3>\n\n\n\n
                                                      A Jenkins job<\/em> is a broad term for any automated task configured in Jenkins, historically set up via the graphical UI (such as a Freestyle job). A Jenkins pipeline<\/em> is a modern, code-based workflow that models your entire build, test, and release process as code using a Jenkinsfile<\/code>, which can be checked into version control alongside your project.<\/p>\n\n\n\n
                                                      What is a Jenkinsfile?<\/h3>\n\n\n\n
                                                      A Jenkinsfile<\/code> is a text configuration file stored in the root of your source code repository that defines your Jenkins pipeline. Written using Declarative or Scripted pipeline syntax, it models the build, test, and deployment stages as code, ensuring your automation workflow is versioned and tracked alongside your application code.<\/p>\n\n\n\n
                                                      How does Jenkins automate software testing?<\/h3>\n\n\n\n
                                                      Jenkins executes test commands through build tools or test runners (such as mvn test<\/code> for Java, npm test<\/code> for JavaScript, or pytest<\/code> for Python). Jenkins captures the test results, parses generated XML report files (like JUnit XML), marks builds as passed or failed based on test outcomes, and generates visual trend reports on the dashboard.<\/p>\n\n\n\n
                                                      Does Jenkins require Java?<\/h3>\n\n\n\n
                                                      Yes. The Jenkins controller itself is written in Java and requires a supported Java runtime (typically OpenJDK 17 or 21) to execute. However, this does not limit what Jenkins can build; it can build and test software written in any programming language.<\/p>\n\n\n\n
                                                      Can Jenkins build applications written in different programming languages?<\/h3>\n\n\n\n
                                                      Yes. Jenkins is language-agnostic. By installing the relevant tools, compilers, and plugins\u2014or by running build steps inside Docker containers\u2014Jenkins can automate projects written in Python, Node.js, Go, C++, C#, Rust, Ruby, or any other programming language.<\/p>\n\n\n\n
                                                      What happens when a Jenkins test fails?<\/h3>\n\n\n\n
                                                      When an automated test fails, the test runner exits with a non-zero exit status. Jenkins detects this exit code, halts the pipeline to prevent broken code from advancing to packaging or deployment, flags the build as Failed (Red) or Unstable (Yellow), highlights the failing assertions on the dashboard, and notifies the team.<\/p>\n\n\n\n
                                                      Is Jenkins free to use?<\/h3>\n\n\n\n
                                                      Yes. Jenkins is open-source software released under the MIT License. It is completely free to download, install, modify, and use for personal, academic, or commercial projects.<\/p>\n\n\n\n
                                                      What should students learn after creating their first Jenkins pipeline?<\/h3>\n\n\n\n
                                                      After mastering basic build and test automation, students should explore:<\/p>\n\n\n\n
                                                        \n
                                                      1. Running build agents dynamically inside Docker containers<\/strong>.<\/li>\n\n\n\n
                                                      2. Static code analysis and security auditing with SonarQube<\/strong>.<\/li>\n\n\n\n
                                                      3. Managing pull requests automatically using GitHub\/GitLab webhooks<\/strong>.<\/li>\n\n\n\n
                                                      4. Deploying applications to cloud infrastructure or container orchestration platforms like Kubernetes<\/strong>.<\/li>\n<\/ol>\n\n\n\n
                                                        16. Conclusion<\/h2>\n\n\n\n
                                                        Mastering Jenkins transforms software development from an error-prone manual chore into a reliable, professional engineering discipline. By learning how to configure declarative pipelines, automate builds with Maven, and let automated test suites catch regressions early, students gain direct experience with the continuous integration workflows used across top tech teams. Building confidence in DevOps starts with these small, consistent experiments\u2014setting up a local server, intentionally breaking tests to learn how Jenkins handles failure, and gradually extending your pipeline with new tools. As you integrate automation into your academic assignments and personal projects, you not only eliminate late-night integration headaches but also develop the practical, job-ready CI\/CD skills essential for a successful career in software delivery.<\/p>\n\n\n\n
                                                        <\/p>\n","protected":false},"excerpt":{"rendered":"
                                                        1. Introduction Every developer remembers the anxiety of working on a group programming project where everyone\u2019s code worked fine on their personal laptop, but everything shattered into cryptic errors once…<\/p>\n","protected":false},"author":3,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1819","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts\/1819","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/comments?post=1819"}],"version-history":[{"count":1,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts\/1819\/revisions"}],"predecessor-version":[{"id":1821,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/posts\/1819\/revisions\/1821"}],"wp:attachment":[{"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/media?parent=1819"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/categories?post=1819"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devopsschool.org\/blog\/wp-json\/wp\/v2\/tags?post=1819"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}