Skip to main content
AI
  • Get started with AI

    • Red Hat AI

      Accelerate the development and deployment of enterprise AI solutions.

    • AI learning hub

      Explore learning materials and tools, organized by task.

    • AI interactive demos

      Click through scenarios with Red Hat AI, including training LLMs and more.

    • AI/ML learning paths

      Expand your Red Hat OpenShift AI knowledge using these learning resources.

    • AI quickstarts

      Focused AI use cases designed for fast deployment on Red Hat AI platforms.

    • No-cost AI training

      Foundational Red Hat AI training.

  • Featured resources

    • Red Hat OpenShift AI
    • Open source AI for developers
    • AI product application development
    • Open source-powered AI/ML for hybrid cloud
    • AI and Node.js cheat sheet

Red Hat AI Factory with NVIDIA

Red Hat AI Factory with NVIDIA is a co-engineered, enterprise-grade AI solution for building, deploying, and managing AI at scale across hybrid cloud environments.

Learn
  • Self-guided

    • Documentation

      Find answers, get step-by-step guidance, and learn how to use Red Hat products.

    • Learning paths

      Explore curated walkthroughs for common development tasks.

    • Guided learning

      Receive custom learning paths powered by our AI assistant.

    • See all learning
  • Hands-on

    • Developer Sandbox

      Spin up Red Hat's products and technologies without setup or configuration.

    • Interactive labs

      Learn by doing in these hands-on, browser-based experiences.

    • Interactive demos

      Click through product features in these guided tours.

  • Browse by topic

    • AI/ML
    • Automation
    • Java
    • Kubernetes
    • Linux
    • See all topics
  • Training & certifications

    • Courses and exams
    • Certifications
    • Skills assessments
    • Red Hat Academy
    • Learning subscription
    • Explore training
Build
  • Get started

    • Red Hat build of Podman Desktop

      A downloadable, local development hub to experiment with our products and builds.

    • Developer Sandbox

      Spin up Red Hat's products and technologies without setup or configuration.

  • Download products

    • Red Hat Enterprise Linux
    • Red Hat AI
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform
    • See all products
  • Featured

    • Red Hat build of OpenJDK
    • Red Hat JBoss Enterprise Application Platform
    • Red Hat OpenShift Dev Spaces
    • Red Hat Developer Toolset
  • References

    • E-books
    • Documentation
    • Cheat sheets
    • Architecture center
Community
  • Get involved

    • Events
    • Live AI events
    • Red Hat Summit
    • Red Hat Accelerators
    • Community discussions
  • Follow along

    • Articles & blogs
    • Developer newsletter
    • Videos
    • Github
  • Get help

    • Customer service
    • Customer support
    • Regional contacts
    • Find a partner

Join the Red Hat Developer program

Download Red Hat products and project builds, access support documentation, learning content, and more.

ConsoleDocsSupport Search
New For you

Resources to explore

Check out popular resources, tools, and information from Red Hat. We'll recommend more as you browse.

  • Product downloads
  • Cheat sheets
  • Red Hat Developer learning portal
  • Developer blog
  • E-books
  • Developer Sandbox
Log in

Get more with a Red Hat Developer account

  • Product downloads
  • Console access
  • Event registration
  • Training & trials
Explore more account benefitsLog in or register

A subscription may be required for some services.

Contact us

Automate Lightwell updates with Mend Renovate

