总结

以上是小编为你收集整理的8天入门docker系列 —— 第五天 使用aspnetcore小案例熟悉容器互联和docker-compose一键部署全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

ASP.NET Core 实战：使用 Docker 容器化部署 ASP.NET Core + MySQL + Nginx

 一、前言

　　在之前的文章（ASP.NET Core 实战：Linux 小白的 .NET Core 部署之路）中，我介绍了如何在 Linux 环境中安装 .NET Core SDK /.NET Core Runtime、Nginx、MySQL，以及如何将我们的 ASP.NET Core MVC 程序部署到 Linux 上，同时，使用 supervisor  守护程序守护我们的 .NET Core 程序。如果，你有看过那篇文章，并且和我一样是个 Linux 小白用户的话，可能第一感觉就是，把 .NET Core 项目部署在 IIS 上也挺好。

　　将 .NET Core 项目部署到 Linux 上如此复杂，就没有简单的部署方式吗？

　　你好，有的，Docker 了解一下～～～

　　PS：这里的示例代码还是采用之前的毕业设计项目，在这篇文章发布的时候，我已经在程序的仓库中添加了对于 Docker 的支持，你可以下载下来，自己尝试一下，毕竟，实践出真知。

　　 代码仓储：https://github.com/Lanesra712/Danvic.PSU

 二、Step by Step

　　1、安装 Docker & Docker Compose

　　在代码交付的过程中，偶尔会遇到这样的问题，在本地测试是好的，但是部署到测试环境、生产环境时就出这样那样的问题，同时，因为本地与测试环境、生产环境之间存在差异，我们可能无法在本地复现这些问题，那么，有没有一种工具可以很好的解决这一问题呢？随着历史的车轮不断前行，容器技术诞生了。

　　Docker，作为最近几年兴起的一种虚拟化容器技术，他可以将我们的运行程序与操作系统做一个隔离，例如这里我们需要运行 .NET Core 程序，我们不再需要关心底层的操作系统是什么，不需要在每台需要需要运行程序的机器上安装程序运行的各种依赖，我们可以通过程序打包成镜像的方式，将应用程序和该程序的依赖全部置于一个镜像文件中，这时，只要别的机器上有安装 Docker，就可以通过我们打包的这个镜像来运行这个程序。

　　1.1、卸载 Docker

　　在安装 Docker 之前，我们应该确定当前的机器上是否已经安装好了 Docker，为了防止与现在安装的 Docker CE 发生冲突，这里我们先卸载掉以前版本的 Docker，如果你确定你的机器上并没有安装 Docker 的话此步可以跳过。

　　在 Linux 中可以使用 \ 加 Enter 在输入很长很长的语句时进行换行，这里和后面的命令都是采用这样的方式。

sudo yum remove docker \
  docker-client \
  docker-client-latest \
  docker-common \
  docker-latest \
  docker-latest-logrotate \
  docker-logrotate \
  docker-engine

　　1.2、添加 yum 源

　　在安装 Docker CE 的方式上，我是采用将 Docker CE 的源添加到 yum 源中，之后我们就可以直接使用 yum install 安装 Docker CE，整个的安装过程如下。

# 安装工具包从而可以让我们在 yum 中添加别的仓储源
sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

# 设置 docker ce 的稳定库地址
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

# 安装 docker ce
sudo yum install docker-ce docker-ce-cli containerd.io

　　当我们安装好 Docker 之后，我们就可以使用 docker 命令验证我们是否在机器上成功安装了 Docker，同时，也可以使用 docker --version 命令查看我们安装的 Docker CE 版本。

　　1.3、设置开机自启

　　当 Docker 已经在我们的机器上安装完成后，我们就可以将 Docker 设置成机器的自启服务，这样，如果出现服务器重启的情况下，我们的 Docker 也可以随服务器的重启自动启动 Docker 服务。

# 启动 Docker 服务并允许开机自启
sudo systemctl start docker

# 查看当前 dokcer 的运行情况
sudo systemctl status docker

　　1.4、Hello World

