Jetson AGX Orin容器化快速启动指南：Docker环境搭建与AI应用部署

1. 项目概述：为什么需要容器化快速启动？

如果你刚拿到一块NVIDIA Jetson AGX Orin 64GB开发套件，面对这块性能强大但生态独特的边缘AI计算平台，第一感觉可能是兴奋，紧接着可能就是一丝迷茫。官方的JetPack SDK提供了完整的系统镜像，但当你真正开始部署一个具体的AI应用时，往往会发现一个经典困境：如何在保证系统环境纯净、可复现的前提下，快速搭建起包含特定框架版本（如PyTorch、TensorRT）、依赖库和自定义代码的完整开发与部署环境？手动配置不仅耗时，而且极易出现版本冲突、依赖缺失等问题，一旦系统崩溃或需要迁移到另一台设备，所有工作又得重头再来。

这正是“Jetson Containers Quickstart”项目要解决的核心痛点。它不是一个单一的软件，而是一套基于Docker容器的最佳实践与方法论，旨在为Jetson AGX Orin 64GB（同样适用于其他Jetson系列）用户提供一个标准化、可移植、一键式的环境搭建方案。其核心价值在于，将复杂的系统级环境配置封装进一个轻量级的“集装箱”（容器）里。你可以把这个容器理解为一个预先配置好的、包含操作系统、编程语言、深度学习框架、推理引擎等所有必要组件的“沙箱”。在这个沙箱里进行开发、训练和部署，环境是绝对隔离且一致的。今天在这台Orin上跑通的模型，明天打包成容器，可以无缝地在另一台Orin甚至其他架构的服务器上运行，彻底告别“在我机器上是好的”这类问题。

对于Jetson开发者而言，这套方案的吸引力是巨大的。AGX Orin 64GB拥有强大的Ampere架构GPU和丰富的AI算力，是部署计算机视觉、自然语言处理等复杂模型的理想边缘设备。但它的ARM64架构与常见的x86服务器不同，许多预编译的Python包或深度学习框架轮子（wheel）无法直接使用，需要从源码编译，这个过程动辄数小时，且极易出错。Jetson Containers项目通过提供一系列预构建的、针对Jetson硬件和JetPack版本优化过的Docker镜像，直接将最耗时、最易错的环境搭建环节变成了一个简单的docker pull和docker run命令。无论是想快速验证一个模型在Orin上的性能，还是要构建一个可交付的产品级应用镜像，这套快速启动指南都是你的高效起点。

2. 核心优势与适用场景解析

2.1 对比传统部署方式的优势

在接触容器化方案前，大多数Jetson开发者的工作流可能是这样的：在宿主机上直接安装JetPack，然后通过pip或apt安装各种包，过程中可能需要手动编译OpenCV、PyTorch等。我们来对比一下这种传统方式与容器化方案的差异：

从表格中可以清晰看出，容器化方案在开发效率、维护成本和工程规范性上具有压倒性优势。特别是对于团队协作和持续集成/持续部署（CI/CD）流水线，容器是实现标准化交付的基石。

2.2 主要适用场景与目标用户

这个快速启动项目主要服务于以下几类场景和用户：

1. AI应用开发者与研究员：你有一个训练好的模型，需要快速在Jetson AGX Orin上验证其推理速度和精度。使用预置的PyTorch或TensorFlow镜像，可以在几分钟内进入一个交互式的Python环境，直接开始模型的转换与测试，无需关心底层库的编译。

2. 嵌入式软件工程师：你正在开发一个基于Jetson的产品，需要将算法、中间件、应用程序打包成一个整体进行部署。通过编写自定义的Dockerfile，基于官方镜像构建一个包含你所有业务代码的“最终镜像”，这个镜像就是可以交付给生产环境的软件单元。

3. 教育与培训者：你需要为学员提供一个统一的、免配置的实验环境。可以预先准备好包含所有实验所需工具的容器镜像，学员只需运行容器即可开始学习，避免了因环境差异导致的教学问题。

4. 系统集成商：需要为不同客户部署功能相似但配置略有差异的Jetson系统。可以为每个客户定制一个容器镜像，实现批量化、标准化的部署，极大降低运维成本。

