Jenkins

You can explain continuous delivery flows and set up a working Jenkins controller using Docker Compose.

1. What CI/CD is and why it transforms software delivery90 min
   • Deployment pipelines
   • Feedback loops
   • Lead time for changes
   • Manual release bottlenecks
   • Trunk-based development principles
2. Continuous integration, delivery and deployment explained90 min
   • Automated testing
   • Release gates
   • Production deployment triggers
   • CD vs continuous deployment
   • Artifact promotion flows
3. Jenkins overview and architecture: controller and agents90 min
   • Master-agent communication
   • Remoting protocol
   • Executor allocation
   • Workspace isolation
   • Scalability bottlenecks
4. Installing Jenkins: native, Docker and Kubernetes120 min
   • apt-get install jenkins
   • jenkins/jenkins:lts image
   • Helm chart deployment
   • Docker socket mounting
   • Volume permission handling
5. Initial setup, the security wizard and plugin management90 min
   • Suggested plugins
   • Admin user creation
   • Update center configuration
   • Initial admin password retrieval
   • Security realm configuration
6. Troubleshooting initial controller startup failures60 min
   • docker logs jenkins
   • Java heap size tuning -Xmx
   • Port conflict resolution
   • File descriptor limits
   • SELinux permission denied fixes

Hands-on project: Deploy Jenkins via Docker Compose with persistent volume storage on /var/jenkins_home and unlock it using the initial admin password from container logs.

You can configure traditional freestyle jobs to poll Git repositories and execute shell build steps.

1. The Jenkins dashboard and job types90 min
   • Dashboard UI
   • Freestyle project
   • Folder organization
   • View configuration
   • Item creation workflows
2. Creating and configuring freestyle projects90 min
   • General properties
   • Build retention
   • Discard old builds
   • Build wrappers
   • Parameterised builds definition
3. Source code management with Git90 min
   • Repository URL
   • SSH credentials
   • Branch specifier
   • Clean workspace before checkout
   • Submodule configuration
4. Build steps and build triggers120 min
   • Execute shell
   • Poll SCM
   • Build periodically cron syntax
   • Build after other projects are built
   • Conditional build steps
5. Build history, console output and the workspace90 min
   • Console log stream
   • Workspace directory
   • Build status indicators
   • Console text download
   • Build result parsing
6. Debugging failed freestyle execution logs60 min
   • Exit code interpretation
   • Environment variable inspection
   • PATH variable debugging
   • Workspace permission troubleshooting
   • Stuck build interruption

Hands-on project: Create a freestyle job that clones a Git repository, runs a Maven clean compile goal, and archives the resulting JAR file in the workspace.

You can write declarative Jenkinsfiles with multiple stages, parallel execution, and environment variables.

1. Pipeline as code: why it matters90 min
   • Version control for build logic
   • Reproducible builds
   • Reviewable workflows
   • Infrastructure drift prevention
   • Pipeline auditing
2. Declarative vs Scripted pipelines90 min
   • pipeline {} block
   • Groovy DSL syntax
   • Error handling differences
   • Syntax validator tool
   • Node allocation patterns
3. The Jenkinsfile: stages, steps and post actions120 min
   • stage blocks
   • sh command
   • post success and failure blocks
   • always and cleanup blocks
   • stage timeout directive
4. Environment variables, parameters and credentials120 min
   • env directive
   • parameters block
   • withCredentials binding
   • string and boolean parameters
   • BUILD_NUMBER reference
5. Conditional logic, when blocks and parallel stages120 min
   • when branch conditions
   • parallel execution block
   • failFast option
   • expression when evaluator
   • matrix syntax for multi-config builds
6. Pipeline linter and syntax validation workflow90 min
   • Declarative Linter API
   • Jenkins CLI replay command
   • Pipeline snippet generator
   • Groovy syntax debugging
   • Dry-run execution

Hands-on project: Write a multi-stage Jenkinsfile for a Java application containing build, test, and package stages running in parallel where applicable.

You can set up webhook-driven multibranch pipelines that validate GitHub pull requests automatically.

1. Connecting GitHub and GitLab90 min
   • Personal access tokens
   • GitHub App integration
   • Webhook endpoints
   • SSH deploy keys
   • API rate limiting configuration
2. Webhooks vs SCM polling90 min
   • HTTP POST payloads
   • Polling overhead
   • Instant triggers
   • Payload signature verification
   • Firewall and NAT traversal
3. Pull-request and branch builds90 min
   • Discovery strategies
   • PR status checks
   • Target branch filtering
   • Fork PR build security
   • Merge commit simulation
