Zhihao Lou's Notebook

How to Reverse Proxy Jupyter Notebook on a Subpath Using Nginx

Thu, 29 Feb 2024 00:00:00 +0000

Recently, I needed to proxy my Jupyter Notebook web interface from host.domain:8888 to a subpath directly from the HTTP 80 port host.domain/jupyter/. Unfortunately, the fact that Jupyter uses WebSocket for the communication between its kernel and the web application, makes setting up correct proxy in Nginx slightly more complicated. After a few searches and experimentation, I have reached a working solution, which I am documenting below.

In `jupyter_notebook_config.py` file

In order for the Jupyter server to serve files correctly, we need to set its base URL in $HOME/.jupyter/jupyter_notebook_config.py. Simply set or add the following line

c.ServerApp.base_url = '/jupyter/'

In `http` section of `nginx.conf` file

We need to create a variable based on the $http_upgrade value

map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}

In `server` section of `nginx.conf` file

We need to define a subpath and use the variable we just defined

location /jupyter/ {
        proxy_pass http://localhost:8888;
        proxy_http_version 1.1;
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
	proxy_set_header Connection $connection_upgrade;
	proxy_set_header Upgrade $http_upgrade;
}

Linux Server Review: Fedora 37 Server Edition

Sun, 15 Jan 2023 00:00:00 +0000

Introduction

In the previous post, we’ve reviewed Debian 11 from the perspective of using it as a server. Today, let’s check out the other major distribution, Fedora 37 Server Edition.

Installation

The installation is done using net install image. Fedora installation process really encourages you to use its graphical interface, and its TUI has very limited capability. Compare to Debian, it is a much heavier weight experience. The installation process needs at least 2GB of RAM to succeed. Even in TUI, the process will crash if has only 1GB of memory.

On the other hand, the Fedora’s installer (the older but lesser known Anaconda) allows much more flexibility and customization than Debian’s installation.

In particular, you can fully control the enable / disable of root account, whether allowing SSH as root using password, and regular user account’s group setting all independently.

Default Service and Security

Fedora 37 Server Edition by defaults installs Cockpit that runs on port 9090. This is a fully featured server management web service (web console, in Red Hat’s documentation) that make lots of system administration work straightforward. It also contain lots of additional capabilities like managing virtual machines or containers. But those features are not limited to Fedora, and beyond the scope of this review.

From security point of view, the default settings for Fedora Server is really tight. It has only port 22 (SSH) and 9090 (aforementioned Cockpit) open out of the box. More importantly, the majority ports are configured to drop the packet outright. That makes port scanning takes more than 10x longer than using reject.

# Nmap 7.93 scan initiated Mon Jan  9 22:35:45 2023 as: nmap -p- -T4 -oN - 192.168.1.55
Nmap scan report for fedora-server.lan (192.168.1.55)
Host is up (0.00059s latency).
Not shown: 65383 filtered tcp ports (no-response), 150 filtered tcp ports (admin-prohibited)
PORT     STATE SERVICE
22/tcp   open  ssh
9090/tcp open  zeus-admin
MAC Address: 0A:E5:16:D0:BC:B5 (Unknown)

# Nmap done at Mon Jan  9 22:38:09 2023 -- 1 IP address (1 host up) scanned in 144.60 seconds

In addition, the (in)famous SELinux is set to enforcing by default. This adds an additional layer of protection, and will potentially cause a ton of headaches down the line if you need to do anything unconventional by Red Hat’s book.

Network Services

Similar to the Debian review, I am going to document my experience in setting up Nginx and PostgreSQL in Fedora.

Serving Web Pages with Nginx

Fedora 37’s package repository have Nginx version 1.22.1, which is the current stable version. The installation includes a nginx.service unit file, but by default it is not enabled. To start the Nginx server, you will need to enable and start the service using systemctl, and also add HTTP service in firewall-cmd. The configuration files come with the package are very close to the upstream.

# tree /etc/nginx
/etc/nginx
├── conf.d
├── default.d
├── fastcgi.conf
├── fastcgi.conf.default
├── fastcgi_params
├── fastcgi_params.default
├── koi-utf
├── koi-win
├── mime.types
├── mime.types.default
├── nginx.conf
├── nginx.conf.default
├── scgi_params
├── scgi_params.default
├── uwsgi_params
├── uwsgi_params.default
└── win-utf

Serving Static Files

For static sites, you will simply need to change the root location in /etc/nginx/nginx.conf and make sure the user nginx has access to the files. This is very close to the upstream behavior.

