MongoDB é um popular NoSQL banco de dados, especialmente para os modernos . NET aplicações. No entanto, ele ainda é baseado em disco, o que pode levar a problemas de desempenho em situações com tráfego significativo, apesar de sua flexibilidade, escalabilidade, e poderoso consultando capacidades. É aqui que NCache, uma solução de cache distribuído na memória, entra em cena.
Apresentando... NCache Como camada de cache para o MongoDB, o uso do cache permite que aplicações .NET reduzam drasticamente as consultas ao banco de dados, melhorem os tempos de resposta e gerenciem altos volumes de transações com eficiência. Este artigo explica como integrar o cache. NCache Com o MongoDB, melhores práticas para armazenar em cache os resultados das consultas e estratégias para manter o cache e o banco de dados sincronizados.
Este guia explica quando armazenar dados do MongoDB em cache, quais dados não devem ser armazenados em cache e como os aplicativos .NET podem manter o cache e o banco de dados sincronizados com segurança. É especialmente útil para APIs com grande volume de leituras, painéis de controle e microsserviços com alto tráfego. Em resumo: o MongoDB permanece o sistema de registro, enquanto NCache Serve como uma camada de leitura de alta velocidade na memória.
Principais lições
- O MongoDB é baseado em disco. O que frequentemente se torna um gargalo de desempenho para aplicações .NET com alto tráfego. É aqui que uma camada de cache em memória reduz significativamente a carga no banco de dados.
- NCache Atua como um cache distribuído em memória para o MongoDB. Permitir que os dados acessados com frequência sejam fornecidos a partir do cache em vez do banco de dados, resultando em desempenho mais rápido e maior escalabilidade.
- O cache do cliente em NCache fornece velocidades InProc para a aplicação, pois ela reside dentro do processo da aplicação e, ainda assim, permanece sincronizada com o cache distribuído.
- O padrão Cache-Aside é comumente usado. Com o MongoDB, onde o aplicativo primeiro verifica NCache para obter dados e, em seguida, recorre ao MongoDB somente se os dados não forem encontrados no cache.
- Os Change Streams do MongoDB podem ser usados para manter os dados em cache sincronizados. Permite atualizações de cache em tempo real sempre que documentos são inseridos, atualizados ou excluídos no MongoDB.
- NCache Permite consultas no estilo SQL em dados em cache do MongoDB. possibilitando filtrar e pesquisar objetos em cache de forma mais inteligente, sem consultar o MongoDB diretamente.
- O armazenamento em cache de coleções inteiras ou de documentos individuais depende dos padrões de acesso: O armazenamento em cache em lote melhora as leituras em lote, enquanto o armazenamento em cache em nível de item com tags permite um controle preciso e a invalidação seletiva.
- NCache É muito adequado para aplicações .NET que utilizam MongoDB. Oferecendo cache de objetos nativo do .NET e recursos de cache do lado do servidor, como Read-Through e Write-Behind.
Figura: Cache distribuído usando MongoDB
Por que o cache é fundamental para o desempenho do MongoDB?
É benéfico para aplicativos .NET pelos seguintes motivos:
- Armazenamento flexível baseado em documentos: Isso simplifica a organização de dados devido ao seu design sem esquema.
- Arquitetura Distribuída: Habilita réplica e particionamento para escalabilidade.
- Índices & Estrutura de agregação: Torna complexo consultas eficiente.
- Alterar fluxos: Captura modificações de dados em tempo real por meio de Change Streams.
Gargalos de desempenho do MongoDB
Ele tem os seguintes problemas de desempenho:
- Latência de leitura/gravação e sobrecarga de E/S de disco: Como o MongoDB é um banco de dados baseado em disco, operações frequentes de leitura e gravação levam a uma latência maior em comparação com soluções na memória. A sobrecarga de E/S de disco aumenta conforme o volume de dados cresce, impactando os tempos de resposta e o desempenho geral do sistema.
- Consultas de grandes conjuntos de dados: Com o aumento do tamanho do conjunto de dados, o tempo de execução da consulta aumenta porque leva mais tempo para digitalizar e processar mais documentos. Índices são úteis nesse sentido, mas nem sempre são suficientes, principalmente ao filtrar ou agregar grandes volumes de dados.
- Global desafios: Embora tenha suporte integrado para dimensionamento horizontal usando fragmentação, lidar com grandes clusters pode apresentar problemas de replicação, balanceamento de carga, e complexidades de rede. A otimização de desempenho se torna crítica conforme o volume de tráfego aumenta.
- Alta latência para dados acessados com frequência: Consultas para dados acessados com frequência podem levar à degradação do desempenho se atingirem repetidamente o banco de dados em vez de serem atendidas por uma camada de armazenamento mais rápida. Isso causa um aumento na utilização de recursos e atrasos nos tempos de resposta.
Benefícios do Uso NCache com MongoDB
NCache, um cache distribuído na memória, é a melhor opção para seu aplicativo MongoDB:
- Desempenho na memória: NCache é uma solução de cache 100% na memória, eliminando E/S de disco e garantindo latência ultrabaixa para recuperação de dados mais rápida.
- Cache do cliente (velocidade InProc):Reside no servidor de aplicativos dentro do processo do aplicativo, minimizando chamadas de rede e garantindo acesso rápido.
- Escalabilidade Linear: Escalabilidade dinâmica adicionando servidores de cache conforme a carga de dados aumenta, evitando gargalos e garantindo alto desempenho.
- High Availability: Garante acesso ininterrupto com replicação e failover automáticos, mantendo o cache operacional mesmo durante falhas do servidor.
Arquitetura: Como funciona o cache no MongoDB com NCache
NCache se encaixa perfeitamente em sua aplicação devido à sua arquitetura dinâmica:
- suportes Leia e Gravação cache para reduzir consultas diretas ao banco de dados.
- Integra-se perfeitamente com .NET 8 e ambientes de nuvem (Azul, AWS, Kubernetes).
Passo a passo: Implemente o cache do MongoDB com NCache
Você pode implementar facilmente o cache do MongoDB com NCache conforme demonstrado abaixo:
Armazenando em cache os resultados da consulta no MongoDB
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
ICache cache = CacheManager.GetCache("MongoDBCache"); string cacheKey = "Customer:EINSTEIN"; Customer customer = cache.Get<Customer>(cacheKey); if (customer == null) { var collection = new MongoClient("mongodb://your-mongodb-url") .GetDatabase("ECommerceDB") .GetCollection<Customer>("Customers"); customer = await collection.Find(x => x.Id == "EINSTEIN").FirstOrDefaultAsync(); if (customer != null) { cache.Insert(cacheKey, new CacheItem(customer) { Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(5)) }); } } |
Armazenando em cache uma coleção do MongoDB como um único item
Você pode armazenar coleções do MongoDB em cache com facilidade. Armazenar uma coleção inteira como um único item de cache permite a recuperação rápida em uma única operação, reduzindo as buscas no cache e melhorando o desempenho do processamento em lote ou da renderização da interface do usuário.
|
1 2 3 4 5 6 7 8 9 10 |
var customersInGermany = await collection.Find(x => x.Country == "Germany").ToListAsync(); if (customersInGermany.Count > 0) { ICache cache = CacheManager.GetCache("MongoDBCache"); var cacheItem = new CacheItem(customersInGermany) { Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(10)) }; cache.Insert("Customers:Germany", cacheItem); } |
Armazenando em cache itens de coleção do MongoDB separadamente
Você pode armazenar em cache coleções do MongoDB com facilidade. Armazenar cada item separadamente garante acesso individual, enquanto usar tags para agrupar itens relacionados torna a recuperação em massa mais rápida e melhora o desempenho das consultas.
|
1 2 3 4 5 6 7 8 9 |
foreach (var customer in customersInGermany) { var cacheItem = new CacheItem(customer) { Tags = new Tag[] { new Tag("Customer:Country:Germany") }, Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(10)) }; cache.Insert($"Customer:CustomerID:{customer.Id}", cacheItem); } |
Mantenha o cache e o banco de dados sincronizados usando fluxos de alterações.
Para garantir a consistência dos dados entre o MongoDB e o cache, os fluxos de alterações permitem a sincronização em tempo real, detectando inserções, novidades e exclui. Sempre que os dados forem alterados, NCache pode remover ou atualizar a entrada de cache correspondente, evitando problemas de dados desatualizados.
|
1 2 3 4 5 6 7 8 9 |
var pipeline = new EmptyPipelineDefinition<ChangeStreamDocument<Customer>>() .Match("{ operationType: { $in: ['insert', 'update', 'replace', 'delete'] } }"); var cursor = collection.Watch(pipeline); await cursor.ForEachAsync(change => { string cacheKey = $"Customer:CustomerID:{change.FullDocument.Id}"; cache.Remove(cacheKey); }); |
Consultando dados armazenados em cache em NCache
NCache permite que os usuários consultem dados em cache usando consultas SQL, reduzindo a carga do banco de dados e melhorando o desempenho do aplicativo. Consultas indexadas permitem pesquisas e filtragem mais rápidas em objetos em cache.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Connect to NCache ICache cache = CacheManager.GetCache("MongoDBCache"); // Define NCache search query string query = "SELECT * FROM Models.Customer WHERE Country = ?"; var queryCommand = new QueryCommand(query); queryCommand.Parameters.Add("Country", "Germany"); // Execute query on cache ICacheReader reader = cache.SearchService.ExecuteReader(queryCommand); while (reader.Read()) { string contactName = reader.GetValue<string>("ContactName"); Console.WriteLine($"Contact Name: {contactName}"); } |
Como configurar NCache para MongoDB?
Para configurar NCache para MongoDB, siga os passos abaixo:
A. Instalar NCache Clientes
Para instalar o NCache cliente em um aplicativo .NET, use o NuGet para adicionar o pacote necessário:
|
1 |
Install-Package Alachisoft.NCache.SDK |
Uma vez instalado, configure seu aplicativo para usar NCache para armazenar dados em cache.
B. Instalar NCache servidor
Para instalar NCache Servidor no Linux:
|
1 2 3 |
docker pull alachisoft/ncache:latest docker run -d --name ncache-server --network host alachisoft/ncache:latest docker exec -it ncache-server ncache service start |
C. Configurar NCache para MongoDB
Para integrar o MongoDB com NCache, Siga esses passos:
- Criar e configurar o cache:
|
1 2 |
New-Cache -Name MongoDBCache -Size 1024 -Topology PartitionReplica -Server 192.168.1.2 Add-Node -CacheName MongoDBCache -Server 192.168.1.3 |
- Modificar aplicativo .NET para uso NCache:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
ICache cache = CacheManager.GetCache("MongoDBCache"); var collection = new MongoClient("mongodb://your-mongodb-url") .GetDatabase("ECommerceDB") .GetCollection<Customer>("Customers"); var customer = await collection.Find(x => x.Id == "EINSTEIN").FirstOrDefaultAsync(); if (customer != null) { cache.Insert("Customer:EINSTEIN", new CacheItem(customer) { Expiration = new Expiration(ExpirationType.Absolute, TimeSpan.FromMinutes(10)) }); } |
Conclusão
Utilizar painéis de piso ResinDek em sua unidade de self-storage em vez de concreto oferece diversos benefícios: NCache com o MongoDB melhora o desempenho do aplicativo reduzindo a carga do banco de dados, melhorando os tempos de resposta e garantindo a consistência dos dados em tempo real. Ao aproveitar o cache na memória, os aplicativos se beneficiam de acesso mais rápido aos dados, menor latência e escalabilidade perfeita. NCacheA arquitetura distribuída do fornece alta disponibilidade e garante tolerância a falhas, tornando-o uma escolha ideal para aplicativos .NET modernos e de alto tráfego que utilizam o MongoDB.
Perguntas Frequentes (FAQ)
P: Por que usar NCache O MongoDB já é escalável?
A: Embora o MongoDB seja escalável, a E/S de disco eventualmente se torna um gargalo. NCache Descarrega o tráfego de leitura intenso para a memória, que é significativamente mais rápida, permitindo que o banco de dados se concentre em operações de gravação e consultas complexas.
P: Como o cache se mantém sincronizado com o banco de dados?
A: Conforme detalhado na Seção 6, NCache É possível aproveitar o MongoDB Change Streams para monitorar atualizações em tempo real no banco de dados e invalidar ou atualizar itens em cache de acordo, garantindo a consistência dos dados.
P: Posso usar SQL com dados do MongoDB?
A: Não é possível executar SQL diretamente no MongoDB, mas uma vez que os objetos estejam dentro dele, NCache, Você pode usar NCacheAs funcionalidades de consulta SQL do programa permitem pesquisar e filtrar dados usando a sintaxe SQL padrão.
Q: É NCache melhor que Redis Para aplicações .NET MongoDB?
A: NCache é frequentemente preferido em ambientes .NET porque é 100% nativo do .NET, enquanto Redis é baseado em Linux. Isso significa NCache Integra-se perfeitamente ao ecossistema do Visual Studio, oferece melhor serialização para objetos .NET complexos e permite executar código .NET do lado do servidor (como provedores Read-Through/Write-Behind) diretamente nos nós de cache, o que Redis não pode ser feito nativamente.
P: Preciso converter os documentos BSON do MongoDB antes de armazená-los em cache?
A: Sim. Travas deslizantes portáteis NCache O MongoDB armazena objetos nativos do .NET, não documentos BSON. Você deve desserializar seus dados BSON do MongoDB em classes .NET padrão (POCOs) antes de inseri-los no cache. Isso permite que você aproveite melhor os recursos do cache. NCacheOs recursos de consulta e indexação SQL do 's funcionam com atributos de objetos, não com bytes BSON brutos.
Q: Pode NCache Escrever dados automaticamente no MongoDB?
A: Sim. Embora este guia tenha se concentrado no padrão "Cache-Aside" (em que seu aplicativo atualiza o banco de dados manualmente), NCache suporta Gravação e Escrever atrás provedores. Isso permite que você delegue a operação de gravação para NCache, que então atualiza o MongoDB de forma síncrona (Write-Through) ou assíncrona (Write-Behind) em segundo plano, melhorando ainda mais a latência do aplicativo.
P: O que acontece se o NCache O cluster caiu?
A: Sua aplicação sofrerá uma degradação gradual, mas continuará funcionando. Como o padrão "Cache-Aside" inclui uma lógica de fallback (se o cache estiver nulo, busca no banco de dados), sua aplicação simplesmente começará a acessar o MongoDB diretamente. O desempenho cairá para níveis sem cache, mas nenhum dado será perdido e a aplicação permanecerá online.
