xml地图|网站地图|网站标签 [设为首页] [加入收藏]
polly微服务故障处理库,API网关组件Ocelot
分类:编程

熔断、降级:

  • defaultdict函数将所有值初始化为指定类型

介绍:

熔断:熔断就是我们常说的“保险丝”,意为当服务出现某些状况时,切断服务,从而防止应用程序不断地常识执行可能会失败的操作造成系统的“雪崩”,或者大量的超时等待导致系统卡死等情况,很多地方也将其成为“过载保护”。

Ocelot是一个.NET API网关。该项目针对的是使用.NET运行微服务/面向服务架构的人员,他们需要一个统一的入口进入他们的系统。然而,它可以处理任何说HTTP并在ASP.NET Core支持的任何平台上运行的任何东西。

降级:降级的目的就是当某个服务提供者发生故障的时候,向调用方返回一个替代响应或者错误响应。

from collections import defaultdict
a = defaultdict(int)
a[0]

''

Ocelot是一组按特定顺序的中间件,Ocelot操纵HttpRequest对象进入由其配置指定的状态,直到它到达请求生成器中间件,在该中间件中创建HttpRequestMessage对象,该对象用于向下游服务发出请求。提出请求的中间件是Ocelot管道中的最后一件事。它不叫下一个中间件。来自下游服务的响应存储在每个请求作用域存储库中,并在请求返回到Ocelot管道时进行恢复。有一件中间件将HttpResponseMessage映射到HttpResponse对象上,并返回给客户端。这基本上是与其他一些功能。

介绍:

POLLY是一个.NET回弹和瞬态故障处理库,它允许开发人员以流畅和线程安全的方式表达诸如重试、断路器、超时、隔板隔离和回退等策略。github官方解释嘿嘿。

Polly以.NET Standard 1.1(覆盖范围:.NET Framework 4.5-4.6.1,.NET Core 1.0,Mono,Xamarin,UWP,WP8.1 +)

            .NET Standard 2.0+(覆盖范围:.NET Framework 4.6.1, .NET Core 2.0+以及后来的Mono,Xamarin和UWP目标)

  • python按照引用传递

Ocelot只能用于.NET Core,并且目前已经构建到netstandard2.0。所有下面 我们使用.NET Core 2.1做演示。

安装:

首先当然是创建一个控制台项目,然后通过NuGet安装:

Install-Package Polly

图片 1

出现以上界面就说明你已经安装了最新的版本到你的项目;

创建一个基本示例:

首先我们创建一个.NET Core 2.1空项目。

当然我们还是要先引用的拉, Nuget 命令行: Install-Package Ocelot

配置:添加一个json文件实现最基本的配置:

{
    "ReRoutes": [],
    "GlobalConfiguration": {
        "BaseUrl": "urladdress"
    }
}

这里最重要的是BaseUrl。Ocelot需要知道它正在运行的URL,以便执行标题查找和替换以及某些管理配置。当设置这个URL时,它应该是客户端将看到的Ocelot运行的外部URL。

然后我们将刚才的配置文件加入到ASP.NET Core Configuration:Program.cs

图片 2图片 3

 public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
            WebHost.CreateDefaultBuilder(args)
                   .ConfigureAppConfiguration((hostingContext, builder) =>
                   {
                       builder
                       .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
                       .AddJsonFile("ocelot.json");
                   })
                .UseStartup<Startup>();

View Code

最后在添加服务以及设置中间件:Startup.cs

图片 4图片 5

 public void ConfigureServices(IServiceCollection services)
        {
            services.AddOcelot();//添加ocelot服务
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            app.UseOcelot().Wait();//设置所有的Ocelot中间件
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Hello World!");
            });
        }
    }

View Code

 这些就是基本的所需编程代码。

策略介绍:

