编写者：rand777 dream520nb

本文已完成并校对，部分内容引用自 计算机自学指南 与 MirrorZ 帮助文档

前置知识

Linux命令

注意

容器镜像请确保文件未被篡改，来源是否可信，谨慎将其部署至生产环境。

CMake 构建目录内容详解

当执行 cmake -B build -S . 后，会在 build 目录中生成大量文件。理解这些文件的用途对于调试构建问题和理解 CMake 工作原理至关重要。

目录

1. 构建目录结构概览
2. 核心缓存文件
3. CMakeFiles 目录
4. 生成的构建文件
5. 不同生成器的输出差异
6. 临时文件和中间文件
7. 编译数据库
8. 实际案例详解
9. 清理和维护

1. 构建目录结构概览

1.1 典型结构

执行 cmake -B build -S . 后，build 目录的典型结构：

build/
├── CMakeCache.txt                 # CMake 缓存文件
├── CMakeFiles/                     # CMake 内部文件目录
│   ├── CMakeOutput.log             # 配置输出日志
│   ├── CMakeError.log               # 配置错误日志
│   ├── cmake.check_cache            # 缓存检查标记
│   ├── Makefile.cmake               # 生成的 Makefile 的 CMake 部分
│   ├── CMakeTmp/                    # 临时测试文件
│   ├── TargetDirectories.txt        # 目标目录信息
│   ├── myapp.dir/                   # 每个目标的内部目录
│   │   ├── build.make               # 目标构建规则
│   │   ├── cmake_clean.cmake         # 清理规则
│   │   ├── DependInfo.cmake          # 依赖信息
│   │   ├── depend.internal           # 内部依赖
│   │   ├── flags.make                # 编译标志
│   │   ├── link.txt                  # 链接命令
│   │   └── progress.make             # 构建进度
│   └── progress.marks                # 进度标记
├── Makefile                         # 生成的 Makefile（Unix Makefiles）
├── build.ninja                      # 生成的 Ninja 文件（Ninja 生成器）
├── *.sln                             # Visual Studio 解决方案（VS 生成器）
├── *.vcxproj                         # Visual Studio 项目文件
├── compile_commands.json             # 编译数据库（可选）
├── CMakeDoxyfile.in                  # Doxygen 配置（如果启用）
├── CMakeDoxygenDefaults.cmake         # Doxygen 默认配置
├── Testing/                          # 测试相关目录
│   ├── Temporary/                    # 临时测试文件
│   └── CMakeLists.txt                 # 测试的 CMake 文件
├── cmake_install.cmake                # 安装脚本
├── install_manifest.txt               # 安装文件清单
├── *.a, *.so, *.exe                   # 构建产出的库和可执行文件
├── lib/                               # 库输出目录（如果配置）
├── bin/                               # 可执行文件输出目录（如果配置）
└── CMakeCache.txt.lock                # 缓存文件锁（CMake 3.17+）

2. 核心缓存文件

2.1 CMakeCache.txt

CMakeCache.txt 是 CMake 最重要的缓存文件，存储了所有缓存变量的值。

# 查看缓存内容
cat build/CMakeCache.txt

文件内容示例：

# This is the CMakeCache file.
# 这是 CMake 缓存文件，用于存储构建配置信息

# 路径信息
CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
# 说明：CMake 命令的路径

CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.22
# 说明：CMake 安装根目录

# 编译器信息
CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
# 说明：C++ 编译器路径

CMAKE_C_COMPILER:FILEPATH=/usr/bin/cc
# 说明：C 编译器路径

CMAKE_CXX_COMPILER_ID:INTERNAL=GNU
# 说明：C++ 编译器标识

CMAKE_CXX_COMPILER_VERSION:INTERNAL=11.4.0
# 说明：C++ 编译器版本

# 构建类型
CMAKE_BUILD_TYPE:STRING=Release
# 说明：当前构建类型（可以通过 -D 修改）