　　就像我们在学习一门新的语言时，运行的第一句代码，几乎都是打印出 Hello World，而在 Docker Hub 中，也有这么一个镜像，在无数的 Docker 教程中，安装完 Docker 后，第一件事就是拉取这个镜像文件，“告诉” Docker，我来了。

　　Docker Hub 是存放镜像的仓库，里面包含了许多的镜像文件，因为服务器在国外的原因，下载的速度可能不理想，像国内的阿里云、腾讯云也有提供对于 Docker 镜像的加速器服务，你可以按需使用，当然，你也可以创建属于你的私有镜像仓库。

docker run hello-world

　　docker run 命令，它会在我们的本地镜像库中先寻找这个镜像，然后运行。如果在本地没有找到的话，则会自动使用 docker pull 从 Docker Hub 中寻找，能找到的话，则会自动下载到本地，然后运行，找不到的话，这条命令也就运行失败了。

　　1.5、安装 Docker Compose

　　在实际的项目开发中，我们可能会有多个应用镜像，例如在本篇文章的示例中，为了在 Docker 中运行我们的程序，我们需要三个镜像：应用程序自身镜像、MySQL Server 镜像、以及 Nginx 镜像，为了将我们的程序启动起来，我们需要手敲各个容器的启动参数，环境变量，容器命名，指定不同容器的链接参数等等一系列的操作，又多又烦，可能某一步操作失败后程序就无法正常运行。而当我们使用了 Docker Compose 之后，我们就可以把这些命令一次性写在 docker-compose.yml 配置文件中，以后每次启动我们的应用程序时，只需要通过 docker compose 命令就可以自动帮我们完成这些操作。

# 从 github 下载 docker compose 二进制文件
sudo curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 对下载的二进制文件应用可执行权限
sudo chmod +x /usr/local/bin/docker-compose

# 查看 docker compose 版本
docker-compose --version

　　2、构建程序镜像

　　当我们在服务器上安装好 docker 和 docker compose 之后，就可以开始构建我们的程序镜像了。首先我们需要对我们的运行程序添加对于 Docker 的支持。你可以自己手动在 MVC 项目中添加 Dockerfile 文件，或是通过右键添加 Docker 支持。

　　Dockerfile 就像一个执行的清单，它告诉 Docker，我们这个镜像在构建和运行时需要按照什么样的命令运行。打开 VS 为我们自动创建的 Dockerfile，可以看到清晰的分成了四块的内容。

　　我们知道，.NET Core 程序的运行需要依赖于 .NET Core Runtime（CoreCLR），因此，为了使我们的程序可以运行起来，我们需要从 hub 中拉取 runtime ，并在 此基础上构建我们的应用镜像。同时，为了避免因为基础的环境的不同造成对程序的影响，这里的 Runtime 需要同程序开发时的 .NET Core SDK 版本保持一致，所以这里我使用的是 .NET Core 2.1 Runtime。

　　一个镜像中包含了应用程序及其所有的依赖，与虚拟机不同的是，容器中的每个镜像最终是共享了宿主机的操作系统资源，容器作为用户空间中的独立进程运行在主机操作系统上。

　　PS: 图片版权归属于微软的技术文档，如有侵权，请联系我删除，源文件地址：什么是 Docker？

　　镜像可以看成一个个小型的 “虚拟主机”，这里我们在镜像中创建了一个 /app 路径作为我们程序在镜像中的工作目录，同时，将 80 端口暴露给 Docker，从而可以使我们在镜像外面通过端口访问到当前镜像中的运行的程序。

FROM microsoft/dotnet:2.1-aspnetcore-runtime AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

　　因为我们的应用是一个多层架构的单体应用，最终的 MVC 项目依赖于解决方案中的各个类库以及我们从 Nuget 中下载的各种第三方组件，在部署时，需要将这些组件打包成 dll 引用。所以，这里我们需要使用 .NET Core SDK 中包含的 .NET Core CLI 进行还原和构建。

