Uma introdução a Resiliência em Sistemas Distribuídos bem como o uso de padrões e políticas de resiliência com o Polly. Código fonte e animações em: https://github.com/maiconcp/polly-meetup Apresentação realizada no evento: https://www.meetup.com/pt-BR/qualyteam/events/258072791/

1. @maiconpereira
@maiconcp
@maiconcp

3. “É a capacidade da aplicação de se recuperar de falhas e continuar a
funcionar”
- melhor cenário: Sem o usuário perceber
- Pior cenário: “graceful degradation” do serviço, ou seja, oferecer o serviço de
forma limitada (algo como ser tolerante a falhas)

4. • Transiente
• Ocorre uma vez e depois desaparece
• Se a operação for repetida, a falha não acontecerá novamente
• Intermitente
• Ocorre e desaparece por “sua própria vontade”. Ex.: conector com problemas
• Difícil de diagnosticar
• Permanente:
• Continua a existir até que o componente faltoso seja substituído
• Exs: bugs de software, chips queimados
http://www.fisiocomp.ufjf.br/anapaula/SD/SD_aula_13.pdf

5. http://www.fisiocomp.ufjf.br/anapaula/SD/SD_aula_13.pdf

6. 1. A rede é confiável
2. A latência é zero
3. A banda é infinita
4. A rede é segura
5. A topologia é imutável
6. Existe apenas um administrador
7. Não há custo para transporte de dados
8. A rede é homogênea
https://en.wikipedia.org/wiki/Fallacies_of_distributed_computing

7. 99,5%
99,5%
99,5%
99,5%
99,5%
99,5%
97,5%
Falhas Transientes
• Mover contêiner de nó
• Falhas na rede
• Deploy

14. • Aplicado à: Falhas curtas, como por exemplo:
• quando se está movendo um container de nó
• ou falhas nas rede;
• Como: Realizando novas tentativas quando um serviço estiver
indisponível por um período de tempo
Premissa Aka Como a politica ajuda?
Muitas falhas são
transitórias e podem se
auto-corrigir após um
pequeno tempo.
“Talvez seja apenas um
episódio”
Permite configurar re-
tentativas automáticas

15. Send
Retry
Policy
Retries:

16. Variações
• RetryForever: Tentar indefinidamente
• Retry(X): Tentar X vezes
• WaitAndRetry(x,y): Tentar X vezes com um intervalo de Y entre
tentativas

17. Quanto
tempo
esperar antes
de repetir?

18. • Refere-se ao tempo dos intervalos entre tentativas,
eles crescem exponencialmente a cada tentativa... Acho que já vi
isso...

19. 0
50
100
150
200
250
300
350
1 2 3 4 5 6 7 8 9
Segundos
Número da Tentativa

20. • Ponto de Atenção: Muitas novas tentativas pode sobrecarregar o
servidor podendo gerar um DoS (Denial of Service – Negação do
Serviço);

21. Já sei como
implementar
isso... For..
Try..catch......

22. • Fluent
• Reusabilidade
• Thread Safe
• Suporte Async

23. // Retry a specified number of times, using a function to
// calculate the duration to wait between retries based on
// the current retry attempt (allows for exponential backoff)
// In this case will wait for
// 2 ^ 1 = 2 seconds then
// 2 ^ 2 = 4 seconds then
// 2 ^ 3 = 8 seconds then
// 2 ^ 4 = 16 seconds then
// 2 ^ 5 = 32 seconds
Policy
.Handle<SomeException>()
.WaitAndRetry(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)))
.Execute(() =>
{
// do....
});

24. Padrão Disjuntor

25. • Manter a integridade do sistema
Premissa Aka
Como a política
ajuda?
Quando um Sistema está
sobrecarregado, falhar
rápido é melhor do que
fazer o chamador esperar.
Protejer o Sistema, pode
ajudá-lo a se recuperar
“Dê um tempo ao sistema"
Quebra o circuito
(bloqueia execuções)
por um período,
quando as falhas
excedem algum limite
pré-configurado..

26. Send
Circuit
Breaker
Threshold:

27. // Break the circuit after the specified number of consecutive exceptions
// and keep circuit broken for the specified duration.
Policy
.Handle<SomeExceptionType>()
.CircuitBreaker(2, TimeSpan.FromMinutes(1));
Policy
.Handle<TException>(...)
.AdvancedCircuitBreaker(
failureThreshold: 0.5,
samplingDuration: TimeSpan.FromSeconds(5),
minimumThroughput: 20,
durationOfBreak: TimeSpan.FromSeconds(30))

29. • Todos as aplicações clientes deveriam trabalhar com um tempo limite
para não ficarem bloqueadas indeterminadamente esperando uma
resposta;
Premissa Aka Como a política ajuda?
Depois um certo tempo,
um resultado de sucesso é
improvável.
“Não espere para sempre”
Garante que o chamador
não terá que esperar além
do tempo limite.

30. Send
Timeout
Policy

31. // Timeout after 30 seconds, if the executed delegate has not completed.
// Enforces this timeout even if the executed code has no cancellation mechanism.
Policy
.Timeout(30, TimeoutStrategy.Pessimistic)

33. Premissa Aka Como a política ajuda?
As coisas ainda falharão -
planeje o que você fará
quando isso acontecer.
“Falha graciosamente”
Define um valor alternativo
a ser retornado (ou ação a
ser executada) em caso de
falha.

34. Profile
Fallback
Policy
Obter Imagem Perfil

35. // Provide a substitute value, if an execution faults.
Policy<UserAvatar>
.Handle<Whatever>()
.Fallback<UserAvatar>(UserAvatar.Blank)
.Execute...

37. • Cache de Leitura
• Reduz o tempo da chamada
• Reduz o tráfego na rede
• Reduz a sobrecarga do destinatário
Premissa Aka Como a política ajuda?
Algumas solicitações
serão semelhantes.
"Você pediu isso antes"
Fornece uma resposta do cache, se conhecido.
Armazena as respostas automaticamente no cache,
quando recuperadas pela primeira vez.

38. Install-Package Polly.Caching.Memory
Install-Package Microsoft.Extensions.Caching.Memory

39. public class PollyCacheSample
{
public CachePolicy<string> CachePolicy =>
Policy.Cache<string>(_memoryCacheProvider, TimeSpan.FromMinutes(5));
private readonly MemoryCacheProvider _memoryCacheProvider;
public PollyCacheSample()
{
// This approach creates a CachePolicy directly,
// with its own Microsoft.Extensions.Caching.Memory.MemoryCache instance:
var memoryCache = new MemoryCache(new MemoryCacheOptions());
_memoryCacheProvider = new MemoryCacheProvider(memoryCache);
}
public void GetSomeThingById(int id)
{
var policyResult = CachePolicy.Execute(context =>
{
return new ClientService().GetSomeThing(id);
}, new Context(operationKey: id.ToString()));
}
CriandoacachePolíticaExecução

41. • Isolar as partes da aplicação em pools para que, se um falhar, os
outros continuarão a funcionar.
• Limita a paralelização
"Uma falha não deve afundar
o navio inteiro"

43. • “Falhas diferentes requerem estratégias diferentes; resiliência
significa usar uma combinação.”
// Define a combined policy strategy, built of previously-defined policies.
var policyWrap = Policy
.Wrap(fallback, cache, retry, breaker, timeout, bulkhead);
// (wraps the policies around any executed delegate: fallback outermost ...
bulkhead innermost)
policyWrap.Execute(...)
// Define a standard resilience strategy ...
PolicyWrap commonResilience = Policy.Wrap(retry, breaker, timeout);

44. ASP

45. • Mesmo após o dispose do HttpClient, o soquete não é liberado imediatamente e pode
causar um problema sério chamado 'esgotamento de soquetes'.
• Portanto, HttpClient deve ser instanciado uma única vez e reutilizado durante a vida útil
da aplicação
• O uso do HttpClient como um Singleton ou Static pode ocasionar um outro problema
quando há alteração de DNS (ver documentação no site da Microsoft)
https://aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/
using (var httpCliente = new HttpClient())
{
...
}
https://docs.microsoft.com/pt-br/dotnet/standard/microservices-architecture/implement-resilient-applications/use-httpclientfactory-to-implement-resilient-http-requests