# 安装路径
CMAKE_INSTALL_PREFIX:PATH=/usr/local
# 说明：安装前缀路径

# 项目选项
BUILD_TESTS:BOOL=ON
# 说明：构建测试选项

USE_OPENMP:BOOL=OFF
# 说明：使用 OpenMP 选项

# 找到的库
OpenCV_DIR:UNINITIALIZED=/usr/lib/x86_64-linux-gnu/cmake/opencv4
# 说明：OpenCV 的 CMake 配置目录

OpenCV_INCLUDE_DIRS:PATH=/usr/include/opencv4
# 说明：OpenCV 头文件目录

OpenCV_LIBS:STRING=opencv_core;opencv_imgproc
# 说明：OpenCV 库列表

# 平台信息
CMAKE_SYSTEM_NAME:STRING=Linux
# 说明：系统名称

CMAKE_SYSTEM_PROCESSOR:STRING=x86_64
# 说明：处理器架构

# 内部变量（以 INTERNAL 标记）
// 这些变量通常不应手动修改
CMAKE_CXX_FLAGS:STRING=-O2 -DNDEBUG
# 说明：C++ 编译标志

CMAKE_C_FLAGS:STRING=-O2 -DNDEBUG
# 说明：C 编译标志

2.2 缓存变量类型

CMakeCache.txt 中的变量有不同标记：

标记	含义	示例
:STRING	字符串类型	CMAKE_BUILD_TYPE:STRING=Debug
:BOOL	布尔类型	BUILD_TESTS:BOOL=ON
:PATH	路径类型	CMAKE_INSTALL_PREFIX:PATH=/usr/local
:FILEPATH	文件路径	CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++
:INTERNAL	内部变量	CMAKE_CXX_COMPILER_ID:INTERNAL=GNU
:STATIC	静态变量	PROJECT_VERSION:STATIC=1.2.3
UNINITIALIZED	未初始化	OpenCV_DIR:UNINITIALIZED=...

2.3 操作缓存

# 查看缓存变量
cmake -LA build
# 输出所有缓存变量

cmake -LAH build
# 输出所有缓存变量（带帮助文本）

# 修改缓存变量
cmake -DCMAKE_BUILD_TYPE=Debug build

# 删除缓存变量
cmake -UVAR_NAME build

# 完全清除缓存
rm build/CMakeCache.txt
rm -rf build/CMakeFiles

3. CMakeFiles 目录

CMakeFiles 是 CMake 的心脏 - 它是 CMake 在配置和构建过程中产生的核心工作目录，包含了所有必要的内部信息、依赖关系、编译规则和临时文件

3.1 CMakeFiles 结构

CMakeFiles/
├── CMakeOutput.log          # 成功的检查输出
├── CMakeError.log           # 失败的检查输出
├── cmake.check_cache        # 缓存检查标记
├── Makefile.cmake            # CMake 生成的 Makefile 部分
├── Makefile2                 # 主 Makefile 的二级文件
├── TargetDirectories.txt     # 所有目标的目录
├── progress.marks            # 构建进度标记
├── CMakeTmp/                 # 临时测试文件
├── 3.22.1/                   # CMake 版本目录
│   ├── CMakeCCompiler.cmake  # C 编译器信息
│   ├── CMakeCXXCompiler.cmake # C++ 编译器信息
│   ├── CMakeDetermineCompilerABI_C.bin # C ABI 测试二进制
│   ├── CMakeDetermineCompilerABI_CXX.bin # C++ ABI 测试二进制
│   └── CMakeSystem.cmake     # 系统信息
├── myapp.dir/                # myapp 目标目录
│   ├── build.make            # 构建规则
│   ├── cmake_clean.cmake     # 清理规则
│   ├── DependInfo.cmake      # 依赖信息
│   ├── depend.internal       # 内部依赖
│   ├── flags.make            # 编译标志
│   ├── link.txt              # 链接命令
│   ├── progress.make         # 进度规则
│   ├── main.cpp.o            # 编译的对象文件
│   ├── main.cpp.o.d          # 对象文件的依赖
│   └── main.cpp.o.progress   # 编译进度
└── mylib.dir/                # mylib 目标目录
    ├── ...

