Jenkins: Jobs, Pipelines, CI/CD and DevOps for Beginners

Learn how to implement continuous integration with Git and Jenkins, building and testing code as developers integrate changes into a pipeline for a faster and more reliable DevOps workflow.

Sign up for a free GitHub account to store your pipeline as code in a git repository, and connect GitHub with Jenkins for your CI/CD workflow.

Fork the public repository to create your own copy, then use Visual Studio Code space on the main branch to explore the project, install dependencies, and run npm start.

Use docker as a build environment in Jenkins pipelines to ensure npm and other tools run inside a node 18 alpine image.

Learn to troubleshoot Jenkins pipelines using Docker and diagnose common container errors. Restore pipeline operation by stopping and restarting containers with docker compose down and docker compose up -d.

Explains how docker and non-docker stages use separate workspaces, and demonstrates enabling a shared workspace with reused node true to synchronize workspaces across pipeline stages.

Define a pipeline by adding a Jenkins file at the project root, commit and push changes, then configure Jenkins to run the pipeline from Git SCM on main.

In a Jenkins pipeline, set up a production build by running npm ci to install dependencies and npm run build to create an optimized build for deployment.

Revisit Jenkins architecture and how a Docker-enabled agent runs a stage: the controller clones the repo into the workspace, maps it to the container, runs commands, then stops the container.

Practice running tests in a Jenkins pipeline by adding a test stage, checking for index.html in the build folder, and executing npm test within ci/cd.

Expand the Jenkins pipeline by adding a test stage, verify the build artifact, and run npm tests in a Node.js docker environment, noting stage dependencies.

Publish a JUnit report from Jenkins by configuring a post action to always publish the JUnit XML file from the test results directory, enabling trend and detail viewing in Jenkins.

Discover how to use single-line and block comments in a Jenkinsfile to speed up pipeline development by disabling stages or commands while keeping a valid pipeline.

Run end-to-end tests with playwright in a Jenkins CI pipeline by building and serving a local build, then executing npx playwright test.

Publish an html report from Playwright in Jenkins by enabling the html reporter, configuring the html publisher with pipeline syntax, and viewing the report directly from the job workspace.

Learn how to run the unit test and end-to-end test in parallel inside a wrapper stage using the parallel directive. Configure per-stage post actions to publish JUnit and HTML reports.

Learn how the Blue Ocean plugin transforms Jenkins pipelines into a clearer visual interface, enabling easier pipeline visualization, test and log inspection, and artifact access, with a switchable classic view.

Structure a pipeline by considering stage dependencies and the build-to-test order, balancing parallelism to save time. Use fail-fast and early linting, then experiment to optimize common failures.

Learn to apply security updates to Jenkins and plugins, document each change, and perform one-at-a-time updates using Docker Compose, including stopping, rebuilding, restarting, and validating the new version.

Master Jenkins fundamentals for continuous integration by building a simple, yet functional, pipeline and learn the most important concepts for working with pipelines in Jenkins.

Deploy your website to the cloud with Netlify, and build a complete CI/CD pipeline featuring continuous delivery and continuous deployment, including build, test, and deployment steps.

Manually deploy the application by uploading the build directory to Netlify, then open the production URL to verify deployment success.

Automate Netlify deployments from Jenkins by installing Netlify CLI via npm and running it from the project's node_modules with Docker and the Node.js runtime, avoiding browser interactions.

Configure deployment by storing the Netlify site id in a Jenkins file as an environment variable named netlify_ci_id, enabling automated production deployment and log verification.

Generate a Netlify token and securely store it in Jenkins as a global secret text credential, then reference it in your pipeline.

Learn how to securely inject the Netlify_auth_token into a Jenkins pipeline using the credentials helper and Netlify_site_id. Use Netlify status to verify authentication and review pipeline logs for deployment readiness.

Deploy production builds with the Netlify CLI deploy command, configure the Netlify auth token and site ID, specify the build directory, and verify deployment via logs and the site URL.

Configure build triggers in Jenkins to run pipelines periodically using cron syntax, including scheduling at 3 a.m. Monday to Friday, with attention to minute, hour, and load distribution.

Enable git poll SCM in Jenkins to automatically trigger the pipeline when new commits are detected in the GitHub repository, checking the repository on a configurable schedule (every minute).

Automate post-deployment checks by running end-to-end Playwright tests against production in a Jenkins pipeline, with separate HTML reports and environment variables to validate production behavior.