Serving Dynamic Web Applications

For a dynamic web app using nginx -> gunicorn -> flask, Fedora Server turns out to be much more difficult to configure than expected, mostly due to the harsh SELinux security settings.

Fedora Server’s gunicorn installation doesn’t include a systemd unit file. You can manually create one in /etc/systemd/system/, similar to many other Linux distributions. However, due to SELinux, the unit file has to be actually in that directory. A symlink to an unexpected location will cause SELinux to deny access due to lack of Type Enforcement context.

Similarly, a simple proxy_pass in nginx will also fail. After scrambling around SELinux audit log and audit2why command, we get the following message.

type=AVC msg=audit(1673673416.968:788): avc:  denied  { name_connect } for  pid=7058 comm="nginx" dest=8000 scontext=system_u:system_r:httpd_t:s0 tcontext=system_u:object_r:soundd_port_t:s0 tclass=tcp_socket permissive=0

	Was caused by:
	The boolean httpd_can_network_connect was set incorrectly.
	Description:
	Allow httpd to can network connect

	Allow access by executing:
	# setsebool -P httpd_can_network_connect 1

That means SELinux does not allow nginx to connect to upstream server by default. To allow network connect, the “correct” way is to run the following command

# setsebool -P httpd_can_network_connect 1

There are lots of online discussion and debate already on whether to turn off SELinux. It is beyond the scope of this review to have deeper discussion about this topic.

Database with PostgreSQL

Fedora 37 comes with PostgreSQL version 14.3, which is one major version behind as of this writing. The installation includes a few Fedora customized tools such as postgresql-setup and postgresql-new-systemd-unit. Once it is installed, it will put postgresql.service and postgresql@.service under /usr/lib/systemd/system, but no actual database will be created.

To create the default database with data directory at /var/lib/pgsql/data, simply run the included script and then enable the postgresql service:

# postgresql-setup --initdb
# systemctl enable postgresql
# systemctl start postgresql

To allow connection over TCP port (5432 by default), the port needs to be explicitly allowed in firewalld

# firewall-cmd --permanent --add-port=5432/tcp

For a database with custom data directory, things is a bit more complicated under Fedora 37 Server Edition. There are directions on how to achieve that under /usr/share/doc/postgresql/README.rpm-dist.

You first need to create a new systemd unit file, and initialize the database in the special directory

# postgresql-new-systemd-unit --unit postgresql@pgdata --datadir /data/pgdata
# postgresql-setup --initdb --unit postgresql@pgdata --port 5433

Once the data directory is created, to make SELinux happy, you will need to set context and enable NIS.

# semanage fcontext -a -t postgresql_db_t "/data/pgdata(/.*)?"
# setsebool -P nis_enabled 1

Finally, for allowing network connection, in addition to changes in typical postgresql.conf and pg_hba.conf, you will also need to open the TCP port.

Summary

Fedora 37 Server Edition is a very solid and secure distribution, to the point it is making system administration annoying with SELinux enabled. Most packages are quite up-to-date, but the additional scripts included are not as useful as Debian ones. This is a great Linux distribution for those who are already experienced in Linux.

Linux Server Review: Debian 11 Bullseye

Thu, 05 Jan 2023 00:00:00 +0000

Forward

Recently, I needed to spin up a Linux server instance. Since I have been out of practice for a few years now, I went out to look for a few comprehensive reviews for various Linux distributions. Unfortunately, while that are abundance of Linux reviews, from the great Distrowatch to various blogs and Youtube channels, rarely do they focus on server related topics. Considering Linux as a server is what over 90% of people working on Linux actually do, and Linux on desktop™ is perpetually a year away, the lack of server oriented Linux review is really a sad really. Unsatisfied with this, I decided to write my own.

This will be the first out of hopefully a few posts to review distributions with a focus on server administration. This post will review Debian 11 Bullseye.

Installation

The installation is done using netinst.iso image via TUI with only SSH server and standard system utilities installed.

Root Account

During installation, the Debian installer will give you the option to set a password for root user or disable it entirely.

Setting a non-empty password will enable the root user login via password. This is a more traditional setup that many people are familiar with. If one choose to enter an empty password in the process, the root user will be disabled. Instead, the regular user to be created in the next step will be part of sudo group and can carry out sysadmin work via sudo commands. Worth noting that, as a quirk from the Debian installation, if the root user is enabled, sudo the program will not be installed by default, and as a result, the regular user created will not be in sudo group.

Default Security

