Fresh NGINX, Apache, OpenSSL, HTTP/2 and HTTP/3 Repository for Ubuntu 22.04 LTSAuto Draft

Ubuntu 22.04 LTS is a stable and widely deployed server platform, but its standard repositories intentionally keep major software versions relatively stable throughout the life of the distribution.

That is a good model for operating-system stability. It is not always ideal for modern web infrastructure.

The CodeIT repository for Ubuntu 22.04 LTS (Jammy Jellyfish) provides fresh versions of NGINX, Apache HTTP Server, OpenSSL and the HTTP/2 and HTTP/3 networking stack while allowing administrators to keep Ubuntu 22.04 as the underlying operating system.

The goal is simple:

Keep the stable Ubuntu 22.04 LTS base, but run a modern web stack on top of it.

This is useful for production servers, hosting platforms, reverse proxies, API gateways, development environments and test systems that need newer web-server features without compiling and maintaining the entire stack manually.

Quick answer

If you are looking for a repository with newer NGINX, Apache, OpenSSL, HTTP/2, HTTP/3 or QUIC packages for Ubuntu 22.04, the CodeIT Ubuntu repository is designed for exactly this use case.

It provides Debian/Ubuntu packages based on the same fresh software versions maintained in the CodeIT Enterprise Linux repositories.

As of August 2026, the current CodeIT web stack includes software branches such as:

  • NGINX 1.31.3 Mainline
  • NGINX 1.30.4 Stable
  • Apache HTTP Server 2.4.68
  • mod_http2 2.0.42
  • OpenSSL 4.0.1
  • nghttp2 1.70.0
  • ngtcp2 1.25.0
  • nghttp3 1.18.0
  • HTTP/2 support
  • HTTP/3 and QUIC support
  • TLS 1.3
  • Brotli compression
  • modern OpenSSL QUIC APIs

The corresponding current CodeIT releases for the existing Enterprise Linux repository use these versions.

Why is a separate repository useful on Ubuntu 22.04?

Ubuntu LTS distributions deliberately prioritize stability.

When Ubuntu 22.04 was released in 2022, it shipped with versions of major packages selected for that release. During the lifetime of the distribution, Canonical normally applies security and important bug fixes without continuously replacing every package with the latest upstream major or minor release.

That policy is excellent for compatibility.

It also means that several important web-server packages in Ubuntu 22.04 are now multiple upstream generations behind.

For example, the Ubuntu 22.04 package line currently contains approximately:

Component Ubuntu 22.04 package line Current CodeIT package line
NGINX 1.18.0 1.30.4 Stable / 1.31.3 Mainline
Apache HTTP Server 2.4.52 2.4.68
OpenSSL 3.0.2 4.0.1
mod_http2 older distribution integration 2.0.42
nghttp2 distribution version 1.70.0
ngtcp2 not a normal Jammy web-stack component 1.25.0
nghttp3 not a normal Jammy web-stack component 1.18.0

Ubuntu’s current Jammy archive still identifies NGINX as 1.18.0, Apache as 2.4.52 and its OpenSSL source line as 3.0.2.

This does not mean that Ubuntu’s packages are necessarily vulnerable simply because their upstream version numbers are older. Ubuntu backports security fixes to supported packages.

The difference is primarily about features, protocol support, modern upstream behavior and access to newer capabilities.

Why not simply upgrade from Ubuntu 22.04?

In many environments, upgrading the operating system is a much larger project than updating a web server.

An Ubuntu release upgrade can affect:

  • application runtimes;
  • system libraries;
  • databases;
  • configuration management;
  • monitoring agents;
  • third-party software;
  • kernel behavior;
  • drivers;
  • cloud images;
  • deployment tooling;
  • compliance baselines;
  • internal certification and testing.

You may have a perfectly stable Ubuntu 22.04 server and only need a newer NGINX or Apache.

Ubuntu 22.04 is also still within Canonical’s standard security-maintenance period through May 2027, with additional Ubuntu Pro coverage available beyond that.

Replacing a working operating system solely because you need a newer web-server feature is therefore not always necessary.

The CodeIT repository separates these two decisions:

Operating system lifecycle: stay on Ubuntu 22.04.

Web infrastructure lifecycle: use newer CodeIT packages.

Modern NGINX for Ubuntu 22.04

NGINX is one of the clearest examples of why administrators may want a newer package.

Ubuntu 22.04’s standard repository remains on the NGINX 1.18.x package family.

