与你相识


博主介绍：

– 本人是普通大学生一枚，每天钻研计算机技能，CSDN主要分享一些技术内容，因我常常去寻找资料，不经常能找到合适的，精品的，全面的内容，导致我花费了大量的时间，所以会将摸索的内容全面细致记录下来。另外，我更多关于管理，生活的思考会在简书中发布，如果你想了解我对生活有哪些反思，探索，以及对管理或为人处世经验的总结，我也欢迎你来找我。

– 目前的学习专注于Go语言，辅学算法，前端领域。也会分享一些校内课程的学习，例如数据结构，计算机组成原理等等，如果你喜欢我的风格，请关注我，我们一起成长。

Introduction

后端部署会经过这样几个步骤：

  1. 构建Dockerfile文件
  2. 通过Dockerfile文件生成镜像
  3. 通过镜像生成容器
  4. 把项目放到容器中（目录挂载），然后打包项目
  5. 在后台运行main程序
  6. 搭建nginx服务器
  7. 配置nginx服务器

在后端部署教学中，我会带着你走过这样几个步骤：

  • 为什么要构建Dockerfile文件
  • 拆解Dockerfile文件的各个部分
  • 通过Dockerfile文件生成镜像
  • 通过镜像生成容器
  • 在容器中运行程序
  • 搭建nginx服务器
  • 通过配置nginx服务器转发访问后端的请求

我会写一版简洁版本，写一版详解版本，这两个版本的核心是一样的，但是简洁版本因为是直接复制的命令，所以可能命令步骤更完善一些。

另外我是先写的详解版本，后写的简洁版本。

此外，我还写了前端部署与前后端部署，如果需要也可自取：

Table of Contents

后端部署步骤简洁版

无注释，无讲解版本，适合有一定基础，拿来就用的人

1、构建Dockerfile文件

进入到服务器中，在/root目录下创建一个文件夹，我们选择创建一个project文件夹作为我们的本次的主要路径

  • 创建project文件夹
cd /root
mkdir project
  • 在project文件夹中创建Dockerfile文件
cd /root/project
touch Dockerfile
  • 打开Dockerfile文件，写入内容
vim Dockerfile    # 打开Dockerfile文件

按[i]进入编辑模式，复制下面的内容到Dockerfile文件：

FROM centos:latest

ENV MYPATH /usr/local/project
WORKDIR  $MYPATH

RUN yum -y update \
    && yum -y install vim \
    && yum -y install git \
    && yum install -y gcc-c++ \
    && yum -y install wget \
    && wget -P /root/ https://dl.google.com/go/go1.14.1.linux-amd64.tar.gz \
    && tar -zxvf /root/go1.14.1.linux-amd64.tar.gz -C /usr/local \
    && echo export PATH=$PATH:/usr/local/go/bin >> /etc/profile \
    && source /etc/profile && go version \
    && echo "source /etc/profile" >> /root/.bashrc \
    && go env -w GOPROXY=https://goproxy.cn,direct \
    && go env -w GO111MODULE=on \

按[Esc]，然后输入wq保存退出。

2、通过Dockerfile文件生成镜像

输入命令

cd /root/project  # 进入Dockerfile文件目录
docker build -f Dockerfile -t centos_go:latest .

通过docker images命令可以查看是否已经创建了centos_go镜像

3、通过镜像生成容器

创建我们的项目文件夹

cd /root/project
mkdir smart_campus

生成容器

docker run -it -v /root/project/smart_campus/:/usr/local/project/smart_campus --name smart_campus centos_go_vue:0.1 /bin/bash

进入容器

docker exec -it smart_campus /bin/bash

4、把项目放到容器中（目录挂载），然后打包项目

使用xftp工具可以把我们的项目文件复制到/root/project/smart_campus中，找到main.go文件
使用命令打包程序

go build main.go

通过ls命令可以查看到当前目录多了一个main文件，它是一个可执行程序

5、在后台运行main程序

首先进入到第4步容器的main可执行文件地方

nohup ./main > start.log 2>&1 &

