跳至主要內容

打包和分发软件

大约 61 分钟

打包和分发软件

来源：官方文档 原始多页入口：打包和分发软件 内容规模：约 56,468 字符，84 个章节标题，186 个命令/代码块，38 条提示框

阅读提要

  • 副标题：使用 RPM 软件包管理系统打包软件
  • 摘要：使用 RPM 软件包管理器将软件打包到 RPM 软件包中。准备打包的源代码、打包软件并调查高级打包场景，如将 Python 项目或 RubyGems 软件包打包到 RPM 软件包中。
  • 主要章节：使用 RPM 软件包管理系统打包软件；对红帽文档提供反馈；第 1 章 RPM 简介；第 2 章 设置 RPM 打包工作区；第 3 章 RPM 宏；第 4 章 为 RPM 打包创建软件；第 5 章 为 RPM 打包准备软件；第 6 章 使用 RPM 打包软件；第 7 章 打包 Python 3 RPM；第 8 章 修改 Python 脚本中的解释器指令；第 9 章 打包 Ruby gems
  • 推荐阅读顺序：先看“阅读提要”和目录，再按章节查看“关键点/命令/注意”；需要原文细节时点击来源链接。

章节笔记

概览

  • 该章节主要为下一级主题的入口。

使用 RPM 软件包管理系统打包软件

  • 要点：摘要

对红帽文档提供反馈

  • 要点：我们致力于为您提供高质量的文档，您的反馈将对我们有很大帮助。为帮助我们改进，您可以通过 Red Hat Jira 跟踪系统提交建议或报告错误。
  • 要点：步骤
  • 列表：登录到 Jira 网站。 如果您还没有帐户，请创建一个。
  • 列表：单击顶部导航栏中的 Create。
  • 列表：在 Summary 字段中输入描述性标题。
  • 列表：在 Description 字段中输入您对改进的建议。包括文档相关部分的链接。
  • 列表：点窗口底部的 Create。

第 1 章 RPM 简介

  • 要点：RPM Package Manager (RPM)是一个运行在 Red Hat Enterprise Linux (RHEL)、CentOS 和 Fedora 上的软件包管理系统。您可以使用 RPM 为任何这些操作系统所创建的软件进行分发、管理和更新。
  • 要点：与在传统存档文件中分发软件相比，RPM 软件包管理系统有以下优点：
  • 列表：RPM 以可独立安装、更新或删除软件包的形式管理软件，从而更轻松地维护操作系统。
  • 列表：RPM 简化了软件的分发，因为 RPM 软件包是独立的二进制文件，类似于压缩的存档。这些软件包是为特定的操作系统和硬件架构而构建的。RPM 包含诸如这样的文件，如在软件包安装时放到文件系统上适当路径下的已编译的可执行文件和库。
  • 列表：安装、升级和删除打包的软件。
  • 列表：查询关于打包的软件的详细信息。
  • 列表：验证打包的软件的完整性。
  • 列表：从软件源构建您自己的软件包，并完成构建说明。

1.1. RPM 软件包

  • 要点：RPM 软件包由用于在 Red Hat Enterprise Linux (RHEL)上安装和擦除这些文件的文件和元数据归档。
  • 要点：具体来说，RPM 软件包包含以下部分：
  • 列表：GPG 签名 GPG 签名用于验证软件包的完整性。
  • 列表：标头（软件包元数据） RPM 软件包管理器使用此元数据来确定软件包依赖项、安装文件的位置及其他信息。
  • 列表：payload 有效负载是一个 cpio 归档，其中包含要安装到系统的文件。
  • 列表：源 RPM（SRPM） SRPM 包含源代码和一个 spec 文件，该文件描述了如何将源代码构建为二进制 RPM。另外，SRPM 可以包含源代码的补丁。
  • 列表：二进制 RPM 一个二进制 RPM 包含了根据源代码和补丁构建的二进制文件。

1.2. 列出 RPM 打包工具

  • 要点：除了用于构建软件包的 rpmbuild (8) 程序外，RPM 还提供其他工具，使在 Red Hat Enterprise Linux (RHEL)上创建软件包的过程变得更加容易。
  • 要点：先决条件
  • 列表：rpmdevtools 软件包已安装： # dnf install rpmdevtools
  • 列表：使用以下方法之一列出 RPM 打包工具： 要列出 rpmdevtools 软件包提供的某些工具及其简短描述，请输入： $ rpm -qi rpmdevtools 要列出所有工具，请输入： $ rpm -ql rpmdevtools | grep ^/usr/bin
  • 列表：要列出 rpmdevtools 软件包提供的某些工具及其简短描述，请输入： $ rpm -qi rpmdevtools
  • 列表：要列出所有工具，请输入： $ rpm -ql rpmdevtools | grep ^/usr/bin
  • 命令/配置摘录：
# dnf install rpmdevtools
$ rpm -qi rpmdevtools

第 2 章 设置 RPM 打包工作区

  • 要点：要构建 RPM 软件包，您必须首先创建一个特殊的工作区，它由用于不同打包目的的目录组成。

