GVKun编程网logo

.net core 发布到docker（netcore发布到docker）

11

在本文中，您将会了解到关于.netcore发布到docker的新资讯，同时我们还将为您解释netcore发布到docker的相关在本文中，我们将带你探索.netcore发布到docker的奥秘，分析n

在本文中，您将会了解到关于.net core 发布到docker的新资讯，同时我们还将为您解释netcore发布到docker的相关在本文中，我们将带你探索.net core 发布到docker的奥秘，分析netcore发布到docker的特点，并给出一些关于.netcore 使用surging框架发布到docker、.NetCore 发布到 Centos docker、.netcore 项目 docker 化，以及 docker 之间通信、.netcore2.0 docker 发布实践的实用技巧。

本文目录一览：

.net core 发布到docker（netcore发布到docker）

.net core 发布到docker（netcore发布到docker）

 

1. 安装docker-desktop，windows环境安装包

官方网站：https://www.docker.com/

 

2.注册登陆Docker账号

安装成功后，在官方网站注册一个账号，使用账号登陆docker，然后windows的Hyper-V虚拟机就有一个新的虚拟机了

 

 

注意：登陆Docker不能使用邮箱作为账号，否则使用Docker的编译发布镜像的时候，会出现无法验证的错误

Get https://registry-1.docker.io/v2/microsoft/dotnet/manifests/latest: unauthorized: incorrect username or password

 

3.创建core的项目，确保能在本地运行。测试项目绑定本地的5000端口

public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
            .UseUrls("http://*:5000")
                .UseStartup<Startup>()
                .Build();

 

 

4.使用vs发布生成代码

5.发布成功后，publish文件夹添加Dockerfile文件，文件内容如下

# 基于microsoft/dotnet:latest构建Docker Image
FROM microsoft/dotnet:latest
 
# 进入docker中的/usr/local/src目录
RUN cd /usr/local/src
 
# 创建DockerWebAPI目录
RUN mkdir DockerTest
 
# 设置工作路径
WORKDIR /usr/local/src/DockerTest
 
# 将当前文件夹下的所有文件全部复制到工作目录
COPY *.* ./
 
# 向外界暴露5000端口
EXPOSE 5000
 
# 执行dotnet DockerWebAPI.dll命令
CMD ["dotnet", "DockerTest.dll"]

 

microsoft/dotnet:latest 是最新的包，打包后的镜像文件可能有1G以上

microsoft/dotnet:2.1-aspnetcore-runtime 2.1的运行时包，比较小

其他.net core 镜像环境可以自己去找

 

6.发布到docker，红字部分为docker镜像名称

docker build -t dotnet/dockertest .

7.启动镜像

docker run -it -p 8080:5000 dotnet/dockertest

成功后如下图所示

 

-----------------------------------------

附加：

错误1：

启动镜像时，*.deps.json缺少

解决办法：

项目文件csproj，添加配置

 

<PublishWithAspNetCoreTargetManifest>false</PublishWithAspNetCoreTargetManifest>

修改配置后从步骤4开始重新发布！

 

.netcore 使用surging框架发布到docker

.netcore 使用surging框架发布到docker

demo运行在windows的docker中，系统是win10，所以需要先下载Docker for Windows，安装完毕后系统会重启，然后桌面上可以找到Docker for Windows的快捷图标，右下角有个鲸鱼小图标

单击右键，选择菜单中的Kitematic

会提示你下载Kitematic，自行下载后解压即可，将Kitematic快捷到桌面；

打开Kitematic，在搜索栏中下载好RabbitMQ、redis、consul相关镜像，因为这些是surging运行的先决条件。

接着去GitHub上下载surging网关项目，修改其中的gatewaySettings.json中Register下的Address地址，对应的事consul docker镜像的ip

具体如何查看其ip，看如下操作：

打开Kitematic，点击左下角，如图：

进入到命令窗口，输入docker container ls或者 docker ps -a 查看docker，

可以看到现在运行的docker的相关信息，

如图：

然后查看consul的相关配置，输入docker inspect 镜像的 containerID，如consul的id是b0e98b94638c，输入命令如下：docker inspect b0e98b94638c，

