ASP.NET Core no Service Fabric do Azure Reliable ServicesASP.NET Core in Azure Service Fabric Reliable Services

ASP.NET Core é uma estrutura de software livre e de plataforma cruzada.ASP.NET Core is an open-source and cross-platform framework. Essa estrutura foi projetada para a criação de aplicativos conectados à Internet, baseados em nuvem, como aplicativos Web, aplicativos de IoT e back-ends móveis.This framework is designed for building cloud-based, internet-connected applications, such as web apps, IoT apps, and mobile back ends.

Este artigo é um guia detalhado para hospedar serviços de ASP.NET Core no Service Fabric Reliable Services usando o Microsoft. AspNetCore .This article is an in-depth guide to hosting ASP.NET Core services in Service Fabric Reliable Services by using the Microsoft.ServiceFabric.AspNetCore. conjunto de pacotes NuGet.set of NuGet packages.

Para obter um tutorial introdutório sobre ASP.NET Core em Service Fabric e instruções sobre como configurar seu ambiente de desenvolvimento, consulte Tutorial: Crie e implante um aplicativo com um serviço de front-end de API Web ASP.NET Core e um serviçode back-end com estado.For an introductory tutorial on ASP.NET Core in Service Fabric and instructions on getting your development environment set up, see Tutorial: Create and deploy an application with an ASP.NET Core Web API front-end service and a stateful back-end service.

O restante deste artigo pressupõe que você já esteja familiarizado com ASP.NET Core.The rest of this article assumes you're already familiar with ASP.NET Core. Caso contrário, leia os conceitos básicos do ASP.NET Core.If not, please read through the ASP.NET Core fundamentals.

ASP.NET Core no ambiente de Service FabricASP.NET Core in the Service Fabric environment

Os aplicativos ASP.NET Core e Service Fabric podem ser executados no .NET Core ou no .NET Framework completo.Both ASP.NET Core and Service Fabric apps can run on .NET Core or full .NET Framework. Você pode usar ASP.NET Core de duas maneiras diferentes no Service Fabric:You can use ASP.NET Core in two different ways in Service Fabric:

  • Hospedado como um executável convidado.Hosted as a guest executable. Dessa forma, é usada principalmente para executar aplicativos ASP.NET Core existentes no Service Fabric sem alterações de código.This way is primarily used to run existing ASP.NET Core applications on Service Fabric with no code changes.
  • Execute dentro de um serviço confiável.Run inside a reliable service. Dessa forma, permite uma melhor integração com o tempo de execução do Service Fabric e permite serviços de ASP.NET Core com estado.This way allows better integration with the Service Fabric runtime and allows stateful ASP.NET Core services.

O restante deste artigo explica como usar ASP.NET Core dentro de um serviço confiável, por meio dos componentes de integração do ASP.NET Core que acompanham o SDK do Service Fabric.The rest of this article explains how to use ASP.NET Core inside a reliable service, through the ASP.NET Core integration components that ship with the Service Fabric SDK.

Hospedagem de serviço Service FabricService Fabric service hosting

No Service Fabric, uma ou mais instâncias e/ou réplicas do serviço são executadas em um processo de host de serviço: um arquivo executável que executa o código de serviço.In Service Fabric, one or more instances and/or replicas of your service run in a service host process: an executable file that runs your service code. Você, como autor de um serviço, possui o processo de host de serviço e Service Fabric ativa e monitora para você.You, as a service author, own the service host process, and Service Fabric activates and monitors it for you.

O ASP.NET tradicional (até MVC 5) está rigidamente acoplado ao IIS por meio de System. Web. dll.Traditional ASP.NET (up to MVC 5) is tightly coupled to IIS through System.Web.dll. ASP.NET Core fornece uma separação entre o servidor Web e o aplicativo Web.ASP.NET Core provides a separation between the web server and your web application. Essa separação permite que os aplicativos Web sejam portáteis entre diferentes servidores Web.This separation allows web applications to be portable between different web servers. Ele também permite que os servidores Web sejam hospedados automaticamente.It also allows web servers to be self-hosted. Isso significa que você pode iniciar um servidor Web em seu próprio processo, em oposição a um processo que é de propriedade de um software de servidor Web dedicado, como o IIS.This means you can start a web server in your own process, as opposed to a process that's owned by dedicated web server software, such as IIS.

Para combinar um serviço de Service Fabric e o ASP.NET, como um executável convidado ou em um serviço confiável, você deve ser capaz de iniciar o ASP.NET dentro do processo de host do serviço.To combine a Service Fabric service and ASP.NET, either as a guest executable or in a reliable service, you must be able to start ASP.NET inside your service host process. ASP.NET Core hospedagem interna permite que você faça isso.ASP.NET Core self-hosting allows you to do this.

Hospedando ASP.NET Core em um serviço confiávelHosting ASP.NET Core in a reliable service

Normalmente, os aplicativos de ASP.NET Core auto-hospedados criam um Webhost no ponto de entrada de um aplicativo static void Main() , como Program.cso método em.Typically, self-hosted ASP.NET Core applications create a WebHost in an application's entry point, such as the static void Main() method in Program.cs. Nesse caso, o ciclo de vida do Webhost está associado ao ciclo de vida do processo.In this case, the life cycle of the WebHost is bound to the life cycle of the process.

Hospedando ASP.NET Core em um processo

Mas o ponto de entrada do aplicativo não é o lugar certo para criar um Webhost em um serviço confiável.But the application entry point isn't the right place to create a WebHost in a reliable service. Isso ocorre porque o ponto de entrada do aplicativo é usado apenas para registrar um tipo de serviço com o tempo de execução Service Fabric, para que ele possa criar instâncias desse tipo de serviço.That's because the application entry point is only used to register a service type with the Service Fabric runtime, so that it can create instances of that service type. O Webhost deve ser criado em um serviço confiável em si.The WebHost should be created in a reliable service itself. Dentro do processo de host de serviço, as instâncias de serviço e/ou réplicas podem passar por vários ciclos de vida.Within the service host process, service instances and/or replicas can go through multiple life cycles.