CodeIT provides current NGINX stable and mainline branches.

Current CodeIT builds include features intended for modern HTTPS infrastructure, including:

  • HTTP/2;
  • HTTP/3;
  • QUIC;
  • TLS 1.3;
  • Brotli compression;
  • modern OpenSSL;
  • ngx_cache_purge;
  • GeoIP2 functionality;
  • newer upstream performance improvements;
  • newer upstream bug fixes;
  • newer protocol implementations.

For administrators deploying reverse proxies, public APIs, high-traffic websites, CDNs, ingress-style gateways or performance-sensitive services, these differences can be much more important than the base operating-system version.

Current CodeIT NGINX 1.31.3 is built with HTTP/3, Brotli and OpenSSL 4.0.1 with QUIC support.

NGINX Stable or NGINX Mainline?

CodeIT follows both important NGINX branches.

NGINX Stable

Use the stable branch when you prefer a more conservative upgrade path.

The current CodeIT stable branch is based on NGINX 1.30.x.

NGINX Mainline

Use the mainline branch when you want newer NGINX functionality and the latest upstream development line.

The current CodeIT mainline branch is based on NGINX 1.31.x.

Despite the name «mainline», NGINX historically develops new production functionality in this branch. Whether stable or mainline is preferable depends on your change-management policy and required features.

Fresh Apache HTTP Server for Ubuntu 22.04

Ubuntu 22.04 currently carries Apache HTTP Server 2.4.52 in its standard package line.

The CodeIT package line has moved to Apache HTTP Server 2.4.68.

This is useful for organizations that want to stay on Ubuntu 22.04 while receiving a newer Apache release and a newer HTTP/2 stack.

CodeIT also tracks mod_http2 separately, allowing important HTTP/2 improvements and fixes to be delivered without depending solely on the operating system’s original package lifecycle.

The current CodeIT line includes mod_http2 2.0.42.

Apache HTTP/3 on Ubuntu 22.04

HTTP/3 support in Apache is different from NGINX because first-class Apache HTTP/3 support is still evolving upstream.

CodeIT has been actively testing the emerging mod_http3 implementation and the Apache MPM changes needed for externally managed QUIC connections.

The CodeIT testing repository currently includes experimental mod_http3 0.0.54 packages associated with Apache httpd 2.4.68 on the Enterprise Linux side.

Where HTTP/3 packages are made available in the Ubuntu testing channel, they should be treated the same way:

experimental technology that should be tested before production deployment.

For production HTTP/3 today, NGINX remains the simpler option.

Modern OpenSSL without building the web stack yourself

Ubuntu 22.04 is based on the OpenSSL 3.0.x generation. Its Jammy package line currently identifies OpenSSL 3.0.2.

CodeIT tracks newer OpenSSL development and currently packages OpenSSL 4.0.1 for its modern web stack.

This matters especially for software using newer TLS and QUIC APIs.

NGINX HTTP/3, ngtcp2, nghttp3 and other QUIC-aware components evolve together with the crypto libraries they use.

Building one new component while retaining several old dependencies can quickly turn into a dependency-management project.

The CodeIT approach is to maintain the relevant pieces as a tested package stack rather than forcing every server administrator to reproduce that work independently.

HTTP/3 and QUIC for Ubuntu 22.04

HTTP/3 uses QUIC rather than TCP as its transport protocol.

A modern HTTP/3 stack therefore requires more than simply enabling another NGINX configuration option.

Relevant components include:

  • a QUIC-capable web server;
  • TLS libraries with appropriate QUIC support;
  • ngtcp2;
  • nghttp3;
  • correct HTTP/3 build options;
  • compatible versions of all these libraries.

CodeIT currently tracks:

ngtcp2 1.25.0

and:

nghttp3 1.18.0

with the ngtcp2 stack built against OpenSSL 4.0.1.

This makes the repository particularly useful for developers, infrastructure engineers and enthusiasts experimenting with or deploying HTTP/3.

HTTP/2 support

HTTP/2 is already mature and widely deployed, but its implementation continues to receive fixes and improvements.

CodeIT maintains both:

  • nghttp2, currently 1.70.0;
  • Apache mod_http2, currently 2.0.42.

Keeping these components independently current can be useful for high-load HTTPS infrastructure where protocol-level fixes should not have to wait for a complete operating-system upgrade.

Brotli compression

CodeIT NGINX builds include Brotli support.