显示这个docker的配置，内容会很多，不过ip的信息在最后，如图

找到其中的ip是多少，然后修改surging网关中的consul地址为："Address": "172.17.0.4:8500"，其他配置根据上面的操作进行修改，如redis 镜像地址的查找和修改等；

修改好surging的网关配置后在Surging.ApiGateway项目上单击右键，由于我项目中已经添加过，所以该处为灰色，如图：

新建docker-Compose后修改其中docker-compose.yml的配置如下：

在后面添加docker的外部端口和内部端口的映射和网络模式，这里我们都使用桥接模式，包括之前的consul、RabbitMQ、redis都是同一模式，这样他们会在同一VLAN下，

然后运行网关，如下：

接下来新建一个解决方案，方案名随意，喜欢就好，由于时间比较短，这里我简单的处理，不清楚的可以留言

新建Service.A，然后在其下新建控制台应用Service.A、Service.B、Service.C，新建类库Service.A.Service、Service.B.Service、Service.C.Service；

编辑Service.A.csporj、Service.B.csporj、Service.C.csporj，如下

将其中的引用包都复制过去，分别修改一下对应的Service，即其中的<ProjectReference Include="..\Service.A.Service\Service.A.Service.csproj" />，Service.A引用Service.A.Service，Service.B引用Service.B.Service

Service.C引用Service.C.Service;

类库Service.A.Service、Service.B.Service、Service.C.Service中都引用

<PackageReference Include="surging" Version="0.5.4" />

如图：

由于代码很多地方相识，以下我只说Service.A,和Service.A.Service；

Service.A 中新增Configs文件夹，下面添加log4net.config，log4net.config代码如下：

<log4net>

 <root>

 <level value="Error" />

 <!-- <appender-ref ref="RollingLogFileAppender" /> -->

 <appender-ref ref="ErrorRollingLogFileAppender" />

 </root>

 <appender name="ErrorRollingLogFileAppender" type="log4net.Appender.RollingFileAppender,log4net" LEVEL="ERROR">

 <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />

 <param name="File" value="c:\surging\Error\" />

 <param name="AppendToFile" value="true" />

 <param name="RollingStyle" value="Composite" />

 <param name="DatePattern" value="_yyyyMMddHH.TXT" />

 <param name="StaticLogFileName" value="false" />

 <param name="MaxSizeRollBackups" value="-1" />

 <param name="MaximumFileSize" value="5MB" />

 <layout type="log4net.Layout.PatternLayout,log4net">

  <param name="ConversionPattern" value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />

 </layout>

 <filter type="log4net.Filter.LevelRangeFilter">

  <param name="LevelMin" value="ERROR" />

  <param name="LevelMax" value="FATAL" />

 </filter>

 </appender>

</log4net>

然后新增cacheSettings.json其中Map:Properties下的value的值是redis地址

{ 
 "CachingSettings": [
  {
  "Id": "ddlCache",
  "Class": "Surging.Core.Caching.RedisCache.RedisContext,Surging.Core.Caching",
  "Properties": [
   {
   "Name": "appRuleFile",
   "Ref": "rule"
   },
   {
   "Name": "dataContextPool",
   "Ref": "ddls_sample",
   "Maps": [
    {
    "Name": "Redis",
    "Properties": [
    {
     "value": "172.17.0.2:6379::1"
     }
    ]
    },
    {
    "Name": "MemoryCache"
    }
   ]
   },
   {
   "Name": "defaultExpireTime",
   "value": "120"
   },
   {
   "Name": "connectTimeout",
   "Value": "120"
   },
   {
   "Name": "minSize",
   "Value": "1"

   },
   {
   "Name": "maxSize",
   "Value": "10"
   }
  ]
  }
 ]
}

新增eventBusSettings.json，其中的EventBusConnection对应的是RabbitMQ docker的地址

{
 "EventBusConnection": "172.17.0.3",
 "EventBusUserName": "guest",
 "EventBusPassword": "guest"
}

Program.cs的代码如下