通过jobs -l命令来查看是否在后台运行成功，如果没有运行成功，可以通过cat start.log命令来查看程序启动日志，查看是否有问题。
通过在后端程序中的配置我们可以知道后端的端口，比如是8000，通过命令可以查出承载后端程序的容器的ip地址，假如是172.17.0.5。
我们就可以得出访问后端程序的地址是172.17.0.5:8000，这可以为我们nginx访问后端程序作为基础。

6、搭建nginx容器

docker images查看一下是否有nginx镜像，如果没有的话

  • 下载nginx镜像
docker pull nginx
  • 复制配置文件
docker run --name nginx-test -d nginx  # 创建一个容器
mkdir /root/project/nginx  # 在我们的project文件夹中创建一个nginx文件夹用来存放nginx方面的内容
docker cp nginx-test:/etc/nginx/nginx.conf /root/project/nginx/  # 从nginx容器中复制出配置文件 （不需要进入到容器中）
docker cp nginx-test:/etc/nginx/conf.d /root/project/nginx/
docker stop nginx-test  # 停止容器运行
docker rm nginx-test  # 删除测试容器
docker run -it --name nginx --net host -v /root/nginx/project/nginx.conf:/etc/nginx/nginx.conf -v /root/nginx/project/conf.d:/etc/nginx/conf.d -v /root/project/nginx/logs:/var/log/nginx -d nginx  # 创建正式的nginx容器

7、配置nginx容器

cd /root/project/nginx/conf.d
cp default.conf smart_campus.conf  # 复制一遍默认的配置文件
vim smart_campus.conf

把下面的内容放到smart_campus.conf文件中

upstream myserver {
    server 172.17.0.5:8000;  # 后端请求的地址，因为我们的后端部署在一个容器中，而容器的ip地址是172.17.0.5，api的端口是8000，所以要这样写。
    # 如果还有的话，可以继续往下写
    # server XXXX;
    # server XXXX;
}

server {
    listen 80;
    client_max_body_size 20m;
    server_name 38.5.15.5;  # 你的服务器地址

    location /api {  # 如果访问38.5.15.5/api为前缀的话，就会进入到这一块
        proxy_pass http://myserver;    # 被转发到172.17.0.5:8000  
        index index.html index.htm;
    }
}

修改了配置文件之后，我们需要重启一下nginx容器，重新加载一下配置文件。

docker restart nginx

可以通过docker ps来查看一下是否启动成功，如果没有启动成功，需要去查看一下error.log（我们挂载的第三个目录），大概率是配置文件写错了（少加了分号，多写了括号等）。

这样之后我们就成功部署完了nginx服务器。

当我们访问我们的服务器（38.5.15.5）80端口的时候，并且有/api前缀的时候，比如http://38.5.15.5/api，就会被转发到172.17.0.5:8000。

后端部署详解版 （万字警告）

首先你需要在一个目录里，这个目录是无所谓的，但是我建议你还是为每一个项目单独创建一个文件夹，这个可以便于我们后期的管理。

首先我们可以看到，下图中我们使用ls命令来查看本文件夹中有什么文件，我们在这个文件夹里创建了一个Dockerfile文件和一个smart_campus文件夹，这就是我们的所有内容了。

这个Dockerfile文件非常的关键，里面就定义了我们的镜像格式，而创建镜像有多种方式，我们所使用的就是以Dockerfile来创建镜像。

接下来让我们看看Dockerfile文件里有什么内容吧！

构建Dockerfile文件