3.2 重要文件详解

CMakeOutput.log 和 CMakeError.log

# 查看配置输出
cat build/CMakeFiles/CMakeOutput.log

CMakeOutput.log 示例：

The system is: Linux - 5.15.0-91-generic - x86_64
Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded.
Compiler: /usr/bin/c++ 
Build flags: 
Id flags: 

The output was:
0
...

Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out"

The CXX compiler identification is GNU, found in "/home/user/build/CMakeFiles/3.22.1/CompilerIdCXX/a.out"

CMakeError.log 示例：

Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" failed.
Compiler: /usr/bin/c++ 
Build flags: 
Id flags: 

The output was:
1
/usr/bin/c++: fatal error: no input files

Makefile.cmake

# CMake generated Makefile: 不要手动编辑
# Generated by CMake 3.22.1

# 设置 CMake 命令路径
CMAKE_COMMAND = /usr/bin/cmake

# 项目源码路径
PROJECT_SOURCE_DIR = /home/user/project

# 构建路径
PROJECT_BINARY_DIR = /home/user/project/build

# CMake 内部变量
CMAKE_CXX_COMPILER = /usr/bin/c++
CMAKE_C_COMPILER = /usr/bin/cc
...

myapp.dir/build.make

# myapp.dir/build.make - myapp 目标的构建规则

# 编译 main.cpp
CMakeFiles/myapp.dir/main.cpp.o: ../src/main.cpp
    @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/user/project/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/myapp.dir/main.cpp.o"
    /usr/bin/c++  $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/myapp.dir/main.cpp.o -c ../src/main.cpp

# 编译 utils.cpp
CMakeFiles/myapp.dir/src/utils.cpp.o: ../src/utils.cpp
    /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/myapp.dir/src/utils.cpp.o -c ../src/utils.cpp

# 链接 myapp
myapp: CMakeFiles/myapp.dir/main.cpp.o CMakeFiles/myapp.dir/src/utils.cpp.o
    @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/user/project/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable myapp"
    $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/myapp.dir/link.txt --verbose=$(VERBOSE)

myapp.dir/flags.make

# 编译标志
CXX_FLAGS = -O2 -DNDEBUG -Wall -Wextra

# 包含目录
CXX_INCLUDES = -Iinclude -I/usr/include/opencv4

# 编译定义
CXX_DEFINES = -DUSE_FEATURE_X -DVERSION=\"1.2.3\"

myapp.dir/link.txt

/usr/bin/c++ -O2 -DNDEBUG 
    CMakeFiles/myapp.dir/main.cpp.o 
    CMakeFiles/myapp.dir/utils.cpp.o 
    -o myapp 
    -Wl,-rpath,/usr/lib/x86_64-linux-gnu 
    /usr/lib/x86_64-linux-gnu/libopencv_core.so 
    /usr/lib/x86_64-linux-gnu/libpthread.so

3.3 编译器信息文件

CMakeCXXCompiler.cmake：

# 这个文件记录了 C++ 编译器信息
set(CMAKE_CXX_COMPILER "/usr/bin/c++")
set(CMAKE_CXX_COMPILER_ARG1 "")
set(CMAKE_CXX_COMPILER_ID "GNU")
set(CMAKE_CXX_COMPILER_VERSION "11.4.0")
set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
set(CMAKE_CXX_COMPILER_WRAPPER "")
set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17")
set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON")
set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;...")

4. 生成的构建文件

4.1 Makefile 生成器

使用 -G "Unix Makefiles"（Linux/macOS 默认）：

build/
├── Makefile                 # 主 Makefile
├── CMakeFiles/              # CMake 内部文件
└── [其他目标文件]