注意：虽然容器带来了巨大便利，但它并非“银弹”。对于需要直接访问特定硬件（如某些特定的传感器、GPIO引脚）或对实时性有极端要求的场景，可能需要更深入的配置，甚至考虑使用Docker的--privileged模式或设备映射（--device），但这会部分牺牲容器的安全隔离性。对于绝大多数AI推理和应用服务化场景，标准容器已完全足够。

3. 环境准备与基础工具链安装

在开始拉取和运行Jetson容器之前，我们需要确保宿主系统（即Jetson AGX Orin上运行的Linux系统）已经准备好了容器运行的基石——Docker引擎。虽然NVIDIA官方在较新的JetPack版本中可能会预装Docker，但手动检查和安装是一个好习惯。

3.1 确认JetPack版本与系统状态

首先，打开终端，通过以下命令确认你的JetPack版本和系统架构，这决定了你应该选择哪个标签（tag）的容器镜像。

# 查看JetPack版本（L4T版本） head -n 1 /etc/nv_tegra_release # 输出可能类似于：# R35 (release), REVISION: 4.3, GCID: 33984743, BOARD: t186ref, EABI: aarch64, DATE: Fri Jun 16 19:38:25 UTC 2023 # 这里的“R35”对应L4T 35.x版本，是选择容器镜像的关键。 # 查看系统架构，确认是aarch64（ARM64） uname -m # 应输出：aarch64 # 查看CUDA版本（如果你安装了） nvcc --version # 或 cat /usr/local/cuda/version.txt

记录下L4T版本号（如r35.4.1），因为NVIDIA NGC（容器镜像仓库）中的Jetson镜像通常以L4T版本作为标签。

3.2 安装与配置Docker引擎

如果你的系统没有安装Docker，请按照以下步骤进行安装。这里采用官方推荐的方式。

# 1. 卸载旧版本（如果存在） sudo apt-get remove docker docker-engine docker.io containerd runc # 2. 安装依赖工具 sudo apt-get update sudo apt-get install -y \ ca-certificates \ curl \ gnupg \ lsb-release # 3. 添加Docker官方GPG密钥 sudo mkdir -p /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg # 4. 设置Docker稳定版仓库 # 注意：Jetson基于Ubuntu，但需要确认你的发行版代号。对于JetPack 5.x/6.x，通常是jammy(22.04)或noble(24.04)。 # 使用 lsb_release -cs 查看。假设是jammy。 echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null # 5. 安装Docker引擎 sudo apt-get update sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-compose-plugin # 6. 将当前用户加入docker组，避免每次使用docker都要sudo sudo usermod -aG docker $USER # **重要**：执行此命令后，你需要完全注销并重新登录，或者重启系统，才能使组权限生效。 # 7. 验证安装 docker --version

3.3 安装NVIDIA Container Toolkit

这是最关键的一步。普通的Docker容器无法直接访问宿主机的NVIDIA GPU。NVIDIA Container Toolkit（之前称为nvidia-docker2）是一组工具，它修改了Docker的运行时，使得容器能够无缝地使用Jetson的GPU、CUDA驱动等硬件资源。

# 1. 设置软件仓库和GPG密钥 distribution=$(. /etc/os-release;echo $ID$VERSION_ID) \ && curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \ && curl -fsSL https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \ sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \ sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list # 2. 安装工具包 sudo apt-get update sudo apt-get install -y nvidia-container-toolkit # 3. 配置Docker使用NVIDIA作为默认运行时 sudo nvidia-ctk runtime configure --runtime=docker sudo systemctl restart docker # 4. 验证配置是否成功 # 运行一个基础CUDA容器，测试GPU是否能在容器内被识别 docker run --rm --runtime=nvidia --gpus all nvidia/cuda:12.1.1-base-ubuntu22.04 nvidia-smi

如果最后一条命令成功运行，并输出了与在宿主机上运行nvidia-smi类似的GPU信息，那么恭喜你，你的Jetson AGX Orin已经具备了运行加速AI容器的全部基础条件。

实操心得：在安装NVIDIA Container Toolkit时，网络环境至关重要。由于需要从GitHub和NVIDIA仓库拉取资源，确保你的设备网络通畅。如果遇到GPG error或Failed to fetch，可以尝试更换网络或检查/etc/apt/sources.list.d/nvidia-container-toolkit.list中的仓库地址是否正确对应你的系统版本。

4. 探索与获取NVIDIA官方Jetson容器镜像