using Autofac;
using Surging.Core.Codec.MessagePack;
using Surging.Core.Consul;
using Surging.Core.Consul.Configurations;
using Surging.Core.CPlatform;
using Surging.Core.CPlatform.Utilities;
using Surging.Core.DotNetty;
using Surging.Core.EventBusRabbitMQ;
using Surging.Core.Log4net;
using Surging.Core.ProxyGenerator;
using Surging.Core.ServiceHosting;
using Surging.Core.ServiceHosting.Internal.Implementation;
using System;
using System.Text;
namespace Service.A
{
 class Program
 {
  static void Main(string[] args)
  {
   NewMethod();
  }
  private static void NewMethod()

  {

   Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

   var host = new ServiceHostBuilder()

    .RegisterServices(builder =>

    {

     builder.AddMicroService(option =>

     {

      option.AddServiceRuntime();

      option.AddRelateService();

      //option.UseZooKeeperManager(new ConfigInfo("127.0.0.1:2181"));

      option.UseConsulManager(new ConfigInfo("172.17.0.4:8500"));

      option.UseDotNettyTransport();

      option.UseRabbitMQTransport();

      option.AddRabbitMQAdapt();

      //option.UseProtoBufferCodec();

      option.UseMessagePackCodec();

      builder.Register(p => new CPlatformContainer(ServiceLocator.Current));

     });

    })

    .SubscribeAt()

    .UseLog4net("Configs/log4net.config")

    //.UseServer("127.0.0.1", 98)

    //.UseServer("127.0.0.1", 98，“true”) //自动生成Token

    //.UseServer("127.0.0.1", 98，“123456789”) //固定密码Token

    .UseServer(options =>

    {

     options.Ip = "172.17.0.6";

     options.Port = 9990;

     options.Token = "True";

     options.ExecutionTimeoutInMilliseconds = 30000;

     options.MaxConcurrentRequests = 200;

     options.NotRelatedAssemblyFiles = "Centa.Agency.Application.DTO\\w*|StackExchange.Redis\\w*";

    })

    .UseProxy()

    .UseStartup<Startup>()

    .Build();

   using (host.Run())

   {
    Console.WriteLine($"服务端启动成功，{DateTime.Now}。");
   }
  }
 }
}

新增Startup.cs

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Surging.Core.Caching.Configurations;
using Surging.Core.CPlatform.Utilities;
using Surging.Core.EventBusRabbitMQ.Configurations;
using System;
namespace Service.A
{
 public class Startup

 {
  public Startup()
  {
   var config = new ConfigurationBuilder()

   .SetBasePath(AppContext.BaseDirectory);

   ConfigureEventBus(config);

   //ConfigureCache(config);

  }
  public IContainer ConfigureServices(ContainerBuilder builder)
  {
   var services = new ServiceCollection();
   ConfigureLogging(services);
   builder.Populate(services);
   ServiceLocator.Current = builder.Build();
   return ServiceLocator.Current;
  }
  public void Configure(IContainer app)
  {
   app.Resolve<ILoggerFactory>()
     .AddConsole((c, l) => (int)l >= 3);

  }

  #region 私有方法
  /// <summary>
  /// 配置日志服务
  /// </summary>
  /// <param name="services"></param>
  private void ConfigureLogging(IServiceCollection services)
  {
   services.AddLogging();
  }
 
  private static void ConfigureEventBus(IConfigurationBuilder build)

  {
   build

   .AddEventBusFile("eventBusSettings.json", optional: false);
  } 

  /// <summary>
  /// 配置缓存服务
  /// </summary>
  private void ConfigureCache(IConfigurationBuilder build)
  {
   build
    .AddCacheFile("cacheSettings.json", optional: false);
  }
  #endregion
 }
}

Service.A.Service 类库下新增AService.cs

using Surging.Core.ProxyGenerator;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace Service.A.Service

{
 public class AService:ProxyServiceBase,IAService

 {
  public Task<string> SayHello(string name)

  {
   return Task.FromResult($"{name} say : hello");
  }
 }
}

新增IAService.cs

using Surging.Core.CPlatform.Ioc;
using Surging.Core.CPlatform.Runtime.Server.Implementation.ServiceDiscovery.Attributes;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace Service.A.Service
{
 [ServiceBundle("api/{Service}")]
 public interface IAService : IServiceKey
 {
  Task<string> SayHello(string name); 
 }
}