Makefile 内容示例：

# CMAKE generated file: DO NOT EDIT!
# Generated by CMake 3.22.1

# 默认目标
default: all

# 包含主构建文件
include CMakeFiles/Makefile2

# 伪目标
.PHONY: all clean install test

# 构建所有
all: cmake_check_build_system
    $(CMAKE_COMMAND) -E cmake_progress_start /home/user/project/build/CMakeFiles /home/user/project/build/progress.marks
    $(MAKE) -f CMakeFiles/Makefile2 all
    $(CMAKE_COMMAND) -E cmake_progress_start /home/user/project/build/CMakeFiles 0

# 清理
clean:
    $(MAKE) -f CMakeFiles/Makefile2 clean

# 安装
install: all
    $(MAKE) -f CMakeFiles/Makefile2 install

# 测试
test: all
    $(MAKE) -f CMakeFiles/Makefile2 test

4.2 Ninja 生成器

使用 -G Ninja：

build/
├── build.ninja              # 主 Ninja 构建文件
├── rules.ninja              # Ninja 规则
└── CMakeFiles/              # CMake 内部文件

build.ninja 内容示例：

# CMAKE generated file: DO NOT EDIT!
# Generated by Ninja

# 变量定义
CMAKE_COMMAND = /usr/bin/cmake
CXX_COMPILER = /usr/bin/c++
CXX_FLAGS = -O2 -DNDEBUG -Wall

# 规则定义
rule CXX_COMPILER
  command = ${CXX_COMPILER} ${DEFINES} ${INCLUDES} ${FLAGS} -MD -MT $out -MF $out.d -o $out -c $in
  description = Building CXX object $out

rule CXX_LINKER
  command = ${CXX_COMPILER} $FLAGS $LINK_FLAGS $in -o $out $LINK_LIBRARIES
  description = Linking CXX executable $out

# 构建目标
build CMakeFiles/myapp.dir/main.cpp.o: CXX_COMPILER ../src/main.cpp
  DEFINES = -DUSE_FEATURE_X
  INCLUDES = -Iinclude
  FLAGS = -O2 -DNDEBUG

build myapp: CXX_LINKER CMakeFiles/myapp.dir/main.cpp.o CMakeFiles/myapp.dir/utils.cpp.o
  LINK_LIBRARIES = /usr/lib/libopencv_core.so /usr/lib/libpthread.so

4.3 Visual Studio 生成器

使用 -G "Visual Studio 17 2022"：

build/
├ MyProject.sln               # Visual Studio 解决方案
├ MyProject.vcxproj           # Visual Studio 项目文件
├ MyProject.vcxproj.filters   # 文件过滤器
├ CMakeCache.txt              # 缓存文件
├ CMakeFiles/                 # CMake 内部文件
├ ALL_BUILD.vcxproj           # 构建所有目标
├ ZERO_CHECK.vcxproj          # CMake 重新检查
├ INSTALL.vcxproj             # 安装目标
├ RUN_TESTS.vcxproj           # 测试目标
└ *.dir/                      # 目标目录

MyProject.sln 内容：

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31903.59
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "MyProject", "MyProject.vcxproj", "{GUID}"
EndProject
...

5. 不同生成器的输出差异

5.1 文件对比

文件类型	Makefile	Ninja	Visual Studio
主构建文件	Makefile	build.ninja	*.sln
规则文件	内嵌在 Makefile	rules.ninja	*.vcxproj
依赖文件	*.d	*.d	*.tlog
对象文件	*.o	*.o	*.obj
库文件	*.a, *.so	*.a, *.so	*.lib, *.dll
可执行文件	*	*	*.exe

5.2 目录结构差异

Makefile/Ninja（简洁）：

build/
├── Makefile/build.ninja
├── CMakeFiles/
├── myapp
├── libmylib.a
└── ...

Visual Studio（复杂）：