Uma instância de serviço confiável é representada por sua classe de serviço derivada StatelessService de StatefulServiceou.A Reliable Service instance is represented by your service class deriving from StatelessService or StatefulService. A pilha de comunicação para um serviço está contida em ICommunicationListener uma implementação em sua classe de serviço.The communication stack for a service is contained in an ICommunicationListener implementation in your service class. Os Microsoft.ServiceFabric.AspNetCore.* pacotes NuGet contêm implementações ICommunicationListener do que iniciam e gerenciam o ASP.NET Core Webhost para Kestrel ou http. sys em um serviço confiável.The Microsoft.ServiceFabric.AspNetCore.* NuGet packages contain implementations of ICommunicationListener that start and manage the ASP.NET Core WebHost for either Kestrel or HTTP.sys in a reliable service.

Diagrama para hospedagem de ASP.NET Core em um serviço confiável

ASP.NET Core ICommunicationListenersASP.NET Core ICommunicationListeners

As ICommunicationListener implementações para Kestrel e http. sys Microsoft.ServiceFabric.AspNetCore.* nos pacotes NuGet têm padrões de uso semelhantes.The ICommunicationListener implementations for Kestrel and HTTP.sys in the Microsoft.ServiceFabric.AspNetCore.* NuGet packages have similar use patterns. Mas eles executam ações um pouco diferentes específicas para cada servidor Web.But they perform slightly different actions specific to each web server.

Ambos os ouvintes de comunicação fornecem um construtor que usa os seguintes argumentos:Both communication listeners provide a constructor that takes the following arguments:

  • ServiceContext serviceContext : Esse é o ServiceContext objeto que contém informações sobre o serviço em execução.ServiceContext serviceContext: This is the ServiceContext object that contains information about the running service.
  • string endpointName : Este é o nome de uma Endpoint configuração no Service manifest. xml.string endpointName: This is the name of an Endpoint configuration in ServiceManifest.xml. É principalmente onde os dois ouvintes de comunicação diferem.It's primarily where the two communication listeners differ. O http. sys requer Endpoint uma configuração, enquanto Kestrel não.HTTP.sys requires an Endpoint configuration, while Kestrel doesn't.
  • Func<string, AspNetCoreCommunicationListener, IWebHost> build : Esse é um lambda que você implementa, no qual você cria e retorna um IWebHost.Func<string, AspNetCoreCommunicationListener, IWebHost> build: This is a lambda that you implement, in which you create and return an IWebHost. Ele permite que você configure IWebHost a maneira que normalmente faria em um aplicativo ASP.NET Core.It allows you to configure IWebHost the way you normally would in an ASP.NET Core application. O lambda fornece uma URL que é gerada para você, dependendo das opções de integração de Service Fabric que você usa e Endpoint a configuração que você fornece.The lambda provides a URL that's generated for you, depending on the Service Fabric integration options you use and the Endpoint configuration you provide. Em seguida, você pode modificar ou usar essa URL para iniciar o servidor Web.You can then modify or use that URL to start the web server.

Middleware de integração Service FabricService Fabric integration middleware

O Microsoft.ServiceFabric.AspNetCore pacote NuGet inclui o UseServiceFabricIntegration método de extensão IWebHostBuilder no, que adiciona o middleware com reconhecimento Service Fabric.The Microsoft.ServiceFabric.AspNetCore NuGet package includes the UseServiceFabricIntegration extension method on IWebHostBuilder that adds Service Fabric–aware middleware. Esse middleware configura o Kestrel ou o http. sys ICommunicationListener para registrar uma URL de serviço exclusiva com o serviço de nomenclatura de Service Fabric.This middleware configures the Kestrel or HTTP.sys ICommunicationListener to register a unique service URL with the Service Fabric Naming Service. Em seguida, ele valida as solicitações do cliente para garantir que os clientes estejam se conectando ao serviço certo.It then validates client requests to ensure clients are connecting to the right service.

Essa etapa é necessária para impedir que os clientes se conectem erroneamente ao serviço errado.This step is necessary to prevent clients from mistakenly connecting to the wrong service. Isso ocorre porque, em um ambiente de host compartilhado, como Service Fabric, vários aplicativos Web podem ser executados na mesma máquina física ou virtual, mas não usam nomes de host exclusivos.That's because, in a shared-host environment such as Service Fabric, multiple web applications can run on the same physical or virtual machine but don't use unique host names. Esse cenário é descrito mais detalhadamente na próxima seção.This scenario is described in more detail in the next section.

Um caso de identidade equivocadaA case of mistaken identity

Réplicas de serviço, independentemente do protocolo, escutam em uma combinação de IP: porta exclusiva.Service replicas, regardless of protocol, listen on a unique IP:port combination. Depois que uma réplica de serviço começa a escutar em um ponto de extremidade de IP: porta, ela relata esse endereço de ponto de extremidade para o Service Fabric Serviço de Nomenclatura.Once a service replica has started listening on an IP:port endpoint, it reports that endpoint address to the Service Fabric Naming Service. Lá, os clientes ou outros serviços podem descobri-lo.There, clients or other services can discover it. Se os serviços usarem portas de aplicativo atribuídas dinamicamente, uma réplica de serviço poderá usar coincidentemente o mesmo ponto de extremidade de IP: porta de outro serviço anteriormente na mesma máquina física ou virtual.If services use dynamically assigned application ports, a service replica might coincidentally use the same IP:port endpoint of another service previously on the same physical or virtual machine. Isso pode fazer com que um cliente se conecte erroneamente ao serviço errado.This can cause a client to mistakenly connect to the wrong service. Esse cenário pode resultar se ocorrer a seguinte sequência de eventos:This scenario can result if the following sequence of events occurs:

  1. O serviço A escuta em 10.0.0.1:30000 por HTTP.Service A listens on 10.0.0.1:30000 over HTTP.
  2. O cliente resolve o serviço A e Obtém o endereço 10.0.0.1:30000.Client resolves Service A and gets address 10.0.0.1:30000.
  3. O serviço A se move para um nó diferente.Service A moves to a different node.
  4. O serviço B é colocado em 10.0.0.1 e usa coincidentemente a mesma porta 30000.Service B is placed on 10.0.0.1 and coincidentally uses the same port 30000.
  5. O cliente tenta se conectar ao serviço A com o endereço em cache 10.0.0.1:30000.Client attempts to connect to service A with cached address 10.0.0.1:30000.
  6. O cliente agora está conectado com êxito ao serviço B, não percebendo que ele está conectado ao serviço errado.Client is now successfully connected to service B, not realizing it's connected to the wrong service.

