feat: update docker build pipeline

Author: daohu527

.flake8

@@ -0,0 +1,4 @@
+[flake8]
+max-line-length = 88
+extend-ignore = E203, W503
+exclude = .git,__pycache__,build,dist

.github/workflows/lint-format.yml

@@ -60,12 +60,12 @@ jobs:
         if: github.event_name == 'pull_request'
         run: |
           echo "Running apollo_lint.sh in diff mode for PR..."
-          ${{ github.workspace }}/scripts/ci/apollo_ci.sh --all --diff origin/${{ github.base_ref }}
+          ${{ github.workspace }}/scripts/ci/apollo_lint.sh --all --diff origin/${{ github.base_ref }}
         env:
           GITHUB_BASE_REF: ${{ github.base_ref }}
 
       - name: Run Lint and Format Checks (Push Full Mode)
         if: github.event_name == 'push' && github.ref == 'refs/heads/main'
         run: |
           echo "Running apollo_lint.sh in full mode for push to main branch..."
-          ${{ github.workspace }}/scripts/ci/apollo_ci.sh --all
+          ${{ github.workspace }}/scripts/ci/apollo_lint.sh --all

README.md

@@ -1,12 +1,16 @@
 # Welcome to Apollo's GitHub page!
 
-[Apollo-Lite](https://github.com/wheelos/apollo-lite) is a high-performance, flexible architecture accelerating the development, testing, and deployment of Autonomous Vehicles.
+[Apollo-Lite](https://github.com/wheelos/apollo-lite) is a high-performance,
+flexible architecture accelerating the development, testing, and deployment of
+Autonomous Vehicles.
 
 ---
-> We choose to go to the moon in this decade and do the other things,
-> not because they are easy, but because they are hard.
+
+> We choose to go to the moon in this decade and do the other things, not
+> because they are easy, but because they are hard.
 >
 > -- John F. Kennedy, 1962
+
 ---
 
 ## Table of Contents
@@ -23,8 +27,12 @@
 
 ## Introduction
 
-Apollo is packed with powerful modules and features designed for autonomous driving development. Before you take it for a spin, please ensure your environment is properly calibrated and configured by following the prerequisites and installation instructions below.
-For a deeper dive, check out Apollo's [architecture overview](http://apollo.auto/docs/architecture_overview.html) to understand its core technologies and platform design.
+Apollo is packed with powerful modules and features designed for autonomous
+driving development. Before you take it for a spin, please ensure your
+environment is properly calibrated and configured by following the prerequisites
+and installation instructions below. For a deeper dive, check out Apollo's
+[architecture overview](http://apollo.auto/docs/architecture_overview.html) to
+understand its core technologies and platform design.
 
 ---
 
@@ -45,9 +53,13 @@ For a deeper dive, check out Apollo's [architecture overview](http://apollo.auto
 ## Quick Start
 
 ### 1. Setup Host Environment
-Run the following scripts in order to prepare your host machine, which will perform the following steps sequentially:
+
+Run the following scripts in order to prepare your host machine, which will
+perform the following steps sequentially:
+
 1. Install Docker (checks if already installed, then proceeds)
-2. Install NVIDIA Container Toolkit (checks if already installed, depends on Docker)
+2. Install NVIDIA Container Toolkit (checks if already installed, depends on
+   Docker)
 3. Perform host system configurations
 
 ```bash
@@ -56,11 +68,12 @@ bash docker/setup_host/setup_host.sh
 ```
 
 ### 2. Start Docker Container
+
 Download and start the Apollo container image (only needs to be done once):
 
 ```bash
-# docker pull & start
-bash docker/scripts/dev_start.sh
+# docker pull & start testing
+bash docker/scripts/dev_start.sh -d testing
 ```
 
 Enter the running container environment in subsequent sessions with:
@@ -70,17 +83,13 @@ Enter the running container environment in subsequent sessions with:
 bash docker/scripts/dev_into.sh
 ```
 
-### 3. Build Apollo
-
-Inside the container, install build dependencies:
+Setting Environment Variables
 
 ```bash
-# update bazel & gcc
-sudo bash docker/build/installers/install_bazel.sh
-sudo bash docker/build/installers/install_gcc.sh
+source cyber/setup.bash
 ```
 
-> **Note:** Current container image does not have the latest Bazel and GCC. You need to manually install/upgrade them. Future container versions will include these by default.
+### 3. Build Apollo
 
 Build the entire Apollo project with:
 
@@ -100,16 +109,19 @@ To build a single module, use:
 
 ## Copyright and License
 
-Apollo is licensed under the [Apache License 2.0](LICENSE). Please adhere to the licensing terms when using or contributing to this project.
+Apollo is licensed under the [Apache License 2.0](LICENSE). Please adhere to the
+licensing terms when using or contributing to this project.
 
 ---
 
 ## Connect with us
 
 - ⭐ Star and Fork to support the project!
-- 💬 Join our [community discussion group](http://apollo.auto/community) to chat with developers.
+- 💬 Join our [community discussion group](http://apollo.auto/community) to chat
+  with developers.
 - 📧 For collaboration or business inquiries, contact: [email protected]
 
 ---
 
-Thank you for being part of Apollo's journey towards autonomous driving innovation!
+Thank you for being part of Apollo's journey towards autonomous driving
+innovation!

docker/build/README.md

@@ -1,152 +1,140 @@
-# Apollo Docker Image Build Process
+# Apollo Docker Image Build Guide
 
-## Introduction
+## Overview
 
-As you may already know, Apollo runs inside Docker container. There are
-basically two types of Apollo Docker images: CyberRT and Dev. CyberRT images
-were for developers who want to play with the CyberRT framework only, while Dev
-images were used to build and run the whole Apollo project.
+Apollo runs within Docker containers, with images tailored for development and
+deployment. We currently support `x86_64` and `aarch64` architectures.
 
-Currently, two CPU architectures are supported: `x86_64` and `aarch64`.
+**Image Types:**
 
-**Note**
+- **Cyber (Base/Cyber)**: Core CyberRT framework, ideal for CyberRT-focused
+  development.
+- **Dev**: Full Apollo project with development toolchain, for building and
+  running the entire Apollo stack.
+- **Runtime**: Optimized, minimal image for production deployment.
 
-> `dev.aarch64` image was still WIP as of today. It is expected to be ready in
-> the next few months.
+## Quick Start
 
-In the section below, I will describe briefly the steps to build these Docker
-images.
+Use the `./build_docker.sh` script to build images.
 
-## Build CyberRT Image
+### 1. Build CyberRT Image
 
-Type `./build_docker.sh -h` for help message:
+Builds the base development environment including CUDA/CuDNN/TensorRT and the
+CyberRT framework.
 
-```
-Usage:
-    build_docker.sh -f <Dockerfile> [Options]
-Available options:
-    -c,--clean      Use "--no-cache=true" for docker build
-    -m,--mode       "build" for build everything from source if possible, "download" for using prebuilt ones
-    -g,--geo        Enable geo-specific mirrors to speed up build. Currently "cn" and "us" are supported.
-    -d,--dist       Whether to build stable("stable") or experimental("testing") Docker images
-    -t,--timestamp  Specify Cyber image timestamp to build Dev image from it. Format: yyyymmdd_hhmm (e.g 20210205_1520)
-    --dry           Dry run (for testing purpose)
-    -h,--help       Show this message and exit
-E.g.,
-    build_docker.sh -f cyber.x86_64.dockerfile -m build -g cn
-    build_docker.sh -f dev.aarch64.dockerfile -m download -d testing
-```
+```bash
+cd docker/build
 
-Here, the `-g/--geo` option is used to enable geo-location based settings (APT &
-PYPI mirrors, etc.). Two codes (`us` & `cn`) are supported now, and the default
-is `us`.
+# Build x86_64 CyberRT image (default: download pre-built dependencies)
+./build_docker.sh -f cyber.x86_64.dockerfile
 
-To build the latest CyberRT image, simply run:
+# For users in mainland China (accelerated mirrors)
+./build_docker.sh -f cyber.x86_64.dockerfile -g cn
 
-```
-./build_docker.sh -f cyber.<TARGET_ARCH>.dockerfile
+# Build all dependencies from source (takes longer)
+./build_docker.sh -f dev.x86_64.cpu.dockerfile -m build
 ```
 
-Users of mainland China can specify `-g cn` to speed up build process:
+### 2. Build Apollo Dev Image
 
-```
-./build_docker.sh -f cyber.<TARGET_ARCH>.dockerfile -g cn
-```
-
-## Build Apollo Dev Image
+Builds the full Apollo development image, based on a CyberRT image.
 
-Run the following command to build Apollo Dev image:
+```bash
+# Build x86_64 Dev image
+./build_docker.sh -f dev.x86_64.dockerfile
 
-```
-build_docker.sh -f dev.<TARGET_ARCH>.dockerfile
+# Build aarch64 Dev image (ensure qemu-user-static is configured for cross-arch builds)
+./build_docker.sh -f dev.aarch64.dockerfile -m download
 ```
 
-On success, output messages like the following will be shown at the bottom of
-your screen.
+### 3. Build Apollo Runtime Image
 
-```
-Successfully built baca71e567e6
-Successfully tagged apolloauto/apollo:dev-x86_64-18.04-20200824_0339
-Built new image apolloauto/apollo:dev-x86_64-18.04-20200824_0339
-```
+Used for lightweight production deployments. Requires a prior Apollo Release
+Build.
 
-## Build Apollo Runtime Docker Image
-
-Apollo Runtime Docker was used in combination with Release Build output for easy
-deployment. You can run the following commands to build Apollo Runtime Docker
-image on your own.
-
-```
-# Generate required APT packages
+```bash
+# 1. Generate required APT packages from Apollo Release Build
 ./apollo.sh release -c -r
 
+# 2. Navigate to the Docker build directory and copy package list
 cd docker/build
-# Copy the generated package list for docker build
 cp /apollo/output/syspkgs.txt .
 
-cp runtime.x86_64.dockerfile.sample runtime.x86_64.dockerfile
+# 3. Build the Runtime image (x86_64 only currently)
+# cp runtime.x86_64.dockerfile.sample runtime.x86_64.dockerfile # if file doesn't exist
 bash build_docker.sh -f runtime.x86_64.dockerfile
 ```
 
-> Note: Apollo Runtime Docker supports x86_64 only as Release Build was not
-> ready for Aarch64 yet.
+---
 
-## Tips
+## Script Arguments
 
-### Build Log
+Run `./build_docker.sh --help` for full options:
 
-The build log for CyberRT and Dev Docker images was located at
-`/opt/apollo/build.log`, which contains download links and checksums of
-dependent packages during Docker build.
-
-### Enable Local HTTP Cache to Speed Up Build
+```
+Usage:
+    build_docker.sh -f <Dockerfile> [Options]
 
-You can enable local HTTP cache to speed up package downloading by performing
-the following steps on your **host** running Docker:
+Options:
+    -f, --dockerfile   Path to the Dockerfile (e.g., 'cyber.x86_64.dockerfile').
+    -c, --clean        Disable Docker build cache (--no-cache=true).
+    -m, --mode         Installation mode: 'download' (default, use pre-built), 'build' (build from source).
+    -g, --geo          Enable geo-specific mirrors ('cn' or 'us', default 'us').
+    -t, --timestamp    Timestamp of the previous stage image (YYYYMMDD_HHMM).
+    --dry              Dry run (print commands without execution).
+    -h, --help         Show help message and exit.
+```
 
-1. Download all prerequisite packages to a directory (say, `$HOME/archive`) with
-   URLs listed in the build log. Pay attention to their checksum.
-2. Change to that archive directory and start your local HTTP cache server at
-   port **8388**.
+---
 
-```
-cd $HOME/archive
-nohup python3 -m http.server 8388 &
-```
+## Advanced Tips
 
-> Note: Another advantage with the local HTTP cache mechanism is, it has little
-> influence on the final image size. Even if the cached package was missing or
-> broken, it can still be downloaded from the original URL.
+### Cross-Architecture Builds
 
-3. Rerun `build_docker.sh`.
+For cross-architecture builds (e.g., building `aarch64` on `x86_64`), ensure
+`qemu-user-static` is configured:
 
-## Add New Installer
+```bash
+docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+```
 
-The best practice of a new installer would be:
+**Recommendation:** Utilize `docker buildx` for a more robust and efficient
+multi-platform build experience.
 
-1. Well tested.
+### Optimize Build Speed
 
-   Of course. Make it work, and don't break other installers, such as
-   incompatible versions of libraries.
+- **Local HTTP Cache:** Setting up a local HTTP server to cache downloaded
+  packages can significantly speed up repeated builds without affecting final
+  image size.
 
-1. Standalone.
+  **Steps:**
 
-   Have minimum assumption about the basement, which means, you can depend on
-   the base image and `installers/installer_base.sh`. Other than that, you
-   should install all the dependencies in your own installer.
+  1.  **Download prerequisites:** Identify and download all necessary
+      prerequisite packages to a local directory (e.g., `$HOME/apollo_cache`).
+      URLs are typically listed in the build log (`/opt/apollo/build.log`). Pay
+      attention to checksums for integrity.
+  2.  **Start local HTTP server:** Navigate to your cache directory and start a
+      simple HTTP server on port **8388**:
+      ```bash
+      mkdir -p "$HOME/apollo_cache" && cd "$_"
+      nohup python3 -m http.server 8388 &
+      ```
+  3.  **Rerun build:** Execute `build_docker.sh` as usual. The Docker build
+      process will attempt to fetch packages from
+      `http://host.docker.internal:8388` (or directly from
+      `http://<your_host_ip>:8388` if `host.docker.internal` is not available),
+      greatly reducing download times.
 
-1. Thin.
+  - **Benefit:** Even if a cached package is missing or broken, the build
+    process will fall back to downloading from the original URL.
 
-   It will generate a new layer in the final image, so please keep it as thin as
-   possible. For example, clean up all intermediate files:
+- **Avoid `--no-cache` (`-c`):** Only use when strictly necessary, as it forces
+  re-downloading and re-building all layers, significantly increasing build
+  time.
 
-   ```bash
-   wget xxx.zip
-   # Unzip, make, make install
-   rm -fr xxx.zip xxx
-   ```
+### Debugging Builds
 
-1. Cross-architecture.
+Build logs are located at `/opt/apollo/build.log` inside the container,
+providing detailed information on downloads and installation steps.
 
-   It would be awesome to work perfectly for different architectures such as
-   `x86_64` and `aarch64`.
+---