build/
├── MyProject.sln
├── MyProject.vcxproj
├── MyProject.vcxproj.filters
├── x64/
│   ├── Debug/
│   │   ├── myapp.exe
│   │   ├── myapp.pdb
│   │   ├── mylib.lib
│   │   └── mylib.dll
│   └── Release/
│       ├── myapp.exe
│       └── ...
├── CMakeFiles/
└── ...

6. 临时文件和中间文件

6.1 CMakeTmp 目录

CMakeTmp/ 包含 CMake 在配置阶段生成的临时测试文件：

CMakeFiles/CMakeTmp/
├── CMakeCXXCompilerABI.cpp    # C++ ABI 测试源码
├── CMakeCCompilerABI.c         # C ABI 测试源码
├── CMakeTestCXXCompiler.cxx    # C++ 编译器测试
├── CMakeTestCCompiler.c        # C 编译器测试
├── cmTC_abcd/                  # 测试编译目录
│   ├── CMakeLists.txt           # 测试项目的 CMake 文件
│   ├── test.c                   # 测试源码
│   └── CMakeFiles/              # 测试的 CMake 文件
└── cmTC_abcd.out                # 测试输出文件

6.2 对象文件和依赖文件

对象文件 (*.o / *.obj)：

CMakeFiles/myapp.dir/main.cpp.o        # 编译后的对象文件
CMakeFiles/myapp.dir/utils.cpp.o

依赖文件 (*.d)：

CMakeFiles/myapp.dir/main.cpp.o.d      # 头文件依赖信息
main.cpp.o.d 内容示例：
main.o: main.cpp include/header1.h include/header2.h

进度文件 (*.progress)：

CMakeFiles/myapp.dir/main.cpp.o.progress  # 构建进度信息
progress.marks                              # 全局进度标记

7. 编译数据库

7.1 compile_commands.json

当设置 -DCMAKE_EXPORT_COMPILE_COMMANDS=ON 时生成：

[
  {
    "directory": "/home/user/project/build",
    "command": "/usr/bin/c++ -Iinclude -I/usr/include/opencv4 -O2 -DNDEBUG -Wall -o CMakeFiles/myapp.dir/main.cpp.o -c ../src/main.cpp",
    "file": "../src/main.cpp",
    "output": "CMakeFiles/myapp.dir/main.cpp.o"
  },
  {
    "directory": "/home/user/project/build",
    "command": "/usr/bin/c++ -Iinclude -I/usr/include/opencv4 -O2 -DNDEBUG -Wall -o CMakeFiles/myapp.dir/utils.cpp.o -c ../src/utils.cpp",
    "file": "../src/utils.cpp",
    "output": "CMakeFiles/myapp.dir/utils.cpp.o"
  }
]

7.2 用途

这个文件被以下工具使用：

• clangd：代码补全和导航
• clang-tidy：静态代码分析
• cppcheck：代码检查
• IDEs：VS Code、CLion 等

8. 实际案例详解

8.1 简单项目的构建目录

项目结构：

project/
├── CMakeLists.txt
└── src/
    └── main.cpp

CMakeLists.txt：

cmake_minimum_required(VERSION 3.10)
project(Hello)
add_executable(hello src/main.cpp)

执行： cmake -B build -S .

build 目录内容：

build/
├── CMakeCache.txt
├── CMakeFiles/
│   ├── 3.22.1/
│   ├── CMakeOutput.log
│   ├── CMakeError.log
│   ├── Makefile.cmake
│   ├── Makefile2
│   ├── TargetDirectories.txt
│   ├── cmake.check_cache
│   ├── progress.marks
│   └── hello.dir/
│       ├── build.make
│       ├── cmake_clean.cmake
│       ├── DependInfo.cmake
│       ├── depend.internal
│       ├── flags.make
│       ├── link.txt
│       └── progress.make
├── Makefile
└── cmake_install.cmake

执行构建： cmake --build build

build 目录新增：

