 |
v0.14.0 |
|
v0.14.0 |
Classes | |
| class | LocalNativeAuthenticator |
Variables | |
| active_server_limit | |
| This is an application. More... | |
| admin_access | |
| Duration (in seconds) to determine the number of active users. More... | |
| concurrent_spawn_limit | |
| Allow named single-user servers per user Default: False c.JupyterHub.allow_named_servers = False. More... | |
| template_paths | |
| The config file to load Default: 'jupyterhub_config.py' c.JupyterHub.config_file = 'jupyterhub_config.py'. More... | |
| env_keep | |
| Extra variables to be passed into jinja templates Default: {} c.JupyterHub.template_vars = {}. More... | |
| jupyterhub_config.active_server_limit |
This is an application.
The date format used by logging formatters for %(asctime)s Default: 'Y-m-d H:M:S' c.Application.log_datefmt = 'Y-m-d H:M:S' The Logging format template Default: '[%(name)s]%(highlevel)s %(message)s' c.Application.log_format = '[%(name)s]%(highlevel)s %(message)s' Set the log level by value or name. Choices: any of [0, 10, 20, 30, 40, 50, 'DEBUG', 'INFO', 'WARN', 'ERROR', 'CRITICAL'] Default: 30 c.Application.log_level = 30 Instead of starting the Application, dump configuration to stdout Default: False c.Application.show_config = False Instead of starting the Application, dump configuration to stdout (as JSON) Default: False c.Application.show_config_json = False An Application for starting a Multi-User Jupyter Notebook server. Maximum number of concurrent servers that can be active at a time.
Setting this can limit the total resources your users can consume.
An active server is any server that's not fully stopped. It is considered active from the time it has been requested until the time that it has completely stopped.
If this many user servers are active, users will not be able to launch new servers until a server is shutdown. Spawn requests will be rejected with a 429 error asking them to try again.
If set to 0, no limit is enforced. Default: 0
Definition at line 48 of file jupyterhub_config.py.
| jupyterhub_config.admin_access |
Duration (in seconds) to determine the number of active users.
Default: 1800 c.JupyterHub.active_user_window = 1800 Resolution (in seconds) for updating activity
If activity is registered that is less than activity_resolution seconds more recent than the current value, the new value will be ignored.
This avoids too many writes to the Hub database. Default: 30 c.JupyterHub.activity_resolution = 30 Grant admin users permission to access single-user servers.
Users should be properly informed if this is enabled. Default: False
Definition at line 67 of file jupyterhub_config.py.
| jupyterhub_config.concurrent_spawn_limit |
Allow named single-user servers per user Default: False c.JupyterHub.allow_named_servers = False.
Answer yes to any questions (e.g. confirm overwrite) Default: False c.JupyterHub.answer_yes = False PENDING DEPRECATION: consider using services
Dict of token:username to be loaded into the database.
Allows ahead-of-time generation of API tokens for use by externally managed services, which authenticate as JupyterHub users.
Consider using services for general services that talk to the JupyterHub API. Default: {} c.JupyterHub.api_tokens = {} Authentication for prometheus metrics Default: True c.JupyterHub.authenticate_prometheus = True Class for authenticating users.
This should be a subclass of :class:`jupyterhub.auth.Authenticator`
with an :meth:`authenticate` method that:
- is a coroutine (asyncio or tornado)
- returns username on success, None on failure
- takes two arguments: (handler, data),
where `handler` is the calling web.RequestHandler,
and `data` is the POST form data from the login page.
.. versionchanged:: 1.0
authenticators may be registered via entry points,
e.g. `c.JupyterHub.authenticator_class = 'pam'`
Currently installed:
Add this to the beginning of all JupyterHub URLs. Use base_url to run JupyterHub within an existing website.
.. deprecated: 0.9 Use JupyterHub.bind_url Default: '/' c.JupyterHub.base_url = '/' The public facing URL of the whole JupyterHub application.
This is the address on which the proxy will bind. Sets protocol, ip, base_url Default: 'http://:8000' c.JupyterHub.bind_url = 'http://:8000' Whether to shutdown the proxy when the Hub shuts down.
Disable if you want to be able to teardown the Hub while leaving the proxy running.
Only valid if the proxy was starting by the Hub process.
If both this and cleanup_servers are False, sending SIGINT to the Hub will only shutdown the Hub, leaving everything else running.
The Hub should be able to resume from database state. Default: True c.JupyterHub.cleanup_proxy = True Whether to shutdown single-user servers when the Hub shuts down.
Disable if you want to be able to teardown the Hub while leaving the single- user servers running.
If both this and cleanup_proxy are False, sending SIGINT to the Hub will only shutdown the Hub, leaving everything else running.
The Hub should be able to resume from database state. Default: True c.JupyterHub.cleanup_servers = True Maximum number of concurrent users that can be spawning at a time.
Spawning lots of servers at the same time can cause performance problems for the Hub or the underlying spawning system. Set this limit to prevent bursts of logins from attempting to spawn too many servers at the same time.
This does not limit the number of total running servers. See active_server_limit for that.
If more than this many users attempt to spawn at a time, their requests will be rejected with a 429 error asking them to try again. Users will have to wait for some of the spawning services to finish starting before they can start their own.
If set to 0, no limit is enforced. Default: 100
Definition at line 192 of file jupyterhub_config.py.
| jupyterhub_config.env_keep |
Extra variables to be passed into jinja templates Default: {} c.JupyterHub.template_vars = {}.
Extra settings overrides to pass to the tornado application. Default: {} c.JupyterHub.tornado_settings = {} Trust user-provided tokens (via JupyterHub.service_tokens) to have good entropy.
If you are not inserting additional tokens via configuration file, this flag has no effect.
In JupyterHub 0.8, internally generated tokens do not pass through additional hashing because the hashing is costly and does not increase the entropy of already-good UUIDs.
User-provided tokens, on the other hand, are not trusted to have good entropy by default, and are passed through many rounds of hashing to stretch the entropy of the key (i.e. user-provided tokens are treated as passwords instead of random keys). These keys are more costly to check.
If your inserted tokens are generated by a good-quality mechanism, e.g. openssl rand -hex 32, then you can set this flag to True to reduce the cost of checking authentication tokens. Default: False c.JupyterHub.trust_user_provided_tokens = False Names to include in the subject alternative name.
These names will be used for server name verification. This is useful if JupyterHub is being run behind a reverse proxy or services using ssl are on different hosts.
Use with internal_ssl Default: [] c.JupyterHub.trusted_alt_names = [] Downstream proxy IP addresses to trust.
This sets the list of IP addresses that are trusted and skipped when processing the X-Forwarded-For header. For example, if an external proxy is used for TLS termination, its IP address should be added to this list to ensure the correct client IP addresses are recorded in the logs instead of the proxy server's IP address. Default: [] c.JupyterHub.trusted_downstream_ips = [] Upgrade the database automatically on start.
Only safe if database is regularly backed up. Only SQLite databases will be backed up to a local file automatically. Default: False c.JupyterHub.upgrade_db = False Callable to affect behavior of /user-redirect/
Receives 4 parameters: 1. path - URL path that was provided after /user- redirect/ 2. request - A Tornado HTTPServerRequest representing the current request. 3. user - The currently authenticated user. 4. base_url - The base_url of the current hub, for relative redirects
It should return the new URL to redirect to, or None to preserve current behavior. Default: None c.JupyterHub.user_redirect_hook = None Base class for spawning single-user notebook servers.
Subclass this, and override the following methods:
As JupyterHub supports multiple users, an instance of the Spawner subclass is created for each user. If there are 20 JupyterHub users, there will be 20 instances of the subclass. Extra arguments to be passed to the single-user server.
Some spawners allow shell-style expansion here, allowing you to use environment variables here. Most, including the default, do not. Consult the documentation for your spawner to verify! Default: [] c.Spawner.args = [] An optional hook function that you can implement to pass auth_state to the spawner after it has been initialized but before it starts. The auth_state dictionary may be set by the .authenticate() method of the authenticator. This hook enables you to pass some or all of that information to your spawner.
Example::
def userdata_hook(spawner, auth_state):
spawner.userdata = auth_state["userdata"]
c.Spawner.auth_state_hook = userdata_hook
Default: None c.Spawner.auth_state_hook = None The command used for starting the single-user server.
Provide either a string or a list containing the path to the startup script command. Extra arguments, other than this path, should be provided via args.
This is usually set if you want to start the single-user server in a different python environment (with virtualenv/conda) than JupyterHub itself.
Some spawners allow shell-style expansion here, allowing you to use environment variables. Most, including the default, do not. Consult the documentation for your spawner to verify! Default: ['jupyterhub-singleuser'] c.Spawner.cmd = ['jupyterhub-singleuser'] Maximum number of consecutive failures to allow before shutting down JupyterHub.
This helps JupyterHub recover from a certain class of problem preventing launch in contexts where the Hub is automatically restarted (e.g. systemd, docker, kubernetes).
A limit of 0 means no limit and consecutive failures will not be tracked. Default: 0 c.Spawner.consecutive_failure_limit = 0 Minimum number of cpu-cores a single-user notebook server is guaranteed to have available.
If this value is set to 0.5, allows use of 50% of one CPU. If this value is set to 2, allows use of up to 2 CPUs.
This is a configuration setting. Your spawner must implement support for the limit to work. The default spawner, LocalProcessSpawner, does not implement this support. A custom spawner must add support for this setting for it to be enforced. Default: None c.Spawner.cpu_guarantee = None Maximum number of cpu-cores a single-user notebook server is allowed to use.
If this value is set to 0.5, allows use of 50% of one CPU. If this value is set to 2, allows use of up to 2 CPUs.
The single-user notebook server will never be scheduled by the kernel to use more cpu-cores than this. There is no guarantee that it can access this many cpu-cores.
This is a configuration setting. Your spawner must implement support for the limit to work. The default spawner, LocalProcessSpawner, does not implement this support. A custom spawner must add support for this setting for it to be enforced. Default: None c.Spawner.cpu_limit = None Enable debug-logging of the single-user server Default: False c.Spawner.debug = False The URL the single-user server should start in.
{username} will be expanded to the user's username
Example uses:
notebook_dir to / and default_url to /tree/home/{username} to allow people to navigate the whole filesystem from their notebook server, but still start in their home directory./notebooks instead of /tree if default_url points to a notebook instead of a directory./lab to have JupyterLab start by default, rather than Jupyter Notebook. Default: '' c.Spawner.default_url = '' Disable per-user configuration of single-user servers.When starting the user's single-user server, any config file found in the user's $HOME directory will be ignored.
Note: a user could circumvent this if the user modifies their Python environment, such as when they have their own conda environments / virtualenvs / containers. Default: False c.Spawner.disable_user_config = False List of environment variables for the single-user server to inherit from the JupyterHub process.
This list is used to ensure that sensitive information in the JupyterHub process's environment (such as CONFIGPROXY_AUTH_TOKEN) is not passed to the single-user server's process. Default: ['PATH', 'PYTHONPATH', 'CONDA_ROOT', 'CONDA_DEFAULT_ENV', 'VIRTUAL_ENV', 'LANG', 'LC_ALL', 'JUPYTERHUB_SINGLEUSER_APP']
Definition at line 846 of file jupyterhub_config.py.
| jupyterhub_config.template_paths |
The config file to load Default: 'jupyterhub_config.py' c.JupyterHub.config_file = 'jupyterhub_config.py'.
DEPRECATED: does nothing Default: False c.JupyterHub.confirm_no_ssl = False Number of days for a login cookie to be valid. Default is two weeks. Default: 14 c.JupyterHub.cookie_max_age_days = 14 The cookie secret to use to encrypt cookies.
Loaded from the JPY_COOKIE_SECRET env variable by default.
Should be exactly 256 bits (32 bytes). Default: b'' c.JupyterHub.cookie_secret = b'' File in which to store the cookie secret. Default: 'jupyterhub_cookie_secret' c.JupyterHub.cookie_secret_file = 'jupyterhub_cookie_secret' The location of jupyterhub data files (e.g. /usr/local/share/jupyterhub) Default: '/usr/local/share/jupyterhub' c.JupyterHub.data_files_path = '/usr/local/share/jupyterhub' Include any kwargs to pass to the database connection. See sqlalchemy.create_engine for details. Default: {} c.JupyterHub.db_kwargs = {} url for the database. e.g. sqlite:///jupyterhub.sqlite Default: 'sqlite:///jupyterhub.sqlite' c.JupyterHub.db_url = 'sqlite:///jupyterhub.sqlite' log all database transactions. This has A LOT of output Default: False c.JupyterHub.debug_db = False DEPRECATED since version 0.8: Use ConfigurableHTTPProxy.debug Default: False c.JupyterHub.debug_proxy = False If named servers are enabled, default name of server to spawn or open, e.g. by user-redirect. Default: '' c.JupyterHub.default_server_name = '' The default URL for users when they arrive (e.g. when user directs to "/")
By default, redirects users to their own server.
Can be a Unicode string (e.g. '/hub/home') or a callable based on the handler object:
::
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
Default: traitlets.Undefined c.JupyterHub.default_url = traitlets.Undefined Dict authority:dict(files). Specify the key, cert, and/or ca file for an authority. This is useful for externally managed proxies that wish to use internal_ssl.
The files dict has this format (you must specify at least a cert)::
{
'key': '/path/to/key.key',
'cert': '/path/to/cert.crt',
'ca': '/path/to/ca.crt'
}
The authorities you can override: 'hub-ca', 'notebooks-ca', 'proxy-api-ca', 'proxy-client-ca', and 'services-ca'.
Use with internal_ssl Default: {} c.JupyterHub.external_ssl_authorities = {} Register extra tornado Handlers for jupyterhub.
Should be of the form ("<regex>", Handler)
The Hub prefix will be added, so /my-page will be served at /hub/my-page. Default: [] c.JupyterHub.extra_handlers = [] DEPRECATED: use output redirection instead, e.g.
jupyterhub &>> /var/log/jupyterhub.log Default: '' c.JupyterHub.extra_log_file = '' Extra log handlers to set on JupyterHub logger Default: [] c.JupyterHub.extra_log_handlers = [] Generate certs used for internal ssl Default: False c.JupyterHub.generate_certs = False Generate default config file Default: False c.JupyterHub.generate_config = False The URL on which the Hub will listen. This is a private URL for internal communication. Typically set in combination with hub_connect_url. If a unix socket, hub_connect_url must also be set.
For example:
"http://127.0.0.1:8081" "unix+http://%2Fsrv%2Fjupyterhub%2Fjupyterhub.sock"
.. versionadded:: 0.9 Default: '' c.JupyterHub.hub_bind_url = '' The ip or hostname for proxies and spawners to use for connecting to the Hub.
Use when the bind address (hub_ip) is 0.0.0.0, :: or otherwise different from the connect address.
Default: when hub_ip is 0.0.0.0 or ::, use socket.gethostname(), otherwise use hub_ip.
Note: Some spawners or proxy implementations might not support hostnames. Check your spawner or proxy documentation to see if they have extra requirements.
.. versionadded:: 0.8 Default: '' c.JupyterHub.hub_connect_ip = '' DEPRECATED
Use hub_connect_url
.. versionadded:: 0.8
.. deprecated:: 0.9 Use hub_connect_url Default: 0 c.JupyterHub.hub_connect_port = 0 The URL for connecting to the Hub. Spawners, services, and the proxy will use this URL to talk to the Hub.
Only needs to be specified if the default hub URL is not connectable (e.g. using a unix+http:// bind url).
.. seealso:: JupyterHub.hub_connect_ip JupyterHub.hub_bind_url
.. versionadded:: 0.9 Default: '' c.JupyterHub.hub_connect_url = '' The ip address for the Hub process to bind to.
By default, the hub listens on localhost only. This address must be accessible from the proxy and user servers. You may need to set this to a public ip or '' for all interfaces if the proxy or user servers are in containers or on a different host.
See hub_connect_ip for cases where the bind and connect address should differ, or hub_bind_url for setting the full bind URL. Default: '127.0.0.1' c.JupyterHub.hub_ip = '127.0.0.1' The internal port for the Hub process.
This is the internal port of the hub itself. It should never be accessed directly. See JupyterHub.port for the public port to use when accessing jupyterhub. It is rare that this port should be set except in cases of port conflict.
See also hub_ip for the ip and hub_bind_url for setting the full bind URL. Default: 8081 c.JupyterHub.hub_port = 8081 Trigger implicit spawns after this many seconds.
When a user visits a URL for a server that's not running, they are shown a page indicating that the requested server is not running with a button to spawn the server.
Setting this to a positive value will redirect the user after this many seconds, effectively clicking this button automatically for the users, automatically beginning the spawn process.
Warning: this can result in errors and surprising behavior when sharing access URLs to actual servers, since the wrong server is likely to be started. Default: 0 c.JupyterHub.implicit_spawn_seconds = 0 Timeout (in seconds) to wait for spawners to initialize
Checking if spawners are healthy can take a long time if many spawners are active at hub start time.
If it takes longer than this timeout to check, init_spawner will be left to complete in the background and the http server is allowed to start.
A timeout of -1 means wait forever, which can mean a slow startup of the Hub but ensures that the Hub is fully consistent by the time it starts responding to requests. This matches the behavior of jupyterhub 1.0.
.. versionadded: 1.1.0 Default: 10 c.JupyterHub.init_spawners_timeout = 10 The location to store certificates automatically created by JupyterHub.
Use with internal_ssl Default: 'internal-ssl' c.JupyterHub.internal_certs_location = 'internal-ssl' Enable SSL for all internal communication
This enables end-to-end encryption between all JupyterHub components. JupyterHub will automatically create the necessary certificate authority and sign notebook certificates as they're created. Default: False c.JupyterHub.internal_ssl = False The public facing ip of the whole JupyterHub application (specifically referred to as the proxy).
This is the address on which the proxy will listen. The default is to listen on all interfaces. This is the only address through which JupyterHub should be accessed by users.
.. deprecated: 0.9 Use JupyterHub.bind_url Default: '' c.JupyterHub.ip = '' Supply extra arguments that will be passed to Jinja environment. Default: {} c.JupyterHub.jinja_environment_options = {} Interval (in seconds) at which to update last-activity timestamps. Default: 300 c.JupyterHub.last_activity_interval = 300 Dict of 'group': ['usernames'] to load at startup.
This strictly adds groups and users to groups.
Loading one set of groups, then starting JupyterHub again with a different set will not remove users or groups from previous launches. That must be done through the API. Default: {} c.JupyterHub.load_groups = {} The date format used by logging formatters for %(asctime)s See also: Application.log_datefmt c.JupyterHub.log_datefmt = 'Y-m-d H:M:S' The Logging format template See also: Application.log_format c.JupyterHub.log_format = '[%(name)s]%(highlevel)s %(message)s' Set the log level by value or name. See also: Application.log_level c.JupyterHub.log_level = 30 Specify path to a logo image to override the Jupyter logo in the banner. Default: '' c.JupyterHub.logo_file = '' Maximum number of concurrent named servers that can be created by a user at a time.
Setting this can limit the total resources a user can consume.
If set to 0, no limit is enforced. Default: 0 c.JupyterHub.named_server_limit_per_user = 0 File to write PID Useful for daemonizing JupyterHub. Default: '' c.JupyterHub.pid_file = '' The public facing port of the proxy.
This is the port on which the proxy will listen. This is the only port through which JupyterHub should be accessed by users.
.. deprecated: 0.9 Use JupyterHub.bind_url Default: 8000 c.JupyterHub.port = 8000 DEPRECATED since version 0.8 : Use ConfigurableHTTPProxy.api_url Default: '' c.JupyterHub.proxy_api_ip = '' DEPRECATED since version 0.8 : Use ConfigurableHTTPProxy.api_url Default: 0 c.JupyterHub.proxy_api_port = 0 DEPRECATED since version 0.8: Use ConfigurableHTTPProxy.auth_token Default: '' c.JupyterHub.proxy_auth_token = '' Interval (in seconds) at which to check if the proxy is running. Default: 30 c.JupyterHub.proxy_check_interval = 30 The class to use for configuring the JupyterHub proxy.
Should be a subclass of :class:`jupyterhub.proxy.Proxy`.
.. versionchanged:: 1.0
proxies may be registered via entry points,
e.g. `c.JupyterHub.proxy_class = 'traefik'`
Currently installed:
Note: enabling this feature requires restarting all notebook servers.
Use with internal_ssl Default: False c.JupyterHub.recreate_internal_certs = False Redirect user to server (if running), instead of control panel. Default: True c.JupyterHub.redirect_to_server = True Purge and reset the database. Default: False c.JupyterHub.reset_db = False Interval (in seconds) at which to check connectivity of services with web endpoints. Default: 60 c.JupyterHub.service_check_interval = 60 Dict of token:servicename to be loaded into the database.
Allows ahead-of-time generation of API tokens for use by externally managed services. Default: {} c.JupyterHub.service_tokens = {} List of service specification dictionaries.
A service
For instance::
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':
}
]
Default: [] c.JupyterHub.services = [] Instead of starting the Application, dump configuration to stdout See also: Application.show_config c.JupyterHub.show_config = False Instead of starting the Application, dump configuration to stdout (as JSON) See also: Application.show_config_json c.JupyterHub.show_config_json = False Shuts down all user servers on logout Default: False c.JupyterHub.shutdown_on_logout = False The class to use for spawning single-user servers.
Should be a subclass of :class:`jupyterhub.spawner.Spawner`.
.. versionchanged:: 1.0
spawners may be registered via entry points,
e.g. `c.JupyterHub.spawner_class = 'localprocess'`
Currently installed:
When setting this, you should also set ssl_key Default: '' c.JupyterHub.ssl_cert = '' Path to SSL key file for the public facing interface of the proxy
When setting this, you should also set ssl_cert Default: '' c.JupyterHub.ssl_key = '' Host to send statsd metrics to. An empty string (the default) disables sending metrics. Default: '' c.JupyterHub.statsd_host = '' Port on which to send statsd metrics about the hub Default: 8125 c.JupyterHub.statsd_port = 8125 Prefix to use for all metrics sent by jupyterhub to statsd Default: 'jupyterhub' c.JupyterHub.statsd_prefix = 'jupyterhub' Run single-user servers on subdomains of this host.
This should be the full https://hub.domain.tld[:port].
Provides additional cross-site protections for javascript served by single- user servers.
Requires <username>.hub.domain.tld to resolve to the same host as hub.domain.tld.
In general, this is most easily achieved with wildcard DNS.
When using SSL (i.e. always) this also requires a wildcard SSL certificate. Default: '' c.JupyterHub.subdomain_host = '' Paths to search for jinja templates, before using the default templates. Default: []
Definition at line 652 of file jupyterhub_config.py.