# 注释版
# 所有的指令都是全部大写的
# FROM表示你的镜像所依托的基础镜像是什么，我们就依托centos系统了
# 第一句话就代表我们这个镜像是centos系统了
FROM centos:latest
# 写一下作者的信息
MAINTAINER Yunfei Hu@89713373@qq.com
# 使用ENV定义一个MYPATH路径
ENV MYPATH /usr/local/project
# 设置WORKDIR为我们刚刚定义的MYPATH路径
# 设置WORKDIR的目的是让我们进入容器的时候，当前的路径。 （不设置默认进入根目录）
# 比如设置/usr/local/project，进入容器就会直接进入到这个目录下
WORKDIR  $MYPATH
# 执行一些指令，需要特别强调，现在我们这个镜像已经有一个centos了，它是前后安装的
# 那么下面这些就相当于在这个空壳子centos上，去建立一些我们需要的东西
# 第一句话是更新yum工具
RUN yum -y update \
    # 通过yum下载vim，此时我们的精简centos系统，有了vim这个工具
    && yum -y install vim \
    # 通过yum下载vim，此时我们的精简centos系统，有了git这个工具
    && yum -y install git \
    # 通过yum下载vim，此时我们的精简centos系统，有了gcc这个工具
    && yum install -y gcc-c++ \
    # 通过yum下载vim，此时我们的精简centos系统，有了wget这个工具。 
    # 为什么要下载wget呢？ 因为下面要下载go的编译器，它是一个安装包，需要用wget来下载
    # yum是直接下载并安装，wget只是一个下载工具，类似于迅雷
    && yum -y install wget \
    # 通过wget来下载这个安装包
    && wget -P /root/ https://dl.google.com/go/go1.14.1.linux-amd64.tar.gz \
    # 用tar指令来解压缩这个安装包到/usr/local
    && tar -zxvf /root/go1.14.1.linux-amd64.tar.gz -C /usr/local \
    # 添加go环境在系统环境变量中
    && echo export PATH=$PATH:/usr/local/go/bin >> /etc/profile \
    # 重新编译一下/etc/profile文件（环境变量生效），并且查看一下go版本
    && source /etc/profile && go version \
    # 在bash每次启动的时候，都会加载.bashrc文件中的内容，也就是每次打开bash(终端)
    # 的时候，都会编译一下/etc/profile文件（环境配置文件）
    && echo "source /etc/profile" >> /root/.bashrc \
    # 设置我们刚刚下载的go编译工具的代理地址（下载速度会变快）
    && go env -w GOPROXY=https://goproxy.cn,direct \
    # 在Go11.1版本之后，go采用go module来代替之前的依赖管理，如果我们想要启用
    # go module的功能，需要设置GO111MODULE,它有三个值，on，off，auto，默认为auto
    # on开启，off关闭，auto则会寻找项目根目录有没有go.mod文件来决定是否开启。
    && go env -w GO111MODULE=on \
# 打印------end-------代表完成    
CMD echo "-----end-----"

接下来我们看看注释版，具体的命令我就不在这里细说了，只说一下结构和需要注意的事情，首先这是shell脚本命令的写法，可以搜索Dockerfile构建命令来查找更多相关命令。

它就像一个流水线一样，可以通过这个文件保存这样一套命令的执行步骤，降低我们的操作的重复性。

别看文档的命令很多，其实结构并不复杂，一共为三层，第一层主要是做一些环境前置的搭建，第二层用来构建环境中的一些我们所需要的工具，第三层是返回反馈信息。

第一层 | FROM

这里面主要的代码就是第一句了，FROM指令后面跟的叫基础镜像。

FROM centos:latest
MAINTAINER Yunfei Hu@89713373@qq.com
ENV MYPATH /usr/local/project
WORKDIR  $MYPATH

这是因为我们构建镜像的时候，通常会以一个镜像为基础，在其上进行定制，这就是基础镜像，在Dockerfile中基础镜像必须指定，FROM就做这个事情。

就好像你要搭建一个庞大的积木，为了节省你的时间，Docker已经为我们搭建了一些常用的积木模板。 你可以在这个积木模板上再进行自己的发挥，去搭建各种各样的工具。

我们指定的是centos:latest，这说明基础镜像是centos系统，latest说明版本是最新的，你也可以通过指定具体的版本号来下载对应的版本。