build/
├── CMakeFiles/
│   └── hello.dir/
│       ├── src.main.cpp.o      # 编译的对象文件
│       └── src.main.cpp.o.d     # 依赖文件
└── hello                        # 生成的可执行文件

8.2 复杂项目的构建目录

项目结构：

project/
├── CMakeLists.txt
├── src/
│   ├── main.cpp
│   ├── lib1/
│   └── lib2/
├── include/
├── tests/
└── docs/

构建目录结构：

build/
├── CMakeCache.txt
├── CMakeFiles/
├── Makefile/build.ninja
├── bin/                          # 可执行文件输出
│   └── myapp
├── lib/                          # 库文件输出
│   ├── libmylib.a
│   └── libmylib.so
├── tests/                        # 测试输出
│   ├── test_runner
│   └── test_results.xml
├── docs/                         # 文档输出
│   └── html/
├── compile_commands.json         # 编译数据库
├── cmake_install.cmake
└── install_manifest.txt          # 安装清单

9. 清理和维护

9.1 清理方法

# 方法1：使用 CMake 清理目标
cmake --build build --target clean

# 方法2：手动删除构建目录
rm -rf build/
mkdir build

# 方法3：选择性清理
rm build/CMakeCache.txt          # 只清除缓存
rm -rf build/CMakeFiles/         # 清除内部文件
rm build/myapp                   # 只删除可执行文件

# 方法4：使用 CMake 清理所有
cmake --build build --target clean-all  # 如果定义了该目标

9.2 重新配置

# 方法1：清除缓存后重新配置
rm build/CMakeCache.txt
cmake -B build -S .

# 方法2：使用 --fresh 选项（CMake 3.24+）
cmake --fresh -B build -S .

# 方法3：完全重新构建
rm -rf build/
mkdir build
cmake -B build -S .
cmake --build build

9.3 维护技巧

# 查看缓存差异
diff build/CMakeCache.txt build.old/CMakeCache.txt

# 备份构建目录
cp -r build build.backup

# 创建构建目录的快照
tar -czf build.tar.gz build/

# 查看构建日志
tail -f build/CMakeFiles/CMakeOutput.log

# 监控文件变化
watch -n 1 ls -la build/

总结

CMake 构建目录包含以下重要文件：

1. 缓存文件 (CMakeCache.txt)：存储所有配置变量
2. 内部文件 (CMakeFiles/)：CMake 的工作文件
3. 构建文件 (Makefile, build.ninja, *.sln)：特定生成器的构建文件
4. 中间文件 (*.o, *.d)：编译产生的临时文件
5. 输出文件 (可执行文件、库)：最终构建产物
6. 辅助文件 (compile_commands.json, cmake_install.cmake)：用于工具和安装

理解这些文件的作用可以帮助你：

• 调试构建问题
• 优化构建过程
• 管理构建配置
• 集成开发工具

---

使用别人写好的软件/工具最大的障碍是什么——必然是配环境。配环境带来的折磨会极大地消解你对软件、编程本身的兴趣。虚拟机可以解决配环境的一部分问题，但它庞大笨重，且为了某个应用的环境配置好像也不值得模拟一个全新的操作系统。

Docker 的出现让环境配置变得（或许）不再折磨。简单来说 Docker 使用轻量级的“容器”（container）而不是整个操作系统去支持一个应用的配置。应用自身连同它的环境配置被打包为一个个 image 可以自由运行在不同平台的一个个 container 中，这极大地节省了所有人的时间成本。

如何学习docker

Docker 官方文档当然是最好的初学教材，但最好的导师一定是你自己——尝试去使用 Docker 才能享受它带来的便利。Docker 在工业界发展迅猛并已经非常成熟，你可以下载它的桌面端并使用图形界面。

当然，如果你像我一样，是一个疯狂的造轮子爱好者，那不妨自己亲手写一个迷你 Docker 来加深理解。

