Docker入门与实战——实战案例（编程开发）（一）

实战案例（编程开发）

- 1、C/C++
- 2、Java
- - 2.1、使用官方镜像
  - [2.2、Spring Boot](#2.2、Spring Boot)
  - 2.3、相关资源
- 3、Python
- - 3.1、使用官方镜像
  - 3.2、使用PyPy
  - 3.3、使用Django
  - - 3.3.1、使用Django镜像
    - 3.3.2、使用Compose搭建Django应用
    - [3.3.3、使用Docker Hub镜像](#3.3.3、使用Docker Hub镜像)
    - 3.3.4、自定义uWSGI+Nginx+Django镜像
  - 3.4、使用Flask
  - - [3.4.1、使用Docker Hub镜像](#3.4.1、使用Docker Hub镜像)
    - 3.4.2、使用Compose构建Flask+MongoDB服务
  - 3.5、使用Sentry
  - 3.6、相关资源
- 4、JavaScript

1、C/C++

C是一门古老的语言，在今天仍然是系统领域和高性能计算的主要选择，它在1969年由贝尔实验室设计开发。C语言具有高效、灵活、功能丰富、表达力强和较高的可移植性等特点。C++在C的基础上，支持了数据的抽象与封装、面向对象和泛型编程。功能与性能的平衡使C++成为目前应用最广泛的系统编程语言之一。

1.1、GCC

GCC（GNU Compiler Collection，GNU编译器套装）是一套由GNU开发的编程语言编译器，是一套根据GPL及LGPL许可证发行的自由软件，也是GNU计划的关键部分。GCC（特别是其中的C语言编译器）通常被认为是跨平台编译器的事实标准。

GCC可处理C/C++、Fortran、Pascal、Objective-C、Java、Ada等多种语言。

1.1.1、使用官方镜像

将C/C++代码运行在容器内的最简方法，就是将编译指令写入Dockerfile中，然后使用此Dockerfile构建自定义镜像，最后直接运行此镜像，即可启动程序。

如果对GCC版本有要求，则可以在以上命令中加入镜像标签，并在下一步Dockerfile的FROM指令中明确GCC版本号。

然后，在Dockerfile中，加入需要执行的GCC编译命令：

bash 复制代码

FROM gcc:4.9
COPY . usr/src/myapp
WORKDIR /usr/src/myapp
RUN gcc -o myapp main.c
CMD ["./myapp"]

编辑main.c，内容如下：

c 复制代码

#include<stdio.h>

int main()
{
	printf("Hello World\n");
	return 0;
}

现在，就可以使用Dockerfile来构建镜像my-gcc-app：

bash 复制代码

docker build -t gcc-image .

用户可以使用docker images命令查看生成的镜像：

bash 复制代码

$ docker images
                                                                               i Info →   U  In Use
IMAGE                   ID             DISK USAGE   CONTENT SIZE   EXTRA
gcc-image:latest        0ff8c88cbf54       1.37GB             0B

创建并运行此容器，会编译并运行程序，输出Hello World语句：

bash 复制代码

$ docker run -it --rm --name gcc-container gcc-image
Hello World

如果只需要容器编译程序，而不需要运行它，则可以使用如下命令：

bash 复制代码

docker run --rm -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp gcc gcc -o myapp

1.1.2、定制镜像

下面，笔者给出了基于buildpack-deps:wheezy镜像创建GCC镜像的Dockerfile供读者参考：

1.2、LLVM

LLVM（Low Level Virtual Machine，底层虚拟机）是美国伊利诺伊大学的一个研究项目，试图提供一个现代化的，基于SSA的编译策略，同时支持静态和动态编程语言。和之前为大家所熟知的JVM以及.net Runtime这样的虚拟机不同，这个虚拟系统提供了一套中立的中间代码和编译基础设施，并围绕这些设施提供了一套全新的编译策略（使得优化能够在编译、连接、运行环境执行过程中，以及安装之后以有效的方式进行）和其他一些非常有意思的功能。

LLVM包括若干重要的子项目，其中Clang将在后面讲解。

1.2.1、使用官方镜像

Docker Hub中已经有用户提供了LLVM镜像，读者可以直接下载使用，不再赘述：

1.2.2、定制镜像

读者可以基于前面提到的SSHD基础镜像来定制GCC镜像，构建后直接运行。也可以使用Docker Hub中提供的第三方Dockerfile，定制或修改后构建镜像，然后运行容器即可。

1.3、Clang

Clang是一个由Apple公司用C++实现、基于LLVM的C/C++/Objective-C/Objective-C++编译器，其目标就是超越GCC成为标准的C/C++编译器，它遵循LLVM BSD许可。Clang很好地兼容了GCC。

Clang的特性包括以下几点。

快：在OSX上的测试中，Clang比GCC 4.0快2.5倍。
内存占用小：Clang内存占用一般比GCC要小得多。
诊断信息可读性强：Clang对于错误的语法不但有源码提示，还会在错误的调用和相关上下文上有更好的提示。
基于库的模块化设计：Clang将编译过程分成彼此分离的几个阶段，将大大增强了IDE对于代码的操控能力。

1.3.1、使用官方镜像

在Docker Hub中已经有用户提供了Clang的镜像，读者可以直接下载使用：

读者可以通过Docker Hub的镜像详情查看实际安装指令，确认是否符合需求，如下所示：

1.3.2、定制镜像

如前文所说，读者可以基于SSHD镜像自定义Dockerfile，也可以使用Docker Hub中的第三方镜像构建Clang容器。

这里以ubuntu:bionic系统为例，给出了示例Dockerfile文件：

1.3.3、相关资源

GCC官网：https://gcc.gnu.org/。
GCC官方镜像：https://hub.docker.com/_/gcc/。
GCC官方镜像仓库：https://github.com/docker-library/gcc。
LLVM官网：http://llvm.org/。

2、Java

Java是广受欢迎的编程语言和开发平台，有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今，Java仍是企业和开发人员的首选开发平台，全球有数百万开发人员运行超过60亿台Java虚拟机。Java是一种跨平台、面向对象、泛型编程的编译型语言，广泛应用于企业级应用开发和移动应用开发领域，由SUN公司在1995年推出。Java是基于类的面向对象的高级语言，其设计理念是尽可能减少部署依赖，致力于允许Java应用的开发者"开发一次，到处运行"。这就意味着Java的二进制编码不需要再次编译，即可运行在异构的JVM上。Java在大型互联网项目，特别是互联网金融和电子商务项目中非常受欢迎。OpenJDK(Open Java Development Kit)是免费开源的Java平台，支持Java SE(Standard Edition)。从Java7开始，OpenJDK就是官方的Java SE环境。

2.1、使用官方镜像

在容器中运行Java代码最简单的方法就是将Java编译指令直接写入Dockerfile。然后使用此Dockerfile构建并运行此镜像，即可启动程序。

首先，从官方仓库获取某版本Java基础镜像：

bash 复制代码

docker pull eclipse-temurin:8-jdk

然后，在本地新建一个空目录，在其中创建Dockerfile文件。在Dockerfile中，加入需要执行的Java编译命令，例如：

bash 复制代码

FROM eclipse-temurin:8-jdk
COPY . /usr/src/javaapp
WORKDIR /usr/src/javaapp
RUN javac HelloWorld.java
CMD ["java", "HelloWorld"]

java 复制代码

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

如果希望使用最新的Java 10，则可以修改基础镜像为FROM eclipse-temurin:10-jdk。下面继续使用此Dockerfile构建镜像java-image：

bash 复制代码

docker build -t java-image .

用户可以通过docker images命令查看生成的镜像：

bash 复制代码

$ docker images
                                                                             i Info →   U  In Use
IMAGE                   ID             DISK USAGE   CONTENT SIZE   EXTRA
eclipse-temurin:8-jdk   1f884d67c72d        314MB             0B

然后，运行此镜像即自动编译程序并执行：

bash 复制代码

$ docker run -it --rm --name java-container java-image
Hello World!

如果只需要在容器中编译Java程序，而不需要运行，则可以使用如下命令：

bash 复制代码

docker run --rm -v "$(pwd)":/usr/src/javaapp -w /usr/src/javaapp eclipse-temurin:8-jdk javac HelloWorld.java

以上命令会将当前目录("$(pwd)")挂载为容器的工作目录，并执行javac HelloWorld.java命令编译HelloWorld.java代码，然后生成HelloWorld.class类文件至当前目录下：

bash 复制代码

$ ls
Dockerfile       HelloWorld.class HelloWorld.java

2.2、Spring Boot

Spring Boot是由Pivotal团队开发的框架，其设计目的是简化新Spring应用的初始搭建以及开发过程。SpringBoot致力于在蓬勃发展的快速应用开发领域成为领导者，旨在简化创建产品级的Spring应用和服务。Spring Boot是一个基于Spring框架的快速开发的框架，可以用来创建独立、可运行的、生产级别的Spring应用程序。使用Spring Boot可以大大简化Spring应用程序的开发过程，通过自动配置Spring和第三方库，减少了大量烦琐的配置，从而让开发人员更加专注于业务代码的编写。

下图显示了Spring Boot在Spring生态中的位置。

Spring Boot的特性包括：

创建独立的Spring应用。
内嵌Tomcat、Jetty或Undertow（无须部署WAR文件）。
提供starter POM，简化Maven配置。
尽可能地实现Spring项目配置自动化。
提供工业级特性，如Metrics、健康检查等。
不生成代码，不需要XML配置。

使用compose搭建Spring Boot应用

下面介绍如何使用compose搭建Spring Boot应用，环境要求是JDK 1.8或以上版本，Maven 3.0或以上版本。

下面创建一个Spring Boot应用。

第一步，先下载并解压Spring Boot应用模板代码：

然后，编辑代码文件'src/main/java/hello/Application.java'，内容如下：

@SpringBootApplication和@RestController表示Java类Application已经准备好被Spring MVC调用，并提供HTTP服务。注解@RequestMapping("/")表示context path"/"的请求路由到方法home中进行处理，main方法中的 SpringApplication.run()用来启动一个Spring Boot应用。
第二步，容器化spring boot应用。首先，新建src/main/docker/Dockerfile，内容如下：

然后，使用docker-maven-plugin构建镜像，pom.xml文件内容如下：

此处镜像的名称为registry.aliyuncs.com/linhuatest/gs-spring-boot-docker，其中registry.aliyuncs.com是阿里云镜像仓库的域名，linhuatest是用户的命名空间，gs-spring-boot-docker是用户某个仓库的名称，此处没有镜像tag，默认为latest；Dockerfile文件所在的目录可以理解为Dockerfile的context，用于保存Dockerfile依赖的资源；要将资源复制到Dockerfile文件所在的目录（即context）中，用户只需要编译出jar文件。

最后，用户可以构建和推送镜像到任何一个镜像仓库，如下所示：

2.3、相关资源

Java官方镜像：https://registry.hub.docker.com/_/java/。
Java官方镜像标签：https://registry.hub.docker.com/_/java/tags/manage/。
Spring Boot官网：http://projects.spring.io/spring-boot/。

3、Python

Python是一种解释型动态语言，是功能强大的面向对象语言，集成了模块(module)、异常处理(exception)、动态类型(dynamic typing)、高级数据结构（元组、列表、序列）、类(class)等高级特性。Python设计精良，语法简约，表达能力很强。目前，所有主流操作系统（Windows、Linux、类UNIX系统）都支持Python。

3.1、使用官方镜像

首先，推荐用户使用Docker官方提供的Python镜像作为基础镜像。

第一步，新建项目目录py-official，进入此目录，然后使用docker pull命令拉取官方镜像：

bash 复制代码

docker pull python

接下来，在项目中新建一个Dockerfile文件，内容如下：

bash 复制代码

FROM python
COPY . /usr/src/py
WORKDIR /usr/src/py
CMD ["python", "./sample.py"]

新建sample.py文件，计算Fibonacci数列：

python 复制代码

def fib(n):
	a, b = 0, 1
	while a < n:
		print(a, end=' ')
		a, b = b, a + b
	print()
fib(1000)

新建requirements.txt依赖文件，读者可以在此文件中加入项目依赖程序，如Django等。此处仅新建空文件：

bash 复制代码

touch requirements.txt

第二步，使用docker build命令构建名为py3-image的镜像：

bash 复制代码

docker build -t py3-image .

可见至此用户已经成功构建了镜像，可以通过dockerimages命令进行查看：

bash 复制代码

$ docker images
                                                                             i Info →   U  In Use
IMAGE                   ID             DISK USAGE   CONTENT SIZE   EXTRA
py3-image:latest        111c004ee5b2       1.12GB             0B

第三步，通过docker $container$ run命令创建并运行容器：

bash 复制代码

$ docker run -it --rm --name py3-container py3-image
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

如果只需要运行单个Python脚本，那么无须使用Dockerfile构建自定义镜像，而是通过以下命令直接使用官方Python镜像，带参数运行容器：

bash 复制代码

docker run -it --rm --name my-running-script -v "$(pwd)":/usr/src/myapp -w /usr/src/myapp python:3 python your-daemon-or-script.py

如果读者希望深入了解Python的官方镜像，包括镜像的原始Dockerfile、ONBUILD指令的具体执行内容等，则可以参考GitHub上的docker-library/official-images仓库。

3.2、使用PyPy

PyPy是一个Python实现的Python解释器和即时编译(JIT)工具，它专注于速度、效率，和CPython的完全兼容性。通过JIT技术，PyPy可以使Python的运行速度提高近十倍，同时保证兼容性。

使用官方镜像

首先，设置项目目录，并新建hi.py实例程序：

然后，在根目录新建Dockerfile，其内容基于pypy3的onbuild版本镜像：

如果用户需要使用pypy2，则可以使用FROM pypy:2-onbuild。

onbuild版本的镜像内含若干onbuild触发器，它们可以在镜像构建期间完成一些必要的初始化操作，便于项目直接运行。pypy的onbuild镜像会复制一个requirements.txt依赖文件，运行RUN pip install安装依赖程序，然后将当前目录复制到/usr/src/app。

下面，用户开始构建和运行此镜像：

如果用户只需要运行单个pypy脚本，并希望避免新建Dockerfile，那么可以直接使用如下指令：

如果需要使用pypy2运行，则可以使用如下指令：

3.3、使用Django

Django是一个开放源代码的Web应用框架，是基于Python实现的流行的Web框架之一，于2005年7月在BSD许可证下发布。Django采用了MVC（模型、视图、控制器）的经典软件设计模式，主要目标是使得开发复杂的、数据库驱动的网站变得简单。Django注重组件的重用性和可插拔性，以及敏捷开发和DRY(Don't Repeat Yourself)法则。

相比Tornado、Flask、Web.py等框架，Django要"重"一些，但它自带了很多工具包，包括认证系统、站点管理系统、评论系统等，便于进行中小型站点的快速开发。

3.3.1、使用Django镜像

在本地可通过pip安装Django，十分简单：

下面创建一个容器镜像。

第一步，新建项目目录django-official，新建一个名为dockerdjango的Django项目：

新建Dockerfile文件，内容如下：

使用onbuild标签意味着在执行docker build命令的过程中，docker engine会执行ONBUILD命令中的操作。具体的ONBUILD命令可以在GitHub上的docker-library仓库中看到，即：
第二步，新建requirements.txt文件，内容为Django：
第三步，使用docker build命令构建此Django镜像：

可见Django镜像构建成功，并生成相应的镜像。下面，用户可以使用docker $container$ run命令运行此镜像，并得到相应的容器ID：

使用docker ps命令可见Django容器已暴露8000端口，但是没有绑定访问端口：

再次使用docker ps命令可见Django容器不仅暴露8000端口，还映射到了本地端口32768：
第四步，通过浏览器访问主机的32768端口来访问此Django服务，如图所示。

还可以通过docker logs django-container命令查看日志。还可以使用docker $container$ run的entrypoint进入容器，执行更多操作：

3.3.2、使用Compose搭建Django应用

Compose是一个定义和运行服务（多容器应用）的官方工具。用户可以通过一个Compose配置文件定义服务，然后使用up命令创建并启动服务。关于Compose的详细讲解，可参阅本书第四部分相关章节。

首先安装docker-compose：

下面用户使用Docker Compose来配置和运行一个简单的Django/PostgreSQL应用。

第一步，用户需要创建一个Dockerfile，一个Python依赖文件，还有一个docker-compose.yml文件。

新建一个项目文件夹，例如命名为djangocompose，并在其根目录新建一个Dockerfile文件，文件内容如下：

在项目文件夹的根目录新建一个requirements.txt文件，文件内容如下：

注意psycopg2是Python与PostgreSQL的数据库连接池。

最后，在项目文件夹的根目录新建一个docker-compose.yml文件，内容如下：
第二步，新建一个Django项目，在其中用docker-compose命令新建一个Django项目：
第三步，配置Django的数据库连接。

进入项目文件夹，编辑djangocompose/settings.py文件。设置DATABASES=...字段：

运行docker-compose up命令：

此时用户的Django应用已经开始运行了，访问容器的8000端口，即可看到运行效果，如图所示。

下面用户可以登录容器查看此Django应用的运行状态。

首先使用docker ps查看当前主机运行的容器：

可见Web服务的容器ID是eb078d59a780，用户可以使用docker exec命令登录到容器的bash环境中：

3.3.3、使用Docker Hub镜像

Django+uWSGI+Nginx的技术组合拥有优异的性能，也是常用的Django Web技术栈。下面用户使用Docker Hub上的dockerfiles/django-uwsgi-nginx镜像构建Django应用。

首先，使用docker pull命令获取镜像：

然后，使用build命令构建名为django-uwsgi-nginx-image的Django镜像：

用户可以使用docker images查看镜像信息：

然后，构建并运行django-uwsgi-nginx-image镜像：

这里的-d参数表示后台运行容器，并打印出容器ID。用户可以使用docker ps-a查看所有容器：

3.3.4、自定义uWSGI+Nginx+Django镜像

用户也可以通过本地编译自定义uWSGI+Nginx+Django镜像。

首先，新建Dockerfile文件，内容如下：

然后，在Dockerfile同级目录下新建app文件夹，内含requirements.txt文件，文件内容如下：

然后，新建Nginx配置文件django.conf，内容如下：

新建run.sh文件，内容如下：

新建supervisord.conf文件，内容如下：

新建uwsgi.ini文件，内容如下：

新建uwsgi_params文件，内容如下：

下面，用户可以使用docker create构建镜像，使用dockerpush将镜像提交至仓库，然后用户可以登录到生产环境，使用docker pull从仓库拉取此镜像，最后运行此镜像：

目前容器内的默认卷地址是/opt/django/app，读者可以挂载特定的应用卷，例如：

至此，用户可以成功地在Nginx+uWSGI环境下运行Django应用了。

3.4、使用Flask

Flask是一个使用Python编写的轻量级Web应用框架，该框架基于Werkzeug WSGI工具箱和Jinja2模板引擎。Flask使用BSD授权，也被称为microframework，因为它仅仅使用简单的核心，使用extension来增加其他功能。

Flask的特色：

内置开发用服务器和debugger。
支持集成单元测试(unit testing)。
支持RESTful请求调度。
支持使用Jinja2模板引擎。
支持Secure Cookies（客户端sEssion）。
与WSGI 1.0 100%兼容。
基于Unicode。
有详细的文件、教学手册。
与Google App Engine兼容。
可用Extensions增加其他功能。

Flask是目前广受欢迎的常用Python Web方案之一。

3.4.1、使用Docker Hub镜像

第一步，项目准备工作。构建Flask App目录：

run.py内容如下：

__init.py_内容如下：
第二步，获取Docker Hub的Flask镜像：
第三步，创建并运行Flask容器（Flask的App代码作为Docker数据卷）：

3.4.2、使用Compose构建Flask+MongoDB服务

MongoDB是一个基于分布式文件存储的数据库，旨在为Web应用提供可扩展的高性能数据存储解决方案。MongoDB是介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。将Flask与MongoDB结合使用，是一种简单高效的Web服务架构，可以以较高的性能支撑图片服务等各种常见Web服务。

第一步，新建mongo-flask项目文件夹，并新建Flask框架的核心文件app.py，内容如下：
第二步，新建templates文件夹，放置Flask框架的前端模板文件index.html，内容如下：
第三步，回到项目根目录，新建requirements.txt文件，内容如下：
第四步，新建Dockerfile文件，内容如下：
第五步，新建docker-compose.yml文件，内容如下：

3.5、使用Sentry

Sentry是一个实时的事件日志和聚合平台，基于Django构建。Sentry可以将Python程序的所有异常自动记录下来，然后在一个好用的UI上呈现和搜索。处理异常是每个程序的必要部分，所以Sentry是Python后端系统常用的组件。

使用Docker Hub镜像

为了使用Sentry服务，用户需要按照以下步骤操作：

1)启动一个功能完整的Sentry实例；
2)配置初始化用户；
3)配置环境变量。

启动一个功能完整的Sentry实例的步骤如下。

首先，启动一个Redis容器：

之后，启动一个Postgres容器：

最后，生成一个新的密钥，供所有Sentry容器使用。SENTRY_SECRET_KEY环境变量即此密钥：

如果用户需要升级，可以使用以下命令：

现在用户可以启动Sentry服务：

默认配置需要一个Celery Beat（任务调度器）和CeleryWorker（执行具体任务的工作进程），用户可以按需启动相应数量的Worker（工作进程）（每个Worker独占名称）。

启动Celery Beat和Celery Worker：

此时用户可以通过docker ps命令查看当前运行的容器：

用户可以使用标准的容器端口映射，在运行docker $container$ run命令时添加-p 8080:9000参数，然后打开浏览器输入http://localhost:8080或http://host-ip:8080，即可访问Sentry服务。

关于用Sentry配置初始化用户以及环境变量，可以参考Sentry官方镜像文档。

3.6、相关资源

Python官网：https://www.python.org/。
Python Dockerfile：https://github.com/docker-library/python/。
Python官方镜像：https://registry.hub.docker.com/_/python/。
PyPy官网：http://pypy.org/。
Django官网：https://www.djangoproject.com/。
Flask官网：http://flask.pocoo.org/。
uwsgi官方仓库：https://github.com/unbit/uwsgi。
Sentry官网：https://getsentry.com/welcome/。

4、JavaScript

JavaScript(JS)是主流浏览器上支持的脚本语言，这也是早期JavaScript的唯一用途。Node.js自2009年发布，使用Google Chrome浏览器的V8引擎。Node.js的出现，让服务端应用也可以基于JavaScript进行编写。它采用事件驱动，性能优异，同时还提供了很多系统级API，如文件操作、Socket、HTTP网络编程等，支持主流操作系统。Node.js应用通过非驻塞IO和异步事件将系统吞吐能力和效率最大化。

4.1、使用Node.js

Node.js是基于Chrome V8引擎的JavaScript运行时环境，可用于构建服务端应用程序。Node.js具有以下优点。

高性能：Node.js采用事件驱动、非阻塞I/O模型，能够处理大量并发连接，提高Web应用程序的响应速度和吞吐量。
跨平台：Node.js可在Windows、Linux、macOS等多个操作系统上运行，具有很好的跨平台兼容性。
易于学习和使用：Node.js的API简单易用，语法与前端JavaScript类似，容易上手学习。
强大的社区支持：Node.js拥有庞大的社区，有很多优秀的第三方模块和工具可供使用，且社区活跃度高。
可扩展性强：Node.js的模块化开发方式和NPM包管理工具，使得应用程序的开发和维护更加容易，可扩展性强。
同构渲染：Node.js可用于实现前后端同构渲染，提高Web应用程序的性能和SEO效果。
适用于实时通信：Node.js的Socket.IO库可用于构建实时通信应用程序，如聊天室、游戏等。

4.1.1、使用官方镜像

可以通过docker run命令直接使用官方镜像：

bash 复制代码

docker run -it node:latest bash
root@7bfbcc718209:/# node --version
v26.11.1

Node.js拥有3种官方镜像：node:<version>、node:<version>-alpine、node:<version>-slim。其中常用的是带有版本标签的，以及带有onbuild标签的Node镜像。

首先，在Node.js项目中新建一个Dockerfile：

bash 复制代码

FROM node
COPY . /usr/src/node
WORKDIR /usr/src/node
EXPOSE 8888

然后，新建server.js文件，内容如下：

js 复制代码

'use strict';

var connect = require('connect');
var serveStatic = require('serve-static');

var app = connect();
app.user('/', serveStatic('.', {'index':['index.html']}));
app.listen(8080);

console.log('MyApp is ready at http://localhost:8080');

之后，通过npm init命令来新建Node项目必需的package.json文件：