系列目录：

本系列分为项目集成、项目部署、架构演进三个方向，后续会根据情况调整文章目录。

开源地址：https://github.com/cyq1162/Taurus.MVC

本系列第一篇：Taurus.MVC V3.0.3 微服务开源框架发布：让.NET 架构在大并发的演进过程更简单。

Taurus.MVC 微服务框架 入门开发教程：项目集成：1、服务端：注册中心、网关（提供可运行程序下载）。

Taurus.MVC 微服务框架 入门开发教程：项目集成：2、客户端：ASP.NET Core（C#）项目集成：应用中心。

Taurus.MVC 微服务框架 入门开发教程：项目集成：3、客户端：其它编程语言项目集成：应用中心。

Taurus.MVC 微服务框架 入门开发教程：项目集成：4、默认安全认证与自定义安全认证。

Taurus.MVC 微服务框架 入门开发教程：项目集成：5、统一的日志管理。

Taurus.MVC 微服务框架 入门开发教程：项目集成：6、微服务的二次开发。

Taurus.MVC 微服务框架 入门开发教程：项目部署：1、微服务应用程序常规部署实现多开，节点扩容。

Taurus.MVC 微服务框架 入门开发教程：项目部署：2、让Kestrel支持绑定多个域名转发，替代Ngnix使用。

Taurus.MVC 微服务框架 入门开发教程：项目部署：3、微服务应用程序版本升级：全站升级和局部模块升级。

Taurus.MVC 微服务框架 入门开发教程：项目部署：4、微服务应用程序发布到Docker部署（上）。

Taurus.MVC 微服务框架 入门开发教程：项目部署：5、微服务应用程序发布到Docker部署（下）。

Taurus.MVC 微服务框架 入门开发教程：项目部署：6、微服务应用程序Docker部署实现多开。

Taurus.MVC 微服务框架 入门开发教程：架构演进：1、从单应用程序简单过渡到负载均衡。

Taurus.MVC 微服务框架 入门开发教程：架构演进：2、负载均到模块拆分负载。

Taurus.MVC 微服务框架 入门开发教程：架构演进：3、模块拆分负载到多级负载均衡。

Taurus.MVC 微服务框架 入门开发教程：运行示例：https://github.com/cyq1162/Taurus.MVC.MicroService.Demo

前言：

对于Taurus.MVC 微服务应用程序而言，程序需要在启动时，将自身的可访问地址告诉注册中心。

而通过Docker发布时，其访问路径（IP）或端口（被映射）改变了，而且是后期在部署时才变化的。

那如果在程序启动之时，就获知自身的可访问地址呢？

在：Taurus.MVC 微服务框架 入门开发教程：项目部署：1、微服务应用程序常规部署实现多开，节点扩容。一文中，

通过本地的配置随机端口，实现节点的多开。

但对于部署到Docker中的而言，走的是镜像的端口映射，因此，情况有所不同。

好在，发现Docker可以在增加节点时设置环境变量。

因此，可将映射后的地址或端口，通过环境变量注射进来，在应用程序中预先读取即可。

下面是经过优化，同时兼容两者的示例代码：

1、Net5、NET6、NET7….系列：Program.cs

using CYQ.Data;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using System.Net;
using System.Net.Sockets;
using Taurus.Core;

var builder = WebApplication.CreateBuilder(args);
string host = AppConfig.GetApp("Host");
string runUrl = MicroService.Config.AppRunUrl;
if (host.Contains(":0"))//随机端口
{
    TcpListener tl = new TcpListener(IPAddress.Any, 0);
    tl.Start();
    int port = ((IPEndPoint)tl.LocalEndpoint).Port;//获取随机可用端口
    tl.Stop();
    host = host.Replace(":0", ":" + port);
    if (runUrl.Contains(":0"))
    {
        MicroService.Config.AppRunUrl = runUrl.Replace(":0", ":" + port);//设置启动路径
    }
}
else
{
    //判断是否Docker部署，通过环境变量传递当前运行地址，或端口：
    string dockerHost = Environment.GetEnvironmentVariable("DockerHost");//跨服务器配置完整路径host:port
    if (!string.IsNullOrEmpty(dockerHost))
    {
        MicroService.Config.AppRunUrl = host;
    }
    else
    {
         // Docker部署：设置映射后的地址
                //判断是否Docker部署，通过环境变量传递当前运行地址，或端口：
                string dockerUrl = Environment.GetEnvironmentVariable("DockerUrl");//跨服务器配置完整路径：http://host:port
                if (!string.IsNullOrEmpty(dockerUrl))
                {
                    MicroService.Config.AppRunUrl = dockerUrl;
                }
                else
                {
                    string dockerHost = Environment.GetEnvironmentVariable("DockerHost");//本机服务器IP，仅配置端口即可。
                    string dockerPort = Environment.GetEnvironmentVariable("DockerPort");//本机服务器，仅配置端口即可。

                    if (!string.IsNullOrEmpty(dockerHost) || !string.IsNullOrEmpty(dockerPort))
                    {
                        string http = "http";
                        if (!string.IsNullOrEmpty(runUrl))
                        {
                            Uri uri = new Uri(runUrl);
                            http = uri.Scheme;
                            if (string.IsNullOrEmpty(dockerHost))
                            {
                                dockerHost = uri.Host;
                            }
                            if (string.IsNullOrEmpty(dockerPort))
                            {
                                dockerPort = uri.Port.ToString();
                            }
                        }
                        if (string.IsNullOrEmpty(dockerHost))
                        {
                            dockerHost = "localhost";
                        }
                        if (string.IsNullOrEmpty(dockerHost))
                        {
                            dockerHost = "80";
                        }
                        MicroService.Config.AppRunUrl = http + "://" + dockerHost + ":" + dockerPort;
                    }
                }
    }
}
builder.WebHost.UseUrls(host);
builder.Services.AddHttpContext();
builder.Services.Configure<KestrelServerOptions>(x => x.AllowSynchronousIO = true).Configure<IISServerOptions>(x => x.AllowSynchronousIO = true);