　　就像在下面的代码中，我们在镜像的内部创建了一个 /src 的路径，将当前解决方案下的类库都复制到这个目录下，之后通过 dotnet restore 命令还原我们的主程序所依赖的各个组件。当我们还原好依赖的组件后，就可以使用 dotnet build 命令生成 Release 版本的 dll 文件，同时输出到之前创建的 /app 路径下。

FROM microsoft/dotnet:2.1-sdk AS build
WORKDIR /src
COPY ["PSU.Site/PSU.Site.csproj", "PSU.Site/"]
COPY ["03_Logic/PSU.Domain/PSU.Domain.csproj", "03_Logic/PSU.Domain/"]
COPY ["03_Logic/PSU.Repository/PSU.Repository.csproj", "03_Logic/PSU.Repository/"]
COPY ["01_Entity/PSU.Entity/PSU.Entity.csproj", "01_Entity/PSU.Entity/"]
COPY ["02_Infrastructure/PSU.Utility/PSU.Utility.csproj", "02_Infrastructure/PSU.Utility/"]
COPY ["04_Rule/PSU.Model/PSU.Model.csproj", "04_Rule/PSU.Model/"]
COPY ["02_Infrastructure/PSU.EFCore/PSU.EFCore.csproj", "02_Infrastructure/PSU.EFCore/"]
COPY ["04_Rule/PSU.IService/PSU.IService.csproj", "04_Rule/PSU.IService/"]
COPY ["Controllers.PSU/Controllers.PSU.csproj", "Controllers.PSU/"]
RUN dotnet restore "PSU.Site/PSU.Site.csproj"
COPY . .
WORKDIR "/src/PSU.Site"
RUN dotnet build "PSU.Site.csproj" -c Release -o /app

　　上面一步可以看成我们在使用 VS 生成 Release 版本的解决方案，当生成没有出错之后，我们就可以进行程序的发布。

FROM build AS publish
RUN dotnet publish "PSU.Site.csproj" -c Release -o /app

　　当已经生成发布文件之后，按照我们平时部署在 Windows 上的过程，这时就可以通过 IIS 部署运行了，因此，构建我们应用镜像的最后一步就是通过 dotnet 命令执行我们的程序。

FROM base AS final
WORKDIR /app
COPY --from=publish /app .
ENTRYPOINT ["dotnet", "PSU.Site.dll"]

　　似乎到这一步构建程序镜像就结束了，按照这样流程做的话，就需要我们将整个的解决方案上传到服务器上了，可是，很多时候，我们仅仅是把我们在本地发布好的项目上传到服务器上，这与我们现在的构建流程具有很大的不同，所以这里我们来修改 Dockerfile 文件，从而符合我们的发布流程。

　　从上面分析 Dockerfile 的过程中不难看出，在服务器上构建镜像的第二步、第三步就是我们现在在开发环境中手动完成的部分，所以这里，我们只需要对这部分进行删除即可，修改后的 Dockerfile 如下。

FROM microsoft/dotnet:2.1-aspnetcore-runtime
WORKDIR /app
COPY . /app 
EXPOSE 80
ENTRYPOINT ["dotnet","PSU.Site.dll"]

　　在修改后的 Dockerfile 中，可以看到，我们删去了 build 和 release 的过程，选择直接将我们 Dockerfile 路径下的文件拷贝到镜像中的 /app 路径下，然后直接执行 dotnet 命令，运行我们的程序。

　　为了确保 Dockerfile 与发布后的文件处于同一路径下，这里我们需要使用 VS 修改 Dockerfile 的属性值，确保会复制到输出的目录下，这里选择如果较新则复制即可。

　　3、编写 docker-compose.yml

　　当我们构建好应用的镜像，对于 Nginx 和 MySQL 我们完全可以从 hub 中拉取下来，再执行一些配置即可。所以，我们现在就可以编写 docker compose 文件，来定义我们的应用镜像运行时需要包含的依赖以及每个镜像的启动顺序。