Once installed, Debian 11 has reasonably good out-of-box security. Nmap scan show that only TCP port 22 (SSH) is open. One thing to note is that all other ports are rejected with TCP reset. Depending the school of thought you subscribe to, this might be either the exact right thing to do, or reducing the security by not using drop / no-response, and thus allowing port scanning to move quickly. I was able to scan all 65,535 ports in about 11 seconds.

# Nmap 7.93 scan initiated Sat Dec 31 00:11:30 2022 as: nmap -p- -T4 -oN - 192.168.1.53
Nmap scan report for debian.lan (192.168.1.53)
Host is up (0.00054s latency).
Not shown: 65534 closed tcp ports (reset)
PORT   STATE SERVICE
22/tcp open  ssh
MAC Address: 08:00:27:D2:04:B6 (Oracle VirtualBox virtual NIC)

# Nmap done at Sat Dec 31 00:11:41 2022 -- 1 IP address (1 host up) scanned in 10.85 seconds

In addition, the default sshd_config is set to disallow password login for root account. This adds some more security or annoyance depending on your view.

Network Services

For most developers, you want to hit the ground run in the shortest time possible. This usually means needing to spin up a web server and a database of sorts. Here I review how to install and configure Nginx and PostgreSQL in Debian 11.

Serving Web Pages with Nginx

Debian 11’s package repository currently contains Nginx version 1.18.0. This is a few version behind, but completely expected. When installed, it will automatically add nginx.service as part of multi-user.target.wants. It also come with a very modularized configuration directory.

# tree /etc/nginx/
/etc/nginx/
├── conf.d
├── fastcgi.conf
├── fastcgi_params
├── koi-utf
├── koi-win
├── mime.types
├── modules-available
├── modules-enabled
│   ├── 50-mod-http-geoip.conf -> /usr/share/nginx/modules-available/mod-http-geoip.conf
│   ├── 50-mod-http-image-filter.conf -> /usr/share/nginx/modules-available/mod-http-image-filter.conf
│   ├── 50-mod-http-xslt-filter.conf -> /usr/share/nginx/modules-available/mod-http-xslt-filter.conf
│   ├── 50-mod-mail.conf -> /usr/share/nginx/modules-available/mod-mail.conf
│   ├── 50-mod-stream.conf -> /usr/share/nginx/modules-available/mod-stream.conf
│   └── 70-mod-stream-geoip.conf -> /usr/share/nginx/modules-available/mod-stream-geoip.conf
├── nginx.conf
├── proxy_params
├── scgi_params
├── sites-available
│   └── default
├── sites-enabled
│   └── default -> /etc/nginx/sites-available/default
├── snippets
│   ├── fastcgi-php.conf
│   └── snakeoil.conf
├── uwsgi_params
└── win-utf

Serving Static Files

For static pages, one can put the files anywhere. Just make sure the user www-data have access to the directory and the files within, and update the root line in /etc/nginx/sites-available/default and it is good to go.

Serving Dynamic Web Applications

Unlike static pages, Debian doesn’t include builtin niceties for serving a web app. Use an nginx -> gunicorn -> flask application as an example. To achieve that, you will need to manually create a systemd unit file for gunicorn in /etc/systemd/system/, and in nginx site configure file, point proxy_pass to the bind address or socket of gunicorn.

Database with PostgreSQL

Another common use for a Linux server is to run a relational database. Here I use PostgreSQL as an example for the review.

Debian 11 comes with PostgreSQL version 13, which is not up to date, but completely serviceable. In addition to the database and client tools, it also included a few Debian customized management tools such as pg_lsclusters, pg_ctlcluster, and pg_createcluster that help with cluster management. Upon installation, somewhat surprisingly, it automatically creates a database cluster called main with data directory at /var/lib/postgresql/13/main. This cluster is configured to start automatically, and allow localhost connection only by default. If this is what you need, you are good to go. Or you can further customize the configuration files under /etc/postgresql/13/main/.

Sometimes, a data directory under /var may not be the best option. It is straightforward to create new cluster with custom data directory, presumably in a separate mount point, using either the included Debian specific pg_createcluster script or PostgreSQL’s builtin initdb command. In addition, the default cluster can be turned off by editing the configure file /etc/postgresql/13/main/start.conf.

Summary

The Debian 11 offers a solid albeit slightly out-of-date Linux server distribution. Its packages includes many small quality-of-life improvements over their corresponding upstream releases. From the perspective of server applications, these choices are certainly the right tradeoff to make. This is definitely a great Linux distribution for servers.