Isso pode causar bugs em momentos aleatórios que podem ser difíceis de diagnosticar.This can cause bugs at random times that can be difficult to diagnose.

Usando URLs de serviço exclusivasUsing unique service URLs

Para evitar esses bugs, os serviços podem postar um ponto de extremidade no Serviço de Nomenclatura com um identificador exclusivo e, em seguida, validar esse identificador exclusivo durante as solicitações do cliente.To prevent these bugs, services can post an endpoint to the Naming Service with a unique identifier, and then validate that unique identifier during client requests. Essa é uma ação cooperativa entre serviços em um ambiente confiável que não é hostil pelo locatário.This is a cooperative action between services in a non-hostile-tenant trusted environment. Ele não fornece autenticação de serviço segura em um ambiente de locatário hostil.It doesn't provide secure service authentication in a hostile-tenant environment.

Em um ambiente confiável, o middleware adicionado pelo UseServiceFabricIntegration método acrescenta automaticamente um identificador exclusivo ao endereço Postado para o serviço de nomenclatura.In a trusted environment, the middleware that's added by the UseServiceFabricIntegration method automatically appends a unique identifier to the address posted to the Naming Service. Ele valida esse identificador em cada solicitação.It validates that identifier on each request. Se o identificador não corresponder, o middleware retornará imediatamente uma resposta HTTP 410 out.If the identifier doesn't match, the middleware immediately returns an HTTP 410 Gone response.

Os serviços que usam uma porta atribuída dinamicamente devem fazer uso desse middleware.Services that use a dynamically assigned port should make use of this middleware.

Os serviços que usam uma porta exclusiva fixa não têm esse problema em um ambiente cooperativo.Services that use a fixed unique port don't have this problem in a cooperative environment. Uma porta exclusiva fixa é normalmente usada para serviços voltados externamente que precisam de uma porta conhecida para que os aplicativos cliente se conectem ao.A fixed unique port is typically used for externally facing services that need a well-known port for client applications to connect to. Por exemplo, a maioria dos aplicativos da Web voltados para a Internet usará a porta 80 ou 443 para conexões de navegador da Web.For example, most internet-facing web applications will use port 80 or 443 for web browser connections. Nesse caso, o identificador exclusivo não deve ser habilitado.In this case, the unique identifier shouldn't be enabled.

O diagrama a seguir mostra o fluxo de solicitação com o middleware habilitado:The following diagram shows the request flow with the middleware enabled:

Integração do Service Fabric ASP.NET Core

As implementações Kestrel e http ICommunicationListener . sys usam esse mecanismo exatamente da mesma maneira.Both Kestrel and HTTP.sys ICommunicationListener implementations use this mechanism in exactly the same way. Embora o http. sys possa diferenciar internamente as solicitações com base em caminhos de URL exclusivos usando o recurso subjacente de compartilhamento de porta http. sys , essa funcionalidade não é usada ICommunicationListener pela implementação de http. sys.Although HTTP.sys can internally differentiate requests based on unique URL paths by using the underlying HTTP.sys port sharing feature, that functionality is not used by the HTTP.sys ICommunicationListener implementation. Isso ocorre porque resulta em códigos de status de erro HTTP 503 e HTTP 404 no cenário descrito anteriormente.That's because it results in HTTP 503 and HTTP 404 error status codes in the scenario described earlier. Isso, por sua vez, dificulta para os clientes determinarem a intenção do erro, pois HTTP 503 e HTTP 404 são comumente usados para indicar outros erros.That in turn makes it difficult for clients to determine the intent of the error, as HTTP 503 and HTTP 404 are commonly used to indicate other errors.

Portanto, as implementações Kestrel e http ICommunicationListener . sys padronizam o middleware fornecido pelo UseServiceFabricIntegration método de extensão.Thus, both Kestrel and HTTP.sys ICommunicationListener implementations standardize on middleware provided by the UseServiceFabricIntegration extension method. Portanto, os clientes precisam apenas executar uma ação de reresolução de ponto de extremidade de serviço em respostas HTTP 410.Therefore, clients only need to perform a service endpoint re-resolve action on HTTP 410 responses.

HTTP. sys em Reliable ServicesHTTP.sys in Reliable Services

Você pode usar o HTTP. sys em Reliable Services importando o pacote NuGet Microsoft. AspNetCore. https .You can use HTTP.sys in Reliable Services by importing the Microsoft.ServiceFabric.AspNetCore.HttpSys NuGet package. Este pacote contém HttpSysCommunicationListener, uma implementação do ICommunicationListener.This package contains HttpSysCommunicationListener, an implementation of ICommunicationListener. HttpSysCommunicationListenerpermite que você crie um Webhost ASP.NET Core dentro de um serviço confiável usando HTTP. sys como o servidor Web.HttpSysCommunicationListener allows you to create an ASP.NET Core WebHost inside a reliable service by using HTTP.sys as the web server.

O HTTP. sys é criado na API do servidor http do Windows.HTTP.sys is built on the Windows HTTP Server API. Essa API usa o driver de kernel http. sys para processar solicitações HTTP e roteá-las para processos que executam aplicativos Web.This API uses the HTTP.sys kernel driver to process HTTP requests and route them to processes that run web applications. Isso permite que vários processos na mesma máquina física ou virtual hospedem aplicativos Web na mesma porta, sem ambigüidade por um caminho de URL exclusivo ou nome de host.This allows multiple processes on the same physical or virtual machine to host web applications on the same port, disambiguated by either a unique URL path or host name. Esses recursos são úteis em Service Fabric para hospedar vários sites no mesmo cluster.These features are useful in Service Fabric for hosting multiple websites in the same cluster.

Nota

A implementação de HTTP. sys funciona apenas na plataforma Windows.HTTP.sys implementation works only on the Windows platform.

O diagrama a seguir ilustra como o HTTP. sys usa o driver de kernel http. sys no Windows para compartilhamento de porta:The following diagram illustrates how HTTP.sys uses the HTTP.sys kernel driver on Windows for port sharing:

Diagrama de HTTP. sys

HTTP. sys em um serviço sem estadoHTTP.sys in a stateless service

Para usar HttpSys em um serviço sem estado, substitua CreateServiceInstanceListeners o método e retorne uma HttpSysCommunicationListener instância:To use HttpSys in a stateless service, override the CreateServiceInstanceListeners method and return a HttpSysCommunicationListener instance:

protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
{
    return new ServiceInstanceListener[]
    {
        new ServiceInstanceListener(serviceContext =>
            new HttpSysCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
                new WebHostBuilder()
                    .UseHttpSys()
                    .ConfigureServices(
                        services => services
                            .AddSingleton<StatelessServiceContext>(serviceContext))
                    .UseContentRoot(Directory.GetCurrentDirectory())
                    .UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.None)
                    .UseStartup<Startup>()
                    .UseUrls(url)
                    .Build()))
    };
}

HTTP. sys em um serviço com estadoHTTP.sys in a stateful service

HttpSysCommunicationListenerNão está projetado atualmente para uso em serviços com estado devido a complicações com o recurso subjacente de compartilhamento de porta http. sys .HttpSysCommunicationListener isn't currently designed for use in stateful services due to complications with the underlying HTTP.sys port sharing feature. Para obter mais informações, consulte a seção a seguir sobre alocação de porta dinâmica com HTTP. sys.For more information, see the following section on dynamic port allocation with HTTP.sys. Para serviços com estado, Kestrel é o servidor Web sugerido.For stateful services, Kestrel is the suggested web server.

Configuração do ponto de extremidadeEndpoint configuration

Uma Endpoint configuração é necessária para servidores Web que usam a API do servidor http do Windows, incluindo http. sys.An Endpoint configuration is required for web servers that use the Windows HTTP Server API, including HTTP.sys. Os servidores Web que usam a API do servidor HTTP do Windows devem primeiro reservar sua URL com HTTP. sys (normalmente, isso é feito com a ferramenta netsh ).Web servers that use the Windows HTTP Server API must first reserve their URL with HTTP.sys (this is normally accomplished with the netsh tool).

Essa ação requer privilégios elevados que os serviços não têm, por padrão.This action requires elevated privileges that your services don't have by default. As opções "http" ou "https" para a Protocol propriedade Endpoint da configuração em manifestar. XML são usadas especificamente para instruir o tempo de execução de Service Fabric para registrar uma URL com http. sys em seu nome.The "http" or "https" options for the Protocol property of the Endpoint configuration in ServiceManifest.xml are used specifically to instruct the Service Fabric runtime to register a URL with HTTP.sys on your behalf. Ele faz isso usando o prefixo de URL de curinga forte .It does this by using the strong wildcard URL prefix.

Por exemplo, para reservar http://+:80 um serviço, use a seguinte configuração no Service manifest. xml:For example, to reserve http://+:80 for a service, use the following configuration in ServiceManifest.xml:

<ServiceManifest ... >
    ...
    <Resources>
        <Endpoints>
            <Endpoint Name="ServiceEndpoint" Protocol="http" Port="80" />
        </Endpoints>
    </Resources>

</ServiceManifest>

E o nome do ponto de extremidade deve ser HttpSysCommunicationListener passado para o construtor:And the endpoint name must be passed to the HttpSysCommunicationListener constructor:

 new HttpSysCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
 {
     return new WebHostBuilder()
         .UseHttpSys()
         .UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.None)
         .UseUrls(url)
         .Build();
 })

Usar HTTP. sys com uma porta estáticaUse HTTP.sys with a static port

Para usar uma porta estática com http. sys, forneça o número da porta na Endpoint configuração:To use a static port with HTTP.sys, provide the port number in the Endpoint configuration:

  <Resources>
    <Endpoints>
      <Endpoint Protocol="http" Name="ServiceEndpoint" Port="80" />
    </Endpoints>
  </Resources>

Usar HTTP. sys com uma porta dinâmicaUse HTTP.sys with a dynamic port

Para usar uma porta atribuída dinamicamente com http. sys, omita a Port propriedade Endpoint na configuração:To use a dynamically assigned port with HTTP.sys, omit the Port property in the Endpoint configuration:

  <Resources>
    <Endpoints>
      <Endpoint Protocol="http" Name="ServiceEndpoint" />
    </Endpoints>
  </Resources>

Uma porta dinâmica alocada por Endpoint uma configuração fornece apenas uma porta por processo de host.A dynamic port allocated by an Endpoint configuration provides only one port per host process. O modelo de Hospedagem de Service Fabric atual permite que várias instâncias de serviço e/ou réplicas sejam hospedadas no mesmo processo.The current Service Fabric hosting model allows multiple service instances and/or replicas to be hosted in the same process. Isso significa que cada uma delas compartilhará a mesma porta quando alocada por meio da Endpoint configuração.This means each one will share the same port when allocated through the Endpoint configuration. Várias instâncias de http. sys podem compartilhar uma porta usando o recurso subjacente de compartilhamento de porta http. sys .Multiple HTTP.sys instances can share a port by using the underlying HTTP.sys port sharing feature. Mas não há suporte HttpSysCommunicationListener para isso devido às complicações que ele introduz para solicitações de cliente.But it's not supported by HttpSysCommunicationListener due to the complications it introduces for client requests. Para o uso de porta dinâmica, Kestrel é o servidor Web sugerido.For dynamic port usage, Kestrel is the suggested web server.

KESTREL em Reliable ServicesKestrel in Reliable Services

Você pode usar o Kestrel em Reliable Services importando o pacote NuGet Microsoft. Microsoft. AspNetCore. Kestrel .You can use Kestrel in Reliable Services by importing the Microsoft.ServiceFabric.AspNetCore.Kestrel NuGet package. Este pacote contém KestrelCommunicationListener, uma implementação do ICommunicationListener.This package contains KestrelCommunicationListener, an implementation of ICommunicationListener. KestrelCommunicationListenerpermite que você crie um Webhost ASP.NET Core dentro de um serviço confiável usando o Kestrel como o servidor Web.KestrelCommunicationListener allows you to create an ASP.NET Core WebHost inside a reliable service by using Kestrel as the web server.