KodeKloud Docker for the Absolute Beginner 全面的介绍了 Docker 的基础功能，并且有大量的配套练习，同时提供免费的云环境来完成练习。其余的云相关的课程如 Kubernetes 需要付费，但个人强烈推荐：讲解非常仔细，适合从 0 开始的新手；有配套的 Kubernetes 的实验环境，不用被搭建环境劝退。

安装Docker CE

docker拉取失败解决方案

配置daemon.json文件：参考 docker magic 配置docker代理

自动安装

Docker 提供了一个自动配置与安装的脚本，支持 Debian、RHEL、SUSE 系列及衍生系统的安装。请注意，Docker 官方不建议在生产环境使用此脚本安装 Docker CE。

以下内容假定

您为 root 用户，或有 sudo 权限，或知道 root 密码； 您系统上有 curl 或 wget

export DOWNLOAD_URL="https://mirrors.cernet.edu.cn/docker-ce"
# 如您使用 curl
curl -fsSL https://raw.githubusercontent.com/docker/docker-install/master/install.sh | sudo -E sh
# 如您使用 wget
wget -O- https://raw.githubusercontent.com/docker/docker-install/master/install.sh | sudo -E sh

Debian/Ubuntu/Raspbian

Debian Ubuntu Raspberry Pi OS

以下内容根据 官方文档 修改而来。

如果你过去安装过 docker，先删掉：

for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

安装依赖

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

信任 Docker 的 GPG 公钥并添加仓库：

Debian.sh

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.cernet.edu.cn/docker-ce/linux/debian \
"$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Ubuntu.sh

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.cernet.edu.cn/docker-ce/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Respbian.sh

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/raspbian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://mirrors.cernet.edu.cn/docker-ce/linux/raspbian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Fedora

Fedora

以下内容根据 官方文档 修改而来。

如果你之前安装过 docker，请先删掉

sudo dnf remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine

安装依赖，下载 repo 文件，并把软件仓库地址替换为镜像站：

sudo dnf -y install dnf-plugins-core
sudo dnf-3 config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo
sudo sed -i 's+https://download.docker.com+https://mirrors.cernet.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo

最后安装：

sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

CentOS/RHEL

以下内容根据 官方文档 修改而来。

CentOS RockyLinux AlmaLinux

如果你之前安装过 docker，请先删掉

sudo dnf remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine

安装依赖，下载 repo 文件，并把软件仓库地址替换为CERNET联合镜像站：

CentOS

sudo  yum install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo sed -i 's+https://download.docker.com+https://mirrors.cernet.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo

RockyLinux & AlmaLinux

sudo  yum install -y yum-utils
yum-config-manager --add-repo https://download.docker.com/linux/rhel/docker-ce.repo
sudo sed -i 's+https://download.docker.com+https://mirrors.cernet.edu.cn/docker-ce+' /etc/yum.repos.d/docker-ce.repo

最后安装：

sudo yum install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

OpenMediaVault

OpenMediaVault

Open Media Vault 是一款基于 Debian 的 NAS 操作系统。

omv-env set OMV_DOCKER_APT_REPOSITORY_URL "https://mirrors.cernet.edu.cn/docker-ce/linux/debian"

迁移Docker数据

备份原数据

首先，停止 Docker 服务，以确保在修改配置时不会发生数据损坏。

sudo systemctl stop docker

假设迁移到 /opt/docker-images 中，则需要先备份，创建文件夹并给予权限

sudo mkdir -p /opt/docker-images
sudo chmod -R 755 /opt/docker-images

使用rsync协议同步复制原docker数据卷

sudo rsync -aP /var/lib/docker/ /opt/docker-images/

删除旧数据（可选）

sudo rm -rf /var/lib/docker

配置daemon.json

在 Linux 系统上，Docker 的配置文件通常位于 /etc/docker/daemon.json 。如果该文件不存在，可以手动创建。

sudo nano /etc/docker/daemon.json

