什么是前后端分离架构

前后端分离架构是一种软件架构模式，将系统的前端界面（通常是用户界面）和后端业务逻辑完全分离开发和部署。在前后端分离架构中，前端和后端通过 API（Application Programming Interface）进行通信，前端负责展示数据和用户交互，后端负责处理业务逻辑和数据存储。

以下是前后端分离架构的一些特点和优势：

  1. 解耦合性： 前后端分离架构将前端和后端彻底分离，降低了系统各个模块之间的耦合度，使得前端和后端可以独立开发、测试、部署和维护。
  2. 技术多样性： 前后端分离架构允许前端和后端使用不同的技术栈和编程语言进行开发，例如前端可以使用 JavaScript 框架（如React、Vue.js、Angular），后端可以使用各种后端语言和框架（如Node.js、Spring Boot、Django）。
  3. 性能优化： 前后端分离架构可以通过静态资源缓存、CDN 加速等技术来优化前端页面的加载速度和性能，提升用户体验。
  4. 灵活性和可扩展性： 前后端分离架构使得系统更加灵活和可扩展，可以根据需求动态调整前端和后端的资源，并且能够更容易地适应系统的变化和扩展。
  5. 团队协作： 前后端分离架构使得前端和后端团队可以独立工作，提高了团队的协作效率和开发效率。每个团队可以专注于自己擅长的领域，提高了开发质量和项目交付速度。
  6. 微服务架构支持： 前后端分离架构与微服务架构相互配合，可以更好地实现系统的模块化和分布式部署，使得系统更易于扩展、维护和升级。

总的来说，前后端分离架构是一种现代化的软件开发模式，能够提高系统的灵活性、可扩展性和开发效率，适用于各种规模和复杂度的Web应用开发。

为什么学前后端分离架构

学习前后端分离架构有多个方面的好处：

  1. 跟上行业趋势： 前后端分离架构是现代Web应用开发的主流趋势之一。了解和掌握这种架构模式可以让你跟上行业的发展方向，提高自己的竞争力。
  2. 提高开发效率： 前后端分离架构可以让前端和后端团队分别独立开发、测试和部署，大大提高了开发效率。团队成员可以专注于自己擅长的领域，减少了沟通和协调的成本。
  3. 灵活性和可维护性： 前后端分离架构将前端和后端解耦，降低了系统各个模块之间的耦合度，使得系统更加灵活和可维护。系统的变更和升级也更加容易和安全。
  4. 技术多样性： 前后端分离架构允许使用不同的技术栈和编程语言进行开发，例如前端可以使用各种JavaScript框架，后端可以使用各种后端语言和框架，这样可以根据需求选择最适合的技术栈。
  5. 提高用户体验： 前后端分离架构可以通过静态资源缓存、CDN加速等技术来优化前端页面的加载速度和性能，提高用户体验。
  6. 适应复杂业务需求： 对于复杂的业务需求和大型系统，前后端分离架构更加适用。它可以更好地支持系统的模块化和分布式部署，提高了系统的可扩展性和稳定性。

总的来说，学习前后端分离架构有助于提高你的技术水平和就业竞争力，让你能够更好地应对现代Web应用开发的挑战，并为未来的职业发展打下坚实的基础。

前后端分离架构详解

前后端分离架构是一种软件架构模式，将系统的前端界面（通常是用户界面）和后端业务逻辑完全分离开发和部署。在传统的单体架构中，前端和后端是紧密耦合的，前端页面直接与后端服务进行交互。而在前后端分离架构中，前端和后端通过 API（Application Programming Interface）进行通信，前端负责展示数据和用户交互，后端负责处理业务逻辑和数据存储。

以下是前后端分离架构的一些关键特点和组成部分：

  1. 前端（Client-side）：
    • 用户界面（UI）： 前端负责用户界面的设计和开发，包括页面布局、样式设计和交互效果等。
    • 数据展示： 前端从后端获取数据，并在页面上展示给用户。通常使用 HTML、CSS 和 JavaScript 等技术来实现数据展示和用户交互。
    • 前端框架和库： 前端开发可以借助各种框架和库，如React、Vue.js、Angular等，来简化开发流程和提高开发效率。
  2. 后端（Server-side）：
    • 业务逻辑： 后端负责处理业务逻辑，包括数据处理、验证、授权、存储等。
    • 数据存储： 后端通常与数据库交互，负责数据的读写和管理。常见的数据库包括MySQL、MongoDB、Redis等。
    • 后端框架和技术： 后端开发可以使用各种编程语言和框架，如Node.js、Spring Boot、Django等，来构建后端服务和API。
  3. 通信（Communication）：
    • API 接口： 前端和后端通过API进行通信。API定义了前后端之间的数据交换和通信规则，通常使用RESTful API或GraphQL等。
    • 数据格式： API通常使用JSON或XML等数据格式进行数据传输，前端通过HTTP请求调用后端API，并将数据展示给用户。
  4. 部署和维护（Deployment and Maintenance）：
    • 独立部署： 前后端可以独立部署和维护，分别部署在不同的服务器上，并独立扩展和升级。
    • 自动化部署： 可以使用自动化工具和持续集成/持续部署（CI/CD）流水线来自动化部署和测试。
  5. 安全性（Security）：
    • 身份验证和授权： 前后端通信需要进行身份验证和授权，以确保数据安全性和用户权限。
    • 数据加密： 敏感数据需要进行加密传输，以防止数据泄露和篡改。

前后端分离架构适用于各种规模和复杂度的Web应用开发，能够提高开发效率、灵活性和可维护性，是现代Web应用开发的主流趋势之一。

前后端分离架构面试答案

在面试中，关于前后端分离架构的问题可能涉及到架构原理、优势、组成部分、技术栈选择、实践经验等方面。以下是针对一些常见问题的简洁回答：

  1. 什么是前后端分离架构？

    前后端分离架构是一种软件架构模式，将系统的前端界面（通常是用户界面）和后端业务逻辑完全分离开发和部署。前端和后端通过 API 进行通信，实现了前后端的解耦。

  2. 前后端分离架构有哪些优势？

    • 提高开发效率：前后端团队可以独立开发、测试和部署，提高了开发效率。
    • 灵活性和可维护性：降低了系统各个模块之间的耦合度，使得系统更加灵活和可维护。
    • 技术多样性：允许使用不同的技术栈和编程语言进行开发，根据需求选择最适合的技术。
    • 提高用户体验：可以通过优化前端页面加载速度和性能来提高用户体验。
    • 适应复杂业务需求：更易于实现系统的模块化和分布式部署，提高了系统的可扩展性和稳定性。

  3. 前后端分离架构的组成部分是什么？

    • 前端（Client-side）：负责用户界面的设计和开发，包括页面布局、样式设计和交互效果等。
    • 后端（Server-side）：负责处理业务逻辑、数据存储和与前端的通信。
    • 通信（Communication）：前后端通过 API 进行通信，API 定义了数据交换和通信规则。
    • 部署和维护（Deployment and Maintenance）：前后端可以独立部署和维护，分别部署在不同的服务器上。

  4. 在前后端分离架构中，如何进行前后端通信？

    前后端通信通常通过 API 进行。前端通过 HTTP 请求调用后端 API，并将数据展示给用户。API 可以使用 RESTful API 或 GraphQL 等方式定义，通常使用 JSON 或 XML 等数据格式进行数据传输。

  5. 你有前后端分离架构的实践经验吗？

    在回答这个问题时，可以分享你在项目中的具体实践经验，包括使用的技术栈、遇到的挑战和解决方案、团队协作方式等。重点突出你的角色和贡献，以及项目的成果和效果。

这些简洁的回答可以作为面试中对前后端分离架构相关问题的参考。在回答问题时，尽量简明扼要地表达自己的理解和经验，突出重点，让面试官对你的理解和实践能力有一个清晰的了解。

常见前后端分离软件

前后端分离架构在现代Web应用开发中得到了广泛应用，有许多常见的软件和工具可供选择。以下是一些常见的前后端分离软件和工具：

  1. 前端框架和库：
    • React.js：由 Facebook 开发的 JavaScript 库，用于构建用户界面。
    • Vue.js：一套用于构建用户界面的渐进式框架，易于上手和学习。
    • Angular：Google 开发的前端框架，用于构建单页应用。
    • jQuery：快速、简洁的 JavaScript 库，简化了 HTML 文档遍历、事件处理、动画等操作。
  2. 后端框架和技术：
    • Node.js：基于 Chrome V8 引擎的 JavaScript 运行时环境，用于构建高性能的网络应用。
    • Spring Boot：Java 平台的快速开发框架，用于构建基于 Spring 的企业级应用。
    • Django：Python 编程语言的 Web 开发框架，提供了强大的数据库访问、模板引擎等功能。
    • Flask：Python 编程语言的轻量级 Web 框架，简单、灵活。
  3. API 开发工具：
    • Swagger：API 文档生成工具，可以通过注解或配置文件生成 API 文档，并提供了交互式的 API 测试工具。
    • Postman：用于测试 API 的强大工具，支持各种 HTTP 请求，可以创建和共享测试集合，进行自动化测试等。
  4. 版本控制工具：
    • Git：分布式版本控制系统，用于管理代码的版本、协作开发和版本控制。
  5. 自动化部署和持续集成工具：
    • Jenkins：开源的自动化服务器，用于实现持续集成和持续部署。
    • Travis CI：持续集成服务，可以与 GitHub 等代码托管平台集成，自动构建和测试代码。
  6. 前端构建工具：
    • Webpack：用于打包和构建前端项目的模块打包工具，支持代码分割、加载器、插件等功能。
    • Babel：JavaScript 编译器，用于将 ES6+ 代码转换为向后兼容的 JavaScript 代码。

以上是一些常见的前后端分离软件和工具，可以根据项目需求和团队技术栈选择合适的工具和技术。

什么是Jumpserver

Jumpserver 是一个开源的堡垒机系统，用于管理和控制服务器远程访问权限。它提供了安全的跳板机访问方式，帮助管理者集中管理服务器访问权限，加强对服务器的安全管理。

Jumpserver 的主要功能包括：

  1. 用户和权限管理： 提供灵活的用户和权限管理功能，管理员可以根据需要分配用户角色和权限，限制用户对服务器的操作权限。
  2. 远程访问控制： 提供安全的远程访问控制功能，管理员可以配置白名单、黑名单等规则，限制用户对服务器的远程访问。
  3. 审计和日志记录： 记录用户的操作日志和审计日志，管理员可以查看用户的操作记录，追踪敏感操作和异常行为。
  4. 资源管理： 管理员可以管理服务器资源和资产信息，包括服务器的基本信息、网络配置、运行状态等。
  5. 集中管理： 提供集中式的管理界面，管理员可以在一个平台上管理多个服务器，方便统一管理和监控。
  6. 可扩展性： Jumpserver 提供了丰富的插件和扩展机制，可以根据需要定制和扩展功能。

Jumpserver 是一个功能强大、灵活且易于使用的堡垒机系统，广泛应用于企业和组织中，帮助管理员加强对服务器的安全管理和控制。

为什么学Jumpserver

学习 Jumpserver 有几个重要的理由：

  1. 加强服务器安全管理： Jumpserver 是一个堡垒机系统，可以帮助管理者加强对服务器的安全管理。通过 Jumpserver，可以集中管理服务器的访问权限、审计用户操作、限制用户权限等，有效防止未经授权的访问和操作。
  2. 提高运维效率： Jumpserver 提供了集中式的管理界面，管理员可以在一个平台上管理多个服务器，方便快捷地进行服务器的远程访问和管理。这可以大大提高运维效率，减少了手动操作和管理的成本。
  3. 规范化操作流程： Jumpserver 提供了丰富的权限管理和审计功能，可以规范用户的操作行为，保证操作的合规性和安全性。管理员可以根据实际需求配置用户的权限和操作规则，确保服务器的安全运行。
  4. 学习安全管理和审计技术： Jumpserver 的学习可以帮助开发者了解和掌握安全管理和审计技术，包括用户权限管理、远程访问控制、操作审计等方面的知识和技能，有助于提升自己在安全领域的专业能力。
  5. 应对复杂的系统架构： 在现代复杂的系统架构中，服务器数量庞大，分布在不同的地区和网络环境中，管理和维护变得非常复杂和困难。Jumpserver 可以帮助管理员应对这种复杂性，提供统一的管理平台，简化管理流程，提高管理效率。

综上所述，学习 Jumpserver 对于加强服务器安全管理、提高运维效率、规范化操作流程、学习安全管理和审计技术以及应对复杂的系统架构等方面都具有重要意义，对于从事系统管理、运维、安全等领域的人员都是非常有价值的。

Jumpserver详解

