Ler em inglês

Compartilhar via


Microsoft Orleans

Orleans:

  • É uma estrutura multiplataforma para a construção de aplicativos distribuídos robustos e escaláveis. Aplicativos distribuídos são definidos como aplicativos que abrangem mais de um único processo, muitas vezes além dos limites do hardware, usando comunicação ponto a ponto.
  • Escala desde um único servidor local até milhares de aplicativos distribuídos e altamente disponíveis na nuvem.
  • Estende conceitos familiares e expressões C# para ambientes multiservidor.
  • Foi projetado para escalar elasticamente. Quando um host ingressa em um cluster, ele pode aceitar novas ativações. Quando um host sai do cluster, as ativações anteriores nesse host serão reativadas nos hosts restantes conforme necessário. Um host pode sair de um cluster devido à redução de escala ou a uma falha da máquina. Um cluster do Orleans pode ser reduzido horizontalmente para um só host. As mesmas propriedades que permitem a escalabilidade elástica permitem a tolerância a falhas. O cluster detecta e se recupera rapidamente de falhas.
  • Simplifica as complexidades do desenvolvimento de aplicativos distribuídos, fornecendo um conjunto comum de padrões e APIs.
  • Permite que desenvolvedores familiarizados com o desenvolvimento de aplicativos de servidor único façam a transição para a construção de serviços nativos da nuvem resilientes e escaláveis ​​e aplicativos distribuídos.
  • Às vezes é chamado de ".NET distribuído".
  • É a estrutura preferida ao criar aplicativos nativos da nuvem.
  • É executado em qualquer lugar com suporte para .NET. Isso inclui hospedagem no Linux, Windows e macOS.
  • Os aplicativos podem ser implantados em Kubernetes, máquinas virtuais e serviços PaaS, como Serviço de Aplicativo do Azure e Aplicativos de Contêiner do Azure.

O "Modelo de Ator"

O Orleans é baseado no "modelo de ator". O modelo de ator teve origem no início da década de 70 e agora é um componente principal do Orleans. O modelo de ator é um modelo de programação no qual cada ator é um objeto leve, coordenado e imutável que encapsula um estado e um comportamento correspondente. Os atores se comunicam exclusivamente entre si usando mensagens assíncronas. Em especial, o Orleans ventou a abstração do Ator Virtual, na qual os atores existem de forma permanente.

Observação

Os atores são entidades puramente lógicas que existem sempre virtualmente. Um ator não pode ser criado nem destruído explicitamente, e sua existência virtual não é afetada pela falha de um servidor que o executa. Como os atores sempre existem, eles são sempre discutidos.

Essa é uma abordagem inovadora para construir uma nova geração de aplicativos distribuídos para a era da nuvem. O Orleans modelo de programação doma a complexidade inerente aos aplicativos distribuídos altamente paralelos sem restringir recursos ou impor restrições ao desenvolvedor.

Para obter mais informações, confira Orleans: Atores Virtuais por meio do Microsoft Research. Um ator virtual é representado como um grão do Orleans.

O que são grãos?

O grão é um dos vários primitivos do Orleans. Em termos de modelo de ator, um grão é um ator virtual. O bloco de construção fundamental em qualquer aplicativo Orleans é um grão. Os grãos são entidades que compreendem identidade, comportamento e estado definidos pelo usuário. Considere a seguinte representação visual de um grão:

Um grão é composto de identidade, comportamento e estado estável.

As identidades de grãos são chaves definidas pelo usuário que tornam os grãos sempre disponíveis para invocação. Os grãos podem ser invocados por outros grãos ou por qualquer número de clientes externos. Cada grão é uma instância de uma classe que implementa uma ou mais das seguintes interfaces:

Os grãos podem ter dados de estado voláteis ou persistentes que podem ser armazenados em qualquer sistema de armazenamento. Assim, os grãos dividem implicitamente os estados do aplicativo, habilitando a escalabilidade automática e simplificando a recuperação de falhas. O estado de grãos é mantido na memória enquanto o grão estiver ativo, levando a uma latência menor e menos carga nos armazenamentos de dados.