O Kestrel é um servidor Web de plataforma cruzada para ASP.NET Core com base no libuv, uma biblioteca de e/s assíncrona de plataforma cruzada.Kestrel is a cross-platform web server for ASP.NET Core based on libuv, a cross-platform asynchronous I/O library. Ao contrário de HTTP. sys, Kestrel não usa um Gerenciador de ponto de extremidade centralizado.Unlike HTTP.sys, Kestrel doesn't use a centralized endpoint manager. Além disso, ao contrário de HTTP. sys, o Kestrel não dá suporte ao compartilhamento de porta entre vários processos.Also unlike HTTP.sys, Kestrel doesn't support port sharing between multiple processes. Cada instância de Kestrel deve usar uma porta exclusiva.Each instance of Kestrel must use a unique port.

Diagrama de Kestrel

KESTREL em um serviço sem estadoKestrel in a stateless service

Para usar Kestrel em um serviço sem estado, substitua CreateServiceInstanceListeners o método e retorne uma KestrelCommunicationListener instância:To use Kestrel in a stateless service, override the CreateServiceInstanceListeners method and return a KestrelCommunicationListener instance:

protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
{
    return new ServiceInstanceListener[]
    {
        new ServiceInstanceListener(serviceContext =>
            new KestrelCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
                new WebHostBuilder()
                    .UseKestrel()
                    .ConfigureServices(
                        services => services
                            .AddSingleton<StatelessServiceContext>(serviceContext))
                    .UseContentRoot(Directory.GetCurrentDirectory())
                    .UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.UseUniqueServiceUrl)
                    .UseStartup<Startup>()
                    .UseUrls(url)
                    .Build();
            ))
    };
}

KESTREL em um serviço com estadoKestrel in a stateful service

Para usar Kestrel em um serviço com estado, substitua CreateServiceReplicaListeners o método e retorne uma KestrelCommunicationListener instância:To use Kestrel in a stateful service, override the CreateServiceReplicaListeners method and return a KestrelCommunicationListener instance:

protected override IEnumerable<ServiceReplicaListener> CreateServiceReplicaListeners()
{
    return new ServiceReplicaListener[]
    {
        new ServiceReplicaListener(serviceContext =>
            new KestrelCommunicationListener(serviceContext, (url, listener) =>
                new WebHostBuilder()
                    .UseKestrel()
                    .ConfigureServices(
                         services => services
                             .AddSingleton<StatefulServiceContext>(serviceContext)
                             .AddSingleton<IReliableStateManager>(this.StateManager))
                    .UseContentRoot(Directory.GetCurrentDirectory())
                    .UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.UseUniqueServiceUrl)
                    .UseStartup<Startup>()
                    .UseUrls(url)
                    .Build();
            ))
    };
}

Neste exemplo, uma instância singleton do IReliableStateManager é fornecida para o contêiner de injeção de dependência webhost.In this example, a singleton instance of IReliableStateManager is provided to the WebHost dependency injection container. Isso não é estritamente necessário, mas permite que você use IReliableStateManager e Reliable Collections em seus métodos de ação do controlador MVC.This isn't strictly necessary, but it allows you to use IReliableStateManager and Reliable Collections in your MVC controller action methods.

Um Endpoint nome de configuração não é fornecido KestrelCommunicationListener para em um serviço com estado.An Endpoint configuration name is not provided to KestrelCommunicationListener in a stateful service. Isso é explicado mais detalhadamente na seção a seguir.This is explained in more detail in the following section.

Configurar o Kestrel para utilizar HTTPSConfigure Kestrel to use HTTPS

Ao habilitar HTTPS com Kestrel em seu serviço, você precisará definir várias opções de escuta.When enabling HTTPS with Kestrel in your service, you'll need to set several listening options. Atualize o ServiceInstanceListener para usar um ponto de extremidade EndpointHttps e escute em uma porta específica (como a porta 443).Update the ServiceInstanceListener to use an EndpointHttps endpoint and listen on a specific port (such as port 443). Ao configurar o host Web para usar o servidor Web Kestrel, você deve configurar o Kestrel para escutar endereços IPv6 em todas as interfaces de rede:When configuring the web host to use the Kestrel web server, you must configure Kestrel to listen for IPv6 addresses on all network interfaces:

new ServiceInstanceListener(
serviceContext =>
    new KestrelCommunicationListener(
        serviceContext,
        "EndpointHttps",
        (url, listener) =>
        {
            ServiceEventSource.Current.ServiceMessage(serviceContext, $"Starting Kestrel on {url}");

            return new WebHostBuilder()
                .UseKestrel(opt =>
                {
                    int port = serviceContext.CodePackageActivationContext.GetEndpoint("EndpointHttps").Port;
                    opt.Listen(IPAddress.IPv6Any, port, listenOptions =>
                    {
                        listenOptions.UseHttps(GetCertificateFromStore());
                        listenOptions.NoDelay = true;
                    });
                })
                .ConfigureAppConfiguration((builderContext, config) =>
                {
                    config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
                })

                .ConfigureServices(
                    services => services
                        .AddSingleton<HttpClient>(new HttpClient())
                        .AddSingleton<FabricClient>(new FabricClient())
                        .AddSingleton<StatelessServiceContext>(serviceContext))
                .UseContentRoot(Directory.GetCurrentDirectory())
                .UseStartup<Startup>()
                .UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.None)
                .UseUrls(url)
                .Build();
        }))

Para obter um exemplo completo em um tutorial, consulte Configurar Kestrel para usar HTTPS.For a full example in a tutorial, see Configure Kestrel to use HTTPS.

Configuração do ponto de extremidadeEndpoint configuration

Uma Endpoint configuração não é necessária para usar o Kestrel.An Endpoint configuration isn't required to use Kestrel.

Kestrel é um servidor Web autônomo simples.Kestrel is a simple standalone web server. Diferentemente de http. sys (ou HttpListener), ele não Endpoint precisa de uma configuração em um manifesto. XML porque ele não requer o registro de URL antes de iniciar.Unlike HTTP.sys (or HttpListener), it doesn't need an Endpoint configuration in ServiceManifest.xml because it doesn't require URL registration before starting.

Usar o Kestrel com uma porta estáticaUse Kestrel with a static port

Você pode configurar uma porta estática na Endpoint configuração de immanifest. xml para uso com Kestrel.You can configure a static port in the Endpoint configuration of ServiceManifest.xml for use with Kestrel. Embora isso não seja estritamente necessário, ele oferece dois benefícios potenciais:Although this isn't strictly necessary, it offers two potential benefits:

  • Se a porta não cair no intervalo de portas do aplicativo, ela será aberta por meio do firewall do sistema operacional pelo Service Fabric.If the port doesn't fall in the application port range, it's opened through the OS firewall by Service Fabric.
  • A URL fornecida por KestrelCommunicationListener você usará essa porta.The URL provided to you through KestrelCommunicationListener will use this port.
  <Resources>
    <Endpoints>
      <Endpoint Protocol="http" Name="ServiceEndpoint" Port="80" />
    </Endpoints>
  </Resources>