其他类库和服务与以上代码基本无二，这里不在赘述。不清楚的可以留言

所有代码都处理好后，在Service.A、Service.B、Service.C项目上右键新增docker支持文件，然后会生成一下文件

修改其中的docker-compose.yml

version: ''3''

 

services:

 service.a:

 image: servicea

 ports:

  - "127.0.0.1:9990:9990"

 network_mode: "bridge"

 build:

  context: .

  dockerfile: Service.A/Dockerfile

 

 service.b:

 image: serviceb

 ports:

  - "127.0.0.1:9991:9991"

 network_mode: "bridge"

 build:

  context: .

  dockerfile: Service.B/Dockerfile

 

 service.c:

 image: servicec

 ports:

  - "127.0.0.1:9992:9992"

 network_mode: "bridge"

 build:

  context: .

  dockerfile: Service.C/Dockerfile

 

 webapplication1:

 image: webapplication1

 build:

  context: .

  dockerfile: ../WebApplication1/Dockerfile

然后选择docker运行即可

最后访问surging网关，即可看见效果

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

您可能感兴趣的文章:
  • 快速了解如何在.NETCORE中使用Generic-Host建立主机
  • .NETCore Docker实现容器化与私有镜像仓库管理
  • .NetCore利用BlockingCollection实现简易消息队列
  • .NetCore获取Json和Xml格式的配置信息
  • Asp.NetCore1.1版本去掉project.json后如何打包生成跨平台包
  • .NetCore实现上传多文件的示例详解
  • .NETCore添加区域Area代码实例解析

.NetCore 发布到 Centos docker

.NetCore 发布到 Centos docker

     【搭建环境】

     系统：CentOS 7.0    容器：Docker 1.13.1    .Net Core 版本:.NET Core 2.2     工具：putty、filezilla 等.

一、安装 docker

1. 安装 docker

　　　　yum install docker            ps: 更新 docker 用 yum update

2. 启动 docker 服务

　　　　systemctl  start docker.service

3. 配置开机启动

　　　　systemctl enable docker.service

　　　　4. 配置 docker 加速器

　　　　　 配置 docker 加速最快的方法直接修改 /etc/docker/daemon.json 下的配置信息为:　　　　　　

          { 
             "registry-mirrors": ["https://d8b3zdiw.mirror.aliyuncs.com"] 
           }

5. 在终端重启 docker 服务　　　　　　

sudo systemctl daemon-reload 
        sudo systemctl restart docker

二、部署.NetCore 应用到 Docker

1. 新建一个 ASP.NET Core 2.2 项目，在 Windows 下发布运行成功

2. 添加 docker 支持，选择 Linux（或在添加项目时勾选启用 docker 支持）

3. 编写 DockerFile, 并设置文件属性：始终复制　　　　

FROM microsoft/dotnet:2.2-aspnetcore-runtime    
        COPY  . /apiweb    
        WORKDIR /apiweb
        EXPOSE 80 
        ENTRYPOINT ["dotnet", "ApiWeb.dll"]

 

      构建Dockerfile 注释
      ① FROM指定基础镜像，这里统一使用microsoft/dotnet（：tag）Tag是一个标签，指定一个版本或者最近的版本（即latest）
      ② COPY拷贝发布文件到本地的/ apiweb /的路径下，供容器使用
      ③ WORKDIR 指定容器的工作目录
      ④ EXPOSE 指定容器的端口（注意，不是服务器访问到程序的端口） 
      ⑤ ENTRYPOINT 执行交互命令，使用CMD亦可赛艇，但是注意两者都是执行完整命令的话，是会相互覆盖的，只有最后一个有效。

4. 发布项目

5. 将 Dockerfile 文件复制到发布成功的目录，并利用 ftp 工具全部上传到服务器

　　

6. 构建 Docker 镜像

①. 进入到发布文件目录（Dockerfile 文件所在目录）

　　cd  /home/wwwroot/apiweb

②. 拉取基础镜像

