04_apollo_docker子模块整体软件架构深入分析文档
1. 概述
Apollo Docker子模块是Apollo自动驾驶平台的容器化解决方案，提供完整的开发、构建和运行环境。采用分层架构设计，支持多平台（x86_64、aarch64）和多种硬件加速，实现开发环境一致性与可移植性，简化平台部署维护流程，为开发者提供高效可靠的开发体验。
2. 软件架构图
graph TB
subgraph "Docker子模块"
subgraph "构建系统"
B1[Dockerfile定义]:::key
B2[安装脚本]:::key
B3[配置文件]:::key
end
subgraph "开发环境"
D1[基础镜像]
D2[Cyber镜像]
D3[开发镜像]:::key
end
subgraph "运行时环境"
R1[运行时镜像]
R2[独立运行镜像]
end
subgraph "辅助工具"
T1[开发工具脚本]:::key
T2[主机配置工具]:::key
T3[资源清理工具]:::key
end
end
subgraph "外部依赖"
E1[Docker引擎]:::key
E2[CUDA驱动]
E3[系统库]
end
B1 --> D1
B2 --> D1
B3 --> D1
D1 --> D2
D2 --> D3
D3 --> R1
R1 --> R2
T1 --> D3
T2 --> E1
T3 --> E1
E1 --> D1
E2 --> D1
E3 --> D1
classDef key fill:#e1f5fe
3. 调用流程图
Apollo Docker子模块的调用流程涵盖了从环境准备到系统运行的完整生命周期，包括Docker引擎安装、镜像构建、容器启动和项目开发等多个阶段。整个流程设计清晰，步骤明确，便于开发者理解和使用。
3.1. Docker环境准备流程
sequenceDiagram
participant User as 开发者
participant Host as 主机系统
participant Docker as Docker引擎
participant Repo as Docker仓库
User->>Host: 执行docker setup脚本
Host->>Host: 检查系统版本
Host->>Host: 验证硬件配置
Host->>Host: 安装必要依赖
Host->>Docker: 下载Docker安装包
Docker-->>Host: 安装包下载完成
Host->>Docker: 安装Docker引擎
Docker-->>Host: 安装完成
Host->>Docker: 配置Docker服务
Docker-->>Host: 配置完成
Host->>Repo: 配置Docker镜像源
Repo-->>Host: 配置完成
Host-->>User: Docker环境准备完成
3.2. Docker镜像构建流程
sequenceDiagram
participant User as 开发者
participant Host as 主机系统
participant Build as 构建系统
participant Docker as Docker引擎
participant Env as 环境配置
User->>Host: 执行build_docker.sh
Host->>Build: 启动构建流程
Build->>Build: 解析命令行参数
Build->>Build: 验证参数有效性
Build->>Env: 加载环境配置
Env-->>Build: 配置加载完成
Build->>Build: 检查系统依赖
Build->>Host: 获取系统信息
Host-->>Build: 系统信息返回
Build->>Build: 生成构建配置
Build->>Build: 加载Dockerfile
Build->>Build: 执行安装脚本
Build->>Build: 配置环境变量
Build->>Docker: 构建基础镜像
Docker->>Docker: 执行构建步骤
Docker-->>Build: 基础镜像构建完成
Build->>Docker: 构建Cyber镜像
Docker->>Docker: 执行构建步骤
Docker-->>Build: Cyber镜像构建完成
Build->>Docker: 构建开发镜像
Docker->>Docker: 执行构建步骤
Docker-->>Build: 开发镜像构建完成
Build->>Docker: 构建运行时镜像
Docker->>Docker: 执行构建步骤
Docker-->>Build: 运行时镜像构建完成
Build-->>Host: 构建流程完成
Host-->>User: 镜像构建完成
3.3. 开发容器启动流程
sequenceDiagram
participant User as 开发者
participant Host as 主机系统
participant Docker as Docker引擎
participant Env as 开发环境
User->>Host: 执行dev_start.sh
Host->>Docker: 检查Docker服务状态
Docker-->>Host: 服务状态返回
Host->>Docker: 检查开发镜像是否存在
Docker-->>Host: 镜像状态返回
Host->>Docker: 检查容器是否已存在
Docker-->>Host: 容器状态返回
alt 容器已存在
Host->>Docker: 启动现有容器
Docker-->>Host: 容器启动完成
else 容器不存在
Host->>Docker: 创建开发容器
Docker->>Docker: 配置容器参数
Docker->>Docker: 挂载工作目录
Docker->>Docker: 配置网络
Docker->>Docker: 设置环境变量
Docker->>Docker: 启动容器
Docker-->>Host: 容器创建完成
end
Host->>Env: 初始化开发环境
Env->>Env: 加载环境配置
Env->>Env: 配置Bazel构建系统
Env->>Env: 配置CyberRT框架
Env->>Env: 配置开发工具
Env-->>Host: 环境初始化完成
Host-->>User: 开发环境就绪
3.4. Apollo项目开发流程
sequenceDiagram
participant User as 开发者
participant Host as 主机系统
participant Env as 开发环境
participant Build as Bazel构建系统
participant Cyber as CyberRT框架
participant Runtime as 运行时环境
User->>Host: 执行dev_into.sh
Host->>Env: 进入开发容器
Env-->>User: 容器终端就绪
User->>Env: 编辑Apollo源码
User->>Env: 执行bazel build命令
Env->>Build: 启动构建流程
Build->>Build: 解析构建配置
Build->>Build: 检查依赖
Build->>Build: 执行构建步骤
Build->>Cyber: 编译CyberRT组件
Cyber-->>Build: 编译完成
Build->>Build: 生成可执行文件
Build-->>Env: 构建完成
Env-->>User: 构建结果返回
User->>Env: 执行运行时测试
Env->>Runtime: 启动运行时环境
Runtime->>Runtime: 初始化组件
Runtime->>Runtime: 执行测试用例
Runtime-->>Env: 测试结果返回
Env-->>User: 测试结果输出
User->>Env: 构建运行时镜像
Env->>Runtime: 执行镜像构建
Runtime->>Runtime: 打包可执行文件
Runtime->>Runtime: 配置运行时环境
Runtime->>Runtime: 生成镜像
Runtime-->>Env: 镜像构建完成
Env-->>User: 镜像构建结果返回
3.5. 容器管理流程
sequenceDiagram
participant User as 开发者
participant Host as 主机系统
participant Docker as Docker引擎
participant Env as 容器环境
User->>Host: 执行容器管理命令
Host->>Docker: 解析命令参数
alt 启动容器
Docker->>Env: 启动容器
Env->>Env: 初始化环境
Env-->>Docker: 容器启动完成
else 停止容器
Docker->>Env: 停止容器
Env->>Env: 保存状态
Env-->>Docker: 容器停止完成
else 重启容器
Docker->>Env: 重启容器
Env->>Env: 保存状态
Env->>Env: 重新初始化
Env-->>Docker: 容器重启完成
else 删除容器
Docker->>Env: 删除容器
Env->>Env: 清理资源
Env-->>Docker: 容器删除完成
end
Docker-->>Host: 命令执行结果
Host-->>User: 结果返回
4. 详细UML类图
Apollo Docker子模块的UML类图展示了系统的核心组件、它们之间的关系以及各自的职责。类图设计遵循面向对象的设计原则，确保了系统的模块化、可扩展性和可维护性。
4.1. 核心模块类图
核心模块类图展示了Docker子模块的主要组件及其之间的关系，包括DockerSystem、BuildManager、ContainerManager等核心类。这些类构成了Docker子模块的骨架，负责系统的整体协调和管理。
classDiagram
class DockerSystem {
+initialize()
+buildImages()
+startContainer()
+stopContainer()
+cleanupResources()
+getSystemStatus(): SystemStatus
+setLogger(Logger): void
-buildManager: BuildManager
-containerManager: ContainerManager
-config: DockerConfig
-logger: Logger
-systemStatus: SystemStatus
}
class BuildManager {
+buildBaseImage()
+buildCyberImage()
+buildDevImage()
+buildRuntimeImage()
+buildTestImage()
+buildProductionImage()
+validateBuildConfig(): bool
+getBuildProgress(): float
+setBuildConfig(BuildConfig): void
-dockerfiles: map<string, Dockerfile>
-installers: list<Installer>
-buildConfig: BuildConfig
-buildProgress: float
-buildStatus: BuildStatus
}
class ContainerManager {
+startDevContainer()
+startRuntimeContainer()
+startTestContainer()
+enterContainer()
+stopAllContainers()
+removeContainer(string): bool
+getContainerStatus(string): ContainerStatus
+listContainers(): list<Container>
-containers: list<Container>
-containerConfig: ContainerConfig
-containerFactory: ContainerFactory
}
class Dockerfile {
+load(string)
+getStages(): list<Stage>
+getPlatform(): string
+generateBuildCommand(): string
+getBuildArgs(): map<string, string>
+setBuildArg(string, string): void
-content: string
-stages: list<Stage>
-platform: string
-gpuType: string
-buildArgs: map<string, string>
-baseImage: string
}
class Stage {
+getName(): string
+getCommands(): list<string>
+getBaseStage(): string
+addCommand(string): void
-name: string
-commands: list<string>
-baseStage: string
-workdir: string
-envVars: map<string, string>
}
class Installer {
<<abstract>>
+install()
+uninstall()
+getVersion(): string
+getDependencies(): list<string>
+isInstalled(): bool
+update(): bool
-packageName: string
-version: string
-installPath: string
-isInstalled: bool
}
class BazelInstaller {
+installBazel()
+configureBazel()
+installBazelExtensions()
+getBazelConfig(): BazelConfig
-bazelVersion: string
-extensions: list<string>
-bazelConfig: BazelConfig
}
class CUDAInstaller {
+installCUDA()
+installCUDNN()
+installTensorRT()
+configureCUDA()
+validateCUDA(): bool
-cudaVersion: string
-cudnnVersion: string
-tensorrtVersion: string
-cudaConfig: CUDAConfig
}
class PythonInstaller {
+installPython()
+installPackages()
+installVirtualEnv()
+getPackageList(): list<string>
+createVirtualEnv(string): bool
-pythonVersion: string
-requirementsFile: string
-packages: list<string>
-virtualEnvs: map<string, string>
}
class ProtobufInstaller {
+installProtobuf()
+compileProtobufFiles(string): bool
+getProtobufVersion(): string
-protobufVersion: string
-installPath: string
-compilerPath: string
}
class Container {
+start()
+stop()
+pause()
+resume()
+exec(string)
+getLogs(): string
+getResourceUsage(): ResourceUsage
+getId(): string
+getName(): string
-containerId: string
-containerName: string
-image: string
-status: ContainerStatus
-ports: list<PortMapping>
-volumes: list<VolumeMapping>
-envVars: map<string, string>
-network: NetworkConfig
}
class ContainerFactory {
+createDevContainer(): Container
+createRuntimeContainer(): Container
+createTestContainer(): Container
+createProductionContainer(): Container
-containerConfig: ContainerConfig
}
class SystemStatus {
+isHealthy(): bool
+getDockerVersion(): string
+getAvailableSpace(): long
+getCPUCount(): int
-isHealthy: bool
-dockerVersion: string
-availableSpace: long
-cpuCount: int
-memorySize: long
}
DockerSystem --> BuildManager
DockerSystem --> ContainerManager
DockerSystem --> DockerConfig
DockerSystem --> Logger
DockerSystem --> SystemStatus
BuildManager --> Dockerfile
BuildManager --> Installer
BuildManager --> BuildConfig
BuildManager --> BuildStatus
Dockerfile --> Stage
Installer <|-- BazelInstaller
Installer <|-- CUDAInstaller
Installer <|-- PythonInstaller
Installer <|-- ProtobufInstaller
BazelInstaller --> BazelConfig
CUDAInstaller --> CUDAConfig
ContainerManager --> Container
ContainerManager --> ContainerFactory
ContainerManager --> ContainerConfig
Container --> ResourceUsage
Container --> PortMapping
Container --> VolumeMapping
Container --> NetworkConfig
4.2. 数据流类图
数据流类图展示了Docker子模块中数据的流动和处理过程，包括BuildData、ContainerData、ConfigData等核心数据类。这些类负责数据的传输、转换和存储，确保了系统数据的一致性和可靠性。
classDiagram
class DockerData {
<<abstract>>
+getTimestamp(): timestamp
+getDataId(): string
+serialize(): bytes
+deserialize(bytes)
+validate(): bool
+clone(): DockerData
#timestamp: timestamp
#dataId: string
#source: string
#valid: bool
}
class BuildData {
+getBuildType(): string
+getPlatform(): string
+getGPUType(): string
+getStages(): list<string>
+getOptions(): map<string, string>
+getBuildProgress(): float
+setBuildProgress(float): void
+addBuildStage(string): void
-buildType: string
-platform: string
-gpuType: string
-stages: list<string>
-options: map<string, string>
-progress: float
-buildId: string
-startTime: timestamp
-endTime: timestamp
}
class ContainerData {
+getContainerId(): string
+getImageName(): string
+getStatus(): string
+getStartTime(): timestamp
+getEndTime(): timestamp
+getResourceUsage(): ResourceUsage
+setResourceUsage(ResourceUsage): void
+setContainerStatus(string): void
-containerId: string
-imageName: string
-status: string
-startTime: timestamp
-endTime: timestamp
-resourceUsage: ResourceUsage
-containerName: string
-networkInfo: NetworkInfo
}
class ResourceUsage {
+getCPU(): float
+getMemory(): float
+getGPU(): float
+getDisk(): float
+getNetworkIn(): long
+getNetworkOut(): long
+setCPU(float): void
+setMemory(float): void
+setGPU(float): void
-cpuUsage: float
-memoryUsage: float
-gpuUsage: float
-diskUsage: float
-networkIn: long
-networkOut: long
-timestamp: timestamp
}
class ConfigData {
+getConfigKey(): string
+getConfigValue(): string
+getScope(): string
+isMandatory(): bool
+getDefaultValue(): string
+setConfigValue(string): void
-configKey: string
-configValue: string
-scope: string
-isMandatory: bool
-defaultValue: string
-description: string
-dataType: string
}
class NetworkInfo {
+getIPAddress(): string
+getMacAddress(): string
+getGateway(): string
+getSubnetMask(): string
+getPorts(): list<PortMapping>
-ipAddress: string
-macAddress: string
-gateway: string
-subnetMask: string
-ports: list<PortMapping>
}
class LogData {
+getLogLevel(): string
+getLogMessage(): string
+getLogSource(): string
+getLogTimestamp(): timestamp
+setLogLevel(string): void
+setLogMessage(string): void
-logLevel: string
-logMessage: string
-logSource: string
-logTimestamp: timestamp
-logId: string
}
DockerData <|-- BuildData
DockerData <|-- ContainerData
DockerData <|-- ConfigData
DockerData <|-- LogData
ContainerData --> ResourceUsage
ContainerData --> NetworkInfo
BuildData --> ConfigData
ContainerData --> ConfigData
LogData --> DockerData
NetworkInfo --> PortMapping
4.3. 配置管理类图
配置管理类图展示了Docker子模块的配置管理系统，包括DockerConfig、PlatformConfig、GlobalConfig等核心配置类。这些类负责系统配置的加载、存储和管理，确保了系统配置的一致性和可维护性。
classDiagram
class DockerConfig {
+loadConfig(string): bool
+saveConfig(string): bool
+getPlatformConfig(string): PlatformConfig
+setPlatformConfig(string, PlatformConfig): bool
+getGlobalConfig(): GlobalConfig
+setGlobalConfig(GlobalConfig): bool
+getInstallerConfig(string): InstallerConfig
+setInstallerConfig(string, InstallerConfig): bool
+reloadConfig(): bool
-platforms: map<string, PlatformConfig>
-globalConfig: GlobalConfig
-installerConfigs: map<string, InstallerConfig>
-logger: Logger
-configPath: string
}
class PlatformConfig {
+getArchitecture(): string
+getGPUType(): string
+getOSVersion(): string
+getDockerfilePath(): string
+isValid(): bool
+getSupportedStages(): list<string>
+addSupportedStage(string): void
-architecture: string
-gpuType: string
-osVersion: string
-dockerfilePath: string
-supportedStages: list<string>
-baseImage: string
-buildArgs: map<string, string>
}
class GlobalConfig {
+getDockerVersion(): string
+getDefaultPlatform(): string
+isGPUSupported(): bool
+getNetworkMode(): string
+getDefaultVolume(): string
+isExperimentalFeaturesEnabled(): bool
+setDefaultPlatform(string): void
+setGPUSupported(bool): void
-dockerVersion: string
-defaultPlatform: string
-gpuSupported: bool
-networkMode: string
-defaultVolume: string
-experimentalFeatures: bool
-defaultStage: string
-cacheEnabled: bool
}
class InstallerConfig {
+getInstallerName(): string
+getVersion(): string
+getDependencies(): list<string>
+getInstallPath(): string
+getOptions(): map<string, string>
+setOption(string, string): void
-installerName: string
-version: string
-dependencies: list<string>
-installPath: string
-options: map<string, string>
-checksum: string
-downloadURL: string
}
class ContainerConfig {
+getContainerName(): string
+getImageName(): string
+getWorkdir(): string
+getPortMappings(): list<PortMapping>
+getVolumeMappings(): list<VolumeMapping>
+getEnvVars(): map<string, string>
+addPortMapping(PortMapping): void
+addVolumeMapping(VolumeMapping): void
+setEnvVar(string, string): void
-containerName: string
-imageName: string
-workdir: string
-portMappings: list<PortMapping>
-volumeMappings: list<VolumeMapping>
-envVars: map<string, string>
-privileged: bool
-networkMode: string
}
class PortMapping {
+getHostPort(): int
+getContainerPort(): int
+getProtocol(): string
-hostPort: int
-containerPort: int
-protocol: string
}
class VolumeMapping {
+getHostPath(): string
+getContainerPath(): string
+getMode(): string
-hostPath: string
-containerPath: string
-mode: string
}
class NetworkConfig {
+getNetworkName(): string
+getNetworkMode(): string
+getIPAddress(): string
+isBridgeMode(): bool
-networkName: string
-networkMode: string
-ipAddress: string
-subnet: string
-gateway: string
}
DockerConfig --> PlatformConfig
DockerConfig --> GlobalConfig
DockerConfig --> InstallerConfig
DockerConfig --> Logger
PlatformConfig --> InstallerConfig
GlobalConfig --> InstallerConfig
ContainerManager --> ContainerConfig
ContainerConfig --> PortMapping
ContainerConfig --> VolumeMapping
ContainerConfig --> NetworkConfig
Container --> NetworkConfig
5. 状态机
Apollo Docker子模块的状态机展示了系统在不同阶段的状态转换和处理流程，包括镜像构建状态机和容器生命周期状态机等。这些状态机设计清晰，状态转换明确，便于开发者理解系统的运行机制和行为。
5.1. Docker镜像构建状态机
Docker镜像构建状态机展示了从构建开始到构建完成的完整流程，包括初始化、验证、配置、构建、测试等多个阶段。每个阶段都有明确的状态转换条件和处理逻辑，确保了构建过程的稳定性和可靠性。
stateDiagram-v2
[*] --> Initializing: 开始构建流程
Initializing --> Validating: 初始化完成
Validating --> Configuring: 验证通过
Configuring --> Building: 配置完成
Building --> Testing: 构建完成
Testing --> Publishing: 测试通过
Publishing --> [*]: 发布完成
Validating --> Error: 验证失败
Configuring --> Error: 配置失败
Building --> Error: 构建失败
Testing --> Error: 测试失败
Publishing --> Error: 发布失败
Error --> [*]: 结束构建
state Initializing {
[*] --> LoadingDockerfile: 加载Dockerfile
LoadingDockerfile --> ParsingStages: Dockerfile加载完成
ParsingStages --> LoadingInstallers: 阶段解析完成
LoadingInstallers --> ValidatingDockerfile: 安装脚本加载完成
ValidatingDockerfile --> [*]: Dockerfile验证通过
}
state Validating {
[*] --> CheckingDockerVersion: 检查Docker版本
CheckingDockerVersion --> CheckingPlatform: Docker版本检查通过
CheckingPlatform --> CheckingGPU: 平台检查通过
CheckingGPU --> CheckingDependencies: GPU检查通过
CheckingDependencies --> ValidatingBuildArgs: 依赖检查通过
ValidatingBuildArgs --> [*]: 构建参数验证通过
}
state Configuring {
[*] --> SettingEnvironment: 设置环境变量
SettingEnvironment --> ConfiguringBuildArgs: 环境变量设置完成
ConfiguringBuildArgs --> SettingCache: 构建参数配置完成
SettingCache --> ConfiguringNetwork: 缓存策略设置完成
ConfiguringNetwork --> [*]: 网络配置完成
}
state Building {
[*] --> BuildingBase: 构建基础镜像
BuildingBase --> BuildingCyber: 基础镜像构建完成
BuildingCyber --> BuildingDev: Cyber镜像构建完成
BuildingDev --> BuildingRuntime: 开发镜像构建完成
BuildingRuntime --> BuildingTest: 运行时镜像构建完成
BuildingTest --> BuildingProduction: 测试镜像构建完成
BuildingProduction --> [*]: 生产镜像构建完成
}
state Testing {
[*] --> TestingBase: 测试基础镜像
TestingBase --> TestingCyber: 基础镜像测试通过
TestingCyber --> TestingDev: Cyber镜像测试通过
TestingDev --> TestingRuntime: 开发镜像测试通过
TestingRuntime --> TestingTest: 运行时镜像测试通过
TestingTest --> TestingProduction: 测试镜像测试通过
TestingProduction --> [*]: 生产镜像测试通过
}
state Publishing {
[*] --> TaggingImage: 标记镜像
TaggingImage --> PushingImage: 镜像标记完成
PushingImage --> VerifyingImage: 镜像推送完成
VerifyingImage --> [*]: 镜像验证完成
}
state Error {
[*] --> LoggingError: 记录错误信息
LoggingError --> CleaningUp: 错误信息记录完成
CleaningUp --> [*]: 资源清理完成
}
5.2. Docker容器生命周期状态机
Docker容器生命周期状态机展示了容器从创建到删除的完整生命周期，包括创建、运行、暂停、停止、重启、删除等多个状态。每个状态都有明确的转换条件和处理逻辑，确保了容器管理的稳定性和可靠性。
stateDiagram-v2
[*] --> Created: 创建容器
Created --> Running: 启动容器
Running --> Paused: 暂停容器
Paused --> Running: 恢复容器
Running --> Stopped: 停止容器
Stopped --> Running: 重启容器
Stopped --> Removed: 删除容器
Removed --> [*]: 容器删除完成
state Created {
[*] --> ConfiguringContainer: 配置容器参数
ConfiguringContainer --> MountingVolumes: 容器参数配置完成
MountingVolumes --> MappingPorts: 卷挂载完成
MappingPorts --> SettingEnvVars: 端口映射完成
SettingEnvVars --> [*]: 环境变量设置完成
}
state Running {
[*] --> Initializing: 初始化容器
Initializing --> Ready: 初始化完成
Ready --> Processing: 执行命令
Processing --> Ready: 命令执行完成
Ready --> Monitoring: 监控容器状态
Monitoring --> Ready: 状态检查完成
Ready --> [*]: 退出容器
}
state Paused {
[*] --> SavingMemory: 保存内存状态
SavingMemory --> [*]: 内存状态保存完成
}
state Stopped {
[*] --> SavingState: 保存容器状态
SavingState --> ClosingNetwork: 状态保存完成
ClosingNetwork --> ReleasingResources: 网络连接关闭
ReleasingResources --> [*]: 资源释放完成
}
state Removed {
[*] --> RemovingContainer: 删除容器
RemovingContainer --> UnmountingVolumes: 容器删除完成
UnmountingVolumes --> CleaningUp: 卷卸载完成
CleaningUp --> [*]: 清理完成
}
5.3. Docker环境配置状态机
Docker环境配置状态机展示了环境配置的完整流程，包括初始化、检查、配置、验证等多个阶段。每个阶段都有明确的状态转换条件和处理逻辑，确保了环境配置的正确性和一致性。
stateDiagram-v2
[*] --> Initializing: 开始环境配置
Initializing --> Checking: 初始化完成
Checking --> Configuring: 检查通过
Configuring --> Validating: 配置完成
Validating --> Ready: 验证通过
Ready --> [*]: 环境配置完成
Checking --> Error: 检查失败
Configuring --> Error: 配置失败
Validating --> Error: 验证失败
Error --> [*]: 环境配置结束
state Initializing {
[*] --> LoadingConfig: 加载配置文件
LoadingConfig --> ParsingConfig: 配置文件加载完成
ParsingConfig --> [*]: 配置文件解析完成
}
state Checking {
[*] --> CheckingSystem: 检查系统环境
CheckingSystem --> CheckingDocker: 系统环境检查通过
CheckingDocker --> CheckingDependencies: Docker检查通过
CheckingDependencies --> [*]: 依赖检查通过
}
state Configuring {
[*] --> ConfiguringNetwork: 配置网络
ConfiguringNetwork --> ConfiguringStorage: 网络配置完成
ConfiguringStorage --> ConfiguringPermissions: 存储配置完成
ConfiguringPermissions --> [*]: 权限配置完成
}
state Validating {
[*] --> TestingNetwork: 测试网络连接
TestingNetwork --> TestingStorage: 网络连接测试通过
TestingStorage --> TestingPermissions: 存储测试通过
TestingPermissions --> [*]: 权限测试通过
}
state Ready {
[*] --> InitializingEnvironment: 初始化环境
InitializingEnvironment --> [*]: 环境初始化完成
}
5.4. Docker镜像缓存状态机
Docker镜像缓存状态机展示了镜像缓存的管理流程，包括检查缓存、使用缓存、更新缓存等多个阶段。每个阶段都有明确的状态转换条件和处理逻辑，确保了缓存的有效性和一致性。
stateDiagram-v2
[*] --> CheckingCache: 检查缓存
CheckingCache --> UsingCache: 缓存存在且有效
CheckingCache --> BuildingFromScratch: 缓存不存在或无效
UsingCache --> UpdatingCache: 使用缓存完成
BuildingFromScratch --> UpdatingCache: 重新构建完成
UpdatingCache --> [*]: 缓存更新完成
state CheckingCache {
[*] --> CheckingCacheExistence: 检查缓存是否存在
CheckingCacheExistence --> CheckingCacheValidity: 缓存存在
CheckingCacheValidity --> [*]: 缓存有效
}
state UsingCache {
[*] --> LoadingCachedLayers: 加载缓存层
LoadingCachedLayers --> VerifyingCachedLayers: 缓存层加载完成
VerifyingCachedLayers --> [*]: 缓存层验证通过
}
state BuildingFromScratch {
[*] --> BuildingNewLayers: 构建新层
BuildingNewLayers --> VerifyingNewLayers: 新层构建完成
VerifyingNewLayers --> [*]: 新层验证通过
}
state UpdatingCache {
[*] --> SavingNewLayers: 保存新层
SavingNewLayers --> UpdatingCacheMetadata: 新层保存完成
UpdatingCacheMetadata --> [*]: 缓存元数据更新完成
}
6. 源码分析
6.1. 构建系统核心代码分析
6.1.1. build_docker.sh 脚本核心逻辑
#!/usr/bin/env bash
# 支持的架构和GPU类型定义
SUPPORTED_ARCHS=(x86_64 aarch64)
SUPPORTED_GPUS=(amd nvidia)
SUPPORTED_STAGES=(base cyber dev runtime)
# 配置参数初始化
TARGET_ARCH=""
TARGET_GPU=""
TARGET_STAGE=""
USE_CACHE=1
# 核心功能函数
gpu_support_check() {
local gpu="$1"
for entry in "${SUPPORTED_GPUS[@]}"; do
if [[ "${entry}" == "${gpu}" ]]; then
return
fi
done
echo "Unsupported GPU: ${gpu}. Exiting..."
exit 1
}
# 构建命令生成函数
generate_build_command() {
local build_cmd="docker build"
if [[ ${USE_CACHE} -eq 0 ]]; then
build_cmd+=" --no-cache"
fi
build_cmd+=" --build-arg CUDA_LITE=${CUDA_LITE}"
build_cmd+=" --build-arg CUDNN_VERSION=${CUDNN_VERSION}"
build_cmd+=" --build-arg TENSORRT_VERSION=${TENSORRT_VERSION}"
build_cmd+=" -t ${IMAGE_OUT}"
build_cmd+=" -f ${DOCKERFILE} ."
echo "${build_cmd}"
}
# 主流程
determine_target_arch_and_stage "${DOCKERFILE}"
validate_build_config
configure_build_environment
generate_build_command
exec_build_command
6.1.2. Dockerfile 结构分析
FROM nvidia/cuda:11.1-cudnn8-devel-ubuntu18.04 AS base
# 系统环境配置
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update && apt-get install -y --no-install-recommends \
build-essential \
git \
curl \
wget \
&& rm -rf /var/lib/apt/lists/*
# 安装脚本复制和执行
COPY installers/install_base.sh /apollo/installers/
RUN chmod +x /apollo/installers/install_base.sh
RUN /apollo/installers/install_base.sh
# 环境变量配置
ENV APOLLO_HOME=/apollo
ENV PATH=${APOLLO_HOME}/bin:${PATH}
ENV LD_LIBRARY_PATH=${APOLLO_HOME}/lib:${LD_LIBRARY_PATH}
# 工作目录设置
WORKDIR ${APOLLO_HOME}
6.2. 容器管理核心代码分析
6.2.1. dev_start.sh 脚本核心逻辑
#!/usr/bin/env bash
# 容器配置参数
CONTAINER_NAME="apollo_dev"
IMAGE_NAME="apolloauto/apollo:dev-x86_64-nvidia"
WORKDIR="${PWD}"
PORT_MAPPINGS="-p 8888:8888 -p 5555:5555"
# 检查Docker是否运行
if ! docker info > /dev/null 2>&1; then
echo "Docker is not running. Please start Docker first."
exit 1
fi
# 检查容器是否已存在
if docker ps -a | grep -q "${CONTAINER_NAME}"; then
echo "Container ${CONTAINER_NAME} already exists. Starting it..."
docker start "${CONTAINER_NAME}"
else
echo "Creating new container ${CONTAINER_NAME}..."
docker run -itd \
--name "${CONTAINER_NAME}" \
--privileged \
--net host \
--ipc host \
--pid host \
${PORT_MAPPINGS} \
-v "${WORKDIR}:/apollo" \
-v /tmp/.X11-unix:/tmp/.X11-unix \
-e DISPLAY=${DISPLAY} \
"${IMAGE_NAME}"
fi
# 进入容器
echo "Entering container ${CONTAINER_NAME}..."
docker exec -it "${CONTAINER_NAME}" /bin/bash
6.2.2. dev_into.sh 脚本核心逻辑
#!/usr/bin/env bash
# 查找Apollo开发容器
CONTAINER_ID=$(docker ps | grep apolloauto/apollo:dev | awk '{print $1}')
if [ -z "${CONTAINER_ID}" ]; then
echo "No running Apollo development container found."
echo "Please run 'bash scripts/dev_start.sh' first."
exit 1
fi
# 进入容器
echo "Entering Apollo development container: ${CONTAINER_ID}"
docker exec -it "${CONTAINER_ID}" /bin/bash
6.3. 安装系统核心代码分析
6.3.1. installer_base.sh 脚本核心逻辑
#!/usr/bin/env bash
# 基础安装类
installer_base() {
local package_name="$1"
local version="$2"
local install_path="$3"
echo "Installing ${package_name} version ${version}..."
# 检查是否已安装
if is_installed "${package_name}"; then
echo "${package_name} is already installed."
return 0
fi
# 下载源码或二进制包
download_package "${package_name}" "${version}"
# 安装包
install_package "${package_name}" "${version}" "${install_path}"
# 验证安装
if verify_install "${package_name}"; then
echo "${package_name} installed successfully."
return 0
else
echo "Failed to install ${package_name}."
return 1
fi
}
# 安装验证函数
verify_install() {
local package_name="$1"
echo "Verifying ${package_name} installation..."
# 验证逻辑
return 0
}
6.3.2. install_bazel.sh 脚本核心逻辑
#!/usr/bin/env bash
# Bazel安装函数
install_bazel() {
local bazel_version="4.2.2"
local install_path="/usr/local/bin"
echo "Installing Bazel version ${bazel_version}..."
# 下载Bazel安装器
wget -O /tmp/bazel_installer.sh \
"https://github.com/bazelbuild/bazel/releases/download/${bazel_version}/bazel-${bazel_version}-installer-linux-x86_64.sh"
# 安装Bazel
chmod +x /tmp/bazel_installer.sh
/tmp/bazel_installer.sh --prefix="${install_path}"
# 配置环境变量
echo "export PATH=${install_path}:\${PATH}" >> /etc/profile
# 验证安装
if bazel --version > /dev/null 2>&1; then
echo "Bazel ${bazel_version} installed successfully."
return 0
else
echo "Failed to install Bazel."
return 1
fi
}
6.4. 配置管理核心代码分析
6.4.1. setup.sh 脚本核心逻辑
#!/usr/bin/env bash
# Apollo环境配置脚本
export APOLLO_ROOT_DIR="/apollo"
export CYBER_PATH="${APOLLO_ROOT_DIR}/cyber"
export LD_LIBRARY_PATH="${CYBER_PATH}/lib:${LD_LIBRARY_PATH}"
export PATH="${CYBER_PATH}/bin:${APOLLO_ROOT_DIR}/bin:${PATH}"
# Bazel配置
export BAZEL_CONFIG="--config=cuda"
export BAZEL_OUTPUT_BASE="${APOLLO_ROOT_DIR}/.cache/bazel"
# 工作目录设置
cd "${APOLLO_ROOT_DIR}" || exit
# 环境变量验证
echo "Apollo environment configured successfully."
echo "APOLLO_ROOT_DIR: ${APOLLO_ROOT_DIR}"
echo "CYBER_PATH: ${CYBER_PATH}"
echo "PATH: ${PATH}"
7. 设计模式
7.1. 构建器模式
Apollo Docker子模块采用构建器模式来构建不同类型的Docker镜像。通过将复杂的构建过程分解为多个简单的步骤，提高了代码的可维护性和扩展性。
# 构建器模式的实现
build_base_image() {
# 构建基础镜像的步骤
configure_base_environment
install_base_dependencies
setup_base_configuration
}
build_cyber_image() {
# 构建Cyber镜像的步骤
build_base_image # 继承基础镜像
install_cyber_dependencies
build_cyber_framework
setup_cyber_configuration
}
build_dev_image() {
# 构建开发镜像的步骤
build_cyber_image # 继承Cyber镜像
install_dev_dependencies
setup_dev_environment
configure_dev_tools
}
7.2. 工厂方法模式
在Docker容器管理中，工厂方法模式用于创建不同类型的容器实例。
# 工厂方法模式的实现
create_dev_container() {
# 创建开发容器
create_container "dev" "${DEV_IMAGE}" "${DEV_CONTAINER_NAME}"
}
create_runtime_container() {
# 创建运行时容器
create_container "runtime" "${RUNTIME_IMAGE}" "${RUNTIME_CONTAINER_NAME}"
}
create_container() {
local type="$1"
local image="$2"
local name="$3"
# 根据类型创建不同的容器配置
if [[ "${type}" == "dev" ]]; then
docker run -itd --name "${name}" --privileged --net host -v "${WORKDIR}:/apollo" "${image}"
elif [[ "${type}" == "runtime" ]]; then
docker run -itd --name "${name}" --net host "${image}"
fi
}
7.3. 策略模式
策略模式用于处理不同平台和GPU类型的构建策略。
# 策略模式的实现
set_build_strategy() {
local arch="$1"
local gpu="$2"
if [[ "${arch}" == "x86_64" && "${gpu}" == "nvidia" ]]; then
BUILD_STRATEGY="x86_64_nvidia_strategy"
elif [[ "${arch}" == "x86_64" && "${gpu}" == "amd" ]]; then
BUILD_STRATEGY="x86_64_amd_strategy"
elif [[ "${arch}" == "aarch64" && "${gpu}" == "nvidia" ]]; then
BUILD_STRATEGY="aarch64_nvidia_strategy"
fi
}
# 不同策略的实现
x86_64_nvidia_strategy() {
echo "Using x86_64 NVIDIA build strategy"
DOCKERFILE="base.x86_64.nvidia.dockerfile"
CUDA_LITE="11.1"
CUDNN_VERSION="8.0.4.30"
TENSORRT_VERSION="7.2.1"
}
7.4. 模板方法模式
模板方法模式用于定义安装流程的骨架，具体步骤由子类实现。
# 模板方法模式的实现
install_package() {
local package="$1"
# 安装流程的固定步骤
pre_install "${package}"
do_install "${package}" # 具体安装步骤由子类实现
post_install "${package}"
verify_install "${package}"
}
# 具体安装实现
do_install() {
local package="$1"
if [[ "${package}" == "bazel" ]]; then
# Bazel安装实现
install_bazel
elif [[ "${package}" == "protobuf" ]]; then
# Protobuf安装实现
install_protobuf
fi
}
7.5. 单例模式
单例模式用于管理全局配置和资源。
# 单例模式的实现
_get_docker_config() {
if [[ -z "${DOCKER_CONFIG_INSTANCE}" ]]; then
DOCKER_CONFIG_INSTANCE="$(create_config_instance)"
fi
echo "${DOCKER_CONFIG_INSTANCE}"
}
create_config_instance() {
# 创建配置实例
local config=""
config+="APOLLO_REPO=apolloauto/apollo"
config+=";UBUNTU_LTS=18.04"
config+=";CUDA_LITE=11.1"
config+=";CUDNN_VERSION=8.0.4.30"
echo "${config}"
}
8. 总结
Apollo Docker子模块通过容器化技术实现了开发环境的一致性和可移植性，采用分层架构设计支持多平台和多种硬件加速。该模块包含构建系统、开发环境、运行时环境和辅助工具四大核心组件，通过构建器、工厂方法、策略等多种设计模式提高了代码的可维护性和扩展性。Docker子模块为Apollo自动驾驶平台提供了高效、可靠的开发和运行环境，是平台生态系统的重要组成部分，为开发者提供了便捷的开发体验。