How to Modify Variables from a Callback Function in Python

Fri, 22 Apr 2016 00:00:00 +0000

I recently came across the trackbar demo in the OpenCV-Python Tutorials as part of my quest of teaching myself computer vision. This demo shows the usage of the high level GUI features (trackbar in this case) in the OpenCV library. For the demonstration proposes, the tutorial passes a do-nothing function as the callback handler in the creation of trackbar cv2.createTrackbar(). The trackbar value is then retrieved from a call to cv2.getTrackbarPos(). This makes me wonder if it is possible to give a trackbar a proper callback function so the change of position can be handled directly inside the callback.

Using a class method

The straightforward way to enable callback function to communicate with its outside scope is to pass a class method as the callback. Thus, the demo would look like the following without the need to call cv2.getTrackbarPos(). From simplicity, I’m only using one trackbar instead of 4 in the demo.

import cv2
import numpy as np

class ValWithCallback(object):
    def __init__(self, val=0):
        self.val = val
    def change(self, val):
        self.val = val

grey = ValWithCallback(0)
img = np.zeros((300, 512), np.uint8)
cv2.namedWindow('image')
cv2.createTrackbar('GREY', 'image', 0, 255, grey.change)
while (1):
    img[:] = grey.val
    cv2.imshow('image', img)
    k = cv2.waitKey(1) & 0xFF
    if k == ord('q'):
        break
cv2.destroyAllWindows()

However, using a dedicated class for such a simple operation seems an overkill to me. I wonder if there are other simpler and cleaner ways to achieve the same result. The answer turns out to be yes, but a clean implementation requires the understanding how closure in Python works, and how Python treats mutable and immutable objects differently.

Name binding in Python

In Python, by default a function can access a variable outside its scope, but cannot assign a new value to that variable. For immutable types like integer and float, this means the closure is read only.

x=0
def myfunc1():
    print x
myfunc1() # 0
def myfunc2():
    x=1 # this x is now a local variable
myfunc2()
print x # global x is still 0

Furthermore, trying to access a global variable before a (local) assignment will raise an error

x=0
def myfunc3():
    print x
    x=1
myfunc3() # UnboundLocalError

Using a global variable

To change this behavior, we can declare the variable to be global.

x=0
def myfunc4():
    global x
    x=1
myfunc4()
print x # 1

This gives the another solution to the callback problem.

import cv2
import numpy as np
grey=0
def change(x):
    global grey
    grey = x
img = np.zeros((300, 512), np.uint8)
cv2.namedWindow('image')
cv2.createTrackbar('GREY', 'image', 0, 255, change)
while (1):
    img[:] = grey
    cv2.imshow('image', img)
    k = cv2.waitKey(1) & 0xFF
    if k == ord('q'):
        break
cv2.destroyAllWindows()

However, if you have nested classes or functions, using a simple global will be inconvenient. In Python 3, there is nonlocal keyword to provide more flexible control over the variable scope. In Python 2, we are out of luck and need to investigate other possible means to do the same.

Using a mutable type

When a function accessing a variable of mutable type like list or dictionary, the behavior changes. Assignment still cause the variable to bind to a local version, however modifications to the variable itself will be persistent. Consider the following examples:

x=[0]
def myfunc5():
    print x
    x[0] = 1
myfunc5() # [0]
print x # [1]
def myfunc6():
    print x
    x = [1]
myfunc6() # UnboundLoacalError

This behavior prompts another solution to the callback question. To eliminate repetition, I used a more general function and then bind them use functools.partial.

import cv2
import numpy as np
from functools import partial

def change(obj, idx, val):
    obj[idx] = val
color = [0, 0, 0]
img = np.zeros((300, 512, 3), np.uint8)
cv2.namedWindow('image')
cv2.createTrackbar('R', 'image', 0, 255, partial(change, color, 2))
cv2.createTrackbar('G', 'image', 0, 255, partial(change, color, 1))
cv2.createTrackbar('B', 'image', 0, 255, partial(change, color, 0))
while (1):
    img[:] = color
    cv2.imshow('image', img)
    k = cv2.waitKey(1) & 0xFF
    if k == ord('q'):
        break
cv2.destroyAllWindows()

Notes on Hash Table

Tue, 26 Jan 2016 00:00:00 +0000

This post is my study notes on the algorithms and implementations of hash tables.

Hash Functions

Hash Functions for Strings

A common hash function for strings looks like the following:

unsigned hash(char *str) {
    unsigned h = M; // initial value
    while(str) {
        h = h * C + str; // implicit mod 2**(sizeof(unsigned)*8)
        ++ str;
    }
    return str;
}

In particular, the famous djb2 hash function by Danial J. Bernstein uses M=5381 and C=33. The multiplication by 33 or other value in the form of 2**n + 1 can be done by

h = (h << 5 + h) + str; // where n = 5 => C = 33

Some argue that multiplication in modern CPUs is fast enough so this is no longer necessary.

Collision Resolution

Collision happens when different keys generate the same hash. The two major methods for collision resolution are separate chaining and open addressing.

Separate Chaining

Separate chaining is conceptually simple: each entry in the hash table is a list or list-like structure (e.g. head cells) so all keys hash to same index are stored in the same list. Adding and deleting keys are simply the list operations on the corresponding list.

The major downside of separate chaining is the peformance as inserting new entry into the list involves allocating new memory. Following the list may also cause all sorts of performance issue due to non-locality in memory.

Open Addressing

Open addressing store all the entries in the bucket array itself. When collision happens, it try to find an unoccupied slot according to some “probe sequence”. The choice of the probe sequences include:

linear probing: simply trying the next slot
quadratic probing: index is calculated using some quadratic polynomial (python uses this method)
double hashing: next index is calculated by another hash function

One chanlleage in open addressing is when deleting entries, setting the entry back to unoccupied state will break the hash table if there are more entries of the same hash. A common strategy is to set the entry to some dummy state that is different from empty.

Reading Materials

Finding XML Root Element Using Boost Property Tree

Sat, 12 Dec 2015 00:00:00 +0000

Recently, for various reasons, I need to convert some XML parsing code from using libxml2 to boost::property_tree::ptree. During such migration, one issue arises from the different way two libraries treating the root element of a XML document.

In libxml2, one is able to get the root element without knowing its name by using the function xmlDocGetRootElement(). Being spoiled by this feature, our XML files grow a little messier than they otherwise should have and having multiple different names for the root element. In order to be able to process these files, we need the new code to be able to replicate the old behavior.

This requirement creates some difficulties as ptree::get_child() requires the name of each node along the path. To be honest, boost::property_tree is a general purpose tree structure that supports not only XML but also JSON and INI format. As a result, its XML parser is much more tolerant than a pure XML parser. For example, it will be perfectly happy to parse a file with multiple root elements which most other XML library will complain about. As a side effect, the root element in ptree does not have special status.

This means I need to write my own function that finds the root element without referring to its name. Fortunately, ptree provide a Container-like interface that allow me to iterate through the (key-node) pairs of any node’s direct sub-nodes. The pair is defined as

typedef std::pair<const Key, self_type> value_type;

where self_type is a typedef of the node itself. Knowing this, I can simply get the first sub-node from the container. The code snippet looks like the following:

#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/ptree.hpp>
using boost::property_tree::ptree;

std::string filename("some_file_name");
ptree pt;
read_xml(filename, pt, boost::property_tree::xml_parser::trim_whitespace);
ptree &root = pt.begin()->second;

The second used here because pt.begin() returns an iterator that dereference to an std::pair where first is the node name and second is the sub-node itself.

Certainly, this code gives you the root element if the XML file is well-formed. If there are multiple root elements in the XML document, this will return the first one. If there is no root element, it will throw an exception as that will cause to dereference a past-the-end iterator.

Using libxml2 on Supercomputers Considered Harmful

Sat, 05 Dec 2015 00:00:00 +0000

I was blissfully unaware of a nasty bug in libxml2 and happily using it for my parallel simulated annealing code running on Beagle. That is, until last week when Beagle underwent a system upgrade and all of sudden my code start segfaulting. Upon inspecting the core dump, I was surprised to find out that it is xmlInitParser, which is in turn called by xmlParseFile that was causing the segmentation fault.

Since Beagle uses different systems for its head nodes and compute nodes, like many supercomputer systems do, my first intuition was that the libxml2 from the head nodes might be no longer work on compute nodes. If that was the case, simply compiling libxml2 from the source using the cross compiler should fix that. Unfortunately, it was not that simple. A freshly compiled libxml2 still causes segfaults.

A few googles later I landed at this bugzilla page. Basically libxml2 implicitly uses pthreads and somehow statically linking to it might cause the the code to segfault. Even worse, the maintainer refused to fix this bug citing “Static Linking Considered Harmful”.

It is this attitude, not the bug, that made me furious. Surely I understand it is usually a bad practice to statically link some library. But for many supercomputers, statically linking the library is the only viable option. By refusing to fix this bug, the fine people at Gnome simply ignored the constraint we are having in the scientific computing community.