docker pull microsoft/dotnet:2.2-aspnetcore-runtime

③. 执行命令创建镜像 ，注意最后面有个.

docker build -t apiweb .

apiweb 是创建镜像的名称，这个命令会根据当前目录下 dockerfile 配置文件，进行打包。运行查看镜像 docker images

④. 创建容器，其中前一个 apiweb 是容器名 后一个 apiweb 是上一步的镜像名。

--name：指定容器名称；

-p：指定容器端口，是进行宿主和容器之间端口的映射，（-p 宿主端口：容器端口）；

-d：指定容器后台运行，这样容器就会一直运行，即使关掉终端窗口。

docker run --name=apiweb -p 80:80 -d  apiweb
            或者
            docker run --name=apiweb -p 宿主ip:5000:80 -d  apiweb

出现一长串字符串，便是表示容器运行成功。

7. 验证访问

直接通过浏览器访问即可（宿主 ip + 端口号）。

 

            Docker常用命令：
            docker -v / version /info         查看docker版本信息
            docker images                     查看所有镜像
            docker ps                         查看所有正在运行的容器
            docker ps -a                      查看所有容器
            docker rmi+镜像ID                 删除某个镜像
            docker stop+容器ID                停止某个容器
            docker start+容器ID               启动某个容器
            docker restart+容器ID             重启某个容器
            docker rm+容器ID                  删除某个容器
            docker rmi $(docker images -q)    删除所有镜像
            docker rm $(docker ps -a -q)      删除所有容器
            docker logs +容器ID               查看容器日志信息找原因
            netstat -tanlp                    查看端口
            kill+端口                         杀死某个端口
            docker search mysql               镜像检索
            docker pull mysql                 镜像下载
            …

 

 

 

 

 

.netcore 项目 docker 化，以及 docker 之间通信

.netcore 项目 docker 化，以及 docker 之间通信

简言：

　　最近刚完成公司的新系统，系统使用的是微服务架构，由于领导说要将服务 docker 化。下面将我的研究结果分享出来，如若有错误的地方，还请各位大佬多多指点。

目录： 　　

  1. 什么是 docker？
  2. 使用 docker 有什么好处？
  3. docker 的使用和 docker 之间的通信

1. 什么是 docker？　　

　　Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux 或 Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱（沙箱：一个虚拟系统程序）机制，相互之间不会有任何接口。也就是说，我们可以用 docker 把我们系统和系统所需要的环境以及依赖的软件都打包成一个安装包，然后可以安装到 linux 或 windows 上。

　　关于 docker 三个核心概念：

  1. 仓库：存放镜像的仓库
  2. 镜像：类似于系统镜像
  3. 容器：镜像的实例

　　小时候我特喜欢去河边沙滩上玩耍，一般都带着一个袋子，里面装了许多形状的摸具。把沙子打湿之后，拿模具一按，一个形状块就有了，记得小时候最喜欢就就是五角星的模具。偶尔有调皮捣蛋的小伙伴会把我做的形状给弄散，当时我不哭也不恼，拿起模具迅速就再做出一个来，气的他没话可说。有时候突发奇想，想到一种新的形状，然后把它做出来之后，我就会把它记下来，然后回家立马弄个新形状的模具出来。

　　在这里，我把 docker 比喻沙滩，而我的袋子就好比仓库，而模具就是镜像，容器自然就是拿模具做出来的形状块。而真正的程序开发中，你可以把镜像理解为我们做的系统的安装包，容器理解为安装后的运行的系统。以上都是我自己个人对 docker 的理解，如果哪位大佬觉得不合理，还请多交流。

2. 使用 docker 有什么好处？

　　以往的系统开发有这么一个问题，在开发人员的电脑上开发的系统，跑到其他人的电脑上或者是服务器上，需要配环境、安装一大堆的软件。不同的操作系统安装方法还有可能不一样。等安装完了之后，一启动发现一大堆的报错，而再自己的电脑上跑的好好的（这里我遇到过）。还有就是，有可能公司的文件服务器比较悠闲，运行多个系统又怕干扰（这里可以使用虚拟机，但性能不是很好）。

