Server course · SVC-02

Continuous Integration and Delivery with Jenkins

Continuous Integration and Delivery with Jenkins is a course in building CI/CD as Pipeline as Code with Jenkinsfiles, from Docker and securely running Jenkins to multibranch pipelines with GitHub, code quality checks and blue/green deployment to servers and the cloud. It suits software developers and DevOps engineers who are comfortable with Git and Linux.

Updated 8 Oct 2026

From 14,310 THB / person 15,900 −10% excl. VAT 7% · group rates available

Corporate training quote Join the waiting list

PDFDownload the course outline

Duration30 hours · 5 days
FormatOnsite / live online
Next roundOn request
CertificateIncluded

Course overview

Software teams that still build, test and deploy by hand keep hitting the same problems: code that works on one machine but breaks on another, slow and risky releases, and long hunts for the change that broke the system. Jenkins is an open-source CI/CD server used by many organisations, yet many of them still configure freestyle jobs through the web interface, which makes changes hard to track, hard to repeat and hard to maintain as the number of projects grows.

This new edition focuses on Pipeline as Code with the current Jenkins LTS. It takes learners from CI/CD concepts and Docker to installing and securing Jenkins, writing declarative Jenkinsfiles, building multibranch pipelines with GitHub, using agents and Docker agents, building and testing with reports, creating and pushing Docker images, setting quality gates and security scans, moving shared steps into shared libraries, deploying with blue/green strategies, managing Jenkins with Configuration as Code, and deploying Python and Java projects to servers and the cloud. (5 days, 6 hours per day, 30 hours in total, Intermediate level.)

What you’ll gain

Understand continuous integration, continuous delivery and continuous deployment
Containerise applications with Docker and manage images in a registry
Install, configure and secure Jenkins LTS
Write Pipeline as Code with declarative Jenkinsfiles and build multibranch pipelines with GitHub
Use agents and Docker agents to build and test, keeping reports and artifacts
Set quality gates, scan for vulnerabilities and handle credentials safely
Build shared libraries and manage Jenkins with Configuration as Code
Deploy applications automatically with blue/green strategies to servers and the cloud

Who this course is for

Software developers who want to automate build, test and deployment
DevOps engineers and system administrators who run an organisation's Jenkins
Team leads and QA staff who want a reliable software release process
Teachers, lecturers and students interested in CI/CD

Prerequisites

A basic understanding of programming and the software development process
Comfortable with Git, such as commit, branch, push and pull
Basic Linux command-line skills
A GitHub account and the ability to install Docker Desktop, plus your own AWS account for the AWS lab

Curriculum

Course Details

This course is the 2026 edition of Continuous Integration and Delivery with Jenkins, rewritten around Pipeline as Code on the current Jenkins LTS. It runs for 5 days, 6 hours per day (30 hours in total, 09:00-16:00), as lectures alternating with labs and workshops throughout. Intermediate level. It suits developers and DevOps engineers who are comfortable with Git and Linux. Learners install and secure Jenkins, write declarative Jenkinsfiles, build multibranch pipelines with GitHub, use Docker agents, build and scan Docker images, set quality gates, create shared libraries and Configuration as Code, and deploy blue/green to servers and AWS. They take home sample Jenkinsfiles and configuration files.

Day 1 CI/CD, Git and Docker

Section 1: CI/CD and DevOps Concepts

Continuous integration, continuous delivery and continuous deployment, and how they differ
How CI/CD improves release speed and stability
Pipeline stages: checkout, build, test, scan, package and deploy
An overview of CI/CD tools and where Jenkins fits
Examples of CI/CD in organisations

Section 2: Lab: Git Workflow for CI

Trunk-based and feature-branch strategies
Pull requests, code review and status checks
Tags and semantic versioning for releases
Set up a GitHub repository with branch protection
Lab: prepare the sample app repository used throughout the course

Section 3: Lab: Docker for CI/CD

Images, containers, layers and registries
Write good Dockerfiles: multi-stage builds, .dockerignore and non-root users
Manage containers, volumes and networks
Run several services with Docker Compose
Lab: run the app and its database with Docker Compose