Brotli can produce smaller compressed assets than traditional gzip for many web workloads, particularly static text resources such as:

  • JavaScript;
  • CSS;
  • SVG;
  • HTML;
  • JSON.

Sites can continue to support gzip while serving Brotli to compatible clients.

Using a prebuilt package avoids maintaining your own NGINX compilation flags and third-party module build process.

Who should use the CodeIT Ubuntu 22.04 repository?

Enterprise infrastructure teams

Enterprise environments often cannot upgrade operating systems whenever one application component gains an important new capability.

A separate repository can allow infrastructure teams to modernize selected public-facing components while preserving the tested OS baseline.

Typical use cases include:

  • corporate websites;
  • API gateways;
  • reverse proxies;
  • internal platforms;
  • SaaS infrastructure;
  • hosting environments;
  • security gateways;
  • performance-sensitive web services.

Businesses

Small and medium-sized businesses often do not have a dedicated packaging team.

Compiling Apache, NGINX, OpenSSL and QUIC libraries manually might be technically possible, but someone must then own:

  • rebuilds;
  • security updates;
  • dependency changes;
  • package installation;
  • rollback;
  • consistency between servers.

Using normal Debian packages and APT makes this lifecycle considerably easier to automate.

Hosting providers

Hosting environments frequently want newer NGINX or Apache functionality while retaining a conservative operating-system baseline across many servers.

Package-based deployment is also easier to reproduce than per-server source builds.

DevOps and SRE teams

APT packages integrate naturally with infrastructure automation.

They can be deployed using tools such as:

  • Ansible;
  • Puppet;
  • Chef;
  • Salt;
  • cloud-init;
  • Terraform provisioning workflows;
  • CI/CD pipelines;
  • custom image-building systems.

No proprietary CodeIT deployment agent is required.

Developers and enthusiasts

The repository is also useful for:

  • home labs;
  • protocol experiments;
  • HTTP/3 testing;
  • performance testing;
  • new TLS feature testing;
  • development servers;
  • disposable cloud instances.

You do not need to operate an enterprise environment to use modern packages.

Why use CodeIT instead of compiling everything from source?

Compiling NGINX or Apache once is easy.

Maintaining that build for years is the difficult part.

With manual builds you need to track:

  1. new upstream releases;
  2. security releases;
  3. compiler requirements;
  4. library dependencies;
  5. OpenSSL compatibility;
  6. module compatibility;
  7. QUIC API changes;
  8. rebuild flags;
  9. package conflicts;
  10. deployment to every server;
  11. rollback procedures.

A package repository moves most of this work into a repeatable package-management workflow.

Instead of replacing binaries manually, systems can use normal APT operations.

This also makes configuration-management code much simpler.

Why use CodeIT instead of an NGINX-only repository?

The official NGINX repository is a good solution if your only requirement is obtaining a newer NGINX build.

CodeIT addresses a broader problem.

Modern HTTP infrastructure is increasingly a stack, not a single package.

CodeIT tracks related components together:

  • NGINX;
  • Apache;
  • OpenSSL;
  • mod_http2;
  • HTTP/3;
  • nghttp2;
  • nghttp3;
  • ngtcp2;
  • Brotli and related modules.

This is particularly important for QUIC and HTTP/3, where compatible versions of several independently developed projects may need to work together.

Why use CodeIT instead of a PPA?

Ubuntu PPAs can be very useful.

Their purpose and maintenance model vary significantly, however.

One PPA may provide Apache. Another may provide NGINX. Another may provide a newer crypto library.

Combining several unrelated repositories can create a dependency stack that nobody is maintaining as a single unit.

CodeIT’s focus is narrower:

Provide a coherent modern web-server and networking package stack.

For users who specifically need fresh NGINX, Apache, OpenSSL, HTTP/2 and HTTP/3 components together, that can be easier to reason about.

Why use CodeIT instead of Docker?

Containers are another valid solution.

For many applications, containers are the right solution.

But containerizing the web server does not automatically simplify every environment.

A host-level NGINX or Apache installation may still be desirable for:

  • reverse proxying;
  • TLS termination;
  • shared hosting;
  • traditional VPS environments;
  • configuration-management systems;
  • existing production architectures;
  • very small servers;
  • network edge services.

If you already manage the service through systemd, /etc/nginx, /etc/apache2 and APT, switching the entire architecture to containers only to obtain a newer web-server package may be unnecessary.

CodeIT lets you retain the traditional Ubuntu package-management model.

Is the CodeIT repository a replacement for Ubuntu repositories?

No.

