如何将现有应用程序容器化到Docker中

Docker 容器化
Docker
文章字数:   2k
阅读时长:   7 分

“嘿，还在为“在我电脑上明明是好的”这种问题头疼吗？” 别担心，今天咱们就来聊聊如何用 Docker 这个神器，把咱们现有的应用程序打包成一个“集装箱”，让它在任何地方都能愉快地运行起来。

什么是容器化？为什么要用 Docker？

简单来说，容器化就像是把你应用程序和它所需要的所有“零件”（比如代码、依赖库、配置文件等）一起打包到一个独立的、标准化的“箱子”里。这个“箱子”就是容器。

Docker 就是目前最流行的容器化平台，它能帮你轻松创建、管理和部署这些“箱子”。好处多多：

  • 环境一致性：彻底告别“在我机器上可以运行”的魔咒。
  • 快速迭代：容器的启动和停止速度飞快，能大大缩短开发和测试的周期。
  • 轻松扩展：可以轻松地进行水平扩展，以应对不断增长的访问量。
  • 资源隔离：每个容器都是一个独立的环境，避免了不同应用之间的依赖冲突。

实战开始：三步将你的应用装进 Docker

整个过程就像把大象装进冰箱，只需要三步：

  1. **编写 “装箱说明书” (Dockerfile)**：告诉 Docker 如何打包你的应用。
  2. **执行打包 (构建镜像)**：根据说明书，生成一个只读的应用“模板”，也就是镜像 (Image)。
  3. **运行“集装箱” (运行容器)**：基于这个“模板”，创建一个或多个可以运行的实例，也就是容器 (Container)。

听起来很简单？我们马上用一个实际的例子来感受一下。

案例一：容器化一个 Node.js (Express) Web 应用

假设我们有一个简单的 Express 应用，代码如下：

app.js

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello from Dockerized Node.js!');
});

app.listen(port, () => {
  console.log(`App listening at http://localhost:${port}`);
});

package.json