{
    "data-root": "/opt/docker-images", 
    "registry-mirrors": [
        "https://docker.1panel.live",
        "https://image.cloudlayer.icu",
        "https://dockerpull.cn"
    ]
}

Ctrl + X 保存

重启docker

sudo systemctl start docker

验证配置

docker info | grep "Docker Root Dir"

输出结果应该为 Docker Root Dir: /opt/docker-images

容器使用

编写者：dreamnb520

作为一名爱好者，docker对于我们来讲更多的作用是使用他人制作的容器。

在docker上部署tapnet

介绍

TapNet（Temporal Attention Propagation Network）是一种深度学习模型，旨在解决时序数据和动态图建模中的问题。它结合了图神经网络（GNN）和注意力机制，用于在动态图和时序数据中捕捉复杂的依赖关系。TapNet特别适用于那些涉及时间依赖性和图结构的信息传播问题，广泛应用于如交通预测、金融市场分析、社交网络分析等领域。

部署

1. 克隆储存库:

   git clone https://github.com/deepmind/tapnet.git

2. 配置 python 库

   cd tapnet
   pip install .
   pip install tensorflow -i https://mirrors.aliyun.com/pypi/simple/
   pip install tensorflow_datasets -i https://mirrors.aliyun.com/pypi/simple/

3. 检查点下载

   检查点下载链接

测试

python3 tapnet\live_demo.py

拉取cuda的docker镜像

这里我选择的cuda版本为cuda12.1(注：下面写错了，应该是121)

docker pull nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04

检查容器

nvcc --version

结果:

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2022 NVIDIA Corporation
Built on Wed_Sep_21_10:33:58_PDT_2022
Cuda compilation tools, release 11.8, V11.8.89
Build cuda_11.8.r11.8/compiler.31833905_0

配置环境

# 更新
apt update
# 下载
apt install python3.11
# 检查是否安装成功ython3.11 --version

# 安装wget
apt install wget
# 下载pip安装包
wget https://bootstrap.pypa.io/get-pip.py
# 安装
python3.11 get-pip.py
# 检查是否安装成功
python3.11 -m pip --version

cd /home/tapnet

# 安装第三方库
python3.11 -m pip install .

# 安装 cuda 版本 jax
python3.11 -m pip install -U "jax[cuda118]"

# 安装其他库
python3.11 -m pip install tensorflow -i https://pypi.tuna.tsinghua.edu.cn/simple
python3.11 -m pip install tensorflow-datasets -i https://pypi.tuna.tsinghua.edu.cn/simple
python3.11 -m pip install websockets -i https://pypi.tuna.tsinghua.edu.cn/simple

发布docker

docker commit -m "cuda118的镜像" 78bd1a17252aeeaa733fe9ce43802b5472b954d7cd418ccee7521e874ab4ed78 tapnet:cuda118

创建一个容器进行检查

docker run -it -v /f/work/bingRun/docker-tapnet:/home/tapnet --gpus all tapnet:cuda118 /bin/bash

编写python程序测试容器是否可以使用gpu

import jax
import jax.numpy as jnp

def matrix_multiply_on_gpu():
    # 创建两个随机矩阵
    key = jax.random.PRNGKey(0)
    a = jax.random.normal(key, (2, 2))
    b = jax.random.normal(key, (2, 2))

    # 指定在 CUDA 设备上计算
    device = jax.devices("gpu")[0]

    # 将数据传输到 GPU 上
    a_gpu = jax.device_put(a, device=device)
    b_gpu = jax.device_put(b, device=device)

    # 在 GPU 上执行矩阵乘法
    c_gpu = jnp.dot(a_gpu, b_gpu)

    # 打印计算结果
    print("Matrix a:\n", a)
    print("Matrix b:\n", b)
    print("Result of matrix multiplication on GPU:\n", c_gpu)

if __name__ == "__main__":
    matrix_multiply_on_gpu()

贡献者

codingLab