Jumpserver 是一个开源的堡垒机系统，用于管理和控制服务器的远程访问权限。它提供了安全的跳板机访问方式，帮助管理者集中管理服务器访问权限，加强对服务器的安全管理。以下是 Jumpserver 的详细解释：

  1. 用户和权限管理： Jumpserver 提供了灵活的用户和权限管理功能，管理员可以根据需要创建用户、角色和权限，设置用户的访问权限和操作范围，实现精细化的权限控制。
  2. 远程访问控制： Jumpserver 提供了安全的远程访问控制功能，管理员可以配置白名单、黑名单等规则，限制用户对服务器的远程访问。用户可以通过 Jumpserver 提供的 Web 界面或 SSH、RDP 等协议进行远程访问。
  3. 审计和日志记录： Jumpserver 记录用户的操作日志和审计日志，管理员可以查看用户的操作记录，了解用户的操作行为，追踪敏感操作和异常行为，确保服务器的安全性和合规性。
  4. 资源管理： Jumpserver 提供了服务器资源和资产管理功能，管理员可以管理服务器的基本信息、网络配置、运行状态等，方便统一管理和监控服务器资源。
  5. 集中管理： Jumpserver 提供了集中式的管理界面，管理员可以在一个平台上管理多个服务器，统一管理用户、权限、资源和审计日志，简化了管理流程，提高了管理效率。
  6. 可扩展性： Jumpserver 提供了丰富的插件和扩展机制，可以根据需要定制和扩展功能，满足不同场景下的需求。

总的来说，Jumpserver 是一个功能强大、灵活且易于使用的堡垒机系统，广泛应用于企业和组织中，帮助管理员加强对服务器的安全管理和控制。 Jumpserver 的学习和应用可以提高服务器安全性，提高运维效率，规范操作流程，有助于加强系统管理和安全管理能力。

Jumpserver面试题答案

以下是针对 Jumpserver 的一些可能的面试题及其答案：

  1. 什么是 Jumpserver？

    Jumpserver 是一个开源的堡垒机系统，用于管理和控制服务器的远程访问权限。

  2. Jumpserver 的主要功能有哪些？

    • 用户和权限管理
    • 远程访问控制
    • 审计和日志记录
    • 资源管理
    • 集中管理
    • 可扩展性

  3. 为什么需要使用 Jumpserver？

    Jumpserver 可以帮助管理者加强对服务器的安全管理，集中管理服务器访问权限、审计用户操作、限制用户权限等，有效防止未经授权的访问和操作。

  4. Jumpserver 如何实现远程访问控制？

    Jumpserver 提供了安全的远程访问控制功能，管理员可以配置白名单、黑名单等规则，限制用户对服务器的远程访问。

  5. Jumpserver 如何实现审计和日志记录？

    Jumpserver 记录用户的操作日志和审计日志，管理员可以查看用户的操作记录，了解用户的操作行为，追踪敏感操作和异常行为。

  6. Jumpserver 的架构是什么样的？

    Jumpserver 的架构包括前端界面、后端服务和数据库，前端界面提供用户操作界面，后端服务负责处理业务逻辑和与数据库交互。

  7. Jumpserver 如何进行用户和权限管理？

    Jumpserver 提供了灵活的用户和权限管理功能，管理员可以根据需要创建用户、角色和权限，设置用户的访问权限和操作范围。

  8. Jumpserver 如何实现资源管理？

    Jumpserver 提供了服务器资源和资产管理功能，管理员可以管理服务器的基本信息、网络配置、运行状态等，方便统一管理和监控服务器资源。

以上是一些关于 Jumpserver 的可能面试题及其答案，可以根据实际情况和深度进一步展开讨论。

部署文档

https://docs.jumpserver.org/zh/v3/

源码编译jumpserver v3

https://docs.jumpserver.org/zh/v3/installation/source_install/requirements/

组件解释

https://github.com/jumpserver

image-20240402173157253

core部署

JumpServer Core 是 JumpServer 的核心组件，它负责管理和控制整个系统的运行。下面是对 JumpServer Core 的详细解释：

  1. 身份验证和访问控制： JumpServer Core 管理用户身份验证和访问控制。它处理用户登录、身份验证和授权，确保只有经过授权的用户才能访问系统的特定功能和资源。
  2. 资源管理： JumpServer Core 负责管理和维护系统中的各种资源，包括主机、账户、密钥、访问日志等。它提供了一套管理界面和 API，使管理员能够轻松地添加、修改和删除这些资源。
  3. 会话管理： JumpServer Core 负责管理用户与目标主机之间的会话。它记录用户对目标主机的访问请求，并确保会话的安全性和可追溯性。
  4. 审计和日志： JumpServer Core 支持对系统的操作进行审计和日志记录。它记录用户的操作行为，包括登录、访问控制、资源管理等，以便管理员能够跟踪和审查用户的操作历史。
  5. 插件系统： JumpServer Core 提供了一个灵活的插件系统，允许用户根据自己的需求扩展系统的功能。用户可以编写自定义插件，并将其集成到系统中，以满足特定的业务需求。
  6. 任务调度： JumpServer Core 支持对任务进行调度和执行。它能够自动执行定时任务、计划任务和事件触发任务，并监控任务的执行情况和结果。
  7. 通知和报警： JumpServer Core 支持向用户发送通知和报警消息。它能够通过电子邮件、短信、即时通讯等方式向用户发送消息，并提醒用户关注重要事件和异常情况。

总的来说，JumpServer Core 是 JumpServer 的核心引擎，它提供了一套完整的管理和控制功能，帮助用户轻松地管理和监控系统中的资源和任务。

下载core

# 进入 /opt 目录
cd /opt

# 创建 Jumpserver 文件夹
mkdir /opt/jumpserver-3.10.7

# 下载 Jumpserver v3.10.7 版本压缩包，并保存为 jumpserver-3.10.7.tar.gz 文件
wget -O /opt/jumpserver-3.10.7.tar.gz https://github.com/jumpserver/jumpserver/archive/refs/tags/v3.10.7.tar.gz

# 解压 Jumpserver 压缩包到 /opt/jumpserver-3.10.7 目录，并去除一级文件夹
tar -xf jumpserver-3.10.7.tar.gz -C /opt/jumpserver-3.10.7 --strip-components 1

# 进入 jumpserver-3.10.7 目录
cd jumpserver-3.10.7

# 删除原始的 GeoLite2-City.mmdb 和 ipipfree.ipdb 文件
rm -f apps/common/utils/ip/geoip/GeoLite2-City.mmdb apps/common/utils/ip/ipip/ipipfree.ipdb

# 下载新的 GeoLite2-City.mmdb 和 ipipfree.ipdb 文件
wget https://download.jumpserver.org/files/ip/GeoLite2-City.mmdb -O apps/common/utils/ip/geoip/GeoLite2-City.mmdb
wget https://download.jumpserver.org/files/ip/ipipfree.ipdb -O apps/common/utils/ip/ipip/ipipfree.ipdb




GeoLite2-City.mmdb 是 MaxMind 公司提供的一个 IP 地址数据库文件，用于实现 IP 地址到地理位置的映射。MaxMind 是一家专门提供 IP 地址地理位置定位服务的公司，他们收集了大量的 IP 地址数据，并根据这些数据整理出了包含地理位置信息的数据库文件。

具体来说，GeoLite2-City.mmdb 文件包含了 IP 地址到地理位置（国家、地区、城市、经纬度等）的映射关系，通过查询这个文件，可以根据用户的 IP 地址确定其大致的地理位置信息。这样的功能在网络应用中非常常见，例如在网站分析、用户行为跟踪、内容定位等方面都有应用。

需要注意的是，GeoLite2-City.mmdb 文件是根据 MaxMind 公司整理的数据生成的，虽然提供了相当准确的地理位置信息，但也可能存在一定的误差。此外，MaxMind 公司还提供了更高级的商业版数据库文件，如 GeoIP2 City 数据库，提供更精确的地理位置信息和更多的数据字段。

core目录

root@yu:/opt/jumpserver-3.10.7# ls
apps                data           entrypoint.sh  poetry.lock     requirements   ui
CODE_OF_CONDUCT.md  Dockerfile-ce  GITSHA         pyproject.toml  run_server.py  utils
config_example.yml  Dockerfile-ee  jms            README_EN.md    SECURITY.md
CONTRIBUTING.md     docs           LICENSE        README.md       tmp
root@yu:/opt/jumpserver-3.10.7# ls requirements/
apk_pkg.sh  deb_pkg.sh  issues.txt  mac_pkg.sh  rpm_pkg.sh

这里列出了 Jumpserver v3.10.7 版本的目录结构及其说明：

  • apps/: 存放 Jumpserver 应用程序的代码。
  • data/: 存放 Jumpserver 的数据文件。
  • entrypoint.sh: 启动脚本，用于初始化环境并启动 Jumpserver。
  • poetry.lock: Poetry 锁文件，记录了 Jumpserver 所需的 Python 包的精确版本信息。
  • requirements/: 存放 Jumpserver 的依赖安装脚本和相关说明。
    • apk_pkg.sh: 用于在 Alpine Linux 上安装 Jumpserver 依赖的脚本。
    • deb_pkg.sh: 用于在 Debian/Ubuntu Linux 上安装 Jumpserver 依赖的脚本。
    • issues.txt: 记录了与安装 Jumpserver 相关的已知问题。
    • mac_pkg.sh: 用于在 macOS 上安装 Jumpserver 依赖的脚本。
    • rpm_pkg.sh: 用于在 Red Hat/CentOS/Fedora Linux 上安装 Jumpserver 依赖的脚本。
  • ui/: 存放 Jumpserver 的前端界面代码。
  • CODE_OF_CONDUCT.md: Jumpserver 的行为准则文件。
  • Dockerfile-ce: 用于构建 Jumpserver Community Edition Docker 镜像的 Dockerfile。
  • GITSHA: 记录了当前 Git 提交的 SHA 值。
  • pyproject.toml: Poetry 项目文件，定义了 Jumpserver 项目的元数据和依赖。
  • run_server.py: Jumpserver 启动脚本。
  • utils/: 存放 Jumpserver 的工具脚本和辅助文件。
  • config_example.yml: Jumpserver 的配置示例文件。
  • Dockerfile-ee: 用于构建 Jumpserver Enterprise Edition Docker 镜像的 Dockerfile。
  • jms/: 存放 Jumpserver 的管理命令脚本。
  • README_EN.md: Jumpserver 的英文说明文档。
  • SECURITY.md: Jumpserver 的安全相关说明文档。
  • CONTRIBUTING.md: Jumpserver 的贡献指南文件。
  • docs/: 存放 Jumpserver 的文档。
  • LICENSE: Jumpserver 的许可证文件。
  • README.md: Jumpserver 的说明文档。
  • tmp/: 临时目录，存放一些临时文件和数据。

这些目录和文件包含了 Jumpserver 的源代码、依赖安装脚本、配置文件、说明文档等内容，用于管理和运行 Jumpserver 应用。

root@yu:/opt/jumpserver-3.10.7# cat requirements/deb_pkg.sh 
#!/bin/bash
apt install \
    g++ make iputils-ping default-libmysqlclient-dev libpq-dev \
    libffi-dev libldap2-dev libsasl2-dev openssh-client sshpass pkg-config libxml2-dev \
    libxmlsec1-dev libxmlsec1-openssl libaio-dev freetds-dev freerdp2-dev
root@yu:/opt/jumpserver-3.10.7#

这个命令是在 Debian/Ubuntu 系统上使用 apt 包管理器安装一系列软件包。下面是各个软件包的说明和用途：

  • g++: GNU C++ 编译器，用于编译 C++ 程序。
  • make: GNU make 工具，用于自动化构建软件项目。
  • iputils-ping: 包含了 ping 命令等网络诊断工具，用于测试主机之间的连通性。
  • default-libmysqlclient-dev: MySQL 客户端库的默认开发文件，用于开发与 MySQL 数据库的应用程序。
  • libpq-dev: PostgreSQL 客户端库的开发文件，用于开发与 PostgreSQL 数据库的应用程序。
  • libffi-dev: libffi 库的开发文件，用于调用 C 语言函数。
  • libldap2-dev: LDAP 协议库的开发文件，用于与 LDAP 目录服务交互。
  • libsasl2-dev: Cyrus SASL 库的开发文件，用于提供安全的身份验证和数据传输机制。
  • openssh-client: SSH 客户端程序，用于连接到远程服务器并进行安全的远程访问。
  • sshpass: 一个用于提供密码给 ssh 命令的实用程序，用于在脚本中自动输入密码进行 SSH 登录。
  • pkg-config: 用于管理编译时的软件包元数据，通常与开发软件包一起使用。
  • libxml2-dev: libxml2 库的开发文件，用于解析和处理 XML 文档。
  • libxmlsec1-dev: XML 安全性库的开发文件，用于处理 XML 签名、加密等安全相关的操作。
  • libxmlsec1-openssl: libxmlsec1 库的 OpenSSL 加密支持模块。
  • libaio-dev: Linux 异步 I/O (AIO) 库的开发文件，用于异步 I/O 操作。
  • freetds-dev: FreeTDS 库的开发文件，用于与 Microsoft SQL Server 和 Sybase 数据库进行通信。
  • freerdp2-dev: FreeRDP 库的开发文件，用于远程桌面协议的实现。