polly通过官方介绍我们可以知道有7种恢复策略,先不管会不会,先列出来再说哈哈:

    重试策略(Retry):许多故障是短暂的,并且在短暂的延迟后可能会自我纠正。允许我们做的是能够自动配置重试机制

    断路器(Circuit-breaker):当一个系统严重挣扎时,快速失败优于让用户/呼叫者等待。 说白了就是应该优先直接返回失败,而不是一直让用户等待。保护故障系统免受过载可以帮助恢复。

    超时(Timeout):超时策略针对的前置条件是超过一定的等待时间,想要得到成功的结果是不可能的,保证调用者不必等待超时。

 

    隔板隔离(Bulkhead Isolation):隔板隔离针对的前置条件是当进程出现故障时,多个失败一直在主机中对资源(例如线程/ CPU)一直占用。下游系统故障也可能导致上游失败。这两个风险都将造成严重的后果。都说一粒老鼠子屎搅浑一锅粥,而Polly则将受管制的操作限制在固定的资源池中,免其他资源受其影响。

 

    缓存(Cache):就是一些请求,会把数据缓存起来,然后在持续一段时间内,直接从缓存中取。

 

    回退(Fallback):操作仍然会失败,也就是说当发生这样的事情时我们打算做什么。也就是说定义失败返回操作。我们在使用时就是所说的降级。

 

    策略包装(PolicyWrap):不同的故障需要不同的策略 弹性意味着使用组合。

a = [1,2,3]
b = a
a.append(4)
b

[1, 2, 3, 4]

配置文件的详细分析:

Ocelot的主要功能是收取HTTP请求并将它们转发到下游服务。目前以另一个http请求的形式出现。Ocelot描述了将一个请求作为ReRoute路由到另一个请求。为了在Ocelot中获得任何工作,您需要在配置中设置ReRoute。

说道这里我们补充一下刚才写的json文件的两个根节点:ReRoutes和GlobalConfiguration。

    ReRoutes:是一个数组,其中的每一个元素代表了一个路由,我们可以针对每一个路由进行以上功能配置,告诉Ocelot如何处理上游请求的对象。

    GlobalConfiguration:全局配置,可以适当的节约配置,比如baseurl节点,服务发现配置。

这样我们就实现了通过配置文件可以完成对Ocelot的功能配置:路由、服务聚合、服务发现、认证、鉴权、限流、熔断、缓存、Header头传递等。

配置一个示例:下面这个配置信息就是将用户的请求 /ProductService/1 转发到 localhost:8001/api/Test/1

图片 6图片 7

{
  "ReRoutes": [
    {
      "DownstreamPathTemplate": "/api/Test/{postId}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "127.0.0.1",
          "Port": 8001
        }
      ],
      "UpstreamPathTemplate": "/ProductService/{postId}",
      "UpstreamHttpMethod": [ "Get", "Delete" ]
    }
  ],
  "GlobalConfiguration": {
   // "BaseUrl": "http://127.0.0.1:8887/"
  }
}

View Code

  • DownstreamPathTemplate:下游方位url路径
  • DownstreamScheme:下游服务http schema
  • DownstreamHostAndPorts:下游服务的地址,如果使用LoadBalancer的话这里可以填多项
  • UpstreamPathTemplate: 上游也就是用户输入的请求Url模板
  • UpstreamHttpMethod: 上游请求http方法,可使用数组:Get ,Delete等

好了这样就实现了一个基本的Ocelot网关的转发示例。

下面让我们来看一下效果吧:

首先我们运行起来webapi项目发布在8001端口。然后访问地址是:

我们看到的结果是:

图片 8

然后我们启动我们的网关服务;发布在端口8888下,根据以上配置我们可以看到方位地址为:

然后同样的请求结果是:

图片 9

这样我们就实现使用统一网关来访问不同的地址,以便我们以后实现微服务的分发部署,虽然是不是多个接口,但是我们给上游访问还是提供一个接口,我们内部实现访问该访问那个接口。

至于具体怎发布也可参考这篇文章:

使用步骤:

polly一般分为三步进行:

  • 定义条件: 定义你要处理的 错误异常/返回结果

  • 定义处理方式 : 重试,熔断,回退

  • 执行

定义条件:    

.Handle<ExceptionType>():限定条件的单个异常Policy;

.Handle<ExceptionType>(ex => ex.Number == 10):具有条件的单个异常类型。

.Handle<HttpRequestException>()
.Or<OperationCanceledException>():多个异常类型,当然他也可以变成具有条件的多个异常类型,类似于单个操作。