　　右键选中 MVC 项目，添加一个 docker-compose.yml 文件，同样的，需要修改该文件的属性，以便于该文件可以复制到输出目录下。注意，这里的文件名和上文的 Dockerfile 都是特定的，你不能做任何的修改。如果你的电脑上已经安装了 Docker for Windows，你也可以使用 VS，右键添加，选中容器业务流程协调程序支持自动对 docker compose 进行配置。

　　在 yml 文件中，我定义了三个镜像：psu.site、docker.mysql、docker.nginx。三个镜像的定义中有许多相同的地方，都设置了自动重启（restart），以及都处于同一个桥接网络下（psu-net）从而达到镜像间的通信。

　　docker.mysql 是 MySQL 的镜像，我们通过环境变量 MYSQL_ROOT_PASSWORD 设置了 MySQL 的数据库连接密码，并通过挂载卷的方式将镜像中的数据库文件持久化到我们的服务器本地路径中。同时，将镜像的 3306 端口映射到服务器的 3306 端口上。

　　psu.site 则是我们的程序镜像，采用位于 /usr/wwwroot/psu/ 路径下的 Dockerfile 文件进行构建的，因为主程序的运行需要依赖于数据库，所以这里采用 depends_on 属性，使我们的应用镜像依赖于 docker.mysql 镜像，即，在 docker.mysql 启动后才会启动应用镜像。

　　docker.nginx 则是我们的 nginx 镜像，这里将镜像中的 80 端口和 443 端口都映射到服务器 IP 上，因为我们需要配置 Nginx 从而监听我们的程序，所以通过挂载卷的方式，将本地的 nginx.conf 配置文件用配置映射到镜像中。同时，因为我们在构建应用镜像的 Dockerfile 文件时，对外暴露了 80 端口，所以这里就可以通过 links 属性进行监听（如果构建时未暴露端口，你可以在 docker compose 文件中通过 Expose 属性暴露镜像中的端口）。

　　Nginx 的配置文件如下，这里特别需要注意文件的格式，缩进，一点小错误都可能导致镜像无法正常运行。如果你和我一样将 nginx.conf 放到程序运行路径下的，别忘了修改文件的属性。

server {
    listen 80;
	
    location / {
      proxy_pass http://psu.site;
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Host $http_host;
      proxy_cache_bypass $http_upgrade;
    }
}

　　一个完整的 docker compose 文件如下，包含了三个镜像以及一个桥接网络。

version: ''3.7''

services:
  docker.mysql:
    image: mysql
    ports:
      - "3306:3306"
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=123456@sql
    volumes:
      - /usr/mysql:/var/lib/mysql
    networks:
      - psu-net

  psu.site:
    build: /usr/wwwroot/psu/
    restart: always
    depends_on:
      - docker.mysql
    networks:
      - psu-net

  docker.nginx:
    image: nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    links:
      - psu.site
    networks:
      - psu-net

networks:
  psu-net:
    driver: bridge

　　这里需要注意，所有有用到镜像间的通信的地方，我们都需要使用镜像名进行指代，例如上面的 nginx 的配置文件中，我们需要将监听的地址改为镜像名称，以及，我们需要修改程序的数据库访问字符串的服务器地址，修改后的数据库连接字符串如下所示。

"ConnectionStrings": {
    "SQLConnection": "server=docker.mysql;database=PSU.Site;user=root;password=123456@sql;port=3306;persistsecurityinfo=True;"
  }

　　4、发布部署程序

　　当我们构建好 docker compose 文件后就可以把整个文件上传到服务器上进行构建 docker 镜像了。这里我将所有的部署文件放在服务器的 /usr/wwwroot/psu/ 路径下，这时我们就可以通过 docker compose 命令进行镜像构建。

　　定位到部署文件在的位置，我们可以直接使用下面的命令进行镜像的（重新）构建，启动，并链接一个服务相关的容器，整个过程都会在后台运行，如果你希望看到整个过程的话，你可以去掉 -d 参数。

# 执行镜像构建，启动
docker-compose up -d

　　当 up 命令执行完成后，我们就可以通过 ps 命令查看正在运行的容器，若有的容器并没有运行起来，则可以使用 logs 查看容器的运行日志从而进行排错。