November 20, 2026
Ben Breard Matej Marušák
Related topics:
SecurityDevSecOpsCI/CD
Related products:
LightwellImage mode for Red Hat Enterprise Linux

    Lightwell helps protect the supply chain of open source libraries and provides many vulnerability remediations. Lightwell targets both the Common Vulnerabilities and Exposures (CVEs) that scanners are built to detect and newly discovered, or novel, vulnerabilities that scanners do not yet look for. In its first few months, Lightwell has delivered more than 800 novel vulnerability remediations. Lightwell can reduce your risk exposure and close entire attack vectors that were previously invisible to security teams.

    Accessing these remediated libraries is only the first step; you also need to embed them into your software development lifecycle (SDLC) and, ideally, apply them automatically. Whether you're evaluating Lightwell for your organization or rolling out patches across an active enterprise subscription, this workflow shows how to apply remediated dependencies automatically. In this article, we use Mend Renovate, an open source dependency automation tool that runs across most continuous integration and continuous delivery (CI/CD) environments to help teams keep application dependencies up-to-date. If you use an alternative updater, many of the core integration principles and patterns discussed here will still apply.

    See it in action

    Watch the demonstration video of Lightwell with Mend Renovate to see automated dependency updates in action.

    Why Mend Renovate?

    Many tools offer dependency automation, but few are as extensible and as widely adopted as Mend Renovate. Here are the main reasons we chose Mend Renovate for Lightwell:

    • First-class support for versioning and suffixes: Lightwell patches append clean release identifiers (like .rhlw-00001 or .rhlw-00002). You can define specific matching rules so your tooling treats these rebuilds as preferred upgrades rather than unexpected Semantic Versioning (SemVer) jumps.
    • Pluggable advisory feeds: Mend Renovate connects to ecosystem data feeds, such as Open Source Vulnerabilities (osv.dev), so your updater can evaluate vulnerability context alongside release metadata.
    • Built for enterprise scale and native CI/CD runs: Whether you're running centralized GitHub Actions, GitLab CI, or self-hosted command-line runners in air-gapped environments, Mend Renovate runs as a stateless process wherever your code lives.
    • Maintainer and developer friendly: Mend Renovate interacts directly with repositories through a dependency dashboard and submits pull requests (PRs), simplifying updates for end users.

    Exploring the presets and repository use

    Nobody wants to manually edit pom.xml files every time a security update ships. Different applications also require different patching strategies. To help on both fronts, we published standard presets in the lightwell-experience/renovate-config repository. Instead of configuring rules from scratch or relying on the default Maven resolver, you can extend the profile that matches your patching strategy:

    • java-remediated: The conservative baseline. It pins you to your exact library version and only bumps to the latest Lightwell rebuild (for example, 3.7.1 to 3.7.1.rhlw-00002), applying backported security fixes without breaking API changes.
    • java-upgrade: Follows standard Maven SemVer rules and proposes updates to .rhlw artifacts based on your update policies (for example, 3.7.1 to 3.18.0.rhlw-00002).
    • python-manager: Uses Python's local version identifier specification (+rhlw_). Because pip and uv naturally prefer these local builds, Mend Renovate keeps pinned versions up-to-date without extra version rules.

    To use a preset, add an extends block to your renovate.json configuration file:

    {
      "$schema": "https://docs.renovatebot.com/renovate-schema.json",
      "extends": [
        "github>lightwell-experience/renovate-config:java-upgrade"
      ]
    }

    This configuration works without extra changes if you use Renovate and build directly from the Lightwell repositories. However, we expect most enterprise developers to define a few more settings so Renovate fits within their environments and pulls from a local artifact repository, for example.

    Getting started

    Setting up automated remediation requires no major architectural overhaul. Whether developers trigger Mend Renovate locally or run it with centralized CI pipelines, the integration follows a straightforward lifecycle with this automation loop (Figure 1).

    Lightwell Registry publishes a .rhlw patch, triggering Mend Renovate to open a pull request, run the CI test suite, and mark it ready for merge.
    Figure 1: Scheduled or CI-triggered Renovate runs evaluate the application repository against your preset and gate merges on test suite results.

    Prerequisites

    Mend Renovate supports a wide range of platforms and fits well with both Software-as-a-Service (SaaS) and on-premise environments. Refer to the official documentation to see all supported platforms and options.

    Artifact repository: You can access Lightwell repositories directly using Lightwell service accounts. However, this approach assumes broad access and using artifact repositories such as JFrog Artifactory or Sonatype Nexus might offer a better access model for larger environments. We recommend using virtual repositories that resolve dependencies in the priority order shown in Figure 2.

    Virtual repository fallback hierarchy for Lightwell: Predisclosure, Remediated, Validated, and Community repositories.
    Figure 2: Virtual repository resolution falls back from early novel vulnerability fixes to public upstream registries, such as Maven Central for Java and PyPI for Python.

    Source code management (SCM) platform with runners set up: Most major Git-powered platforms are good options, and chances are you're already using one. Common options include GitHub, GitLab, Gitea, and Forgejo.

    Tokens: You need a GitHub token to access security metadata. If you use a different SCM platform for application repositories, you also need a user token for a bot account, as well as access tokens for Lightwell or your artifact repositories.

    Application repository: Start with a Java or Python application, or try the Lightwell demonstration application! This demo is set up for the public testing repository and is easy to modify for the full Lightwell repositories when you have an active membership.

    Adding Mend Renovate to your environment

    If you're new to dependency automation, don't get overwhelmed by the available options. Start by using runners for your SCM platform. Not only does this approach keep things clean, but it centralizes logs so developer teams can access them in one place. Other deployment options exist when running Mend Renovate at scale across thousands of repositories in your SCM platform.

    GitHub users can install the official Mend Renovate GitHub App, while teams running self-hosted Gitea instances can follow the Gitea tutorial on using Renovate Bot. Both approaches monitor your repositories and submit pull requests automatically.

    Adding your application repository

    Once Mend Renovate is running in your SCM platform, you can onboard an application by defining its update rules and registry settings in your repository.

    Configuring renovate.json

    To configure Mend Renovate for Lightwell, update your repository's renovate.json file to accomplish 3 goals:

    • Inherit the Lightwell preset so Mend Renovate recognizes the .rhlw version precedence.
    • Point to your local Artifactory mirror so your tooling fetches metadata and rebuilds instead of querying public registries directly.
    • Group related updates to prevent PR fatigue and keep notification noise down.

    Here's an example configuration tuned for an internal Artifactory mirror (replace the placeholder values [ARTIFACT_MIRROR] and [ARTIFACT_MIRROR] or [VIRTUAL_REPO_PATH]/ for your environment):

    {
      "$schema": "https://docs.renovatebot.com/renovate-schema.json",
      "extends": [
        "config:recommended",
        "github>lightwell-experience/renovate-config:java-upgrade"
      ],
      "dependencyDashboard": true,
      "hostRules": [
        {
          "matchHost": "https://[ARTIFACT_MIRROR]",
          "hostType": "maven"
        }
      ],
      "packageRules": [
        {
          "matchManagers": ["custom.regex"],
          "matchDatasources": ["maven"],
          "registryUrls": ["https://[ARTIFACT_MIRROR]/[VIRTUAL_REPO_PATH]/"]
        },
        {
          "matchManagers": ["custom.regex"],
          "matchDatasources": ["maven"],
          "groupName": "all maven dependencies",
          "groupSlug": "all-maven-deps"
        }
      ]
    }

    Let's break down what's happening in this file:

    • extends: Imports Mend Renovate's default configuration (config:recommended) alongside github>lightwell-experience/renovate-config:java-upgrade. This configuration enables the regex and custom manager rules needed to prefer .rhlw security rebuilds whenever an upgrade path exists.
    • dependencyDashboard: Creates an issue in your repository that acts as Mend Renovate's status hub. It gives you a clean view of pending updates, rate limits, and let-me-retry buttons without cluttering your PR list.
    • hostRules: Tells Renovate that requests heading to https://[ARTIFACT_MIRROR] are Maven queries. If your mirror requires basic authentication, this is also where you'd inject credentials. If you don't use local artifact repositories, add your Lightwell repository credentials here instead.
    • packageRules (Local Artifactory redirect): The Lightwell preset defines the custom regex managers and version-matching rules so you do not have to write them manually. This rule matches those managers and points registryUrls directly to your internal Artifactory repository mirror.
    • packageRules (batching PRs): Instead of Renovate peppering your team with 5 separate PRs for 5 different Maven dependencies, groupName: "all maven dependencies" bundles them into a single pull request. Your CI pipeline runs once against the whole batch, validating all dependency updates at once.

    Once this file lands on your default branch, trigger the Renovate workflow manually or let the next cron run pick it up. Your initial Dependency Dashboard issue appears, followed shortly by a PR containing your Lightwell remediated artifacts.

    Adding OSV vulnerability feeds

    Mend Renovate also supports checking Open Source Vulnerabilities (OSV) feeds. Add the following settings to your renovate.json file to enable this feature:

    "osvVulnerabilityAlerts": true,
    "dependencyDashboardOSVVulnerabilitySummary": "all"

    Keep in mind that OSV support is currently marked as experimental in Mend Renovate. While it worked well in our testing with Lightwell, evaluate its experimental status before enabling it in production environments.

    Once configured, Mend Renovate opens a pull request containing the security advisory metadata and merge controls, as shown in Figure 3.

    Mend Renovate pull request updating netty-codec-dns to 4.1.132.Final-rhlw-00002 with Lightwell Security Advisory details.
    Figure 3: Pull requests generated by Mend Renovate command-line tool link directly to CVE, GitHub Security Advisory (GHSA), and Lightwell advisory records while surfacing automerge and rebase settings.

    Further automation worth exploring

    Getting automated PRs is a great start, but you can optimize further. Once the baseline is working, look for operational friction in your review cycles and optimize your workflow:

    • Find the manual bottlenecks (hint: it's your test suite): The biggest blocker to fast adoption isn't generating the PR, it's having the confidence to merge it. Build reliable unit and integration test coverage so PRs don't wait weeks for manual quality assurance (QA).
    • Batch your updates intentionally: While micro-PRs work well for isolated services, they can flood notifications on larger repos. Use Mend Renovate's group:all package rules to bundle routine patch updates into single weekly digests.
    • Speed up updates with automerge: For drop-in rebuilds (java-remediated) where public APIs remain unchanged, consider enabling automerge to merge pull requests automatically once CI tests pass. This approach shrinks your exposure window down to the duration of a test suite run without touching a single button. Check out the for advanced configuration options around automerge rules and scheduling windows.
    • Use Mend Renovate to automate container and OS updates: Beyond application libraries, you can also use Renovate to track base container layers and coordinate image mode for Red Hat Enterprise Linux (bootc) operating system updates across server fleets.
    • Go deeper with transitive dependencies: The configurations covered so far address direct dependencies. Transitive dependencies also need coverage, and you can find tools for this in the Lightwell Renovate repository and in our article on managing Java transitive dependencies with Lightwell rebuilds.

    Your turn!

    Pairing Mend Renovate with Lightwell reduces manual security tracking by turning tested vulnerability remediations into automated pull requests. Thanks to our friends at mend.io for partnering with us. Explore their commercial offerings for additional security and automation capabilities.

    To start integrating automated remediations into your workflow, add github>lightwell-experience/renovate-config:java-remediated to your project's renovate.json on a test branch, or clone our sample application repository to see automated Lightwell pull requests in action.

    Related Posts

    • Manage Java transitive dependencies with Lightwell rebuilds

    • Test Lightwell dependency upgrades locally

    • Add automated AI evaluations to your CI/CD pipeline

    • Deploy with confidence: Continuous integration and continuous delivery for agentic AI

    • Red Hat UBI vs. Red Hat Hardened Images: How to choose

    • Automate Spring 5.3.x CVE remediation with Lightwell

    Recent Posts

    • Automate Lightwell updates with Mend Renovate

    • Configure HikariCP for Spring Boot on Red Hat OpenShift 4

    • OpenShift Pipelines and Test Containers

    • The ultimate guide to analyzing and troubleshooting critical issues on Red Hat Enterprise Linux 8 and 9

    • Automate Spring 5.3.x CVE remediation with Lightwell

    What’s up next?

    Learning Path Image mode for Red Hat Enterprise Linux share and feature image

    Build a hardened Flask stack and deploy it in image mode for Red Hat Enterprise Linux

    Build a Python Flask application on Red Hat Enterprise Linux 10 using...
    Red Hat Developers logo

    Platforms

    • Red Hat AI
    • Red Hat Enterprise Linux
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform
    • See all products

    Build

    • Developer Sandbox
    • Developer tools
    • Interactive tutorials
    • API catalog

    Quicklinks

    • Learning resources
    • E-books
    • Cheat sheets
    • Blog
    • Events
    • Newsletter

    Communicate

    • About us
    • Contact sales
    • Find a partner
    • Report a website issue
    • Site status dashboard
    • Report a security problem

    Red Hat Developer

    Build here. Go anywhere.

    We serve the builders. The problem solvers who create careers with code.

    Join us if you’re a developer, software engineer, web designer, front-end designer, UX designer, computer scientist, architect, tester, product manager, project manager or team lead.

    Sign me up

    Red Hat legal and privacy links

    • About Red Hat
    • Jobs
    • Events
    • Locations
    • Contact Red Hat
    • Red Hat Blog
    • Inclusion at Red Hat
    • Cool Stuff Store
    • Red Hat Summit
    © 2026 Red Hat

    Red Hat legal and privacy links

    • Privacy statement
    • Terms of use
    • All policies and guidelines
    • Digital accessibility
    Ask AI