46. O HttpClientFactory é um recurso do ASPNET Core 2.1
É uma factory facilita o uso do HttpClient

47. Install-Package Microsoft.Extensions.Http
// Startup.cs
//Add http client services at ConfigureServices(IServiceCollection services)
services.AddHttpClient<ICatalogService, CatalogService>();
services.AddHttpClient<IBasketService, BasketService>();
services.AddHttpClient<IOrderingService, OrderingService>();
public void ConfigureServices(IServiceCollection services)
{
O código criará um HttpClient configurado especificamente para cada serviço,
https://docs.microsoft.com/pt-br/dotnet/standard/microservices-architecture/implement-resilient-applications/use-httpclientfactory-to-implement-resilient-http-requests

48. public class CatalogService : ICatalogService
{
private readonly HttpClient _httpClient;
private readonly string _remoteServiceBaseUrl;
public CatalogService(HttpClient httpClient)
{
_httpClient = httpClient;
}
public async Task<Catalog> GetCatalogItems(int page, int take,
int? brand, int? type)
{
var uri = API.Catalog.GetAllCatalogItems(_remoteServiceBaseUrl,
page, take, brand, type);
var responseString = await _httpClient.GetStringAsync(uri);
...
}
} https://docs.microsoft.com/pt-br/dotnet/standard/microservices-architecture/implement-resilient-applications/use-httpclientfactory-to-implement-resilient-http-requests

49. Install-Package Microsoft.Extensions.Http.Polly

50. //ConfigureServices() - Startup.cs
services.AddHttpClient<IBasketService, BasketService>()
.AddPolicyHandler(GetRetryPolicy());
// Retry Policy
static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy()
{
return HttpPolicyExtensions
.HandleTransientHttpError()
.OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.NotFound)
.WaitAndRetryAsync(6, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2,
retryAttempt)));
}

54. • Um método é considerado idempotente se o resultado de uma
requisição realizada com sucesso é independente do número de vezes
que é executada.
http://www.elemarjr.com/pt/2018/01/lidando-com-falhas-de-conexao-em-microsservicos/

55. https://docs.microsoft.com/pt-br/dotnet/standard/microservices-architecture/implement-resilient-applications/implement-resilient-entity-framework-core-sql-connections

56. • Como podemos reagir em caso de falha?
• Que valor posso retornar se o serviço estiver fora?
• Aceitaremos uma “Consistência Eventual” ?

58. https://github.com/App-vNext/Polly

59. http://www.thepollyproject.org/

60. https://docs.microsoft.com/pt-br/dotnet/standard/microservices-architecture/

63. • https://github.com/App-vNext/Polly
• http://www.thepollyproject.org/
• https://docs.microsoft.com/pt-br/dotnet/standard/microservices-
architecture/implement-resilient-applications/
• https://docs.microsoft.com/pt-br/dotnet/standard/microservices-
architecture/implement-resilient-applications/use-httpclientfactory-to-
implement-resilient-http-requests
• https://docs.microsoft.com/pt-br/aspnet/core/fundamentals/http-
requests?view=aspnetcore-2.2
• https://docs.microsoft.com/pt-br/dotnet/standard/microservices-
architecture/implement-resilient-applications/implement-http-call-retries-
exponential-backoff-polly

64. • https://www.infoq.com/br/presentations/como-sua-aplicacao-deve-se-
comportar-quando-tudo-da-errado
• https://www.infoq.com/br/presentations/resiliencia-com-microservices-
cache-distribuido-feedback-e-tuning
• https://medium.com/beelab/criando-chamadas-http-resilientes-utilizando-
polly-com-httpclient-factory-eafb2644a244
• https://www.infoq.com/presentations/polly
• https://www.slideshare.net/ufried/resilience-reloaded-more-resilience-
patterns
• https://searchnetworking.techtarget.com/definition/graceful-degradation

66. @maiconpereira
@maiconcp
@maiconcp