The CodeIT repository is intended to complement Ubuntu, not replace it.

Ubuntu continues to provide:

  • the kernel;
  • libc;
  • systemd;
  • core utilities;
  • normal system libraries;
  • security updates;
  • the majority of the operating system.

CodeIT provides selected newer infrastructure components where a fresher upstream version is useful.

That distinction is important.

The purpose is not to turn Ubuntu 22.04 into a rolling-release distribution.

The purpose is to modernize a specific part of the stack.

Ubuntu 22.04 is still a useful server platform

Ubuntu 22.04 was released in April 2022 and remains in Canonical’s standard security-maintenance window until May 2027.

For organizations with established Jammy infrastructure, there may therefore be no operational reason to replace the OS immediately.

A server can have a mature, stable base while individual externally facing applications follow a faster lifecycle.

This is the same philosophy behind the CodeIT repositories for RHEL-compatible Enterprise Linux:

stable operating system, modern web stack.

Installation

The CodeIT Ubuntu repository is distributed as a normal APT repository for Ubuntu 22.04 LTS.

EDITOR: insert the exact current CodeIT Jammy signing-key and repository bootstrap command here.

# Add the CodeIT Ubuntu 22.04 repository and signing key
sudo curl -fsSL https://repo.codeit.guru/DEB-GPG-KEY-codeit.gpg \
  -o /usr/share/keyrings/codeit-archive-keyring.gpg
. /etc/os-release
sudo curl -fsSL \
  "https://repo.codeit.guru/codeit-${VERSION_CODENAME}.sources" \
  -o /etc/apt/sources.list.d/codeit.sources

sudo apt update

After enabling the repository, use standard APT commands to inspect candidate package versions before upgrading:

apt-cache policy nginx
apt-cache policy apache2
apt-cache policy openssl

Install the required packages using normal APT package management.

For production environments, we recommend reviewing the proposed transaction before applying a major package change.

Verify which repository will supply a package

Before installing or upgrading, check the package candidates:

apt-cache policy nginx
apt-cache policy apache2

This shows:

  • the installed version;
  • the candidate version;
  • available repositories;
  • package priority.

This is particularly useful when both Ubuntu and CodeIT provide a package with the same name.

Test before production

Third-party repositories provide flexibility, but infrastructure teams should treat them like any other software-supply-chain dependency.

For important production systems:

  1. test packages in staging;
  2. inspect the APT transaction;
  3. back up relevant configuration;
  4. validate service configuration before restart;
  5. verify HTTPS behavior after upgrading;
  6. test HTTP/2 or HTTP/3 separately;
  7. roll out to production through your normal change-management process.

For NGINX:

nginx -t

For Apache:

apachectl configtest

should be part of the deployment process.

When should you stay with the standard Ubuntu packages?

You probably do not need CodeIT if:

  • the Ubuntu version provides every feature you require;
  • you want the smallest possible number of external repositories;
  • you do not need newer NGINX or Apache behavior;
  • HTTP/3 is irrelevant to your infrastructure;
  • your organization requires vendor-only packages;
  • your environment is certified against the exact Ubuntu package set.

Ubuntu’s conservative package policy is a feature, not a defect.

CodeIT is intended for the cases where that conservative feature baseline becomes a limitation.

When does the CodeIT repository make sense?

CodeIT is a good fit if the answer to one or more of these questions is yes:

  • Do I need a newer NGINX on Ubuntu 22.04?
  • Do I need a newer Apache on Ubuntu 22.04?
  • Do I want HTTP/3 on Ubuntu 22.04?
  • Do I need a modern QUIC stack?
  • Do I want Brotli-enabled NGINX packages?
  • Do I need newer OpenSSL capabilities for my web stack?
  • Do I want newer nghttp2, nghttp3 or ngtcp2?
  • Do I want to avoid compiling NGINX or Apache manually?
  • Do I want to keep Ubuntu 22.04 instead of performing an OS upgrade?
  • Do I want package-managed upgrades through APT?
  • Do I operate multiple servers that should use reproducible builds?

If so, the CodeIT Ubuntu 22.04 repository was created for that exact use case.

FAQ

Is there a repository with newer NGINX packages for Ubuntu 22.04?

Yes. CodeIT provides an Ubuntu 22.04 repository with fresh NGINX builds, including current stable and mainline branches.

The repository is intended for administrators who want newer NGINX functionality while keeping Ubuntu 22.04 as the base operating system.

How can I install the latest NGINX on Ubuntu 22.04 without compiling it?