Se um Endpoint for configurado, seu nome deverá ser passado para o KestrelCommunicationListener Construtor:If an Endpoint is configured, its name must be passed into the KestrelCommunicationListener constructor:

new KestrelCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) => ...

Se o Service manifest. xml não usar Endpoint uma configuração, omita o nome KestrelCommunicationListener no construtor.If ServiceManifest.xml doesn't use an Endpoint configuration, omit the name in the KestrelCommunicationListener constructor. Nesse caso, ele usará uma porta dinâmica.In this case, it will use a dynamic port. Consulte a próxima seção para obter mais informações sobre isso.See the next section for more information about this.

Usar o Kestrel com uma porta dinâmicaUse Kestrel with a dynamic port

O Kestrel não pode usar a atribuição de porta Endpoint automática da configuração em um manifesto. xml.Kestrel can't use the automatic port assignment from the Endpoint configuration in ServiceManifest.xml. Isso ocorre porque a atribuição automática de porta Endpoint de uma configuração atribui uma porta exclusiva por processo de host, e um único processo de host pode conter várias instâncias de Kestrel.That's because automatic port assignment from an Endpoint configuration assigns a unique port per host process, and a single host process can contain multiple Kestrel instances. Isso não funciona com Kestrel porque não dá suporte ao compartilhamento de porta.This doesn't work with Kestrel because it doesn't support port sharing. Portanto, cada instância de Kestrel deve ser aberta em uma porta exclusiva.Therefore, each Kestrel instance must be opened on a unique port.

Para usar a atribuição de porta dinâmica com Kestrel, Endpoint omita totalmente a configuração no Service manifest. xml e não passe um nome de ponto KestrelCommunicationListener de extremidade para o construtor, da seguinte maneira:To use dynamic port assignment with Kestrel, omit the Endpoint configuration in ServiceManifest.xml entirely, and don't pass an endpoint name to the KestrelCommunicationListener constructor, as follows:

new KestrelCommunicationListener(serviceContext, (url, listener) => ...

Nessa configuração, KestrelCommunicationListener o selecionará automaticamente uma porta não usada do intervalo de portas do aplicativo.In this configuration, KestrelCommunicationListener will automatically select an unused port from the application port range.

Provedor de configuração de Service FabricService Fabric configuration provider

A configuração do aplicativo no ASP.NET Core é baseada em pares chave-valor estabelecidos pelo provedor de configuração.App configuration in ASP.NET Core is based on key-value pairs established by the configuration provider. Leia configuração no ASP.NET Core para saber mais sobre o suporte geral ASP.NET Core configuração.Read Configuration in ASP.NET Core to understand more on general ASP.NET Core configuration support.

Esta seção descreve como o provedor de configuração do Service Fabric se integra com a configuração do Microsoft.ServiceFabric.AspNetCore.Configuration ASP.NET Core importando o pacote NuGet.This section describes how the Service Fabric configuration provider integrates with ASP.NET Core configuration by importing the Microsoft.ServiceFabric.AspNetCore.Configuration NuGet package.

Extensões de inicialização do AddServiceFabricConfigurationAddServiceFabricConfiguration startup extensions

Depois de importar o Microsoft.ServiceFabric.AspNetCore.Configuration pacote NuGet, você precisa registrar a fonte de configuração Service Fabric com ASP.NET Core API de configuração.After you import the Microsoft.ServiceFabric.AspNetCore.Configuration NuGet package, you need to register the Service Fabric Configuration source with ASP.NET Core configuration API. Faça isso verificando extensões AddServiceFabricConfiguration no namespace em Microsoft.ServiceFabric.AspNetCore.Configuration relação IConfigurationBuildera.You do this by checking AddServiceFabricConfiguration extensions in the Microsoft.ServiceFabric.AspNetCore.Configuration namespace against IConfigurationBuilder.

using Microsoft.ServiceFabric.AspNetCore.Configuration;

public Startup(IHostingEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
        .AddServiceFabricConfiguration() // Add Service Fabric configuration settings.
        .AddEnvironmentVariables();
    Configuration = builder.Build();
}

public IConfigurationRoot Configuration { get; }

Agora, o serviço de ASP.NET Core pode acessar as definições de configuração de Service Fabric, assim como qualquer outra configuração de aplicativo.Now the ASP.NET Core service can access the Service Fabric configuration settings, just like any other application settings. Por exemplo, você pode usar o padrão de opções para carregar as configurações em objetos com rigidez de tipos.For example, you can use the options pattern to load settings into strongly typed objects.

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<MyOptions>(Configuration);  // Strongly typed configuration object.
    services.AddMvc();
}

Mapeamento de chave padrãoDefault key mapping

Por padrão, o provedor de configuração Service Fabric inclui o nome do pacote, o nome da seção e o nome da propriedade.By default, the Service Fabric configuration provider includes the package name, section name, and property name. Juntos, eles formam a chave de configuração ASP.NET Core, da seguinte maneira:Together, these form the ASP.NET Core configuration key, as follows:

$"{this.PackageName}{ConfigurationPath.KeyDelimiter}{section.Name}{ConfigurationPath.KeyDelimiter}{property.Name}"

Por exemplo, se você tiver um pacote de configuração MyConfigPackage chamado com o conteúdo a seguir, o valor de configuração estará disponível em IConfiguration ASP.NET Core por meio de MyConfigPackage: myconfigsection: MyParameter.For example, if you have a configuration package named MyConfigPackage with the following content, then the configuration value will be available on ASP.NET Core IConfiguration through MyConfigPackage:MyConfigSection:MyParameter.

<?xml version="1.0" encoding="utf-8" ?>
<Settings xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.microsoft.com/2011/01/fabric">  
  <Section Name="MyConfigSection">
    <Parameter Name="MyParameter" Value="Value1" />
  </Section>  
</Settings>

Opções de configuração do Service FabricService Fabric configuration options

