本文档将手把手教您如何操作 Ubuntu Docker 镜像和容器，并配置一个用于编译多种编程语言的开发环境。

---

第一部分：Docker 基本操作

1. 获取 Ubuntu 镜像

如果本地没有 Ubuntu 镜像，首先需要从 Docker Hub 拉取。

# 拉取最新的 Ubuntu 镜像
docker pull ubuntu:latest
​
# 拉取指定版本的 Ubuntu 镜像（例如 22.04）
docker pull ubuntu:22.04
​
# 查看本地已有的镜像
docker images

2. 运行一个交互式 Ubuntu 容器

最基本的运行方式，但容器在退出后会停止。

# -it: 交互式终端
# --name my_ubuntu_container: 为容器指定一个名字
# ubuntu:22.04: 使用的镜像
docker run -it --name my_ubuntu_container ubuntu:22.04

运行此命令后，您将直接进入容器的 Bash Shell。

3. 运行一个后台持续的容器（推荐开发模式）

使用 -d 选项让容器在后台运行，并使用 --restart=unless-stopped 使其在退出时自动重启（除非手动停止）。

# -d: 后台运行
# --restart=unless-stopped: 自动重启策略
docker run -it -d --name my_dev_env --restart=unless-stopped ubuntu:22.04

此时容器在后台运行，您需要 attached 到它。

# 进入正在后台运行的容器
docker exec -it my_dev_env /bin/bash

为什么推荐这种方式？ 因为你可以在容器内安装好所有环境，然后退出（exit），容器仍然在后台运行。下次想用时，直接 docker exec -it ... 进入，之前安装的软件和创建的文件都还在。

4. 在容器和宿主机之间复制文件

# 将宿主机当前目录下的 main.c 文件复制到容器的 /tmp 目录下
docker cp ./main.c my_dev_env:/tmp/
​
# 将容器 /tmp/output.txt 文件复制到宿主机当前目录
docker cp my_dev_env:/tmp/output.txt ./

5. 管理容器

# 查看正在运行的容器
docker ps
​
# 查看所有容器（包括已停止的）
docker ps -a
​
# 停止容器
docker stop my_dev_env
​
# 启动已停止的容器
docker start my_dev_env
​
# 删除容器（必须先停止）
docker rm my_dev_env
​
# 强制删除一个运行中的容器
docker rm -f my_dev_env

---

第二部分：容器内的基本配置与操作

当你第一次进入一个基础的 Ubuntu 容器时，它是一个“最小化”系统，很多常用工具都没有。你需要先进行基本配置。

1. 更新软件源并安装必备工具

# 1. 更新软件包列表
apt update
​
# 2. 升级已安装的包（可选，但建议）
apt upgrade -y
​
# 3. 安装最基础的工具集
# vim: 编辑器
# wget/curl: 网络下载工具
# git: 版本控制
# procps: 提供 ps, top 等命令
# lsb-release: 查看系统版本信息
apt install -y vim wget curl git procps lsb-core

2. 了解容器的一个核心概念

容器是瞬时的，其文件系统的变化只在容器存在时保留。 如果你运行 docker run 而不使用任何持久化存储（如 Docker Volume），那么当你删除容器后，其中的所有数据都会丢失。

---

第三部分：编译环境配置与使用

现在，我们开始在配置好的基础容器内，为各种语言安装编译和运行环境。

1. C 语言

环境配置： 安装 GCC 编译器。

apt update && apt install -y gcc

验证安装：

gcc --version

手把手操作示例：

1. 在容器内创建一个 C 文件。

   vim hello.c

   按 i 进入插入模式，输入以下代码：

   #include <stdio.h>
   int main() {
       printf("Hello, World from C inside Docker!\n");
       return 0;
   }

   按 ESC 键，然后输入 :wq 并按回车保存退出。

2. 编译源代码。

   gcc hello.c -o hello

   这会将 hello.c 编译成一个名为 hello 的可执行文件。

3. 运行程序。

   ./hello

   输出：Hello, World from C inside Docker!

2. C++

环境配置： 安装 G++ 编译器。

apt update && apt install -y g++

验证安装：

g++ --version

手把手操作示例：

1. 创建 C++ 文件。

   vim hello.cpp

   输入内容：

   #include <iostream>
   int main() {
       std::cout << "Hello, World from C++ inside Docker!" << std::endl;
       return 0;
   }

   保存退出。

2. 编译并运行。

   g++ hello.cpp -o hello_cpp
   ./hello_cpp

   输出：Hello, World from C++ inside Docker!

3. Python

环境配置： 基础 Ubuntu 镜像通常预装了 Python 3，但可能没有 pip。

# 检查 Python3 是否已安装
python3 --version
​
# 安装 pip 和 venv（虚拟环境工具）
apt update && apt install -y python3-pip python3-venv

手把手操作示例：