在Docker Hub上有很多的官方镜像，可以在其中寻找一个最符合我们最终目标的镜像为基础镜像进行定制。

  1. 有应用镜像：如 nginx、redis、mongo、mysql、httpd、php、tomcat 。
  2. 有方便开发、构建、运行各种语言应用的编程语言镜像，如node、oraclejdk、openjdk、python、ruby、golang等。
  3. 还有更为基础的操作系统镜像，如 ubuntu、debian、centos、fedora、alpine 等，这些操作系统的软件库为我们提供了更广阔的扩展空间。
  4. 除了选择现有镜像为基础镜像外，Docker 还存在一个特殊的镜像，名为 scratch。这个镜像是虚拟的概念，并不实际存在，它表示一个空白的镜像。

    如果你在DockerFIle中以 scratch 为基础镜像的话(FROM scratch)，意味着你不以任何镜像为基础，接下来所写的指令将作为镜像第一层开始存在。

第二行是配置一下作者信息，第三行是设置一个环境变量，MYPATH是名字，内容是/usr/local/project。

然后是WORKDIR ￥MYPATH来定义工作目录，当我们通过镜像构建一个容器的时候，这个WORKDIR就是我们的默认初始目录。

第二层

下面是我们第二层的命令，这是我们最核心的代码，Dockerfile文件的构建主要在这个里面。

下面这些内容其实就是安装各种各样的工具，那有同学可以就要问了，我们都已经指定了基础镜像了，为什么还要安装各种各样的工具呢？难道基础镜像上没有吗？

RUN yum -y update \
    && yum -y install vim \
    && yum -y install git \
    && yum install -y gcc-c++ \
    && yum -y install wget \
    && wget -P /root/ https://dl.google.com/go/go1.14.1.linux-amd64.tar.gz \
    && tar -zxvf /root/go1.14.1.linux-amd64.tar.gz -C /usr/local \
    && echo export PATH=$PATH:/usr/local/go/bin >> /etc/profile \
    && source /etc/profile && go version \
    && echo "source /etc/profile" >> /root/.bashrc \
    && go env -w GOPROXY=https://goproxy.cn,direct \
    && go env -w GO111MODULE=on \

那么需要注意是，这个基础镜像是一个阉割过的系统，它连ifconfig（查看IP地址）命令都没有，那么我们想要的各种各样的工具当然就没有了，比如vim（文本编辑工具，说人话就是可以让你修改文件内容），git（通过git可以来进行代码管理），gcc（可执行文件需要用到gcc），wget（通过wget来下载安装包）。

我们可以看到第一行是RUN yum -y update，这是更新一下yum工具，yum可以帮助我们下载并安装很多的工具。

然后紧接着是一个\反斜线，它就是说这一行命令和下一行命令是一行，只是我写不下了，所以我需要换行，但是为了让计算机知道这两行命令是一行，需要加一个\来标识一下。

A && B就代表先运行A命令，然后再运行B命令，同理上面的命令都会先后执行。

第三层

第三层非常的简单，只有一句话，它会打印------end------在终端上，告诉我们结束了。

CMD echo "-----end-----"

通过Dockerfile文件生成镜像

# 通过以下命令来构建镜像
# -f后面指定我们的Dockerfile文件的路径，如果是在当前目录，而且是Dockerfile的话
# -f也可以不写，因为Dockerfile这个名字是官方指定的，它会自动去找
# -t是用来设置名字和Tag（版本），比如我写centos_go:0.1，表示这是一个centos带go
#  环境的系统，版本是0.1。
#  需要特别注意的是，这条命令的最后有一个点，不能去掉，它指的是上下文路径，是指docker在
#  构建镜像的时候，有时候需要用到本机的文件（比如复制），docker build命令得知这个路径
#  后，会将路径下的所有内容打包。 如果不说明这个参数，默认的上下文路径就是Dockerfile所在的位置
docker build -f Dockerfile -t centos_go:0.1 .

当你通过运行上面那条命令之后，它就会根据Dockerfile来构建与之对应的镜像了，它会下载各种东西，等待一段时间之后，会有一个Success，也就是构建完成了。

值得一提的是Dockerfile文件的名字通常是Dockerfile，这个是官方指定的文件名字，如果你使用这个名字的话，可以不用加-f参数。

它会自动去寻找Dockerfile文件，然后执行其中的命令，最终生成一个镜像系统。也就是如下。

docker build -t centos_go:0.1 .