O provedor de configuração de Service Fabric ServiceFabricConfigurationOptions também dá suporte para alterar o comportamento padrão do mapeamento de chave.The Service Fabric configuration provider also supports ServiceFabricConfigurationOptions to change the default behavior of key mapping.

Configurações criptografadasEncrypted settings

O Service Fabric dá suporte a configurações criptografadas, assim como o provedor de configuração de Service Fabric.Service Fabric supports encrypted settings, as does the Service Fabric configuration provider. As configurações criptografadas não são descriptografadas para ASP.NET Core IConfiguration por padrão.The encrypted settings aren't decrypted to ASP.NET Core IConfiguration by default. Em vez disso, os valores criptografados são armazenados nesse local.The encrypted values are stored there instead. Mas se você quiser descriptografar o valor a ser armazenado no ASP.NET Core IConfiguration, poderá definir o sinalizador decryptvalue como false na AddServiceFabricConfiguration extensão, da seguinte maneira:But if you want to decrypt the value to store in ASP.NET Core IConfiguration, you can set the DecryptValue flag to false in the AddServiceFabricConfiguration extension, as follows:

public Startup()
{
    ICodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
    var builder = new ConfigurationBuilder()        
        .AddServiceFabricConfiguration(activationContext, (options) => options.DecryptValue = false); // set flag to decrypt the value
    Configuration = builder.Build();
}

Vários pacotes de configuraçãoMultiple configuration packages

O Service Fabric dá suporte a vários pacotes de configuração.Service Fabric supports multiple configuration packages. Por padrão, o nome do pacote é incluído na chave de configuração.By default, the package name is included in the configuration key. Mas você pode definir o IncludePackageName sinalizador como false, da seguinte maneira:But you can set the IncludePackageName flag to false, as follows:

public Startup()
{
    ICodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
    var builder = new ConfigurationBuilder()        
        // exclude package name from key.
        .AddServiceFabricConfiguration(activationContext, (options) => options.IncludePackageName = false); 
    Configuration = builder.Build();
}

Mapeamento de chave personalizada, extração de valor e população de dadosCustom key mapping, value extraction, and data population

O provedor de configuração de Service Fabric também dá suporte a cenários mais avançados para personalizar ExtractKeyFunc o mapeamento de chave com e extrair ExtractValueFuncos valores personalizados com.The Service Fabric configuration provider also supports more advanced scenarios to customize the key mapping with ExtractKeyFunc and custom-extract the values with ExtractValueFunc. Você pode até mesmo alterar todo o processo de preenchimento de dados da configuração Service Fabric para ASP.NET Core configuração ConfigActionusando o.You can even change the whole process of populating data from Service Fabric configuration to ASP.NET Core configuration by using ConfigAction.

Os exemplos a seguir ilustram como ConfigAction usar o para personalizar a população de dados:The following examples illustrate how to use ConfigAction to customize data population:

public Startup()
{
    ICodePackageActivationContext activationContext = FabricRuntime.GetActivationContext();
    
    this.valueCount = 0;
    this.sectionCount = 0;
    var builder = new ConfigurationBuilder();
    builder.AddServiceFabricConfiguration(activationContext, (options) =>
        {
            options.ConfigAction = (package, configData) =>
            {
                ILogger logger = new ConsoleLogger("Test", null, false);
                logger.LogInformation($"Config Update for package {package.Path} started");

                foreach (var section in package.Settings.Sections)
                {
                    this.sectionCount++;

                    foreach (var param in section.Parameters)
                    {
                        configData[options.ExtractKeyFunc(section, param)] = options.ExtractValueFunc(section, param);
                        this.valueCount++;
                    }
                }

                logger.LogInformation($"Config Update for package {package.Path} finished");
            };
        });
  Configuration = builder.Build();
}

Atualizações de configuraçãoConfiguration updates

O provedor de configuração de Service Fabric também dá suporte a atualizações de configuração.The Service Fabric configuration provider also supports configuration updates. Você pode usar ASP.NET Core IOptionsMonitor para receber notificações de alteração e, em IOptionsSnapshot seguida, usar para recarregar os dados de configuração.You can use ASP.NET Core IOptionsMonitor to receive change notifications, and then use IOptionsSnapshot to reload configuration data. Para obter mais informações, consulte Opções de ASP.NET Core.For more information, see ASP.NET Core options.

Essas opções têm suporte por padrão.These options are supported by default. Nenhuma codificação adicional é necessária para habilitar atualizações de configuração.No further coding is needed to enable configuration updates.

Cenários e configuraçõesScenarios and configurations

Esta seção fornece a combinação de servidor Web, configuração de porta, opções de integração de Service Fabric e configurações diversas que recomendamos para solucionar os seguintes cenários:This section provides the combination of web server, port configuration, Service Fabric integration options, and miscellaneous settings we recommend to troubleshoot the following scenarios:

  • Serviços sem estado ASP.NET Core e expostos externamenteExternally exposed ASP.NET Core stateless services
  • Somente interno ASP.NET Core serviços sem monitoração de estadoInternal-only ASP.NET Core stateless services
  • Somente interno ASP.NET Core serviços com estadoInternal-only ASP.NET Core stateful services

Um serviço exposto externamente é aquele que expõe um ponto de extremidade chamado de fora do cluster, geralmente por meio de um balanceador de carga.An externally exposed service is one that exposes an endpoint that's called from outside the cluster, usually through a load balancer.

Um serviço somente interno é aquele cujo ponto de extremidade é chamado apenas de dentro do cluster.An internal-only service is one whose endpoint is only called from within the cluster.

Nota

Os pontos de extremidade de serviço com estado geralmente não devem ser expostos à Internet.Stateful service endpoints generally shouldn't be exposed to the internet. Os clusters por trás de balanceadores de carga que não reconhecem Service Fabric resolução de serviço, como Azure Load Balancer, não poderão expor serviços com estado.Clusters behind load balancers that are unaware of Service Fabric service resolution, such as Azure Load Balancer, will be unable to expose stateful services. Isso ocorre porque o balanceador de carga não poderá localizar e rotear o tráfego para a réplica de serviço com estado apropriada.That's because the load balancer won't be able to locate and route traffic to the appropriate stateful service replica.

Serviços sem estado ASP.NET Core e expostos externamenteExternally exposed ASP.NET Core stateless services