Section 4: Lab: Dockerising Applications

Containerise a Python app and a Java app built with Maven
Name and tag images with the Git commit and version number
Push images to Docker Hub or GitHub Container Registry
Shrink images and choose secure base images
Lab: build, tag and push the sample app image by hand before automating it

Day 2 Installing Jenkins and Pipeline as Code

Section 5: Lab: Installing Jenkins LTS

Jenkins architecture: controller, agents, executors and plugins
Install Jenkins LTS on Docker with a data volume, and the Java 21 or 25 requirement
The setup wizard, the first admin user and suggested plugins
Tour the Jenkins interface and Pipeline Graph View
Lab: get Jenkins running for the rest of the course

Section 6: Lab: Administering and Securing Jenkins

Manage and update plugins and review security warnings
Users, groups and matrix or role-based authorisation
Store passwords, tokens and SSH keys in Jenkins credentials
Keep builds off the controller and apply key security settings
Lab: create role-based users and test their permissions

Section 7: Lab: Your First Declarative Jenkinsfile

Freestyle jobs versus Pipeline as Code, and why pipelines belong in Git
The pipeline, agent, stages, steps and post structure
Pipeline jobs using Pipeline script from SCM
Use the Snippet Generator and Replay to write and experiment
Lab: a first pipeline that checks out, builds and tests the sample app

Section 8: Lab: Declarative Pipeline in Depth

environment, parameters and options such as timeout and retry
when conditions based on branch, tag and parameters
parallel and matrix stages to test several environments
Approval steps with input before deployment
Lab: a pipeline that tests in parallel and waits for approval before production

Day 3 Multibranch, Agents and Docker Pipelines

Section 9: Lab: Multibranch Pipelines with GitHub

Create a multibranch pipeline that discovers branches and pull requests
Connect GitHub with credentials and set a webhook to build on every push
Report build status back to the pull request
Behave differently for the main branch, feature branches and pull requests
Lab: open a pull request and watch the pipeline run and report

Section 10: Lab: Agents and Docker Agents

Add agents over SSH or as inbound agents and assign labels
Install Docker on a Jenkins agent and connect it to the controller
Use agent { docker } so each stage runs in its own container
Dependency and workspace caching for faster builds
Lab: use different containers for the Java and Python builds

Section 11: Lab: Build, Test and Report

Build with Maven and pip and run unit tests
Publish JUnit reports and show test trends
Measure code coverage and show it in Jenkins
archiveArtifacts, stash and unstash between stages
Lab: fail the pipeline on failing tests and report the cause clearly

Section 12: Lab: Building and Pushing Docker Images in a Pipeline

Build images in the pipeline and tag them with the Git commit
Log in to the registry with withCredentials without leaking passwords to the log
Push images to Docker Hub or GitHub Container Registry
Scan images with Trivy and fail the pipeline above a threshold
Lab: a pipeline that builds, scans and pushes images automatically

Day 4 Quality, Security and Deployment

Section 13: Lab: Quality Gates and Pipeline Security

Analyse code with SonarQube and wait for the quality gate in the pipeline
Check dependencies for vulnerabilities and outdated libraries
Least privilege for credentials and agents
Protect against untrusted code from external pull requests
Lab: stop the pipeline when code quality misses the threshold

Section 14: Lab: Shared Libraries

Why reusable steps should leave the Jenkinsfile
Shared library structure: vars, src and resources
Write custom steps and pipeline templates for many projects
Version a library and load it with @Library
Lab: move the build-and-push steps into a shared library

Section 15: Lab: Deployment Strategies

Deploy to servers over SSH with Docker Compose
Separate dev, staging and production with approvals
Blue/green deployment and switching traffic
Post-deployment health checks and automatic rollback
Lab: deploy blue/green and practise a rollback

Section 16: Workshop: Deploying a Python Project

Plan a pipeline for a containerised Python app
Test with pytest, build the image and scan it
Deploy the container to a server acting as a Jenkins agent
Workshop: an end-to-end pipeline from code push to a running app

Day 5 Cloud, Configuration as Code and Capstone

