The Complete Jenkins DevOps CI/CD Pipeline Bootcamp

Learn how Jenkins, an open source Java-based tool, automates building, testing, and deploying software to enable fast, error-free continuous integration with auto-triggered workflows.

Compare the stable long-term support release and the weekly Jenkins release to decide installation for production or development environments, and follow the course's stable setup for end-to-end Jenkins learning.

Explore high-level installation routes for Jenkins, including WAR, native packages, installers, and Docker, with 256 MB RAM minimum and Java 11/17 prerequisites, focusing on Ubuntu-based deployment for DevOps.

Prepare the execution environment for Jenkins on Linux or Ubuntu, using cloud-based instances (DigitalOcean) and verify Java prerequisites before installation.

Install OpenJDK 11 on the Jenkins machine with apt-get, confirm installation, and verify the Java version. Prepare for the upcoming Jenkins installation.

Learn to install Jenkins on an Ubuntu-based machine, add the Jenkins repository, install OpenJDK 11 and fontconfig, start Jenkins on port 8080, and unlock with the log password.

Install Jenkins on Ubuntu, configure the admin user, and install plugins via the setup wizard, then start Jenkins and prepare for continuous integration and deployment.

Explore Jenkins master-slave architecture, where the master node acts as controller and scheduler. Slave nodes execute tasks via a Jenkins agent and report results to the master.

Create and execute a Jenkins job to run any task, exploring freestyle, pipeline, and multi-configuration projects, defining build steps, and viewing console output and build history.

Learn how to configure a Jenkins job, including discard old builds, log rotation, source control, build triggers, build environment, and post build actions, with practical examples.

Learn to execute a shell script from a Jenkins job, configure permissions with chmod, pass parameters, and view results in the Jenkins console output.

Create and configure a parameterized Jenkins job with string parameters like first name and age, enabling builds with parameters and dynamic inputs.

Learn to configure a parameterized Jenkins job using boolean, string, and choice parameters to drive a script with an if statement, echoing personalized messages to the console.

Understand the anatomy of a software build and how Jenkins automates compiling, testing, and packaging. The continuous integration workflow triggers builds on new code changes from the Git repository.

Build your application manually on the Jenkins machine by cloning the GitHub repo, navigating to the maven-samples single-module, and validating Maven is installed before compiling with Maven.

Install Maven on a host, verify installation, and manually package a project with Maven, running validate, compile, test, and clean install to produce a jar in target.

Port manual build expertise to automation with Jenkins by creating a freestyle job that compiles, tests, packages, and cleans the code, then enable log rotation and prep for GitHub cloning.

Validate that Jenkins can clone a GitHub repository by configuring source code management, selecting the correct branch, and confirming the build via console output.

Build an application with Jenkins by configuring Maven top level targets and goals like clean and package. Troubleshoot the pom.xml location in the workspace to run mvn clean install successfully.

Fix build paths in Jenkins by navigating the workspace to the pom.xml and running mvn clean install, via shell or the invoke top-level Maven targets, for a successful build.

Archive the Maven-built jar as a post-build artifact, publish it for deployment, and understand artifact versions across builds in a Jenkins CI/CD pipeline.

Publish JUnit test results by configuring the post-build action to read the surefire-reports xml files produced by Maven, revealing test details each build.

Learn to view test result trends in Jenkins by publishing post-build results and interpreting green, gray, and red indicators across builds.

Abort long running Jenkins builds by clicking the cross icon, then review status icons and project health indicators to understand aborted, in progress, and successful states.

Learn common Jenkins build triggers, including build now, remote triggers, build after other projects, periodic builds, and GitHub hook or poll SCM.

Configure a Jenkins job to poll SCM changes and trigger builds automatically using a schedule pattern with minute, hour, day of month, month, and day of week.

Schedule builds in Jenkins using the build periodically trigger, configure cron expressions, and run jobs at specific times or off-hours to deliver timely results.

Explore how Jenkins plugins extend the core functionality from job scheduling to reporting, and learn to manage dependencies and upgrades from a central catalog to avoid regressions.

Explore running Jenkins with no plugins, access the default page on port 8080, and create a basic freestyle project with limited options while noting plugins extend functionality.

Install and use Jenkins plugins to enable fetch, build, test, publish, and deploy steps, compare manual and automated plugin installation, and explore pipelines from freestyle jobs to self-contained declarative pipelines.

Demonstrates building a freestyle Jenkins job with manually installed plugins, fetching code from GitHub, building and testing the code, and managing plugin and runtime dependencies.

Configure a Jenkins build that fetches code from GitHub, builds the application, runs static and runtime tests, and publishes MS test results with TRX reports.