环境就绪后，我们就可以从“镜像超市”里挑选需要的环境了。NVIDIA官方维护了一个庞大的容器镜像仓库——NVIDIA GPU Cloud (NGC)，其中有一个专门的“Jetson”分类，里面存放了为Jetson平台优化过的各种基础镜像和全套服务镜像。

4.1 访问NGC目录与镜像选择策略

你可以通过浏览器访问 NGC网站 ，在左侧筛选器中选择“Jetson”，就能看到所有可用的镜像。对于快速启动，我们主要关注以下几类：

1. L4T Base: 最基础的镜像，仅包含JetPack的Linux内核和根文件系统。适合作为自定义镜像的起点。
2. L4T PyTorch: 包含了特定版本PyTorch（已针对Jetson CUDA编译）的镜像。这是AI开发者的首选。
3. L4T TensorFlow: 包含了特定版本TensorFlow的镜像。
4. L4T ML: 包含了多种机器学习框架和工具（如PyTorch, TensorFlow, JupyterLab）的“全家桶”镜像。
5. DeepStream: NVIDIA强大的智能视频分析SDK的容器化版本。
6. Riva: 用于语音AI服务的SDK镜像。

选择镜像时，最关键的两个标签是：

• l4t-version: 必须与你的宿主机JetPack (L4T) 版本匹配，如r35.4.1。
• jetpack-version: 有时也会用JetPack版本号作为标签，如jp5.1.2。

策略建议：如果你是初学者，想快速开始AI模型实验，推荐直接从nvcr.io/nvidia/l4t-pytorch:r35.4.1-pth2.1-py3这类镜像开始。它包含了Python3、PyTorch 2.1以及基本的科学计算库，开箱即用。

4.2 使用Docker命令拉取与运行镜像

假设我们决定拉取上述的PyTorch镜像。

# 1. 拉取镜像。由于镜像较大（通常几个GB），请确保网络稳定。 docker pull nvcr.io/nvidia/l4t-pytorch:r35.4.1-pth2.1-py3 # 2. 运行一个交互式容器 docker run -it --rm --runtime=nvidia --gpus all \ --network host \ -v /home/$USER/workspace:/workspace \ nvcr.io/nvidia/l4t-pytorch:r35.4.1-pth2.1-py3

让我们拆解这个docker run命令：

• -it: 以交互模式运行，并分配一个伪终端，让你可以进入容器内的shell。
• --rm: 容器退出时自动删除其文件系统。非常适合临时实验，避免留下大量停止的容器。
• --runtime=nvidia --gpus all: 使用NVIDIA运行时，并将所有GPU设备暴露给容器。
• --network host: 让容器使用宿主机的网络栈。在Jetson上，这通常能简化网络配置（如访问本地摄像头）。
• -v /home/$USER/workspace:/workspace: 将宿主机的~/workspace目录挂载到容器的/workspace路径。这是极其重要的一步，它实现了宿主机与容器间的文件共享。你可以在宿主机上用喜欢的IDE编辑代码，代码实时同步到容器内运行。
• 最后是镜像名和标签。

执行后，你会进入容器的bash终端。可以立即验证环境：

# 在容器内执行 python3 -c "import torch; print(f'PyTorch version: {torch.__version__}')" python3 -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}')" python3 -c "import torch; print(f'CUDA device: {torch.cuda.get_device_name(0)}')"

如果一切正常，你将看到PyTorch版本、CUDA可用以及识别出Jetson Orin的GPU信息。

4.3 镜像管理与清理

随着实验的进行，你可能会拉取多个镜像或创建多个容器。有效的管理能节省宝贵的存储空间。

# 查看已下载的镜像列表 docker images # 查看正在运行的容器 docker ps # 查看所有容器（包括已停止的） docker ps -a # 停止一个运行中的容器 docker stop <容器ID或名称> # 删除一个已停止的容器 docker rm <容器ID或名称> # 删除一个未被任何容器使用的镜像 docker rmi <镜像ID或名称> # 清理所有已停止的容器、未使用的网络和构建缓存（谨慎使用） docker system prune -a

注意事项：docker system prune -a命令会删除所有未被使用的镜像、容器、网络和构建缓存，非常彻底。在执行前，请确认没有需要保留的、未打标签的中间镜像或已停止的容器。对于日常清理，更推荐使用docker container prune和docker image prune进行针对性清理。

5. 构建自定义应用容器镜像