我们可以通过docker images来查看我们已经创建的镜像，可以看到下面就是我们创建的镜像，名字是centos_go，版本是0.1，镜像的ID，创建的时间，还有镜像的大小。

镜像本身是没什么用的，它就相当于一个建筑设计图一样，只是一个模板，我们可以通过这个镜像来创建很多的容器，这个容器就相当于基于这个建筑设计图去建立一个建筑，我们可以给这个建筑一个名字，你可以创建建筑A，建筑B，建筑C，在不同的建筑里放进去不同的东西。

所以我们接下来就需要去学习如何创建和使用容器了。

容器使用

Dockerfile文件的构建是我们部署的第一个难点，接下来就是第二个难点，就是容器的使用。

通过在命令行中输入以下命令，可以让我们把容器创建出来，我们将从左到右为大家说明此条命令。

docker run -it -v /root/project:/usr/local/project --name centos_test01 centos_go:0.1 /bin/bash

-i 代表交互式操作，-t 是终端运行，也就是在终端进行交互式操作，这个就是专业术语，所谓的交互式操作是什么意思呢？ 就是你可以在命令行中输入命令来控制容器。

低端：和容器交流，可以有个方式给容器命令让容器执行命令
高端：与容器建立交互式操作关系，通过指令来让容器进行对应的行动

其实是一个意思。

-v 后面跟的是容器内和容器外的路径映射，什么意思呢？因为容器里面默认是空的，什么都没有，但是我想要让容器中某个目录和我真机的目录保持一致，就需要做这样一个映射，前面的是真机的目录，后面的是容器内的目录，如果你没有这个文件夹，它也会自动创建，此时这两个文件夹就是一个绑定的关系，在其中一个创建文件或操作文件，另一个也会自动改变。

那么这样的话，当你在宿主机从git上拉取代码的时候，容器内的代码也会更新。

我打算把项目放到project这个目录下，所以直接映射到project了，还记得我们构建镜像的时候制定的WORKDIR吗？ 是/usr/local/project，也就是进入容器直接进入到项目目录，可以减少一些操作。

再往后面的--name是指定这个容器的名字。

再往后面的centos_go:0.1，是我们刚刚创建的镜像名，意思是通过这个镜像来创建容器，此时这条命令其实已经结束了，但是你会发现在镜像名的后面有一个/bin/bash，此时你需要分清的是镜像名前面的是属于docker启动的参数，镜像后面的是终端的命令，/bin/bash的意思是你进行交互式操作总得有个载体，我们用的是/bin/bash即你经常使用的那个黑窗口，执行指令都需要/bin/bash来进行解释。

通过上面的命令就可以让我们直接创建这个容器，这个容器有自身的一套文件系统，也就是说你刚进去的时候是什么都没有的，在你刚进去的时候，你默认应该会进到当时我们设置的WORKDIR文件夹，然后当你进入到我们映射的文件夹中，应该能看到我们的项目文件。

你可以在宿主机通过下面的命令来对容器进行一些操作

# 查看当前正在运行的容器
docker ps 
# 进入当前正在运行的容器
docker attach 容器ID
# 查看所有的容器
docker ps -a
# 如果你创建了这个容器，但是这个容器没有运行，你是无法直接进去的，需要先启动
docker start 容器ID
# 有启动当然也有停止
docker stop 容器ID

现在的状态大概是这样的，真机和我们创建的容器之间是不连通的，但是容器之间是可以互相连通的，它们在一个局域网之内，并且容器的IP每次启动都会重新分配。

现在你已经进来到docker创建的这个容器中了，你可以把你想要启动的项目启动一下。

root/project中存放着我们的项目，你需要进入到项目目录中，然后使用go build main.go命令来编译一下我们的程序，会出现一个main的执行程序，就可以使用下面的nohup命令来进行不挂断执行了。

下面这句话就是后台执行某个命令（而这个命令是执行某个程序），然后把这个命令产生的结果给start.log这个文件夹。