1. 创建 Python 文件。

   vim hello.py

   输入内容：

   print("Hello, World from Python inside Docker!")

   保存退出。

2. 运行程序。

   python3 hello.py

   输出：Hello, World from Python inside Docker!

使用虚拟环境（最佳实践）：

# 1. 创建虚拟环境
python3 -m venv my_venv
​
# 2. 激活虚拟环境
source my_venv/bin/activate
# 激活后，命令行提示符前会出现 (my_venv)
​
# 3. 在虚拟环境中安装包（例如安装 numpy）
pip install numpy
​
# 4. 运行你的 Python 脚本
python3 your_script.py
​
# 5. 退出虚拟环境
deactivate

4. Java

环境配置： 安装默认的 JRE 和 JDK。

apt update && apt install -y default-jre default-jdk

验证安装：

java -version
javac -version

手把手操作示例：

1. 创建 Java 文件。

   vim HelloWorld.java

   输入内容：

   public class HelloWorld {
       public static void main(String[] args) {
           System.out.println("Hello, World from Java inside Docker!");
       }
   }

   保存退出。

2. 编译并运行。

   javac HelloWorld.java   # 编译，生成 HelloWorld.class
   java HelloWorld         # 运行

   输出：Hello, World from Java inside Docker!

5. Go

环境配置： 安装 Go 语言环境。

apt update && apt install -y golang-go

验证安装：

go version

手把手操作示例：

1. 创建 Go 文件。

   vim hello.go

   输入内容：

   package main
   import "fmt"
   func main() {
       fmt.Println("Hello, World from Go inside Docker!")
   }

   保存退出。

2. 运行程序。Go 可以直接运行，也可以编译成二进制文件。

   # 方式一：直接运行
   go run hello.go
   ​
   # 方式二：编译后运行
   go build hello.go
   ./hello

   输出：Hello, World from Go inside Docker!

---

第四部分：持久化与最佳实践

1. 使用 Docker Volume 持久化你的工作

为了避免容器删除后代码丢失，你应该将工作目录挂载到宿主机。

# 1. 创建一个 Docker Volume（可选，Docker 会自动管理）
# docker volume create my_volume
​
# 2. 运行容器时，将宿主机的目录挂载到容器内
# -v $(pwd)/my_code:/app: 将当前目录下的 my_code 文件夹挂载到容器的 /app 目录
docker run -it -d --name my_dev_env \
  --restart=unless-stopped \
  -v $(pwd)/my_code:/app \
  ubuntu:22.04

现在，你在容器 /app 目录下做的所有修改（创建、编辑、删除文件），都会实时反映到宿主机的 ./my_code 目录下。即使你删除了容器，你的代码也安全地留在宿主机上。

2. 使用 Dockerfile 构建自定义开发环境镜像

每次都进入容器手动安装环境很低效。你可以创建一个 Dockerfile 来定义一个包含所有所需环境的新镜像。

1. 创建 Dockerfile 文件（无后缀名）:

   # 使用官方 Ubuntu 基础镜像
   FROM ubuntu:22.04
   ​
   # 避免安装软件时交互式提示（如时区选择）
   ENV DEBIAN_FRONTEND=noninteractive
   ​
   # 更新并安装所有需要的软件
   RUN apt update && apt upgrade -y \
       && apt install -y \
           vim \
           git \
           wget \
           curl \
           gcc \
           g++ \
           python3 \
           python3-pip \
           python3-venv \
           default-jdk \
           golang-go \
       && apt clean all \
       && rm -rf /var/lib/apt/lists/*
   ​
   # 设置工作目录
   WORKDIR /app
   ​
   # 指定默认的启动命令（这样 docker run 不会立即退出）
   CMD ["tail", "-f", "/dev/null"]

2. 构建镜像:

   # -t: 为镜像打标签，格式为 name:tag
   docker build -t my_ubuntu_dev:1.0 .

3. 使用自定义镜像运行容器:

   docker run -it -d --name my_dev_box \
     -v $(pwd)/code:/app \
     my_ubuntu_dev:1.0

   现在，你运行的容器已经自带了所有编程环境，开箱即用！

---

总结

操作	命令示例
运行临时容器	docker run -it ubuntu:22.04
运行后台容器	docker run -it -d --name my_dev --restart=unless-stopped ubuntu:22.04
进入后台容器	docker exec -it my_dev /bin/bash
复制文件到容器	docker cp ./file.txt my_dev:/path/
安装 C 环境	apt install -y gcc
安装 C++ 环境	apt install -y g++
安装 Python 环境	apt install -y python3 python3-pip
挂载工作目录	-v $(pwd)/code:/app
构建自定义镜像	docker build -t my_dev_image:1.0 .

通过这份指南，你应该可以 confidently 地在 Docker Ubuntu 容器中进行各种开发工作了。记住核心思想：使用 Volume 持久化数据，使用 Dockerfile 定义环境。