定义返回结果的条件:

.HandleResult<HttpResponseMessage>(r => r.StatusCode == HttpStatusCode.NotFound):用条件处理返回值,处理单个返回值。

.HandleResult<HttpResponseMessage>(r => r.StatusCode == HttpStatusCode.InternalServerError)
.OrResult<HttpResponseMessage>(r => r.StatusCode == HttpStatusCode.BadGateway):处理多个返回值。

 指定策略(重试):

.Retry():重试一次。

.Retry(3):重试三次,修改数值即可定义自己想使用的次数。

.Retry(3, (exception, retryCount) =>
    {
        // do something 
    }):重试多次,在每次重试都执行一个操作,参数为:当前异常和重试计数。

.Retry(3, (exception, retryCount, context) =>
    {
        // do something 
    }):重试多次,在每次重试都执行一个操作,参数为:当前异常,重试计数和上下文

.RetryForever():永远重试直到成功,同时也也有重试的相同扩展,可以写参数。

.WaitAndRetry(new[]
  {
    TimeSpan.FromSeconds(1),
    TimeSpan.FromSeconds(2),
    TimeSpan.FromSeconds(3)
  }):等待并重试,就是在每个重试的时候需要等待指定的执行时间,同样有相同扩展,可以在每个重试调用一个操作。

.WaitAndRetryForever(retryAttempt => 
 TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
    ):等待和重试永远(直到成功)

  指定策略(熔断):

.CircuitBreaker(2, TimeSpan.FromMinutes(1)):在指定数量的连续异常之后中断开。这里就不做过多解释了。

 指定策略(降级):回退

.Fallback<UserAvatar>(UserAvatar.Blank):如果执行错误,则提供替代值,就是出现错误,定义一个返回值给他

.Fallback<UserAvatar>(() => UserAvatar.GetRandomAvatar()) :定义一个方法给他,该方法代替提供值。

执行: 

.Execute(() => DoSomething()):执行一项方法

执行通过任意上下文数据的操作:

var policy = Policy
    .Handle<SomeExceptionType>()
    .Retry(3, (exception, retryCount, context) =>
    {
        var methodThatRaisedException = context["methodName"];
        Log(exception, methodThatRaisedException);
    });

policy.Execute(
    () => DoSomething(),
    new Dictionary<string, object>() {{ "methodName", "some method" }}
);
  • isinstance函数检查对象是否为某个特定的类型

路由小知识:

UpstreamHost=>"UpstreamHost": "baidu.com":上游主机

    此功能允许您基于上游主机进行ReRoutes。这通过查看客户端使用的主机头来工作,然后将其用作我们用来识别ReRoute的信息的一部分。这样就是显示了只有在主机头值为baidu.com时才会匹配。

Priority=> "Priority": 0:优先级

    此功能设置访问路由的优先级,假设在同一个路由下有多个路由,会根据优先级匹配优先级最高的,0是最低的。

Dynamic Routing:动态路由

    这个主要是为了服务发现而实现的,在这种模式下,Ocelot将使用上游路径的第一个分段来查找服务发现提供商的下游服务。官网给出的大概配置效果:

图片 10图片 11

{
    "ReRoutes": [],
    "Aggregates": [],
    "GlobalConfiguration": {
        "RequestIdKey": null,
        "ServiceDiscoveryProvider": {
            "Host": "localhost",
            "Port": 8510,
            "Type": null,
            "Token": null,
            "ConfigurationKey": null
        },
        "RateLimitOptions": {
            "ClientIdHeader": "ClientId",
            "QuotaExceededMessage": null,
            "RateLimitCounterPrefix": "ocelot",
            "DisableRateLimitHeaders": false,
            "HttpStatusCode": 429
        },
        "QoSOptions": {
            "ExceptionsAllowedBeforeBreaking": 0,
            "DurationOfBreak": 0,
            "TimeoutValue": 0
        },
        "BaseUrl": null,
            "LoadBalancerOptions": {
            "Type": "LeastConnection",
            "Key": null,
            "Expiry": 0
        },
        "DownstreamScheme": "http",
        "HttpHandlerOptions": {
            "AllowAutoRedirect": false,
            "UseCookieContainer": false,
            "UseTracing": false
        }
    }
}