4. Multibranch pipelines120 min
   • Automatic branch indexing
   • Orphaned item cleanup
   • Jenkinsfile discovery
   • Scan repository triggers
   • Branch property overrides
5. GitHub Organization folders90 min
   • Organization scanning
   • Repository discovery
   • Managed repositories
   • Project filtering by regex
   • Team access synchronization
6. Troubleshooting webhook delivery failures60 min
   • GitHub webhook delivery log
   • CSRF protection bypass for webhooks
   • Reverse proxy header forwarding
   • SSL certificate validation errors
   • Network packet capture with tcpdump

Hands-on project: Configure a GitHub webhook to trigger a multibranch Jenkins pipeline that runs automated checks on every pull request opening.

You can run unit tests, publish JUnit test reports, and enforce quality gates using SonarQube in pipelines.

1. Integrating Maven, Gradle and npm90 min
   • Tool installations configuration
   • mvn clean install
   • npm ci and build
   • Gradle wrapper execution
   • Global tool configuration
2. Running unit and integration tests90 min
   • Surefire plugin reports
   • Jest test execution
   • Test result xml format
   • Parallel test execution configuration
   • Flaky test retry strategies
3. Publishing test reports and coverage90 min
   • junit publish step
   • Cobertura coverage publisher
   • Trend graphs
   • HTML publisher plugin
   • Test result aggregation
4. Archiving artifacts and fingerprinting90 min
   • archiveArtifacts step
   • fingerprint tracking
   • Artifact retention rules
   • Upstream downstream artifact passing
   • Storage cleanup policies
5. Code quality and security scanning with SonarQube120 min
   • sonar-scanner CLI
   • Quality Gate check step
   • Token authentication
   • Code smell and vulnerability reporting
   • Branch analysis configuration
6. Handling test failure exceptions in pipelines60 min
   • catchError step usage
   • allowEmptyResults parameter
   • Continuous inspection failure handling
   • Build status propagation
   • Test report parsing debugging

Hands-on project: Integrate Maven test execution and SonarQube quality analysis into a Jenkinsfile, failing the build if code coverage drops below 80 percent.

You can securely manage secrets using Jenkins credentials store and send build failure alerts to Slack channels.

1. The Jenkins plugin ecosystem90 min
   • Update site management
   • Plugin dependency resolution
   • Offline plugin installation
   • .hpi file manual upload
   • Plugin deprecation warnings
2. Managing credentials and secrets securely90 min
   • Secret text bindings
   • Secret file bindings
   • Masking sensitive data in logs
   • Folder-level credentials scope
   • SSH private key management
3. Email and Slack notifications90 min
   • Mailer plugin configuration
   • Slack notification plugin
   • Conditional message templating
   • Webhook URL configuration
   • Channel mention formatting
4. The Blue Ocean visual pipeline editor90 min
   • Blue Ocean UI layout
   • Visualizing pipeline stages
   • Debugging failed steps
   • Branch navigation in UI
   • Visual editor limitations
5. Essential plugins for production pipelines90 min
   • Timestamper plugin
   • AnsiColor plugin
   • Build Timeout plugin
   • Ws-Cleanup plugin
   • Pipeline Utility Steps plugin
6. Auditing plugin security advisories60 min
   • Jenkins security advisory center
   • Vulnerable plugin identification
   • Emergency patching procedures
   • Plugin compatibility matrix
   • Rollback after faulty plugin upgrade

Hands-on project: Configure secret text and username-password credentials in Jenkins and write a post-build block to send Slack webhook notifications on build status changes.

You can provision and scale static and dynamic Jenkins agents across containerized hosts.

1. Controller and agent architecture in depth90 min
   • Workload offloading
   • Security isolation
   • JNLP agent protocol
   • TCP port for inbound agents
   • Controller resource protection
2. Static and dynamic (on-demand) agents90 min
   • SSH launch method
   • Ephemeral executors
   • Agent decommissioning
   • Remoting jar execution
   • Host key verification
3. Labels and node selection90 min
   • agent { node { label 'linux-slave' } }
   • Node restriction settings
   • Workspace cleanup
   • Exclusive execution flags
   • Label expression matching
4. Scaling builds across multiple agents90 min
   • Executor concurrency limits
   • Queue management
   • Load balancing builds
   • Offline node handling
   • Retention strategies
5. Running agents on Docker and Kubernetes120 min
   • Docker container agents
   • Pod template definitions
   • Dynamic provisioning
   • JNLP inbound agent sidecar
   • Workspace volume sharing