使用官方镜像快速启动后，下一步就是将我们自己的应用程序也容器化。这通过编写一个Dockerfile文件来实现，它定义了如何从基础镜像一步步构建出包含你所有代码和依赖的最终镜像。

5.1 Dockerfile核心语法与编写实践

让我们为一个简单的Python AI应用创建一个Dockerfile。假设你的项目目录结构如下：

my_ai_project/ ├── Dockerfile ├── requirements.txt ├── app.py └── models/ └── my_model.pt

一个典型的、针对Jetson优化的Dockerfile内容如下：

# 1. 指定基础镜像。这里我们使用之前拉取的PyTorch镜像。 FROM nvcr.io/nvidia/l4t-pytorch:r35.4.1-pth2.1-py3 # 2. 设置容器内的工作目录。后续命令默认在此目录下执行。 WORKDIR /app # 3. 将宿主机的依赖文件列表复制到容器中。 COPY requirements.txt . # 4. 安装Python依赖。使用国内镜像源以加速下载。 RUN pip3 install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt # 5. 将整个项目代码复制到容器的工作目录。 COPY . . # 6. 声明容器运行时监听的端口（如果你的应用是Web服务）。 # EXPOSE 8080 # 7. 设置容器启动时默认执行的命令。 # 例如，直接运行Python脚本： CMD ["python3", "app.py"] # 或者，启动一个交互式shell，方便调试： # CMD ["/bin/bash"]

逐行解析与技巧：

• FROM: 必须且是第一条指令。选择与宿主机L4T版本严格匹配的基础镜像，这是成功的基石。
• WORKDIR: 设置工作目录是个好习惯，它使得后续的COPY、RUN、CMD等指令路径更清晰。
• COPY: 分步复制文件可以利用Docker的构建缓存。先复制requirements.txt并安装依赖，这层缓存只有在requirements.txt变更时才会失效。然后再复制代码，这样修改代码后重建镜像，无需重复安装依赖，速度极快。
• RUN: 执行命令。--no-cache-dir让pip不缓存安装包，稍微减小镜像体积。-i参数指定镜像源，在国内能极大提升安装速度。
• CMD: 定义容器启动时的默认命令。一个Dockerfile中只能有一条CMD指令。在调试阶段，可以先用CMD ["/bin/bash"]进入容器内部检查环境。

5.2 构建镜像与运行自定义容器

在包含Dockerfile的目录下，打开终端执行构建命令：

# 构建镜像。-t 参数为镜像打上标签，格式通常为 名称:版本。 docker build -t my-ai-app:1.0 . # 查看构建好的镜像 docker images | grep my-ai-app # 运行自定义镜像的容器 docker run -it --rm --runtime=nvidia --gpus all \ --network host \ -v /tmp:/tmp \ # 有时需要挂载临时目录 my-ai-app:1.0

如果Dockerfile中CMD指定的是python3 app.py，容器启动后会直接运行你的应用。如果指定的是/bin/bash，则会进入容器的交互式shell，此时你可以手动执行python3 app.py来运行程序。

5.3 镜像优化与分层构建

镜像层是Docker的核心概念之一。Dockerfile中的每一条指令都会创建一个新的只读层。理解这一点对优化镜像体积和构建速度至关重要。

优化技巧：