# 查看所有正在运行的容器
docker-compose ps

# 显示容器运行日志
docker-compose logs

 三、总结

 　　 本章主要是介绍了如何通过 docker 容器，完整的部署一个可实际使用的 .NET Core 的单体应用，相比于之前通过 Linux 部署 .NET Core 应用，可以看到整个步骤少了很多，也简单很多。文中涉及到了一些 docker 的命令，如果你之前并没有接触过 docker 的话，可能需要你进一步的了解。当我们将程序打包成一个镜像之后，你完全可以将镜像上传到私有镜像仓库中，或是直接打包成镜像的压缩文件，这样，当需要切换部署环境时，只需要获取到这个镜像之后即可快速完成部署，相比之前，极大的方便了我们的工作。

原文出处：https://www.cnblogs.com/danvic712/p/10566750.html

ASP.NET Core 开发 - Docker 部署运行

ASP.NET Core 开发 Docker 部署，.NET Core 支持 Docker 部署运行。我们将 ASP.NET Core 部署在 Docker 上运行。

大家可能都见识过 Docker ，今天我们就详细了解一下 Docker 的用途，以及真实的应用场景。

Docker 源于 PaaS，PaaS 的应用场景即是 Docker 的应用场景。

Platform as a Service: 平台即服务，是面向软件开发者的服务，云计算平台提供硬件，OS, 编程语言，开发库，部署工具，帮助软件开发者更快的开发软件服务。比如 Google 的 GAE.

八个 Docker 的真实应用场景 http://dockone.io/article/126

Docker 最大优势：

静态打包：把应用程序及其运行时打包为一个镜像；
动态运行：以一个应用容器的形式运行这个应用。

我们无需再关心每个系统要安装什么环境，直接将镜像复制到系统中运行。

一次打包，直接运行。

参考 Docker 的 logo , 我们可以将 Docker 理解为鲸鱼上的集装箱，而鲸鱼就是操作系统。

Docker 是一个集装箱，将所有的环境打包好在一起，我们只需要考虑挪动集装箱。

下面我们就来正式开.NET Core 的 Docker 之旅。

Docker 命令：

docker 命令相关了解。

docker images //镜像列表

 
docker ps -a //所有运行过的容器
docker ps -l //最后运行容器

docker export 容器id > 文件  //持久化容器

docker import 文件 //导入容器

 
cat export.tar | docker import - linezero/demo-export:latest

 

docker save 镜像id > 文件 //持久化镜像

docker load < 文件

 

docker rm 容器id //删除容器

docker rmi 镜像id/镜像名称  //删除镜像

docker run 镜像 //运行

提示：可以使用 docker rm $(docker ps -q -a) 一次性删除所有的容器，docker rmi $(docker images -q) 一次性删除所有的镜像。

ASP.NET Core 运行于 Docker

本文环境 ：Ubuntu 14.04  Docker for Linux 1.11.2

首先我们创建一个 ASP.NET Core 应用。

dotnet new -t web

然后在 Program.cs 添加 UseUrls("http://*:5000")

还原 dotnet restore

发布 dotnet publish

我们在 publish 文件夹添加 Dockerfile 文件

FROM microsoft/dotnet:latest

COPY . /app

WORKDIR /app

EXPOSE 5000/tcp

ENTRYPOINT ["dotnet", "aspnetcore.dll"]

最终 publish 目录如下：

将 publish 文件夹复制到 Ubuntu 系统

运行构建命令，构建 Docker 镜像。 

docker build -t linezero/demo .

后面的点是需要的。

然后运行容器

docker run -it -p 8080:5000 linezero/demo

容器跟镜像的关系，一个镜像可以创建多个容器。

如上面的，我可以再创建一个 docker run -d -p 8090:5000 linezero/demo 

-d 参数也就是后台运行，然后通过 docker ps 可以看到容器运行的状态，通过 docker stop 容器 id 停止。

Dockerfile  Docker 容器配置文件

源码模板

FROM microsoft/dotnet:latest

COPY . /app

WORKDIR /app