　　而使用 docker，可以把开发好的系统以及系统所依赖的东西，打包成镜像，然后可以发布到支持 docker 的平台。并且 docker 能够确保每个容器都拥有自己的资源，并且和其他容器是隔离的。你可以用不同的容器来运行使用不同堆栈的应用程序等等（docker 好处实在太多，我就不一一列举了）。

3.docker 的使用和 docker 之间的通信

　　怎么安装 docker，去哪下载等等我就不讲了，大家都不是编程小白。

　　第一步：首先下载 dotnet core 镜像：docker run -it microsoft/dotnet ，这个是启动命令，如果镜像不存在则会自动下载。

　　第二步：创建项目

　　　　　1. 首先创建一个 userservice 的 web api core 项目并创建一个 usercontroller , 并修改 Program 类中的 CreateWebHostBuilder　　

[Route("api/[controller]")]
    [ApiController]
    public class UserController : ControllerBase
    {
        public IActionResult Get()
        {
            return Ok(new[] { new {Id=1,Name="li" }, new { Id = 2, Name = "lisi" } });
        }
    }　　　　　　

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseUrls("http://*:5000")
.UseStartup<Startup>();

　　　　　2. 其次再创建一个 emailservice 的 web  api core 项目，并创建一个 emailcontroller，在修改 Program 类中的 CreateWebHostBuilder

[Route("api/[controller]")]
    [ApiController]
    public class EmailController : ControllerBase
    {
        public IConfiguration Configuration { get; set; }
        public EmailController(IConfiguration Configuration)
        {
            this.Configuration = Configuration;
        }
        public async Task<IActionResult> Post(long userId)
        {
            using (HttpClient client = new HttpClient())
            {
                var content = await client.GetAsync("http://user-service:5000/api/user");　　　　//这里的user-service是docker的link机制，下面会讲
                return new JsonResult(new { users= await content.Content.ReadAsStringAsync() ,constr= Configuration["databaseurl"] });
            }

        }
    }
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseUrls("http://*:4001")
                .UseStartup<Startup>();

　　　　　最后，再分别发布下项目。

　　第三步：编写 Dockerfile

　　　 分别在publish 文件夹同级建一个 Dockerfile。有关 dockerfile 里面的指令解释，请阅读:https://www.cnblogs.com/linjiqin/p/8735230.html

　　1. 首先编写 emialservic 的 dockerfile：　　　　

FROM microsoft/dotnet　　　　　#本镜像继承自哪个镜像
COPY publish /publish   　　　# 拷贝当前文件夹下的publish文件夹到镜像中的根目录下的publish文件夹
WORKDIR /publish　　　　　　　　#设置镜像的工作目录
EXPOSE 4001/tcp   　　　　　　# 暴露 tcp连接的4001端口
CMD ["dotnet","EmailService.dll","--databaseurl=132456789"]　　　　#设置命令，以及一些参数

 　　2. 编写 userservice 的 dockerfile:　　

FROM microsoft/dotnet　　
COPY publish /publish   
WORKDIR /publish
EXPOSE 5000/tcp   
CMD ["dotnet","UserService.dll"]

 　　

　　第四步：分别在目录下运行 cmd，然后输入：docker build -t dotnet/emailservice . 和 docker build -t dotnet/userservice .(注意后面的。号)，然后镜像就制作完成了。

　　第五步：因为 emailservice 依赖于 userservice，所以 emailservice 和 userservice 要进行通信。

　　　　　　docker 通信有三种方式：

      1. 通过 docker 容器 ip 加端口号。因为 docker 容器重启之后 ip 地址会改变，不方便迁移。所以不推荐使用。(除非使用固定 ip)
      2. 通过映射到主机的端口号。这种方式可以，但是会占用主机端口号
      3. docker 的 link 机制。docker 的 link 机制可以通过一个 name 来和另一个容器通信，link 机制方便了容器去发现其它的容器并且可以安全的传递一些连接信息给其它的容器。

　　我这采用 link 机制，首先编写一个 docker-compose.yml 文件　　　　　　