O ciclo de vida gerenciado de um grão do Orleans.

A instanciação de grãos é executada automaticamente sob demanda pelo runtime do Orleans. Os grãos que não são usados por um tempo são removidos automaticamente da memória para liberar recursos. Isso é possível devido à sua identidade estável, que permite invocar grãos, independentemente de já estarem carregados na memória ou não. Isso também permite a recuperação transparente da falha porque o chamador não precisa saber em qual servidor um grão cria uma instância em nenhum momento. Os grãos têm um ciclo de vida gerenciado, com o runtime do Orleans responsável por ativar/desativar e colocar/localizar grãos, conforme necessário. Isso permite que o desenvolvedor grave o código como se todos os grãos estivessem sempre na memória.

O que são Silos?

Um silo é outro exemplo de primitivo do Orleans. Um silo hospeda um ou mais grãos. O runtime do Orleans é o que implementa o modelo de programação para aplicativos.

Normalmente, um grupo de silos é executado como um cluster para escalabilidade e tolerância a falhas. Quando executados como um cluster, os silos se coordenam entre si para distribuir o trabalho e detectar e se recuperar de falhas. O runtime permite que os grãos hospedados no cluster se comuniquem entre si como estivessem dentro de um único processo. Para ajudar a visualizar a relação entre clusters, silos e grãos, leve em consideração o seguinte diagrama:

Um cluster tem um ou mais silos, e um silo tem um ou mais grãos.

O diagrama anterior mostra a relação entre clusters, silos e grãos. Você pode ter qualquer quantidade de clusters, cada cluster tem um ou mais silos e cada silo tem um ou mais grãos.

Além do modelo de programação principal, os silos fornecem grãos com um conjunto de serviços de runtime, como temporizadores, lembretes (temporizadores persistentes), persistência, transações, fluxos e muito mais. Para obter mais informações, confira O que posso fazer com o Orleans?

Os aplicativos Web e outros clientes externos chamam grãos no cluster usando a biblioteca de clientes, que gerencia automaticamente a comunicação de rede. Os clientes também podem ser co-hospedados no mesmo processo com silos para simplicidade.

O que posso fazer com o Orleans?

O Orleans é uma estrutura para a criação de aplicativos nativos de nuvem e deve ser considerada sempre que você estiver criando aplicativos .NET que eventualmente precisariam ser dimensionados. Há formas aparentemente infinitas de usar o Orleans, mas algumas das maneiras mais comuns são: jogos, bancos, aplicativos de chat, acompanhamento de GPS, negociação de ações, carrinhos de compras, aplicativos de votação e muito mais. O Orleans é usado pela Microsoft no Azure, Xbox, Skype, Halo, PlayFab, Gears of War e muitos outros serviços internos. O Orleans tem muitos recursos que facilitam o uso para diversos aplicativos.

Persistência

O Orleans fornece um modelo de persistência simples que garante que o estado esteja disponível antes de processar uma solicitação e que sua consistência seja mantida. Os grãos podem ter vários objetos de dados persistentes nomeados. Por exemplo, pode haver um chamado "perfil" para o perfil de um usuário e um chamado "estoque" para seu estoque. Esse estado pode ser armazenado em qualquer sistema de armazenamento.

Enquanto um grão está em execução, o estado é mantido na memória para que as solicitações de leitura possam ser atendidas sem acessar o armazenamento. Quando o grão atualiza seu estado, a chamada IStorage.WriteStateAsync garante que o repositório de backup seja atualizado quanto à durabilidade e consistência.

Para obter mais informações, consulte Persistência de granularidade.

Lembretes e temporizadores

Lembretes são um mecanismo de agendamento durável para grãos. Eles podem ser usados para garantir que alguma ação seja concluída em um ponto futuro, mesmo que o grão não esteja ativado no momento. Os temporizadores são o complementos não duráveis aos lembretes e podem ser usados para eventos de alta frequência, que não exigem confiabilidade.