RUN ["dotnet", "restore"]

RUN ["dotnet", "build"]

EXPOSE 5000/tcp

ENTRYPOINT ["dotnet", "run"]

发布后模板

FROM microsoft/dotnet:latest

COPY . /app

WORKDIR /app

EXPOSE 5000/tcp

ENTRYPOINT ["dotnet", "xx.dll"]

以上模板都依赖于  microsoft/dotnet 镜像，单独安装的命令为

docker pull microsoft/dotnet

也可以先不安装，build 的时候会为我们安装。国内速度可能有些慢，请耐心等待。

有了 Docker dotnet 镜像，你无需折腾 dotnet sdk 安装，镜像自带。

我们如果想将 Docker 放置到其他机器运行，很简单。

直接保存镜像，然后复制镜像到其他机器，然后使用 docker 命令 load 既可。

docker save linezero/demo > demo.tar

然后加载命令

docker load < demo.tar

然后就可以使用 docker run 运行程序了，无需关心程序需要哪些依赖。

原文链接：https://www.cnblogs.com/linezero/p/docker.html

Asp.Net Core&Docker 部署到树莓派 3B 中

　　花了一点时间将吃灰数月的树莓派装上了 Docker，并在容器中部署了一个 Asp.Net Core 应用程序，通过花生壳映射树莓派中的程序，可以使用外网访问树莓派，玩起来很有意思 (外网访问地址：http://2194cn9096.imwork.net/，访问不通可能树莓派断电了)，过程中发现了一点问题，或许对于同样路线的朋友有所帮助，特此写出玩转过程。

　　码云 Demo 地址：https://gitee.com/530521314/ControlEvent.git

一、树莓派安装操作系统

　　1、进入官网下载操作系统：https://www.raspberrypi.org/downloads/，我使用了官方的 Raspbian 系统，并且选择了无界面的轻量版 Raspbian Stretch Lite.

　　2、下载格式化 SD 卡的工具：https://www.sdcard.org/downloads/formatter_4/eula_windows/

　　3、下载将系统烧录到 SD 卡中的工具 Win32 DiskImager：http://sourceforge.net/projects/win32diskimager/，选择系统磁盘路径地址，选择卡，然后执行 Write 即可，等待几分钟，便完成烧录工作

　　4、做一些配置工作，方便启动树莓派后可以快速玩转

　　　4.1、启动 SSH，在卡分区内创建一个名为 ssh 的文件夹即可

　　　4.2、设置无线连接，本次我没有使用外接显示器到树莓派中，使用 Putty 工具直接无线连接，个人感觉更为方便，在卡内 boot 文件夹内，创建一个 wpa_supplicant.conf 的文件，并写下如下内容，该内容在树莓派通电后会由系统自动添加到 /etc/wpa_supplicant/wpa_supplicant.conf 中，设置完毕后便可以插入到树莓派，开始通电了

country=CN
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

//WiFi没有密码
network={
ssid="你的无线网络名称（ssid）"
    key_mgmt=NONE
}

//WiFi使用WEP加密
network={
    ssid="无线网络名称（ssid）"
    key_mgmt=NONE
    wep_key0="wifi密码"
}

//WiFi使用WPA/WPA2加密
network={
    ssid="无线网络名称（ssid）"
    key_mgmt=WPA-PSK
    psk="wifi密码"
}

//以我的举例(priority连接优先级最高)：
network={
    ssid="Yang1802"
    key_mgmt=WPA-PSK
    psk="xxxxxxxx"
    priority=1
}

　　　4.3、使用 Putty 连接树莓派，树莓派 ip 地址可以找办法查看（如我使用的华为路由器，则可以登录路由器管理平台查看），使用账号 pi，密码 raspberry 完成登录，开始校正树莓派时间

// 设置时区为 亚洲（Asia） 上海（Shanghai）
sudo dpkg-reconfigure tzdata
// 启动 NTP 使计算机时钟与 Internet 时间服务器同步
sudo timedatectl set-ntp true

 　　5、切换到 root 账号，方便操作

sudo su

二、树莓派安装 Docker

 　　1、开始安装 Docker，由于树莓派使用的是 ARM 板，因此在安装 Docker 时，需要使用 ARM 板的安装教程：https://docs.docker.com/install/linux/docker-ce/debian/#install-using-the-convenience-script，使用提供的安装脚本完成安装即可，需要等待一些时间。

$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh

　　2、安装 Git 工具，安装 Git 的目的是用于下载码云上的代码到树莓派中，虽然这个环节是有点冗余的，当我配置好了一台 Jenkins 服务器后，完全可以使用 Jenkins 服务器的功能将需要的镜像生产完成，因此这个环节就显得不这么重要了，但是，如果没有 Jenkins 服务器，那么这个环节就不得不进行了，毕竟需要将代码转移到树莓派中，或是开发环境中开发完毕，使用 ftp 转移到树莓派中等多种方式实现，使用如下命令安装 git 工具。

sudo apt-get install git

三、使用 Dockerfile 编译镜像并生成容器

　　 1、新建应用程序，按照约定的标准化应用程序构建方式完成项目搭建 (前几篇文章中讲到了)，具体的项目结构可以从码云中查看。

　　2、增加 Dockerfile 并修改默认的 Dockerfile 内容，由于树莓派使用的是 Arm 板子，因此对于.net core 运行环境也有所不同，在 Dockerfile 中需要指定发布目标平台，具体 Dockerfile 如下，使用的基础镜像可以从 dotnet 组织提供的示例中找到：https://github.com/dotnet/dotnet-docker，我针对该示例中有的 Dockerfile 做了一些改动，以适应项目结构的需要。

FROM microsoft/dotnet:2.2-sdk-stretch-arm32v7 AS build
WORKDIR /app

# copy csproj and restore as distinct layers
COPY ControlEvent.Web.csproj ./ControlEvent.Web/
WORKDIR /app/ControlEvent.Web
RUN dotnet restore

# copy and build app and libraries
WORKDIR /app/
COPY . ./ControlEvent.Web/
WORKDIR /app/ControlEvent.Web
RUN dotnet publish -c Release -r linux-arm -o out

FROM microsoft/dotnet:2.2-runtime-deps-stretch-slim-arm32v7 AS runtime
WORKDIR /app
COPY --from=build /app/ControlEvent.Web/out ./
ENTRYPOINT ["./ControlEvent.Web"]

　　3、提交代码，在树莓派中使用 Git 克隆项目获取代码，并进入到 Dockerfile 层级使用命令构建镜像

　　使用如下命令构建镜像，我的目标镜像名称为 controlevent，此次构建要花费点时间，需要下载相关的基础镜像，下一次构建时会很快了

docker build --pull -t controlevent .

　　4、使用如下命令生成容器，本次指定了 - it 参数，在生成完毕后可以查看控制台输出，直接按 Ctrl Q 和 P 退出即可，也可直接使用 - d 参数后台运行

docker run --rm -it -p 9527:80 controlevent

　　5、使用 ip 地址及端口访问，如果绑定了花生壳，并且在花生壳中做了本地映射，也可以直接使用域名加端口直接访问树莓派中的服务

　至此，本次树莓派中安装 Docker 并部署 Asp.Net Core 应用程序就完成了。

　本文地址：https://www.cnblogs.com/CKExp/p/10233780.html

　欢迎关注微信订阅号，有新的文章将同步到订阅号中

2019-1-7,望技术有成后能回来看见自己的脚步

今天关于从零实操基于 WSL2 Docker 部署 Asp.Net Core 项目和wsl2运行docker的分享就到这里，希望大家有所收获，若想了解更多关于8天入门docker系列 —— 第五天 使用aspnetcore小案例熟悉容器互联和docker-compose一键部署、ASP.NET Core 实战：使用 Docker 容器化部署 ASP.NET Core + MySQL + Nginx、ASP.NET Core 开发 - Docker 部署运行、Asp.Net Core&Docker 部署到树莓派 3B 中等相关知识，可以在本站进行查询。