Section 17: Workshop: Deploying a Java Project to AWS

Overview of deploying a Java project built with Maven
Prepare EC2 and a least-privilege IAM user in the learner's AWS account
Store AWS keys safely in Jenkins credentials
A pipeline that builds, tests, creates an image and deploys to EC2 automatically
Shut down and remove resources afterwards to control costs

Section 18: Lab: Jenkins Configuration as Code

Configure Jenkins from YAML with the Configuration as Code plugin
Install plugins and create seed jobs automatically
Run Jenkins with Docker Compose so it can be rebuilt at any time
Backup, restore and safe Jenkins LTS upgrades
Lab: rebuild a whole Jenkins instance from files in Git

Section 19: Lab: Monitoring and Troubleshooting Pipelines

Read console logs and Pipeline Graph View to find failures
Common problems: Docker permissions, full workspaces and wrong credentials
Collect metrics with the Prometheus plugin and show them in Grafana
Notify build results by email or team chat
Lab: fix a pipeline prepared with several faults

Section 20: Workshop: An End-to-End CI/CD Capstone

Design a pipeline for your own or a sample app from pull request to production
Combine tests, quality gates, security scans, Docker images and blue/green deployment
Use a shared library and Configuration as Code so it is repeatable
Present your work, review best practices and plan adoption in your organisation

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

Join the waiting list Ask about rounds

For organisations — in-house / private

Tailor the content to your team’s tools and projects
Your dates, at your office or live online
Quotation with tax ID for procurement

Corporate training quote

Instructors

Samit KoyomFounder & CEO, IT Genius Engineering

Frequently asked questions

How do continuous integration and continuous delivery differ?

Continuous integration (CI) means merging everyone's code into the main branch often, with every push triggering an automatic build and test run so mistakes are caught early. Continuous delivery (CD) builds on CI by keeping tested code always ready to deploy, with deployment at the press of an approval. Removing the approval and deploying to production automatically is called continuous deployment. In Jenkins all of these steps are written in a Jenkinsfile kept in Git.

What are Pipeline as Code and the Jenkinsfile, and why are they better than freestyle jobs?

Pipeline as Code means writing the whole CI/CD process as a file called a Jenkinsfile and keeping it in the same repository as the code, instead of configuring freestyle jobs field by field in the web interface. Every change goes through code review and has a history, each branch and pull request gets its own pipeline through multibranch pipelines, Jenkins can be rebuilt or moved easily, and repeated steps can move into a shared library. This course uses declarative Jenkinsfiles throughout.

What are the steps to build a Docker image in a Jenkins pipeline and deploy it?

Start by installing Docker on a Jenkins agent and storing the registry password in Jenkins credentials. Then write a declarative Jenkinsfile with stages for checkout, testing in a container, building the image tagged with the Git commit, scanning for vulnerabilities, pushing to the registry through withCredentials and deploying the image to the target server. Finally, create a multibranch pipeline pointing at the repository and set a webhook so it runs on every push.

What is blue/green deployment and how does it reduce risk?

Blue/green deployment uses two identical environments. Blue runs the current version that users rely on, while the new version is installed and tested on green. When it is ready, the load balancer or reverse proxy switches all traffic to green, so users see almost no downtime, and if health checks find a problem you can switch straight back to blue. The catch is that the database must work with both versions.

Who is the Continuous Integration and Delivery with Jenkins course for, and what should I know beforehand?

It suits software developers, DevOps engineers, system administrators who run Jenkins, team leads, QA staff and students interested in CI/CD. You should understand basic programming and software development, be comfortable with Git and use basic Linux commands. You should have a GitHub account and be able to install Docker Desktop, and the AWS lab uses your own AWS account.

What will I be able to do after the Continuous Integration and Delivery with Jenkins course?

You will be able to containerise applications, install and run Jenkins LTS securely, write declarative Jenkinsfiles, build multibranch pipelines with GitHub, use agents and Docker agents, build and test with reports, build, scan and push Docker images, set quality gates, create shared libraries and Configuration as Code, plan blue/green deployments and deploy Python and Java projects to servers and AWS. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.