通过安装这些软件包，可以满足 Jumpserver 编译和运行所需的依赖项。

系统依赖

apt-get install -y pkg-config libxmlsec1-dev libpq-dev libffi-dev libxml2 libxslt-dev libldap2-dev libsasl2-dev sshpass mariadb-client bash-completion g++ make sshpass

这个命令是在 Ubuntu 或 Debian 系统上使用 apt-get 包管理器安装一系列软件包。以下是各个软件包的说明和用途：

  • pkg-config: 用于管理编译时的软件包元数据，通常与开发软件包一起使用。
  • libxmlsec1-dev: XML 安全性库的开发文件，用于处理 XML 签名、加密等安全相关的操作。
  • libpq-dev: PostgreSQL 客户端库的开发文件，用于开发与 PostgreSQL 数据库的应用程序。
  • libffi-dev: libffi 库的开发文件，用于调用 C 语言函数。
  • libxml2: XML 解析器库，用于解析和处理 XML 文档。
  • libxslt-dev: XSLT 转换库的开发文件，用于对 XML 进行 XSLT 转换。
  • libldap2-dev: LDAP 协议库的开发文件，用于与 LDAP 目录服务交互。
  • libsasl2-dev: Cyrus SASL 库的开发文件，用于提供安全的身份验证和数据传输机制。
  • sshpass: 一个用于提供密码给 ssh 命令的实用程序，用于在脚本中自动输入密码进行 SSH 登录。
  • mariadb-client: MariaDB 数据库的客户端程序，用于连接到 MariaDB 数据库服务器。
  • bash-completion: Bash 命令自动完成功能的扩展，提供了在命令行中使用 Tab 键补全命令的功能。
  • g++: GNU C++ 编译器，用于编译 C++ 程序。
  • make: GNU make 工具，用于自动化构建软件项目。

这些软件包通常是开发和运行 Jumpserver 所需的依赖项，通过安装这些软件包，可以满足 Jumpserver 应用程序的编译、运行和依赖需求。

python3.11编译安装