1. 合并RUN指令：将多个RUN指令用&&连接起来，减少镜像层数。例如：

   RUN apt-get update && \ apt-get install -y --no-install-recommends \ package1 \ package2 \ && rm -rf /var/lib/apt/lists/* # 清理apt缓存，减小体积

2. 使用.dockerignore文件：在构建上下文目录（即docker build命令最后的.所指目录）创建.dockerignore文件，列出不需要复制到镜像中的文件和文件夹（如.git,__pycache__, 日志文件，大的数据集等）。这能加速构建过程并减小镜像体积。
3. 选择更小的基础镜像：如果最终应用不需要完整的PyTorch，可以考虑从l4t-base开始，仅安装必要的库。但通常，为了稳定性和兼容性，直接使用NVIDIA官方优化过的框架镜像是更省心的选择。

6. 容器化开发工作流与高级技巧

将容器集成到日常开发中，而不仅仅是部署的最后一步，能最大化其价值。这里分享一套高效的容器化开发工作流。

6.1 开发-调试-部署一体化工作流

1. 开发阶段：在宿主机上使用VS Code、PyCharm等IDE编写代码。项目根目录下放置Dockerfile和.dockerignore。
2. 调试阶段：使用带挂载卷的方式运行容器。这是最关键的一步，它让你在享受容器环境一致性的同时，又能实时修改代码。

   docker run -it --rm --runtime=nvidia --gpus all \ --network host \ -v $(pwd):/app \ # 将当前目录挂载到容器的/app -w /app \ # 设置容器启动后的工作目录为/app nvcr.io/nvidia/l4t-pytorch:r35.4.1-pth2.1-py3 \ /bin/bash

   进入容器后，你位于/app，这里的文件就是宿主机上的项目文件。你可以直接运行python app.py，代码修改在宿主机保存后，容器内立即生效。你甚至可以在容器内安装调试工具（如pdb,ipdb）。
3. 构建阶段：调试完成后，运行docker build -t my-app:latest .构建最终镜像。由于依赖已缓存，构建速度很快。
4. 测试阶段：运行最终镜像进行集成测试：docker run ... my-app:latest。
5. 部署阶段：将镜像推送到私有或公共的Docker仓库（如Docker Hub, NGC私有仓库），然后在生产环境的Jetson设备上拉取并运行。

6.2 使用Docker Compose管理多容器服务

当你的应用包含多个组件时（例如，一个Web API服务 + 一个数据库 + 一个消息队列），使用Docker Compose可以轻松定义和运行它们。创建一个docker-compose.yml文件：

version: '3.8' services: ai-server: image: nvcr.io/nvidia/l4t-pytorch:r35.4.1-pth2.1-py3 # 或使用你构建的自定义镜像 container_name: my_ai_server runtime: nvidia deploy: resources: reservations: devices: - driver: nvidia count: all capabilities: [gpu] volumes: - ./src:/app/src # 挂载代码 - ./models:/app/models # 挂载模型文件 working_dir: /app command: python3 src/main.py ports: - "8080:8080" # 映射宿主机8080端口到容器8080端口 networks: - ai-net redis-cache: image: redis:7-alpine container_name: ai_redis ports: - "6379:6379" networks: - ai-net networks: ai-net: driver: bridge

然后，在项目目录下，只需一条命令即可启动所有服务：

docker-compose up -d

使用docker-compose logs -f ai-server查看日志，docker-compose down停止并清理所有服务。

6.3 性能调优与资源限制

在Jetson这样的边缘设备上，资源是宝贵的。你需要对容器资源使用有所控制。

# 限制容器使用的CPU核心数（例如，限制使用2个CPU核心） docker run -it --cpus="2.0" ... # 限制容器使用的内存（例如，限制使用4GB内存） docker run -it -m 4g ... # 限制容器使用的GPU内存（需要通过环境变量，并非所有场景都支持） # 更常见的做法是限制可用的GPU设备编号 docker run -it --gpus '"device=0"' ... # 仅使用第一块GPU（对Orin来说就是唯一的那块）

对于Jetson Orin，尤其需要注意散热和功耗。长时间高负载运行容器时，可以通过Jetson的jetson_clocks工具或NVIDIA的Power Management工具来监控和调整设备状态，但这通常需要在宿主机层面操作。

7. 常见问题排查与实战经验

即便按照指南操作，在实际中仍可能遇到各种问题。这里汇总了一些典型问题及其解决方案。

7.1 容器启动与GPU访问故障

问题1：运行容器时提示docker: Error response from daemon: could not select device driver...

• 原因：NVIDIA Container Toolkit未正确安装或配置。
• 排查：
  1. 确认已安装nvidia-container-toolkit：dpkg -l | grep nvidia-container-toolkit。
  2. 确认Docker已配置NVIDIA运行时：检查/etc/docker/daemon.json文件，应包含"default-runtime": "nvidia"或"runtimes"部分有nvidia配置。
  3. 重启Docker服务：sudo systemctl restart docker。

问题2：容器内运行nvidia-smi或import torch时报错，找不到GPU/CUDA。

• 原因：运行容器时未添加--gpus参数或NVIDIA运行时参数。
• 排查：
  1. 确保运行命令包含--runtime=nvidia --gpus all。
  2. 在容器内检查/dev目录下是否有nvidia*设备文件：ls /dev | grep nvidia。
  3. 检查容器内的CUDA版本是否与宿主机驱动兼容。使用官方镜像通常能保证兼容性。

问题3：拉取镜像速度极慢或超时。

• 原因：NGC仓库服务器在国外，网络连接不稳定。
• 解决：
  1. 使用代理：为Docker Daemon配置HTTP/HTTPS代理（需修改/etc/systemd/system/docker.service.d/proxy.conf并重启服务）。这是最有效的方法。
  2. 使用镜像加速器：虽然国内对NGC的直接镜像加速器较少，但可以尝试配置Docker Hub的国内镜像加速器，有时对层拉取有改善。修改/etc/docker/daemon.json，添加"registry-mirrors"字段。

7.2 存储与权限相关问题

问题4：在容器内创建的文件，在宿主机上归属root用户，无法直接编辑。

• 原因：Docker容器默认以root用户运行，创建的文件属主自然是root。
• 解决：
  1. （推荐）在运行时指定用户：docker run -u $(id -u):$(id -g) ...。这会以当前宿主机用户的UID和GID运行容器，创建的文件权限就正确了。但前提是容器内存在对应的UID/GID（通常基础镜像都有）。
  2. 修改宿主机文件权限：每次容器运行后，手动sudo chown更改属主。
  3. 在Dockerfile中创建同名用户：在构建镜像时，创建一个与宿主机开发用户同UID/GID的用户，并以此用户运行CMD。

问题5：容器内进程占用的磁盘空间越来越大。

• 原因：应用程序在容器内产生了日志、缓存或临时文件。
• 解决：
  1. 使用-v挂载卷，将日志等目录映射到宿主机，方便管理和清理。
  2. 定期清理停止的容器和悬空镜像：docker system prune。
  3. 在Dockerfile的RUN指令中，及时清理apt或pip的缓存（如&& rm -rf /var/lib/apt/lists/*）。

7.3 网络与设备访问问题

问题6：容器内的应用无法访问宿主机上的摄像头（如/dev/video0）。

• 原因：设备未挂载到容器中。
• 解决：使用--device参数将设备文件挂载进去。

  docker run -it --rm --runtime=nvidia --gpus all \ --device /dev/video0:/dev/video0 \ ... nvcr.io/... /bin/bash

  对于需要访问多个视频设备或V4L2设备的情况，可以挂载整个/dev目录（不推荐，有安全风险）或使用--privileged模式（更不推荐，除非万不得已）。

问题7：容器无法连接到宿主机的某个服务（如数据库）。

• 原因：容器的网络命名空间是隔离的。使用--network host时，容器使用宿主机网络，localhost或127.0.0.1即指向宿主机。使用默认的桥接网络时，宿主机对容器而言是网关地址（如172.17.0.1）。
• 解决：
  • 如果服务在宿主机上，使用--network host模式，并在容器内用localhost连接。
  • 如果服务在另一个容器中，使用Docker Compose或自定义桥接网络，通过服务名连接。

7.4 镜像构建失败问题

问题8：构建镜像时，pip install因编译某个包失败而报错。

• 原因：Jetson是ARM架构，某些Python包的预编译轮子（wheel）不提供ARM64版本，需要从源码编译，可能缺少必要的系统库。
• 解决：
  1. 在Dockerfile的RUN apt-get install阶段，提前安装编译工具和该Python包可能依赖的系统库，例如build-essential,cmake,libopenblas-dev等。
  2. 尽可能在requirements.txt中指定不需要编译的、有ARM64轮子的版本，或者寻找替代包。
  3. 考虑使用NVIDIA官方镜像中已预装的版本，避免自己编译。

问题9：构建镜像时层缓存失效，每次都要从头安装。

• 原因：Dockerfile中某条指令之前的内容发生了改变，导致其后续所有层的缓存失效。
• 优化：将最不常变化的指令放在前面（如安装系统包），将最常变化的指令（如复制源代码）放在最后。这就是为什么要把COPY requirements.txt和RUN pip install放在COPY . .之前的原因。

掌握这些排查技巧，你就能从容应对Jetson容器化开发中的大多数挑战。记住，容器化是一个实践性极强的技能，多动手、多踩坑、多总结，你就能越来越熟练地驾驭这套强大的工具，让Jetson AGX Orin 64GB的强大算力在标准、高效、可复现的软件环境中得到充分发挥。从快速启动一个预置环境，到构建并部署一个完整的自定义AI应用镜像，这条路径已经清晰可见。剩下的，就是开始你的项目，将想法在边缘变为现实。