Learn how staging environments enable safe deployment testing through infrastructure as code, creating production-identical non-public pre-production spaces that protect live sites.

Deploy the project to a staging environment with the Netlify CLI, remove the prod flag, and test via the draft URL.

Pause a Jenkins pipeline between the build and deploy stages, enabling a manual input for staging review before production, and add a timeout to avoid forever waiting.

Engage in hands-on practice by adding a manual approval step to a Jenkins pipeline between deploy staging and deploy to production, guided by a step-by-step quiz.

Add a manual approval stage between deploy staging and deploy production in a Jenkins pipeline, configure the input message and 15-minute timeout, then commit the updated Jenkins file.

Automate end-to-end testing by extracting the dynamic staging url from Netlify's json output, saving it to a file, and parsing it with jq to feed tests in the pipeline.

Learn how to pass dynamic data between stages in Jenkins pipelines by setting and reading environment variables with a script block, using dynamic values like the date command.

Enable end-to-end testing on the staging deployment by adapting production tests and wiring a staging URL through stages with scripts and environment variables.

Learn to merge related pipeline stages in Jenkins to streamline staging and production deployment. Use a single docker image with environment variables for reliable CI/CD and end-to-end testing.

Learn how continuous delivery automates building, testing, and deploying with a manual approval checkpoint, and how continuous deployment removes that step to push updates to production.

remove the manual approval step and enable continuous deployment in Jenkins pipeline by injecting a dynamic application version based on the build id, then verify it with tests across environments.

Learn to manage environment variables in a ci cd workflow: check if the version variable is defined using echo or env, export it, and display building version in a message.

Fetch website content with curl, inspect the page source for a description or title, and pipe to grep to verify text like Valentino while using quiet mode for CI/CD checks.

Take a break after deploying our small application and explore CLI tools, variables, secrets, and approval steps. Compare continuous delivery and continuous deployment, and review Linux commands and complex scripts.

Explore how to find and build appropriate Docker images for your projects, install extra tools, and integrate a custom image into Jenkins pipelines for faster, reliable CI/CD and DevOps workflows.

Explore how Docker containers package applications and dependencies for isolated, efficient execution, using images, push and pull operations, and registries to enable consistent builds in DevOps pipelines.

Choose a docker image in the Jenkins pipeline by matching your project's language and version, using official images like node:18-alpine or python:3-alpine, and consult Docker Hub docs for tags.

Learn where dotnet images reside, compare Docker Hub with the Microsoft Artifact Registry, and use fully qualified paths from mcr.microsoft.com to access dotnet runtime images.

Create a Dockerfile at the project root, start from a base image, install Netlify CLI and jq via run, then tag and build the image in a Jenkins pipeline.

Use a custom Playwright Docker image in the Jenkins pipeline to deploy staging and prod, removing npm install and Netlify CLI, trimming node_modules, and speeding up deploys.

Update the dockerfile to use my playwright, remove npm install serve, and ensure unit and end-to-end tests run in the test stage of the pipeline.

Install serve globally with npm and update the docker image accordingly. Commit changes, run the pipeline, and note faster end-to-end tests using the my playwright image built for our needs.

Optimize the pipeline by moving docker image builds to a nightly Jenkins job, freeing the day pipeline for faster execution and reusing the latest image during the day.

Install Linux packages in Docker containers by using the right package manager for each image, install jq without node, and manage permissions in a Jenkins pipeline.

Install jq with apt in a custom docker image built in the pipeline, using apt update and apt install with &&, and remove npm-installed jq to rely on Linux packages.

Review the basics of Docker for basic DevOps needs, emphasize practicing to deepen your understanding of this underlying technology, essential regardless of your job title.

Deploy a website to the AWS cloud using a CLI and explore Jenkins features while building a complete CI/CD pipeline that builds, tests, and deploys in AWS.

Explore Amazon Web Services as a global pay-as-you-go cloud platform offering virtual servers, storage, and more, with hands-on setup guidance for the console, regions, free tier, and multi-factor authentication.

Amazon S3 explains storing public files in buckets as objects and serving them over HTTP, highlighting unique bucket names and the basics for automation in upcoming lessons.

Learn to interact with the AWS cloud using the AWS CLI in a Jenkins pipeline by running a Docker image, checking the AWS CLI version, and handling entrypoint overrides.

We use AWS CLI v2 in this course, not v1, and follow the most up-to-date documentation.