Para obter mais informações, consulte Temporizadores e lembretes.

Posicionamento flexível de grãos

Quando um grão é ativado no Orleans, o runtime decide em qual servidor (silo) ativar esse grão. Isso é chamado de posicionamento de grãos.

O processo de posicionamento no Orleans pode ser totalmente configurado. Os desenvolvedores podem escolher entre um conjunto de políticas de posicionamento prontas para uso, como aleatórias, prefer-locais e baseadas em carga, ou a lógica personalizada pode ser configurada. Isso permite flexibilidade total na decisão de onde os grãos são criados. Por exemplo, os grãos podem ser colocados em um servidor próximo aos recursos que precisam operar ou em outros grãos com os quais se comunicam.

Para saber mais, consulte o Posicionamento de grãos.

Controle de versão de grãos e clusters heterogêneos

A atualização de sistemas de produção de forma que seja responsável e com segurança para alterações pode ser desafiante, especialmente nos sistemas com estado. Para isso, as interfaces de grão no Orleans podem ser usadas na versão.

O cluster mantém um mapeamento das implementações de grãos disponíveis em quais silos no cluster e nas versões dessas implementações. Essa versão das informações é usada pelo runtime em conjunto com estratégias de posicionamento para tomar decisões no roteamento de chamadas para grãos. Além disso, para atualizar com segurança um grão com controle de versão, também permite clusters heterogêneos, em que diferentes silos têm diferentes conjuntos de implementações de grãos disponíveis.

Para saber mais, consulte o Controle de versão de grãos.

Trabalhadores sem estado

Os trabalhadores sem estado são grãos especialmente marcados que não têm nenhum estado associado e podem ser ativados em vários silos simultaneamente. Isso permite o aumento do paralelismo para funções sem estado.

Para obter mais informações, consulte Grãos para trabalhador sem estado.

Filtros de chamada de grão

Um filtro de chamada de grãos é a lógica comum a muitos grãos. O Orleans dá suporte a filtros para chamadas de entrada e saída. Filtros para autorização, registro em log e telemetria e tratamento de erros são considerados comuns.

Contexto da solicitação

Metadados e outras informações podem ser aprovados com uma série de solicitações usando o contexto de solicitação. O contexto de solicitação pode ser usado para manter as informações de rastreamento distribuído ou outros valores definidos pelo usuário.

Transações ACID distribuídas

Além do modelo de persistência simples descrito acima, os grãos podem ter um estado transacional. Vários grãos podem participar de transações ACID juntos, independentemente de onde seu estado esteja armazenado. As transações no Orleans são distribuídas e descentralizadas (não há nenhum gerenciador de transações central ou coordenador de transações) e têm isolamento em série.

Para obter mais informações sobre transações, consulte Transações.

Fluxos

Os fluxos ajudam os desenvolvedores a processar uma série de itens de dados quase em tempo real. Os fluxos do Orleans são gerenciados. Os fluxos não precisam ser criados ou registrados antes que um grão ou cliente publique ou assine um fluxo. Isso permite uma maior separação de produtores de fluxo e consumidores entre si e da infraestrutura.

O processamento de fluxo é confiável: os grãos podem armazenar pontos de verificação (cursores) e redefinir um ponto de verificação armazenado durante a ativação ou a qualquer momento subsequente. Os fluxos dão suporte à entrega em lote de mensagens aos consumidores para melhorar a eficiência e o desempenho de recuperação.

Os fluxos são apoiados por serviços de fila, como Hubs de Eventos do Azure, Amazon Kinesis e outros.

Um número aleatório de fluxos pode ser multiplexado em um número menor de filas e a responsabilidade pelo processamento dessas filas é equilibrada de forma uniforme em todo o cluster.

Vídeo de introdução ao Orleans

Se você tiver interesse em uma introdução em vídeo sobre o Orleans, confira o seguinte vídeo:

Próximas etapas