2.1. 配置 RPM 打包工作区

  • 要点：通过配置 RPM 打包工作区，为您的环境做好软件打包准备。
  • 要点：要配置 RPM 打包工作区，请使用 rpmdev-setuptree 工具设置一个目录布局。
  • 列表：您已安装了 rpmdevtools 软件包，它提供打包 RPM 的工具： # dnf install rpmdevtools
  • 列表：运行 rpmdev-setuptree 程序： $ rpmdev-setuptree
  • 列表：配置打包工作区目录： $ tree ~/rpmbuild/ /home/user/rpmbuild/ |-- BUILD |-- RPMS |-- SOURCES |-- SPECS `-- SRPMS 5 directories, 0 files
  • 列表：RPM 打包工作区目录
  • 命令/配置摘录：
# dnf install rpmdevtools
$ rpmdev-setuptree

2.2. RPM 打包工作区目录

  • 要点：查看 rpmdev-setuptree 实用程序创建的以下目录以配置 RPM 打包工作区。
  • 表格样本（共 6 行）：
    • 目录 | 用途
    • BUILD | 包含从 SOURCES 目录中的源文件编译的构建工件。
    • RPMS | 二进制 RPM 在不同架构的子目录中的 RPMS 目录下创建。例如，在 x86_64 或 noarch 子目录中。
    • SOURCES | 包含压缩的源代码存档和补丁。然后，rpmbuild 命令在此目录中搜索这些存档和补丁。

第 3 章 RPM 宏

  • 要点：RPM 宏是一种直接文本替换，除了简单字面替换之外，还可以执行各种字符串操作、评估表达式、与操作系统(OS)交互和其他操作。

3.1. 显示内置 RPM 宏

  • 要点：在 Red Hat Enterprise Linux (RHEL)系统中显示内置 RPM 宏列表。RPM 提供多个内置宏，您可以使用它来简化软件包维护，并使其在软件包之间保持一致。
  • 要点：流程
  • 列表：显示内置 RPM 宏： $ rpm --showrc|grep "<builtin>”
  • 命令/配置摘录：
$ rpm --showrc|grep "<builtin>”

3.2. 显示 RPM 发布宏

  • 要点：显示 Red Hat Enterprise Linux (RHEL)系统的 RPM 发布宏。
  • 要点：不同的发行版根据被打包的软件的语言实现或发布的具体准则，提供不同的推荐 RPM 宏集合。推荐的 RPM 宏集合通常作为 RPM 软件包提供，可以使用 DNF 软件包管理器进行安装。您可以在 /usr/lib/rpm/macros.d/ 目录中找到已安装的宏文件。
  • 列表：显示原始 RPM 宏定义： $ rpm --showrc
  • 列表：确定宏做什么，以及如何在打包 RPM 时有用： $ rpm --showrc | grep <macro_name>
  • 列表：可选：显示 RPM 系统版本的 RPM 宏信息： $ rpm -ql rpm | grep macros
  • 命令/配置摘录：
$ rpm --showrc
$ rpm --showrc | grep <macro_name>

3.3. 使用宏自定义 RPM 行为

  • 要点：通过编辑 RPM 宏自定义 RPM 行为。
  • 要点：您可以在带有自定义宏的 ~/.rpmmacros 文件中覆盖除内置的宏外的任何宏。您进行的任何更改都会影响到共享同一主目录的每个系统上的每个构建。
  • 列表：自定义宏： %_topdir /opt/<directory>/rpmbuild 您可以使用 rpmdev-setuptree 工具创建 < directory >，包括所有子目录。 请注意，此宏的值默认为 ~/rpmbuild。
  • 命令/配置摘录：
%_topdir /opt/<directory>/rpmbuild
  • 注意：注意 要基于每台机器覆盖宏，请将这些宏放在 /etc/rpm/macros ClusterClaim 文件中。
  • 注意：警告 不建议使用您在 ~/.rpmmacros 文件中定义的新宏。其他机器上不会包括此类宏，用户可能想要重建您的软件包。

3.4. 在 spec 文件中定义自定义 RPM 宏

  • 要点：定义自定义 RPM 宏以简化软件包维护，并使其在软件包之间保持一致，除了使用内置和发布 RPM 宏外。RPM spec 文件可以使用 %define 和 %global 宏。
  • 要点：%define 和 %global 宏之间的区别如下：
  • 列表：%define 有全局范围，除了在 parametric 宏中使用时，其范围在此宏中是本地的。%define 宏的正文在使用时会被扩展。
  • 列表：%global 有全局范围。在定义时扩展 %global 宏的正文。
  • 列表：在宏扩展过程中，所有空格（前一个和成功）都会删除 <body >。
  • 列表：宏名称可能包含字母数字字符和下划线(_)字符。
  • 列表：包含 (opts) 字段是可选的： simple 宏不包含 (opts) 字段。在这种情况下，只执行递归宏扩展。 Parametric 选项是类似于功能的宏，可以接受参数和可能的选项。如需了解更多详细信息，请参阅 /usr/share/doc/rpm/macros.md 文件。
  • 列表：simple 宏不包含 (opts) 字段。在这种情况下，只执行递归宏扩展。
  • 命令/配置摘录：
%define date 20241114 %define upstream_version 2.5.4-pre1
  • 注意：重要 对以下操作使用 %global 宏： 避免多个冗余评估 在 parametric 宏内定义全局宏 否则，请使用 %define 宏。
  • 注意：重要 宏在 spec 文件中被评估和扩展，即使在使用 hash (#)和 spec 文件部分的行中被评估和扩展，如 %changelog。 要转义宏扩展，您可以使用 %dnl 宏来注释掉下一个新行。 您还可以通过在宏前面放置第二个百分比符号(%)来转义宏扩展，例如 %%{name}。

3.5. spec 的 %files 部分中的通用 RPM 指令

  • 要点：在 spec 文件的 %files 部分中使用以下 RPM 指令。
  • 要点：其他资源
  • 列表：spec 文件的正文项
  • 注意：重要 文档可以在软件包安装过程中排除，例如在镜像上节省磁盘空间。许可证文件可能类似于文档文件，但必须始终随软件一起安装。因此，您必须为许可证文件使用 %license 宏而不是 %doc。
  • 表格样本（共 5 行）：
    • Macro | 定义
    • %license | %license 宏标识列为许可证的文件。RPM 安装并标记此文件作为许可证，例如 %license LICENSE。
    • %doc | %doc 宏识别列为文档文件的文件。RPM 安装并标记此文件作为文档文件，例如 %doc README。 重要 文档可以在软件包安装过程中排除，例如在镜像上节省磁盘空间。许可证文件可能类似于文档文件，但必须始终随软件一起安装。因此，您必须为许可证文件使用 %license 宏而不是 %doc。 %doc 宏用于有关打包软件、代码示例和各种附带项目的文档。请注意，如果包含代码示例，在从文件中删除可执行模式时必须小心。
    • %dir | %dir 宏可确保路径是 RPM 软件包所拥有的目录。RPM 文件清单然后准确检测在卸载操作过程中要清理哪些目录。 用法示例： %dir %{_libdir}/%{name}

3.6. %autosetup 和 %setup 宏

  • 要点：使用 %autosetup 宏解包源存档并应用补丁，而不是使用 %patch 指令手动指定每个补丁。
  • 要点：您还可以使用 %setup 宏解压缩用于构建 RPM 软件包的源存档。
  • 注意：重要 %autosetup 根据在 spec 文件中出现的顺序应用补丁。始终考虑根据 spec 中的数字来保持源和补丁，以避免意外操作。或者，使用 %patchlist 或非编号 补丁 条目完全避免编号。
  • 注意：重要 尽可能使用 %autosetup 宏，而不是 %setup 宏。

3.6.1. %autosetup 宏选项

  • 要点：使用以下 %autosetup 宏选项来控制其行为。%autosetup 也接受所有 %setup 宏选项。
  • 要点：如需更多信息，请参阅系统中的 patch (1) 手册页。
  • 注意：注意 您可以组合 %autosetup 宏选项。
  • 表格样本（共 5 行）：
    • 宏选项 | 描述
    • -v | 使用 -v 选项启用 %autosetup 宏的详细程度。
    • -N | 使用 -N 选项禁用自动补丁应用程序。
    • -S<vcs_name> | 使用 -S <vcs_name > 选项指定要使用的版本控制系统(VCS)，例如 git_am,git,patch, 或 gendiff。

3.6.2. %autopatch 宏选项

  • 要点：%autopatch 宏按 spec 文件中所述的顺序应用所有补丁。使用以下 %autopatch 宏选项来控制其行为。
  • 要点：如需更多信息，请参阅系统中的 patch (1) 手册页。
  • 注意：注意 您可以组合 %autopatch 宏选项。
  • 表格样本（共 6 行）：
    • 宏选项 | 描述
    • -v | 使用 -v 选项启用 %autopatch 宏的详细程度。
    • -q | 如果没有检测到匹配的补丁，请使用 -q 选项关闭警告。
    • -p | 使用 -p 选项控制补丁前缀剥离。如需更多信息，请参阅系统中的 patch (1) 手册页。

3.6.3. %setup 宏选项

  • 要点：使用以下 %setup 宏选项来控制源存档的解包。
  • 注意：注意 您可以组合 %setup 宏选项。
  • 表格样本（共 8 行）：
    • 宏选项 | 描述
    • -q | 使用 -q 选项限制 %setup 宏的详细程度。将这个选项作为第一个选项传递给 %setup 宏。
    • -n | 使用 -n 选项指定扩展源代码存档中的目录名称。 例如，当扩展源代码存档中的目录与预期名称不同时，您可以使用这个选项(%{ <name> }-%{ <version> })，这可能会导致 '%setup 宏的错误。例如，如果软件包名称是 cello，但源代码存档名称为 hello-1.0.tgz，且包含 hello/ 目录，则 spec 文件必须具有以下内容： Name: cello Source0: https://example.com/%{name}/release/hello-%{version}.tar.gz ... %prep %setup -n hello
    • -c | 使用 the -c 选项创建一个目录，然后在解包任何源前更改到此目录，例如： /usr/bin/mkdir -p cello-1.0 cd 'cello-1.0' 归档扩展后不会更改该目录。

第 4 章 为 RPM 打包创建软件

  • 要点：为 Red Hat Enterprise Linux (RHEL)上的 RPM 打包准备您的软件源代码。

4.1. 什么是源代码

  • 要点：源代码是人类可读的计算机指令，其描述了如何执行计算。源代码是使用编程语言表达的。
  • 要点：以下三种不同编程语言编写的 Hello World 程序版本涵盖了主要的 RPM Package Manager 用例：
  • 列表：使用 Bash 编写的 hello World bello 项目使用 Bash 实现 Hello World。实现仅包含 bello shell 脚本。此程序的目的是在命令行上输出 Hello World。 bello 文件包含以下内容： #!/bin/bash printf "Hello World\n"
  • 列表：使用 Python 编写的 hello World pello 项目使用 Python 实现 Hello World。该实现仅包含 pello.py 程序。程序的目的是在命令行中输出 Hello World。 pello.py 文件包含以下内容： #!/usr/bin/python3 print("Hello World")
  • 列表：使用 C 编写的 hello World cello 项目在 C 中实现 Hello World。实现仅包含 cello.c 和 Makefile 文件。因此，除了 LICENSE 文件外，生成的 tar.gz 存档还有两个文件。程序的目的是在命令行中输出 Hello World。 cello.c 文件包含以下内容： #include <stdio.h> int main(void) { printf("Hello World\n"); return 0; }
  • 命令/配置摘录：
#!/bin/bash printf "Hello World\n"
#!/usr/bin/python3 print("Hello World")
  • 注意：注意 对于 Hello World 程序的每个版本，打包过程会是不同的。

4.2. 创建软件的方法

  • 要点：您可以通过原生编译或解释软件，将人类可读的源代码转换为机器代码。

4.2.1. 原生编译的软件

  • 要点：原生编译的软件是使用编程语言编写的软件，使用生成的二进制可执行文件编译到机器代码中。原生编译的软件是独立软件。
  • 注意：注意 原生编译的 RPM 软件包是特定于架构的。 如果您在使用 64 位(x86_64) AMD 或 Intel 处理器的计算机上编译此类软件，则它不能在 32 位(x86) AMD 或 Intel 处理器上运行。生成的软件包在其名称中指定了架构。

4.2.2. 解释的软件

  • 要点：一些编程语言，如 Bash 或 Python 不会编译成机器代码。相反，语言解释器或语言虚拟机会逐步执行程序的源代码步骤，而无需之前进行转换。
  • 要点：您可以使用解释语言编写的原始解释或字节编译软件：
  • 列表：原始解释的软件 您不需要编译这类软件。原始解释的软件由解释器直接执行。
  • 列表：字节编译的软件 您必须首先将这类软件编译成字节码，然后由语言虚拟机执行。 注意 有些字节编译的语言可以是原始解释的或字节编译的。
  • 注意：注意 完全使用解释编程语言编写的软件不是特定于架构的。因此，生成的 RPM 软件包在其名称中有 noarch 字符串。
  • 注意：注意 有些字节编译的语言可以是原始解释的或字节编译的。

4.3. 从源构建软件

  • 要点：构建使用源代码到可执行软件工件的编译语言编写的软件。

4.3.1. 从原生编译的代码构建软件

  • 要点：使用手动或自动构建，构建使用编译语言编写到可执行文件中的软件。
  • 要点：手动构建使用编译语言编写的软件。
  • 列表：从 GNU Compiler Collection 调用 C 编译器，来将源代码编译成二进制： $ gcc -g -o cello cello.c
  • 列表：运行生成的二进制文件 cello ： $ ./cello Hello World
  • 列表：在与 cello.c 相同的目录中，创建包含以下内容的 Makefile 文件： cello: gcc -g -o cello cello.c clean: rm cello 请注意，cello: 和 clean: 下的行必须以制表符(tab)开头。
  • 列表：构建软件： $ make make: 'cello' is up to date.
  • 列表：因为构建已在当前目录中可用，请重复以下步骤： 输入 make clean 命令： $ make clean rm cello 输入 make 命令： $ make gcc -g -o cello cello.c 请注意，此时尝试再次构建程序无效，因为 GNU make 系统检测到现有的二进制文件： $ make make: 'cello' is up to date.
  • 列表：输入 make clean 命令： $ make clean rm cello
  • 命令/配置摘录：
#include <stdio.h> int main(void) {  printf("Hello World\n");  return 0; }
$ gcc -g -o cello cello.c

4.3.2. 解释源代码

  • 要点：字节编译了使用编译语言编写的源代码，并使使用 shell 脚本语言编写的源代码直接可执行。
  • 要点：字节软件的流程因以下因素而异：
  • 列表：编程语言
  • 列表：语言虚拟机
  • 列表：与该语言一起使用的工具和流程
  • 列表：字节编译 pello.py 文件： $ python -m compileall pello.py
  • 列表：验证是否已创建了文件的字节编译版本： $ ls pass:[pycache] pello.cpython-311.pyc 请注意，输出中的软件包版本可能会因安装的 Python 版本而有所不同。
  • 列表：在 pello.py 中运行程序： $ python pello.py Hello World
  • 命令/配置摘录：
print("Hello World")
$ python -m compileall pello.py
  • 注意：注意 您可以对例如用 Python 编写的软件进行字节编译。用于分发的 Python 软件通常是字节编译的，但这不是以本文档中介绍的方法。上述流程目的不是为了符合社区标准，而是为了简单。
  • 注意：注意 bello 文件顶部的 shebang (#!)符号不是编程语言源代码的一部分。 使用 shebang 将文本文件转换为可执行文件。系统程序加载程序解析包含 shebang 的行，以获取二进制可执行文件的路径，其然后用作编程语言解释器。

第 5 章 为 RPM 打包准备软件

  • 要点：要准备一个使用 RPM 进行打包的软件，您可以首先给软件打补丁，为其创建一个 LICENSE 文件，并将它归档为 tar 包。

5.1. 修复软件

  • 要点：在打包软件时，您可能需要对原始源代码进行某些更改，如修复 bug 或更改配置文件。在 RPM 打包中，您可以将原始源代码保持不变，并对其应用补丁。
  • 要点：补丁是更新源代码文件的一段文本。补丁具有 diff 格式，因为它代表文本的两个版本之间的区别。您可以使用 diff 工具创建一个补丁，然后使用 patch 工具将补丁应用到源代码。
  • 注意：注意 软件开发人员通常使用版本控制系统（如 Git）来管理其代码库。这些工具提供了自己的创建区别或给软件打补丁的方法。

5.1.1. 为 C 程序示例创建一个补丁文件

  • 要点：使用 diff 实用程序，从使用 C (cello.c)编写的示例 Hello world 程序的原始源代码创建一个补丁。然后，您可以应用此补丁来对打包的软件进行更改，而无需更改原始源代码。
  • 要点：先决条件
  • 列表：您在系统上安装了 diff 工具： # dnf install diffutils
  • 列表：备份原始源代码： $ cp -p cello.c cello.c.orig -p 选项保留模式、所有权和时间戳。
  • 列表：根据需要修改 cello.c ： #include <stdio.h> int main(void) { printf("Hello World from my very first patch!\n"); return 0; }
  • 列表：生成补丁： $ diff -Naur cello.c.orig cello.c --- cello.c.orig 2016-05-26 17:21:30.478523360 -0500 +++ cello.c 2016-05-27 14:53:20.668588245 -0500 @@ -1,6 +1,6 @@ #include<stdio.h> int main(void){ - printf("Hello World!\n"); + printf("Hello World from my very first patch!\n"); return 0; } \ No newline at end of file 以 +…
  • 列表：将补丁保存到文件中： $ diff -Naur cello.c.orig cello.c > cello.patch
  • 列表：恢复原始 cello.c ： $ mv cello.c.orig cello.c 重要 您必须保留原始 cello.c，因为 RPM 软件包管理器在构建 RPM 软件包时使用原始文件，而不是修改后的文件。如需更多信息，请参阅 使用 spec 文件。
  • 命令/配置摘录：
# dnf install diffutils
$ cp -p cello.c cello.c.orig
  • 注意：注意 建议使用 diff 命令的 Naur 选项，因为它适合大多数用例： -N (--new-file) -N 选项将缺少的文件处理为空文件。 -a (--text) -a 选项将所有文件视为文本。因此，diff 工具不会忽略它归类为二进制文件的文件。 -u (-U NUM 或 --unified[=NUM]) -u 选项以统一上下文的输出 NUM （默认 3）行的形式返回输出。这是一个在补丁文件中常用的紧凑的，易读的格式。 -r (--recursive) -r 选项递归比较 diff 工具找到的任何子目录。 但请注意，在这种特殊情况下，只需要 -u 选项。
  • 注意：重要 您必须保留原始 cello.c，因为 RPM 软件包管理器在构建 RPM 软件包时使用原始文件，而不是修改后的文件。如需更多信息，请参阅 使用 spec 文件。

5.1.2. 给 C 程序示例打补丁

  • 要点：使用 patch 实用程序将代码补丁应用到使用 C (cello.c)编写的示例 Hello world 程序。
  • 要点：先决条件
  • 列表：您在系统上安装了 patch 工具： # dnf install patch
  • 列表：您从原始源代码创建了一个补丁。具体说明请参阅 为 C 程序示例创建一个补丁文件。
  • 列表：将补丁文件重定向到 patch 命令： $ patch < cello.patch patching file cello.c
  • 列表：检查 cello.c 的内容现在是否反映了这个补丁： $ cat cello.c #include<stdio.h> int main(void){ printf("Hello World from my very first patch!\n"); return 1; }
  • 列表：构建打了补丁的 cello.c 程序： $ make gcc -g -o cello cello.c
  • 列表：运行构建的 cello.c 程序： $ ./cello Hello World from my very first patch!
  • 命令/配置摘录：
# dnf install patch
$ patch < cello.patch

5.2. 创建一个 LICENSE 文件

  • 要点：要启用适当的软件使用，请创建一个许可证文件，其中包含 RPM 软件包的必要版权和法律信息。为了打包目的，还必须为许可证文件提供您要打包的软件。
  • 要点：建议您使用软件许可证分发软件。软件许可证文件告知用户他们可以做什么，而无法使用源代码。没有源代码许可证意味着您保留此代码的所有权限，任何人都不能从源代码复制、分发或创建衍生工作。
  • 列表：使用所需许可证声明创建 LICENSE 文件： $ vim LICENSE 例如，GPLv3 LICENSE 文件有以下文本： $ cat /tmp/LICENSE This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later versi…
  • 列表：源代码示例
  • 命令/配置摘录：
$ vim LICENSE
$ cat /tmp/LICENSE

5.3. 为分发创建一个源代码存档

  • 要点：为了准备软件进行分发，请将您的源代码和所需组件放入存档文件中。
  • 要点：归档文件是一个带有 .tar.gz 或 .tgz 后缀的文件。将源代码放入存档是一种发布软件以便以后打包分发的常见方法。

5.3.1. 为 Bash 程序示例创建一个源代码存档

  • 要点：要准备分发的示例 Bash 程序，请将源代码和必要的组件放入存档文件中。
  • 要点：bello 项目是一个用 Bash 写的 Hello World 文件。以下示例仅包含 bello shell 脚本。因此，生成的 tar.gz 存档除了 LICENSE 文件外只有一个文件。
  • 列表：假定使用 bello 程序的 0.1 版本。
  • 列表：您创建了一个 LICENSE 文件。具体说明，请参阅 创建一个 LICENSE 文件。
  • 列表：将所有需要的文件移到一个目录中： $ mkdir bello-0.1 $ mv ~/bello bello-0.1/ $ mv LICENSE bello-0.1/
  • 列表：为分发创建存档： $ tar -cvzf bello-0.1.tar.gz bello-0.1 bello-0.1/ bello-0.1/LICENSE bello-0.1/bello
  • 列表：将创建的存档移到 ~/rpmbuild/SOURCES/ 目录中，这是 rpmbuild 命令存储用于构建软件包的文件的默认目录： $ mv bello-0.1.tar.gz ~/rpmbuild/SOURCES/
  • 列表：使用 Bash 编写 hello World
  • 命令/配置摘录：
$ mkdir bello-0.1
$ mv ~/bello bello-0.1/
  • 注意：注意 patch 文件不在存档中随程序一起分发。构建 RPM 时，RPM 软件包管理器应用补丁。补丁将与 tar.gz 存档一起放在 ~/rpmbuild/SOURCES/ 目录中。

5.3.2. 为 Python 程序示例创建一个源代码存档

  • 要点：要准备分发的 Python 程序示例，请将源代码和必要的组件放入存档文件中。
  • 要点：pello 项目是一个用 Python 写的 Hello World 文件。以下示例仅包含 pello.py 程序。因此，生成的 tar.gz 存档除了 LICENSE 文件外只有一个文件。
  • 列表：假定使用 pello 程序的 0.1.1 版本。
  • 列表：您创建了一个 LICENSE 文件。具体说明，请参阅 创建一个 LICENSE 文件。
  • 列表：将所有需要的文件移到一个目录中： $ mkdir pello-0.1.1 $ mv pello.py pello-0.1.1/ $ mv LICENSE pello-0.1.1/
  • 列表：为分发创建存档： $ tar -cvzf pello-0.1.1.tar.gz pello-0.1.1 pello-0.1.1/ pello-0.1.1/LICENSE pello-0.1.1/pello.py
  • 列表：将创建的存档移到 ~/rpmbuild/SOURCES/ 目录中，这是 rpmbuild 命令存储用于构建软件包的文件的默认目录： $ mv pello-0.1.1.tar.gz ~/rpmbuild/SOURCES/
  • 列表：使用 Python 编写 hello World
  • 命令/配置摘录：
$ mkdir pello-0.1.1
$ mv pello.py pello-0.1.1/
  • 注意：注意 patch 文件不在存档中随程序一起分发。构建 RPM 时，RPM 软件包管理器应用补丁。补丁将与 tar.gz 存档一起放在 ~/rpmbuild/SOURCES/ 目录中。

5.3.3. 为 C 程序示例创建一个源代码存档

  • 要点：要准备分发的 C 程序示例，请将源代码和必要的组件放入存档文件中。
  • 要点：cello 项目是 C 中的 Hello World 文件。以下示例仅包含 cello.c 和 Makefile 文件。因此，生成的 tar.gz 存档除了 LICENSE 文件有两个文件。
  • 列表：假定使用 cello 程序的 1.0 版本。
  • 列表：您创建了一个 LICENSE 文件。具体说明，请参阅 创建一个 LICENSE 文件。
  • 列表：将所有需要的文件移到一个目录中： $ mkdir cello-1.0 $ mv cello.c cello-1.0/ $ mv Makefile cello-1.0/ $ mv LICENSE cello-1.0/
  • 列表：为分发创建存档： $ tar -cvzf cello-1.0.tar.gz cello-1.0 cello-1.0/ cello-1.0/Makefile cello-1.0/cello.c cello-1.0/LICENSE
  • 列表：将创建的存档移到 ~/rpmbuild/SOURCES/ 目录中，这是 rpmbuild 命令存储用于构建软件包的文件的默认目录： $ mv cello-1.0.tar.gz ~/rpmbuild/SOURCES/
  • 列表：使用 C 语言编写的 hello World
  • 命令/配置摘录：
$ mkdir cello-1.0
$ mv cello.c cello-1.0/
  • 注意：注意 patch 文件不在存档中随程序一起分发。构建 RPM 时，RPM 软件包管理器应用补丁。补丁将与 tar.gz 存档一起放在 ~/rpmbuild/SOURCES/ 目录中。

第 6 章 使用 RPM 打包软件

  • 要点：了解打包流程与 RPM 软件包管理器的基础知识。

6.1. 关于 spec 文件

  • 要点：spec 文件是一个包含 rpmbuild 工具用来构建 RPM 软件包的指令的文件。
  • 要点：spec 文件通过在一系列小节中定义指令来为构建系统提供必要的信息。这些部分在 spec 文件的 Preamble 和 Body 部分中定义：
  • 列表：Preamble 部分包含一系列在 Body 部分中使用的元数据项。
  • 列表：Body 部分代表说明的主要部分。

6.1.1. spec 文件的 preamble 项

  • 要点：在 RPM spec 文件的 Preamble 部分中使用以下指令。
  • 表格样本（共 16 行）：
    • 指令 | 定义
    • Name | 软件包的基本名称必须与 spec 文件名匹配。
    • Version | 软件的上游版本号。
    • 发布 | 软件包版本发布的次数。 将初始值设置为 1%{?dist}，并随着软件包的每次新发布而增加该值。当构建软件的新 版本 时，重置为 1。

6.1.2. spec 文件的正文项

  • 要点：在 RPM spec 文件的 Body 部分中，使用以下指令：
  • 表格样本（共 9 行）：
    • 指令 | 定义
    • %description | RPM 中打包的软件的完整描述。此描述可跨越多行，并且可以分为几个段落。
    • %prep | 准备进行构建的软件的命令或一系列命令，例如，在 Source 指令中解压缩存档。%prep 指令可以包含 shell 脚本。
    • %conf | 用于配置用于构建的软件的命令或一系列命令。

6.1.3. 高级 spec 文件项

  • 要点：spec 文件可以包含高级项目，如 Scriptlets、File 触发器和 Triggers。这些指令会影响 spec 文件，以及通过更新 RPM 中信息安装结果 RPM 的目标操作系统。
  • 要点：Scriptlets、File Triggers 和 Triggers 在目标系统的安装过程中的不同点生效，而不是构建过程：
  • 列表：Scriptlets 在安装或删除软件包之前或之后无条件执行。
  • 列表：当指定触发器条件与安装系统上的其他软件包匹配或事务中的其他软件包匹配时，触发器会被有条件执行。
  • 列表：当指定路径前缀与安装的系统或事务中的其他文件匹配时，就会有条件地执行文件触发器。
  • 列表：--nopre
  • 列表：--nopost
  • 列表：--nopreun
  • 命令/配置摘录：
# rpm --no<scriptlet_name>
# rpm --nopretrans
  • 注意：注意 宏的行为方式可能会改变。例如，宏的行为可能会随着软件包的开发而改变。
  • 表格样本（共 7 行）：
    • 指令 | 描述
    • %pretrans | %pretrans scriptlet 在安装或删除软件包前执行。
    • %pre | %pre scriptlet 在目标系统上安装软件包之前执行。
    • %post | %post scriptlet 在目标系统上安装软件包后执行。

6.1.4. Epoch 指令

  • 要点：如果设置 Version spec file 指令不足以比较软件包版本，您可以使用 Epoch 指令。例如，您可以使用 Epoch 解决所发生的升级路径问题，因为上游更改以不兼容的方式在版本号方案中。
  • 要点：epoch 是一个数字字段。如果您为 Epoch 分配了一个值，它会添加一个 RPM 在比较软件包版本时使用的限定符。没有在 spec 文件中列出的 Epoch 指令意味着未设置 Epoch。这与不设置 Epoch 而通常的原则不同，即 Epoch 为 0。但是，出于处理目的，如果您没有设置 Epoch，RPM 将其视为与 Epoch 设置为 0 时一样，反之亦然。
  • 注意：重要 在 spec 文件中使用 Epoch 通常会省略，因为在大多数情况下，在大多数情况下，引入了一个 Epoch 值，在比较软件包时，会中断预期的 RPM 行为。因此，请考虑使用 Epoch 作为最后的手段。 例如，您使用 Epoch: 1 和 Version: 1.0 安装 foobar 软件包。另一个软件包 foobar with Version: 2.0，但没有 Epoch 指令。因此，新版本永远不会被视为更新，因为 Epoch 版本优先于为 RPM 软件包版本控制的传统 Name-Version-Release 标记。

6.1.5. 软件包版本基本

  • 要点：软件包描述的基本部分是 Name,Version, 和 Release (NVR) spec 文件指令中定义的信息。RPM 使用此信息比较软件包版本并跟踪软件包依赖项。
  • 要点：使用 RPM 时，您还可以看到 EVR (epoch-version-release), NEVR (name-epoch-version-release)和 NEVRA (name-epoch-version-release-architecture)。EVR 是 RPM 始终用来比较的软件包的完整版本信息。RPM 一次比较一个组件，从第一个组件开始。当发现组件的不同时，RPM 将停止此比较。例如，如果 Epoch 不同，RPM 不会比较 EVR 组件的其余部分。
  • 列表：spec 文件的 preamble 项
  • 命令/配置摘录：
# rpm -q bash bash-4.4.19-7.el8.x86_64
  • 注意：注意 rpm -q 命令默认以 NEVRA 格式显示软件包信息。

6.2. spec 文件条件

  • 要点：使用 spec 文件条件启用 spec 文件的各种部分的条件。
  • 要点：条件通常会处理以下方面：
  • 列表：特定于架构的章节。
  • 列表：特定于操作系统的章节。
  • 列表：不同操作系统版本之间的兼容性问题。
  • 列表：条件表达式(1)。您可以将 %if 用于多个目的。例如，它可以具有以下语法： "如果表达式为 true，则执行一些操作： %if expression ... %endif "如果表达式为 true，则执行一些操作，否则执行另一个操作： %if expression ... %elsif expression ... %else ... %endif %if 也可以跟着任意数量的 %elif 条件（嵌套 %elsif），例如： %if expression %elif expression ... %else %endif
  • 列表："如果表达式为 true，则执行一些操作： %if expression ... %endif
  • 列表："如果表达式为 true，则执行一些操作，否则执行另一个操作： %if expression ... %elsif expression ... %else ... %endif
  • 命令/配置摘录：
%if expression ... %endif
%if expression ... %elsif expression ... %else ... %endif

6.2.1. 使用 %if 条件的示例

  • 要点：查看以下示例，以演示如何在 spec 文件中使用 %if 条件。
  • 要点：例 6.1. 使用 %if 条件来处理 Red Hat Enterprise Linux 10 和其他操作系统间的兼容性
  • 命令/配置摘录：
%if 0%{?rhel} == 10 sed -i '/AS_FUNCTION_DESCRIBE/ s/^/#/' configure.in sed -i '/AS_FUNCTION_DESCRIBE/ s/^/#/' acinclude.m4 %endif
%define ruby_archive %{name}-%{ruby_version} %if 0%{?milestone:1}%{?revision:1} != 0 %define ruby_archive %{ruby_archive}-%{?milestone}%{?!milestone:%{?revision:r%{revision}}} %endif

6.2.2. %if 条件的专用变体

  • 要点：查看以下可在 spec 文件中使用的专用 %if 条件语句来指定系统架构或操作系统。
  • 要点：%if 条件的专用变体包括 %ifarch、%ifnarch 和 %ifos 条件。这些条件通常用于使用，因此有自己的宏。
  • 表格样本（共 4 行）：
    • 条件 | 描述
    • %ifarch | 使用 %ifarch 条件开始特定于架构的 spec 文件的块。条件后跟一个或多个架构说明符，各自用逗号或空格分开，例如： %ifarch i386 sparc ... %endif %ifarch 和 %endif 之间的 spec 文件的所有内容仅在 32 位 AMD 和 Intel 构架或基于 Sun SPARC 的系统上时才被处理。
    • %ifnarch | %ifnarch 条件的逻辑与 %ifarch 条件的逻辑相反。 %ifnarch aarch64 ... %endif 只有在具有 64 位 ARM 架构的系统上未执行时，才会处理 %ifnarch 和 %endif 之间的 spec 文件的内容。
    • %ifos | 使用 %ifos 条件根据构建的操作系统控制处理。条件可以后跟一个或多个操作系统名称，例如： %ifos linux ... %endif 只有在 Linux 系统上完成构建时，才会处理 %ifos 和 %endif 之间的 spec 文件的内容。

6.2.3. 其他资源

  • 列表：关于 spec 文件

6.3. BuildRoots

  • 要点：buildroot 是一个 chroot 环境，充当 RPM 构建工件的根目录。构建这些工件以匹配目标层次结构，可确保 RPM 在安装过程中保留正确的文件系统布局。
  • 要点：buildroot 中的文件稍后放入 RPM 有效负载中。这个有效负载成为 RPM 的主要部分。当在最终用户的系统中安装 RPM 软件包时，这些文件将提取到 root 目录中，保留正确的层次结构。
  • 注意：注意 rpmbuild 程序有自己的默认值。覆盖这些默认值可能导致某些问题。因此，请避免定义您自己的 buildroot 宏的值。改为使用默认的 %{buildroot} 宏。

6.4. 使用 spec 文件

  • 要点：要使用 RPM 打包新软件，您必须创建一个 spec 文件。
  • 要点：您可以使用以下方法之一创建 spec 文件：
  • 列表：从头开始手动编写新的 spec 文件。
  • 列表：使用 rpmdev-newspec 工具。这个工具会创建一个未填充的 spec 文件，您可以在其中填充必要的指令和字段。
  • 注意：注意 某些以程序员为中心的文本编辑器，预先使用自己的 spec 模板填充一个新的 spec 文件。rpmdev-newspec 工具提供了一个与编辑器无关的方法。

6.4.1. 为 Bash、Python 和 C 程序示例创建一个新的 spec 文件

  • 要点：使用 rpmdev-newspec 实用程序为 Hello World! 程序的三个示例实现创建一个 spec 文件。
  • 要点：先决条件
  • 列表：以下 Hello World! 程序实现被放在 ~/rpmbuild/SOURCES 目录中： bello-0.1.tar.gz pello-0.1.2.tar.gz cello-1.0.tar.gz (cello-output-first-patch.patch)
  • 列表：bello-0.1.tar.gz
  • 列表：pello-0.1.2.tar.gz
  • 列表：cello-1.0.tar.gz (cello-output-first-patch.patch)
  • 列表：进到 ~/rpmbuild/SPECS 目录： $ cd ~/rpmbuild/SPECS
  • 列表：为 Hello World! 程序的三个实现创建一个 spec 文件： $ rpmdev-newspec bello bello.spec created; type minimal, rpm version >= 4.11. $ rpmdev-newspec cello cello.spec created; type minimal, rpm version >= 4.11. $ rpmdev-newspec pello pello.spec created; type minimal, rpm version >= 4.11. ~/rpmbuild/SPECS/ 目录现在包含三个 spec 文件，名为 bello.spec、…
  • 命令/配置摘录：
$ cd ~/rpmbuild/SPECS
$ rpmdev-newspec bello

6.4.2. 修改原始 spec 文件

  • 要点：通过修改 rpmdev-newspec 实用程序生成的原始输出 spec 文件，为 rpmbuild 实用程序提供必要的指令。然后，rpmbuild 使用这些指令来构建 RPM 软件包。
  • 要点：先决条件
  • 列表：未填充的 ~/rpmbuild/SPECS/<name>.spec spec 文件是使用 rpmdev-newspec 工具创建的。如需更多信息，请参阅 为 Bash、Python 和 C 程序示例创建一个新的 spec 文件。
  • 列表：打开 rpmdev-newspec 工具提供的 ~/rpmbuild/SPECS/<name>.spec 文件。
  • 列表：填充 spec 文件 Preamble 部分的以下指令： 名称 ：Name 已指定为 rpmdev-newspec 的参数。 Version ：设置 Version 以匹配源代码的上游版本。 Release:Release 自动设置为 1%{?dist}，这最初是 1。 Summary: 输入软件包的单行说明。 License: 输入与源代码关联的软件许可证。 URL ：输入到上游软件网站的 URL。为实现一致性，请使用 %{name} RPM 宏变量，并使用 https://example.com/%{name} 格式。 Source: 输入上游软件源代码的 URL。直接到被打包的软件版本的连接。 注意 本文档中的 URL 示例…
  • 列表：名称 ：Name 已指定为 rpmdev-newspec 的参数。
  • 列表：Version ：设置 Version 以匹配源代码的上游版本。
  • 列表：Release:Release 自动设置为 1%{?dist}，这最初是 1。
  • 注意：注意 本文档中的 URL 示例包括可能在以后更改的硬编码的值。同样，发行版本也可以更改。要简化这些潜在的更改，请使用 %{name} 和 %{version} 宏。通过使用这些宏，您只需要更新 spec 文件中的一个字段。

6.4.3. Bash 程序示例的 spec 文件示例

  • 要点：查看以下为使用 Bash 编程语言编写的示例程序示例 spec 文件(bello)。
  • 要点：要安装 bello，您必须创建目标目录，并在其中安装可执行的 bash 脚本文件。因此，您可以在 %install 部分中使用 install 命令。您可以使用 RPM 宏来执行此操作，而无需硬编码路径。
  • 列表：BuildRequires 指令指定软件包的 build-time 依赖项已被删除，因为没有可用于 bello 的构建步骤。Bash 是原始解释编程语言，文件仅安装到其系统上的位置。
  • 列表：Requires 指令，其指定软件包的运行时依赖项，仅包含 Bash，因为 bello 脚本只需要 Bash shell 环境即可执行。
  • 列表：指定如何构建软件的 %build 部分为空，因为不需要构建 bash 脚本。
  • 列表：什么是源代码
  • 命令/配置摘录：
Name: bello Version: 0.1 Release: 1%{?dist} Summary: Hello World example implemented in bash script License: GPLv3+ URL: https://www.example.com/%{name} Source0: https://www.example.com/%{name}/releases/%{name}-%{version}.tar.gz Requires: bash BuildArch: noarch %description The long-tail description for our Hello World Example implemented in bash script. %prep %setup -q %build %install mkdir -p %{buildroot}/%{_bindir} install -m 0755 %{name} %{buildroot}/%{_bindir}/%{name} %files %license LICENSE %{_bindir}/%{name} %changelog * Tue May 31 2016 Adam Miller <maxamillion@fedoraproject.org> - 0.1-1 - First bello package - Example second item in …

6.4.4. Python 程序示例的 spec 文件示例

  • 要点：查看以下为使用 Python 编程语言编写的示例程序的 spec 文件示例文件(pello)。
  • 要点：在 spec 文件中内联创建包装程序脚本的示例表明 spec 文件本身是可以写成脚本的。此打包程序脚本使用 此文档 来执行 Python 字节编译代码。
  • 列表：Requires 指令指定软件包的运行时依赖项，其中包括两个软件包： 在运行时执行字节编译的代码所需的 python 软件包。 执行小入口点脚本所需的 bash 软件包。
  • 列表：在运行时执行字节编译的代码所需的 python 软件包。
  • 列表：执行小入口点脚本所需的 bash 软件包。
  • 列表：BuildRequires 指令指定软件包的 build-time 依赖项，它只包括 python 软件包。pello 程序需要 python 来执行字节编译构建过程。
  • 列表：%build 部分指定如何构建软件，创建脚本的字节编译版本。请注意，在实际打包中，它通常会根据所使用的发行版自动完成。
  • 列表：%install 部分对应于这样的事实，即您必须将字节文件安装到系统上的库目录中，以便可以访问它。
  • 命令/配置摘录：
Name: pello Version: 0.1.1 Release: 1%{?dist} Summary: Hello World example implemented in Python License: GPLv3+ URL: https://www.example.com/%{name} Source0: https://www.example.com/%{name}/releases/%{name}-%{version}.tar.gz BuildRequires: python Requires: python Requires: bash BuildArch: noarch %description The long-tail description for our Hello World Example implemented in Python. %prep %setup -q %build python -m compileall %{name}.py %install mkdir -p %{buildroot}/%{_bindir} mkdir -p %{buildroot}/usr/lib/%{name} cat > %{buildroot}/%{_bindir}/%{name} <<EOF #!/bin/bash /usr/bin/python /usr/lib/%{name}/%{name}.pyc EOF chmod 0755 %{buildroo…

6.4.5. C 程序示例的 spec 文件示例

  • 要点：查看以下注解为使用 C 编程语言编写的示例程序的示例 spec 文件(cello)。
  • 要点：您可以使用 %make_install 宏安装 cello 程序。这是可能是因为 cello 程序的 Makefile 文件可用。
  • 列表：BuildRequires 指令，其指定软件包的 build-time 依赖项，包括以下执行编译构建过程所需的软件包： gcc make
  • 列表：gcc
  • 列表：make
  • 列表：本例中省略了该软件包的运行时依赖项 Requires 指令。所有运行时要求都由 rpmbuild 进行处理，而 cello 程序不需要核心 C 标准库之外的任何内容。
  • 列表：%build 部分反映了这样一个事实，即此示例中，为 cello 程序编写了 Makefile 文件。因此，您可以使用 GNU make 命令。但是，您必须删除对 %configure 的调用，因为您没有提供配置脚本。
  • 列表：什么是源代码
  • 命令/配置摘录：
Name: cello Version: 1.0 Release: 1%{?dist} Summary: Hello World example implemented in C License: GPLv3+ URL: https://www.example.com/%{name} Source0: https://www.example.com/%{name}/releases/%{name}-%{version}.tar.gz Patch0: cello-output-first-patch.patch BuildRequires: gcc BuildRequires: make %description The long-tail description for our Hello World Example implemented in C. %prep %setup -q %patch0 %build make %{?_smp_mflags} %install %make_install %files %license LICENSE %{_bindir}/%{name} %changelog * Tue May 31 2016 Adam Miller <maxamillion@fedoraproject.org> - 1.0-1 - First cello package

6.5. 构建 RPM

  • 要点：使用 rpmbuild 实用程序构建示例 bello、pello 和 cello 程序的 RPM 软件包。
  • 要点：不同的用例需要不同的参数组合到 rpmbuild 命令。以下是主要用例：
  • 列表：构建源 RPM.
  • 列表：构建二进制 RPM： 从源 RPM 重新构建二进制 RPM 。 从 spec 文件构建二进制 RPM。
  • 列表：从源 RPM 重新构建二进制 RPM 。
  • 列表：从 spec 文件构建二进制 RPM。
  • 注意：注意 使用 rpmbuild 命令时，期望某个目录和文件结构，它们与 rpmdev-setuptree 实用程序配置的结构相同。

6.5.1. 构建源 RPM

  • 要点：使用 rpmbuild 实用程序将 bello、pello 和 cello 示例程序的源代码放在源 RPM (SRPM)软件包中。
  • 要点：构建源 RPM (SRPMs)具有以下优点：
  • 列表：您可以保留部署到环境中的 RPM 文件的特定 Name-Version-Release (NVR)的确切源。这包括确切的 spec 文件、源代码以及所有相关的补丁。这对于跟踪和调试目的很有用。
  • 列表：您可以在不同的硬件平台或构架上构建二进制 RPM。
  • 列表：您在您的系统上安装了 rpmbuild 工具： # dnf install rpm-build
  • 列表：您可以将以下 Hello World! 实现放在 ~/rpmbuild/SOURCES/ 目录中： bello-0.1.tar.gz pello-0.1.2.tar.gz cello-1.0.tar.gz ( cello-output-first-patch.patch )
  • 列表：bello-0.1.tar.gz
  • 列表：pello-0.1.2.tar.gz
  • 命令/配置摘录：
# dnf install rpm-build
$ cd ~/rpmbuild/SPECS/

6.5.2. 从源 RPM 重新构建一个二进制 RPM

  • 要点：使用 rpmbuild 实用程序从其源 RPM (SRPM)软件包重建示例 bello、pello 和 cello 程序的二进制 RPM 软件包。然后您可以在多个系统中安装并运行二进制软件包。
  • 要点：创建二进制 RPM 时产生的输出非常详细，这对调试非常有用。输出因不同的示例而异，并对应于其 spec 文件。
  • 列表：~/rpmbuild/RPMS/YOURARCH，其中 YOURARCH 是您的构架
  • 列表：如果软件包没有特定于架构，则 ~/rpmbuild/RPMS/noarch/
  • 列表：您在您的系统上安装了 rpmbuild 工具： # dnf install rpm-build
  • 列表：导航到 ~/rpmbuild/SRPMS/ 目录，其包含 SRPM： $ cd ~/rpmbuild/SRPMS/
  • 列表：从 SRPM 重建二进制 RPM： $ rpmbuild --rebuild <srpm> 例如，要从 SRPMs 中重建 bello、pello 和 cello，请完成以下步骤： 重建 bello 程序： $ rpmbuild --rebuild bello-0.1-1.el8.src.rpm 重建 pello 程序： $ rpmbuild --rebuild pello-0.1.2-1.el8.src.rpm 重建 cello 程序： $ rpmbuild --rebuild cello-1.0-1.el8.src.rpm 注意 调用 rpmbuild --rebuild 涉及以下过程： 将 SRPM 的内容(spec 文件和…
  • 列表：重建 bello 程序： $ rpmbuild --rebuild bello-0.1-1.el8.src.rpm
  • 命令/配置摘录：
# dnf install rpm-build
$ cd ~/rpmbuild/SRPMS/
  • 注意：注意 调用 rpmbuild --rebuild 涉及以下过程： 将 SRPM 的内容(spec 文件和源代码)安装到 ~/rpmbuild/ 目录中。 使用安装的内容构建一个 RPM。 删除 spec 文件和源代码。 在使用以下任一方法构建后，您可以保留 spec 文件和源代码： 在构建 RPM 时，请使用 rpmbuild 命令和 --recompile 选项，而不是 --rebuild 选项。 为 bello、pello 和 cello 程序安装 SRPMs： 安装 SRPM for bello ： $ rpm -Uvh ~/rpmbuild/SRPMS/bello-0.1-1.el8.src.rpm Updating / installing... 1:bello-0.1-1.el8 [100%] 为 pello 安装 SRPM： $ rpm -Uvh ~/rpmbuild/SRPMS/pello-0.1.2-1.el8.src.rpm Updating / installing... ...1:pello-0.1.2-1.el8 [100%] 安装 SRPM for ce…

6.5.3. 从 spec 文件构建二进制 RPM

  • 要点：使用 rpmbuild 命令从 规格 文件中构建示例 bello、pello 和 cello 程序的二进制 RPM。
  • 要点：先决条件
  • 列表：您已在系统上安装了 rpmbuild 工具： # dnf install rpm-build
  • 列表：导航到 ~/rpmbuild/SPECS/ 指令，其包含 spec 文件： $ cd ~/rpmbuild/SPECS/
  • 列表：从其 spec 构建二进制 RPM： $ rpmbuild -bb <spec_file> 例如，要从其 spec 文件构建 bello、pello 和 cello 二进制 RPM，请完成以下步骤： 构建 bello 程序： $ rpmbuild -bb bello.spec 构建 pello 程序： $ rpmbuild -bb pello.spec 构建 cello 程序： $ rpmbuild -bb cello.spec
  • 列表：构建 bello 程序： $ rpmbuild -bb bello.spec
  • 列表：构建 pello 程序： $ rpmbuild -bb pello.spec
  • 列表：构建 cello 程序： $ rpmbuild -bb cello.spec
  • 命令/配置摘录：
# dnf install rpm-build
$ cd ~/rpmbuild/SPECS/

6.6. 将 RPM 活动记录到 syslog

  • 要点：使用系统日志协议(syslog)记录任何 RPM 活动或事务。
  • 要点：先决条件
  • 列表：syslog 插件已安装在系统上： # dnf install rpm-plugin-syslog 注意 syslog 消息的默认位置是 /var/log/messages 文件。但是，您可以将 syslog 配置为使用另一个位置来存储消息。
  • 列表：打开您配置为存储 syslog 消息的文件。 或者，如果您使用默认的 syslog 配置，请打开 /var/log/messages 文件。
  • 列表：搜索包括 [RPM] 字符串的新行。
  • 命令/配置摘录：
# dnf install rpm-plugin-syslog
  • 注意：注意 syslog 消息的默认位置是 /var/log/messages 文件。但是，您可以将 syslog 配置为使用另一个位置来存储消息。

6.7. 提取 RPM 内容

  • 要点：要访问软件包的内容，请提取 RPM 文件。
  • 要点：在某些情况下，例如，如果 RPM 需要的软件包损坏了，您可能需要提取软件包的内容。在这种情况下，如果 RPM 安装仍正常工作，您可以使用 rpm2archive 实用程序将 .rpm 文件转换为 tar 存档以使用软件包的内容。
  • 列表：将 RPM 文件转换为 tar 归档： $ rpm2archive <filename>.rpm 生成的文件具有 .tgz 后缀。例如，要从 bash 软件包创建一个归档，请完成以下步骤： 将 bash RPM 软件包转换为 tar 归档： $ rpm2archive bash-4.4.19-6.el8.x86_64.rpm 显示归档文件的内容： $ ls bash-4.4.19-6.el8.x86_64.rpm.tgz bash-4.4.19-6.el8.x86_64.rpm.tgz
  • 列表：将 bash RPM 软件包转换为 tar 归档： $ rpm2archive bash-4.4.19-6.el8.x86_64.rpm
  • 列表：显示归档文件的内容： $ ls bash-4.4.19-6.el8.x86_64.rpm.tgz bash-4.4.19-6.el8.x86_64.rpm.tgz
  • 命令/配置摘录：
$ rpm2archive <filename>.rpm
$ rpm2archive bash-4.4.19-6.el8.x86_64.rpm
  • 注意：注意 如果 RPM 安装严重损坏，您可以使用 rpm2cpio 工具将 RPM 软件包文件转换为 cpio 存档。

6.8. 签名 RPM 软件包

  • 要点：为 RPM 软件包签名，以确保任何第三方都不能更改其内容。
  • 要点：您可以使用以下软件之一签署 RPM 软件包：
  • 列表：Sequoia PGP 支持 OpenPGP 标准。RPM 也使用 Sequoia PGP 来验证软件签名。
  • 列表：GNU Privacy Guard (GnuPG)支持旧的 OpenPGP 标准版本，这使得 GnuPG 与 RHEL 9 及更早的版本更加兼容。
  • 注意：警告 从版本 10.1 开始，RHEL 支持 OpenPGPv6 和 RPMv6 签名。这些签名与早期版本的 RHEL 不兼容。这些版本上的 RPM 忽略了这样的签名。如果软件包包含 RPMv4 签名，RPM 会使用它。 但是，在 RHEL 9.7 及更新的版本中，您可以使用 multisig DNF 插件启用对 OpenPGPv6 和 RPMv6 签名的支持。

6.8.1. 使用 GnuPG 签名 RPM 软件包

  • 要点：使用 GNU Privacy Guard (GnuPG)签名 RPM 软件包，以确保任何第三方都不能更改其内容。
  • 要点：要使用 GNU Privacy Guard (GnuPG)软件签署 RPM 软件包，请首先创建一个 OpenPGP 密钥。
  • 列表：您已在您的系统上安装了 rpm-sign 和 pinentry 软件包。
  • 列表：生成一个 OpenPGP 密钥对： $ gpg --gen-key
  • 列表：检查生成的密钥对： $ gpg --list-keys
  • 列表：导出公钥： $ gpg --export -a '<public_key_name>' > RPM-GPG-KEY-pmanager
  • 列表：配置 RPM 以使用 GnuPG 签名软件包。
  • 列表：向 RPM 软件包添加一个签名。
  • 命令/配置摘录：
$ gpg --gen-key
$ gpg --list-keys

6.8.2. 使用 Sequoia PGP 签名 RPM 软件包

  • 要点：使用 Sequoia PGP 为 RPM 软件包进行签名，以确保任何第三方都不能更改其内容。
  • 要点：要使用 Sequoia PGP 软件签署软件包，请首先创建一个 OpenPGP 密钥。
  • 列表：安装 Sequoia PGP 工具： # dnf install sequoia-sq
  • 列表：生成一个 OpenPGP 密钥对： $ sq key generate --own-key --userid <key_name>
  • 列表：检查生成的密钥对： $ sq key list
  • 列表：导出公钥： $ sq cert export --cert-userid '<key_name>' > RPM-PGP-KEY-pmanager
  • 列表：配置 RPM ，以使用 Sequoia PGP 签名软件包。
  • 列表：向 RPM 软件包添加签名。
  • 命令/配置摘录：
# dnf install sequoia-sq
$ sq key generate --own-key --userid <key_name>
  • 注意：注意 与 GnuPG 不同，Sequoia PGP 仅接受完整的密钥 ID 或指纹。

6.8.3. 使用 PQC 使用 Sequoia PGP 签名 RPM 软件包

  • 要点：使用 Sequoia PGP 使用 PQC 算法签署 RPM 软件包，以确保任何第三方不能更改其内容。
  • 要点：post-quantum 加密(PQC)是一组算法，旨在通过量级计算机实现攻击，从而增强软件安全性。
  • 列表：安装 Sequoia PGP 工具： # dnf install sequoia-sq
  • 列表：生成一个 OpenPGP 密钥对： $ sq key generate --own-key --expiration=never \ --cannot-authenticate --cannot-encrypt \ --email <vendor_email> --name "<vendor_name>" \ --cipher-suite mldsa87 --profile rfc9580 将 <vendor_email > 和 & lt;vendor_name> 替换为提供 RPM 软件包的软件包的电子邮件和软件厂商的名称。 这个命令生成一个主密钥和签名子密钥。
  • 列表：检查生成的密钥对： $ sq key list --cert-email <vendor_email> - <ml_dsa_fingerprint> - user IDs: - <vendor_email> (authenticated) - <vendor_name> (authenticated) - created 2025-10-03 14:36:44 UTC - usable for signing - @softkeys/<ml_dsa_fingerprint>: available, unlocked - <subkey_fingerprint> - created 2025-10-03 14:36…
  • 列表：导出 PQC OpenPGP 证书： $ sq cert export --cert-email '<vendor_email>' > RPM-PGP-KEY-VENDOR
  • 列表：为 PQC 配置 RPM。
  • 列表：您创建了 PQC 密钥对。如需更多信息，请参阅创建 PQC 密钥。
  • 命令/配置摘录：
# dnf install sequoia-sq
$ sq key generate --own-key --expiration=never \ --cannot-authenticate --cannot-encrypt \ --email <vendor_email> --name "<vendor_name>" \ --cipher-suite mldsa87 --profile rfc9580
  • 注意：重要 在添加任何使用 PQC 算法的 RPMv6 签名前，始终考虑将 RPMv4 兼容签名添加到软件包中。这样可确保软件包在 RHEL 10.1 之前的版本上具有 RPM 的签名可以进行验证。

第 7 章 打包 Python 3 RPM

  • 要点：您可以使用 DNF 软件包管理器在系统中安装 Python 软件包。DNF 使用 RPM 软件包格式，它提供了更好的软件下游控制。
  • 要点：与原生 Python 软件包相比，将 Python 项目打包成 RPM 软件包提供了以下优点：
  • 列表：可以依赖于 Python 和非 Python 软件包，并严格由 DNF 软件包管理器强制执行。
  • 列表：您可以用加密的方式为软件包签名。使用加密签名，您可以验证、集成和测试 RPM 软件包的内容以及操作系统的其余部分。
  • 列表：您可以在构建过程中运行测试。

7.1. 示例 Python 软件包的 spec 文件描述

  • 要点：参阅以下 python3-pello 软件包示例中有关 Python RPM spec 文件的备注。
  • 要点：与非 Python RPM spec 文件相比，Python 项目的 RPM spec 文件有一些具体信息。例如，建议任何 Python 库的 RPM 软件包名称包含 python3- 前缀。
  • 列表：通过定义 python3_pkgversion 宏，您可以设置将为哪个 Python 版本构建此软件包。要为默认的 Python 版本 3.12 进行构建，请删除该行。
  • 列表：将 Python 项目打包到 RPM 中时，需要将 python- 前缀添加到项目的原始名称中。这里的项目名称是 Pello，因此源 RPM (SRPM)的名称是 python-pello。
  • 列表：BuildRequires 指定了构建和测试此软件包所需的软件包。在 BuildRequires 中，始终包含 python3-devel 和其他构建 Python 软件包的工具。另外，列出软件所需的项目，如 python3-setuptools。在 %check 部分中添加需要运行测试的任何运行时和测试依赖项。
  • 列表：当为二进制 RPM 选择名称（用户必须安装的软件包）时，请添加版本化的 Python 前缀。对默认的 Python 3.12 使用 python3- 前缀。您可以使用 %{python3_pkgversion} 宏，对于默认的 Python 版本 3.12 其评估为 3，除非您将其设置为明确的版本，例如，当有较新版本的 Python 可用时（请参阅脚注 1）。
  • 列表：%py3_build 和 %py3_install 宏会分别运行 setup.py build 和 setup.py install 命令，使用附加参数来指定安装位置、要使用的解释器以及其他详情。 注意 使用 setuptools 软件包中的 setup.py build 和 setup.py install 命令已弃用。对于现代项目，请使用 pyproject-rpm-macros 包中的 pyproject RPM 宏。有关更多信息，请参阅使用pyproject RPM宏打包Python项目。
  • 列表：%check 部分运行打包项目的测试。确切的命令取决于项目本身，但您可以使用 %pytest 宏以 RPM 友好的方式运行 pytest 命令。
  • 命令/配置摘录：
%global python3_pkgversion 3 Name: python-pello Version: 1.0.2 Release: 1%{?dist} Summary: Example Python library License: MIT URL: https://github.com/fedora-python/Pello Source: %{url}/archive/v%{version}/Pello-%{version}.tar.gz BuildArch: noarch BuildRequires: python%{python3_pkgversion}-devel # Build dependencies need to be specified manually BuildRequires: python%{python3_pkgversion}-setuptools # Test dependencies need to be specified manually # Runtime dependencies need to be BuildRequired manually to run tests during build BuildRequires: python%{python3_pkgversion}-pytest >= 3 %global _description %{expand: Pello is an example package …
  • 注意：注意 使用 setuptools 软件包中的 setup.py build 和 setup.py install 命令已弃用。对于现代项目，请使用 pyproject-rpm-macros 包中的 pyproject RPM 宏。有关更多信息，请参阅使用pyproject RPM宏打包Python项目。

7.2. Python 3 RPM 的常见宏

  • 要点：在 Python RPM spec 文件中，总是对 Python 3 RPM 使用宏，而不是硬编码其值。
  • 要点：您可以重新定义在这些宏中使用哪个 Python 3 版本。为此，请在 spec 文件的顶部定义 python3_pkgversion 宏。如需更多信息，请参阅 Python 软件包示例的 spec 文件描述。如果您定义了 python3_pkgversion 宏，下表中的宏值与该 Python 3 版本匹配。
  • 列表：上游文档中的 Python 宏
  • 表格样本（共 10 行）：
    • Macro | 常规定义 | 描述
    • %{python3_pkgversion} | 3 | 所有其他宏使用的 Python 版本。当您为不同于默认的 Python 版本构建时，重新定义这个宏。
    • %{python3} | /usr/bin/python3 | Python 3 解释器。
    • %{python3_version} | 3.12 | Python 3 解释器的 major.minor 版本。

7.3. 为 Python RPM 使用自动生成的依赖项

  • 要点：使用上游提供的元数据为 Python RPM 启用自动生成依赖项。
  • 要点：先决条件
  • 列表：RPM 的 spec 文件存在。如需更多信息，请参阅 Python 软件包示例的 spec 文件描述。
  • 列表：在生成的 RPM 中包含以下目录之一： .dist-info .egg-info RPM 构建过程会自动从这些目录中生成虚拟 pythonX.Ydist，例如： python3.12dist(pello) 然后，Python 依赖项生成器读取上游元数据，并使用生成的 pythonX.Ydist 虚拟提供为每个 RPM 软件包生成运行时需求。生成的要求标签的示例： Requires: python3.12dist(requests)
  • 列表：.dist-info
  • 列表：.egg-info RPM 构建过程会自动从这些目录中生成虚拟 pythonX.Ydist，例如： python3.12dist(pello) 然后，Python 依赖项生成器读取上游元数据，并使用生成的 pythonX.Ydist 虚拟提供为每个 RPM 软件包生成运行时需求。生成的要求标签的示例： Requires: python3.12dist(requests)
  • 列表：检查生成的 Requires。
  • 列表：要删除某些生成的 Requires，请在 spec 文件的 %prep 部分中修改上游提供的元数据。
  • 命令/配置摘录：
python3.12dist(pello)
Requires: python3.12dist(requests)

7.4. 使用pyproject RPM宏打包Python项目

  • 要点：通过使用CodeReady Linux Builder (CRB)存储库中的pyproject RPM宏，将使用pyproject.toml或setup.py文件的Python项目打包成RPM包。

7.4.1. 用于Python打包的pyproject RPM宏

  • 要点：通过使用 pyproject RPM 宏将 Python 项目打包成 RPM 包。这些宏与在 setup.py、pyproject.toml 或两者中定义元数据的项目一起工作，并通过标准化协议调用基于标准的构建后端。
  • 要点：许多上游Python项目不再依赖setup.py脚本。相反，它们将项目元数据存储在 pyproject.toml 中，并使用构建后端，例如setuptools、flit-core、hatchling 或 poetry-core。pyproject RPM 宏通过标准化协议调用任何兼容的构建后端，而不是直接调用 setup.py。

7.4.2. 准备使用 pyproject RPM 宏

  • 要点：通过在 RPM 规范文件中使用 pyproject RPM 宏来打包 Python 项目。%pyproject_buildrequires 宏在 pyproject-rpm-macros 包上添加生成的 BuildRequires，因此不要在构建主机上手动安装该包。在构建主机上启用 CodeReady Linux Builder (CRB) 存储库，以便在包构建期间提供依赖关系。
  • 要点：先决条件
  • 列表：您在构建主机上具有 root 权限。
  • 列表：对于使用 Red Hat Subscription Manager (Red Hat Subscription Manager) 注册的系统。
  • 列表：在构建主机上启用 CodeReady Linux Builder 存储库： # subscription-manager repos --enable codeready-builder-for-rhel-10-x86_64-rpms
  • 列表：在 RPM 规范文件中，添加 BuildRequires: python3-devel 并在 %generate_buildrequires 部分使用 %pyproject_buildrequires 宏： BuildRequires: python3-devel %generate_buildrequires %pyproject_buildrequires
  • 命令/配置摘录：
# subscription-manager repos --enable codeready-builder-for-rhel-10-x86_64-rpms
BuildRequires: python3-devel %generate_buildrequires %pyproject_buildrequires
  • 注意：重要 红帽不支持 CodeReady Linux Builder 存储库中包含的内容。

7.4.3. Python 3 RPM的常见pyproject RPM宏

  • 要点：在 Python RPM 规范文件中，使用 pyproject RPM 宏来构建在 setup.py、pyproject.toml 或两者中定义元数据的项目。
  • 要点：您可以通过定义规范文件顶部的 python3_pkgversion 宏来重新定义宏使用哪个 Python 3 版本，例如 %global python3_pkgversion 3.14。省略此宏以构建默认的Python 3版本。
  • 表格样本（共 7 行）：
    • Macro | 描述
    • %pyproject_build 需要 | 从上游元数据扩展构建要求。使用 -g test 等选项来包括来自命名依赖项组的依赖项。
    • %pyproject_wheel | 通过使用上游指定的构建后端构建轮包。
    • %pyproject_install | 将构建的轮子包安装到构建根中。

7.4.4. 包含 pyproject RPM 宏的 Python 软件包的规范文件描述

  • 要点：使用带注释的 RPM 规范文件示例打包 Python 项目，该项目在 setup.py、pyproject.toml 或两者中定义元数据。该示例显示了用于构建要求、轮式构建、安装和自动化文件列表的pyproject RPM宏。
  • 要点：例 7.2. 使用pyproject RPM宏构建的Python库的示例规范文件
  • 列表：%generate_buildrequires 部分中的 %pyproject_buildrequires 宏从上游元数据创建生成要求。
  • 列表：%pyproject_wheel 宏通过使用上游指定的构建后端构建轮包。
  • 列表：%pyproject_install 宏会将轮子安装到构建根中。
  • 列表：%pyproject_save_files -l pello 宏记录已安装的文件。-l 选项验证许可证文件是否存在。pello 参数列出了名为 pello 的可导入模块。
  • 列表：%check 部分运行 %pyproject_check_import 以验证可导入性，%pytest 以运行测试。
  • 列表：%files 部分使用 -f %{pyproject_files 包含 %pyproject_save_files 生成的文件列表。
  • 命令/配置摘录：
Name: python-pello Version: 1.0.2 Release: 1%{?dist} Summary: Example Python library License: MIT URL: https://example.com/Pello Source: %{url}/archive/v%{version}/Pello-%{version}.tar.gz BuildArch: noarch %description %_description Pello is an example package with an executable that prints Hello World! on the command line. %package -n python3-pello Summary: %{summary} %description -n python3-pello Pello is an example package with an executable that prints Hello World! on the command line. %prep %autosetup -p1 -n Pello-%{version} %generate_buildrequires %pyproject_buildrequires %build %pyproject_wheel %install %pyproject_install %pyproject_s…

第 8 章 修改 Python 脚本中的解释器指令

  • 要点：修改打包的 Python 脚本，以便它们符合预期格式。
  • 要点：在 Red Hat Enterprise Linux (RHEL) 10 中，可执行 Python 脚本应该使用解释器指令，也称为 hashbangs 或 shebangs，它至少指定主 Python 版本。例如：
  • 列表：Python 脚本中的一些解释器指令会导致构建错误。
  • 列表：根据您的场景，执行以下步骤之一来修改解释器指令： 在 spec 文件的 %prep 部分中使用以下宏： %py3_shebang_fix <SCRIPTNAME> ... SCRIPTNAME 可以是任何文件、目录或文件和目录列表。 因此，所有列出的文件和列出的目录中的所有 .py 文件的解释器指令都已修改为指向 %{python3}。将保留原始解释器指令的现有标记，并将添加 %{py3_shebang_flags} 宏中定义的其他标志。您可以在 spec 文件中重新定义 %{py3_shebang_flags} 宏，以更改将要添加的标记。 修改打包的 Python 脚本，以便它们符合预期格式。
  • 列表：在 spec 文件的 %prep 部分中使用以下宏： %py3_shebang_fix <SCRIPTNAME> ... SCRIPTNAME 可以是任何文件、目录或文件和目录列表。 因此，所有列出的文件和列出的目录中的所有 .py 文件的解释器指令都已修改为指向 %{python3}。将保留原始解释器指令的现有标记，并将添加 %{py3_shebang_flags} 宏中定义的其他标志。您可以在 spec 文件中重新定义 %{py3_shebang_flags} 宏，以更改将要添加的标记。
  • 列表：修改打包的 Python 脚本，以便它们符合预期格式。
  • 列表：解释器调用
  • 命令/配置摘录：
#!/usr/bin/python3 #!/usr/bin/python3.12
%py3_shebang_fix <SCRIPTNAME> ...

第 9 章 打包 Ruby gems

  • 要点：将 Ruby 项目打包为 RPM 文件。
  • 要点：Ruby 是一个解释通用的编程语言。使用 Ruby 编写的程序通常使用 RubyGems 软件打包，后者提供特定的 Ruby 打包格式。
  • 注意：注意 本文档指的是与 gem 前缀相关的 RubyGems 概念，如 .gemspec 用于 gem 规范，与 RPM 相关的术语是不合格的。

9.1. RubyGems 与 RPM 的关系

  • 要点：RubyGems 使用与 RPM 软件包类似的元数据。您可以将 gems 重新打包到 RPM 中，以便与 Red Hat Enterprise Linux (RHEL)无缝集成。
  • 要点：RubyGems 代表 Ruby 编程语言的原生打包格式。这个格式与 RPM 软件包共享术语，如 spec 文件、软件包名称和依赖项。通过将 gems 重新打包到 RPM 软件包中，您可以通过安装打包的 gem 来满足系统依赖项。
  • 列表：软件包名称必须遵循 rubygem-%{gem_name} 模式。
  • 列表：解释器指令必须使用 #!/usr/bin/ruby 字符串。

9.2. RubyGems spec 文件约定

  • 要点：查看 RubyGems spec 文件结构示例，以及创建此类 spec 文件时必须遵循的特定内容。
  • 要点：RubyGems spec 文件必须满足以下条件：
  • 列表：文件包含 %{gem_name} 的定义，后者是 gem 规范中的名称。
  • 列表：软件包的源必须是发布的 gem 归档的完整 URL。
  • 列表：软件包的版本必须是 gem 的版本。
  • 列表：文件包含以下 BuildRequires: 指令： BuildRequires: rubygems-devel rubygems-devel 软件包包含构建所需的宏。
  • 列表：文件不包含任何其他 rubygem (foo) Requires 或 Provides 指令，因为这些指令是从 gem 元数据自动生成的。
  • 命令/配置摘录：
BuildRequires: rubygems-devel

9.2.1. RubyGems spec 文件示例

  • 要点：查看以下特定于 RubyGems 的示例 spec 文件的一部分来构建 gems。请注意，spec 文件的剩余部分遵循通用 spec 文件指南。
  • 要点：例 9.1. 示例 spec 文件的特定于 RubyGems 的部分
  • 命令/配置摘录：
%prep %setup -q -n %{gem_name}-%{version} # Modify the gemspec if necessary # Also apply patches to code if necessary %patch 0 -p1 %build # Create the gem as gem install only works on a gem file gem build ../%{gem_name}-%{version}.gemspec # %%gem_install compiles any C extensions and installs the gem into ./%%gem_dir # by default, so that we can move it into the buildroot in %%install %gem_install %install mkdir -p %{buildroot}%{gem_dir} cp -a ./%{gem_dir}/* %{buildroot}%{gem_dir}/ # If there were programs installed: mkdir -p %{buildroot}%{_bindir} cp -a ./%{_bindir}/* %{buildroot}%{_bindir} # If there are C extensions, copy them to the extd…

9.2.2. RubyGems spec 文件指令

  • 要点：检查 spec 文件中特定于 RubyGems 的特定项的以下特定项的具体信息。
  • 表格样本（共 4 行）：
    • 指令 | RubyGems 具体信息
    • %prep | RPM 可以直接解包 gem 归档。%setup -n %{gem_name}-%{version} 宏提供解包 gem 的目录。在同一目录级别，会自动创建 %{gem_name}-%{version}.gemspec 文件。您可以使用此文件执行以下操作： 修改 .gemspec 文件 将补丁应用到代码。
    • %build | 本节包含将软件构建成机器码的命令。%gem_install 宏仅对 gem 归档进行操作。因此，您必须首先使用 gem build ../%{gem_name}-%{version}.gemspec 命令重新创建存档。然后，%gem_install 使用重新创建的 gem 文件进行构建，并将 gem 代码安装到默认的 ./%{gem_dir} 临时目录中。在安装之前，构建的源会被放入自动创建的临时目录中。
    • %install | 安装将在 %{buildroot} 层次结构中执行。您可以创建所需的目录，然后将安装的代码从临时目录复制到 %{buildroot} 层次结构中。如果 gem 创建了共享对象，则它们会被移到特定于架构的 %{gem_extdir_mri} 路径中。

9.2.3. 其他资源

  • 列表：Ruby 的 Fedora 打包指南

9.3. RubyGems macros

  • 要点：查看以下用于 RubyGems 创建的软件包的宏。这些宏由 rubygems-devel 软件包提供。
  • 表格样本（共 8 行）：
    • 宏名称 | 扩展路径 | 使用方法
    • %{gem_dir} | /usr/share/gems | gem 结构的顶级目录。
    • %{gem_instdir} | %{gem_dir}/gems/%{gem_name}-%{version} | 包含 gem 的实际内容的目录。
    • %{gem_libdir} | %{gem_instdir}/lib | gem 的库目录。

9.4. 使用 gem2rpm 生成 spec 文件

  • 要点：使用 gem2rpm 工具创建用于构建 gems 的 RPM spec 文件。

9.4.1. 为 Ruby gem 创建 RPM spec 文件

  • 要点：使用 gem2rpm 实用程序为 RubyGems 软件包生成 RPM spec 文件。
  • 要点：先决条件
  • 列表：您已在系统中安装了 gem2rpm 工具： $ gem install gem2rpm
  • 列表：下载最新版本的 gem，并为这个 gem 生成 RPM spec 文件： $ gem2rpm --fetch <gem_name> > <gem_name>.spec
  • 列表：编辑生成的 spec 文件来添加缺失的信息，例如许可证和更改日志。
  • 列表：构建 RPM
  • 命令/配置摘录：
$ gem install gem2rpm
$ gem2rpm --fetch <gem_name> > <gem_name>.spec

9.4.2. 使用自定义 gem2rpm 模板生成 spec 文件

  • 要点：gem2rpm 模板是可以从中生成 RPM spec 文件的标准的 嵌入式 Ruby (ERB) 文件。编辑生成 RPM spec 文件的模板，而不是编辑生成的 spec 文件。
  • 要点：先决条件
  • 列表：您已在系统中安装了 gem2rpm 工具： $ gem install gem2rpm
  • 列表：显示所有 gem2rpm 内置模板： $ gem2rpm --templates
  • 列表：选择其中一个内置模板，并将其保存为自定义模板： $ gem2rpm -t <template> -T > rubygem-<gem_name>.spec.template 请注意，对于 RHEL 10 Beta，建议使用 fedora-27-rawhide 模板。
  • 列表：根据需要编辑模板。如需更多信息，请参阅 gem2rpm 模板变量。
  • 列表：使用编辑的模板生成 spec 文件： $ gem2rpm -t rubygem-<gem_name>.spec.template <gem_name>-<latest_version>.gem > <gem_name>-GEM.spec
  • 列表：构建 RPM
  • 命令/配置摘录：
$ gem install gem2rpm
$ gem2rpm --templates

9.4.3. gem2rpm 模板变量

  • 要点：查看 gem2rpm 模板中包含的用于 RPM spec 文件生成的以下变量。
  • 表格样本（共 10 行）：
    • 变量 | 解释
    • package | gem 的 Gem::Package 变量。
    • spec | gem 的 Gem::Specification 变量（与 format.spec相同）。
    • config | Gem2Rpm::Configuration 变量，可以重新定义 spec 模板助手中使用的默认宏或规则。

完整目录

  • 使用 RPM 软件包管理系统打包软件
  • 对红帽文档提供反馈
  • 第 1 章 RPM 简介
    • 1.1. RPM 软件包
    • 1.2. 列出 RPM 打包工具
  • 第 2 章 设置 RPM 打包工作区
    • 2.1. 配置 RPM 打包工作区
    • 2.2. RPM 打包工作区目录
  • 第 3 章 RPM 宏
    • 3.1. 显示内置 RPM 宏
    • 3.2. 显示 RPM 发布宏
    • 3.3. 使用宏自定义 RPM 行为
    • 3.4. 在 spec 文件中定义自定义 RPM 宏
    • 3.5. spec 的 %files 部分中的通用 RPM 指令
    • 3.6. %autosetup 和 %setup 宏
      • 3.6.1. %autosetup 宏选项
      • 3.6.2. %autopatch 宏选项
      • 3.6.3. %setup 宏选项
  • 第 4 章 为 RPM 打包创建软件
    • 4.1. 什么是源代码
    • 4.2. 创建软件的方法
      • 4.2.1. 原生编译的软件
      • 4.2.2. 解释的软件
    • 4.3. 从源构建软件
      • 4.3.1. 从原生编译的代码构建软件
      • 4.3.2. 解释源代码
  • 第 5 章 为 RPM 打包准备软件
    • 5.1. 修复软件
      • 5.1.1. 为 C 程序示例创建一个补丁文件
      • 5.1.2. 给 C 程序示例打补丁
    • 5.2. 创建一个 LICENSE 文件
    • 5.3. 为分发创建一个源代码存档
      • 5.3.1. 为 Bash 程序示例创建一个源代码存档
      • 5.3.2. 为 Python 程序示例创建一个源代码存档
      • 5.3.3. 为 C 程序示例创建一个源代码存档
  • 第 6 章 使用 RPM 打包软件
    • 6.1. 关于 spec 文件
      • 6.1.1. spec 文件的 preamble 项
      • 6.1.2. spec 文件的正文项
      • 6.1.3. 高级 spec 文件项
      • 6.1.4. Epoch 指令
      • 6.1.5. 软件包版本基本
    • 6.2. spec 文件条件
      • 6.2.1. 使用 %if 条件的示例
      • 6.2.2. %if 条件的专用变体
      • 6.2.3. 其他资源
    • 6.3. BuildRoots
    • 6.4. 使用 spec 文件
      • 6.4.1. 为 Bash、Python 和 C 程序示例创建一个新的 spec 文件
      • 6.4.2. 修改原始 spec 文件
      • 6.4.3. Bash 程序示例的 spec 文件示例
      • 6.4.4. Python 程序示例的 spec 文件示例
      • 6.4.5. C 程序示例的 spec 文件示例
    • 6.5. 构建 RPM
      • 6.5.1. 构建源 RPM
      • 6.5.2. 从源 RPM 重新构建一个二进制 RPM
      • 6.5.3. 从 spec 文件构建二进制 RPM
    • 6.6. 将 RPM 活动记录到 syslog
    • 6.7. 提取 RPM 内容
    • 6.8. 签名 RPM 软件包
      • 6.8.1. 使用 GnuPG 签名 RPM 软件包
      • 6.8.2. 使用 Sequoia PGP 签名 RPM 软件包
      • 6.8.3. 使用 PQC 使用 Sequoia PGP 签名 RPM 软件包
  • 第 7 章 打包 Python 3 RPM
    • 7.1. 示例 Python 软件包的 spec 文件描述
    • 7.2. Python 3 RPM 的常见宏
    • 7.3. 为 Python RPM 使用自动生成的依赖项
    • 7.4. 使用pyproject RPM宏打包Python项目
      • 7.4.1. 用于Python打包的pyproject RPM宏
      • 7.4.2. 准备使用 pyproject RPM 宏
      • 7.4.3. Python 3 RPM的常见pyproject RPM宏
      • 7.4.4. 包含 pyproject RPM 宏的 Python 软件包的规范文件描述
  • 第 8 章 修改 Python 脚本中的解释器指令
  • 第 9 章 打包 Ruby gems
    • 9.1. RubyGems 与 RPM 的关系
    • 9.2. RubyGems spec 文件约定
      • 9.2.1. RubyGems spec 文件示例
      • 9.2.2. RubyGems spec 文件指令
      • 9.2.3. 其他资源
    • 9.3. RubyGems macros
    • 9.4. 使用 gem2rpm 生成 spec 文件
      • 9.4.1. 为 Ruby gem 创建 RPM spec 文件
      • 9.4.2. 使用自定义 gem2rpm 模板生成 spec 文件
      • 9.4.3. gem2rpm 模板变量