Learn to use the AWS CLI inside a Jenkins pipeline to manage AWS services, list S3 buckets with aws s3 ls, and handle non-interactive credential configurations.

Create a Jenkins IAM user with an S3-specific policy and no console access, then use AWS CLI access keys for programmatic calls, following least privilege and secret management.

Learn to manage AWS credentials in Jenkins by creating and binding the AWS access key id and AWS secret access key using the with credentials block in a pipeline.

Upload a local file to an S3 bucket using the AWS CLI copy command in a Jenkins pipeline, creating index.html and using an environment variable for the bucket.

Learn how to turn an S3 bucket into a public static website by enabling static website hosting, allowing public access, and configuring a get object policy for all bucket objects.

Deploy the built site to AWS in production by syncing the local build directory with an S3 bucket using the AWS CLI sync, ensuring the bucket mirrors the build.

Explore amazon elastic compute cloud (ec2) fundamentals, launching a ubuntu instance with a free tier ami, and connecting via ec2 instance connect. Stop, start, and terminate to control costs.

Deploy a website to the AWS cloud with a fully automated pipeline using S3 and IAM, and learn to use the AWS CLI and domain linking to an S3 bucket.

Dockerize a web app for AWS by building a Docker image, storing it in Amazon Container Registry, deploying with Amazon Elastic Container Service, and optimizing Jenkins pipelines with Linux commands.

Learn how Amazon Elastic Container Service (ECS) lets you deploy containerized apps on AWS without managing virtual servers, using Docker containers, clusters, and task definitions for scalable deployments.

Explore Elastic Container Service launch modes, compare EC2 and Fargate, and learn to provision a cluster, estimate costs, and deploy a Docker container using Fargate for beginners.

Learn to create an ECS cluster using AWS Fargate, deploy a simple nginx container from Docker Hub, name your cluster, and distinguish production and testing environments.

Create an ECS task definition using JSON for a single nginx container on Fargate, configure port mappings and CPU and memory resources, and save the definition as a JSON file.

Learn to create an ECS service from a task definition using Fargate, deploy nginx, and configure security group rules to expose HTTP access.

Update a running ECS deployment by creating a new task definition revision and updating the service via the AWS CLI, with Jenkins automation.

Update the service via AWS CLI by specifying the cluster, service name, and a task definition revision in Jenkins. The update launches the new task and briefly runs two tasks.

Automate updating AWS task definitions by parsing CLI JSON with jq to extract the latest revision and feed it into your deployment scripts, reducing manual edits in Jenkins pipelines.

Use the AWS CLI wait command to ensure an ECS service becomes stable after updating the task definition in a Jenkins pipeline, avoiding unreliable sleeps.

Learn how to package your web app in a docker image, build it with a dockerfile, push to Amazon ECR, and deploy to ECS in a Jenkins pipeline.

Create a docker image by defining a dockerfile, using nginx as the base image, and copying site files to /usr/share/nginx/html.

Build a docker image in a Jenkins pipeline using the project’s dockerfile and build context, tagging it as my Jenkins app. Troubleshoot by mapping docker.sock and installing Docker.

Build a custom AWS CLI docker image within a Jenkins pipeline, creating two images (AWS CLI and Playwright), optimizing build time and validating root usage via logs.

Tag Docker images with a versioned tag to uniquely identify images and support deployment, updates, and rollbacks. Use app name and version variables to generate tags that include build numbers.

Learn how to store a docker image in a private AWS Elastic Container Registry (ECR), tag and push it from a Jenkins pipeline using get-login-password and docker login.

Publish and reference an ECR Docker image, update the ECS task definition with the image URI and execution role, then deploy and verify the Jenkins build version across the pipeline.

Automate text substitution in a Jenkins pipeline using sed to replace a hardcoded app version with a version variable in the task definition, performing in-place, global edits.

Learn to use Jenkins to build a Docker image, store it in a Docker container registry, and deploy to the AWS cloud, including EKS and ECR.

Terminate cloud resources to prevent unexpected costs, as illustrated by Netlify and AWS bills; set reminders to cancel services after learning, and review pay-as-you-go plans.

Trace the past of Jenkins and its plugin-driven CI/CD roots, and compare it with modern platforms like GitLab and GitHub that offer integrated, secure pipelines with YAML and Docker support.

Explore Jenkins basics, AWS, and DevOps with practical tips, and deepen skills in Docker, Kubernetes, Linux CLI, and bash to extend learning beyond the course.