JupyterHub-自构建

官方提供的 [JupyterHub(Docker)](/doc/248/#h2-jupyterhub28docker29) 部署后，还需要自行安装 jupyterlab 环境，无法修改配置(启动参数中没有指定配置文件)，自然也就无法定义JupyterHub Web的管理员

## docker-compose 部署
使用自构建镜像+[SSL](https://jupyterhub.readthedocs.io/en/stable/tutorial/getting-started/security-basics.html)
```bash
version: '3.3'
name: 'jupyterhub'
services:
  jupyterhub:
    image: 918178/jupyterhub:latest
    # restart: always
    ports:
      - '8000:8000'  # 开放端口
    volumes:
      - ./jupyterhub_config.py:/srv/jupyterhub/jupyterhub_config.py  # jupyterhub_config.py 配置文件
      # - ./key:/srv/jupyterhub/key  # SSL 证书
      - ./key/*.918178.xyz.cer:/path/to/my.cert  # SSL cert
      - ./key/*.918178.xyz.key:/path/to/my.key  # SSL key
```
`jupyterhub_config.py`
```python
# 精简配置文件
c = get_config()  # 不可动
c.JupyterHub.admin_access = True  # 管理员有权在各自计算机上以其他用户身份登录,以进行调试
c.JupyterHub.hub_ip = '0.0.0.0'  # API 允许访问的IP
c.JupyterHub.hub_port = 8081  # API 允许访问的端口
c.JupyterHub.ip = '0.0.0.0'  # Web 允许访问的IP
c.JupyterHub.port = 8000  # Web 允许访问的端口
c.JupyterHub.ssl_cert = '/path/to/my.cert'  # SSL cert
c.JupyterHub.ssl_key = '/path/to/my.key'  # SSL key
c.Spawner.args = ['--allow-root']  # 单用户服务器必须设置,否则可能会无法启动
c.Authenticator.admin_users = {'root','zwzw'}  # 管理员帐号(需要系统下自行创建)
```

## Dockerfile 自构建
参考官方Docker镜像构建层的命令，自行构建一个优化这些问题的
```bash
nano Dockerfile		# 创建 Dockerfile 构建配置
docker build -t 918178/jupyterhub:latest .		# 构建镜像
docker run -itd --name jupyterhub -p 8000:8000 918178/jupyterhub:latest		# 部署容器

# 上传 Docker Hub，方便后期使用
docker login		# 根据提示登录你的 Hub 帐号
docker push 918178/jupyterhub:latest		# 上传镜像
```
`Dockerfile`，构建的配置文件
```yaml
# 使用 debian 作为基础镜像(官方使用的是Ubuntu)
FROM debian:bullseye-slim

# 环境变量
ENV DEBIAN_FRONTEND=noninteractive \
    PYTHONDONTWRITEBYTECODE=1
    # LC_ALL=en_us.UTF-8 \
    # LANG=en_us.UTF-8 \
    # LANGUAGE=en_us.UTF-8

# 创建工作目录
WORKDIR /srv/jupyterhub

# 复制自定义配置文件
COPY jupyterhub_config.py .

# 更新 apt 源并安装依赖项
RUN sed -i 's#http://deb.debian.org/#http://mirrors.tuna.tsinghua.edu.cn/#' /etc/apt/sources.list && \
    apt-get update -qq && \
    apt-get install -yqq --no-install-recommends ca-certificates curl gnupg locales python-is-python3 python3-pip python3-pycurl nodejs npm && \
    locale-gen $LC_ALL && \
    npm config set registry https://registry.npm.taobao.org && \
    npm install -g configurable-http-proxy@^4.2.0 && \
    pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple && \
    python3 -m pip install --no-compile --no-cache-dir --upgrade setuptools pip jupyterhub jupyterlab notebook jupyterlab-language-pack-zh-CN && \
    apt-get autoremove -y && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* /var/log/* /var/tmp/* ~/.npm
# 安装完成后清理以缩减镜像大小

# 新加一个zwzw用户作为管理员
RUN useradd -m -s /bin/bash zwzw && \
    echo 'zwzw:123456' | chpasswd

# 暴露 JupyterHub 端口(Web,API)
EXPOSE 8000 8001

# 启动 JupyterHub
CMD ["jupyterhub", "--config", "jupyterhub_config.py"]
```

## jupyterhub_config.py 配置文件
可以使用 `jupyterhub --generate-config` 来生成默认配置文件

`jupyterhub_config.py` 精简配置文件
```python
c = get_config()  # 不可动
c.JupyterHub.admin_access = True  # 管理员有权在各自计算机上以其他用户身份登录,以进行调试
# c.JupyterHub.hub_ip = '0.0.0.0'  # API 允许访问的IP
# c.JupyterHub.hub_port = 8081  # API 允许访问的端口
c.JupyterHub.ip = '0.0.0.0'  # Web 允许访问的IP
c.JupyterHub.port = 8000  # Web 允许访问的端口
c.Spawner.args = ['--allow-root']  # 单用户服务器必须设置,否则可能会无法启动
# c.Spawner.notebook_dir = '~'  # 每个用户工作目录
# c.Spawner.default_url = '/lab'  # 用户登录后默认打开lab(主界面)/notebooks(笔记本)
c.Authenticator.admin_users = {'root','zwzw'}  # 管理员帐号(需要系统下自行创建)
# c.JupyterHub.ssl_cert = '/path/to/my.cert'  # SSL 指定证书
# c.JupyterHub.ssl_key = '/path/to/my.key'  # SSL 指定密钥
```

`jupyterhub_config.py` 完整配置文件说明
```python
# jupyterhub 的配置文件
c = get_config()  # noqa

#------------------------------------------------------------------------------
# 应用程序（SingletonConfigurable）配置
#------------------------------------------------------------------------------
## 这是一个应用程序。

## 由日志格式化程序用于 %(asctime)s 的日期格式
#  默认: '%Y-%m-%d %H:%M:%S'
# c.Application.log_datefmt = '%Y-%m-%d %H:%M:%S'

## 日志格式模板
#  默认: '[%(name)s]%(highlevel)s %(message)s'
# c.Application.log_format = '[%(name)s]%(highlevel)s %(message)s'

## 通过值或名称设置日志级别。
#  选择: [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'] 中的任何一个
#  默认: 30
# c.Application.log_level = 30

## 配置额外的日志处理程序。
#
#  默认的 stderr 日志处理程序由 log_level、log_datefmt 和 log_format 设置配置。
#
#  此配置可用于配置额外的处理程序（例如，将日志输出到文件）或更精细地控制默认处理程序。
#
#  如果提供，这应该是一个日志配置字典，有关更多信息，请参阅：
#  https://docs.python.org/3/library/logging.config.html#logging-config-
#  dictschema
#
#  此字典与基本日志配置合并，该配置定义了以下内容：
#
#  * 用于交互式使用的日志格式化程序称为
#    ``console``。
#  * 一个将写入 stderr 的日志处理程序称为
#    ``console``，它使用格式化程序 ``console``。
#  * 一个名称为该应用程序的记录器设置为 ``DEBUG``
#    级别。
#
#  此示例添加了一个新的处理程序，该处理程序将写入文件：
#
#  .. code-block:: python
#
#     c.Application.logging_config = {
#         'handlers': {
#             'file': {
#                 'class': 'logging.FileHandler',
#                 'level': 'DEBUG',
#                 'filename': '<path/to/file>',
#             }
#         },
#         'loggers': {
#             '<application-name>': {
#                 'level': 'DEBUG',
#                 # 注意：如果您在此处不列出默认的 "console"
#                 # 处理程序，它将被禁用
#                 'handlers': ['console', 'file'],
#             },
#         }
#     }
#  默认: {}
# c.Application.logging_config = {}

## 而不是启动应用程序，将配置转储到 stdout
#  默认: False
# c.Application.show_config = False

## 而不是启动应用程序，将配置转储到 stdout（作为 JSON）
#  默认: False
# c.Application.show_config_json = False

#------------------------------------------------------------------------------
# JupyterHub（Application）配置
#------------------------------------------------------------------------------
## 用于启动多用户 Jupyter 笔记本服务器的应用程序。

## 同时可以活动的服务器的最大数量。
#
#  设置这个可以限制用户可以消耗的总资源。
#
#  任何未完全停止的服务器都被视为活动服务器。从请求服务器的时间到完全停止的时间，它被认为是活动的。
#
#  如果这么多用户服务器是活动的，用户将无法启动新的服务器，直到关闭服务器。生成请求将被拒绝，并显示 429 错误，要求他们重试。
#
#  如果设置为 0，则不强制执行任何限制。
#  默认: 0
# c.JupyterHub.active_server_limit = 0

## 用于确定活动用户数量的持续时间（以秒为单位）。
#  默认: 1800
# c.JupyterHub.active_user_window = 1800

## 更新活动的分辨率（以秒为单位）
#
#  如果注册的活动比当前值更近 activity_resolution 秒，则将忽略新值。
#
#  这避免对 Hub 数据库进行太多写操作。
#  默认: 30
# c.JupyterHub.activity_resolution = 30

## 自 2.0.0 版本起已弃用
#
#          默认的管理员角色具有完整的权限，现在应该使用自定义 RBAC 作用域来创建受限制的管理员角色。
#          https://jupyterhub.readthedocs.io/en/stable/rbac/index.html
# 默认: False
c.JupyterHub.admin_access = True  # 管理员有权在各自计算机上以其他用户身份登录,以进行调试

## 自版本 0.7.2 以来已弃用，使用 Authenticator.admin_users 替代。
#  默认: set()
# c.JupyterHub.admin_users = set()

## 允许每个用户使用命名的单用户服务器
#  默认: False
# c.JupyterHub.allow_named_servers = False

## 对任何问题回答是（例如，确认覆盖）
#  默认: False
# c.JupyterHub.answer_yes = False

## 分页端点返回的记录的默认数量
#  默认: 50
# c.JupyterHub.api_page_default_limit = 50

## 一次可以返回的最大记录数
#  默认: 200
# c.JupyterHub.api_page_max_limit = 200

## 待弃用：考虑使用 services
#
#          要加载到数据库中的令牌:用户名字典。
#
#          允许提前为由外部托管的服务生成的 API 令牌，这些服务作为 JupyterHub 用户进行身份验证。
#
#          考虑使用 services 用于与 JupyterHub API 通信的一般服务。
#  默认: {}
# c.JupyterHub.api_tokens = {}

## 用于 Prometheus 指标的身份验证
#  默认: True
# c.JupyterHub.authenticate_prometheus = True

## 用于认证用户的类。
#
#  这应该是 :class:`jupyterhub.auth.Authenticator` 的子类
#
#  具有一个 :meth:`authenticate` 方法:
#
#  - 是一个协程（asyncio 或 tornado）
#  - 成功时返回用户名，失败时返回 None
#  - 接受两个参数：（handler，data），
#    其中 `handler` 是调用的 web.RequestHandler，
#    `data` 是登录页面的 POST 表单数据。
#
#  .. versionchanged:: 1.0
#      认证器可以通过入口点进行注册，
#      例如 `c.JupyterHub.authenticator_class = 'pam'`
#
#  目前安装的有：
#    - default: jupyterhub.auth.PAMAuthenticator
#    - dummy: jupyterhub.auth.DummyAuthenticator
#    - null: jupyterhub.auth.NullAuthenticator
#    - pam: jupyterhub.auth.PAMAuthenticator
#  默认: 'jupyterhub.auth.PAMAuthenticator'
# c.JupyterHub.authenticator_class = 'jupyterhub.auth.PAMAuthenticator'

## 整个应用程序的基本 URL。
#
#  将其添加到所有 JupyterHub URL 的开头。
#  使用 base_url 在现有网站中运行 JupyterHub。
#
#  .. deprecated: 0.9
#      使用 JupyterHub.bind_url
#  默认: '/'
# c.JupyterHub.base_url = '/'

## 整个 JupyterHub 应用程序的公共 URL。
#
#  这是代理将绑定的地址。
#  设置协议、IP、base_url
#  默认: 'http://:8000'
# c.JupyterHub.bind_url = 'http://:8000'

## 在 Hub 关闭时是否关闭代理。
#
#  如果要能够拆除 Hub 但保留代理运行，请禁用此选项。
#
#  仅在代理由 Hub 进程启动时有效。
#
#  如果这个和 cleanup_servers 都为 False，向 Hub 发送 SIGINT 将只关闭 Hub，保留其他所有内容运行。
#
#  Hub 应该能够从数据库状态中恢复。
#  默认: True
# c.JupyterHub.cleanup_proxy = True

## 在 Hub 关闭时是否关闭单用户服务器。
#
#  如果要能够拆除 Hub 但保留单用户服务器运行，请禁用此选项。
#
#  如果这个和 cleanup_proxy 都为 False，向 Hub 发送 SIGINT 将只关闭 Hub，保留其他所有内容运行。
#
#  Hub 应该能够从数据库状态中恢复。
#  默认: True
# c.JupyterHub.cleanup_servers = True

## 一次可以并发生成的用户的最大数量。
#
#  同时生成大量服务器可能会导致 Hub 或底层生成系统的性能问题。设置此限制以防止登录爆发尝试同时生成太多服务器。
#
#  这不限制总运行服务器的数量。有关此限制，请参阅 active_server_limit。
#
#  如果一次有超过这么多用户尝试生成，它们的请求将被拒绝，并显示 429 错误，要求它们重试。用户必须等待一些生成服务完成启动，然后才能启动自己的服务。
#
#  如果设置为 0，则不强制执行任何限制。
#  默认: 100
# c.JupyterHub.concurrent_spawn_limit = 100

## 要加载的配置文件
#  默认: 'jupyterhub_config.py'
# c.JupyterHub.config_file = 'jupyterhub_config.py'

## 已弃用：无效
#  默认: False
# c.JupyterHub.confirm_no_ssl = False

## 登录 cookie 有效的天数。
#          默认为两周。
#  默认: 14
# c.JupyterHub.cookie_max_age_days = 14

## 用于加密 cookie 的 cookie 密钥。
#
#          默认情况下从 JPY_COOKIE_SECRET 环境变量加载。
#
#          应该正好是 256 位（32 字节）。
#  默认: traitlets.Undefined
# c.JupyterHub.cookie_secret = traitlets.Undefined

## 存储 cookie 密钥的文件。
#  默认: 'jupyterhub_cookie_secret'
# c.JupyterHub.cookie_secret_file = 'jupyterhub_cookie_secret'

## 要定义的自定义作用域。
#
#          用于定义自定义角色时，
#          授予用户细粒度的权限
#
#          所有自定义作用域必须有描述，
#          并且必须以前缀 `custom:` 开头。
#
#          例如::
#
#              custom_scopes = {
#                  "custom:jupyter_server:read": {
#                      "description": "read-only access to a single-user server",
#                  },
#              }
#  默认: {}
# c.JupyterHub.custom_scopes = {}

## jupyterhub 数据文件的位置（例如 /usr/local/share/jupyterhub）
#  默认: '/usr/local/share/jupyterhub'
# c.JupyterHub.data_files_path = '/usr/local/share/jupyterhub'

## 包括传递给数据库连接的任何 kwargs。
#          有关详细信息，请参阅 sqlalchemy.create_engine。
#  默认: {}
# c.JupyterHub.db_kwargs = {}

## 数据库的 url。例如 `sqlite:///jupyterhub.sqlite`
#  默认: 'sqlite:///jupyterhub.sqlite'
# c.JupyterHub.db_url = 'sqlite:///jupyterhub.sqlite'

## 记录所有数据库事务。这会产生很多输出
#  默认: False
# c.JupyterHub.debug_db = False

## 已弃用，自版本 0.8 起使用 ConfigurableHTTPProxy.debug
#  默认: False
# c.JupyterHub.debug_proxy = False

## 如果启用了命名服务器，则指定在没有指定服务器时生成或打开的服务器的默认名称，例如由用户重定向。
#
#  注意：如果未启用命名服务器，则此选项不起作用，并且不会更改默认服务器的存在或行为，即默认服务器命名为 `''`（空字符串）的存在或行为。这仅影响在没有指定服务器时启动的命名服务器是哪个，例如通过链接到 `/hub/user-redirect/lab/tree/mynotebook.ipynb`。
#  默认: ''
# c.JupyterHub.default_server_name = ''

## 用户到达时的默认 URL（例如，当用户导向到“/”时）
#
#  默认情况下，将用户重定向到他们自己的服务器。
#
#  可以是 Unicode 字符串（例如 '/hub/home'）或基于处理程序对象的可调用项：
#
#  ::
#
#      def default_url_fn(handler):
#          user = handler.current_user
#          if user and user.admin:
#              return '/hub/admin'
#          return '/hub/home'
#
#      c.JupyterHub.default_url = default_url_fn
#  默认: traitlets.Undefined
# c.JupyterHub.default_url = traitlets.Undefined

## 字典权限:字典(文件)。指定用于某个权限的密钥、证书和/或
#          CA 文件。这对于希望使用 internal_ssl 的外部托管代理非常有用。
#
#          文件字典具有以下格式（您必须至少指定证书）：
#
#              {
#                  'key': '/path/to/key.key',
#                  'cert': '/path/to/cert.crt',
#                  'ca': '/path/to/ca.crt'
#              }
#
#          您可以覆盖的权威机构：'hub-ca'、'notebooks-ca'、
#          'proxy-api-ca'、'proxy-client-ca'和'services-ca'。
#
#          与 internal_ssl 一起使用
#  默认: {}
# c.JupyterHub.external_ssl_authorities = {}

## 已弃用。
#
#  如果需要注册其他 HTTP 端点，请改用 services。
#  默认: []
# c.JupyterHub.extra_handlers = []

## 已弃用：改用输出重定向，例如
#
#  jupyterhub &>> /var/log/jupyterhub.log
#  默认: ''
# c.JupyterHub.extra_log_file = ''

## 在 JupyterHub 记录器上设置的额外日志处理程序
#  默认: []
# c.JupyterHub.extra_log_handlers = []

## 用作主机的替代标头（例如，X-Forwarded-Host）
#          在确定请求是否跨源时
#
#          当 JupyterHub 在运行重新写入主机头的代理后面时，这可能很有用。
#  默认: ''
# c.JupyterHub.forwarded_host_header = ''

## 生成用于内部 ssl 的证书
#  默认: False
# c.JupyterHub.generate_certs = False

## 生成默认配置文件
#  默认: False
# c.JupyterHub.generate_config = False

## Hub 监听的 URL。这是内部通信的私有 URL。
#  通常与 hub_connect_url 一起设置。如果是 Unix 套接字，则 hub_connect_url **必须** 也设置。
#
#  例如：
#
#      "http://127.0.0.1:8081"
#      "unix+http://%2Fsrv%2Fjupyterhub%2Fjupyterhub.sock"
#
#  .. versionadded:: 0.9
#  默认: ''
# c.JupyterHub.hub_bind_url = ''

## 代理和 spawners 用于连接到 Hub 的 IP 或主机名。
#
#  在绑定地址 (`hub_ip`) 为 0.0.0.0、:: 或与连接地址不同时使用。
#
#  默认: 当 `hub_ip` 为 0.0.0.0 或 :: 时，使用 `socket.gethostname()`，
#  否则使用 `hub_ip`。
#
#  注意: 一些 spawner 或代理实现可能不支持主机名。查看您的 spawner 或代理文档，看看它们是否有额外的要求。
#
#  .. versionadded:: 0.8
#  默认: ''
# c.JupyterHub.hub_connect_ip = ''

## 已弃用
#
#  使用 hub_connect_url
#
#  .. versionadded:: 0.8
#
#  .. deprecated:: 0.9
#      使用 hub_connect_url
#  默认: 0
# c.JupyterHub.hub_connect_port = 0

## 用于连接到 Hub 的 URL。Spawners、services 和代理将使用
#  此 URL 与 Hub 进行通信。
#
#  仅在默认的 hub URL 不可连接时需要指定（例如使用 unix+http:// 绑定 URL）。
#
#  .. seealso::
#      JupyterHub.hub_connect_ip
#      JupyterHub.hub_bind_url
#
#  .. versionadded:: 0.9
#  默认: ''
# c.JupyterHub.hub_connect_url = ''

## Hub 进程绑定的 IP 地址。
#
#  默认情况下，Hub 只监听本地主机。此地址必须从代理和用户服务器访问。
#  如果代理或用户服务器在容器中或在不同的主机上，您可能需要将其设置为公共 IP 或 '' 以覆盖所有接口。
#
#  请参阅 `hub_connect_ip` 以了解绑定和连接地址应有所不同的情况，
#  或参阅 `hub_bind_url` 以设置完整的绑定 URL。
#  默认: '127.0.0.1'
c.JupyterHub.hub_ip = '0.0.0.0'

## Hub 进程的内部端口。
#
#  这是 Hub 本身的内部端口。不应直接访问此端口。
#  有关访问 jupyterhub 时使用的公共端口，请参见 JupyterHub.port。
#  除了端口冲突的情况下，很少需要设置此端口。
#
#  也请参阅 `hub_ip` 获取 IP 和 `hub_bind_url` 以设置完整的绑定 URL。
#  默认: 8081
c.JupyterHub.hub_port = 8081

## Hub 自身的路由前缀。
#
#  覆盖以仅将一部分流量发送到 Hub。默认是将 Hub 用作所有请求的默认路由。
#
#  这对于正常的 JupyterHub 操作是必要的，因为 Hub 必须接收对例如 `/user/:name` 的请求，
#  当用户的服务器未运行时。
#
#  但是，一些只使用 JupyterHub API 的部署可能希望自己处理这些事件，
#  在这种情况下，他们可以向代理注册自己的默认目标，
#  并设置例如 `hub_routespec = /hub/` 以仅提供 Hub 自己的页面，
#  或者甚至 `/hub/api/` 以进行仅 API 操作。
#
#  注意：hub_routespec 必须包含 base_url（如果有）。
#
#  .. versionadded:: 1.4
#  默认: '/'
# c.JupyterHub.hub_routespec = '/'

## 在此秒数后触发隐式生成。
#
#  当用户访问尚未运行的服务器的 URL 时，会显示一个页面，指示所请求的服务器未运行，
#  并显示一个按钮以生成服务器。
#
#  将其设置为正值将在此秒数后重定向用户，从而自动为用户点击此按钮，
#  自动开始生成过程。
#
#  警告：这可能导致在共享实际服务器的访问 URL 时出现错误和令人惊讶的行为，
#  因为可能会启动错误的服务器。
#  默认: 0
# c.JupyterHub.implicit_spawn_seconds = 0

## 等待生成器初始化的超时时间（以秒为单位）
#
#  如果在 Hub 启动时有许多生成器处于活动状态，检查生成器是否健康可能需要很长时间。
#
#  如果检查时间超过此超时时间，init_spawner 将被留在后台完成，
#  并允许 http 服务器启动。
#
#  超时为 -1 表示永远等待，这可能导致 Hub 启动缓慢，
#  但确保 Hub 在开始响应请求之前完全一致。
#  这与 jupyterhub 1.0 的行为相匹配。
#
#  .. versionadded: 1.1.0
#  默认: 10
# c.JupyterHub.init_spawners_timeout = 10

## 存储由 JupyterHub 自动创建的证书的位置。
#
#  与 internal_ssl 一起使用
#  默认: 'internal-ssl'
# c.JupyterHub.internal_certs_location = 'internal-ssl'

## 为所有内部通信启用 SSL
#
#  这启用了所有 JupyterHub 组件之间的端到端加密。
#  JupyterHub 将自动创建必要的证书颁发机构，并在创建时签署笔记本证书。
#  默认: False
# c.JupyterHub.internal_ssl = False

## 整个 JupyterHub 应用程序（特指代理）的公共 IP。
#
#  这是代理将侦听的地址。默认是在所有接口上侦听。
#  这是用户应该访问 JupyterHub 的唯一地址。
#
#  .. 废弃: 0.9
#      使用 JupyterHub.bind_url
#  默认: ''
# 设置 JupyterHub 服务监听的地址
c.JupyterHub.ip = '0.0.0.0'

## 提供传递给 Jinja 环境的额外参数。
#  默认: {}
# c.JupyterHub.jinja_environment_options = {}

## 更新上次活动时间戳的间隔（以秒为单位）。
#  默认: 300
# c.JupyterHub.last_activity_interval = 300

## 在启动时加载的组的字典 `{'group': {'users':['usernames'], 'properties': {}}`。
#
#  示例::
#
#      c.JupyterHub.load_groups = {
#          'groupname': {
#              'users': ['usernames'],
#              'properties': {'key': 'value'},
#          },
#      }
#
#  这严格地*添加*组和用户到组中。如果定义了属性，
#  则替换所有现有属性。
#
#  加载一组组，然后使用不同的集合再次启动 JupyterHub 将不会从先前的启动中删除用户或组。
#  必须通过 API 完成。
#
#  .. versionchanged:: 3.2
#    将组的格式从用户名列表更改为字典
#  默认: {}
# c.JupyterHub.load_groups = {}

## 在启动时加载的预定义角色字典列表。
#
#          例如::
#
#              load_roles = [
#                              {
#                                  'name': 'teacher',
#                                  'description': 'Access to users' information and group membership',
#                                  'scopes': ['users', 'groups'],
#                                  'users': ['cyclops', 'gandalf'],
#                                  'services': [],
#                                  'groups': []
#                              }
#                          ]
#
#          除了 'name' 之外的所有键都是可选的。
#          请在 JupyterHub REST API 文档中查看所有可用的作用域。
#
#          默认角色在 roles.py 中定义。
#  默认: []
# c.JupyterHub.load_roles = []

## 用于 %(asctime)s 的日志格式化程序使用的日期格式
#  另请参阅：Application.log_datefmt
# c.JupyterHub.log_datefmt = '%Y-%m-%d %H:%M:%S'

## 日志格式模板
#  另请参阅：Application.log_format
# c.JupyterHub.log_format = '[%(name)s]%(highlevel)s %(message)s'

## 按值或名称设置日志级别。
#  另请参阅：Application.log_level
# c.JupyterHub.log_level = 30

## 
#  另请参阅：Application.logging_config
# c.JupyterHub.logging_config = {}

## 指定路径以覆盖横幅中的 Jupyter 徽标的徽标图像。
#  默认: ''
# c.JupyterHub.logo_file = ''

## 用户在同一时间可以创建的最大并发命名服务器数。
#
#  设置这个可以限制用户可以消耗的总资源。
#
#  如果设置为 0，则不执行任何限制。
#
#  可以是整数，也可以是基于处理程序对象的可调用/可等待对象：
#
#  ::
#
#      def named_server_limit_per_user_fn(handler):
#          user = handler.current_user
#          if user and user.admin:
#              return 0
#          return 5
#
#      c.JupyterHub.named_server_limit_per_user = named_server_limit_per_user_fn
#  默认: 0
# c.JupyterHub.named_server_limit_per_user = 0

## OAuth 访问令牌的到期时间（以秒为单位）。
#
#          默认情况下，它将在存储它们的 cookie 到期后到期，
#          根据 `cookie_max_age_days` 配置。
#
#          这些是在访问单用户服务器或服务时存储在 cookie 中的令牌。
#          当它们到期时，您必须重新验证 Hub，
#          即使您的 Hub 认证仍然有效。
#          如果您的 Hub 认证有效，
#          登录可能是一个透明的重定向，就像刷新页面一样。
#
#          这不影响通常不会过期的 JupyterHub API 令牌。
#          仅影响在 oauth 流中发出的令牌
#          访问服务和单用户服务器。
#
#          .. versionadded:: 1.4
#              以前无法配置 OAuth 令牌过期。
#          .. versionchanged:: 1.4
#              默认现在使用 cookie_max_age_days，
#              以便 oauth 令牌通常存储在 cookie 中，
#              当存储它们的 cookie 到期时过期。
#              以前是一个小时。
#  默认: 0
# c.JupyterHub.oauth_token_expires_in = 0

## 要写入 PID 的文件
#          对于将 JupyterHub 变为守护进程很有用。
#  默认: ''
# c.JupyterHub.pid_file = ''

## 代理的公共端口。
#
#          这是代理将侦听的端口。
#          这是用户应通过的唯一端口
#          访问 JupyterHub。
#
#          .. deprecated: 0.9
#              使用 JupyterHub.bind_url
#  默认: 8000
c.JupyterHub.port = 8000

## 已弃用自版本 0.8 起: 使用 ConfigurableHTTPProxy.api_url
#  默认: ''
# c.JupyterHub.proxy_api_ip = ''

## 已弃用自版本 0.8 起: 使用 ConfigurableHTTPProxy.api_url
#  默认: 0
# c.JupyterHub.proxy_api_port = 0

## 已弃用自版本 0.8 起: 使用 ConfigurableHTTPProxy.auth_token
#  默认: ''
# c.JupyterHub.proxy_auth_token = ''

## 已弃用自版本 0.8 起: 使用 ConfigurableHTTPProxy.check_running_interval
#  默认: 5
# c.JupyterHub.proxy_check_interval = 5

## 用于配置 JupyterHub 代理的类。
#
#          应该是 :class:`jupyterhub.proxy.Proxy` 的子类。
#
#          .. versionchanged:: 1.0
#              代理可以通过入口点注册，例如 `c.JupyterHub.proxy_class = 'traefik'`
#
#  当前已安装的：
#    - configurable-http-proxy: jupyterhub.proxy.ConfigurableHTTPProxy
#    - 默认: jupyterhub.proxy.ConfigurableHTTPProxy
#  默认: 'jupyterhub.proxy.ConfigurableHTTPProxy'
# c.JupyterHub.proxy_class = 'jupyterhub.proxy.ConfigurableHTTPProxy'

## 已弃用自版本 0.8 起。使用 ConfigurableHTTPProxy.command
#  默认: []
# c.JupyterHub.proxy_cmd = []

## 在重新启动时重新创建 JupyterHub 中使用的所有证书。
#
#          注意：启用此功能需要重新启动所有笔记本服务器。
#
#          与 internal_ssl 一起使用
#  默认: False
# c.JupyterHub.recreate_internal_certs = False

## 将用户重定向到服务器（如果正在运行），而不是控制面板。
#  默认: True
# c.JupyterHub.redirect_to_server = True

## 清除并重置数据库。
#  默认: False
# c.JupyterHub.reset_db = False

## 检查服务与 Web 端点的连接性的间隔（以秒为单位）。
#  默认: 60
# c.JupyterHub.service_check_interval = 60

## 要加载到数据库中的令牌:服务名称的字典。
#
#          允许提前为由外部管理的服务生成的 API 令牌。
#  默认: {}
# c.JupyterHub.service_tokens = {}

## 服务规范字典的列表。
#
#  一个服务
#
#  例如：
#
#  services = [
#      {
#          'name': 'cull_idle',
#          'command': ['/path/to/cull_idle_servers.py'],
#      },
#      {
#          'name': 'formgrader',
#          'url': 'http://127.0.0.1:1234',
#          'api_token': 'super-secret',
#          'environment':
#      },
#      {
#         'name': 'idle-culler',
#         'command': ['python3', '-m', 'jupyterhub_idle_culler', '--timeout=3600'],  # 可能需要 pip install jupyterhub-ilde-culler
#         'admin':True  # 1.5.0 需要服务管理员权限，去kill 部分闲置的进程notebook, 2.0版本已经改了，可以只赋给 idel-culler 部分特定权限，roles
#      }
#  ]
#  默认: []
# c.JupyterHub.services = []

## 而不是启动应用程序，将配置转储到标准输出
#  另请参阅: Application.show_config
# c.JupyterHub.show_config = False

## 而不是启动应用程序，将配置以 JSON 格式转储到标准输出
#  另请参阅: Application.show_config_json
# c.JupyterHub.show_config_json = False

## 在注销时关闭所有用户服务器
#  默认: False
# c.JupyterHub.shutdown_on_logout = False

## 用于生成单用户服务器的类。
#
#          应该是 :class:`jupyterhub.spawner.Spawner` 的子类。
#
#          .. versionchanged:: 1.0
#              spawners 可以通过入口点进行注册，
#              例如 `c.JupyterHub.spawner_class = 'localprocess'`
#
#  当前已安装的:
#    - default: jupyterhub.spawner.LocalProcessSpawner
#    - localprocess: jupyterhub.spawner.LocalProcessSpawner
#    - simple: jupyterhub.spawner.SimpleLocalProcessSpawner
#  默认: 'jupyterhub.spawner.LocalProcessSpawner'
# c.JupyterHub.spawner_class = 'jupyterhub.spawner.LocalProcessSpawner'

## 用于代理的公共接口的 SSL 证书文件的路径
#
#          设置此项时，您还应设置 ssl_key
#  默认: ''
# c.JupyterHub.ssl_cert = ''

## 用于代理的公共接口的 SSL 密钥文件的路径
#
#          设置此项时，您还应设置 ssl_cert
#  默认: ''
# c.JupyterHub.ssl_key = ''

## 用于发送统计数据到的 statsd 主机。空字符串（默认值）表示禁用发送统计数据。
#  默认: ''
# c.JupyterHub.statsd_host = ''

## 关于 hub 的统计数据发送到的端口
#  默认: 8125
# c.JupyterHub.statsd_port = 8125

## 由 jupyterhub 发送到 statsd 的所有统计数据的前缀
#  默认: 'jupyterhub'
# c.JupyterHub.statsd_prefix = 'jupyterhub'

## 在此主机的子域上运行单用户服务器。
#
#          这应该是完整的 `https://hub.domain.tld[:port]`。
#
#          为单用户服务器提供了额外的跨站点保护。
#
#          需要 `<username>.hub.domain.tld` 解析到与 `hub.domain.tld` 相同的主机。
#
#          通常，使用通配符 DNS 可以更容易地实现这一点。
#
#          当使用 SSL（即始终）时，这还需要通配符 SSL 证书。
#  默认: ''
# c.JupyterHub.subdomain_host = ''

## 在使用默认模板之前搜索 jinja 模板的路径。
#  默认: []
# c.JupyterHub.template_paths = []

## 传递到 jinja 模板中的额外变量
#  默认: {}
# c.JupyterHub.template_vars = {}

## 传递给 tornado 应用程序的额外设置覆盖。
#  默认: {}
# c.JupyterHub.tornado_settings = {}

## 信任用户提供的令牌（通过 JupyterHub.service_tokens）具有良好的熵。
#
#          如果您没有通过配置文件插入其他令牌，
#          此标志不起作用。
#
#          在 JupyterHub 0.8 中，内部生成的令牌不会
#          经过附加哈希处理，因为哈希处理成本高昂
#          而且不能增加已经具有良好 UUID 熵的熵。
#
#          另一方面，不会默认信任用户提供的令牌具有良好的熵，
#          并且会通过多轮哈希处理来拉伸密钥的熵
#          （即用户提供的令牌被视为密码而不是随机密钥）。
#          检查这些密钥的成本更高。
#
#          如果您插入的令牌是由良好质量的机制生成的，
#          例如 `openssl rand -hex 32`，则可以将此标志设置为 True，
#          以减少检查身份验证令牌的成本。
#  默认: False
# c.JupyterHub.trust_user_provided_tokens = False

## 包含在主题替代名称中的名称。
#
#          这些名称将用于服务器名称验证。如果 JupyterHub 在反向代理后运行，
#          或者使用 ssl 的服务在不同的主机上，
#          这很有用。
#
#          使用 internal_ssl
#  默认: []
# c.JupyterHub.trusted_alt_names = []

## 下游代理 IP 地址的信任。
#
#          这设置了信任的 IP 地址列表，在处理 `X-Forwarded-For` 标头时将被跳过。例如，如果外部代理用于 TLS 终结，则应将其 IP 地址添加到此列表中，以确保在日志中记录正确的客户端 IP 地址，而不是代理服务器的 IP 地址。
#  默认: []
# c.JupyterHub.trusted_downstream_ips = []

## 启动时自动升级数据库。
#
#          仅在数据库定期备份时才安全。
#          仅 SQLite 数据库将自动备份到本地文件。
#  默认: False
# c.JupyterHub.upgrade_db = False

## 请求针对非运行中服务器时返回 503 而不是 424。
#
#  在 JupyterHub 2.0 之前，当任何请求针对当前未运行的用户服务器时，我们返回 503。默认情况下，JupyterHub 2.0 将返回 424 - 这使运营指标仪表板更有用。
#
#  JupyterLab < 3.2 期望 503，以了解用户服务器是否不再运行，并提示用户启动其服务器。设置此配置为 true 以保留旧行为，以便 JupyterLab < 3.2 可以继续在用户服务器停止时显示适当的 UI。
#
#  此选项将在未来的版本中删除。
#  默认: False
# c.JupyterHub.use_legacy_stopped_server_status_code = False

## 用于影响 /user-redirect/ 行为的可调用项
#
#  接收 4 个参数：1. path - 在 /user-redirect/ 之后提供的 URL 路径 2. request - 代表当前请求的 Tornado HTTPServerRequest。 3. user - 当前经过身份验证的用户。 4. base_url - 当前 hub 的 base_url，用于相对重定向
#
#  它应返回要重定向到的新 URL，或者返回 None 以保留当前行为。
#  默认: None
# c.JupyterHub.user_redirect_hook = None

#------------------------------------------------------------------------------
# Spawner(LoggingConfigurable) configuration
#------------------------------------------------------------------------------
## 单用户笔记本服务器生成器的基类。
#
#      子类化它，并覆盖以下方法：
#
#      - load_state
#      - get_state
#      - start
#      - stop
#      - poll
#
#      由于 JupyterHub 支持多个用户，为每个用户创建 Spawner 子类的实例。如果有 20 个 JupyterHub 用户，则将有 20 个子类的实例。

## 传递给单用户服务器的额外参数。
#  有些 spawners 允许在这里使用 shell 风格的扩展，允许使用环境变量。大多数 spawner 不支持这个功能。
#  默认值: []
c.Spawner.args = ['--allow-root']  # 单用户服务器必须设置,否则可能会无法启动

## 在单用户服务器初始化后但在启动之前，将 `auth_state` 传递给 spawner 的可选钩子函数。
#  `auth_state` 字典可以由认证器的 `.authenticate()` 方法设置。此钩子函数使您能够将部分或全部信息传递给您的 spawner。
#  默认值: None
# c.Spawner.auth_state_hook = None

## 用于启动单用户服务器的命令。
#  提供一个字符串或包含启动脚本命令路径的列表。除了此路径之外的其他额外参数应通过 `args` 提供。
#  如果要在与 JupyterHub 本身不同的 python 环境中启动单用户服务器（使用 virtualenv/conda），通常会设置这个参数。
#  一些 spawners 允许在这里使用 shell 风格的扩展，允许使用环境变量。大多数不支持此功能。
#  默认值: ['jupyterhub-singleuser']
# c.Spawner.cmd = ['jupyterhub-singleuser']

## 在关闭 JupyterHub 之前允许的最大连续失败次数。
#  这有助于 JupyterHub 从某些问题中恢复，这些问题阻止在自动重新启动的上下文中启动（例如 systemd、docker、kubernetes）。
#  0 表示没有限制，连续失败将不会被跟踪。
#  默认值: 0
# c.Spawner.consecutive_failure_limit = 0

## 单用户笔记本服务器保证具有可用的最小 CPU 核心数。
#  如果此值设置为 0.5，则允许使用 50% 的一个 CPU。如果此值设置为 2，则允许使用最多 2 个 CPU。
#  **这是一个配置设置。您的 spawner 必须实现对此限制的支持。** 默认的 spawner `LocalProcessSpawner` 不实现此支持。
#  默认值: None
# c.Spawner.cpu_guarantee = None

## 单用户笔记本服务器被允许使用的最大 CPU 核心数。
#  如果此值设置为 0.5，则允许使用 50% 的一个 CPU。如果此值设置为 2，则允许使用最多 2 个 CPU。
#  单用户笔记本服务器永远不会被内核调度使用超过这个数目的 CPU 核心。不能保证它可以访问这么多的 CPU 核心。
#  **这是一个配置设置。您的 spawner 必须实现对此限制的支持。** 默认的 spawner `LocalProcessSpawner` 不实现此支持。
#  默认值: None
# c.Spawner.cpu_limit = None

## 启用单用户服务器的调试日志记录。
#  默认值: False
# c.Spawner.debug = False

## 单用户服务器应该启动的 URL。
#  `{username}` 将扩展为用户的用户名。
#  示例用法：
#  - 您可以将 `notebook_dir` 设置为 `/`，将 `default_url` 设置为 `/tree/home/{username}`，以允许人们从其笔记本服务器导航整个文件系统，但仍然在其主目录中启动。
#  - 如果 `default_url` 指向笔记本而不是目录，则从 `/tree` 更改为 `/notebooks`。
#  - 您可以将其设置为 `/lab`，以默认情况下启动 JupyterLab，而不是 Jupyter Notebook。
#  默认值: ''
# c.Spawner.default_url = ''

## 禁用单用户服务器的用户配置。
#  在启动用户的单用户服务器时，将忽略用户 $HOME 目录中找到的任何配置文件。
#  注意：如果用户修改其 Python 环境（例如，当他们拥有自己的 conda 环境/虚拟环境/容器时），用户可能会绕过此设置。
#  默认值: False
# c.Spawner.disable_user_config = False

## 单用户服务器从 JupyterHub 进程继承的环境变量列表。
#  此列表用于确保 JupyterHub 进程环境中的敏感信息（例如 `CONFIGPROXY_AUTH_TOKEN`）不会传递给单用户服务器的进程。
#  默认值: ['PATH', 'PYTHONPATH', 'CONDA_ROOT', 'CONDA_DEFAULT_ENV', 'VIRTUAL_ENV', 'LANG', 'LC_ALL', 'JUPYTERHUB_SINGLEUSER_APP']
# c.Spawner.env_keep = ['PATH', 'PYTHONPATH', 'CONDA_ROOT', 'CONDA_DEFAULT_ENV', 'VIRTUAL_ENV', 'LANG', 'LC_ALL', 'JUPYTERHUB_SINGLEUSER_APP']

## 单用户服务器进程的额外环境变量。
#  最终进入单用户服务器进程的环境变量来自三个来源：
#    - 这个 `environment` 可配置项
#    - 列在 `env_keep` 中的 JupyterHub 进程的环境变量
#    - 用于在单用户笔记本和 hub 之间建立联系的变量（例如 JUPYTERHUB_API_TOKEN）
#
#  `environment` 可配置项应该由 JupyterHub 管理员设置，以添加特定于安装的环境变量。它是一个字典，其中键是环境变量的名称，值可以是字符串或可调用对象。
#  如果是可调用对象，它将被调用一次（传递 spawner 实例作为参数），并且应该相对快速地返回一个字符串（请勿进行阻塞操作！）。
#
#  请注意，不保证在升级后调用方的接口完全相同，因此如果使用可调用对象，请确保在升级后它仍然能够正常工作！
#
#  .. versionchanged:: 1.2
#      此配置中的环境变量具有最高优先级，
#      允许覆盖 'default' 环境变量，
#      例如 JUPYTERHUB_API_URL。
#  默认值: {}
# c.Spawner.environment = {}

## 在放弃生成的 HTTP 服务器之前等待的超时时间（以秒为单位）。
#  一旦成功生成服务器，我们等待的时间，然后假设服务器无法接受连接。
#  默认值: 30
# c.Spawner.http_timeout = 30

## 单用户服务器应连接到 Hub 的 URL。
#  如果您的 JupyterHub 配置中设置的 Hub URL 无法从生成的笔记本访问，您可以通过此配置设置不同的 URL。
#  如果不需要更改 URL，则为 None。
#  默认值: None
# c.Spawner.hub_connect_url = None

## 单用户服务器应监听的 IP 地址（或主机名）。
#  通常是 '127.0.0.1'（默认）或 '0.0.0.0'。
#  JupyterHub 代理实现应能够向此接口发送数据包。
#  在远程启动或容器中启动的子类应该覆盖默认值为 '0.0.0.0'。
#
#  .. versionchanged:: 2.0
#      默认值更改为 '127.0.0.1'，从 ''。
#      在大多数情况下，这不会导致行为更改，
#      因为 '' 被解释为 '未指定'，
#      它使用子进程自己的默认值，通常是 '127.0.0.1'。
#  默认值: '127.0.0.1'
# c.Spawner.ip = '127.0.0.1'

## 单用户笔记本服务器保证拥有的最小字节数。
#  允许以下后缀：
#    - K -> 千字节
#    - M -> 兆字节
#    - G -> 千兆字节
#    - T -> 太字节
#
#  **这是一个配置设置。您的 spawner 必须实现对此限制的支持。** 默认的 spawner，`LocalProcessSpawner`，**不** 实现此支持。自定义 spawner **必须** 添加对此设置的支持以进行执行。
#  默认值: None
# c.Spawner.mem_guarantee = None

## 单用户笔记本服务器被允许使用的最大字节数。
#  允许以下后缀：
#    - K -> 千字节
#    - M -> 兆字节
#    - G -> 千兆字节
#    - T -> 太字节
#
#  如果单用户服务器尝试分配的内存超过此值，它将失败。不能保证单用户笔记本服务器能够分配这么多内存 - 只是不能分配超过这么多。
#
#  **这是一个配置设置。您的 spawner 必须实现对此限制的支持。** 默认的 spawner，`LocalProcessSpawner`，**不** 实现此支持。自定义 spawner **必须** 添加对此设置的支持以进行执行。
#  默认值: None
# c.Spawner.mem_limit = None

## 单用户服务器的笔记本目录的路径。
#
#  启动笔记本界面时，用户会看到此目录的文件列表。
#  当前的界面不容易浏览此目录树中的子目录以外的文件。
#
#  `~` 将会扩展为用户的主目录，{username} 将被替换为用户名。
#
#  请注意，这并*不*防止用户访问此路径之外的文件！他们可以通过许多其他方式进行操作。
#  默认: ''
# c.Spawner.notebook_dir = ''

## 此服务器的 OAuth 客户端发放的 OAuth 令牌的允许范围。
#
#          这设置了单用户服务器的 OAuth 客户端（即与服务器进行身份验证后存储在浏览器中的令牌）发放的 OAuth 令牌的最大和默认范围，
#          定义服务器可以代表登录用户执行的操作。
#
#          默认是一个空列表，表示最小权限以识别用户，不能代表他们执行任何操作。
#
#          如果可调用，将使用 Spawner 作为单一参数调用它。
#          可调用对象可能是异步的。
#  默认: traitlets.Undefined
# c.Spawner.oauth_client_allowed_scopes = traitlets.Undefined

## OAuth 令牌的允许角色。
#
#          在 3.0 版中已弃用：请使用 oauth_client_allowed_scopes
#
#          这设置了单用户服务器的 OAuth 客户端（即与服务器进行身份验证后存储在浏览器中的令牌）发放的 OAuth 令牌的最大和默认角色，
#          定义服务器可以代表登录用户执行的操作。
#
#          默认是一个空列表，表示最小权限以识别用户，不能代表他们执行任何操作。
#  默认: traitlets.Undefined
# c.Spawner.oauth_roles = traitlets.Undefined

## 用户在启动服务器时可以指定的选项的 HTML 表单。
#
#  已提供周围的 `<form>` 元素和提交按钮。
#
#  例如：
#
#  .. code:: html
#
#      设置您的密钥：
#      <input name="key" val="default_key"></input>
#      <br>
#      选择一个字母：
#      <select name="letter" multiple="true">
#        <option value="A">字母 A</option>
#        <option value="B">字母 B</option>
#      </select>
#
#  此表单提交的数据将传递到 spawner 中的 `self.user_options`
#
#  而不是一个表单片段字符串，这也可以是一个可调用对象，它以当前 spawner 实例作为参数之一，并返回一个字符串。
#  如果它返回一个 future，则将异步调用可调用对象。请注意，跨版本使用 spawner 类的接口并不稳定，
#  因此使用此功能可能导致 JupyterHub 升级失败。
#  默认: traitlets.Undefined
# c.Spawner.options_form = traitlets.Undefined

## 解释 HTTP 表单数据
#
#  表单数据将始终作为字符串列表的字典到达。重写此函数以了解单值、数字等。
#
#  这应该将表单数据强制转换为 self.user_options 期望的结构，self.user_options 必须是字典，并且应该是可 JSON 序列化的，
#  尽管它可以包含字节以及标准的 JSON 数据类型。
#
#  此方法不应具有任何副作用。任何 `user_options` 的处理都应在 `.start()` 中进行，
#  以确保跨 API 和表单提交页面生成的服务器生成一致的行为。
#
#  实例将在通过此函数传递给 self.user_options 之前接收此数据，在 `Spawner.start` 之前。
#
#  .. versionchanged:: 1.0
#      user_options 在 JupyterHub 数据库中进行持久化，以便在没有给定选项的情况下重用。
#      user_options 将作为此持久化的一部分序列化为 JSON
#      （在存在上传文件数据的情况下还支持字节），
#      如果 user_options 被重复使用，则任何非字节非可 JSON 化值都将替换为 None。
#  默认: traitlets.Undefined
# c.Spawner.options_from_form = traitlets.Undefined

## 以秒为单位的轮询 Spawner 获取单用户服务器状态的间隔。
#
#  在每个轮询间隔，将调用每个 Spawner 的 `.poll` 方法，该方法检查单用户服务器是否仍在运行。
#  如果它没有运行，那么 JupyterHub 将相应地修改自己的状态，并从可配置的代理中删除适当的路由。
#  默认: 30
# c.Spawner.poll_interval = 30

## 单用户服务器监听的端口。
#
#  默认为 `0`，每次使用随机分配的端口号。
#
#  如果设置为非零值，所有 Spawners 将使用相同的端口，仅在每个服务器位于不同地址时才有意义，例如在容器中。
#
#  在 0.7 版中新增。
#  默认: 0
# c.Spawner.port = 0

## 一个可选的钩子函数，您可以实现以在 spawner 停止后执行一些工作。
#
#  这可以独立于任何具体的 spawner 实现进行设置。
#  默认: None
# c.Spawner.post_stop_hook = None

## 一个可选的钩子函数，您可以实现以在 spawner 启动之前执行一些引导工作。
#  例如，为用户创建一个目录或加载初始内容。
#
#  这可以独立于任何具体的 spawner 实现进行设置。
#
#  这可能是一个协程。
#
#  示例::
#
#      from subprocess import check_call
#      def my_hook(spawner):
#          username = spawner.user.name
#          check_call(['./examples/bootstrap-script/bootstrap.sh', username])
#
#      c.Spawner.pre_spawn_hook = my_hook
#  默认: None
# c.Spawner.pre_spawn_hook = None

## 用于 $JUPYTERHUB_API_TOKEN 请求的作用域列表
#
#          如果未指定，则将使用 `server` 角色中的作用域（与 4.0 之前的版本保持不变）。
#
#          如果是可调用的，将以 Spawner 实例作为唯一参数调用它
#          （JupyterHub 用户作为 spawner.user 可用）。
#
#          JUPYTERHUB_API_TOKEN 将被分配用户拥有的这些作用域的 _子集_
#          （与 oauth_client_allowed_scopes 相同）。
#
#          .. versionadded:: 4.0
#  默认: traitlets.Undefined
# c.Spawner.server_token_scopes = traitlets.Undefined

## SSL 替代名称列表
#
#          如果所有 spawner 应该具有相同的值，可以在配置中设置，
#          或由知道其名称的 Spawner 在运行时设置。
#  默认: []
# c.Spawner.ssl_alt_names = []

## 是否在 alt 名称中包含 `DNS:localhost`，`IP:127.0.0.1`
#  默认: True
# c.Spawner.ssl_alt_names_include_local = True

## 在放弃启动单用户服务器之前的超时时间（以秒为单位）。
#
#  这是启动返回之前的超时时间，而不是服务器响应的超时时间。
#  spawner.start 的调用方将假定如果它花费的时间超过这个时间，启动就失败了。
#  启动应在服务器进程启动并知道其位置时返回。
#  默认: 60
# c.Spawner.start_timeout = 60

#------------------------------------------------------------------------------
# Authenticator(LoggingConfigurable) configuration
#------------------------------------------------------------------------------
## Base class for implementing an authentication provider for JupyterHub

## 具有对该 JupyterHub 的管理员权限的用户集。
# 
# 注意：从 JupyterHub 2.0 开始，不再需要完整的管理员权限，可以通过角色来管理更精确的权限。
# 
# 管理员用户具有额外的特权：
#   - 使用管理员面板查看登录用户列表
#   - 在某些身份验证器中添加/删除用户
#   - 重新启动/停止 hub
#   - 启动/停止用户的单用户服务器
#   - 可以访问每个单独用户的单用户服务器（如果配置）
# 
# 管理员访问权限应该与 root 访问权限相同对待。
# 
# 默认为空集合，这样没有用户具有管理员访问权限。
# 默认: set()
c.Authenticator.admin_users = {'root','zwzw'}

## 允许登录的用户名集。
# 
# 与支持的身份验证器一起使用，以限制可以登录的用户。
# 这是一个附加列表，进一步限制用户，超出身份验证器已经设置的任何限制。
# 此列表中的任何用户在 hub 启动时被授予 'user' 角色。
# 
# 如果为空，则不执行任何附加限制。
# 
# .. versionchanged:: 1.2
#     `Authenticator.whitelist` 重命名为 `allowed_users`
# 默认: set()
# c.Authenticator.allowed_users = set()

## 认证信息刷新之前的最大年龄（以秒为单位）
#          强制刷新用户认证信息。
#
#          刷新认证信息允许请求/重新验证认证
#  令牌等。
#
#          有关用户认证信息刷新时发生的情况的详细信息，请参见 :meth:`.refresh_user`
#          （默认情况下什么也不会发生）。
#  默认: 300
# c.Authenticator.auth_refresh_age = 300

## 自动开始登录过程
#
#          而不是从 `/hub/login` 处开始带有 "Login with..." 链接的登录。
#
#          要使其工作，`.login_url()` 必须提供除默认的 `/hub/login` 之外的 URL，
#          例如，一个 oauth 处理程序或另一个自动登录处理程序，
#          注册到 `.get_handlers()`。
#
#          .. versionadded:: 0.8
#  默认: False
# c.Authenticator.auto_login = False

## 自动开始 OAuth2 授权请求的登录过程
#
#  当另一个应用程序将 JupyterHub 用作 OAuth2 提供程序时，它会发送
#  用户到 `/hub/api/oauth2/authorize`。如果用户尚未登录，并且
#  未设置 auto_login，则用户将被转到 hub 的主页，而没有
#  任何关于接下来该怎么做的上下文。
#
#  将此设置为 true 将仅在 `/hub/api/oauth2/authorize` 端点上
#  自动将用户重定向到登录页面，如果他们尚未登录。
#
#  .. versionadded:: 1.5
#  默认: False
# c.Authenticator.auto_login_oauth2_authorize = False

## 不允许登录的用户名集合。
#
#  与支持的身份验证器一起使用，以限制哪些用户不能登录。
#  这是一个附加的阻止列表，进一步限制用户，超出身份验证器已经实施的任何限制。
#
#  如果为空，则不执行任何附加限制。
#
#  .. versionadded: 0.9
#
#  .. versionchanged:: 1.2
#      `Authenticator.blacklist` 重命名为 `blocked_users`
#  默认: set()
# c.Authenticator.blocked_users = set()

## 删除数据库中未通过验证的任何用户
#
#          当 JupyterHub 启动时，将对数据库中的每个用户调用 `.add_user`
#          来验证所有用户是否仍然有效。
#
#          如果 `delete_invalid_users` 为 True，
#          任何未通过验证的用户将从数据库中删除。
#          如果用户可能从外部系统中删除，例如本地用户帐户，请使用此选项。
#
#          如果为 False（默认值），则无效用户将保留在 Hub 的数据库中，
#          并将发出警告。这是默认值，以避免由于配置更改而导致数据丢失。
#  默认: False
# c.Authenticator.delete_invalid_users = False

## 启用持久存储 auth_state（如果可用）。
#
#          auth_state 将被加密并存储在 Hub 的数据库中。
#          这可以包括诸如身份验证令牌等的东西。
#          以环境变量的形式传递给 Spawners。
#
#          加密 auth_state 需要 cryptography 包。
#
#          另外，JUPYTERHUB_CRYPT_KEY 环境变量必须
#          包含一个（或多个，以;分隔）32B 加密密钥。
#          这些可以是 base64 或十六进制编码的。
#
#          如果加密不可用，则无法持久存储 auth_state。
#
#          0.8 版本中新增
#  默认: False
# c.Authenticator.enable_auth_state = False

## 让身份验证器管理用户组
#
#          如果为 True，Authenticator.authenticate 和/或 .refresh_user
#          可以返回 'groups' 字段中的组名列表，
#          这将分配给用户。
#
#          如果为 True，则禁用所有分配组的 API。
#  默认: False
# c.Authenticator.manage_groups = False

## 一个可选的挂钩函数，您可以实现它来进行一些引导工作
#  在身份验证期间。例如，从外部系统加载用户帐户详细信息。
#
#  此函数在用户经过所有身份验证检查并准备成功进行身份验证后被调用。
#  无论对其的更改如何，此函数必须返回身份验证字典。
#
#  这可能是一个协程。
#
#  .. versionadded: 1.0
#
#  示例::
#
#      import os, pwd
#      def my_hook(authenticator, handler, authentication):
#          user_data = pwd.getpwnam(authentication['name'])
#          spawn_data = {
#              'pw_data': user_data
#              'gid_list': os.getgrouplist(authentication['name'], user_data.pw_gid)
#          }
#
#          if authentication['auth_state'] is None:
#              authentication['auth_state'] = {}
#          authentication['auth_state']['spawn_data'] = spawn_data
#
#          return authentication
#
#      c.Authenticator.post_auth_hook = my_hook
#  默认: None
# c.Authenticator.post_auth_hook = None

## 在启动之前强制刷新认证。
#
#          这会强制在启动服务器之前调用 :meth:`.refresh_user`，
#          以确保认证状态是最新的。
#
#          这在例如通过环境变量从 auth_state 传递给 spawner 的可能已过期
#          的 auth 令牌时可能很重要。
#
#          如果 refresh_user 无法刷新用户认证数据，
#          启动将失败，直到用户再次登录。
#  默认: False
# c.Authenticator.refresh_pre_spawn = False

## 将认证器用户名映射到 JupyterHub 用户的字典。
#
#          主要用于将 OAuth 用户名规范化为本地用户。
#  默认: {}
# c.Authenticator.username_map = {}

## 所有有效用户名必须匹配的正则表达式模式。
#
#  如果用户名不匹配此处指定的模式，则不会尝试进行身份验证。
#
#  如果未设置，允许任何用户名。
#  默认: ''
# c.Authenticator.username_pattern = ''

## 已弃用，使用 `Authenticator.allowed_users`
#  默认: set()
# c.Authenticator.whitelist = set()

#------------------------------------------------------------------------------
# CryptKeeper(SingletonConfigurable) 配置
#------------------------------------------------------------------------------
## 封装加密配置
#
#      通过以下 encryption_config 单例使用。

#  默认: []
# c.CryptKeeper.keys = []

## 用于加密的线程数
#  默认: 8
# c.CryptKeeper.n_threads = 8
```

**相关教程：**
[nginx 非80端口的同端口http跳转https](https://blog.csdn.net/linkyy5/article/details/125765290)