# nohup表示不挂断地运行命令，也就是你即便关掉终端，依然不会终止
# 启动文件，将结果输出到start.log中
# 2>&1，2是标准错误，1是标准输出，就是把错误结果打印出来，&1是就是对标准输出的引用
# 最后的&是是把该命令以后台的job的形式运行，可以通过jobs -l命令来查看当前的所有job
nohup /usr/local/project/smart_campus/scs_api/main > start.log 2>&1 &

你可以通过jobs -l命令或者去start.log来查看是否已经启动成功。

当我们进入容器之后，使用exit命令退出容器，或者使用Ctrl+D快捷键退出容器，都会使容器停止运行，里面的程序当然也会停止运行，如果想退出容器，又不让容器停止，可以使用Ctrl+P+Q的快捷键方式。

现在的状态是你的宿主机在外面待机中，你目前进入到容器中已经以后台的方式启动了你的项目，但是我们的目的是部署，是让别人在别的电脑上能够访问到我们的后端程序/接口，但是你还记得吗？宿主机和容器之间是不相通的，而你的程序却在容器中启动，这个时候我们希望达到的效果是访问宿主机可以被转发到容器中的程序，但是目前不行，这个时候有很多种解决方案。

其中一种比较简单的是做端口映射，在创建容器的时候，通过-p来做端口的映射，这样当你访问宿主机的80端口的时候，就可以被自动转发到容器内的8000端口了，这样一种方式的问题在于，端口是写死的，不便于我们之后的扩展性，如果你程序的端口修改了的话，你就需要重新做一个映射。

docker run -itd -p 80:8000 docker.io/centos:latest /bin/bash

为了有一种更方便的做法，我们打算使用Nginx来解决ip的转发问题。

就变成了这样一种状况，因为nginx本身也是一个容器，nginx容器和容器1容器2之间都是可以互联的，我们在宿主机上只需要去管理nginx就可以了，nginx会帮我们转发给各个容器，这样大家就各司其职。

容器使用的基本原则

最后，容器有两个基本原则

基本原则1：不经常变动或者变动很少的设定信息应该固化到Dockerfile或者镜像之中
基本原则2：有定制需要的设定配置文件应该以挂载等允许的方式进行外部持久化存储

像我们下面要讲的nginx容器，我们需要经常修改nginx的配置文件，如果你不把它挂载到外部环境的话，你每次需要修改配置文件，都需要到容器中去修改，但是如果你的配置文件一旦出问题的话，你的nginx容器将无法启动（无法启动，也就无法进入），那你就无法修改，这就陷入了一个怪圈之中——因为配置文件出错，你无法进入到容器中，但是容器中的配置文件出现了问题需要你进入修改。 而挂载，把配置文件放到外面，就可以解决这个问题，把配置文件修改好了，nginx容器自然就可以启动了。

这就是基本原则2的意义，也就是为什么要挂载目录。

在容器中搭建nginx服务器

宿主机和后端程序现在是不连通的，所以需要通过nginx这个中间商来进行转发。

nginx服务器不一定要用docker来搭建，也可以直接搭建在真机之中，但是那可能会造成我们之后的操作的不方便，分别管理总是更清晰，更模块化的，所以我们还是用docker来搭建，另外容器之间是互通的，这也方便nginx服务器访问其它的容器。

搭建nginx容器需要经历这么几个步骤，它和我们前面搭建后端的容器有些不同，这次我们不用Dockerfile的方式来搭建容器了，之前我们使用Dockerfile来构建镜像的原因是因为我们不仅仅需要那一个基础的centos镜像，还需要很多的工具，这个时候通过Dockerfile文件直接批量的处理会很方便，但是nginx容器不需要那么多工具，所以直接下载就可以了。

  • 下载nginx镜像
  • 启动测试容器（目的只是为了复制ngixn配置文件在外面）
  • 复制配置文件
  • 删除测试容器
  • 创建正式nginx容器
  • 修改配置文件

1、 下载nginx镜像

docker pull nginx

它会从Docker Hub下载nginx镜像，Docker Hub上还有很多其它的镜像以支持我们日常的使用。
此时你使用docker images就能看到我们下载了一个nginx镜像，而且TAG是latest（最新版）。
在这里插入图片描述
2、启动测试容器