6. Troubleshooting agent disconnection errors60 min
   • Network timeout configuration
   • SSH key authentication debugging
   • Agent log analysis
   • Out of memory killer on agents
   • Clock skew synchronization with NTP

Hands-on project: Configure a permanent SSH agent node connected to the Jenkins controller and execute pipeline stages specifically targeted to that node label.

You can build container images inside pipelines, push them to registries, and deploy them to Kubernetes clusters.

1. Building and pushing Docker images in pipelines120 min
   • docker.image build command
   • Registry authentication binding
   • Image tagging strategies
   • Docker socket mounting security
   • Multi-arch image building
2. Running build steps inside containers120 min
   • agent { docker { image 'maven:3.9-eclipse-temurin-17' } }
   • Container workspace mapping
   • Custom tool execution
   • Container reuse optimization
   • Entrypoint override handling
3. Jenkins on Kubernetes with dynamic pod agents120 min
   • Kubernetes plugin configuration
   • PodTemplate YAML definition
   • Container sidecars
   • Resource request and limit allocation
   • Ephemeral storage sizing
4. Deploying applications to Kubernetes120 min
   • kubectl rollout restart
   • Kubeconfig credential binding
   • Namespace isolation
   • Deployment verification checks
   • Rollback on deployment timeout
5. Container registry and Helm integration120 min
   • Helm upgrade install step
   • Chart value overrides
   • Rollback on failure
   • OCI registry chart pushing
   • Release history tracking
6. Debugging containerized build failures60 min
   • Pod termination state inspection
   • Kubernetes event log analysis
   • Image pull backoff resolution
   • RBAC permissions for Jenkins service account
   • Persistent volume claim attachment errors

Hands-on project: Build a Docker image from a pipeline workspace, push it to an image registry, and update a Kubernetes deployment manifest using kubectl apply.

You can write reusable Groovy shared libraries and manage controller configuration as code using JCasC.

1. Shared libraries for reusable pipeline code120 min
   • vars directory structure
   • Global shared library configuration
   • Calling custom steps
   • Implicit loading mechanism
   • Shared library version pinning
2. Pipeline templates and best practices90 min
   • Dry principle in CI/CD
   • Error handling wrappers
   • Standardized release flows
   • Global default timeouts
   • Method encapsulation in Groovy
3. Jenkins Configuration as Code (JCasC)120 min
   • jenkins.yaml configuration file
   • Environment variable substitution
   • Immutable infrastructure setup
   • Reloading configuration via UI and CLI
   • Unclassified property definitions
4. Role-based access control and security hardening90 min
   • Role-Based Authorization Strategy plugin
   • Global and project roles
   • Security advisories patching
   • Anonymous read access removal
   • API token revocation policies
5. Backup, monitoring and maintaining Jenkins90 min
   • ThinBackup plugin
   • Prometheus metrics plugin
   • Log rotation and cleanup
   • Heap dump generation and analysis
   • Disk space threshold alerts
6. Troubleshooting Groovy CPS transformation errors60 min
   • CPS transformation limitations
   • NotSerializableException debugging
   • @Whitelisted annotation usage
   • Non-CPS method helper pattern
   • Script security sandbox approvals

Hands-on project: Create a custom global shared library containing a standardized build function and load it into multiple team pipelines.

You can run a Jenkins controller that survives a host failure and an upgrade.

1. Controller sizing and agent topology90 min
   • Controller as orchestrator only
   • Ephemeral agents
   • Executor limits
   • JVM garbage collection tuning
   • Memory sizing for large instances
2. Backup, restore and disaster recovery90 min
   • What in JENKINS_HOME matters
   • thinBackup vs scripted
   • Restore rehearsal
   • Object storage synchronization
   • RTO and RPO metrics for CI
3. Upgrades without an outage window90 min
   • LTS upgrade path
   • Plugin compatibility
   • Rollback plan
   • Staging upgrade verification
   • Zero-downtime rolling updates
4. Configuration as code90 min
   • JCasC jenkins.yaml
   • Seed jobs
   • Reproducing from scratch
   • Job DSL plugin integration
   • Immutable controller lifecycle
5. Managing multi-team shared controller instances90 min
   • Folder isolation per team
   • Resource quota enforcement
   • Global vs local plugin conflicts
   • Audit logging for admin actions
   • Capacity planning across squads
6. Disaster recovery simulation drills60 min
   • Simulating controller host failure
   • Restoring JENKINS_HOME from backup snapshot
   • Validating active agent reconnection
   • Verifying webhook routing post-restore
   • Post-incident review documentation