var app = builder.Build();
app.UseHttpContext();
app.UseTaurusMvc(app.Environment);
app.Run();

2、ASP.NET 2.N到3.N系列：Program.cs

using System;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using CYQ.Data;
using System.Net.Sockets;
using System.Net;
using Taurus.Core;
using System.Net.Http;

namespace Taurus.View
{
    public class Program
    {
        public static void Main(string[] args)
        {
            try
            {
                BuildWebHost(args).Run();
            }
            catch (Exception err)
            {
                Console.WriteLine(err.Message);
                Console.Read();
            }
        }

        public static IWebHost BuildWebHost(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                .UseStartup<Startup>()
                .UseUrls(GetUrl())
                .Build();
        public static string GetUrl()
        {
            //ServicePointManager.DefaultConnectionLimit = 10000;
            //System.Threading.ThreadPool.SetMaxThreads(1000, 1000);
            //HttpClientHandler. = 10000;
           



            string host = AppConfig.GetApp("Host");
            string runUrl = MicroService.Config.AppRunUrl;
            if (host.Contains(":0"))//常规部署随机端口
            {
                TcpListener tl = new TcpListener(IPAddress.Any, 0);
                tl.Start();
                int port = ((IPEndPoint)tl.LocalEndpoint).Port;//获取随机可用端口
                tl.Stop();
                host = host.Replace(":0", ":" + port);
                if (runUrl.Contains(":0"))
                {
                    runUrl = runUrl.Replace(":0", ":" + port);//设置启动路径
                }
                if (runUrl.Contains("localhost"))
                {
                    System.Net.IPAddress[] addressList = Dns.GetHostEntry(Dns.GetHostName()).AddressList;
                    foreach (var address in addressList)
                    {
                        if (!address.ToString().Contains(":"))
                        {
                            runUrl = runUrl.Replace("localhost", address.ToString());//设置启动路径
                            break;
                        }
                    }

                }
                MicroService.Config.AppRunUrl = runUrl;

            }
            else 
            {
                // Docker部署：设置映射后的地址
                //判断是否Docker部署，通过环境变量传递当前运行地址，或端口：
                string dockerUrl = Environment.GetEnvironmentVariable("DockerUrl");//跨服务器配置完整路径：http://host:port
                if (!string.IsNullOrEmpty(dockerUrl))
                {
                    MicroService.Config.AppRunUrl = dockerUrl;
                }
                else
                {
                    string dockerHost = Environment.GetEnvironmentVariable("DockerHost");//本机服务器IP，仅配置端口即可。
                    string dockerPort = Environment.GetEnvironmentVariable("DockerPort");//本机服务器，仅配置端口即可。

                    if (!string.IsNullOrEmpty(dockerHost) || !string.IsNullOrEmpty(dockerPort))
                    {
                        string http = "http";
                        if (!string.IsNullOrEmpty(runUrl))
                        {
                            Uri uri = new Uri(runUrl);
                            http = uri.Scheme;
                            if (string.IsNullOrEmpty(dockerHost))
                            {
                                dockerHost = uri.Host;
                            }
                            if (string.IsNullOrEmpty(dockerPort))
                            {
                                dockerPort = uri.Port.ToString();
                            }
                        }
                        if (string.IsNullOrEmpty(dockerHost))
                        {
                            dockerHost = "localhost";
                        }
                        if (string.IsNullOrEmpty(dockerHost))
                        {
                            dockerHost = "80";
                        }
                        MicroService.Config.AppRunUrl = http + "://" + dockerHost + ":" + dockerPort;
                    }
                }
            }
            //string url = AppConfig.GetApp("Host", host);//"[http|https]://*:8888"
            return host;
        }
    }
}

后续，可以创建增映像的容器时，补上环境变量即可，如图：

 也可以通过命令行创建容器时，添加环境变量：

docker run -d -p 8001:80 --name=my8001 ---env dockport=8001 regcenter   //创建容器，容器外对运行端口是8001

添加多个环境变量：

docker run -d -p 8001:80 --name=my8001 ---env dockhost=192.168.1.88 ---env dockport=8001 regcenter   //创建容器，容器外对运行端口是8001

总结：

对于微服务应用程序，需要做的，就是将自身的运行地址，在程序启动之初，就发送到注册中心。

而内部启动时候核心即时读取：MicroService.Config.AppRunUrl 这个属性，其值需要在发送之前设置好即可。