View Code

 使用示例:

降级的使用代码:

图片 12图片 13

 #region 降级
        public static void Downgrade()
        {
            //降级处理程序
            ISyncPolicy policy = Policy.Handle<ArgumentException>()
            .Fallback(() =>
            {
                Console.WriteLine("降级给的返回值结果");
            });
            //运行程序
            policy.Execute(() =>
            {
                Console.WriteLine("任务开始");

                throw new ArgumentException("降级任务出错,马上要降级了");

                Console.WriteLine("任务结束");
            });
        }
        #endregion

View Code

运行结果:

图片 14

重试机制的代码:

出错后重复3次。

图片 15图片 16

 #region 重试机制
        public static void Retry()
        {
            //配置重试次数
            ISyncPolicy policy = Policy.Handle<Exception>().Retry(3);

            try
            {
                policy.Execute(() =>
                {
                    Console.WriteLine("任务开始");
                    if (DateTime.Now.Second % 10 != 0)
                    {
                        throw new Exception("任务出错了,开始重试");
                    }
                    Console.WriteLine("任务结束");
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine("异常结果 : " + ex.Message);
            }
        }
        #endregion

View Code

运行结果:

图片 17

 熔断机制代码:

但出现错误连续三次后,等待20秒后进行

图片 18图片 19

 #region 熔断机制
        public static void Fusing()
        {

            Action<Exception, TimeSpan> onBreak = (exception, timespan) =>
            {
                Console.WriteLine("1");
            };
            Action onReset = () =>
            {
                Console.WriteLine("2");
            };
            ISyncPolicy policy = Policy.Handle<Exception>().CircuitBreaker(3, TimeSpan.FromSeconds(20), onBreak, onReset);
            while (true)
            {
                try
                {

                    policy.Execute(() =>
                        {
                            Console.WriteLine("任务开始");

                            throw new Exception("出错了");

                            Console.WriteLine("任务结束");
                        });

                }
                catch (Exception ex)
                {
                    Console.WriteLine("---------------异常结果-------------- : " + ex.Message + "时间:" + DateTime.Now);
                }
                System.Threading.Thread.Sleep(5000);
            }
        }
        #endregion

View Code

运行结果:

图片 20

混合示例(重试+降级)代码:

出错重试三次后第四次进行降级处理:主要是warp方法来实现的,特别说明warp方法是:最外面(在左边)到最里面(右边)的策略。也就是说从右向左执行方法;

图片 21图片 22

 #region 重试+降级
        public static void RetryDowngrade()
        {
            try
            {
                //降级处理程序
                ISyncPolicy policy = Policy.Handle<Exception>()
                .Fallback(() =>
                {
                    Console.WriteLine("降级成功");
                });
                //配置重试次数
                ISyncPolicy policy2 = Policy.Handle<Exception>().Retry(3, (exception, retryCount, context) =>
                             {
                                 Console.WriteLine(retryCount);

                             });
                //合并
                ISyncPolicy mainPolicy = Policy.Wrap(policy, policy2);
                mainPolicy.Execute(() =>
                {
                    Console.WriteLine("任务开始");

                    throw new Exception("出错了");

                    Console.WriteLine("任务结束");
                });
            }
            catch (Exception ex)
            {

                Console.WriteLine("异常结果 : " + ex.Message);
            }
        }
        #endregion

View Code

运行结果:

图片 23

 源码下载:PollyConsole.rar

Ocelot实现多个端口的轮询:

以上实现的这个有什么用啊,单独发布了接口,然后使用另外一个接口去复制他吗?别急,这只是其中的一个基本使用,现在我们有了基本步骤,我们改一改,实现webapi发布两个接口,8001,8002.然后还使用网关地址访问,可以循环的访问到8001端口和8002端口。

说起来简单,做起来也简单,我们只需要在我们上面的配置上修改一下即可:

图片 24图片 25

{
  "ReRoutes": [
    {
      "DownstreamPathTemplate": "/api/Test/{postId}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "127.0.0.1",
          "Port": 8001
        },
        {
          "Host": "127.0.0.1",
          "Port": 8002
        }
      ],
      "UpstreamPathTemplate": "/ProductService/{postId}",
      "UpstreamHttpMethod": [ "Get" ],
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      }
    }
  ],
  "GlobalConfiguration": {
    // "BaseUrl": "http://127.0.0.1:8887/"
  }
}