因为我们的本机并没有nginx，也就自然没有nginx配置文件，那么我们就无法挂载配置文件，因为挂载文件会让真机的路径覆盖容器的路径，所以我们需要真机里也得有一份配置文件。

–name 后面是容器的名字，-d 后面跟的是我们要按照哪个镜像来创建容器

docker run --name nginx_test -d nginx

3、复制配置文件

有两个文件需要我们复制，下面的cp命令就是把容器中的nginx.conf和conf.d复制到外面的nginx文件夹中

mkdir /root/nginx
docker cp nginx-test:/etc/nginx/nginx.conf /root/nginx/
docker cp nginx-test:/etc/nginx/conf.d /root/nginx/

4、删除测试容器
现在我们外面已经有配置文件了，所以就不需要测试容器了

docker stop nginx-test
docker rm nginx-test

5、创建正式的nginx容器

因为nginx容器有很多我们需要经常操作的地方，所以挂载的地方也比较多，但是捋捋并不难理解

  • –net host的作用是不需要再做端口映射了，相当于是把nginx容器和宿主机进行网络共享。
  • 我们挂载了三个目录，第一个是nginx.conf配置文件，第二个是conf.d配置文件夹，里面存放所有的配置文件，第三个是log文件
docker run -it --name nginx --net host -v /root/nginx/nginx.conf:/etc/nginx/nginx.conf -v /root/nginx/conf.d:/etc/nginx/conf.d -v /root/nginx/logs:/var/log/nginx -d nginx

6、修改配置文件

接下来就需要修改配置文件，让我们的宿主机能够访问到容器内的后端程序了。
我们会发现挂载的有一个nginx.conf和conf.d，它们之间有什么关系呢？

当我们打开nginx.conf会发现它是nginx的总配置文件，而在这个配置文件的最后，有一行include信息，它相当于引入conf.d文件夹中所有以.conf结尾的文件。

在这里插入图片描述
也就是说我们以后写配置文件就在conf.d这里写，会被nginx自动加载。

默认的时候，有一个default.conf，我们可以把它复制一份，然后改成我们想要的名字，比如我这里创建了一个smart_campus.conf文件，用来对我的后端程序进行配置。
在这里插入图片描述

下面配置文件的作用是当我们访问我们的服务器（38.5.15.5）80端口的时候，并且有/api前缀的时候，比如http://38.5.15.5/api，就会被转发到172.17.0.5:8000。

upstream myserver {
    server 172.17.0.5:8000;  # 后端请求的地址，因为我们的后端部署在一个容器中，而容器的ip地址是172.17.0.5，api的端口是8000，所以要这样写。
    # 如果还有的话，可以继续往下写
    # server XXXX;
    # server XXXX;
}

server {
    listen 80;
    client_max_body_size 20m;
    server_name 38.5.15.5;  # 你的服务器地址

    location /api {  # 如果访问38.5.15.5/api为前缀的话，就会进入到这一块
        proxy_pass http://myserver;    # 被转发到172.17.0.5:8000  
        index index.html index.htm;
    }
}

修改了配置文件之后，我们需要重启一下nginx容器，重新加载一下配置文件。

docker restart nginx

可以通过docker ps来查看一下是否启动成功，如果没有启动成功，需要去查看一下error.log（我们挂载的第三个目录），大概率是配置文件写错了（少加了分号，多写了括号等）。

这样之后我们就成功部署完了nginx服务器。

我们现在的图是这样的
在这里插入图片描述

现在当你访问38.5.15.5/api的时候，就能访问到后端api接口了。

欢迎评论区讨论，或指出问题。 如果觉得写的不错，欢迎点赞，转发，收藏。

# docker # 后端 # linux # nginx
Logo
华为云开发者联盟

为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。

更多推荐

cover

HAS2024：华为云以系统性创新加速千行万业智能化升级

avatar 华为云开发者联盟
cover

数仓的两种轻量级数据交换格式：json与jsonb

avatar 华为云开发者联盟
cover

如何使用云数据库GaussDB管理平台进行实例安装？

avatar 华为云开发者联盟