Hands-on project: Stand up a controller with its configuration fully defined in JCasC, script a backup of JENKINS_HOME to object storage, restore it into a clean container to prove the backup works, and perform a plugin and core upgrade behind a tested rollback.

You can stop a pipeline from leaking credentials and prove what an artifact was built from.

1. Authentication and RBAC90 min
   • Matrix and role strategy
   • Folder-scoped permissions
   • Least privilege for jobs
   • LDAP and OAuth integration
   • Service account token security
2. Credentials that do not leak90 min
   • Credentials binding
   • withCredentials masking
   • Why env vars print
   • Secret redaction regex rules
   • Third-party secret manager integration
3. Hardening the agent boundary90 min
   • Script security sandbox
   • Approving Groovy signatures
   • Untrusted PR builds
   • Isolating build workspaces
   • Preventing privilege escalation
4. Provable builds90 min
   • Artifact signing
   • SBOM generation
   • Dependency and image scanning
   • Provenance attestation
   • Vulnerability gate enforcement
5. Supply chain security compliance standards90 min
   • SLSA build level compliance
   • SOC 2 audit logging requirements
   • Secure software factory design
   • Immutable build artifact storage
   • Vulnerability remediation SLAs
6. Auditing pipeline security configurations60 min
   • Jenkins security scan scripts
   • Identifying unmasked secrets in build logs
   • Reviewing global matrix permissions
   • Checking script approval queues
   • Penetration testing CI/CD endpoints

Hands-on project: Lock a multi-team instance down with matrix-based RBAC and folder-scoped credentials, prove a secret is masked in console output, then sign a build artifact and publish an SBOM alongside it.

You can tell a broken pipeline from a broken test, and fix flakiness instead of retrying it.

1. Metrics that matter for CI90 min
   • Queue wait time
   • Build duration trend
   • Change failure rate
   • Executor saturation ratio
   • Deployment frequency tracking
2. Monitoring and alerting90 min
   • Prometheus plugin
   • Grafana dashboards
   • Alert on queue starvation
   • Controller memory leak alerts
   • Agent disconnection monitoring
3. Diagnosing flaky builds90 min
   • Test retry vs root cause
   • Shared-state collisions
   • Workspace cleanliness
   • Network port contention in tests
   • Race condition identification
4. Shared libraries and pipeline tests90 min
   • vars and src layout
   • Unit-testing a library
   • Versioned @Library
   • Jenkins Pipeline Unit testing framework
   • Mocking pipeline steps
5. Optimizing pipeline execution speed90 min
   • Dependency caching strategies
   • Parallel stage tuning
   • Incremental build configuration
   • Removing redundant workspace clones
   • Profiling slow pipeline stages
6. Post-incident analysis for pipeline outages60 min
   • Root cause analysis for blocked executors
   • Post-mortem documentation
   • Implementing preventive guardrails
   • Queue starvation remediation
   • Capacity planning review

Hands-on project: Instrument the instance with the Prometheus plugin and chart queue time and failure rate in Grafana, identify the three slowest stages of a real pipeline, and remove one genuine source of flakiness with evidence it is gone.

You can design, build, and deploy an automated enterprise-grade CI/CD pipeline for a real production application.

1. Design a complete CI/CD pipeline for a real application120 min
   • Architecture diagramming
   • Branching model selection
   • Environment staging design
   • Secret management planning
   • Release cadence definition
2. Build, test, scan, containerize and deploy automatically120 min
   • Pipeline orchestration
   • Quality gate enforcement
   • Automated cluster deployment
   • Artifact tagging and promotion
   • Health check verification
3. Multibranch pipeline with pull-request validation120 min
   • PR build triggers
   • Ephemeral test environments
   • Automatic cleanup on close
   • Status check reporting
   • Code review gate integration
4. Notifications, manual approvals and rollback120 min
   • input step for approvals
   • Automated rollback scripts
   • Stakeholder notifications
   • Emergency abort procedures
   • Audit trail generation
5. Portfolio, GitHub, mock interviews and career prep120 min
   • GitHub repository cleanup
   • Resume pipeline bullet points
   • Technical mock interview simulation
   • Troubleshooting scenario drills
   • System design Q&A preparation
6. Final project review and architecture defense60 min
   • Peer code review presentation
   • Pipeline performance benchmarking
   • Security compliance verification
   • Disaster recovery demonstration
   • Graduation feedback session

Hands-on project: Deliver a complete multi-stage pipeline that triggers on GitHub PR, runs unit tests and SonarQube scans, builds a container via Kubernetes pod agents, deploys to Kubernetes, and posts Slack alerts.