View Code

启动两个端口:

图片 26

重复请求网关两次结果:

图片 27

系列目录

微服务系列文章主要介绍微服务所使用到的一些技术和一些技术示例:

  • 微服务——微服务的介绍和目录
  • 微服务——【Consul】服务发现在windows下简单使用(一)
  • 微服务——【polly】微服务故障处理库(二)
  • 微服务——动态代理AspectCore的使用(三) 
  • 微服务——网关Ocelot+Consul实现集群轮询(四)
a = 7
isinstance(a, float)

False

Ocelot+ Consul:

实现目标:启动服务发现然后模拟集群发布功能,实现发布端口8001,8002后,启动服务发现,然后配置Ocelot网关。实现访问统一接口可以轮询访问8001,8002,8001,8002,...这样。然后可以在添加8003,继续规则。

实现以上目标我们不需要该我们的示例代码,只需要修改配置json文件即可:

图片 28图片 29

{
  "ReRoutes": [
    {
      "DownstreamPathTemplate": "/api/Test/{postId}",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/Product123Service/{postId}",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "ProductService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      },
      "UseServiceDiscovery": true
    }
  ],
  "GlobalConfiguration": {
    // "BaseUrl": "http://127.0.0.1:8887/"
    "ServiceDiscoveryProvider": {
      "Host": "localhost",
      "Port": 8500,
      "Type": "PollConsul",
      "PollingInterval": 100
    }
  }
}

View Code

这个就是我们的服务功能:

Ocelot允许您指定服务发现提供程序,并使用它来查找Ocelot正在将请求转发给下游服务的主机和端口。目前,这仅在GlobalConfiguration部分中受支持,这意味着将为所有的ReRoute使用相同的服务发现提供程序,以便在ReRoute级别指定ServiceName。

  • ServiceName:consul的服务名称
  • LoadBalancerOptions:使用的算法,目前有两种RoundRobin(轮询方式)和LeastConnection(最小连接)
  • UseServiceDiscovery:是否启用服务发现功能 true:为启动
  • ServiceDiscoveryProvider:配置服务发现的一些配置
  • Host:主机地址
  • Port:端口
  • PollingInterval:轮询的间隔时间,以毫秒为单位。并告诉Ocelot多久可以向Consul调用服务配置的更改

想要了解更多可以访问Ocelot官网:

  • is用来判断两份引用是否指向同一个对象与 == 不同

系列目录:

微服务系列文章主要介绍微服务所使用到的一些技术和一些技术示例:

  • 微服务——微服务的介绍和目录
  • 微服务——【Consul】服务发现在windows下简单使用(一)
  • 微服务——【polly】微服务故障处理库(二)
  • 微服务——动态代理AspectCore的使用(三) 
  • 微服务——网关Ocelot+Consul实现集群轮询(四)
a = [1,2,3]
b = a
c = list(a)
a is not c

True
  • 字符串左边加上r表示字符应该按原本样子解释
s = r'e\e'
print(s)

e\e
  • strftime将时间转化为字符串
  • strptime将字符串转化为时间
from datetime import datetime
a = datetime.now()
a.strftime('%m/%d/%Y %H:%M')

'02/09/2018 21:07'

datetime.strptime('20091009', '%Y%m%d')

datetime.datetime(2009, 10, 9, 0, 0)
  • continue 进入下一个迭代
  • break 结束循环
  • pass 空操作

  • range可以用在for循环中,range始终返回迭代器

本文由澳门新葡亰手机版发布于编程,转载请注明出处:polly微服务故障处理库,API网关组件Ocelot

上一篇:TXT文本存储 下一篇:WebRequest异步请求与WebClient异步请求,进阶系列
猜你喜欢
热门排行
精彩图文