要在系统上编译安装 Python 3.11，你可以按照以下步骤进行：

  1. 下载 Python 源代码： 首先，你需要从 Python 官方网站下载 Python 3.11 的源代码压缩包。你可以在 https://www.python.org/downloads/ 找到最新版本的 Python 源代码。

  2. 解压源代码： 下载完成后，在你选择的目录下解压 Python 源代码压缩包。

  3. ``` 编译工具：

    build-essential: 这是一个包含了编译工具的软件包，包括 gcc、g++、make 等。 库文件和开发文件：

    libssl-dev: OpenSSL 库的开发文件，用于加密和解密操作。 zlib1g-dev: zlib 库的开发文件，用于数据压缩和解压。 libsqlite3-dev: SQLite3 数据库的开发文件，用于支持 SQLite3。 libreadline-dev: GNU Readline 库的开发文件，用于提供命令行编辑功能。 libbz2-dev: bzip2 库的开发文件，用于支持 bzip2 压缩格式。 libncurses5-dev: ncurses 库的开发文件，用于提供文本终端界面。 libgdbm-dev: GNU dbm 库的开发文件，用于支持 GNU 数据库管理系统。 liblzma-dev: XZ Utils 库的开发文件，用于支持 XZ 压缩格式。 uuid-dev: UUID 库的开发文件，用于支持 Universally Unique Identifiers。 其他依赖：

    tk-dev: Tk 图形库的开发文件，用于支持 Tkinter 图形界面库。 libffi-dev: libffi 库的开发文件，用于调用 C 语言函数。 libdb-dev: Berkeley DB 库的开发文件，用于支持 Berkeley 数据库。

    #

wget https://www.python.org/ftp/python/3.11.0/Python-3.11.0.tgz

sudo apt-get update sudo apt-get install -y build-essential libssl-dev zlib1g-dev libsqlite3-dev \ libreadline-dev libbz2-dev libncurses5-dev libgdbm-dev \ liblzma-dev uuid-dev tk-dev libffi-dev libdb-dev

./configure --prefix=/opt/py3.11


4. **进入解压后的目录：** 使用 cd 命令进入解压后的 Python 源代码目录。

cd Python-3.11


5. **配置编译选项：** 运行 configure 脚本以配置编译选项，可以根据需要添加或删除选项。以下是一个常用的配置示例：

./configure --enable-optimizations


   这个选项启用了优化编译，会提高 Python 的性能。你可以根据需要添加其他选项，比如指定安装路径等。

6. **编译源代码：** 运行 make 命令编译 Python 源代码。

make -j 4


   `-j` 选项用于指定并行编译的任务数，可以根据你的系统配置进行调整。

7. **安装 Python：** 运行 make install 命令安装编译后的 Python。

make install


   这将安装 Python 到系统默认的位置，如果需要安装到其他位置，可以使用 `--prefix` 参数指定安装路径。

8. **检查安装结果：** 安装完成后，运行以下命令验证 Python 是否成功安装。

python11--version


   如果成功安装，会输出 Python 3.11的版本信息。

9. **配置环境变量（可选）：** 如果希望在命令行中直接使用 python3.11命令启动 Python 3.11 解释器，可以将安装路径下的 bin 目录添加到 PATH 环境变量中。

至此，你已经成功在系统上编译安装了 Python 3.11。如果在安装过程中遇到任何问题，可以查看编译日志或者参考 Python 官方文档中的安装指南。



### configure过程解释

在编译软件时，经常会使用 `configure` 脚本来配置编译选项和检查系统环境。这个过程通常包括以下几个步骤：

1. **检查系统环境：** `configure` 脚本会检查系统环境，包括操作系统类型、处理器架构、已安装的软件包等，以确定编译过程中的一些默认设置和限制。
2. **检查依赖项：** `configure` 脚本会检查系统中已安装的依赖项和库文件，以确保所需的依赖项已满足，并且可以在编译过程中正确使用。
3. **设置编译选项：** `configure` 脚本会根据系统环境和用户的配置选择合适的编译选项，包括编译器、编译器选项、安装路径等。
4. **生成 Makefile：** `configure` 脚本会根据用户的配置生成一个 Makefile 文件，用于指导编译过程。Makefile 包含了编译过程中所需的命令和规则，以及编译选项的设置。
5. **检查结果：** `configure` 脚本通常会输出一些配置信息和警告信息，以及一些需要用户注意的信息。用户可以根据这些信息检查配置是否正确，并根据需要修改配置选项。

总的来说，`configure` 过程是编译软件的准备阶段，它根据系统环境和用户的配置生成一个合适的编译环境，并为后续的编译过程做好准备。通过正确配置 `configure` 脚本，可以确保软件能够顺利编译并在目标系统上正确运行。

### make过程

`make` 是一个工具，用于根据 Makefile 文件中的规则来构建软件项目。在编译软件时，通常会使用 `make` 工具来执行编译过程。下面是 `make` 过程的一般步骤：

1. **读取 Makefile：** `make` 工具会读取当前目录下的名为 Makefile 或 makefile 的文件，其中包含了编译过程所需的规则、依赖关系和命令。
2. **分析规则：** `make` 工具会分析 Makefile 中的规则，确定哪些文件需要被构建，以及它们之间的依赖关系。
3. **执行命令：** 根据规则和依赖关系，`make` 工具会执行相应的命令来构建目标文件。这些命令通常包括编译源代码、链接目标文件、生成可执行文件等。
4. **并行编译（可选）：** 如果 Makefile 中使用了 `-j` 选项，`make` 工具会并行执行多个命令，以加快编译速度。该选项后面可以跟一个数字，表示同时执行的任务数。
5. **检查结果：** 在编译过程结束后，`make` 工具会检查编译的结果，查看是否成功生成了目标文件和可执行文件。如果编译过程出现错误，`make` 工具会显示相应的错误信息，并中止编译过程。

总的来说，`make` 过程是编译软件的核心阶段，它根据 Makefile 中的规则和命令来执行编译过程，生成目标文件和可执行文件。通过正确编写和配置 Makefile 文件，可以确保软件能够顺利编译并生成正确的输出。

running build_scripts creating build/scripts-3.9 copying and adjusting /opt/Python-3.11/Tools/scripts/pydoc3 -> build/scripts-3.9 copying and adjusting /opt/Python-3.11/Tools/scripts/idle3 -> build/scripts-3.9 copying and adjusting /opt/Python-3.11/Tools/scripts/2to3 -> build/scripts-3.9 changing mode of build/scripts-3.9/pydoc3 from 644 to 755 changing mode of build/scripts-3.9/idle3 from 644 to 755 changing mode of build/scripts-3.9/2to3 from 644 to 755 renaming build/scripts-3.9/pydoc3 to build/scripts-3.9/pydoc3.9 renaming build/scripts-3.9/idle3 to build/scripts-3.9/idle3.9 renaming build/scripts-3.9/2to3 to build/scripts-3.9/2to3-3.9



这段输出是在构建 Python 3.11 时生成可执行脚本的过程。在这个过程中，Python 的一些工具脚本被复制到了指定的目录，并进行了调整。

具体来说，以下是发生了什么：

1. `pydoc3`、`idle3` 和 `2to3` 这些脚本被复制到了 `build/scripts-3.9` 目录中。
2. 脚本的文件权限被修改为可执行权限，即从 644 修改为 755。
3. 脚本的文件名也做了一些调整：
   - `pydoc3` 被重命名为 `pydoc3.9`
   - `idle3` 被重命名为 `idle3.9`
   - `2to3` 被重命名为 `2to3-3.9`

这些步骤的目的是将这些 Python 工具脚本准备好，以便用户可以在安装 Python 后直接使用它们。例如，`pydoc3.9` 是 Python 3.9 版本的文档查看器，`idle3.9` 是 Python 3.9 版本的集成开发环境 (IDE)，`2to3-3.9` 是 Python 3.9 版本的 2to3 工具，用于将 Python 2 代码转换为 Python 3 代码。

### make install过程

`make install` 是在编译软件项目之后，用于将编译生成的可执行文件、库文件和其他必要文件安装到系统中的指定位置的命令。以下是 `make install` 过程的一般步骤：

1. **执行安装命令：** 当用户在编译完成后运行 `make install` 命令时，系统会执行 Makefile 中指定的安装命令。这些命令通常包括将编译生成的文件复制到目标安装路径，并设置相应的权限。
2. **复制文件：** `make install` 会将编译生成的可执行文件、库文件、头文件以及其他必要的文件复制到系统中指定的安装路径。这些文件通常包括程序的可执行文件、库文件、配置文件等。
3. **设置权限：** 在复制文件到目标安装路径之后，`make install` 通常会设置相应文件的权限，以确保这些文件可以被正确访问和执行。这些权限设置通常是根据软件的安全要求和用户的需求来确定的。
4. **更新系统配置：** 在一些情况下，`make install` 还会更新系统的配置文件或注册表项，以使新安装的软件能够被系统正确识别和使用。这些配置可能包括环境变量、路径设置等。
5. **完成安装：** 当 `make install` 执行完毕后，软件就被成功安装到系统中了。用户可以通过命令行或图形界面来启动安装的软件，并开始使用它。

总的来说，`make install` 过程是将编译生成的软件安装到系统中的关键步骤，它确保软件能够被正确安装和配置，并在系统中正常运行。通过正确执行 `make install` 命令，用户可以将编译好的软件安装到系统中，并开始使用它。

### 环境变量添加

root@yu:/opt/Python-3.11# tail -1 ~/.bashrc export PATH=$PATH:/opt/py3.11/bin


这行命令将 `/opt/py3.11/bin` 目录添加到了环境变量 `PATH` 中，这样系统就能够在命令行中找到位于该目录下的可执行文件。通常情况下，这种操作用于将新安装的软件的可执行文件路径添加到系统的环境变量中，以便用户能够直接在命令行中运行这些软件。

在这个命令中：

- `export PATH=`：表示将要设置环境变量 `PATH`。
- `$PATH`：表示当前 `PATH` 变量的值，这样就可以在新的 `PATH` 值中包含原有的 `PATH` 值。
- `:/opt/py3.11/bin`：表示要追加到 `PATH` 变量中的路径，即 `/opt/py3.11/bin` 目录，该目录中存放着 Python 3.11 的可执行文件。

通过将这个路径添加到 `PATH` 中，用户就可以直接在命令行中运行 Python 3.11 的可执行文件，而不需要指定完整的路径。

root@yu:/opt/Python-3.11.0# tail -1 ~/.bashrc export PATH=$PATH:/opt/py3.11/bin

root@yu:/opt/Python-3.11.0# python3.11 Python 3.11.0 (main, Apr 2 2024, 08:06:10) [GCC 11.4.0] on linux Type "help", "copyright", "credits" or "license" for more information.

import readline readline

readline.asd KeyboardInterrupt

root@yu:/opt/Python-3.11.0# 



这个输出表明你已经成功地将 Python 3.11 添加到了系统的环境变量中，并且可以在命令行中直接使用。具体来说：

1. 通过 `source ~/.bashrc` 命令，你重新加载了 `.bashrc` 文件，使之前添加到该文件中的环境变量生效。
2. 接着，你输入了 `python3.11` 命令，成功地启动了 Python 3.11 解释器。输出中显示了 Python 3.11 的版本信息以及相关的编译信息。
3. 之后，你尝试导入了 `readline` 模块，并打印了该模块的路径。可以看到，`readline` 模块是从 Python 3.11 的安装路径下加载的。

## venv解释

`venv` 是 Python 中用于创建虚拟环境的模块，它可以帮助你在项目中创建一个独立的 Python 运行环境，用于隔离不同项目之间的依赖关系，使得每个项目都可以使用自己独立的 Python 环境和依赖包，而不会相互干扰。以下是关于 `venv` 的一些详解：

1. **虚拟环境的创建：** 使用 `venv` 模块可以轻松地创建一个新的虚拟环境。你只需在命令行中执行 `python -m venv <venv_name>`，其中 `<venv_name>` 是你想要创建的虚拟环境的名称。
2. **独立的 Python 解释器：** 每个虚拟环境都包含了一个独立的 Python 解释器，这个解释器是在创建虚拟环境时自动生成的。这意味着你可以在每个项目中使用不同版本的 Python 解释器，而不会相互影响。
3. **独立的库和依赖包：** 每个虚拟环境都有自己独立的 `site-packages` 目录，用于存放该环境下安装的 Python 库和依赖包。这意味着你可以在不同项目中安装不同版本的库，而不会发生冲突。
4. **依赖隔离：** 虚拟环境可以帮助你隔离项目之间的依赖关系，使得每个项目都可以使用自己特定的依赖包版本。这样一来，就不会因为一个项目更新了依赖包版本而导致其他项目出现兼容性问题。
5. **激活和退出虚拟环境：** 在 Linux 和 macOS 系统中，可以使用 `source <venv_name>/bin/activate` 命令来激活虚拟环境；在 Windows 系统中，可以使用 `<venv_name>\Scripts\activate.bat` 命令。激活虚拟环境后，命令行提示符会发生变化，以提示你已经进入了虚拟环境。要退出虚拟环境，只需执行 `deactivate` 命令即可。

总的来说，`venv` 是 Python 中用于管理虚拟环境的强大工具，它使得项目开发变得更加简单和可靠。通过合理使用虚拟环境，你可以避免项目之间的依赖冲突，提高项目的可维护性和可移植性。

root@yu:/opt/Python-3.11# python3.11 -m venv /opt/venv-3.11




这个命令创建了一个名为 `/opt/py3` 的虚拟环境。让我们来解释一下结果：

- `bin` 目录包含了虚拟环境的可执行文件，例如 Python 解释器、pip 等。
- `include` 目录通常包含了 C 语言头文件，用于编译 Python 模块。
- `lib` 目录包含了虚拟环境的标准库和第三方库。
- `lib64` 目录是在一些 64 位系统上存放库文件的目录，如果你的系统是 32 位的，可能会是 `lib32`。
- `pyvenv.cfg` 文件包含了关于虚拟环境配置的信息，例如 Python 解释器的路径、创建时间等。

这些目录和文件组成了一个完整的 Python 虚拟环境，你可以在这个环境中安装依赖包、运行 Python 程序等。要开始使用这个虚拟环境，你可以激活它，例如在 Linux 或 macOS 上执行以下命令：

root@yu:~# python3.11 -m venv /opt/venv-3.11 root@yu:~# source /opt/venv-3.11/bin/activate (venv-3.11) root@yu:~# 


激活虚拟环境后，你会看到命令行提示符发生了变化，表明你已经进入了虚拟环境。在这个环境中，你可以安装依赖包、运行 Python 程序等。完成工作后，可以使用 `deactivate` 命令退出虚拟环境。

### pip详解

`pip` 是 Python 的包管理工具，用于安装、卸载、升级和管理 Python 包。以下是关于 `pip` 的一些详解：

1. **安装包：** 使用 `pip install` 命令可以安装 Python 包。例如，要安装名为 `requests` 的包，可以执行 `pip install requests`。
2. **卸载包：** 使用 `pip uninstall` 命令可以卸载已安装的 Python 包。例如，要卸载名为 `requests` 的包，可以执行 `pip uninstall requests`。
3. **查看已安装包：** 使用 `pip list` 命令可以列出当前系统中已安装的 Python 包。
4. **查看包详情：** 使用 `pip show` 命令可以查看特定包的详细信息，包括版本号、作者、依赖关系等。例如，要查看名为 `requests` 的包的详细信息，可以执行 `pip show requests`。
5. **升级包：** 使用 `pip install --upgrade` 命令可以升级已安装的 Python 包到最新版本。例如，要升级名为 `requests` 的包，可以执行 `pip install --upgrade requests`。
6. **搜索包：** 使用 `pip search` 命令可以搜索 PyPI（Python 包索引）中的包。例如，要搜索名为 `requests` 的包，可以执行 `pip search requests`。
7. **从文件中安装包：** 使用 `pip install` 命令还可以从本地文件或 URL 安装包。例如，要从本地文件安装名为 `package.tar.gz` 的包，可以执行 `pip install package.tar.gz`。
8. **下载包：** 使用 `pip download` 命令可以下载包而不安装它们。例如，要下载名为 `requests` 的包，可以执行 `pip download requests`。

总的来说，`pip` 是 Python 开发中非常重要的一个工具，它可以帮助你方便地管理和使用 Python 包，提高开发效率。在使用 `pip` 命令时，记得要谨慎操作，避免不必要的包冲突和依赖问题。



### 腾讯pip源

pip install pip -U pip config set global.index-url https://mirrors.cloud.tencent.com/pypi/simple


## 安装core依赖

为 JumpServer 项目单独创建 python3 虚拟环境。

python3.11-m venv /opt/py3 source /opt/py3/bin/activate


每次运行项目都需要先执行 `source /opt/py3/bin/activate` 载入此环境。

poetry install


这个指令的目的是为了在 JumpServer 项目中创建一个独立的 Python 3 虚拟环境，并使用 Poetry 工具来安装项目所需的依赖。

1. `python3.11-m venv /opt/py3`: 这个命令使用 Python 3.9 的内置模块 `venv` 来创建一个名为 `/opt/py3` 的虚拟环境。这个虚拟环境将包含一个独立的 Python 解释器和 `pip` 工具，以及一个空的 `site-packages` 目录，用于存放项目的依赖包。
2. `source /opt/py3/bin/activate`: 这个命令用于激活之前创建的虚拟环境。通过执行这个命令，当前的命令行会切换到虚拟环境中，从而使得在命令行中执行的 Python 和 pip 命令都会使用虚拟环境中的版本和依赖包。
3. `poetry install`: 这个命令是使用 Poetry 工具来安装 JumpServer 项目的依赖。Poetry 是 Python 的一个包管理工具，它可以帮助你管理项目的依赖关系，并确保项目在不同环境中的一致性。执行 `poetry install` 命令会读取项目中的 `pyproject.toml` 文件，并安装其中声明的依赖包。

通过以上步骤，你可以在 JumpServer 项目中创建一个独立的 Python 虚拟环境，并安装项目所需的依赖。每次需要运行项目时，只需要执行 `source /opt/py3/bin/activate` 命令来激活虚拟环境，然后在其中执行相应的命令即可。这样可以确保项目的依赖包与系统的其他环境隔离开来，提高了项目的可移植性和稳定性。

### poetry详解

Poetry 是一个用于 Python 项目管理的工具，它可以帮助你管理项目的依赖、版本和发布，提高了 Python 项目的开发效率和可维护性。以下是关于 Poetry 的一些详解：

1. **依赖管理：** Poetry 可以帮助你管理项目的依赖关系，包括第三方库、开发工具等。你可以在项目的 `pyproject.toml` 文件中声明项目所需的依赖，并使用 `poetry add` 命令来添加新的依赖，使用 `poetry remove` 命令来移除不需要的依赖。
2. **版本管理：** Poetry 可以帮助你管理项目的 Python 版本和依赖包的版本。你可以在 `pyproject.toml` 文件中指定项目所需的 Python 版本，以及每个依赖包的版本范围。Poetry 还支持锁定依赖包的版本，以确保在不同环境中使用相同的依赖版本。
3. **虚拟环境：** Poetry 可以自动创建和管理项目的虚拟环境。每个 Poetry 项目都有一个独立的虚拟环境，用于隔离项目的依赖和环境。你可以使用 `poetry install` 命令来安装项目的依赖，Poetry 会自动在项目的虚拟环境中安装所需的依赖包。
4. **发布管理：** Poetry 可以帮助你发布 Python 包到 PyPI 或其他包索引服务。你可以使用 `poetry publish` 命令来发布项目，Poetry 会自动打包项目，并将包上传到指定的包索引服务中。
5. **项目初始化：** Poetry 还提供了一个快速初始化项目的功能，你可以使用 `poetry new` 命令来创建一个新的 Python 项目，并自动配置好项目的目录结构和依赖管理文件。

总的来说，Poetry 是一个功能丰富的 Python 项目管理工具，它可以帮助你简化项目的依赖管理、版本控制和发布过程，提高了 Python 项目的开发效率和可维护性。如果你在开发 Python 项目时遇到了依赖管理的问题，不妨考虑使用 Poetry 来简化项目管理工作。

### poetry用法案例

Poetry 是一个功能强大的 Python 项目管理工具，它提供了许多命令和选项来简化项目的依赖管理、版本控制和发布过程。以下是 Poetry 的一些常用用法：

1. **创建新项目：** 使用 `poetry new` 命令可以创建一个新的 Python 项目。例如，要创建一个名为 `myproject` 的新项目，可以执行 `poetry new myproject`。
2. **添加依赖：** 使用 `poetry add` 命令可以添加新的依赖包到项目中。例如，要添加一个名为 `requests` 的依赖包，可以执行 `poetry add requests`。
3. **移除依赖：** 使用 `poetry remove` 命令可以移除项目中不需要的依赖包。例如，要移除名为 `requests` 的依赖包，可以执行 `poetry remove requests`。
4. **安装依赖：** 使用 `poetry install` 命令可以安装项目的依赖。这个命令会读取项目的 `pyproject.toml` 文件，并安装其中声明的依赖包。例如，要安装项目的依赖，可以执行 `poetry install`。
5. **更新依赖：** 使用 `poetry update` 命令可以更新项目中的依赖包到最新版本。这个命令会检查依赖包的更新，并自动更新到最新版本。例如，要更新项目中的所有依赖包，可以执行 `poetry update`。
6. **查看依赖：** 使用 `poetry show` 命令可以查看项目中已安装的依赖包及其版本信息。例如，要查看项目中的所有依赖包，可以执行 `poetry show`。
7. **运行脚本：** 使用 `poetry run` 命令可以在项目的虚拟环境中运行 Python 脚本。例如，要运行项目中的 `app.py` 脚本，可以执行 `poetry run python app.py`。
8. **创建环境：** 使用 `poetry env` 命令可以管理项目的虚拟环境。例如，要创建一个新的虚拟环境，可以执行 `poetry env list` 查看当前已创建的虚拟环境列表，以及执行 `poetry env create` 创建新的虚拟环境。
9. **发布项目：** 使用 `poetry publish` 命令可以发布项目到 PyPI 或其他包索引服务。这个命令会自动打包项目，并将包上传到指定的包索引服务中。例如，要发布项目，可以执行 `poetry publish`。

以上是一些常用的 Poetry 命令和用法，通过合理使用这些命令，可以帮助你简化 Python 项目的依赖管理、版本控制和发布过程，提高项目的开发效率和可维护性。

### 案例

以下是一个使用 Poetry 的简单用法案例：

假设我们有一个名为 `myproject` 的 Python 项目，项目目录结构如下：

codemyproject/ │ ├── pyproject.toml ├── src/ │ └── mypackage/ │ ├── init.py │ └── module.py └── tests/ └── test_module.py


1. **初始化项目：** 首先，我们需要进入项目目录并使用 `poetry init` 命令来初始化项目，创建 `pyproject.toml` 文件。执行该命令后，会提示你输入项目的名称、版本、作者等信息，并生成一个最基本的 `pyproject.toml` 文件。

2. **添加依赖：** 接着，我们可以使用 `poetry add` 命令来添加项目的依赖。例如，假设我们想要添加 `requests` 和 `flask` 两个依赖，可以执行以下命令：

poetry add requests flask


   这会将 `requests` 和 `flask` 两个依赖添加到项目中，并自动更新 `pyproject.toml` 文件。

3. **安装依赖：** 添加完依赖后，我们可以使用 `poetry install` 命令来安装项目的依赖包。这个命令会读取 `pyproject.toml` 文件中声明的依赖，并在项目的虚拟环境中安装这些依赖包。

poetry install


4. **运行脚本：** 如果项目中有需要运行的 Python 脚本，可以使用 `poetry run` 命令来在项目的虚拟环境中运行。例如，要运行 `src/mypackage/module.py` 脚本，可以执行以下命令：

poetry run python src/mypackage/module.py


以上是一个简单的使用 Poetry 的案例，通过合理使用 Poetry 提供的命令和功能，可以帮助我们更轻松地管理项目的依赖、版本和发布。

### poetry加速源


在国内使用 Poetry 时，由于网络环境的限制，你可能会遇到访问 PyPI 包索引的速度较慢或不稳定的问题。为了解决这个问题，你可以配置 Poetry 使用国内的镜像源，以提高包的下载速度和稳定性。

下面是如何配置 Poetry 使用国内源的步骤：

1. **编辑 Poetry 配置文件：** 打开终端，执行以下命令编辑 Poetry 的配置文件（如果文件不存在，则会创建新文件）：

poetry config repositories.tsinghua https://pypi.tuna.tsinghua.edu.cn/simple

(py3) root@yu:/opt/jumpserver-3.10.7# cat ~/.config/pypoetry/config.toml [repositories.tsinghua] url = "https://pypi.tuna.tsinghua.edu.cn/simple" (py3) root@yu:/opt/jumpserver-3.10.7# 


   这个命令会将清华大学的 PyPI 镜像源添加到 Poetry 的配置中。

poetry config virtualenvs.create true

这条命令用于配置 Poetry，在执行 poetry install 命令时自动创建虚拟环境。

虚拟环境是 Python 开发中常用的一种技术，它可以将项目的依赖与系统的 Python 环境隔离开来，避免了不同项目之间的依赖冲突。在 Poetry 中，默认情况下并不会自动创建虚拟环境，需要手动执行 poetry env use 命令来激活或创建虚拟环境。但通过执行该命令后，Poetry 在执行 poetry install 命令时会自动创建一个虚拟环境，并将项目的依赖安装在其中。

这样做的好处是，在使用 Poetry 管理项目时，无需手动创建和管理虚拟环境，简化了项目的操作流程，提高了开发效率。

通过以上步骤，你就成功配置了 Poetry 使用国内的镜像源。在执行 poetry install 或其他相关命令时，Poetry 将会从清华大学的镜像源下载依赖包，从而提高下载速度和稳定性。

安装poetry

(py3) root@yu:/opt/jumpserver-3.10.7# pip install poetry

(py3) root@yu:/opt/jumpserver-3.10.7# poetry --version
Poetry (version 1.8.2)

(py3) root@yu:/opt/jumpserver-3.10.7# poetry config --list
cache-dir = "/root/.cache/pypoetry"
experimental.system-git-client = false
installer.max-workers = null
installer.modern-installation = true
installer.no-binary = null
installer.parallel = true
keyring.enabled = true
repositories.tsinghua.url = "https://pypi.tuna.tsinghua.edu.cn/simple/"
solver.lazy-wheel = true
virtualenvs.create = true
virtualenvs.in-project = null
virtualenvs.options.always-copy = false
virtualenvs.options.no-pip = false
virtualenvs.options.no-setuptools = false
virtualenvs.options.system-site-packages = false
virtualenvs.path = "{cache-dir}/virtualenvs"  # /root/.cache/pypoetry/virtualenvs
virtualenvs.prefer-active-python = false
virtualenvs.prompt = "{project_name}-py{python_version}"
warnings.export = true

core依赖管理

(py3) root@yu:/opt/jumpserver-3.10.7# ls
apps                data           entrypoint.sh  poetry.lock     requirements   ui
CODE_OF_CONDUCT.md  Dockerfile-ce  GITSHA         pyproject.toml  run_server.py  utils
config_example.yml  Dockerfile-ee  jms            README_EN.md    SECURITY.md
CONTRIBUTING.md     docs           LICENSE        README.md       tmp
(py3) root@yu:/opt/jumpserver-3.10.7# 
(py3) root@yu:/opt/jumpserver-3.10.7# cat pyproject.toml |wc -l
188
(py3) root@yu:/opt/jumpserver-3.10.7#

以上是一个示例的 pyproject.toml 文件，包含了一个名为 "jumpserver" 的项目的依赖配置。让我解释一下其中的内容：

  1. [tool.poetry]：这一部分定义了 Poetry 项目的元数据信息，包括项目的名称、版本、描述、作者、许可证等。
  2. [tool.poetry.dependencies]：这一部分定义了项目的依赖关系。每个依赖项都是一个键值对，键是依赖包的名称，值是版本约束。例如，python = "^3.11" 表示项目依赖 Python 版本 3.11，requests = "2.31.0" 表示项目依赖 requests 版本 2.31.0。
  3. [tool.poetry.group.xpack.dependencies]：这一部分定义了项目中的扩展依赖，例如第三方插件或模块。与 [tool.poetry.dependencies] 类似，每个依赖项都是一个键值对，表示依赖包的名称和版本约束。
  4. [[tool.poetry.source]]：这一部分定义了项目中使用的包源。每个包源都是一个键值对，包含名称、URL 和优先级。例如，name = "tsinghua" 表示这是一个名为 "tsinghua" 的包源，url = "https://pypi.tuna.tsinghua.edu.cn/simple/" 表示包源的 URL。
  5. [build-system]：这一部分定义了项目的构建系统配置。其中 requires 指定了项目构建所需的依赖，build-backend 指定了项目的构建后端。

通过编辑 pyproject.toml 文件，你可以管理项目的元数据信息、依赖关系和构建系统配置，从而更方便地管理和维护项目。

poetry安装依赖

(venv-3.11) root@yu:/opt/jumpserver-3.10.7# poetry install
Installing dependencies from lock file

Package operations: 277 installs, 9 updates, 0 removals

  - Installing frozenlist (1.4.1)
  - Downgrading idna (3.6 -> 3.4)
  - Installing multidict (6.0.5)
  - Installing aiosignal (1.3.1)
  - Installing async-timeout (4.0.3)
  - Installing attrs (23.2.0)
  - Downgrading certifi (2024.2.2 -> 2023.7.22)
  - Downgrading pycparser (2.22 -> 2.21)
  - Downgrading urllib3 (2.2.1 -> 1.26.16)
  - Installing yarl (1.9.4)
  - Installing aiohttp (3.8.6): Pending...
  - Downgrading cffi (1.16.0 -> 1.15.1): Pending...
  - Installing markupsafe (2.1.3): Pending...
  - Installing six (1.16.0): Pending...

这是 Poetry 在安装项目依赖时的输出信息。让我为你解释一下每个步骤：

  1. Package operations: 该部分显示了即将执行的包操作总数。在这个例子中，有 277 个包需要被安装，9 个包需要被更新，没有包需要被移除。
  2. Installing dependencies from lock file: Poetry 正在从锁文件中安装依赖项。锁文件通常是 poetry.lock，它包含了项目的确切依赖项及其版本信息。
  3. Package name (Version): Pending...: 这些行列出了即将安装或更新的包，以及它们的版本号。但是，它们的安装操作当前处于挂起状态（Pending...）。这可能是因为 Poetry 正在执行某些先决操作，或者它正在等待其他包的安装完成。
  4. Downgrading/upgrading/installing: 这些关键词指示了 Poetry 正在执行的操作类型。在你的输出中，有些包将被降级（Downgrading），有些包将被升级（Upgrading），有些包将被新安装（Installing）。

总体而言，这个输出表明 Poetry 正在安装项目的依赖项，并且在某些包的安装过程中，它需要进行降级、升级或者等待其他操作完成。请耐心等待直到所有操作完成。

安装完毕

(venv-3.11) root@yu:/opt/jumpserver-3.10.7# poetry show |tail
wcwidth                      
websocket-client             
websockets                   
werkzeug                     
wrapt                        
xlsxwriter                   
xmlsec                       
xmltodict                    
yarl                         
zope-interface               
(venv-3.11) root@yu:/opt/jumpserver-3.10.7# poetry show |wc -l
291

修改core配置

这段配置文件包含了敏感信息，需要在生产环境中谨慎处理。以下是关于配置文件中的两个重要参数的解释：

  1. SECRET_KEY（加密秘钥）： 这是用于加密用户会话数据等敏感信息的密钥。在生产环境中，应该将其设置为一个长随机字符串，并且确保不会泄漏给任何未经授权的人员。你可以使用提供的命令生成一个随机字符串，并将其替换为 SECRET_KEY 的值。
  2. BOOTSTRAP_TOKEN（预共享Token）： 这是用于注册服务账号的令牌。在生产环境中，应该将其设置为一个足够复杂的随机字符串，并确保只有合适的人员能够访问它。同样，你可以使用提供的命令生成一个随机字符串，并将其替换为 BOOTSTRAP_TOKEN 的值。

这两个参数在生产环境中都是非常重要的，并且应该严格保密。确保在部署应用程序时将其设置为安全且难以猜测的值，以保护应用程序的安全性。

# $ cat /dev/urandom | tr -dc A-Za-z0-9 | head -c 48;echo

# $ cat /dev/urandom | tr -dc A-Za-z0-9 | head -c 24;echo

配置参考

(venv-3.11) root@yu:/opt/jumpserver-3.10.7# grep -v '^\s*#' config.yml | grep -v '^\s*$'
SECRET_KEY: pf2Nima3SieTP99P9jcbt8xsWGrZDkYXLvuK3QXbzCoWfTLz
BOOTSTRAP_TOKEN: w9XuVbiG6l5WUBn2jkSZCgMN
DEBUG: true
LOG_LEVEL: DEBUG
DB_ENGINE: mysql
DB_HOST: 127.0.0.1
DB_PORT: 3306
DB_USER: jumpserver
DB_PASSWORD: yuchao666
DB_NAME: jumpserver
HTTP_BIND_HOST: 0.0.0.0
HTTP_LISTEN_PORT: 8080
WS_LISTEN_PORT: 8070
REDIS_HOST: 127.0.0.1
REDIS_PORT: 6379
REDIS_PASSWORD: yuchao666

mariadb安装

注意不是mysql

如果你安装的是 MySQL, 将 mariadb 开发包自行替换成 mysql, 或者不要将 数据库 和 Core 部署在一起

apt-get install -y libmariadb-dev 

apt install mariadb-server -y

(venv-3.11) root@yu:/opt/jumpserver-3.10.7# ss -tunlp|grep 3306
tcp   LISTEN 0      80                 127.0.0.1:3306      0.0.0.0:*    users:(("mariadbd",pid=59886,fd=19))     


# 修改密码为yuchao666
MariaDB [(none)]> SELECT user, host, plugin FROM mysql.user WHERE user = 'root';
+------+-----------+-----------------------+
| User | Host      | plugin                |
+------+-----------+-----------------------+
| root | localhost | mysql_native_password |
+------+-----------+-----------------------+
1 row in set (0.001 sec)

MariaDB [(none)]> ALTER USER 'root'@'localhost' IDENTIFIED BY 'yuchao666';
Query OK, 0 rows affected (0.003 sec)

MariaDB [(none)]> 
MariaDB [(none)]> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.000 sec)

MariaDB [(none)]> 

# 确认密码正确
root@yu:~# mysql
ERROR 1045 (28000): Access denied for user 'root'@'localhost' (using password: NO)
root@yu:~# 
root@yu:~# mysql -uroot -pyuchao666
Welcome to the MariaDB monitor.  Commands end with ; or \g.
Your MariaDB connection id is 34
Server version: 10.6.16-MariaDB-0ubuntu0.22.04.1 Ubuntu 22.04

Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

MariaDB [(none)]> 


# 创建用户、设置密码

create database jumpserver;
CREATE USER 'jumpserver'@'localhost' IDENTIFIED BY 'yuchao666';

GRANT ALL PRIVILEGES ON jumpserver.* TO 'jumpserver'@'localhost';

MariaDB [(none)]> flush privileges;
Query OK, 0 rows affected (0.000 sec)

MariaDB [(none)]>

国际化处理

rm -f apps/locale/zh/LC_MESSAGES/django.mo apps/locale/zh/LC_MESSAGES/djangojs.mo
python apps/manage.py compilemessages

这两个命令的作用如下：

  1. rm -f apps/locale/zh/LC_MESSAGES/django.mo apps/locale/zh/LC_MESSAGES/djangojs.mo: 这个命令用于删除指定目录下的两个文件：django.mo 和 djangojs.mo。这些文件通常是 Django 项目中用于国际化的本地化文件，用于存储已编译的消息以及 JavaScript 代码的翻译。
  2. python apps/manage.py compilemessages: 这个命令用于编译 Django 项目中的翻译文本，将翻译文本从 .po 文件编译成 .mo 文件。.po 文件是可编辑的文本文件，包含了项目中的翻译消息。.mo 文件是二进制文件，用于实际的本地化，以便 Django 能够在运行时动态地加载已翻译的文本。

综合起来，这两个命令的作用是更新 Django 项目中的本地化翻译文件，以便在运行时正确显示本地化文本。

解决报错

CommandError: Can't find msgfmt. Make sure you have GNU gettext tools 0.15 or newer installed.
(venv-3.11) root@yu:/opt/jumpserver-3.10.7# 

这个错误表明在执行 python apps/manage.py compilemessages 命令时，系统找不到 msgfmt 工具。msgfmt 是 GNU gettext 工具包中的一个组件，用于将 .po 文件编译为 .mo 文件。

redis启动

sudo apt install redis-server

(venv-3.11) root@yu:/opt/jumpserver-3.10.7# ss -tunlp|grep 6379
tcp   LISTEN 0      511                127.0.0.1:6379      0.0.0.0:*    users:(("redis-server",pid=60818,fd=6))  
tcp   LISTEN 0      511                    [::1]:6379         [::]:*    users:(("redis-server",pid=60818,fd=7))  
(venv-3.11) root@yu:/opt/jumpserver-3.10.7#

启动core

./jms start


root@yu:~# ss -tunlp |column |grep 8080
tcp   LISTEN 0      2048                 0.0.0.0:8080      0.0.0.0:*    users:(("gunicorn",pid=61153,fd=5),("gunicorn",pid=61152,fd=5),("gunicorn",pid=61151,fd=5),("gunicorn",pid=61150,fd=5),("gunicorn",pid=61145,fd=5))

访问core

http://192.168.234.129:8080/

admin
admin

yuchao666

image-20240402165944095

默认首页

image-20240402170156169

还需要继续去部署lina前端，至此就是正确的。

Jumpserver Lina前端

JumpServer Lina 是 JumpServer 的前端界面，旨在为用户提供一个直观、易用的管理界面，使用户能够轻松地管理和操作 JumpServer 平台。以下是 JumpServer Lina 的一些特点和功能：

  1. 直观的用户界面： JumpServer Lina 设计简洁直观，用户界面友好，使用户能够轻松地浏览和操作系统中的各种资源和功能。
  2. 权限管理： JumpServer Lina 支持权限管理，管理员可以根据用户的角色和权限设置不同的访问权限，确保只有经过授权的用户才能访问系统的特定功能和资源。
  3. 资源管理： JumpServer Lina 提供了一套管理界面，管理员能够轻松地添加、修改和删除系统中的各种资源，包括主机、账户、密钥等。
  4. 会话管理： JumpServer Lina 支持会话管理，用户可以通过界面发起对目标主机的会话，并在界面上查看和管理会话的状态和历史记录。
  5. 任务调度和执行： JumpServer Lina 支持任务调度和执行，用户可以通过界面创建和管理任务，监控任务的执行情况和结果，并查看任务的日志和报告。
  6. 审计和日志： JumpServer Lina 提供了审计和日志功能，管理员可以通过界面查看用户的操作日志和系统的审计报告，以便跟踪和审查用户的操作历史。
  7. 通知和报警： JumpServer Lina 支持向用户发送通知和报警消息，用户可以通过界面接收并处理系统的通知和报警信息，及时关注重要事件和异常情况。

总的来说，JumpServer Lina 是 JumpServer 的前端界面，为用户提供了一个方便快捷的管理和操作平台，帮助用户更高效地管理和控制系统中的资源和任务。

lina项目

JumpServer Lina 是 JumpServer 的前端 UI 项目，主要基于 Vue.js 框架和 Element UI 组件库开发。Vue.js 是一款流行的前端 JavaScript 框架，提供了一套简洁的 API 和响应式数据绑定机制，使开发者能够快速构建交互式的用户界面。Element UI 是一个基于 Vue.js 的桌面端 UI 组件库，提供了丰富的组件和样式，使开发者能够轻松构建美观、易用的用户界面。

JumpServer Lina 主要负责展示 JumpServer 的各种功能和资源，包括主机管理、账户管理、审计日志、任务调度等。它与 JumpServer 后端进行交互，通过 API 获取数据并显示在界面上，同时将用户的操作请求发送给后端进行处理。通过 Vue.js 提供的组件化开发和响应式数据绑定，JumpServer Lina 能够快速响应用户的操作，并提供流畅的用户体验。

在 JumpServer Lina 的开发过程中，开发者通常会使用 Vue CLI 脚手架工具初始化项目，并集成 Element UI 组件库。然后根据设计稿和需求，开发不同的页面和组件，并通过路由管理实现页面间的跳转和导航。同时，开发者还会使用 Vuex 管理应用的状态，并与后端 API 进行交互，实现数据的获取和更新。

总的来说，JumpServer Lina 是一个基于 Vue.js 和 Element UI 的前端 UI 项目，用于展示和管理 JumpServer 平台的各种功能和资源，提供了直观、易用的用户界面，帮助用户更高效地管理和控制系统。

cd /opt
mkdir /opt/lina-v3.10.7
wget -O /opt/lina-v3.10.7.tar.gz https://github.com/jumpserver/lina/archive/refs/tags/v3.10.7.tar.gz
tar -xf lina-v3.10.7.tar.gz -C /opt/lina-v3.10.7 --strip-components 1

这是一个位于 /opt/lina-v3.10.7 目录下的 JumpServer Lina 项目的文件列表。这个项目包含了一些常见的前端开发文件和配置，以下是其中一些文件的解释：

  • alias.config.js: 别名配置文件，用于配置别名以简化模块导入路径。
  • babel.config.js: Babel 配置文件，用于配置 JavaScript 编译器 Babel 的选项和插件。
  • build: 构建目录，包含了项目的构建脚本和配置文件。
  • Dockerfile: Docker 镜像构建文件，用于构建部署 JumpServer Lina 的 Docker 镜像。
  • jest.config.js: Jest 配置文件，用于配置前端测试框架 Jest 的选项和插件。
  • jsconfig.json: JavaScript 配置文件，用于配置 JavaScript 项目的相关设置，例如语法检查、自动补全等。
  • LICENSE: 开源许可证文件，规定了 JumpServer Lina 项目的代码使用许可。
  • nginx.conf: Nginx 配置文件，用于配置反向代理服务器 Nginx 的选项，用于部署和访问 JumpServer Lina。
  • package.json: 包管理文件，用于配置项目的依赖和脚本。
  • public: 公共资源目录，包含了不需要编译的静态资源文件。
  • README.md: 项目的说明文档，包含了项目的介绍、使用方法和其他相关信息。
  • src: 源代码目录，包含了项目的所有源代码文件。
  • tests: 测试目录，包含了项目的测试文件。
  • utils: 实用工具目录，包含了项目中使用的各种实用工具函数。
  • vue.config.js: Vue CLI 配置文件，用于配置 Vue CLI 项目的相关选项。

这些文件和目录组成了 JumpServer Lina 项目的基本结构，用于开发、构建和部署前端应用。

root@yu:/opt/lina-v3.10.7# ls
alias.config.js  Dockerfile      jsconfig.json  nginx.conf         public     tests          yarn.lock
babel.config.js  GITSHA          LICENSE        package.json       README.md  utils
build            jest.config.js  mock           postcss.config.js  src        vue.config.js
root@yu:/opt/lina-v3.10.7#

安装node.js

这段代码是在 Ubuntu 系统上安装 Node.js 的步骤，具体解释如下：

  1. cd /opt: 切换当前工作目录到 /opt。
  2. wget https://nodejs.org/download/release/v16.5.0/node-v16.5.0-linux-x64.tar.xz: 使用 wget 命令下载 Node.js 版本为 16.5.0 的 Linux x64 版本压缩包。
  3. tar -xf node-v16.5.0-linux-x64.tar.xz: 使用 tar 命令解压下载的压缩包。
  4. mv node-v16.5.0-linux-x64 /usr/local/node: 将解压后的文件夹移动到 /usr/local/node 目录下，这是一个常见的安装目录。
  5. chown -R root:root /usr/local/node: 修改 /usr/local/node 目录及其所有子目录和文件的所有者为 root 用户，以确保只有管理员可以对其进行修改。
  6. export PATH=/usr/local/node/bin:$PATH: 将 Node.js 可执行文件所在的路径 /usr/local/node/bin 添加到系统环境变量 PATH 中，这样系统就可以识别并执行 Node.js 命令。
  7. echo 'export PATH=/usr/local/node/bin:$PATH' >> ~/.bashrc: 将上一步添加 PATH 的命令写入到当前用户的 ~/.bashrc 文件中，这样每次登录时都会自动添加 Node.js 到 PATH 中。

这样完成后，Node.js 就安装在系统中，并且可以在任何地方使用 node 和 npm 命令来执行 JavaScript 代码和管理 Node.js 项目了。

cd /opt
wget https://nodejs.org/download/release/v16.5.0/node-v16.5.0-linux-x64.tar.xz
tar -xf node-v16.5.0-linux-x64.tar.xz
mv node-v16.5.0-linux-x64 /usr/local/node
chown -R root:root /usr/local/node
export PATH=/usr/local/node/bin:$PATH
echo 'export PATH=/usr/local/node/bin:$PATH' >> ~/.bashrc


root@yu:~# source ~/.bashrc 
root@yu:~# 
root@yu:~# node -v
v16.5.0
root@yu:~# npm -v
7.19.1
root@yu:~#

Lina 是 JumpServer 的前端 UI 项目，主要使用 Vue.js 框架来构建用户界面。而 Vue.js 是一个基于 JavaScript 的前端框架，它需要在浏览器中运行 JavaScript 代码来呈现用户界面。为了在开发阶段编译和打包 Vue.js 项目，通常需要使用 Node.js 来运行一些构建工具、编译器和打包工具，例如 webpack、Babel 等。因此，Node.js 在 Lina 项目中被用来处理前端开发过程中的各种构建和打包任务，以及在开发环境中运行本地服务器等功能。

为什么要安装lina依赖

https://mirrors.tencent.com/help/npm.html

安装 Lina 依赖是为了构建和运行 JumpServer 的前端 UI 项目。具体来说：

  1. 安装 yarn: Yarn 是一个 JavaScript 的依赖管理工具，类似于 npm，但相比 npm 更快速、稳定。通过全局安装 yarn，可以在项目中使用 yarn 命令来管理依赖包的安装和管理。
  2. 运行 yarn install: 这个命令会根据项目中的 package.json 文件，安装项目所需的所有依赖包。在 Lina 项目中，这些依赖包包括 Vue.js、Element UI 等前端开发所需的框架、库和工具。

通过执行以上步骤，可以确保在进行 JumpServer 前端 UI 开发或部署时，所需的依赖包都已安装并准备就绪，以确保项目的正常运行和开发。

cd /opt/lina-v3.10.7

npm config set registry http://mirrors.cloud.tencent.com/npm/
yarn config set registry http://mirrors.cloud.tencent.com/npm/

npm install -g yarn

root@yu:~# yarn config get registry
http://mirrors.cloud.tencent.com/npm/
root@yu:~# 


root@yu:/opt/lina-v3.10.7# yarn install
yarn install v1.22.22
[1/5] Validating package.json...
[2/5] Resolving packages...
[3/5] Fetching packages...
warning Pattern ["wrap-ansi@^7.0.0"] is trying to unpack in the same destination "/usr/local/share/.cache/yarn/v6/npm-wrap-ansi-cjs-7.0.0-67e145cff510a6a6984bdf1152911d69d2eb9e43-integrity/node_modules/wrap-ansi-cjs" as pattern ["wrap-ansi-cjs@npm:wrap-ansi@^7.0.0"]. This could result in non-deterministic behavior, skipping.
[####################################################---------------------------------------------------------] 871/1823

在执行 yarn install 过程中，Yarn 会完成以下操作：

  1. 验证 package.json 文件：首先，Yarn 会检查项目根目录下的 package.json 文件，以确保其格式正确且没有错误。
  2. 解析依赖包：Yarn 会解析 package.json 文件中声明的所有依赖包，并确定它们的版本。
  3. 获取依赖包：Yarn 会从配置的包管理器源（通常是 npmjs.com 或其他镜像源）下载所需的依赖包。
  4. 下载依赖包：在这一阶段，Yarn 会下载依赖包及其所有的依赖项。进度条显示了下载进度。
  5. 安装依赖包：最后，Yarn 会将下载的依赖包安装到项目的 node_modules 目录中，以供项目使用。

在你的执行过程中，Yarn 已经开始获取和下载依赖包，但进度仅完成了 64/1823，这意味着还有很多依赖包需要下载。请耐心等待，直到进度条完成。

修改lina配置

sed -i "s@Version <strong>.*</strong>@Version <strong>v3.10.7</strong>@g" src/layout/components/Footer/index.vue

vi .env.development

以上命令中使用了两个不同的文本编辑工具：sed 和 vi。

sed 命令用于在文件中进行文本替换操作。在这个命令中，sed -i 表示直接修改源文件，"s@Version <strong>.*</strong>@Version <strong>v3.10.7</strong>@g" 是一个替换规则，它将文件中 Version <strong>...</strong> 的内容替换为 Version <strong>v3.10.7</strong>。src/layout/components/Footer/index.vue 是被修改的文件路径。

这样的修改通常用于更新软件版本或者修改配置文件中的特定信息。在你提供的命令中：

sed 命令用于修改 src/layout/components/Footer/index.vue 文件中的版本信息。这种修改可能是为了更新页面底部的版本显示，确保它与实际部署的软件版本一致。

报错记录

root@yu:/opt/lina-v3.10.7# yarn install
yarn install v1.22.22
[1/5] Validating package.json...
[2/5] Resolving packages...
[3/5] Fetching packages...
warning Pattern ["wrap-ansi@^7.0.0"] is trying to unpack in the same destination "/usr/local/share/.cache/yarn/v6/npm-wrap-ansi-cjs-7.0.0-67e145cff510a6a6984bdf1152911d69d2eb9e43-integrity/node_modules/wrap-ansi-cjs" as pattern ["wrap-ansi-cjs@npm:wrap-ansi@^7.0.0"]. This could result in non-deterministic behavior, skipping.
error nopt@7.2.0: The engine "node" is incompatible with this module. Expected version "^14.17.0 || ^16.13.0 || >=18.0.0". Got "16.5.0"
error Found incompatible module.
info Visit https://yarnpkg.com/en/docs/cli/install for documentation about this command.
root@yu:/opt/lina-v3.10.7#

修改node版本

wget https://nodejs.org/download/release/v16.15.0/node-v16.15.0-linux-x64.tar.xz

root@yu:/opt# tar -xf node-v16.15.0-linux-x64.tar.xz 
root@yu:/opt# mv node-v16.15.0-linux-x64 /usr/local/node
root@yu:/opt# 
root@yu:/opt# 
logout
yu@yu:~$ sudo -i
[sudo] password for yu: 
root@yu:~# 
root@yu:~# 
root@yu:~# node -v
v16.15.0
root@yu:~# npm -v
8.5.5
root@yu:~#

重新安装lina

npm install -g yarn

yarn config set registry http://mirrors.cloud.tencent.com/npm/


root@yu:/opt/lina-3.10.7# yarn -v
1.22.22

root@yu:/opt/lina-3.10.7# yarn config get registry
http://mirrors.cloud.tencent.com/npm/
root@yu:/opt/lina-3.10.7#

2024-4-2 记录 node 16.15版本可以安装lina

root@yu:/opt/lina-3.10.7# yarn install
yarn install v1.22.22
[1/5] Validating package.json...
[2/5] Resolving packages...
[3/5] Fetching packages...
warning Pattern ["wrap-ansi@^7.0.0"] is trying to unpack in the same destination "/usr/local/share/.cache/yarn/v6/npm-wrap-ansi-cjs-7.0.0-67e145cff510a6a6984bdf1152911d69d2eb9e43-integrity/node_modules/wrap-ansi-cjs" as pattern ["wrap-ansi-cjs@npm:wrap-ansi@^7.0.0"]. This could result in non-deterministic behavior, skipping.
[4/5] Linking dependencies...
warning " > less-loader@5.0.0" has unmet peer dependency "webpack@^2.0.0 || ^3.0.0 || ^4.0.0".
warning " > html-webpack-plugin@3.2.0" has unmet peer dependency "webpack@^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0".
warning " > compression-webpack-plugin@6.1.1" has unmet peer dependency "webpack@^4.0.0 || ^5.0.0".
warning " > sass-loader@7.3.1" has unmet peer dependency "webpack@^3.0.0 || ^4.0.0".
warning " > script-ext-html-webpack-plugin@2.1.3" has unmet peer dependency "webpack@^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0".
warning Workspaces can only be enabled in private projects.
[5/5] Building fresh packages...
success Saved lockfile.
Done in 20.57s.
root@yu:/opt/lina-3.10.7#

在您运行 yarn install 后，出现了几个警告信息：

  1. wrap-ansi 包冲突警告： 这个警告是由于存在多个相同的模式尝试在同一位置进行解压缩，但是最终解决了这个冲突，所以不会导致不确定性行为。
  2. less-loader、html-webpack-plugin、compression-webpack-plugin、sass-loader、script-ext-html-webpack-plugin 包的未满足 peer dependency 警告： 这些警告是由于这些包依赖于 webpack，但未指定 webpack 的版本范围。这意味着这些包可以与任何版本的 webpack 一起使用，但是您当前的 webpack 版本可能与这些包的期望版本范围不匹配。您可以根据警告信息，尝试安装与这些包期望的 webpack 版本范围兼容的 webpack。
  3. Workspaces 只能在私有项目中启用的警告： 这个警告是因为工作区功能在您的项目中被启用了，但是您的项目是公共项目。工作区功能通常用于管理包含多个项目的 monorepo。这个警告不会影响依赖项的安装，只是提醒您工作区功能在此情况下可能没有必要。

总的来说，您的 yarn install 命令执行成功，警告信息大多是关于依赖项的一些附加信息，通常不会影响项目的正常运行。如果您的项目在运行过程中遇到了问题，请检查并解决与警告相关的依赖关系问题。

代理文件

root@yu:/opt/lina-3.10.7# cp .env.development.example .env.development


# 全局环境变量 请勿随意改动
ENV = 'development'

# base api
VUE_APP_BASE_API = ''
VUE_APP_PUBLIC_PATH = '/ui/'

# vue-cli uses the VUE_CLI_BABEL_TRANSPILE_MODULES environment variable,
# to control whether the babel-plugin-dynamic-import-node plugin is enabled.
# It only does one thing by converting all import() to require().
# This configuration can significantly increase the speed of hot updates,
# when you have a large number of pages.
# Detail:  https://github.com/vuejs/vue-cli/blob/dev/packages/@vue/babel-preset-app/index.js

VUE_CLI_BABEL_TRANSPILE_MODULES = true

# External auth
VUE_APP_LOGIN_PATH = '/core/auth/login/'
VUE_APP_LOGOUT_PATH = '/core/auth/logout/'


# Dev server for core proxy
VUE_APP_CORE_HOST = 'http://localhost:8080'
VUE_APP_CORE_WS = 'ws://localhost:8080'
VUE_APP_KAEL_HOST = 'http://localhost:8083'
VUE_APP_ENV = 'development'

这段配置文件中包含了一些环境变量和配置项，它们的作用如下：

  • ENV： 设置全局环境变量为开发环境（development），这个变量可能会在整个项目中用于区分不同的环境，例如开发、测试和生产环境。
  • VUE_APP_BASE_API： 定义了项目的基础 API 地址，通常用于与后端交互的接口地址。
  • VUE_APP_PUBLIC_PATH： 设置了项目的公共路径，用于指定项目中静态资源的路径。
  • VUE_CLI_BABEL_TRANSPILE_MODULES： 这个变量用于控制是否启用了 babel-plugin-dynamic-import-node 插件，该插件用于将 import() 转换为 require()，以加快热更新的速度。
  • VUE_APP_LOGIN_PATH 和 VUE_APP_LOGOUT_PATH： 分别定义了登录和登出的路径，用于用户身份认证的相关操作。
  • VUE_APP_CORE_HOST 和 VUE_APP_CORE_WS： 设置了核心服务的主机地址和 WebSocket 地址，用于与后端核心服务进行通信。
  • VUE_APP_KAEL_HOST： 定义了与 Kael 服务通信的主机地址。
  • VUE_APP_ENV： 设置了当前环境为开发环境。

这些配置项通常用于指定项目中的各种参数和地址，以便在不同的环境下运行和部署项目。

启动lina到0.0.0.0

root@yu:/opt/lina-3.10.7# yarn serve --host 0.0.0.0
yarn run v1.22.22
$ vue-cli-service serve --host 0.0.0.0
 INFO  Starting development server...
 10% building 2/2 modules 0 activeℹ ｢wds｣: Project is running at http://0.0.0.0:9528/
ℹ ｢wds｣: webpack output is served from /ui/
ℹ ｢wds｣: Content not from webpack is served from /opt/lina-3.10.7/public
ℹ ｢wds｣: 404s will fallback to /index.html                                                       98% after emitting CopyPlugin                                                      

 DONE  Compiled successfully in 29277ms                                                                                 9:41:08 AM

  App running at:
  - Local:   http://localhost:9528/ui/ 
  - Network: http://192.168.234.129:9528/ui/

  Note that the development build is not optimized.
  To create a production build, run yarn build.

访问Lina堡垒机首页

image-20240402174231203

注意坑，还没配置nginx，所以先用8080端口登录，记录session，然后访问9528即可登录。

jumpserver luna组件

JumpServer 的 Luna 组件是一个基于 Angular 和 Material Design 构建的 Web 终端项目。它提供了一个可视化的、具有实时交互功能的终端界面，使用户能够通过浏览器直接访问和管理远程服务器。

以下是 Luna 组件的一些主要特点和功能：

  1. 实时终端交互： Luna 提供了一个实时的终端界面，用户可以通过浏览器连接到远程服务器，并在终端中执行命令、编辑文件等操作。
  2. 基于 Angular 和 Material Design： Luna 使用 Angular 框架和 Material Design 设计风格，提供了一致性和美观的用户界面。
  3. 多终端支持： Luna 支持在不同的终端设备上运行，包括桌面端和移动端，用户可以在任何设备上方便地使用。
  4. 多语言支持： Luna 提供了多语言支持，可以根据用户的偏好选择不同的语言界面。
  5. 安全性： Luna 支持安全的用户认证和权限控制，保障用户数据和操作的安全性。
  6. 易于集成： Luna 的代码结构清晰，易于理解和扩展，可以与其他系统集成，满足不同场景下的需求。

通过 Luna 组件，用户可以轻松地管理远程服务器，执行各种操作，并获取实时的终端反馈，提高工作效率和便利性。

cd /opt
mkdir /opt/luna-v3.10.7
wget -O /opt/luna-v3.10.7.tar.gz https://github.com/jumpserver/luna/archive/refs/tags/v3.10.7.tar.gz
tar -xf luna-v3.10.7.tar.gz -C /opt/luna-v3.10.7 --strip-components 1

cd /opt/luna-v3.10.7
yarn install


root@yu:/opt/luna-v3.10.7# yarn install
yarn install v1.22.22
warning package-lock.json found. Your project contains lock files generated by tools other than Yarn. It is advised not to mix package managers in order to avoid resolution inconsistencies caused by unsynchronized lock files. To clear this warning, remove package-lock.json.
[1/4] Resolving packages...
[2/4] Fetching packages...
[3/4] Linking dependencies...
warning " > @angular/flex-layout@7.0.0-beta.24" has incorrect peer dependency "@angular/cdk@^7.0.0-rc.0".
warning " > @angular/material@7.3.7" has incorrect peer dependency "@angular/cdk@7.3.7".
warning " > ngx-cookie-service@12.0.3" has incorrect peer dependency "@angular/common@^12.0.0".
warning " > ngx-cookie-service@12.0.3" has incorrect peer dependency "@angular/core@^12.0.0".
warning "tslint-etc > tsutils-etc@1.4.1" has incorrect peer dependency "typescript@^4.0.0".
warning " > codelyzer@4.5.0" has incorrect peer dependency "@angular/compiler@>=2.3.1 <8.0.0 || >7.0.0-beta <8.0.0".
warning " > codelyzer@4.5.0" has incorrect peer dependency "@angular/core@>=2.3.1 <8.0.0 || >7.0.0-beta <8.0.0".
[4/4] Building fresh packages...
Done in 132.34s.
root@yu:/opt/luna-v3.10.7#

修改配置

sed -i "s@[0-9].[0-9].[0-9]@v3.10.7@g" src/environments/environment.prod.ts
vi proxy.conf.json

这个 proxy.conf.json 文件配置了一个反向代理，将不同路径下的请求转发到不同的目标服务器上。具体配置如下：

  1. /koko/elfinder/*: 将以 /koko/elfinder/ 开头的请求转发到 http://localhost:5000，包括 WebSocket 请求。
  2. /koko/static/*: 将以 /koko/static/ 开头的请求转发到 http://localhost:5000，包括 WebSocket 请求。
  3. /koko/*: 将以 /koko/ 开头的请求转发到 http://localhost:5000，包括 WebSocket 请求。
  4. /media/: 将以 /media/ 开头的请求转发到 http://localhost:8080。
  5. /api/: 将以 /api/ 开头的请求转发到 http://localhost:8080。
  6. /ws/: 将以 /ws/ 开头的 WebSocket 请求转发到 ws://localhost:8080。
  7. /core: 将以 /core 开头的请求转发到 http://localhost:8080。
  8. /static: 将以 /static 开头的请求转发到 http://localhost:8080。
  9. /lion: 将以 /lion 开头的请求转发到 http://localhost:9529，并且将 /lion/monitor 重写为 /monitor。
  10. /chen: 将以 /chen 开头的请求转发到 http://localhost:9523，包括 WebSocket 请求。
  11. /kael: 将以 /kael 开头的请求转发到 http://localhost:5173，包括 WebSocket 请求。
  12. /ui/: 将以 /ui/ 开头的请求转发到 http://localhost:9528。

这样的配置可以实现将不同路径下的请求分发到不同的后端服务上，从而实现更灵活的代理配置。

启动Luna

root@yu:/opt/luna-v3.10.7# ./node_modules/.bin/ng serve --host 0.0.0.0


root@yu:~# ss -tunlp |grep 4200
tcp   LISTEN 0      511                  0.0.0.0:4200      0.0.0.0:*    users:(("ng serve --host",pid=63287,fd=23))

不用去访问，继续部署nginx

jumpserver koko组件

cd /opt
mkdir /opt/koko-v3.10.7
wget -O /opt/koko-v3.10.7.tar.gz https://github.com/jumpserver/koko/archive/refs/tags/v3.10.7.tar.gz
tar -xf koko-v3.10.7.tar.gz -C /opt/koko-v3.10.7 --strip-components 1

koko目录

root@yu:/opt/koko-v3.10.7# ls
assets.go  config_example.yml  docs           GITSHA  go.sum   locale    pkg        SECURITY.md  templates  utils
cmd        Dockerfile          entrypoint.sh  go.mod  LICENSE  Makefile  README.md  static       ui
root@yu:/opt/koko-v3.10.7#

这个目录中包含了 Koko 组件的各种文件和目录，具体如下：

  • assets.go: 存储了一些资源文件的 Go 代码，可能是将资源文件编译成 Go 代码的方式。
  • config_example.yml: 配置文件的示例，用于指导用户如何配置 Koko 组件。
  • docs: 存放文档相关的文件或目录，可能包括用户手册、API 文档等。
  • GITSHA: 存储了 Git 版本控制信息，记录了当前代码的 Git SHA 标识符。
  • go.mod 和 go.sum: Go 模块的定义文件，用于管理项目的依赖。
  • locale: 存放国际化（Localization）相关的文件或目录，用于支持不同语言的界面显示。
  • pkg: 存放了项目的 Go 包文件，可能包含了一些核心功能的实现。
  • SECURITY.md: 安全相关的文档，可能包括安全漏洞的报告和解决方案等。
  • templates: 存放了一些模板文件，可能是用于生成动态内容的模板。
  • ui: 用户界面相关的文件或目录，可能包括前端代码、样式表、脚本等。
  • cmd: 存放了一些命令行工具的源代码。
  • Dockerfile: Docker 容器的构建文件，用于构建 Koko 组件的 Docker 镜像。
  • entrypoint.sh: 启动脚本，用于启动 Koko 组件。
  • LICENSE: 许可证文件，规定了 Koko 组件的使用权限和限制。
  • Makefile: Makefile 文件，用于定义项目的编译、测试和发布等任务。
  • README.md: 项目的说明文档，提供了关于项目的基本信息、使用说明等。
  • static: 静态文件，可能包括一些不需要动态生成的文件，如图片、样式表、脚本等。

这些文件和目录提供了构成 Koko 组件的各种资源和工具，帮助用户理解、配置和运行 Koko 组件。

安装koko依赖

apt-get update
apt install software-properties-common -y
add-apt-repository -y ppa:redislabs/redis
apt-get install -y mariadb-client bash-completion redis-tools
cd /opt
mkdir /opt/kubectl-aliases
wget http://download.jumpserver.org/public/kubectl_aliases.tar.gz -O kubectl_aliases.tar.gz
tar -xf kubectl_aliases.tar.gz -C /opt/kubectl-aliases

这段代码是在 Ubuntu 或类似的 Debian 系统上安装一些软件和配置工具，并下载了一些 Kubernetes 相关的别名文件。

具体步骤如下：

  1. 更新 apt 软件包列表：apt-get update
  2. 安装 software-properties-common 包，这是一个实用程序包，提供了添加 PPA 仓库的命令：apt install software-properties-common
  3. 添加 Redis Labs 的 PPA 仓库：add-apt-repository -y ppa:redislabs/redis
  4. 安装 MariaDB 的客户端工具、Bash 自动补全工具和 Redis 的客户端工具：apt-get install -y mariadb-client bash-completion redis-tools
  5. 切换至 /opt 目录：cd /opt
  6. 创建一个名为 kubectl-aliases 的目录：mkdir /opt/kubectl-aliases
  7. 使用 wget 命令下载 Kubernetes 相关的别名文件（kubectl_aliases.tar.gz）：wget http://download.jumpserver.org/public/kubectl_aliases.tar.gz -O kubectl_aliases.tar.gz
  8. 使用 tar 命令解压下载的别名文件，并将其解压到 /opt/kubectl-aliases 目录中：tar -xf kubectl_aliases.tar.gz -C /opt/kubectl-aliases

这些步骤用于准备系统环境，安装必要的软件工具，并下载 Kubernetes 相关的别名文件，以便在命令行中更方便地管理 Kubernetes 集群。

安装golang 必须是1.19.0版本

踩坑记录，需要升级到1.19以上

go: downloading github.com/modern-go/reflect2 v1.0.2
# github.com/jumpserver/koko/pkg/proxy
pkg/proxy/switch.go:35:22: undefined: atomic.Bool
note: module requires Go 1.19
make: *** [Makefile:55: build] Error 2
root@yu:/opt/koko-v3.10.7#

cd /opt
wget https://go.dev/dl/go1.19.linux-amd64.tar.gz


tar -xf    xxxxx   -C /usr/local/

chown -R root:root /usr/local/go
export PATH=/usr/local/go/bin:$PATH
echo 'export PATH=/usr/local/go/bin:$PATH' >> ~/.bashrc

root@yu:~# source ~/.bashrc 


root@yu:~# go version



export GOPROXY=https://goproxy.cn,direct

编译koko

cd /opt/koko-v3.10.7
make


root@yu:/opt/koko-3.10.7# cp config_example.yml config.yml
root@yu:/opt/koko-3.10.7# 

root@yu:/opt/koko-3.10.7# grep -v '^\s*#' config.yml |grep -v '^\s*$'
CORE_HOST: http://127.0.0.1:8080
BOOTSTRAP_TOKEN: w9XuVbiG6l5WUBn2jkSZCgMN
BIND_HOST: 0.0.0.0
SSHD_PORT: 2222
HTTPD_PORT: 5000
LOG_LEVEL: INFO

启动koko

root@yu:/opt/koko-3.10.7# ./build/koko-linux-amd64 -f config.yml 
2024-04-02 10:47:58
KoKo Version -, more see https://www.jumpserver.org
Quit the server with CONTROL-C.
2024/04/02 10:47:58 Load config from env
2024/04/02 10:47:58 Load config from config.yml success
2024/04/02 10:47:58 &{Name:[KoKo]-yu-rVWrhzc CoreHost:http://127.0.0.1:8080 BootstrapToken:w9XuVbiG6l5WUBn2jkSZCgMN BindHost:0.0.0.0 SSHPort:2222 HTTPPort:5000 SSHTimeout:15 LogLevel:INFO Comment:KOKO LanguageCode:zh UploadFailedReplay:true UploadFailedFTPFile:true AssetLoadPolicy: ZipMaxSize:1024M ZipTmpPath:/tmp ClientAliveInterval:30 RetryAliveCountMax:3 ShowHiddenFile:false ReuseConnection:true ShareRoomType:local RedisHost:127.0.0.1 RedisPort:6379 RedisPassword: RedisDBIndex:0 RedisClusters:[] RedisSentinelPassword: RedisSentinelHosts: RedisUseSSL:false EnableLocalPortForward:false EnableVscodeSupport:false HiddenFields:[] RootPath:/opt/koko-3.10.7 DataFolderPath:/opt/koko-3.10.7/data LogDirPath:/opt/koko-3.10.7/data/logs KeyFolderPath:/opt/koko-3.10.7/data/keys AccessKeyFilePath:/opt/koko-3.10.7/data/keys/.access_key ReplayFolderPath:/opt/koko-3.10.7/data/replays FTPFileFolderPath:/opt/koko-3.10.7/data/ftp_files CertsFolderPath:/opt/koko-3.10.7/data/certs}
2024-04-02 10:47:58 [INFO] Exchange share room type: local
2024-04-02 10:47:58 [INFO] Start SSH server at 0.0.0.0:2222
2024-04-02 10:47:58 [INFO] Start HTTP Server at 0.0.0.0:5000
2024-04-02 10:47:58 [INFO] Start ws client success
2024-04-02 10:47:58 [INFO] Upload remain replay done
2024-04-02 10:47:58 [INFO] Upload remain FTP file done

端口查看

root@yu:~# ss -tunlp|column  |grep koko
tcp   LISTEN 0      4096                       *:5000            *:*    users:(("koko-linux-amd6",pid=78277,fd=11))                                                                                                        
tcp   LISTEN 0      4096                       *:2222            *:*    users:(("koko-linux-amd6",pid=78277,fd=10))                                                                                                        
root@yu:~#

Nginx整合

apt install nginx -y

root@yu:~# nginx -v
nginx version: nginx/1.18.0 (Ubuntu)
root@yu:~#

配置文件nginx

server {
  listen 80;
  # server_name _;

  # Luna 配置
  location /luna/ {
    # 注意将模板中的组件名称替换为服务实际 ip 地址， 如都在本机部署
    proxy_pass       http://127.0.0.1:4200;
    # proxy_pass http://luna:4200;
  }

  # Core data 静态资源
  location /media/replay/ {
    add_header Content-Encoding gzip;
    root /opt/jumpserver-3.10.7/data/;
  }

  location /static/ {
    root /opt/jumpserver-3.10.7/data/;
  }

  # KoKo Lion 配置
  location /koko/ {
    # 注意将模板中的组件名称替换为服务实际 ip 地址， 如都在本机部署
    proxy_pass       http://127.0.0.1:5000;
    # proxy_pass       http://koko:5000;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_http_version 1.1;
    proxy_buffering off;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
  }

  # lion 配置
  location /lion/ {
    # 注意将模板中的组件名称替换为服务实际 ip 地址， 如都在本机部署
    proxy_pass       http://127.0.0.1:8081;
    # proxy_pass http://lion:8081;
    proxy_buffering off;
    proxy_request_buffering off;
    proxy_http_version 1.1;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $http_connection;
    proxy_ignore_client_abort on;
    proxy_connect_timeout 600;
    proxy_send_timeout 600;
    proxy_read_timeout 600;
    send_timeout 6000;
  }

  location /ws/ {
    # 注意将模板中的组件名称替换为服务实际 ip 地址， 如都在本机部署
    proxy_pass       http://127.0.0.1:8080;
    # proxy_pass http://core:8080;
    proxy_buffering off;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  location ~ ^/(core|api|media)/ {
    # 注意将模板中的组件名称替换为服务实际 ip 地址， 如都在本机部署
    proxy_pass       http://127.0.0.1:8080;
    # proxy_pass http://core:8080;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  # 前端 Lina
  location /ui/ {
    # 注意将模板中的组件名称替换为服务实际 ip 地址， 如都在本机部署
    proxy_pass       http://127.0.0.1:9528;
    # proxy_pass http://lina:9528;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  }

  location / {
    rewrite ^/(.*)$ /ui/$1 last;
  }
}

启动nginx

root@yu:/etc/nginx/conf.d# rm -rf ../sites-enabled/
root@yu:/etc/nginx/conf.d# 
root@yu:/etc/nginx/conf.d# nginx -s reload
root@yu:/etc/nginx/conf.d#

访问堡垒机nginx

image-20240402190802158

Copyright © www.yuchaoit.cn 2024 all right reserved，powered by Gitbook作者：猿来教育 2024-05-11 17:53:32

results matching ""

    No results matching ""