{
  "name": "docker-node-app",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

第 1 步：编写 Dockerfile

在项目根目录下创建一个名为 Dockerfile (没有后缀名) 的文件，填入以下内容：

# 1. 选择一个官方的 Node.js 镜像作为基础
FROM node:16

# 2. 在容器内创建一个工作目录
WORKDIR /usr/src/app

# 3. 将 package.json 和 package-lock.json (如果有的话) 复制到工作目录
COPY package*.json ./

# 4. 安装应用依赖
RUN npm install

# 5. 将你的应用代码复制到工作目录
COPY . .

# 6. 告诉 Docker 容器在运行时会监听哪个端口
EXPOSE 3000

# 7. 定义容器启动时要执行的命令
CMD [ "node", "app.js" ]

解析：

  • FROM node:16：我们的应用需要 Node.js 环境，所以我们选择一个官方的 Node.js 16 版本作为基础。
  • WORKDIR /usr/src/app：在容器里创建一个 /usr/src/app 目录，并把它设置为之后所有操作的默认目录。
  • COPY package*.json ./ 和 RUN npm install：先只复制 package.json 文件并安装依赖。这样做可以利用 Docker 的缓存机制。只要 package.json 没有变化，npm install 这一步就不会重新执行，从而加快后续的构建速度。
  • COPY . .：将当前目录下的所有文件复制到容器的工作目录中。
  • EXPOSE 3000：声明容器将会监听 3000 端口。这主要起到一个文档的作用，并不会真的把端口暴露给主机。
  • CMD [ "node", "app.js" ]：指定容器启动后默认执行的命令。

第 2 步：构建 Docker 镜像

在终端里，进入到你的项目根目录 (也就是 Dockerfile 所在的目录)，然后运行下面的命令：

docker build -t my-node-app .

解析：

  • docker build：构建镜像的命令。
  • -t my-node-app：-t (tag) 参数给你的镜像起一个名字，这里我们叫它 my-node-app。
  • .：最后一个点表示 Dockerfile 所在的路径是当前目录。

第 3 步：运行 Docker 容器

现在，我们用刚刚构建好的镜像来启动一个容器：

docker run -p 4000:3000 -d my-node-app

解析：

  • docker run：运行容器的命令。
  • -p 4000:3000：-p (publish) 参数用来做端口映射，把主机的 4000 端口映射到容器的 3000 端口。这样我们就可以通过访问主机的 4000 端口来访问容器里的应用了。
  • -d：(detach) 参数表示在后台运行容器。
  • my-node-app：指定要运行的镜像名称。

现在打开你的浏览器，访问 http://localhost:4000，你应该能看到 “Hello from Dockerized Node.js!” 的信息了！

案例二：容器化一个 Python (Flask) Web 应用

假设你有一个简单的 Flask 应用：

app.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello from Dockerized Flask!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

requirements.txt

Flask==2.0.1

第 1 步：编写 Dockerfile

# 使用官方 Python 镜像
FROM python:3.10-slim

# 设置工作目录
WORKDIR /app

# 复制依赖文件并安装
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 5000

# 运行应用
CMD ["python", "app.py"]

这个 Dockerfile 的结构和 Node.js 的例子非常相似，只是基础镜像和安装依赖的命令不同。

第 2 步：构建镜像

docker build -t my-flask-app .

第 3 步：运行容器

docker run -p 5000:5000 -d my-flask-app

现在访问 http://localhost:5000，你就能看到 Flask 应用的欢迎页面了。

案例三：容器化一个 Java (Spring Boot) 应用

对于 Spring Boot 应用，通常我们会先用 Maven 或 Gradle 打包成一个 .jar 文件。

第 1 步：编写 Dockerfile

假设你的项目打包后生成的 jar 包位于 target/my-application.jar。

# 1. 选择一个包含 Java 运行环境的基础镜像
FROM openjdk:11-jre-slim

# 2. 设置工作目录
WORKDIR /app

# 3. 将打包好的 jar 文件复制到容器中
COPY target/my-application.jar app.jar

# 4. 定义容器启动时执行的命令
ENTRYPOINT ["java", "-jar", "/app.jar"]

解析：

  • FROM openjdk:11-jre-slim：选择一个精简的 Java 11 运行时环境作为基础镜像，这能让我们的镜像更小。
  • ENTRYPOINT vs CMD：ENTRYPOINT 和 CMD 类似，都是指定容器启动时执行的命令。但 ENTRYPOINT 更适合作为容器的“入口点”，不容易在 docker run 时被覆盖。

进阶：多阶段构建 (Multi-stage builds)

上面的方法需要我们先在本地打包好 jar 文件。其实我们可以让 Docker 来完成打包和运行的所有工作，这就是“多阶段构建”。这样做的好处是最终的镜像里只包含运行所需的 jar 文件和 JRE，而不包含 Maven、JDK 等构建工具，让镜像体积大大减小。

# --- 构建阶段 ---
FROM maven:3.8.3-jdk-11 AS build
WORKDIR /app
COPY . .
RUN mvn package -DskipTests

# --- 运行阶段 ---
FROM openjdk:11-jre-slim
WORKDIR /app
COPY --from=build /app/target/my-application.jar /app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

第 2 步：构建镜像

# 如果使用多阶段构建，直接在项目根目录运行
docker build -t my-spring-app .

第 3 步：运行容器

docker run -p 8080:8080 -d my-spring-app

总结与最佳实践

将现有应用容器化其实并不复杂，核心就是编写一个合适的 Dockerfile。

几个小贴士：

  • 选择正确的基础镜像：尽量选择官方、精简 (slim) 的镜像。
  • 利用缓存：将不经常变动的部分（如依赖安装）放在前面，经常变动的部分（如复制源代码）放在后面。
  • 使用 .dockerignore 文件：类似于 .gitignore，可以忽略掉不需要打包进镜像的文件（如 node_modules, .git 等），保持镜像整洁。
  • 不要以 root 用户运行：出于安全考虑，最好在 Dockerfile 中创建一个普通用户，并用该用户来运行程序。

希望这篇文章能帮你迈出容器化的第一步。现在就动手试试，把你的应用也装进 Docker 的“集装箱”里吧！

Docker 容器化
  目录