In an ideal world where the bandwidth, IO, and storage are all infinitely abundant, certainly linking library dynamically would be the correct way to do things. However, many current supercomputers, like IBM BlueGene series or Cray XE series (on which Beagle is based) or newer, uses severely limited compute nodes in order to achieve maximal performance. These “nodes” usually don’t even have their own storage beyond the stripped down kernel in their firmware. Famously, the original IBM BlueGene/L model doesn’t even support fork or system calls on the compute node. The only real filesystem they can access is the network shared user filesystem. Hence, it is common practice for the vender to supply compilers that only produces statically linked binary.

That left me with little choice. Surely I can go down the rabbit hole and try to patch the libxml2 code myself, provided the patch attached in the ticket is still relevant 5 years later. But I guess that won’t be the best use of my time. Since their attitude left me a bitter taste, I’ll declare that using libxml2 on supercomputers considered harmful, and switch my XML parsing code entirely to boost::property_tree. Yes, the code I’m working on contains both C and C++ code. Actually, it contains decades of work by multiple people but that will be a post for another day.

How to Use Cached Template Loader in Django

Thu, 26 Nov 2015 13:53:00 +0000

Django’s deployment checklist mentioned that using a cached template loader will improve the performance. However, without giving a solid example, the documentation only direct me to its template loaders docs. So it’s left to me to do some digging and experimenting.

The Django documentation describes the cached.Loader as a wrapper for other “real” loaders. Unlike the more common filesystem.Loader and app_directories.Loader, which one only needs to set DIRS and APP_DIRS options inside of TEMPLATES settings, cached.Loader requires a full loaders option complete with arguments. The example given by the documentation looks like this

TEMPLATES = [{
    'BACKEND': 'django.template.backends.django.DjangoTemplates',
    'DIRS': [os.path.join(BASE_DIR, 'templates')],
    'OPTIONS': {
        'loaders': [
            ('django.template.loaders.cached.Loader', [
                'django.template.loaders.filesystem.Loader',
                'django.template.loaders.app_directories.Loader',
            ]),
        ],
    },
}]

Glancing at this example, which inconspicuously missing the usual 'APP_DIRS': True setting, one attempts to merge that with existing settings which usually ends up look like this

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
            'loaders': [
                ('django.template.loaders.cached.Loader', [
                    'django.template.loaders.filesystem.Loader',
                    'django.template.loaders.app_directories.Loader',
                ]),
            ],
        },
    },
]

Unfortunately, this is not the case. This setting will hit you with an ImproerlyConfigured exception complains about

app_dirs must not be set when loaders is defined.

when rendering. After some Googling and experimenting, it turns out the 'APP_DIRS' setting went missing in the example for a reason. Once you specified django.template.loaders.app_directories.Loader as one of the loaders wrapped in the cached loader, you don’t need (and should not) set 'APP_DIR': True anymore. Removing that line gives you a happily configured Django. Now the correct TEMPLATE setting look like this

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
            'loaders': [
                ('django.template.loaders.cached.Loader', [
                    'django.template.loaders.filesystem.Loader',
                    'django.template.loaders.app_directories.Loader',
                ]),
            ],
        },
    },
]

Zhihao Lou's Notebook

How to Reverse Proxy Jupyter Notebook on a Subpath Using Nginx

In jupyter_notebook_config.py file

In http section of nginx.conf file

In server section of nginx.conf file

Linux Server Review: Fedora 37 Server Edition

Introduction

Installation

Default Service and Security

Network Services

Serving Web Pages with Nginx

Serving Static Files

Serving Dynamic Web Applications

Database with PostgreSQL

Summary

Linux Server Review: Debian 11 Bullseye

Forward

Installation

Root Account

Default Security

Network Services

Serving Web Pages with Nginx

Serving Static Files

Serving Dynamic Web Applications

Database with PostgreSQL

Summary

How to Modify Variables from a Callback Function in Python

Using a class method

Name binding in Python

Using a global variable

Using a mutable type

Notes on Hash Table

Hash Functions

Hash Functions for Strings

Collision Resolution

Separate Chaining

Open Addressing

Reading Materials

Finding XML Root Element Using Boost Property Tree

Using libxml2 on Supercomputers Considered Harmful

How to Use Cached Template Loader in Django

In `jupyter_notebook_config.py` file

In `http` section of `nginx.conf` file

In `server` section of `nginx.conf` file