version: ''3''　　#采用哪个docker-compose的版本
services:　　　　#服务集合
  user-service:　　　　#服务名，name
    image: dotnet/userservice　　　　#启动哪个镜像
    ports:　　　　　　　　#端口映射设置，这里是主机的6001端口映射到docker里的5000端口
    - "6001:5000"
  email-service:　　　　#服务名，name：
    image: dotnet/emailservice　　#启动哪个镜像
    ports:　　　　　　　　　　#端口映射设置，这里是主机的4001端口映射到docker的4001端口
    - "4001:4001"
    links:　　　　　　　　#依赖哪个服务
    - "user-service"
#docker-compose 指令详解：https://www.cnblogs.com/freefei/p/5311294.html

　　

　　然后 emailservice 可以通过：http://user-service:5000 端口来访问 userservice 服务 (我在前面的代码中已经设置好了，所以就不用了)。运行命令：docker-compose up，就行了

 　　

结果图如下：（我这里为了显示结果，然后映射到主机端口。在微服务中只需要把网关的端口映射出来就行）

　　

 

 

 　　　　

.netcore2.0 docker 发布实践

.netcore2.0 docker 发布实践

之前只在winserver2008上通过iis发布过.netcore的项目，这几天突发奇想决定试试再centos上发布下看看，也体验体验.netcore的跨平台，由于是发布在我自己的服务器上，不想把环境弄脏了，所以决定保险一点用docker来做第一次发布测试，(不得不吐槽netcore的发布版docker镜像真大的无法忍啊)具体过程如下：

1，首先准备发布包，这里我用的不是便携发布包（一来太大，二来还是太大）,使用dotnet publish命令打包待发布项目，在bin/debug/.netcoreapp2.0/publish(目录也可能是release)中获取发布文件

2，准备Dockerfile镜像构建文件，文件内容如下：

FROM microsoft/aspnetcore-build:latest

WORKDIR /app

EXPOSE 80

COPY ./ ./

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

PS：这里有个坑，我docker也是个菜鸟，在copy命令时犯错了，copy命令第一个参数指的是原路径，这里的原路径是相对于dockerfile文件所在目录为根目录的，比如我上面的参数“./”指的就是当前目录，第二个参数指的是docker镜像中的目录，这里的目录都是以WORKDIR命令标记的目录为跟目录的，所以“./”在镜像中实际是指“/app”目录，如果你要把文件直接复制到docker镜像工作目录，直接用上面的命令就可以了，如果你要把文件复制到docker镜像中的某一个新建目录中那么需要改变第二个参数，例如“./publish”(镜像中的目录就是./app/publish),这时ENTRYPOINT命令需要修改为["dotnet", "./publish/ServiceDepartmentAugustMember.dll"]，不然是找不到文件的。

3，将编辑好的dockerfile文件放入发布包，然后一并上传到docker所在服务器

4，ssh登陆docker所在服务器，进入发布包所在目录，使用命令：

docker build -t docker.io/xxx:1.0

xxx(这里一般写的是自己的docker登陆用户名)/testnetcore(仓库名）                                            

1.0(镜像版本号，可以写英文代号如lastest)

这么写的docker镜像的tag标签的原因是方便之后把个人镜像push到docker.io上去，如果没有push的需要那么可以直接写 仓库名：版本号

5，因为dockerfile文件比较简单，所以如果报错的话，就是copy路径的问题

6，构建完成以后，可以用docker images 查看下镜像是不是正常生成了，如下：


 

7，使用命令根据镜像开启容器：

docker run --name winter_1 -p 8080:80 docker.io/rokeyyan/winter：1.0

正常情况下会显示下面的内容：


 

8，如果想docker进程挂在后台，那就ctrl+c以后重新用 docker start winter_1 重新启动容器了

9，如果以上都正常，那就用IP:8080愉快的访问你的.netcore应用吧！

关于.net core 发布到docker和netcore发布到docker的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于.netcore 使用surging框架发布到docker、.NetCore 发布到 Centos docker、.netcore 项目 docker 化，以及 docker 之间通信、.netcore2.0 docker 发布实践等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇Docker 网络之端口绑定（docker绑定多个端口）

下一篇Docker学习笔记_创建和使用Centos容器（创建docker容器命令）

相关文章