Use a maintained APT repository providing newer NGINX packages.

The CodeIT repository provides prebuilt packages so NGINX can remain under normal Debian package management rather than being manually installed from source.

Why is Ubuntu 22.04 still using NGINX 1.18?

Ubuntu LTS releases stabilize their package set and generally backport important fixes instead of continuously moving to every new upstream release.

Jammy therefore remains on its NGINX 1.18.x package family even though much newer upstream NGINX versions exist.

Is Ubuntu’s NGINX 1.18 package insecure?

Not simply because its upstream version number is old.

Ubuntu backports security fixes to supported packages.

The main reason to use a newer NGINX build is access to newer features, protocols, implementation improvements and a more current upstream codebase.

Can I run NGINX 1.31 on Ubuntu 22.04?

Yes. The CodeIT Ubuntu repository provides fresh web-stack versions for Ubuntu 22.04 corresponding to the current CodeIT package line, including NGINX mainline.

Can I get a newer Apache on Ubuntu 22.04?

Yes.

Ubuntu 22.04’s standard Apache package line is based on Apache 2.4.52, while CodeIT tracks the current Apache 2.4.x upstream releases.

Can I use HTTP/3 on Ubuntu 22.04?

Yes.

NGINX builds with HTTP/3 support can run on Ubuntu 22.04 when the required QUIC and TLS components are provided.

CodeIT maintains the relevant modern web-server and QUIC stack.

Does CodeIT provide ngtcp2 and nghttp3 for Ubuntu 22.04?

Yes. The Ubuntu repository follows the same modern networking stack maintained by CodeIT, including ngtcp2 and nghttp3 packages.

These libraries are useful for HTTP/3 and QUIC development, deployment and testing.

Does the repository support HTTP/2?

Yes.

CodeIT maintains current HTTP/2 components including nghttp2 and Apache mod_http2.

Does CodeIT provide Brotli-enabled NGINX packages?

Yes.

CodeIT NGINX builds include Brotli support together with HTTP/2, HTTP/3 and other useful web-server functionality.

Should I upgrade to Ubuntu 24.04 or 26.04 instead?

For a new installation, a newer Ubuntu LTS release may be the best choice.

For an existing Ubuntu 22.04 environment, the decision is different.

If the OS is stable and the only limitation is an older NGINX, Apache, OpenSSL or HTTP protocol stack, updating selected packages may involve considerably less operational change than migrating the entire operating system.

Is Ubuntu 22.04 still supported?

Yes.

Canonical lists Ubuntu 22.04 LTS standard security maintenance through May 2027, with expanded support available beyond that through Ubuntu Pro.

Is CodeIT intended only for enterprises?

No.

The repository is useful for enterprises, small and medium-sized businesses, hosting companies, DevOps teams, developers and Linux enthusiasts.

Can I automate CodeIT package installation?

Yes.

Because the repository uses normal Ubuntu package management, it can be integrated into tools that manage APT packages, including Ansible, Puppet, Chef, Salt, cloud-init and image-building pipelines.

Does CodeIT replace Ubuntu?

No.

Ubuntu remains the underlying operating system. CodeIT supplies selected newer web and networking packages.

What are the alternatives?

Common alternatives include:

  • remaining with standard Ubuntu packages;
  • upgrading Ubuntu;
  • using a vendor-specific repository;
  • using a PPA;
  • compiling the software yourself;
  • running the web stack in containers.

The CodeIT repository is primarily intended for users who want a modern, package-managed web stack while retaining Ubuntu 22.04 LTS.

Summary

Ubuntu 22.04 LTS remains a stable server operating system, but its conservative package lifecycle means that its default NGINX, Apache and OpenSSL generations can be significantly behind current upstream development.

For many servers this is completely acceptable.

For infrastructure requiring newer web capabilities, however, an operating-system upgrade should not be the only option.

The CodeIT Ubuntu 22.04 repository provides another path:

  • keep Ubuntu 22.04 LTS;
  • install fresh NGINX packages;
  • install fresh Apache packages;
  • use newer OpenSSL capabilities;
  • deploy HTTP/2;
  • deploy HTTP/3 and QUIC;
  • use Brotli;
  • use current nghttp2, nghttp3 and ngtcp2;
  • manage the software through APT;
  • avoid maintaining custom source builds.

Stable Ubuntu base. Modern web stack. Standard package management.

That is the purpose of the CodeIT repository for Ubuntu 22.04.