Kestrel é o servidor Web sugerido para serviços de front-end que expõem pontos de extremidade HTTP externos para a Internet.Kestrel is the suggested web server for front-end services that expose external, internet-facing HTTP endpoints. No Windows, o HTTP. sys pode fornecer a capacidade de compartilhamento de porta, que permite hospedar vários serviços Web no mesmo conjunto de nós usando a mesma porta.On Windows, HTTP.sys can provide port sharing capability, which allows you to host multiple web services on the same set of nodes using the same port. Nesse cenário, os serviços Web são diferenciados por nome de host ou caminho, sem depender de um proxy de front-end ou gateway para fornecer roteamento HTTP.In this scenario, the web services are differentiated by host name or path, without relying on a front-end proxy or gateway to provide HTTP routing.

Quando exposto à Internet, um serviço sem estado deve usar um ponto de extremidade bem conhecido e estável acessível por meio de um balanceador de carga.When exposed to the internet, a stateless service should use a well-known and stable endpoint that's reachable through a load balancer. Você fornecerá essa URL para os usuários do seu aplicativo.You'll provide this URL to your application's users. Recomendamos a seguinte configuração:We recommend the following configuration:

NotasNotes
Servidor WebWeb server KestrelKestrel Kestrel é o servidor Web preferencial, pois tem suporte no Windows e no Linux.Kestrel is the preferred web server, as it's supported across Windows and Linux.
Configuração de portaPort configuration estáticostatic Uma porta estática conhecida deve ser configurada na Endpoints configuração de manifestar. xml, como 80 para http ou 443 para https.A well-known static port should be configured in the Endpoints configuration of ServiceManifest.xml, such as 80 for HTTP or 443 for HTTPS.
ServiceFabricIntegrationOptionsServiceFabricIntegrationOptions NenhumNone Use a ServiceFabricIntegrationOptions.None opção ao configurar o middleware de integração Service Fabric, para que o serviço não tente validar solicitações de entrada para um identificador exclusivo.Use the ServiceFabricIntegrationOptions.None option when configuring Service Fabric integration middleware, so that the service doesn't attempt to validate incoming requests for a unique identifier. Os usuários externos do seu aplicativo não saberão as informações exclusivas de identificação que o middleware usa.External users of your application won't know the unique identifying information that the middleware uses.
Contagem de InstânciasInstance Count -1-1 Em casos de uso típicos, a configuração de contagem de instâncias deve ser definida como -1.In typical use cases, the instance count setting should be set to -1. Isso é feito para que uma instância esteja disponível em todos os nós que recebem o tráfego de um balanceador de carga.This is done so that an instance is available on all nodes that receive traffic from a load balancer.

Se vários serviços expostos externamente compartilharem o mesmo conjunto de nós, você poderá usar o HTTP. sys com um caminho de URL exclusivo, mas estável.If multiple externally exposed services share the same set of nodes, you can use HTTP.sys with a unique but stable URL path. Você pode fazer isso modificando a URL fornecida ao configurar o IWebHost.You can accomplish this by modifying the URL provided when configuring IWebHost. Observe que isso se aplica somente a HTTP. sys.Note that this applies to HTTP.sys only.

new HttpSysCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
{
    url += "/MyUniqueServicePath";

    return new WebHostBuilder()
        .UseHttpSys()
        ...
        .UseUrls(url)
        .Build();
})

Serviço de ASP.NET Core sem estado somente internoInternal-only stateless ASP.NET Core service

Os serviços sem estado que são chamados apenas de dentro do cluster devem usar URLs exclusivas e portas atribuídas dinamicamente para garantir a cooperação entre vários serviços.Stateless services that are only called from within the cluster should use unique URLs and dynamically assigned ports to ensure cooperation between multiple services. Recomendamos a seguinte configuração:We recommend the following configuration:

NotasNotes
Servidor WebWeb server KestrelKestrel Embora você possa usar HTTP. sys para serviços sem estado internos, o Kestrel é o melhor servidor para permitir que várias instâncias de serviço compartilhem um host.Although you can use HTTP.sys for internal stateless services, Kestrel is the best server to allow multiple service instances to share a host.
Configuração de portaPort configuration atribuído dinamicamentedynamically assigned Várias réplicas de um serviço com estado podem compartilhar um processo de host ou sistema operacional do host e, portanto, precisarão de portas exclusivas.Multiple replicas of a stateful service might share a host process or host operating system and thus will need unique ports.
ServiceFabricIntegrationOptionsServiceFabricIntegrationOptions UseUniqueServiceUrlUseUniqueServiceUrl Com a atribuição de porta dinâmica, essa configuração impede o problema de identidade equivocado descrito anteriormente.With dynamic port assignment, this setting prevents the mistaken identity issue described earlier.
InstanceCountInstanceCount qualquerany A configuração contagem de instâncias pode ser definida como qualquer valor necessário para operar o serviço.The instance count setting can be set to any value necessary to operate the service.

Serviço de ASP.NET Core com estado somente internoInternal-only stateful ASP.NET Core service

Serviços com estado que são chamados apenas de dentro do cluster devem usar portas atribuídas dinamicamente para garantir a cooperação entre vários serviços.Stateful services that are only called from within the cluster should use dynamically assigned ports to ensure cooperation between multiple services. Recomendamos a seguinte configuração:We recommend the following configuration:

NotasNotes
Servidor WebWeb server KestrelKestrel O HttpSysCommunicationListener não é projetado para uso por serviços com estado em que as réplicas compartilham um processo de host.The HttpSysCommunicationListener isn't designed for use by stateful services in which replicas share a host process.
Configuração de portaPort configuration atribuído dinamicamentedynamically assigned Várias réplicas de um serviço com estado podem compartilhar um processo de host ou sistema operacional do host e, portanto, precisarão de portas exclusivas.Multiple replicas of a stateful service might share a host process or host operating system and thus will need unique ports.
ServiceFabricIntegrationOptionsServiceFabricIntegrationOptions UseUniqueServiceUrlUseUniqueServiceUrl Com a atribuição de porta dinâmica, essa configuração impede o problema de identidade equivocado descrito anteriormente.With dynamic port assignment, this setting prevents the mistaken identity issue described earlier.

Passos SeguintesNext steps

Depurar a sua aplicação do Service Fabric com o Visual StudioDebug your Service Fabric application by using Visual Studio