Apache2 configuration that ONLY reverse proxies resources that 404 locally

I'm trying and failing to create a working configuration for apache2 which does the following:

• Resolves resources local either by returning the static file or running some PHP
• If a 404 is to be returned checks against the reverse proxy
• If the reverse proxy returns a 404 return the local ErrorDocument

I want to do something like

ProxyPassMatch ^/(?!200).+
ProxyPassReverse / http://localhost:8080/ nocanon
ProxyErrorOverride On
ProxyPreserveHost On

The problem here is that ProxyPassMatch only works on the URL not the status code. Now in nginx I can use this configuration to do what I want.

location / {
    try_files $uri $uri/ /index.php?$args @fwd;
}

location @fwd{
    proxy_pass http://localhost:8080;
    proxy_set_header X-Forwarded-For $remote_addr;
    proxy_intercept_errors on;
    recursive_error_pages on;
}

Does anyone have any ideas how I can implement my nginx configuration in apache2?

EDIT

I feel like something like this should work (which I got by taking a look at this answer https://stackoverflow.com/questions/1582673/using-mod-rewrite-only-if-a-404-would-have-occured)

<Location /[a-z]+/>
    RewriteEngine on
    RewriteCond %{REQUEST_FILENAME} -s [OR]
    RewriteCond %{REQUEST_FILENAME} -l [OR]
    RewriteCond %{REQUEST_FILENAME} -d
    RewriteRule ^.*$ - [NC,L]
    ProxyPassReverse http://localhost:8080
</Location>

I've also tried

RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d                                                                                                                                                                                      RewriteRule ^ - [L]

RewriteRule ^ - [P]
ProxyPass / http://localhost:8080/
ProxyPassReverse / http://localhost:8080/

and

RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ - [L,P]
ProxyPass / http://localhost:8080/

This seems to work but only on static files. It doesn't work on any PHP that might be rendered, not sure why

RewriteCond /var/www/html_apache/%{REQUEST_FILENAME} -f
RewriteRule ^(.*)$ "/$1" [S=1]
RewriteRule ^ - [P]
ProxyPass / http://localhost:8080/

While "RewriteCond file exists" is not an exact duplicate, it includes an important reminder:

> Remember that RewriteCond with -f or -d needs full path to the file or directory that's why you need to prefix the filename with %{DOCUMENT_ROOT}/.

For example, this configuration first checks if the requested URI corresponds to a real file or directory in the document root.

• If it does, the request is served directly and the rewriting process stops ([L] flag).
• If the requested URI does not correspond to a real file or directory, the request is proxied to the backend server ([P] flag).

RewriteEngine On

# If the request is for a real existing file or directory, serve it directly
RewriteCond %{DOCUMENT_ROOT}%{REQUEST_URI} -f [OR]
RewriteCond %{DOCUMENT_ROOT}%{REQUEST_URI} -d
RewriteRule ^ - [L]

# If the request is not for a real file or directory, proxy it to the backend
RewriteRule ^/(.*)$ http://localhost:8080/$1 [P,L]

# Set up reverse proxy
ProxyPassReverse / http://localhost:8080/

Warning: this would not handle PHP execution. If you want Apache to execute PHP scripts before deciding whether to proxy the request, you will need to make sure you have php-fpm properly configured, in which case you might need to adjust the RewriteCond directives to also consider URIs that correspond to PHP scripts as "real" files.

You can also consider using Apache's ErrorDocument directive in combination with mod_rewrite to handle 404 errors. This approach could potentially be used to implement a fallback to a reverse proxy when a local resource is not found.

# Enable rewrite engine
RewriteEngine On

# If the request is for a real existing file or directory, serve it directly
RewriteCond %{DOCUMENT_ROOT}%{REQUEST_URI} -f [OR]
RewriteCond %{DOCUMENT_ROOT}%{REQUEST_URI} -d
RewriteRule ^ - [L]

# If the request is not for a real file or directory, return a 404 error
# The ErrorDocument directive will handle this
RewriteRule ^ - [R=404]

# Set up a custom 404 error handler
ErrorDocument 404 /handle404.php

In this configuration, /handle404.php is a PHP script that proxies the request to the backend server.
Here is a very basic example of what that script might look like:

<?php
$backend_url = 'http://localhost:8080' . $_SERVER['REQUEST_URI'];
$response = file_get_contents($backend_url);

if ($response === false) {
    // The backend server returned a 404 error
    http_response_code(404);
    echo "Not found";
} else {
    // The backend server returned a successful response
    echo $response;
}

This script uses PHP's file_get_contents function to send a request to the backend server and capture its response.
If the backend server returns a 404 error, the script sends a 404 response to the client. Otherwise, it echoes the backend server's response.

> How exactly would you go about handling the php case?

To handle PHP scripts properly in the Apache configuration, you need to ensure that PHP is executed by Apache before deciding whether to proxy the request. You can achieve this by using mod_proxy_fcgi along with php-fpm. Here is how you can adjust the configuration:

Assuming php-fpm is installed and configured, you then need to configure Apache to it (with necessary modules: mod_rewrite, mod_proxy, mod_proxy_fcgi), meaning you need to tell Apache to pass PHP scripts to php-fpm for execution. You can use the ProxyPassMatch directive for this purpose.
While you keep the mod_rewrite rules to serve local resources or proxy to a backend shown above, you make sure PHP requests are handled by php-fpm.

> All requests go through to the reverse proxy.

This can be due to the placement of the ProxyPass directive. The ProxyPass directive is executed before the mod_rewrite rules. That means the proxy will be used for all requests, bypassing the mod_rewrite rules.

Instead, let's use a RewriteRule directive with [P]:

<VirtualHost *:80>
    ServerName your-domain.com
    DocumentRoot /path/to/your/local/files

    # Handle PHP scripts with php-fpm
    <FilesMatch \.php$>
        SetHandler "proxy:unix:/path/to/your/php-fpm.sock|fcgi://localhost"
    </FilesMatch>

    # Enable rewrite engine
    RewriteEngine On

    # If the request is for a directory, internally redirect to the DirectoryIndex
    RewriteCond %{DOCUMENT_ROOT}%{REQUEST_URI} -d
    RewriteRule ^(.*/)$ $1index.php [L]

    # If the request is for a real existing file, serve it directly
    RewriteCond %{DOCUMENT_ROOT}%{REQUEST_URI} -f
    RewriteRule ^ - [L]

    # If the request is not for a real file, proxy it to the backend
    RewriteRule ^/(.*)$ http://localhost:8080/$1 [P,L]

    ProxyPassReverse / http://localhost:8080/
    ProxyPreserveHost On
    ProxyErrorOverride On

    # Error document for handling 404
    ErrorDocument 404 /path/to/your/error/document.html
</VirtualHost>

That includes:

• the FilesMatch directive tells Apache to use php-fpm for handling PHP scripts. Make sure to set the correct path to your php-fpm socket or TCP address and port if using TCP instead of a Unix socket.

• the RewriteCond and RewriteRule directives are similar to the previous example and serve files and directories if they exist.

• the request proxied to the backend server, when the file does not exist.

• the removal ProxyPass directive, in favor of RewriteRule with the [P] flag instead. This flag tells mod_rewrite to proxy the request, effectively replacing the ProxyPass directive, but also ensuring that the rewrite conditions are respected.

• the local ErrorDocument, when the backend server returns a 404.

• ProxyErrorOverride On tells Apache to handle error responses (like 404) from the proxy target and use the local ErrorDocument instead.

• the RewriteCond and RewriteRule for directories will internally redirect to the index.php file if the request URI corresponds to a directory. This essentially mimics the DirectoryIndex directive.