• Kubernetes 通过 Deployment 部署Jupyterlab

    概要

    在Kubernetes上部署jupyterlab服务，链接Kubernetes集群内的MySQL，实现简单的数据开发功能。

    前置条件

    镜像准备：自定义Docker镜像--Jupyterlab-CSDN博客

    MySQL-Statefulset准备：StatefulSet 简单实践 Kubernetes-CSDN博客

    步骤

    1-namespace.yaml

    1. apiVersion: v1
    2. kind: Namespace
    3. metadata:
    4.   name: jupyterlab
    5.   labels:
    6.     app1: jupyterlab
    7.     app.kubernetes.io/name: jupyterlab

    2-jupyter-config.yaml

    关键配置：

    • c.ServerApp.allow_remote_access = True
    • c.ServerApp.ip = '*'
    • c.ServerApp.open_browser = False  
    • c.ServerApp.password = ''
    • c.ServerApp.port = 8888

    c.ServerApp.ip = '' 默认事localhost，配置 "*" 便于访问，便于nodeport的访问

    如何生成password，参考:

    jupyter-lab 设置密码(password) - 简书 (jianshu.com)

    详细内容：

    1. apiVersion: v1
    2. kind: ConfigMap
    3. metadata:
    4.   labels:
    5.     app1: jupyterlab
    6.     app.kubernetes.io/name: jupyterlab
    7.   name: jupyter-config
    8.   namespace: jupyterlab
    9. data:
    10.   jupyter_lab_config.py: |-
    11.     # Configuration file for lab.
    12.  
    13.     #------------------------------------------------------------------------------
    14.     # Application(SingletonConfigurable) configuration
    15.     #------------------------------------------------------------------------------
    16.  
    17.     ## This is an application.
    18.  
    19.     ## The date format used by logging formatters for %(asctime)s
    20.     #c.Application.log_datefmt = '%Y-%m-%d %H:%M:%S'
    21.  
    22.     ## The Logging format template
    23.     #c.Application.log_format = '[%(name)s]%(highlevel)s %(message)s'
    24.  
    25.     ## Set the log level by value or name.
    26.     #c.Application.log_level = 30
    27.  
    28.     #------------------------------------------------------------------------------
    29.     # JupyterApp(Application) configuration
    30.     #------------------------------------------------------------------------------
    31.  
    32.     ## Base class for Jupyter applications
    33.  
    34.     ## Answer yes to any prompts.
    35.     #c.JupyterApp.answer_yes = False
    36.  
    37.     ## Full path of a config file.
    38.     c.JupyterApp.config_file = '/root/.jupyter/jupyter_lab_config.py'
    39.  
    40.     ## Specify a config file to load.
    41.     #c.JupyterApp.config_file_name = ''
    42.  
    43.     ## Generate default config file.
    44.     #c.JupyterApp.generate_config = False
    45.  
    46.     #------------------------------------------------------------------------------
    47.     # ExtensionApp(JupyterApp) configuration
    48.     #------------------------------------------------------------------------------
    49.  
    50.     ## Base class for configurable Jupyter Server Extension Applications.
    51.     #  
    52.     #  ExtensionApp subclasses can be initialized two ways:
    53.     #  1. Extension is listed as a jpserver_extension, and ServerApp calls
    54.     #      its load_jupyter_server_extension classmethod. This is the
    55.     #      classic way of loading a server extension.
    56.     #  2. Extension is launched directly by calling its `launch_instance`
    57.     #      class method. This method can be set as a entry_point in
    58.     #      the extensions setup.py
    59.  
    60.     ## 
    61.     #c.ExtensionApp.default_url = ''
    62.  
    63.     ## Handlers appended to the server.
    64.     #c.ExtensionApp.handlers = []
    65.  
    66.     ## Whether to open in a browser after starting. The specific browser used is
    67.     #  platform dependent and determined by the python standard library `webbrowser`
    68.     #  module, unless it is overridden using the --browser (ServerApp.browser)
    69.     #  configuration option.
    70.     #c.ExtensionApp.open_browser = False
    71.  
    72.     ## Settings that will passed to the server.
    73.     #c.ExtensionApp.settings = {}
    74.  
    75.     ## paths to search for serving static files.
    76.     #  
    77.     #  This allows adding javascript/css to be available from the notebook server
    78.     #  machine, or overriding individual files in the IPython
    79.     #c.ExtensionApp.static_paths = []
    80.  
    81.     ## Url where the static assets for the extension are served.
    82.     #c.ExtensionApp.static_url_prefix = ''
    83.  
    84.     ## Paths to search for serving jinja templates.
    85.     #  
    86.     #  Can be used to override templates from notebook.templates.
    87.     #c.ExtensionApp.template_paths = []
    88.  
    89.     #------------------------------------------------------------------------------
    90.     # LabServerApp(ExtensionAppJinjaMixin,LabConfig,ExtensionApp) configuration
    91.     #------------------------------------------------------------------------------
    92.  
    93.     ## A Lab Server Application that runs out-of-the-box
    94.  
    95.     ## "A list of comma-separated URIs to get the allowed extensions list
    96.     #  
    97.     #  .. versionchanged:: 2.0.0
    98.     #      `LabServerApp.whitetlist_uris` renamed to `allowed_extensions_uris`
    99.     #c.LabServerApp.allowed_extensions_uris = ''
    100.  
    101.     ## Deprecated, use `LabServerApp.blocked_extensions_uris`
    102.     #c.LabServerApp.blacklist_uris = ''
    103.  
    104.     ## A list of comma-separated URIs to get the blocked extensions list
    105.     #  
    106.     #  .. versionchanged:: 2.0.0
    107.     #      `LabServerApp.blacklist_uris` renamed to `blocked_extensions_uris`
    108.     #c.LabServerApp.blocked_extensions_uris = ''
    109.  
    110.     ## The interval delay in seconds to refresh the lists
    111.     #c.LabServerApp.listings_refresh_seconds = 3600
    112.  
    113.     ## The optional kwargs to use for the listings HTTP requests             as
    114.     #  described on https://2.python-requests.org/en/v2.7.0/api/#requests.request
    115.     #c.LabServerApp.listings_request_options = {}
    116.  
    117.     ## Deprecated, use `LabServerApp.allowed_extensions_uris`
    118.     #c.LabServerApp.whitelist_uris = ''
    119.  
    120.     #------------------------------------------------------------------------------
    121.     # LabApp(NBClassicConfigShimMixin,LabServerApp) configuration
    122.     #------------------------------------------------------------------------------
    123.  
    124.     ## The app directory to launch JupyterLab from.
    125.     #c.LabApp.app_dir = None
    126.  
    127.     ## Whether to enable collaborative mode.
    128.     #c.LabApp.collaborative = False
    129.  
    130.     ## Whether to start the app in core mode. In this mode, JupyterLab will run using
    131.     #  the JavaScript assets that are within the installed JupyterLab Python package.
    132.     #  In core mode, third party extensions are disabled. The `--dev-mode` flag is an
    133.     #  alias to this to be used when the Python package itself is installed in
    134.     #  development mode (`pip install -e .`).
    135.     #c.LabApp.core_mode = False
    136.  
    137.     ## The default URL to redirect to from `/`
    138.     #c.LabApp.default_url = '/lab'
    139.  
    140.     ## Whether to start the app in dev mode. Uses the unpublished local JavaScript
    141.     #  packages in the `dev_mode` folder.  In this case JupyterLab will show a red
    142.     #  stripe at the top of the page.  It can only be used if JupyterLab is installed
    143.     #  as `pip install -e .`.
    144.     #c.LabApp.dev_mode = False
    145.  
    146.     ## Whether to expose the global app instance to browser via window.jupyterlab
    147.     #c.LabApp.expose_app_in_browser = False
    148.  
    149.     ## Whether to load prebuilt extensions in dev mode. This may be useful to run and
    150.     #  test prebuilt extensions in development installs of JupyterLab. APIs in a
    151.     #  JupyterLab development install may be incompatible with published packages, so
    152.     #  prebuilt extensions compiled against published packages may not work
    153.     #  correctly.
    154.     #c.LabApp.extensions_in_dev_mode = False
    155.  
    156.     ## The override url for static lab assets, typically a CDN.
    157.     #c.LabApp.override_static_url = ''
    158.  
    159.     ## The override url for static lab theme assets, typically a CDN.
    160.     #c.LabApp.override_theme_url = ''
    161.  
    162.     ## Splice source packages into app directory.
    163.     #c.LabApp.splice_source = False
    164.  
    165.     ## The directory for user settings.
    166.     #c.LabApp.user_settings_dir = '/root/.jupyter/lab/user-settings'
    167.  
    168.     ## Whether to serve the app in watch mode
    169.     #c.LabApp.watch = False
    170.  
    171.     ## The directory for workspaces
    172.     #c.LabApp.workspaces_dir = '/root/.jupyter/lab/workspaces'
    173.  
    174.     #------------------------------------------------------------------------------
    175.     # ServerApp(JupyterApp) configuration
    176.     #------------------------------------------------------------------------------
    177.  
    178.     ## Set the Access-Control-Allow-Credentials: true header
    179.     #c.ServerApp.allow_credentials = False
    180.  
    181.     ## Set the Access-Control-Allow-Origin header
    182.     #  
    183.     #  Use '*' to allow any origin to access your server.
    184.     #  
    185.     #  Takes precedence over allow_origin_pat.
    186.     #c.ServerApp.allow_origin = ''
    187.  
    188.     ## Use a regular expression for the Access-Control-Allow-Origin header
    189.     #  
    190.     #  Requests from an origin matching the expression will get replies with:
    191.     #  
    192.     #      Access-Control-Allow-Origin: origin
    193.     #  
    194.     #  where `origin` is the origin of the request.
    195.     #  
    196.     #  Ignored if allow_origin is set.
    197.     #c.ServerApp.allow_origin_pat = ''
    198.  
    199.     ## Allow password to be changed at login for the Jupyter server.
    200.     #  
    201.     #  While logging in with a token, the Jupyter server UI will give the opportunity
    202.     #  to the user to enter a new password at the same time that will replace the
    203.     #  token login mechanism.
    204.     #  
    205.     #  This can be set to false to prevent changing password from the UI/API.
    206.     #c.ServerApp.allow_password_change = True
    207.  
    208.     ## Allow requests where the Host header doesn't point to a local server
    209.     #  
    210.     #  By default, requests get a 403 forbidden response if the 'Host' header shows
    211.     #  that the browser thinks it's on a non-local domain. Setting this option to
    212.     #  True disables this check.
    213.     #  
    214.     #  This protects against 'DNS rebinding' attacks, where a remote web server
    215.     #  serves you a page and then changes its DNS to send later requests to a local
    216.     #  IP, bypassing same-origin checks.
    217.     #  
    218.     #  Local IP addresses (such as 127.0.0.1 and ::1) are allowed as local, along
    219.     #  with hostnames configured in local_hostnames.
    220.     c.ServerApp.allow_remote_access = True
    221.  
    222.     ## Whether to allow the user to run the server as root.
    223.     c.ServerApp.allow_root = True
    224.  
    225.     ## " Require authentication to access prometheus metrics.
    226.     #c.ServerApp.authenticate_prometheus = True
    227.  
    228.     ## Reload the webapp when changes are made to any Python src files.
    229.     #c.ServerApp.autoreload = False
    230.  
    231.     ## The base URL for the Jupyter server.
    232.     #  
    233.     #  Leading and trailing slashes can be omitted, and will automatically be added.
    234.     #c.ServerApp.base_url = '/'
    235.  
    236.     ## Specify what command to use to invoke a web browser when starting the server.
    237.     #  If not specified, the default browser will be determined by the `webbrowser`
    238.     #  standard library module, which allows setting of the BROWSER environment
    239.     #  variable to override it.
    240.     #c.ServerApp.browser = ''
    241.  
    242.     ## The full path to an SSL/TLS certificate file.
    243.     #c.ServerApp.certfile = ''
    244.  
    245.     ## The full path to a certificate authority certificate for SSL/TLS client
    246.     #  authentication.
    247.     #c.ServerApp.client_ca = ''
    248.  
    249.     ## The config manager class to use
    250.     #c.ServerApp.config_manager_class = 'jupyter_server.services.config.manager.ConfigManager'
    251.  
    252.     ## The content manager class to use.
    253.     #c.ServerApp.contents_manager_class = 'jupyter_server.services.contents.largefilemanager.LargeFileManager'
    254.  
    255.     ## Extra keyword arguments to pass to `set_secure_cookie`. See tornado's
    256.     #  set_secure_cookie docs for details.
    257.     #c.ServerApp.cookie_options = {}
    258.  
    259.     ## The random bytes used to secure cookies. By default this is a new random
    260.     #  number every time you start the server. Set it to a value in a config file to
    261.     #  enable logins to persist across server sessions.
    262.     #  
    263.     #  Note: Cookie secrets should be kept private, do not share config files with
    264.     #  cookie_secret stored in plaintext (you can read the value from a file).
    265.     #c.ServerApp.cookie_secret = b''
    266.  
    267.     ## The file where the cookie secret is stored.
    268.     #c.ServerApp.cookie_secret_file = ''
    269.  
    270.     ## Override URL shown to users.
    271.     #  
    272.     #  Replace actual URL, including protocol, address, port and base URL, with the
    273.     #  given value when displaying URL to the users. Do not change the actual
    274.     #  connection URL. If authentication token is enabled, the token is added to the
    275.     #  custom URL automatically.
    276.     #  
    277.     #  This option is intended to be used when the URL to display to the user cannot
    278.     #  be determined reliably by the Jupyter server (proxified or containerized
    279.     #  setups for example).
    280.     #c.ServerApp.custom_display_url = ''
    281.  
    282.     ## The default URL to redirect to from `/`
    283.     #c.ServerApp.default_url = '/'
    284.  
    285.     ## Disable cross-site-request-forgery protection
    286.     #  
    287.     #  Jupyter notebook 4.3.1 introduces protection from cross-site request
    288.     #  forgeries, requiring API requests to either:
    289.     #  
    290.     #  - originate from pages served by this server (validated with XSRF cookie and
    291.     #  token), or - authenticate with a token
    292.     #  
    293.     #  Some anonymous compute resources still desire the ability to run code,
    294.     #  completely without authentication. These services can disable all
    295.     #  authentication and security checks, with the full knowledge of what that
    296.     #  implies.
    297.     #c.ServerApp.disable_check_xsrf = False
    298.  
    299.     ## handlers that should be loaded at higher priority than the default services
    300.     #c.ServerApp.extra_services = []
    301.  
    302.     ## Extra paths to search for serving static files.
    303.     #  
    304.     #  This allows adding javascript/css to be available from the Jupyter server
    305.     #  machine, or overriding individual files in the IPython
    306.     #c.ServerApp.extra_static_paths = []
    307.  
    308.     ## Extra paths to search for serving jinja templates.
    309.     #  
    310.     #  Can be used to override templates from jupyter_server.templates.
    311.     #c.ServerApp.extra_template_paths = []
    312.  
    313.     ## Open the named file when the application is launched.
    314.     #c.ServerApp.file_to_run = ''
    315.  
    316.     ## The URL prefix where files are opened directly.
    317.     #c.ServerApp.file_url_prefix = 'notebooks'
    318.  
    319.     ## Extra keyword arguments to pass to `get_secure_cookie`. See tornado's
    320.     #  get_secure_cookie docs for details.
    321.     #c.ServerApp.get_secure_cookie_kwargs = {}
    322.  
    323.     ## (bytes/sec) Maximum rate at which stream output can be sent on iopub before
    324.     #  they are limited.
    325.     #c.ServerApp.iopub_data_rate_limit = 1000000
    326.  
    327.     ## (msgs/sec) Maximum rate at which messages can be sent on iopub before they are
    328.     #  limited.
    329.     #c.ServerApp.iopub_msg_rate_limit = 1000
    330.  
    331.     ## The IP address the Jupyter server will listen on.
    332.     c.ServerApp.ip = '*'
    333.  
    334.     ## Supply extra arguments that will be passed to Jinja environment.
    335.     #c.ServerApp.jinja_environment_options = {}
    336.  
    337.     ## Extra variables to supply to jinja templates when rendering.
    338.     #c.ServerApp.jinja_template_vars = {}
    339.  
    340.     ## Dict of Python modules to load as Jupyter server extensions.Entry values can
    341.     #  be used to enable and disable the loading ofthe extensions. The extensions
    342.     #  will be loaded in alphabetical order.
    343.     #c.ServerApp.jpserver_extensions = {}
    344.  
    345.     ## The kernel manager class to use.
    346.     #c.ServerApp.kernel_manager_class = 'jupyter_server.services.kernels.kernelmanager.AsyncMappingKernelManager'
    347.  
    348.     ## The kernel spec manager class to use. Should be a subclass of
    349.     #  `jupyter_client.kernelspec.KernelSpecManager`.
    350.     #  
    351.     #  The Api of KernelSpecManager is provisional and might change without warning
    352.     #  between this version of Jupyter and the next stable one.
    353.     #c.ServerApp.kernel_spec_manager_class = 'jupyter_client.kernelspec.KernelSpecManager'
    354.  
    355.     ## The full path to a private key file for usage with SSL/TLS.
    356.     #c.ServerApp.keyfile = ''
    357.  
    358.     ## Hostnames to allow as local when allow_remote_access is False.
    359.     #  
    360.     #  Local IP addresses (such as 127.0.0.1 and ::1) are automatically accepted as
    361.     #  local as well.
    362.     #c.ServerApp.local_hostnames = ['localhost']
    363.  
    364.     ## The login handler class to use.
    365.     #c.ServerApp.login_handler_class = 'jupyter_server.auth.login.LoginHandler'
    366.  
    367.     ## The logout handler class to use.
    368.     #c.ServerApp.logout_handler_class = 'jupyter_server.auth.logout.LogoutHandler'
    369.  
    370.     ## Sets the maximum allowed size of the client request body, specified in the
    371.     #  Content-Length request header field. If the size in a request exceeds the
    372.     #  configured value, a malformed HTTP message is returned to the client.
    373.     #  
    374.     #  Note: max_body_size is applied even in streaming mode.
    375.     #c.ServerApp.max_body_size = 536870912
    376.  
    377.     ## Gets or sets the maximum amount of memory, in bytes, that is allocated for use
    378.     #  by the buffer manager.
    379.     #c.ServerApp.max_buffer_size = 536870912
    380.  
    381.     ## Gets or sets a lower bound on the open file handles process resource limit.
    382.     #  This may need to be increased if you run into an OSError: [Errno 24] Too many
    383.     #  open files. This is not applicable when running on Windows.
    384.     #c.ServerApp.min_open_files_limit = 0
    385.  
    386.     ## DEPRECATED, use root_dir.
    387.     #c.ServerApp.notebook_dir = ''
    388.  
    389.     ## Whether to open in a browser after starting. The specific browser used is
    390.     #  platform dependent and determined by the python standard library `webbrowser`
    391.     #  module, unless it is overridden using the --browser (ServerApp.browser)
    392.     #  configuration option.
    393.     #c.ServerApp.open_browser = False
    394.  
    395.     ## Hashed password to use for web authentication.
    396.     #  
    397.     #  To generate, type in a python/IPython shell:
    398.     #  
    399.     #    from jupyter_server.auth import passwd; passwd()
    400.     #  
    401.     #  The string should be of the form type:salt:hashed-password.
    402.     # password = 1
    403.     c.ServerApp.password = 'argon2:$argon2id$v=19$m=10240,t=10,p=8$3SVwOn5jZCsVPToRwHfo6A$/Q67MolIfT+ztoV26F6eeuE0NxfhFFsyzLV//9IV+J4'
    404.  
    405.     ## Forces users to use a password for the Jupyter server. This is useful in a
    406.     #  multi user environment, for instance when everybody in the LAN can access each
    407.     #  other's machine through ssh.
    408.     #  
    409.     #  In such a case, serving on localhost is not secure since any user can connect
    410.     #  to the Jupyter server via ssh.
    411.     #c.ServerApp.password_required = False
    412.  
    413.     ## The port the server will listen on (env: JUPYTER_PORT).
    414.     c.ServerApp.port = 8888
    415.  
    416.     ## The number of additional ports to try if the specified port is not available
    417.     #  (env: JUPYTER_PORT_RETRIES).
    418.     #c.ServerApp.port_retries = 50
    419.  
    420.     ## Preferred starting directory to use for notebooks and kernels.
    421.     #c.ServerApp.preferred_dir = ''
    422.  
    423.     ## DISABLED: use %pylab or %matplotlib in the notebook to enable matplotlib.
    424.     #c.ServerApp.pylab = 'disabled'
    425.  
    426.     ## If True, display controls to shut down the Jupyter server, such as menu items
    427.     #  or buttons.
    428.     #c.ServerApp.quit_button = True
    429.  
    430.     ## (sec) Time window used to check the message and data rate limits.
    431.     #c.ServerApp.rate_limit_window = 3
    432.  
    433.     ## Reraise exceptions encountered loading server extensions?
    434.     #c.ServerApp.reraise_server_extension_failures = False
    435.  
    436.     ## The directory to use for notebooks and kernels.
    437.     c.ServerApp.root_dir = '/home/jupyterlab'
    438.  
    439.     ## The session manager class to use.
    440.     #c.ServerApp.session_manager_class = 'jupyter_server.services.sessions.sessionmanager.SessionManager'
    441.  
    442.     ## Shut down the server after N seconds with no kernels or terminals running and
    443.     #  no activity. This can be used together with culling idle kernels
    444.     #  (MappingKernelManager.cull_idle_timeout) to shutdown the Jupyter server when
    445.     #  it's not in use. This is not precisely timed: it may shut down up to a minute
    446.     #  later. 0 (the default) disables this automatic shutdown.
    447.     #c.ServerApp.shutdown_no_activity_timeout = 0
    448.  
    449.     ## The UNIX socket the Jupyter server will listen on.
    450.     #c.ServerApp.sock = ''
    451.  
    452.     ## The permissions mode for UNIX socket creation (default: 0600).
    453.     #c.ServerApp.sock_mode = '0600'
    454.  
    455.     ## Supply SSL options for the tornado HTTPServer. See the tornado docs for
    456.     #  details.
    457.     #c.ServerApp.ssl_options = {}
    458.  
    459.     ## Supply overrides for terminado. Currently only supports "shell_command".
    460.     #c.ServerApp.terminado_settings = {}
    461.  
    462.     ## Set to False to disable terminals.
    463.     #  
    464.     #  This does *not* make the server more secure by itself. Anything the user can
    465.     #  in a terminal, they can also do in a notebook.
    466.     #  
    467.     #  Terminals may also be automatically disabled if the terminado package is not
    468.     #  available.
    469.     #c.ServerApp.terminals_enabled = True
    470.  
    471.     ## Token used for authenticating first-time connections to the server.
    472.     #  
    473.     #  The token can be read from the file referenced by JUPYTER_TOKEN_FILE or set
    474.     #  directly with the JUPYTER_TOKEN environment variable.
    475.     #  
    476.     #  When no password is enabled, the default is to generate a new, random token.
    477.     #  
    478.     #  Setting to an empty string disables authentication altogether, which is NOT
    479.     #  RECOMMENDED.
    480.     #c.ServerApp.token = ''
    481.  
    482.     ## Supply overrides for the tornado.web.Application that the Jupyter server uses.
    483.     #c.ServerApp.tornado_settings = {}
    484.  
    485.     ## Whether to trust or not X-Scheme/X-Forwarded-Proto and X-Real-Ip/X-Forwarded-
    486.     #  For headerssent by the upstream reverse proxy. Necessary if the proxy handles
    487.     #  SSL
    488.     #c.ServerApp.trust_xheaders = False
    489.  
    490.     ## Disable launching browser by redirect file For versions of notebook > 5.7.2, a
    491.     #  security feature measure was added that prevented the authentication token
    492.     #  used to launch the browser from being visible. This feature makes it difficult
    493.     #  for other users on a multi-user system from running code in your Jupyter
    494.     #  session as you. However, some environments (like Windows Subsystem for Linux
    495.     #  (WSL) and Chromebooks), launching a browser using a redirect file can lead the
    496.     #  browser failing to load. This is because of the difference in file
    497.     #  structures/paths between the runtime and the browser.
    498.     #  
    499.     #  Disabling this setting to False will disable this behavior, allowing the
    500.     #  browser to launch by using a URL and visible token (as before).
    501.     #c.ServerApp.use_redirect_file = True
    502.  
    503.     ## Specify where to open the server on startup. This is the `new` argument passed
    504.     #  to the standard library method `webbrowser.open`. The behaviour is not
    505.     #  guaranteed, but depends on browser support. Valid values are:
    506.     #  
    507.     #   - 2 opens a new tab,
    508.     #   - 1 opens a new window,
    509.     #   - 0 opens in an existing window.
    510.     #  
    511.     #  See the `webbrowser.open` documentation for details.
    512.     #c.ServerApp.webbrowser_open_new = 2
    513.  
    514.     ## Set the tornado compression options for websocket connections.
    515.     #  
    516.     #  This value will be returned from
    517.     #  :meth:`WebSocketHandler.get_compression_options`. None (default) will disable
    518.     #  compression. A dict (even an empty one) will enable compression.
    519.     #  
    520.     #  See the tornado docs for WebSocketHandler.get_compression_options for details.
    521.     #c.ServerApp.websocket_compression_options = None
    522.  
    523.     ## The base URL for websockets, if it differs from the HTTP server (hint: it
    524.     #  almost certainly doesn't).
    525.     #  
    526.     #  Should be in the form of an HTTP origin: ws[s]://hostname[:port]
    527.     #c.ServerApp.websocket_url = ''

     3-jupyter-class.yaml

    1. apiVersion: storage.k8s.io/v1
    2. kind: StorageClass
    3. metadata:
    4.   name: nfs-jupyterlab
    5.   namespace: jupyterlab
    6.   annotations:
    7.     storageclass.kubernetes.io/is-default-class: "false" ## 是否设置为默认的storageclass
    8. provisioner: k8s-sigs.io/nfs-subdir-external-provisioner # or choose another name, must match deployment's env PROVISIONER_NAME'
    9. #provisioner: nfs-subdir-external-provisioner # or choose another name, must match deployment's env PROVISIONER_NAME'
    10. parameters:
    11.   archiveOnDelete: "true"
    12.   pathPattern: "${.PVC.namespace}/${.PVC.name}/${.PVC.annotations.nfs.io/storage-path}"
    13.   # pathPattern: "${.PVC.namespace}/${.PVC.annotations.nfs.io/storage-path}"
    14.   # pathPattern: "${.PVC.namespace}-${.PVC.name}"

    5-pvc.yaml

    1. ---
    2. apiVersion: v1
    3. kind: PersistentVolumeClaim
    4. metadata:
    5.   name: nfs-jupyterlab
    6.   namespace: jupyterlab
    7.   annotations:
    8.     volume.beta.kubernetes.io/storage-class: "nfs-jupyterlab"
    9. spec:
    10.   accessModes:
    11.     - ReadWriteMany
    12.   resources:
    13.     requests:
    14.       storage: 50Mi

    6-jupyter-deployment.yaml

    1. apiVersion: apps/v1
    2. kind: Deployment
    3. metadata:
    4.   name: jupyterlab-deployment
    5.   namespace: jupyterlab
    6.   labels:
    7.     app1: jupyterlab
    8.     app.kubernetes.io/name: jupyterlab
    9. spec:
    10.   replicas: 1
    11.   selector:
    12.     matchLabels:
    13.       app1: jupyterlab
    14.       app.kubernetes.io/name: jupyterlab
    15.   template:
    16.     metadata:
    17.       labels:
    18.         app1: jupyterlab
    19.         app.kubernetes.io/name: jupyterlab
    20.     spec:
    21.       affinity:
    22.         nodeAffinity:
    23.           requiredDuringSchedulingIgnoredDuringExecution:
    24.             nodeSelectorTerms:
    25.               - matchExpressions:
    26.                   - key: kubernetes.io/hostname
    27.                     operator: NotIn
    28.                     values:
    29.                       - master01
    30.                       - master02
    31.                       - master03
    32.       hostNetwork: true
    33.       containers:
    34.         - name: jupyterlab
    35.           image: reporsitory:5000/jupyterlab:1.1
    36.           imagePullPolicy: Always
    37.           ports:
    38.             - name: jupyterlab
    39.               containerPort: 8888
    40.           command:
    41.             - bash
    42.             - "-c"
    43.             - |
    44.               set -ex
    45.               /usr/local/bin/jupyter-lab
    46.           resources:
    47.             requests:
    48.               cpu: 250m
    49.               memory: 500Mi
    50.             limits:
    51.               cpu: 250m
    52.               memory: 500Mi
    53.           volumeMounts:
    54.             - name: data
    55.               mountPath: "/home/jupyterlab/data"
    56.             - name: jupyter-config
    57.               mountPath: /root/.jupyter/
    58.             - name: jupyter
    59.               mountPath: /home/jupyterlab
    60.       volumes:
    61.         - name: data
    62.           persistentVolumeClaim:
    63.             claimName: nfs-jupyter-mysql
    64.         - name: jupyter
    65.           persistentVolumeClaim:
    66.             claimName: nfs-jupyterlab
    67.         - name: jupyter-config
    68.           configMap:
    69.             name: jupyter-config

    7-services.yaml

    1. ---
    2. apiVersion: v1
    3. kind: Service
    4. metadata:
    5.   name: jupyterlab-svc
    6.   namespace: jupyterlab
    7.   labels:
    8.     app1: jupyterlab
    9.     app.kubernetes.io/name: jupyterlab
    10. spec:
    11.   ports:
    12.     - name: jupyterlab
    13.       port: 8888
    14.   selector:
    15.     app1: jupyterlab
    16.   type: NodePort

     成功

    后端状况：

    网页访问：

    Jupyterlab服务的Pod提升

    部署kubectl + bash-completion

    在 Linux 系统中安装并设置 kubectl | Kubernetes

    使用 kubeconfig 文件组织集群访问 | Kubernetes

    更新数据库使用者权限

    1. grant all privileges on *.* to 'root'@'%' identified by '1' with grant option;
    2. flush privileges;

    参考文档

    https://developer.aliyun.com/article/857365
    https://www.jianshu.com/p/743ed2209a8c
    https://www.runoob.com/linux/linux-comm-nohup.html
    https://cloud.tencent.com/developer/article/1783227
    https://zhuanlan.zhihu.com/p/468585680

  • 相关阅读:
    新能源汽车行业资讯-2022-9-19
    设计模式之中介者模式
    基础讲解——ES6
    epiiAdmin框架注意事项
    List集合&UML图
    java子类向父类转型再转回子类
    老哥们平日是怎么排查线上问题的？
    No.1 - 职场关键角色通识宝典之课程内容先导
    一篇文章带你走进cookie，session，Token的世界
    java8 新特性
  • 原文地址：https://blog.csdn.net/m0_59267075/article/details/133981046