Demonstrates publishing a Jenkins build to Docker Hub using the Docker Hub plugin, configuring credentials and Docker daemon access, and tagging images for versioned release.

Learn to use and manage Jenkins plugins, including GitHub and MSTest, and handle build, test, and publish steps, while addressing shell steps, tool dependencies, and server migrations.

Set up a Jenkins build offline by preloading specific plugin HPI files and dependencies, restart the Jenkins server, and deploy a bundled offline plugin package for consistent builds.

Learn to build a self-contained Jenkins workflow that auto-installs plugins and required software. Use a Groovy script to manage plugin installation from the update center and enable server migration.

Automate the one-time setup of Jenkins nodes by installing the .NET runtime, Docker engine, and adding the Jenkins user to the Docker group in a single pipeline run.

Automate a self-contained Jenkins ci/cd pipeline by organizing build.sh, unit_test.sh, and push.sh, building and testing code, and pushing Docker images to Docker Hub with credentials.

Learn how to write custom Jenkins plugins, including required development tools and integration points. Explore publishing, building the HPI, and reusing existing plugins from the community.

Create a Jenkins plugin skeleton using the Jenkins development toolkit, Java, and Maven, and learn the plugin structure from pom.xml to src.

Develop a hello world Jenkins plugin with a build step, package the HPI via Maven, deploy, restart Jenkins, and verify the custom build step prints the provided message.

Learn why a Jenkins pipeline is essential, compare freestyle and declarative approaches, and see how a Jenkinsfile with source control versions the build process alongside code.

Explore the structure of the declarative Jenkins pipeline, defined in a Jenkinsfile, including agent, environment variables, stages (checkout, build, test, deploy), steps, shell execution with sh, and post actions.

Learn to create a sample Jenkins pipeline from a declarative pipeline file, check out code from git, and run build, test, and deploy stages from SCM for versioned releases.

Demonstrates modeling a Jenkins pipeline workflow with a Jenkins file, stages, environment scopes, agents, and the pipeline stage view plugin.

Learn to enforce manual approval in a Jenkins pipeline with an input step and a target_environment parameter (default prod) to pause before deployment, then see post actions run always.

Discover how to run multiple build stages in parallel in a Jenkins pipeline using the parallel block, with nested stages inside a single stage and a jenkinsfile3 demo.

Gain hands-on understanding of Jenkins pipeline steps, stage-level and global environment variables, inputs, post build actions, and parallel stages to accelerate ci/cd across os.

Refactor the Jenkins pipeline to include audit, unit test, and build stages, install Maven if needed, and build the java-tomcat-sample project with mvn clean package to produce a war.

Demonstrates refactoring a Jenkins pipeline to dynamically version builds using environment variables and dir, with jenkinsfile2 and Maven versioning (VERSION and RELEASE_VERSION).

Refactor a Jenkins pipeline to differentiate release and int builds using a boolean RELEASE parameter and dynamic version suffix, and conditionally archive war artifacts with a when expression.

This demo refactors a Jenkins pipeline by replacing shell steps with reusable functions like audit tools, get build version, and package application.

Discover how to implement shared libraries in Jenkins pipelines to share common functions, reduce duplication, and simplify maintenance by storing Groovy files in a shared repository under vars.

Learn to manage shared libraries in a Jenkins pipeline by adding a new function with parameters, and avoid breaking existing jobs by creating new functions for partial changes.

Explore the modern approach to building ci/cd pipelines with microservices, agile practices, and Kubernetes or Docker deployments, while separating build jobs per component to minimize complexity and avoid monolithic Jenkins.

Discover how to use Docker as a build agent in a Jenkins pipeline, including setting a Maven latest image, Docker and Docker Pipeline plugins, and running Maven goals inside containers.

Learn how Jenkins uses a master-slave architecture to manage distributed builds, scheduling and dispatching jobs across Windows, Linux, and Mac slaves while centralizing results and logs.

Set up a Jenkins slave by creating a remote machine, enabling passwordless ssh from the master, installing java, and attaching the slave as a managed node with two executors.

Learn to configure concurrent builds in Jenkins with master and slave executors, labels, and restricted jobs to specific nodes for efficient scheduling.

Explore building Jenkins docker agents to act as on-demand executors, configure a docker cloud, and install the docker plugin to spin up and terminate containers.

Demonstrate building dynamic Jenkins Docker agents via a Docker cloud, provisioning and configuring agent templates, and running jobs on ephemeral containers that spin up and shut down.

Configure multiple docker agent templates in a single docker cloud to support a maven-based java build via a maven agent, and publish the built artifact.