Önbelleğe AlmaCaching

Önbelleğe alma, bir sistemin performansını ve ölçeklenebilirliğini artırmayı amaçlayan yaygın bir tekniktir.Caching is a common technique that aims to improve the performance and scalability of a system. Bunu başarmak için sık erişilen verileri uygulamaya yakın bir konumdaki hızlı depolama alanına geçici olarak kopyalar.It does this by temporarily copying frequently accessed data to fast storage that's located close to the application. Bu hızlı veri depolama alanının konumu uygulamaya özgün kaynaktan daha yakınsa, önbelleğe alma işlemi verileri daha hızlı sunarak istemci uygulamaların yanıt sürelerini önemli ölçüde artırabilir.If this fast data storage is located closer to the application than the original source, then caching can significantly improve response times for client applications by serving data more quickly.

Önbelleğe alma işleminin en etkili olduğu durum, özellikle özgün veri deposunda aşağıdaki koşullar geçerli olduğunda bir istemci örneğinin aynı verileri tekrarlayarak okumasıdır:Caching is most effective when a client instance repeatedly reads the same data, especially if all the following conditions apply to the original data store:

  • Oldukça statik kalır.It remains relatively static.
  • Önbellek hızıyla karşılaştırıldığında yavaştır.It's slow compared to the speed of the cache.
  • Yüksek düzeyde bir çekişmeye tabidir.It's subject to a high level of contention.
  • Ağ gecikmesi erişimin yavaşlamasına neden olabileceği zaman uzaktadır.It's far away when network latency can cause access to be slow.

Dağıtılmış uygulamalarda önbelleğe almaCaching in distributed applications

Dağıtılmış uygulamalar verileri önbelleğe alırken genellikle aşağıdaki stratejilerin birini ya da her ikisini birden uygular:Distributed applications typically implement either or both of the following strategies when caching data:

  • Bir uygulama ya da hizmetin örneğini çalıştıran bilgisayarda verilerin yerel olarak tutulduğu özel bir önbellek kullanma.Using a private cache, where data is held locally on the computer that's running an instance of an application or service.
  • Birden çok işlem ve makine tarafından erişilebilen ortak bir kaynak olarak hizmet veren paylaşılan bir önbellek kullanma.Using a shared cache, serving as a common source that can be accessed by multiple processes and machines.

Her iki durumda da önbelleğe alma, istemci tarafı ve sunucu tarafı gerçekleştirebilir.In both cases, caching can be performed client-side and server-side. İstemci tarafında önbelleğe alma işlemi, web tarayıcısı ya da masaüstü uygulaması gibi bir sistemin kullanıcı arabirimini sağlayan işlem tarafından yapılır.Client-side caching is done by the process that provides the user interface for a system, such as a web browser or desktop application. Sunucu tarafı önbelleğe alma işlemi, uzaktan çalışan iş hizmetleri sağlayan işlem tarafından gerçekleştirilir.Server-side caching is done by the process that provides the business services that are running remotely.

Özel önbelleğe almaPrivate caching

En temel önbellek türü bir bellek içi depodur.The most basic type of cache is an in-memory store. Tek bir işlemin adres alanında tutulur ve bu işlemde çalışan kod tarafından doğrudan erişilir.It's held in the address space of a single process and accessed directly by the code that runs in that process. Bu tür bir önbellek erişime hızlıdır.This type of cache is quick to access. Ayrıca, bir Önbelleğin boyutu genellikle işlemi barındıran makinede bulunan bellek miktarına göre kısıtlandığı için, aynı zamanda ila büyüklükteki miktarlarındaki statik verilerin depolanması için etkili bir yol sağlayabilir.It can also provide an effective means for storing modest amounts of static data, since the size of a cache is typically constrained by the amount of memory available on the machine hosting the process.

Bellekte fiziksel olarak mümkün olandan daha fazla bilgi depolamanız gerekirse, önbelleğe alınmış verileri yerel dosya sistemine yazabilirsiniz.If you need to cache more information than is physically possible in memory, you can write cached data to the local file system. Bu, bellekte tutulan verilere göre daha yavaş olacaktır, ancak yine de bir ağ üzerinden veri almakla daha hızlı ve daha güvenilir olmalıdır.This will be slower to access than data held in memory, but should still be faster and more reliable than retrieving data across a network.

Bu modeli kullanan bir uygulamanın eşzamanlı olarak çalışan birden fazla örneğine sahipseniz, her uygulama örneği kendi veri kopyasını tutan bağımsız bir önbelleğe sahiptir.If you have multiple instances of an application that uses this model running concurrently, each application instance has its own independent cache holding its own copy of the data.

Önbelleği, özgün verilerin geçmiş bir noktadaki anlık görüntüsü olarak düşünün.Think of a cache as a snapshot of the original data at some point in the past. Bu veriler statik değilse farklı uygulama örnekleri, önbelleklerinde verilerin farklı sürümlerini tutabilir.If this data is not static, it is likely that different application instances hold different versions of the data in their caches. Bu nedenle, Şekil 1'de gösterildiği gibi bu örnekler tarafından gerçekleştirilen aynı sorgu farklı sonuçlar döndürebilir.Therefore, the same query performed by these instances can return different results, as shown in Figure 1.

Bellek içi önbelleği bir uygulamanın farklı örneklerinde kullanma

Şekil 1: Bir uygulamanın farklı örneklerinde bellek içi önbellek kullanma.Figure 1: Using an in-memory cache in different instances of an application.

Paylaşılan önbelleğe alma işlemiShared caching

Paylaşılan bir önbellek kullanmak, bellek içi önbelleğe alma işleminde olabildiği gibi her önbellekte verilerin farklılık gösterebileceğine ilişkin kaygıları hafifletmeye yardımcı olabilir.Using a shared cache can help alleviate concerns that data might differ in each cache, which can occur with in-memory caching. Paylaşılan önbelleğe alma işlemi, farklı uygulama örneklerinin önbelleğe alınmış verilere ait aynı görünümünü görmesini sağlar.Shared caching ensures that different application instances see the same view of cached data. Bunu yapmak için Şekil 2'de gösterildiği gibi önbelleği genellikle ayrı bir hizmetin parçası olarak barındırılan ayrı bir konuma yerleştirir.It does this by locating the cache in a separate location, typically hosted as part of a separate service, as shown in Figure 2.

Paylaşılan önbellek kullanma

Şekil 2: Paylaşılan önbellek kullanma.Figure 2: Using a shared cache.

Paylaşılan önbelleğe alma yaklaşımının önemli bir avantajı, sağladığı ölçeklenebilirlik özelliğidir.An important benefit of the shared caching approach is the scalability it provides. Birçok paylaşılan önbellek hizmeti bir sunucu kümesi kullanılarak uygulanır ve verileri küme genelinde saydam bir şekilde dağıtmak için yazılım kullanır.Many shared cache services are implemented by using a cluster of servers and use software to distribute the data across the cluster transparently. Uygulama örneği, önbellek hizmetine bir istek gönderir.An application instance simply sends a request to the cache service. Temel alınan altyapı kümedeki önbelleğe alınmış verilerin konumunu belirler.The underlying infrastructure determines the location of the cached data in the cluster. Daha fazla sunucu ekleyerek önbelleği kolayca ölçeklendirebilirsiniz.You can easily scale the cache by adding more servers.

Paylaşılan önbelleğe alma yaklaşımın iki ana dezavantajları vardır:There are two main disadvantages of the shared caching approach:

  • Önbellek artık her uygulama örneğinde yerel olarak tutulmadığı için önbelleğe erişim daha yavaştır.The cache is slower to access because it is no longer held locally to each application instance.
  • Ayrı bir önbellek hizmeti uygulama gereksinimi, çözüme karmaşıklık katabilir.The requirement to implement a separate cache service might add complexity to the solution.

Önbelleğe alma özelliğini kullanma konularıConsiderations for using caching

Aşağıdaki bölümlerde bir önbellek tasarlama ve kullanmaya ilişkin konular daha ayrıntılı olarak açıklanmaktadır.The following sections describe in more detail the considerations for designing and using a cache.

Verilerin ne zaman önbelleğe alınacağına karar vermeDecide when to cache data

Önbelleğe alma işlemi performans, ölçeklenebilirlik ve kullanılabilirliği önemli ölçüde artırabilir.Caching can dramatically improve performance, scalability, and availability. Sahip olduğunuz veri miktarı ve bu verilere erişmesi gereken kullanıcı sayısı arttıkça, önbelleğe alma işleminin avantajları çoğalır.The more data that you have and the larger the number of users that need to access this data, the greater the benefits of caching become. Bunun nedeni, önbelleğe alma işleminin özgün veri deposundaki büyük hacimli eşzamanlı istekleri işlemeyle ilişkili gecikme süresi ve çekişmeleri azaltmasıdır.That's because caching reduces the latency and contention that's associated with handling large volumes of concurrent requests in the original data store.

Örneğin, bir veritabanı sınırlı sayıda eşzamanlı bağlantıyı destekleyebilir.For example, a database might support a limited number of concurrent connections. Ancak, temel alınan veritabanı yerine paylaşılan bir önbellekten veri almak, kullanılabilir bağlantı sayısı o anda tükenmiş olsa bile, bir istemci uygulamanın bu verilere erişmesini mümkün kılar.Retrieving data from a shared cache, however, rather than the underlying database, makes it possible for a client application to access this data even if the number of available connections is currently exhausted. Ayrıca, veritabanı kullanılamaz duruma gelirse, istemci uygulamalar önbellekte tutulan verileri kullanarak çalışmaya devam edebilir.Additionally, if the database becomes unavailable, client applications might be able to continue by using the data that's held in the cache.

Sıklıkla okunan ancak nadiren değişiklik yapılan verileri (örneğin, okuma işlemlerinin oranı yazma işlemlerinden büyük olan veriler) önbelleğe almayı düşünün.Consider caching data that is read frequently but modified infrequently (for example, data that has a higher proportion of read operations than write operations). Ancak, önbelleği kritik bilgilerin yetkili deposu olarak kullanmanız önerilmez.However, we don't recommend that you use the cache as the authoritative store of critical information. Bunun yerine, uygulamanızın kaybetmeyi göze alamayacağı tüm değişikliklerin her zaman kalıcı bir veri deposuna kaydedildiğinden emin olun.Instead, ensure that all changes that your application cannot afford to lose are always saved to a persistent data store. Diğer bir deyişle, önbellek kullanılamıyorsa uygulamanız veri deposunu kullanarak yine de çalışmaya devam edebilir ve önemli bilgileri kaybetmezsiniz.This means that if the cache is unavailable, your application can still continue to operate by using the data store, and you won't lose important information.

Verilerin nasıl etkili bir şekilde önbelleğe alınacağını belirlemeDetermine how to cache data effectively

Bir önbelleği etkili bir şekilde kullanmanın anahtarı, önbelleğe alınacak en uygun verilerin belirlenmesi ve uygun zamanda önbelleğe alınmasıdır.The key to using a cache effectively lies in determining the most appropriate data to cache, and caching it at the appropriate time. Veriler bir uygulama tarafından ilk kez alındığında isteğe bağlı olarak önbelleğe eklenebilir.The data can be added to the cache on demand the first time it is retrieved by an application. Bunun yapılması, uygulamanın verileri veri deposundan yalnızca bir kez getirmesinin gerekli olduğu ve sonraki erişimin önbellek kullanılarak yerine getirilebileceği anlamına gelir.This means that the application needs to fetch the data only once from the data store, and that subsequent access can be satisfied by using the cache.

Alternatif olarak, bir önbellek genellikle uygulama başladığında önceden kısmen ya da tamamen doldurulabilir (dengeli dağıtım olarak bilinen yaklaşım).Alternatively, a cache can be partially or fully populated with data in advance, typically when the application starts (an approach known as seeding). Ancak, uygulama çalışmaya başladığında bu yaklaşım özgün veri deposunda ani ve yüksek bir yük oluşturabileceğinden, büyük bir önbellek için dengeli dağıtımın uygulanması önerilmeyebilir.However, it might not be advisable to implement seeding for a large cache because this approach can impose a sudden, high load on the original data store when the application starts running.

Genellikle kullanım düzenlerinin analizi, bir önbelleği tamamen ya da kısmen önceden doldurmaya karar vermenize ve önbelleğe alınacak verileri seçmeye yardımcı olabilir.Often an analysis of usage patterns can help you decide whether to fully or partially prepopulate a cache, and to choose the data to cache. Örneğin, uygulamayı düzenli olarak (belki de her gün) kullanan müşteriler için önbelleği statik kullanıcı profili verileri ile dağıtmak yararlı olabilir, ancak uygulamayı yalnızca haftada bir kez kullanan müşteriler için yararlı olmayabilir.For example, it can be useful to seed the cache with the static user profile data for customers who use the application regularly (perhaps every day), but not for customers who use the application only once a week.

Önbelleğe alma işlemi genellikle değişmez veya seyrek değişen verilerle iyi bir şekilde çalışır.Caching typically works well with data that is immutable or that changes infrequently. Örnekler arasında bir e-ticaret uygulamasındaki ürün ve fiyatlandırma bilgileri veya oluşturulması maliyetli olan paylaşılan statik kaynaklar sayılabilir.Examples include reference information such as product and pricing information in an e-commerce application, or shared static resources that are costly to construct. Kaynak talebini en aza indirmek ve performansı artırmak amacıyla bu verilerin bazıları veya tümü, uygulama başlangıcında önbelleğe yüklenebilir.Some or all of this data can be loaded into the cache at application startup to minimize demand on resources and to improve performance. Ayrıca, güncel olduğundan emin olmak için önbellekteki başvuru verilerini düzenli aralıklarla güncelleştiren veya başvuru verileri değiştiğinde önbelleği yenileyen bir arka plan işlemi olması da uygun olabilir.It might also be appropriate to have a background process that periodically updates reference data in the cache to ensure it is up-to-date, or that refreshes the cache when reference data changes.

Bazı özel durumları olsa da, önbelleğe alma işlemi dinamik veriler için daha az yararlıdır (daha fazla bilgi için bu makalenin sonraki bölümlerinde yer alan Yüksek oranda dinamik verileri önbelleğe alma bölümüne bakın).Caching is less useful for dynamic data, although there are some exceptions to this consideration (see the section Cache highly dynamic data later in this article for more information). Özgün veriler düzenli olarak değiştiğinde, önbelleğe alınmış bilgiler hızla eski hale gelir veya önbelleği özgün veri deposuyla eşitleme yükü, önbelleğe alma işleminin verimliliğini azaltır.When the original data changes regularly, either the cached information becomes stale very quickly or the overhead of synchronizing the cache with the original data store reduces the effectiveness of caching.

Bir önbellekte bir varlığın tam verileri bulunmak zorunda değildir.Note that a cache does not have to include the complete data for an entity. Örneğin, bir veri öğesi ad, adres ve hesap bakiyesi olan bir banka müşterisi gibi çok değerli bir nesneyi temsil ettiğinde, bu öğelerden bazıları (ad ve adres gibi) statik kalabilirken, bazıları (hesap bakiyesi gibi) dinamik olabilir.For example, if a data item represents a multivalued object such as a bank customer with a name, address, and account balance, some of these elements might remain static (such as the name and address), while others (such as the account balance) might be more dynamic. Bu durumlarda verilerin statik kısımlarının önbelleğe alınması ve yalnızca kalan bilgilerin gerekli olduğunda alınması (ya da hesaplanması) yararlı olabilir.In these situations, it can be useful to cache the static portions of the data and retrieve (or calculate) only the remaining information when it is required.

Önbelleğin ön popülasyonu veya isteğe bağlı olarak yüklenmesinin ya da ikisinin bir birleşiminin uygun olup olmadığını anlamak için performans testi ve kullanım analizini gerçekleştirmeniz önerilir.We recommend that you carry out performance testing and usage analysis to determine whether prepopulation or on-demand loading of the cache, or a combination of both, is appropriate. Bu karar, verilerin geçiciliğine ve kullanım düzenine göre verilmelidir.The decision should be based on the volatility and usage pattern of the data. Önbellek kullanımı ve performans analizi, ağır yüklerle karşılaşan ve yüksek oranda ölçeklenebilir olması gereken uygulamalarda özellikle önemlidir.Cache utilization and performance analysis are particularly important in applications that encounter heavy loads and must be highly scalable. Örneğin, yüksek oranda ölçeklenebilir senaryolarda yoğun zamandalar veri deposu üzerindeki yükü azaltmak için önbelleğin dağıtılması mantıklı olabilir.For example, in highly scalable scenarios it might make sense to seed the cache to reduce the load on the data store at peak times.

Önbelleğe alma işlemi ayrıca uygulama çalışırken hesaplamaları yinelemekten kaçınmak için kullanılabilir.Caching can also be used to avoid repeating computations while the application is running. Bir işlem veri dönüştürüyor ve karmaşık bir hesaplama gerçekleştiriyorsa, işlemin sonuçlarını önbelleğe kaydedebilir.If an operation transforms data or performs a complicated calculation, it can save the results of the operation in the cache. Aynı hesaplama daha sonra gerekli olursa, uygulama önbellekten sonuçları alabilir.If the same calculation is required afterward, the application can simply retrieve the results from the cache.

Uygulama, önbellekte tutulan verileri değiştirebilir.An application can modify data that's held in a cache. Ancak, önbelleğin her an kaybolabilecek geçici bir veri deposu olarak düşünülmesi önerilir.However, we recommend thinking of the cache as a transient data store that could disappear at any time. Değerli verileri yalnızca önbellekte depolamayın; bilgileri özgün veri deposunda da tuttuğunuzdan emin olun.Do not store valuable data in the cache only; make sure that you maintain the information in the original data store as well. Böylece, önbellek kullanılamaz duruma gelirse veri kaybetme olasılığını en aza indirirsiniz.This means that if the cache becomes unavailable, you minimize the chance of losing data.

Yüksek oranda dinamik verileri önbelleğe almaCache highly dynamic data

Hızlı değişen bilgileri kalıcı bir veri deposunda depoladığınızda, sistemde bir ek yük oluşturabilir.When you store rapidly changing information in a persistent data store, it can impose an overhead on the system. Örneğin, sürekli olarak durum veya başka bir ölçüm bildiren bir cihaz düşünün.For example, consider a device that continually reports status or some other measurement. Bir uygulama, önbelleğe alınan bilgilerin neredeyse her zaman eski olacağı gerekçesiyle bu verileri önbelleğe almamayı seçerse, aynı gerekçe veri deposundan bu bilgileri depolayıp alırken de geçerli olabilir.If an application chooses not to cache this data on the basis that the cached information will nearly always be outdated, then the same consideration could be true when storing and retrieving this information from the data store. Bu verileri kaydetmek ve getirmek için geçen sürede veriler değişmiş olabilir.In the time it takes to save and fetch this data, it might have changed.

Bunun gibi bir durumda, dinamik bilgileri kalıcı veri deposu yerine doğrudan önbellekte depolamanın avantajlarını göz önünde bulundurun.In a situation such as this, consider the benefits of storing the dynamic information directly in the cache instead of in the persistent data store. Veriler önemsiz ise ve denetim gerektirmiyorsa, ara sıra değişikliğin kaybedilmesi ne olursa olsun.If the data is noncritical and does not require auditing, then it doesn't matter if the occasional change is lost.

Önbellekteki veri süre sonunu yönetmeManage data expiration in a cache

Çoğu durumda, bir önbellekte tutulan veriler özgün veri deposunda tutulan verilerin bir kopyasıdır.In most cases, data that's held in a cache is a copy of data that's held in the original data store. Özgün veri deposundaki veriler önbelleğe alındıktan sonra değişebilir ve önbelleğe alınmış verilerin eskimesine yol açabilir.The data in the original data store might change after it was cached, causing the cached data to become stale. Birçok önbelleğe alma sistemi, önbelleği verilerin süresi dolacak ve eski verilerin kalabileceği süreyi azaltacak şekilde yapılandırmanıza olanak tanır.Many caching systems enable you to configure the cache to expire data and reduce the period for which data may be out of date.

Önbelleğe alınan verilerin süresi dolarsa, önbellekten kaldırılır ve uygulamanın verileri özgün veri deposundan alması gerekir (yeni getirilen bilgileri önbelleğe geri yerleştirebilir).When cached data expires, it's removed from the cache, and the application must retrieve the data from the original data store (it can put the newly fetched information back into cache). Önbelleği yapılandırırken varsayılan bir süre sonu ilkesi ayarlayabilirsiniz.You can set a default expiration policy when you configure the cache. Birçok önbellek hizmetinde, önbellekte program aracılığıyla depoladığınız her bir nesne için de süre sonu belirtebilirsiniz.In many cache services, you can also stipulate the expiration period for individual objects when you store them programmatically in the cache. Bazı önbellekler süre sonunu mutlak bir değer ya da belirtilen süre içinde erişilmemesi halinde öğenin önbellekten kaldırılmasına neden olan bir kayan değer olarak belirtmenize olanak verir.Some caches enable you to specify the expiration period as an absolute value, or as a sliding value that causes the item to be removed from the cache if it is not accessed within the specified time. Bu ayar, yalnızca belirtilen nesneler için önbellek genelindeki süre sonu ilkesini geçersiz kılar.This setting overrides any cache-wide expiration policy, but only for the specified objects.

Not

Önbellek için süre sonunu ve içerdiği nesneleri dikkatlice düşünün.Consider the expiration period for the cache and the objects that it contains carefully. Süreyi çok kısa tutarsanız nesnelerin süresi çok çabuk dolar ve önbelleği kullanma avantajları azalır.If you make it too short, objects will expire too quickly and you will reduce the benefits of using the cache. Süreyi çok uzun tutarsanız verileri eskitme riski oluşur.If you make the period too long, you risk the data becoming stale.

Verilerin çok uzun süre kalmasına izin verilirse önbelleğin dolması da mümkündür.It's also possible that the cache might fill up if data is allowed to remain resident for a long time. Bu durumda, önbelleğe yeni öğe eklemeye yönelik her istek, bazı öğelerin çıkarma olarak bilinen bir işlemde zorla kaldırılmasına yol açabilir.In this case, any requests to add new items to the cache might cause some items to be forcibly removed in a process known as eviction. Önbellek hizmetleri genellikle verileri en uzak zamanda kullanılan (LRU) verilere göre çıkarır, ancak genellikle bu ilkeyi geçersiz kılabilir ve öğelerin çıkarılmasını engelleyebilirsiniz.Cache services typically evict data on a least-recently-used (LRU) basis, but you can usually override this policy and prevent items from being evicted. Ancak, bu yaklaşımı benimserseniz önbellekte mevcut olan belleği aşma riski oluşturabilirsiniz.However, if you adopt this approach, you risk exceeding the memory that's available in the cache. Önbelleğe öğe eklemeye çalışan bir uygulama bir özel durum dışında başarısız olur.An application that attempts to add an item to the cache will fail with an exception.

Bazı önbelleğe alma uygulamaları, ek çıkarma ilkeleri sağlayabilir.Some caching implementations might provide additional eviction policies. Çıkarma ilkelerinin birkaç türü vardır.There are several types of eviction policies. Bunlar:These include:

  • En son kullanılan ilkesi (verilerin yeniden gerekli olmayacağı beklentisi ile).A most-recently-used policy (in the expectation that the data will not be required again).
  • İlk giren ilk çıkar ilkesi (en eski veriler ilk önce çıkarılır).A first-in-first-out policy (oldest data is evicted first).
  • Tetiklenen bir olaya dayalı açık bir kaldırma ilkesi (verilerin değiştirilmesi gibi).An explicit removal policy based on a triggered event (such as the data being modified).

İstemci tarafı önbelleğindeki verileri geçersiz hale getirmeInvalidate data in a client-side cache

İstemci tarafı önbelleğinde tutulan verilerin genellikle istemciye veri sağlayan hizmetin gözetimi dışında olduğu kabul edilir.Data that's held in a client-side cache is generally considered to be outside the auspices of the service that provides the data to the client. Bir hizmet, istemciyi bir istemci tarafı önbelleğine bilgi eklemeye veya önbellekten bilgi kaldırmaya doğrudan zorlayamaz.A service cannot directly force a client to add or remove information from a client-side cache.

Diğer bir deyişle, kötü yapılandırılmış önbellek kullanan bir istemcinin süresi geçmiş bilgileri kullanmaya devam etmesi mümkündür.This means that it's possible for a client that uses a poorly configured cache to continue using outdated information. Örneğin, önbelleğin süre sonu ilkeleri düzgün bir şekilde uygulanmazsa, istemci özgün veri kaynağındaki bilgiler değiştiğinde yerel olarak önbelleğe alınmış eski bilgileri kullanabilir.For example, if the expiration policies of the cache aren't properly implemented, a client might use outdated information that's cached locally when the information in the original data source has changed.

HTTP bağlantısı üzerinden veri sunan bir web uygulaması derliyorsanız, en son bilgileri getirmek için bir web istemcisini (tarayıcı veya web ara sunucusu gibi) örtük olarak zorlayabilir.If you are building a web application that serves data over an HTTP connection, you can implicitly force a web client (such as a browser or web proxy) to fetch the most recent information. Bir kaynak, kaynağın URI'sindeki bir değişiklik ile güncelleştirilirse bunu yapabilirsiniz.You can do this if a resource is updated by a change in the URI of that resource. Web istemcileri genellikle bir kaynağın URI’sini istemci tarafı önbelleğinde anahtar olarak kullanır; bu nedenle, URI değişirse web istemcisi bir kaynağın daha önce önbelleğe alınmış tüm sürümlerini yok sayar ve onun yerine yeni sürümü getirir.Web clients typically use the URI of a resource as the key in the client-side cache, so if the URI changes, the web client ignores any previously cached versions of a resource and fetches the new version instead.

Önbellekte eşzamanlılığı yönetmeManaging concurrency in a cache

Önbellekler genellikle bir uygulamanın birden fazla örneği tarafından paylaşılacak şekilde tasarlanır.Caches are often designed to be shared by multiple instances of an application. Her uygulama örneği, önbellekteki verileri okuyup değiştirebilir.Each application instance can read and modify data in the cache. Sonuç olarak, paylaşılan her deposunda gerçekleşen eşzamanlılık sorunlarının aynısı önbellek için de geçerli olur.Consequently, the same concurrency issues that arise with any shared data store also apply to a cache. Bir uygulamanın önbellekte tutulan verileri değiştirmesi gereken bir durumda, uygulamanın bir örneği tarafından yapılan güncelleştirmelerin, başka bir örnek tarafından yapılan değişikliklerin üzerine yazılmamasını sağlamanız gerekebilir.In a situation where an application needs to modify data that's held in the cache, you might need to ensure that updates made by one instance of the application do not overwrite the changes made by another instance.

Verilerin niteliğine ve çakışma olasılığına bağlı olarak iki eşzamanlılık yaklaşımından birini benimseyebilirsiniz:Depending on the nature of the data and the likelihood of collisions, you can adopt one of two approaches to concurrency:

  • İyimser.Optimistic. Verileri güncelleştirmeden hemen önce uygulama, önbellekteki verilerin alındıktan sonra değiştirilip değiştirilmediğini denetler.Immediately prior to updating the data, the application checks to see whether the data in the cache has changed since it was retrieved. Veri hala aynı ise değişiklik yapılabilir.If the data is still the same, the change can be made. Aksi takdirde, uygulamanın güncelleştirip güncelleştirmeyeceğine karar vermesi gerekir.Otherwise, the application has to decide whether to update it. (Bu kararı yönlendiren iş mantığı, uygulamaya özgü olacaktır.) Bu yaklaşım, güncelleştirmelerin nadir olduğu veya çakışma olasılığının düşük olduğu durumlar için uygundur.(The business logic that drives this decision will be application-specific.) This approach is suitable for situations where updates are infrequent, or where collisions are unlikely to occur.
  • Kötümser.Pessimistic. Uygulama, verileri aldığında başka bir örneğin değiştirmesini önlemek için önbelleğe kilitler.When it retrieves the data, the application locks it in the cache to prevent another instance from changing it. Bu işlem, çakışmaların oluşmamasını sağlar ancak aynı verileri işlemesi gereken diğer örnekleri de engelleyebilir.This process ensures that collisions cannot occur, but they can also block other instances that need to process the same data. Kötümser eşzamanlılık, bir çözümün ölçeklenebilirliğini etkileyebilir ve yalnızca kısa süreli işlemler için önerilir.Pessimistic concurrency can affect the scalability of a solution and is recommended only for short-lived operations. Bu yaklaşım, çakışma olasılığının daha yüksek olduğu durumlarda, özellikle bir uygulama önbellekteki birden fazla öğeyi güncelleştiriyorsa ve bu değişikliklerin tutarlı bir şekilde uygulandığından emin olması gerekiyorsa uygun olabilir.This approach might be appropriate for situations where collisions are more likely, especially if an application updates multiple items in the cache and must ensure that these changes are applied consistently.

Yüksek kullanılabilirlik ve ölçeklenebilirlik uygulama ve performansı artırmaImplement high availability and scalability, and improve performance

Bir önbelleği birincil veri deposu olarak kullanmamaya özen gösterin; bu, önbelleğin doldurulduğu özgün veri deposunun rolüdür.Avoid using a cache as the primary repository of data; this is the role of the original data store from which the cache is populated. Özgün veri deposu, verilerin sürekliliğini sağlamaktan sorumludur.The original data store is responsible for ensuring the persistence of the data.

Çözümlerinizde, paylaşılan bir önbellek hizmetinin kullanılabilirliğine yönelik kritik bağımlılıklar oluşturmamaya dikkat edin.Be careful not to introduce critical dependencies on the availability of a shared cache service into your solutions. Paylaşılan önbelleği sağlayan hizmet kullanılamıyorsa, uygulama çalışmaya devam edebilmelidir.An application should be able to continue functioning if the service that provides the shared cache is unavailable. Uygulama, önbellek hizmetinin sürdürülmesini beklerken askıda kalmamalı veya başarısız olmamalıdır.The application should not hang or fail while waiting for the cache service to resume.

Bu nedenle uygulama, önbellek hizmetinin kullanılabilirliğini algılamaya hazır olmalı ve önbellek erişilemez durumdaysa özgün veri deposuna geri dönmelidir.Therefore, the application must be prepared to detect the availability of the cache service and fall back to the original data store if the cache is inaccessible. Bu senaryoyu gerçekleştirmek için Devre Kesici düzeni yararlıdır.The Circuit-Breaker pattern is useful for handling this scenario. Önbelleği sağlayan hizmet kurtarılabilir ve kullanılabilir hale geldikten sonra veriler özgün veri deposundan okunurken Edilgen Önbellek düzeni gibi bir strateji izlenerek önbellek önceden doldurulabilir.The service that provides the cache can be recovered, and once it becomes available, the cache can be repopulated as data is read from the original data store, following a strategy such as the Cache-aside pattern.

Ancak, önbellek geçici olarak kullanılamadığında uygulama özgün veri deposuna geri düşerse sistem ölçeklenebilirliği etkilenebilir.However, system scalability may be affected if the application falls back to the original data store when the cache is temporarily unavailable. Veri deposu kurtarılırken özgün veri deposuna çok sayıda veri isteği gidebilir, bu yüzden zaman aşımları ve bağlantı hataları yaşanabilir.While the data store is being recovered, the original data store could be swamped with requests for data, resulting in timeouts and failed connections.

Bir uygulamanın her örneğinde tüm uygulama örneklerinin eriştiği ortak önbellekle birlikte yerel ve özel bir önbellek uygulamayı düşünün.Consider implementing a local, private cache in each instance of an application, together with the shared cache that all application instances access. Uygulama bir öğeyi aldığında öncelikle yerel önbelleğini, sonra paylaşılan önbelleğini ve son olarak özgün veri deposunu denetleyebilir.When the application retrieves an item, it can check first in its local cache, then in the shared cache, and finally in the original data store. Yerel önbellek, paylaşılan önbellekteki veya paylaşılan önbellek kullanılamıyorsa veritabanındaki veriler kullanılarak doldurulabilir.The local cache can be populated using the data in either the shared cache, or in the database if the shared cache is unavailable.

Bu yaklaşım, yerel önbelleğin paylaşılan önbelleğe göre çok eski duruma gelmesini önleyen dikkatli bir yapılandırma gerektirir.This approach requires careful configuration to prevent the local cache from becoming too stale with respect to the shared cache. Bununla birlikte, paylaşılan önbellek ulaşılamaz durumdaysa yerel önbellek bir arabellek gibi davranır.However, the local cache acts as a buffer if the shared cache is unreachable. Şekil 3'te bu yapı gösterilmiştir.Figure 3 shows this structure.

Paylaşılan önbellek ile yerel bir özel önbellek kullanma

Şekil 3: Paylaşılan önbellek ile yerel bir özel önbellek kullanma.Figure 3: Using a local private cache with a shared cache.

Görece uzun süreli veriler tutan büyük önbellekleri desteklemek için bazı önbellek hizmetleri, önbellek kullanılamaz hale gelirse otomatik yük devretme uygulayan bir yüksek kullanılabilirlik seçeneği sağlar.To support large caches that hold relatively long-lived data, some cache services provide a high-availability option that implements automatic failover if the cache becomes unavailable. Bu yaklaşım genellikle bir birincil önbellek sunucusunda depolanmış önbelleğe alınmış verilerin bir ikincil önbellek sunucusuna çoğaltılmasını ve birincil sunucu başarısız olur ya da bağlantı kaybedilirse ikincil sunucuya geçmeyi içerir.This approach typically involves replicating the cached data that's stored on a primary cache server to a secondary cache server, and switching to the secondary server if the primary server fails or connectivity is lost.

Birden çok hedefe yazma ile ilişkili gecikme süresini azaltmak için, veriler birincil sunucudaki önbelleğe yazılırken ikincil sunucuya çoğaltma işlemi zaman uyumsuz olarak gerçekleşebilir.To reduce the latency that's associated with writing to multiple destinations, the replication to the secondary server might occur asynchronously when data is written to the cache on the primary server. Bu yaklaşım bir hata durumunda bazı önbelleğe alınmış bilgilerin kaybedilme olasılığını doğurur, ancak bu verilerin genel önbellek boyutuna oranı küçük olmalıdır.This approach leads to the possibility that some cached information might be lost in the event of a failure, but the proportion of this data should be small compared to the overall size of the cache.

Paylaşılan önbellek büyükse, çekişme olasılığını azaltmak ve ölçeklenebilirliği artırmak için düğümler arasındaki önbelleğe alınmış verilerin bölümlere ayrılması faydalı olabilir.If a shared cache is large, it might be beneficial to partition the cached data across nodes to reduce the chances of contention and improve scalability. Birçok paylaşılan önbellek, dinamik olarak düğüm ekleme (ve kaldırma) özelliğini destekler ve bölümler arasında verileri yeniden dengeler.Many shared caches support the ability to dynamically add (and remove) nodes and rebalance the data across partitions. Bu yaklaşım, düğüm koleksiyonlarının istemci uygulamalara sorunsuz, tek bir önbellek olarak sunulduğu küme oluşturma işlemini gerektirebilir.This approach might involve clustering, in which the collection of nodes is presented to client applications as a seamless, single cache. Ancak, dahili olarak veriler yükü eşit şekilde dengeleyen önceden tanımlanmış bir dağıtım stratejisine göre düğümler arasında dağıtılır.Internally, however, the data is dispersed between nodes following a predefined distribution strategy that balances the load evenly. Olası bölümleme stratejileri hakkında daha fazla bilgi için bkz. veri bölümleme kılavuzu.For more information about possible partitioning strategies, see Data partitioning guidance.

Kümeleme işlemi de önbelleğin kullanılabilirliğini artırabilir.Clustering can also increase the availability of the cache. Bir düğüm başarısız olursa, önbelleğin geri kalanına hala erişilebilir.If a node fails, the remainder of the cache is still accessible. Kümeleme sıklıkla çoğaltma ve yük devretme ile birlikte kullanılır.Clustering is frequently used in conjunction with replication and failover. Her düğüm çoğaltılabilir ve düğüm başarısız olursa çoğaltma hızlıca çevrimiçi duruma getirilebilir.Each node can be replicated, and the replica can be quickly brought online if the node fails.

Birçok okuma ve yazma işlemi muhtemelen tek verili değerler veya nesneler içerir.Many read and write operations are likely to involve single data values or objects. Ancak, bazen büyük hacimlerde verilerin hızlıca depolanması veya alınması gerekebilir.However, at times it might be necessary to store or retrieve large volumes of data quickly. Örneğin, bir önbelleğin dağıtılması için yüzlerce veya binlerce öğenin önbelleğe yazılması gerekebilir.For example, seeding a cache could involve writing hundreds or thousands of items to the cache. Ayrıca, bir uygulamanın, aynı isteğin parçası olarak çok sayıda ilgili öğeyi önbellekten alması gerekli olabilir.An application might also need to retrieve a large number of related items from the cache as part of the same request.

Çok sayıda büyük ölçekli önbellek bu amaçla toplu işlemler sağlar.Many large-scale caches provide batch operations for these purposes. Bu özellik, bir istemci uygulamanın büyük hacimli öğeleri tek bir istek halinde paketlemesini sağlar ve çok sayıda küçük isteği gerçekleştirmeyle ilgili ek yükü azaltır.This enables a client application to package up a large volume of items into a single request and reduces the overhead that's associated with performing a large number of small requests.

Önbelleğe alma ve son tutarlılıkCaching and eventual consistency

Edilgen önbellek düzeninin işe yaraması için, uygulamanın önbelleği dolduran örneğinin en son ve en tutarlı veri sürümüne erişiminin olması gerekir.For the cache-aside pattern to work, the instance of the application that populates the cache must have access to the most recent and consistent version of the data. Son tutarlılığı uygulayan bir sistemde (çoğaltılmış veri deposu gibi), bu durum geçerli olmayabilir.In a system that implements eventual consistency (such as a replicated data store) this might not be the case.

Uygulamanın bir örneği bir veri öğesini değiştirebilir ve bu öğenin önbelleğe alınmış sürümünü geçersiz hale getirebilir.One instance of an application could modify a data item and invalidate the cached version of that item. Uygulamanın başka bir örneği, bu öğeyi bir önbellekten okumaya çalışarak önbellek kaçağına neden olabilir, bu nedenle verileri veri deposundan okur ve önbelleğe ekler.Another instance of the application might attempt to read this item from a cache, which causes a cache-miss, so it reads the data from the data store and adds it to the cache. Ancak, veri deposu diğer çoğaltmalarla tam olarak eşitlenmediyse uygulama örneği, önbelleği okuyup eski değerle doldurabilir.However, if the data store has not been fully synchronized with the other replicas, the application instance could read and populate the cache with the old value.

Veri tutarlılığını işleme hakkında daha fazla bilgi için bkz. Veri tutarlılığı temel bilgileri.For more information about handling data consistency, see the Data consistency primer.

Önbelleğe alınmış verileri korumaProtect cached data

Kullandığınız önbellek hizmetine bakılmaksızın, önbellekte tutulan verilerin yetkisiz erişimden nasıl korunacağını düşünün.Irrespective of the cache service you use, consider how to protect the data that's held in the cache from unauthorized access. İki temel sorun vardır:There are two main concerns:

  • Önbellekteki verilerin gizliliği.The privacy of the data in the cache.
  • Önbellek ile önbelleği kullanan uygulama arasında akan verilerin gizliliği.The privacy of data as it flows between the cache and the application that's using the cache.

Önbellekteki verileri korumak için, önbellek hizmeti uygulamaların aşağıdakileri belirtmesini gerektiren bir kimlik doğrulama mekanizması uygulayabilir:To protect data in the cache, the cache service might implement an authentication mechanism that requires that applications specify the following:

  • Önbellekteki verilere hangi kimliklerin erişebileceği.Which identities can access data in the cache.
  • Bu kimliklerin hangi işlemleri (okuma ve yazma) gerçekleştirmesine izin verildiği.Which operations (read and write) that these identities are allowed to perform.

Veri okuma ve yazma ile ilişkili ek yükü azaltmak için, bir kimliğe önbellek için yazma ve/veya okuma erişimi verildikten sonra bu kimlik önbellekteki herhangi bir veriyi kullanabilir.To reduce overhead that's associated with reading and writing data, after an identity has been granted write and/or read access to the cache, that identity can use any data in the cache.

Önbelleğe alınan verilerin alt kümelerine erişimi kısıtlamanız gerekirse aşağıdakilerden birini yapabilirsiniz:If you need to restrict access to subsets of the cached data, you can do one of the following:

  • Önbelleği bölümlere ayırın (farklı önbellek sunucuları kullanarak) ve kimliklere yalnızca kullanmalarına izin verilen bölümler için erişim verin.Split the cache into partitions (by using different cache servers) and only grant access to identities for the partitions that they should be allowed to use.
  • Farklı anahtarlar kullanarak her bir alt kümedeki verileri şifreleyin ve yalnızca her bir kümeye erişebilmesi gereken kimliklere şifreleme anahtarları sağlayın.Encrypt the data in each subset by using different keys, and provide the encryption keys only to identities that should have access to each subset. Bir istemci uygulama hala önbellekteki verilerin tümünü alabilir, ancak yalnızca anahtarları olan verilerin şifresini çözebilecektir.A client application might still be able to retrieve all of the data in the cache, but it will only be able to decrypt the data for which it has the keys.

Ayrıca, önbellek içine ve dışına akan verileri korumanız gerekir.You must also protect the data as it flows in and out of the cache. Bunun yapılması, istemci uygulamaların önbelleğe bağlanmak üzere kullandığı ağ altyapısı tarafından sağlanan güvenlik özelliklerine bağlıdır.To do this, you depend on the security features provided by the network infrastructure that client applications use to connect to the cache. Önbellek, istemci uygulamalarını barındıran aynı kuruluş içindeki bir yerinde sunucu kullanılarak uygulanırsa, ağın yalıtımına ek adımlar uygulamanız gerekmez.If the cache is implemented using an on-site server within the same organization that hosts the client applications, then the isolation of the network itself might not require you to take additional steps. Önbellek uzaktaysa ve bir ortak ağ (İnternet gibi) üzerinden TCP veya HTTP bağlantısı gerektiriyorsa, SSL uygulamayı düşünün.If the cache is located remotely and requires a TCP or HTTP connection over a public network (such as the Internet), consider implementing SSL.

Azure 'da önbelleğe alma uygulama konularıConsiderations for implementing caching in Azure

Redsıs Için Azure Cache , bir Azure veri merkezinde hizmet olarak çalışan açık kaynaklı redsıs önbelleğinin bir uygulamasıdır.Azure Cache for Redis is an implementation of the open source Redis cache that runs as a service in an Azure datacenter. Bulut hizmeti, web sitesi veya bir Azure sanal makinesi içinde uygulanmasına bakılmaksızın herhangi bir Azure uygulamasından erişilebilen bir önbelleğe alma hizmeti sağlar.It provides a caching service that can be accessed from any Azure application, whether the application is implemented as a cloud service, a website, or inside an Azure virtual machine. Önbellekler, uygun erişim anahtarına sahip istemci uygulamalar tarafından paylaşılabilir.Caches can be shared by client applications that have the appropriate access key.

Redsıs için Azure önbelleği, kullanılabilirlik, ölçeklenebilirlik ve güvenlik sağlayan yüksek performanslı bir önbelleğe alma çözümüdür.Azure Cache for Redis is a high-performance caching solution that provides availability, scalability and security. Genellikle bir veya daha fazla ayrılmış makineye yayılmış bir hizmet olarak çalışır.It typically runs as a service spread across one or more dedicated machines. Hızlı erişim sağlamak için bellekte mümkün olduğunca fazla bilgi depolamaya çalışır.It attempts to store as much information as it can in memory to ensure fast access. Bu mimari, yavaş G/Ç işlemleri gerçekleştirme gereksinimini azaltarak düşük gecikme süresi ve yüksek aktarım hızı sağlamaya yöneliktir.This architecture is intended to provide low latency and high throughput by reducing the need to perform slow I/O operations.

Redıs için Azure önbelleği, istemci uygulamaları tarafından kullanılan çeşitli API 'lerin birçoğu ile uyumludur.Azure Cache for Redis is compatible with many of the various APIs that are used by client applications. Şirket içinde redin için Azure önbelleği kullanan mevcut uygulamalarınız varsa, redde Azure önbelleği, bulutta önbelleğe alma için hızlı bir geçiş yolu sağlar.If you have existing applications that already use Azure Cache for Redis running on-premises, the Azure Cache for Redis provides a quick migration path to caching in the cloud.

Redis özellikleriFeatures of Redis

Redis basit bir önbellek sunucusundan fazlasıdır.Redis is more than a simple cache server. Çok sayıda senaryoyu destekleyen kapsamlı bir komut kümesi ile dağıtılmış bir bellek içi veritabanı sağlar.It provides a distributed in-memory database with an extensive command set that supports many common scenarios. Bunlar, bu belgenin ilerleyen kısımlarında, redin Caching kullanılarak bölümünde açıklanmıştır.These are described later in this document, in the section Using Redis caching. Bu bölümde Redis tarafından sağlanan bazı temel özellikler özetlenmektedir.This section summarizes some of the key features that Redis provides.

Bellek içi veritabanı olarak RedisRedis as an in-memory database

Redis hem okuma hem de yazma işlemlerini destekler.Redis supports both read and write operations. Redin 'de yazma işlemleri, sistem arızasından düzenli olarak yerel bir anlık görüntü dosyasında ya da yalnızca bir Append günlük dosyasında depolanarak korunabilir.In Redis, writes can be protected from system failure either by being stored periodically in a local snapshot file or in an append-only log file. Bu, birçok önbellekte (geçici veri depoları olarak düşünülmelidir) böyle değildir.This is not the case in many caches (which should be considered transitory data stores).

Tüm yazma işlemleri zaman uyumsuzdur ve istemcilerin veri okumasını ve veri yazmasını engellemez.All writes are asynchronous and do not block clients from reading and writing data. Redis çalışmaya başladığında anlık görüntü ya da günlük dosyasından verileri okur ve bu verileri bellek içi önbelleği oluşturmak için kullanır.When Redis starts running, it reads the data from the snapshot or log file and uses it to construct the in-memory cache. Daha fazla bilgi için Redis web sitesindeki Redis kalıcılığı bölümüne bakın.For more information, see Redis persistence on the Redis website.

Not

Redis geri dönülemez bir arıza olması durumunda tüm yazma işlemlerinin kaydedileceğini garanti etmez, ancak en kötü olasılıkla yalnızca birkaç saniye değerinde veri kaybedebilirsiniz.Redis does not guarantee that all writes will be saved in the event of a catastrophic failure, but at worst you might lose only a few seconds worth of data. Önbelleğin yetkili bir veri kaynağı gibi görev yapacak şekilde tasarlanmadığını ve kritik verilerin uygun bir veri deposuna başarıyla kaydedilmesinin önbelleği kullanan uygulamaların sorumluluğunda olduğunu unutmayın.Remember that a cache is not intended to act as an authoritative data source, and it is the responsibility of the applications using the cache to ensure that critical data is saved successfully to an appropriate data store. Daha fazla bilgi için bkz. önbellek stili.For more information, see the Cache-aside pattern.

Redis veri türleriRedis data types

Redis; değerlerin basit türler ya da karmalar, listeler ve kümeler gibi karmaşık türler içerebildiği bir anahtar-değer deposudur.Redis is a key-value store, where values can contain simple types or complex data structures such as hashes, lists, and sets. Bu veri türlerinde atomik işlemleri destekler.It supports a set of atomic operations on these data types. Anahtarları kalıcı olabilir veya sınırlı bir yaşam süresi ile etiketlenebilir. Sınırlı yaşam süresi olduğunda anahtar ve karşılık gelen değeri, önbellekten otomatik olarak kaldırılır.Keys can be permanent or tagged with a limited time-to-live, at which point the key and its corresponding value are automatically removed from the cache. Redis anahtarları ve değerleri hakkında daha fazla bilgi için Redis web sitesinde Redis veri türleri ve soyutlamalarına giriş sayfasını ziyaret edin.For more information about Redis keys and values, visit the page An introduction to Redis data types and abstractions on the Redis website.

Redis ile çoğaltma ve kümelemeRedis replication and clustering

Redis, kullanılabilirliği sağlamaya ve aktarım hızını korumaya yardımcı olmak için ana/alt çoğaltmayı destekler.Redis supports master/subordinate replication to help ensure availability and maintain throughput. Bir Redis ana düğümüne yapılan yazma işlemleri bir veya daha fazla alt düğüme çoğaltılır.Write operations to a Redis master node are replicated to one or more subordinate nodes. Okuma işlemleri, ana düğüm veya alt düğümlerin herhangi biri tarafından sunulabilir.Read operations can be served by the master or any of the subordinates.

Ağ bölümü söz konusu olduğunda, alt düğümler veri sunmaya devam edebilir ve sonra bağlantı yeniden kurulduğunda ana düğümle saydam bir şekilde yeniden eşitlenir.In the event of a network partition, subordinates can continue to serve data and then transparently resynchronize with the master when the connection is reestablished. Daha fazla ayrıntı için Redis web sitesinde Çoğaltma sayfasını ziyaret edin.For further details, visit the Replication page on the Redis website.

Redin Ayrıca, sunucular arasında verileri saydam olarak bölümleyip yükü yaymanızı sağlayan kümeleme de sağlar.Redis also provides clustering, which enables you to transparently partition data into shards across servers and spread the load. Önbellek boyutu arttıkça yeni Redis sunucuları eklenebildiği ve veriler yeniden bölümlenebildiği için bu özellik ölçeklenebilirliği artırır.This feature improves scalability, because new Redis servers can be added and the data repartitioned as the size of the cache increases.

Ayrıca, kümedeki her sunucu ana/alt çoğaltma kullanılarak çoğaltılabilir.Furthermore, each server in the cluster can be replicated by using master/subordinate replication. Böylece, kümedeki her düğümde kullanılabilirlik sağlanır.This ensures availability across each node in the cluster. Kümeleme ve parçalama hakkında daha fazla bilgi için Redis web sitesinde Redis kümesi öğretici sayfasını ziyaret edin.For more information about clustering and sharding, visit the Redis cluster tutorial page on the Redis website.

Redis bellek kullanımıRedis memory use

Redis önbelleği, ana bilgisayarda kullanılabilir kaynaklara bağlı olan sınırlı bir boyuta sahiptir.A Redis cache has a finite size that depends on the resources available on the host computer. Bir Redis sunucusunu yapılandırırken kullanabileceği en büyük bellek miktarını belirtebilirsiniz.When you configure a Redis server, you can specify the maximum amount of memory it can use. Ayrıca, Redis önbelleğinde bir anahtarı önbellekten otomatik olarak kaldırılacağı bir son kullanma tarihine sahip olacak şekilde yapılandırabilirsiniz.You can also configure a key in a Redis cache to have an expiration time, after which it is automatically removed from the cache. Bu özellik, bellek içi önbelleğin eski veya tarihi geçmiş verilerle doldurulmasını önlemeye yardımcı olabilir.This feature can help prevent the in-memory cache from filling with old or stale data.

Bellek doldukça Redis birkaç ilkeyi izleyerek anahtarları ve değerlerini otomatik olarak çıkarabilir.As memory fills up, Redis can automatically evict keys and their values by following a number of policies. Varsayılan ilke LRU (en uzak zamanda kullanılan) olmakla birlikte, anahtarları rastgele çıkarma ibi diğer ilkeleri de seçebilir veya çıkarmayı tamamen kapatabilirsiniz (bu durumda önbellek dolarsa önbelleğe öğe eklenemez).The default is LRU (least recently used), but you can also select other policies such as evicting keys at random or turning off eviction altogether (in which, case attempts to add items to the cache fail if it is full). Redis’i LRU önbelleği olarak kullanma sayfasında daha fazla bilgi verilmektedir.The page Using Redis as an LRU cache provides more information.

Redis ile işlemler ve toplu işlerRedis transactions and batches

Redis bir istemci uygulamanın önbellekte atomik bir işlem olarak veri okuyup yazan bir dizi işlem göndermesine olanak tanır.Redis enables a client application to submit a series of operations that read and write data in the cache as an atomic transaction. İşlemdeki tüm komutların sırayla çalışması garanti edilir ve diğer eşzamanlı istemciler tarafından gönderilen hiçbir komut bunlar arasında birbirine karışmaz.All the commands in the transaction are guaranteed to run sequentially, and no commands issued by other concurrent clients will be interwoven between them.

Ancak, bunlar ilişkisel bir veritabanı tarafından gerçekleştirildiği için gerçek işlemler değildir.However, these are not true transactions as a relational database would perform them. İşlem iki aşamada gerçekleştirilir: Birinci aşamada komutlar kuyruğa alınır, ikincisinde ise komutlar çalıştırılır.Transaction processing consists of two stages--the first is when the commands are queued, and the second is when the commands are run. Komutu kuyruğa alma aşamasında işlemi oluşturan komutlar istemci tarafından gönderilir.During the command queuing stage, the commands that comprise the transaction are submitted by the client. Bu noktada bir tür hata oluşursa (söz dizimi hatası veya yanlış sayıda parametre gibi), Redis işlemin tamamını gerçekleştirmeyi reddeder ve işlemi iptal eder.If some sort of error occurs at this point (such as a syntax error, or the wrong number of parameters) then Redis refuses to process the entire transaction and discards it.

Çalıştırma aşamasında Redis, kuyruğa alınmış her bir komutu sırayla gerçekleştirir.During the run phase, Redis performs each queued command in sequence. Bu aşamada bir komut başarısız olursa, Redis kuyruğa alınmış sonraki komutla devam eder ve daha önce çalıştırılmış hiçbir komutun etkilerini geri almaz.If a command fails during this phase, Redis continues with the next queued command and does not roll back the effects of any commands that have already been run. Bu basit işlem biçimi, performansı korumaya yardımcı olur ve çekişmeden kaynaklanan performans sorunlarını önler.This simplified form of transaction helps to maintain performance and avoid performance problems that are caused by contention.

Redis, tutarlılığı sürdürmeye yardımcı olmak üzere iyimser türde bir kilitleme uygulamaz.Redis does implement a form of optimistic locking to assist in maintaining consistency. İşlemler ve Redis ile kilitleme hakkında ayrıntılı bilgi için Redis web sitesinde İşlemler sayfasını ziyaret edin.For detailed information about transactions and locking with Redis, visit the Transactions page on the Redis website.

Redin Ayrıca isteklerin işlem dışı toplu işlemeyi destekler.Redis also supports nontransactional batching of requests. İstemcilerin bir Redis sunucusuna komut göndermek için kullandığı Redis protokolü, bir istemcinin aynı istek kapsamında bir dizi işlem göndermesini sağlar.The Redis protocol that clients use to send commands to a Redis server enables a client to send a series of operations as part of the same request. Bu özellik, ağ üzerinde paket parçalanmasını azaltmaya yardımcı olabilir.This can help to reduce packet fragmentation on the network. Toplu iş gerçekleştirilirken her bir komut uygulanır.When the batch is processed, each command is performed. Bu komutların herhangi biri hatalı biçimlendirilmişse reddedilir (bir işlemde bu gerçekleşmez), ancak kalan komutlar uygulanır.If any of these commands are malformed, they will be rejected (which doesn't happen with a transaction), but the remaining commands will be performed. Ayrıca, toplu işteki komutların işlenme sırası hakkında bir garanti yoktur.There is also no guarantee about the order in which the commands in the batch will be processed.

Redis güvenliğiRedis security

Redis yalnızca verilere hızlı erişim sağlamaya odaklanır ve yalnızca güvenilir istemcilerin erişebildiği güvenilir bir ortamda çalışacak şekilde tasarlanmıştır.Redis is focused purely on providing fast access to data, and is designed to run inside a trusted environment that can be accessed only by trusted clients. Redis, parola ile kimlik doğrulamasını temel alan sınırlı bir güvenlik modelini destekler.Redis supports a limited security model based on password authentication. (Kimlik doğrulamasının tamamen kaldırılması mümkündür, ancak önerilmez.)(It is possible to remove authentication completely, although we don't recommend this.)

Kimliği doğrulanmış tüm istemciler aynı genel parolayı paylaşır ve aynı kaynaklara erişime sahiptir.All authenticated clients share the same global password and have access to the same resources. Daha kapsamlı bir oturum açma güvenliğine gereksinim duyuyorsanız, Redis sunucusunun önünde kendi güvenlik katmanınızı uygulamanız ve tüm istemci isteklerinin bu ek katmandan geçmesi gerekir.If you need more comprehensive sign-in security, you must implement your own security layer in front of the Redis server, and all client requests should pass through this additional layer. Redis, güvenilmeyen ya da kimlik doğrulaması yapılmamış istemcilerin doğrudan kullanımına sunulmamalıdır.Redis should not be directly exposed to untrusted or unauthenticated clients.

Komutları devre dışı bırakarak veya yeniden adlandırarak (ve yalnızca yeni adlara sahip ayrıcalıklı istemciler sağlayarak) komutlara erişimi kısıtlayabilirsiniz.You can restrict access to commands by disabling them or renaming them (and by providing only privileged clients with the new names).

Redis hiçbir veri şifreleme biçimini doğrudan desteklemez; bu nedenle tüm kodlama işlemleri istemci uygulamalar tarafından gerçekleştirilmelidir.Redis does not directly support any form of data encryption, so all encoding must be performed by client applications. Ayrıca, Redis herhangi bir biçimde aktarım güvenliği sağlamaz.Additionally, Redis does not provide any form of transport security. Ağda akan verileri korumanız gerekiyorsa SSL ara sunucusu kullanmanız önerilir.If you need to protect data as it flows across the network, we recommend implementing an SSL proxy.

Daha fazla bilgi için Redis web sitesindeki Redis güvenliği sayfasını ziyaret edin.For more information, visit the Redis security page on the Redis website.

Not

Redsıs için Azure önbelleği, istemcilerinin bağlandığı kendi güvenlik katmanını sağlar.Azure Cache for Redis provides its own security layer through which clients connect. Temel alınan Redis sunucuları ortak ağın kullanımına sunulmaz.The underlying Redis servers are not exposed to the public network.

Azure Redis cacheAzure Redis cache

Redsıs için Azure Cache, bir Azure veri merkezinde barındırılan Redsıs sunucularına erişim sağlar.Azure Cache for Redis provides access to Redis servers that are hosted at an Azure datacenter. Erişim denetimi ve güvenlik sağlayan bir cephe gibi hareket eder.It acts as a façade that provides access control and security. Azure portal kullanarak bir önbellek sağlayabilirsiniz.You can provision a cache by using the Azure portal.

Portal, önceden tanımlanmış birkaç yapılandırma sağlar.The portal provides a number of predefined configurations. Bunlar arasında SSL iletişimlerini (gizlilik için) ve %99,9 kullanılabilirliğe sahip bir SLA ile ana/alt çoğaltmayı destekleyen ayrılmış bir hizmet olarak çalışan 53 GB önbellek ve paylaşılan bir donanım üzerinde çalışan çoğaltmasız (kullanılabilirlik garantisi yok) 250 MB önbellek bulunur.These range from a 53 GB cache running as a dedicated service that supports SSL communications (for privacy) and master/subordinate replication with an SLA of 99.9% availability, down to a 250 MB cache without replication (no availability guarantees) running on shared hardware.

Azure portalını kullanarak önbelleğin çıkarma ilkesini de yapılandırabilir ve sağlanan rollere kullanıcı ekleyerek önbelleğe erişimi denetleyebilirsiniz.Using the Azure portal, you can also configure the eviction policy of the cache, and control access to the cache by adding users to the roles provided. Üyelerin gerçekleştirebileceği işlemleri tanımlayan bu roller, sahibi, katkıda bulunan ve okuyucu dahil olmak üzere.These roles, which define the operations that members can perform, include Owner, Contributor, and Reader. Örneğin, Sahip rolünün üyeleri önbellek (güvenlik dahil) ve içerikleri üzerinde tam denetime sahiptir, Katkıda Bulunan rolünün üyeleri önbellekteki bilgileri okuyup yazabilir ve Okuyucu rolünün üyeleri yalnızca önbellekten veri alabilir.For example, members of the Owner role have complete control over the cache (including security) and its contents, members of the Contributor role can read and write information in the cache, and members of the Reader role can only retrieve data from the cache.

Çoğu yönetim görevi Azure portalı üzerinden gerçekleştirilir.Most administrative tasks are performed through the Azure portal. Bu nedenle, yapılandırmayı program aracılığıyla değiştirebilme, Redis sunucusunu kapatabilme, ek alt düğümler yapılandırabilme veya verileri diske zorla kaydedebilme olanağı dahil olmak üzere standart Redis sürümünde kullanılabilir olan yönetim komutlarının birçoğu kullanılamaz.For this reason, many of the administrative commands that are available in the standard version of Redis are not available, including the ability to modify the configuration programmatically, shut down the Redis server, configure additional subordinates, or forcibly save data to disk.

Azure portalı, önbelleğin performansını izlemenize olanak tanıyan kolay bir grafik görüntüsü içerir.The Azure portal includes a convenient graphical display that enables you to monitor the performance of the cache. Örneğin, kurulan bağlantı sayısını, gerçekleştirilen istek sayısını, okuma ve yazma işlemleri hacmini ve önbellek isabetlerinin önbellek kaçaklarına oranını görüntüleyebilirsiniz.For example, you can view the number of connections being made, the number of requests being performed, the volume of reads and writes, and the number of cache hits versus cache misses. Bu bilgileri kullanarak, önbelleğin verimliliğini belirleyebilir ve gerekirse farklı bir yapılandırmaya geçebilir veya çıkarma ilkesini değiştirebilirsiniz.Using this information, you can determine the effectiveness of the cache and if necessary, switch to a different configuration or change the eviction policy.

Ayrıca, bir veya daha fazla kritik ölçüm beklenen aralığın dışındaysa yöneticiye e-posta iletileri gönderen uyarılar oluşturabilirsiniz.Additionally, you can create alerts that send email messages to an administrator if one or more critical metrics fall outside of an expected range. Örneğin, önbellek kaçaklarının sayısı son bir saat içinde belirtilen değeri aşıyorsa, bu durum önbelleğin çok küçük olabileceği veya verilerin çok hızlı çıkarılabileceği anlamına geldiğinden yöneticiyi uyarmak isteyebilirsiniz.For example, you might want to alert an administrator if the number of cache misses exceeds a specified value in the last hour, because it means the cache might be too small or data might be being evicted too quickly.

Ayrıca, önbelleğin CPU, bellek ve ağ kullanımını da izleyebilirsiniz.You can also monitor the CPU, memory, and network usage for the cache.

Daha fazla bilgi ve bir Azure önbelleğinin redin için nasıl oluşturulacağını ve yapılandırılacağını gösteren örnekler için, Azure bloguna redin Için Azure önbelleği etrafında bir sayfa olarak ziyaret edin.For further information and examples showing how to create and configure an Azure Cache for Redis, visit the page Lap around Azure Cache for Redis on the Azure blog.

Önbelleğe alma oturum durumu ve HTML çıktısıCaching session state and HTML output

Azure Web rolleri kullanılarak çalışan ASP.NET Web uygulamaları oluşturuyorsanız, oturum durumu bilgilerini ve HTML çıkışını Redsıs için bir Azure önbelleğine kaydedebilirsiniz.If you're building ASP.NET web applications that run by using Azure web roles, you can save session state information and HTML output in an Azure Cache for Redis. Redsıs için Azure Cache oturum durumu sağlayıcısı, oturum bilgilerini bir ASP.NET Web uygulamasının farklı örnekleri arasında paylaşmanızı sağlar ve istemci-sunucu benzeşimi kullanılabilir değil ve oturum verilerini önbelleğe alırken Web çiftliği durumlarında çok kullanışlıdır bellek içi uygun değildir.The session state provider for Azure Cache for Redis enables you to share session information between different instances of an ASP.NET web application, and is very useful in web farm situations where client-server affinity is not available and caching session data in-memory would not be appropriate.

Oturum durumu sağlayıcısını redin için Azure Cache ile kullanmak aşağıdakiler dahil olmak üzere çeşitli avantajlar sunar:Using the session state provider with Azure Cache for Redis delivers several benefits, including:

  • Oturum durumunu çok sayıda ASP.NET web uygulaması örneğiyle paylaşma.Sharing session state with a large number of instances of ASP.NET web applications.
  • Geliştirilmiş ölçeklenebilirlik sağlama.Providing improved scalability.
  • Birden fazla okuyucu ve tek yazar için aynı oturum durumu verilerine denetimli, eşzamanlı erişimi denetleme.Supporting controlled, concurrent access to the same session state data for multiple readers and a single writer.
  • Bellek kaydetme ve ağ performansını iyileştirme amacıyla sıkıştırmayı kullanma.Using compression to save memory and improve network performance.

Daha fazla bilgi için bkz. ASP.net for redsıs for Azure Cache forThe.For more information, see ASP.NET session state provider for Azure Cache for Redis.

Not

Redsıs için Azure önbelleği için oturum durumu sağlayıcısını, Azure ortamının dışında çalışan ASP.NET uygulamalarıyla birlikte kullanmayın.Do not use the session state provider for Azure Cache for Redis with ASP.NET applications that run outside of the Azure environment. Önbelleğe Azure dışından erişimin neden olduğu gecikme süresi, verileri önbelleğe almanın performans avantajlarını ortadan kaldırabilir.The latency of accessing the cache from outside of Azure can eliminate the performance benefits of caching data.

Benzer şekilde, redde Azure önbelleği için çıktı önbelleği sağlayıcısı, bir ASP.NET Web uygulaması tarafından oluşturulan HTTP yanıtlarını kaydetmenizi sağlar.Similarly, the output cache provider for Azure Cache for Redis enables you to save the HTTP responses generated by an ASP.NET web application. Redde için Azure Cache ile çıkış önbelleği sağlayıcısı kullanılması, karmaşık HTML çıkışı işleyen uygulamaların yanıt sürelerini iyileştirebilir.Using the output cache provider with Azure Cache for Redis can improve the response times of applications that render complex HTML output. Benzer yanıtlar oluşturan uygulama örnekleri, bu HTML çıktısı afresh 'yi oluşturmak yerine önbellekteki paylaşılan çıkış parçalarını kullanabilir.Application instances that generate similar responses can use the shared output fragments in the cache rather than generating this HTML output afresh. Daha fazla bilgi için bkz. redsıs Için Azure önbelleği için ASP.net çıktı önbelleği sağlayıcısı.For more information, see ASP.NET output cache provider for Azure Cache for Redis.

Özel bir Redis önbelleği derlemeBuilding a custom Redis cache

Reda için Azure önbelleği, temeldeki redin sunucularına bir façlade görevi görür.Azure Cache for Redis acts as a façade to the underlying Redis servers. Azure Redis Cache kapsamında olmayan gelişmiş bir yapılandırmaya gereksinim duyuyorsanız (53 GB’dan büyük bir önbellek gibi), Azure sanal makinelerini kullanarak kendi Redis sunucularınızı derleyip barındırabilirsiniz.If you require an advanced configuration that is not covered by the Azure Redis cache (such as a cache bigger than 53 GB) you can build and host your own Redis servers by using Azure virtual machines.

Çoğaltma uygulamak istiyorsanız ana ve alt düğüm olarak görev yapacak birkaç VM oluşturmanız gerekebileceğinden, bu işlem karmaşık olabilir.This is a potentially complex process because you might need to create several VMs to act as master and subordinate nodes if you want to implement replication. Ayrıca, bir küme oluşturmak isterseniz birden fazla ana ve alt sunucu gerekir.Furthermore, if you wish to create a cluster, then you need multiple masters and subordinate servers. Yüksek düzeyde kullanılabilirlik ve ölçeklenebilirlik sağlayan küçük bir kümelenmiş çoğaltma topolojisi, üç çift ana/alt sunucu olarak düzenlenmiş en az altı VM’den oluşur (bir küme en az üç ana düğüm içermelidir).A minimal clustered replication topology that provides a high degree of availability and scalability comprises at least six VMs organized as three pairs of master/subordinate servers (a cluster must contain at least three master nodes).

Her ana/alt çifti, gecikme süresini en aza indirmek için birbirine yakın bir şekilde konumlandırılmalıdır.Each master/subordinate pair should be located close together to minimize latency. Ancak, önbelleğe alınan verileri kullanma olasılığı en yüksek uygulamaların yakınına konumlandırmak isterseniz, her çift kümesi farklı bölgelerde bulunan farklı Azure veri merkezlerinde çalışabilir.However, each set of pairs can be running in different Azure datacenters located in different regions, if you wish to locate cached data close to the applications that are most likely to use it. Azure VM olarak çalışan bir Redis düğümü derleme ve yapılandırma örneği için bkz. Azure’da CentOS Linux sanal makinesinde Redis’i çalıştırma.For an example of building and configuring a Redis node running as an Azure VM, see Running Redis on a CentOS Linux VM in Azure.

Not

Kendi Redsıs önbelleğinizi bu şekilde uygularsanız, hizmeti izleme, yönetme ve güvenli hale getirmekten siz sorumlusunuz.If you implement your own Redis cache in this way, you are responsible for monitoring, managing, and securing the service.

Redis önbelleğini bölümlemePartitioning a Redis cache

Önbelleğin bölümlenmesi için önbelleğin birden fazla bilgisayara bölünmesi gerekir.Partitioning the cache involves splitting the cache across multiple computers. Bu yapı, tek bir önbellek sunucusu kullanmaya göre aşağıdaki birkaç avantajı sağlar:This structure gives you several advantages over using a single cache server, including:

  • Tek bir sunucuda depolanabilecek boyuttan çok daha büyük bir önbellek oluşturma.Creating a cache that is much bigger than can be stored on a single server.
  • Verileri sunucular arasında dağıtma, kullanılabilirliği artırma.Distributing data across servers, improving availability. Bir sunucu arıza yapar veya erişilemez duruma gelirse, içindeki veriler kullanılamaz ancak kalan sunuculardaki verilere hala erişilebilir.If one server fails or becomes inaccessible, the data that it holds is unavailable, but the data on the remaining servers can still be accessed. Önbelleğe alınan veriler bir veritabanında tutulan verilerin yalnızca geçici bir kopyası olduğundan, bir önbellek için bunun bir önemi yoktur.For a cache, this is not crucial because the cached data is only a transient copy of the data that's held in a database. Erişilemez duruma gelen bir sunucuda önbelleğe alınmış veriler, farklı bir sunucuda önbelleğe alınabilir.Cached data on a server that becomes inaccessible can be cached on a different server instead.
  • Yükü sunucular arasında yayma, böylece performans ve ölçeklenebilirliği geliştirme.Spreading the load across servers, thereby improving performance and scalability.
  • Verileri, veriye erişen kullanıcıların yakınındaki bir coğrafi bölgeye konumlandırma, böylece gecikme süresini azaltma.Geolocating data close to the users that access it, thus reducing latency.

Bir önbellek için en yaygın bölümleme türü parçalamadır.For a cache, the most common form of partitioning is sharding. Bu stratejide her bölüm (veya parça) kendi çapında bir Redis önbelleğidir.In this strategy, each partition (or shard) is a Redis cache in its own right. Veriler, verileri dağıtmaya yönelik çeşitli yaklaşımlar kullanabilen parçalama mantığı kullanılarak belirli bir bölüme yönlendirilir.Data is directed to a specific partition by using sharding logic, which can use a variety of approaches to distribute the data. Parçalama düzeni bölümünde parçalama uygulaması hakkında daha fazla bilgi verilmektedir.The Sharding pattern provides more information about implementing sharding.

Bir Redis önbelleğinde bölümlemeyi uygulamak için aşağıdaki yaklaşımlardan birini benimseyebilirsiniz:To implement partitioning in a Redis cache, you can take one of the following approaches:

  • Sunucu tarafı sorgu yönlendirme.Server-side query routing. Bu teknikte bir istemci uygulama, önbelleği oluşturan Redis sunucularından herhangi birine (muhtemelen en yakın sunucuya) bir istek gönderir.In this technique, a client application sends a request to any of the Redis servers that comprise the cache (probably the closest server). Her Redis sunucusu, içerdiği bölümü açıklayan meta verileri depolar ve ayrıca diğer sunucularda hangi bölümlerin bulunduğu hakkında bilgi içerir.Each Redis server stores metadata that describes the partition that it holds, and also contains information about which partitions are located on other servers. Redis sunucusu, istemci isteğini inceler.The Redis server examines the client request. Yerel olarak çözülebiliyorsa istenen işlemi gerçekleştirir.If it can be resolved locally, it will perform the requested operation. Aksi takdirde isteği uygun sunucuya iletir.Otherwise it will forward the request on to the appropriate server. Bu model Redis kümeleme ile gerçekleştirilir ve Redis web sitesinin Redis kümesi öğreticisi sayfasında daha ayrıntılı olarak açıklanır.This model is implemented by Redis clustering, and is described in more detail on the Redis cluster tutorial page on the Redis website. Redis kümelemesi istemci uygulamalar için saydamdır ve istemcileri yeniden yapılandırmanız gerekmeden kümeye başka Redis sunucuları eklenebilir (ve veriler yeniden bölümlenebilir).Redis clustering is transparent to client applications, and additional Redis servers can be added to the cluster (and the data re-partitioned) without requiring that you reconfigure the clients.
  • İstemci-tarafı bölümleme.Client-side partitioning. Bu modelde istemci uygulama, istekleri uygun Redis sunucusuna yönlendiren mantığı (büyük olasılıkla bir kitaplık biçiminde) içerir.In this model, the client application contains logic (possibly in the form of a library) that routes requests to the appropriate Redis server. Bu yaklaşım Redsıs için Azure Cache ile birlikte kullanılabilir.This approach can be used with Azure Cache for Redis. Rediss için birden çok Azure önbelleği oluşturun (her bir veri bölümü için bir tane) ve istekleri doğru önbelleğe yönlendiren istemci tarafı mantığını uygulayın.Create multiple Azure Cache for Rediss (one for each data partition) and implement the client-side logic that routes the requests to the correct cache. Bölümleme düzeni değişirse (örneğin, yeniden depolar için ek Azure önbelleği oluşturulduysa), istemci uygulamalarının yeniden yapılandırılması gerekebilir.If the partitioning scheme changes (if additional Azure Cache for Rediss are created, for example), client applications might need to be reconfigured.
  • Ara sunucu destekli bölümleme.Proxy-assisted partitioning. Bu düzende istemci uygulamalar, istekleri verilerin nasıl bölümlendiğini anlayan bir ara sunucu hizmetine gönderir ve sonra isteği uygun Redis sunucusuna yönlendirir.In this scheme, client applications send requests to an intermediary proxy service which understands how the data is partitioned and then routes the request to the appropriate Redis server. Bu yaklaşım, redde için Azure Cache ile birlikte kullanılabilir; Proxy hizmeti bir Azure bulut hizmeti olarak uygulanabilir.This approach can also be used with Azure Cache for Redis; the proxy service can be implemented as an Azure cloud service. Bu yaklaşım, hizmeti uygulamak için ilave bir karmaşıklık düzeyi gerektirir ve isteklerin gerçekleştirilmesi, istemci tarafı bölümleme yöntemine göre daha uzun sürebilir.This approach requires an additional level of complexity to implement the service, and requests might take longer to perform than using client-side partitioning.

Redis web sitesinin Bölümleme: verileri birden çok Redis örneği arasında bölme sayfasında, Redis ile bölümlemeyi gerçekleştirme hakkında daha fazla bilgi verilmektedir.The page Partitioning: how to split data among multiple Redis instances on the Redis website provides further information about implementing partitioning with Redis.

Redis önbelleği istemci uygulamalarını kullanmaImplement Redis cache client applications

Redis, pek çok programlama dilinde yazılmış istemci uygulamaları destekler.Redis supports client applications written in numerous programming languages. .NET Framework kullanarak yeni uygulamalar derliyorsanız, StackExchange.Redis istemci kitaplığını kullanmak önerilen yaklaşımdır.If you are building new applications by using the .NET Framework, the recommended approach is to use the StackExchange.Redis client library. Bu kitaplık bir Redis sunucusuna bağlanma, komut gönderme ve yanıt almaya ilişkin ayrıntıları özetleyen bir .NET Framework nesne modeli sağlar.This library provides a .NET Framework object model that abstracts the details for connecting to a Redis server, sending commands, and receiving responses. Bir NuGet paketi olarak Visual Studio'da kullanılabilir.It is available in Visual Studio as a NuGet package. Bu aynı kitaplığı, Redsıs için bir Azure önbelleğine veya bir VM 'de barındırılan özel bir Redsıs önbelleğine bağlanmak için kullanabilirsiniz.You can use this same library to connect to an Azure Cache for Redis, or a custom Redis cache hosted on a VM.

Bir Redis sunucusuna bağlanmak için ConnectionMultiplexer sınıfının statik Connect yöntemini kullanırsınız.To connect to a Redis server you use the static Connect method of the ConnectionMultiplexer class. Bu yöntemin oluşturduğu bağlantı, istemci uygulamanın kullanım ömrü boyunca kullanılacak şekilde tasarlanmıştır ve aynı bağlantı birden fazla eşzamanlı iş parçacığı tarafından kullanılabilir.The connection that this method creates is designed to be used throughout the lifetime of the client application, and the same connection can be used by multiple concurrent threads. Gerçekleştirdiğiniz her Redis işleminde bağlantıyı yeniden kurup kesmeyin; aksi takdirde performans bozulabilir.Do not reconnect and disconnect each time you perform a Redis operation because this can degrade performance.

Redis ana bilgisayarının adresi ve parola gibi bağlantı parametrelerini belirtebilirsiniz.You can specify the connection parameters, such as the address of the Redis host and the password. Redin için Azure önbelleği kullanıyorsanız, parola, Azure portal kullanılarak Reda için Azure önbelleği için oluşturulan birincil veya ikincil anahtardır.If you are using Azure Cache for Redis, the password is either the primary or secondary key that is generated for Azure Cache for Redis by using the Azure portal.

Redis sunucusuna bağladıktan sonra önbellek olarak görev yapan Redis veritabanında bir tanıtıcı elde edebilirsiniz.After you have connected to the Redis server, you can obtain a handle on the Redis database that acts as the cache. Redis bağlantısı bunu yapmak için GetDatabase yöntemini sağlar.The Redis connection provides the GetDatabase method to do this. Bundan sonra önbellekten öğeleri alabilir ve StringGet ile StringSet yöntemlerini kullanarak önbellekte verileri depolayabilirsiniz.You can then retrieve items from the cache and store data in the cache by using the StringGet and StringSet methods. Bu yöntemler parametre olarak bir anahtar bekler ve önbellekte eşleşen bir değere (StringGet) sahip öğeyi döndürür ya da öğeyi bu anahtarla (StringSet) önbelleğe ekler.These methods expect a key as a parameter, and return the item either in the cache that has a matching value (StringGet) or add the item to the cache with this key (StringSet).

Redis sunucusunun konumuna bağlı olarak, bir istek sunucuya aktarıldığında ve istemciye bir yanıt döndürüldüğünde birçok işlem biraz gecikme süresi oluşturabilir.Depending on the location of the Redis server, many operations might incur some latency while a request is transmitted to the server and a response is returned to the client. StackExchange kitaplığı, istemci uygulamaların yanıt verebilir durumda kalmasına yardımcı olmak üzere kullanıma sunduğu birçok yöntemin zaman uyumsuz sürümlerini sağlar.The StackExchange library provides asynchronous versions of many of the methods that it exposes to help client applications remain responsive. Bu yöntemler .NET Framework görev tabanlı zaman uyumsuz modelini destekler.These methods support the Task-based Asynchronous pattern in the .NET Framework.

Aşağıdaki kod parçacığı RetrieveItem adlı bir yöntemi gösterir.The following code snippet shows a method named RetrieveItem. Redis ve StackExchange kitaplığını temel alan bir edilgen önbellek düzeni uygulamasını göstermektedir.It illustrates an implementation of the cache-aside pattern based on Redis and the StackExchange library. Yöntem bir dize anahtar değeri alır ve StringGetAsync yöntemini çağırarak (zaman uyumsuz StringGet sürümü) Redis önbelleğinden ilgili öğeyi almaya çalışır.The method takes a string key value and attempts to retrieve the corresponding item from the Redis cache by calling the StringGetAsync method (the asynchronous version of StringGet).

Öğe bulunmazsa, GetItemFromDataSourceAsync yöntemi (yerel bir yöntemdir ve StackExchange kitaplığının parçası değildir) kullanılarak temel alınan veri kaynağından getirilir.If the item is not found, it is fetched from the underlying data source using the GetItemFromDataSourceAsync method (which is a local method and not part of the StackExchange library). Ardından, bir sonraki sefere daha hızlı alınabilmesi için StringSetAsync yöntemi kullanılarak önbelleğe eklenir.It's then added to the cache by using the StringSetAsync method so it can be retrieved more quickly next time.

// Connect to the Azure Redis cache
ConfigurationOptions config = new ConfigurationOptions();
config.EndPoints.Add("<your DNS name>.redis.cache.windows.net");
config.Password = "<Redis cache key from management portal>";
ConnectionMultiplexer redisHostConnection = ConnectionMultiplexer.Connect(config);
IDatabase cache = redisHostConnection.GetDatabase();
...
private async Task<string> RetrieveItem(string itemKey)
{
    // Attempt to retrieve the item from the Redis cache
    string itemValue = await cache.StringGetAsync(itemKey);

    // If the value returned is null, the item was not found in the cache
    // So retrieve the item from the data source and add it to the cache
    if (itemValue == null)
    {
        itemValue = await GetItemFromDataSourceAsync(itemKey);
        await cache.StringSetAsync(itemKey, itemValue);
    }

    // Return the item
    return itemValue;
}

StringGet ve StringSet yöntemleri, dize değerlerini alma veya depolama ile kısıtlı değildir.The StringGet and StringSet methods are not restricted to retrieving or storing string values. Bir bayt dizisi olarak seri hale getirilmiş herhangi bir öğeyi alabilirler.They can take any item that is serialized as an array of bytes. Bir .NET nesnesini kaydetmeniz gerekiyorsa, bayt akışı olarak seri hale getirebilir ve StringSet yöntemini kullanarak önbelleğe yazabilirsiniz.If you need to save a .NET object, you can serialize it as a byte stream and use the StringSet method to write it to the cache.

Benzer şekilde, StringGet yöntemini kullanarak ve bir .NET nesnesi olarak seri durumdan çıkararak nesneyi önbellekten okuyabilirsiniz.Similarly, you can read an object from the cache by using the StringGet method and deserializing it as a .NET object. Aşağıdaki kod, IDatabase arabirimi için bir genişletme yöntemleri kümesini (bir Redis bağlantısının GetDatabase yöntemi bir IDatabase nesnesi döndürür) ve önbellekte bir BlogPost nesnesini okumak ve yazmak için bu yöntemleri kullanan bazı örnek kodları gösterir:The following code shows a set of extension methods for the IDatabase interface (the GetDatabase method of a Redis connection returns an IDatabase object), and some sample code that uses these methods to read and write a BlogPost object to the cache:

public static class RedisCacheExtensions
{
    public static async Task<T> GetAsync<T>(this IDatabase cache, string key)
    {
        return Deserialize<T>(await cache.StringGetAsync(key));
    }

    public static async Task<object> GetAsync(this IDatabase cache, string key)
    {
        return Deserialize<object>(await cache.StringGetAsync(key));
    }

    public static async Task SetAsync(this IDatabase cache, string key, object value)
    {
        await cache.StringSetAsync(key, Serialize(value));
    }

    static byte[] Serialize(object o)
    {
        byte[] objectDataAsStream = null;

        if (o != null)
        {
            BinaryFormatter binaryFormatter = new BinaryFormatter();
            using (MemoryStream memoryStream = new MemoryStream())
            {
                binaryFormatter.Serialize(memoryStream, o);
                objectDataAsStream = memoryStream.ToArray();
            }
        }

        return objectDataAsStream;
    }

    static T Deserialize<T>(byte[] stream)
    {
        T result = default(T);

        if (stream != null)
        {
            BinaryFormatter binaryFormatter = new BinaryFormatter();
            using (MemoryStream memoryStream = new MemoryStream(stream))
            {
                result = (T)binaryFormatter.Deserialize(memoryStream);
            }
        }

        return result;
    }
}

Aşağıdaki kod, edilgen önbellek düzenini izleyerek önbellekte seri hale getirilebilir bir BlogPost nesnesini okumak ve yazmak üzere bu genişletme yöntemlerini kullanan RetrieveBlogPost adlı bir yöntemi gösterir:The following code illustrates a method named RetrieveBlogPost that uses these extension methods to read and write a serializable BlogPost object to the cache following the cache-aside pattern:

// The BlogPost type
[Serializable]
public class BlogPost
{
    private HashSet<string> tags;

    public BlogPost(int id, string title, int score, IEnumerable<string> tags)
    {
        this.Id = id;
        this.Title = title;
        this.Score = score;
        this.tags = new HashSet<string>(tags);
    }

    public int Id { get; set; }
    public string Title { get; set; }
    public int Score { get; set; }
    public ICollection<string> Tags => this.tags;
}
...
private async Task<BlogPost> RetrieveBlogPost(string blogPostKey)
{
    BlogPost blogPost = await cache.GetAsync<BlogPost>(blogPostKey);
    if (blogPost == null)
    {
        blogPost = await GetBlogPostFromDataSourceAsync(blogPostKey);
        await cache.SetAsync(blogPostKey, blogPost);
    }

    return blogPost;
}

Bir istemci uygulama birden çok zaman uyumsuz istek gönderirse Redis, komut kanalı oluşturmayı destekler.Redis supports command pipelining if a client application sends multiple asynchronous requests. Redis, komutları katı bir sırayla alıp yanıtlamak yerine aynı bağlantıyı kullanarak çoğullayabilir.Redis can multiplex the requests using the same connection rather than receiving and responding to commands in a strict sequence.

Bu yaklaşım, ağdan daha verimli bir şekilde yararlanarak gecikme süresini azaltmaya yardımcı olur.This approach helps to reduce latency by making more efficient use of the network. Aşağıdaki kod parçacığı, iki müşterinin ayrıntılarını eşzamanlı olarak alan bir örnek göstermektedir.The following code snippet shows an example that retrieves the details of two customers concurrently. Kod, iki isteği gönderir ve sonra sonuçları almayı beklemeden önce bazı başka işlemler (gösterilmemiştir) yapar.The code submits two requests and then performs some other processing (not shown) before waiting to receive the results. Önbellek nesnesinin Wait yöntemi, .NET Framework Task.Wait yöntemine benzerdir:The Wait method of the cache object is similar to the .NET Framework Task.Wait method:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
var task1 = cache.StringGetAsync("customer:1");
var task2 = cache.StringGetAsync("customer:2");
...
var customer1 = cache.Wait(task1);
var customer2 = cache.Wait(task2);

Redsıs için Azure önbelleğine yönelik istemci uygulamaları yazma hakkında ek bilgi için bkz. redsıs belgeleri Için Azure önbelleği.For additional information on writing client applications that can the Azure Cache for Redis, see the Azure Cache for Redis documentation. StackExchange.Redis sayfasında da daha fazla bilgi bulunabilir.More information is also available at StackExchange.Redis.

Aynı web sitesindeki İşlem hatları ve çoğullayıcılar sayfasında, Redis ve StackExchange kitaplığı zaman uyumsuz işlemler ve kanal oluşturma hakkında daha fazla bilgi verilmektedir.The page Pipelines and multiplexers on the same website provides more information about asynchronous operations and pipelining with Redis and the StackExchange library.

Redis önbelleğini kullanmaUsing Redis caching

Redis’in önbelleğe alma amacıyla en basit kullanımı, değerin herhangi bir ikili veriyi içerebilen rastgele uzunluktaki yorumlanmamış bir dize olduğu anahtar-değer çiftleridir.The simplest use of Redis for caching concerns is key-value pairs where the value is an uninterpreted string of arbitrary length that can contain any binary data. (Aslında bir dize olarak kabul edilebilir bir bayt dizisidir).(It is essentially an array of bytes that can be treated as a string). Bu senaryo, bu makalenin önceki kısımlarında yer alan Redis Önbelleği istemci uygulamalarını kullanma bölümünde gösterilmiştir.This scenario was illustrated in the section Implement Redis Cache client applications earlier in this article.

Anahtarların aynı zamanda yorumlanmamış veriler içerdiğini, bu nedenle herhangi bir ikili bilgiyi anahtar olarak kullanabileceğinizi unutmayın.Note that keys also contain uninterpreted data, so you can use any binary information as the key. Ancak, anahtar uzadıkça depolanması için daha fazla alan gerekir ve arama işlemlerinin gerçekleştirilmesi daha uzun sürer.The longer the key is, however, the more space it will take to store, and the longer it will take to perform lookup operations. Kullanılabilirlik ve bakım kolaylığı için anahtar alanınızı dikkatlice tasarlayın ve anlamlı (ayrıntılı değil) anahtarlar kullanın.For usability and ease of maintenance, design your keyspace carefully and use meaningful (but not verbose) keys.

Örneğin, kimliği 100 olarak müşterinin anahtarını açıklamak için yalnızca "100" yerine "müşteri:100" gibi yapılandırılmış anahtarlar kullanın.For example, use structured keys such as "customer:100" to represent the key for the customer with ID 100 rather than simply "100". Bu düzen, farklı veri türlerini depolayan değerleri birbirinden kolayca ayırt etmenizi sağlar.This scheme enables you to easily distinguish between values that store different data types. Örneğin, kimliği 100 olarak siparişin anahtarını açıklamak için "siparişler:100" anahtarını da kullanabilirsiniz.For example, you could also use the key "orders:100" to represent the key for the order with ID 100.

Tek boyutlu ikili dizeler dışında bir Redis anahtar-değer çiftindeki değer, listeler, kümeler (sıralı ve sırasız) ve karmalar gibi daha yapılandırılmış bilgileri de tutabilir.Apart from one-dimensional binary strings, a value in a Redis key-value pair can also hold more structured information, including lists, sets (sorted and unsorted), and hashes. Redis bu türleri yönetebilen kapsamlı bir komut kümesi sağlar ve bu komutların birçoğu StackExchange gibi bir istemci kitaplığı aracılığıyla .NET Framework uygulamaları tarafından kullanılabilir.Redis provides a comprehensive command set that can manipulate these types, and many of these commands are available to .NET Framework applications through a client library such as StackExchange. Redis web sitesindeki Redis veri türleri ve soyutlamalarına giriş sayfasında bu türlere ve bunları yönetmek için kullanabileceğiniz komutlara ilişkin daha ayrıntılı bir genel bakış sunulmaktadır.The page An introduction to Redis data types and abstractions on the Redis website provides a more detailed overview of these types and the commands that you can use to manipulate them.

Bu bölümde, bu veri türleri ve komutlar için bazı ortak kullanım örnekleri özetlenmektedir.This section summarizes some common use cases for these data types and commands.

Atomik ve toplu işlemler gerçekleştirmePerform atomic and batch operations

Redis, dize değerleri üzerinde bir dizi atomik al ve ayarla işlemini destekler.Redis supports a series of atomic get-and-set operations on string values. Bu işlemler, ayrı GET ve SET komutlarını kullanırken oluşabilecek olası çalışma tehlikelerini ortadan kaldırır.These operations remove the possible race hazards that might occur when using separate GET and SET commands. Kullanılabilir işlemler şunlardır:The operations that are available include:

  • Tamsayı veri değerleri üzerinde atomik artımlı ve azalımlı işlemler gerçekleştirebilen INCR, INCRBY, DECR ve DECRBY.INCR, INCRBY, DECR, and DECRBY, which perform atomic increment and decrement operations on integer numeric data values. StackExchange kitaplığı bu işlemleri gerçekleştirmek için IDatabase.StringIncrementAsync ile IDatabase.StringDecrementAsync yöntemlerinin aşırı yüklenmiş sürümlerini sağlar ve önbellekte depolanmış sonuç değerini döndürür.The StackExchange library provides overloaded versions of the IDatabase.StringIncrementAsync and IDatabase.StringDecrementAsync methods to perform these operations and return the resulting value that is stored in the cache. Aşağıdaki kod parçacığı bu yöntemlerin nasıl kullanılacağını gösterir:The following code snippet illustrates how to use these methods:

    ConnectionMultiplexer redisHostConnection = ...;
    IDatabase cache = redisHostConnection.GetDatabase();
    ...
    await cache.StringSetAsync("data:counter", 99);
    ...
    long oldValue = await cache.StringIncrementAsync("data:counter");
    // Increment by 1 (the default)
    // oldValue should be 100
    
    long newValue = await cache.StringDecrementAsync("data:counter", 50);
    // Decrement by 50
    // newValue should be 50
    
  • Bir anahtar ile ilişkili değeri alan ve yeni bir değerle değiştiren GETSET.GETSET, which retrieves the value that's associated with a key and changes it to a new value. StackExchange kitaplığı bu işlemi IDatabase.StringGetSetAsync yöntemiyle kullanılabilir hale getirir.The StackExchange library makes this operation available through the IDatabase.StringGetSetAsync method. Aşağıdaki kod parçacığında bu yöntemin bir örneği gösterilmektedir.The code snippet below shows an example of this method. Bu kod, önceki örnekte yer alan "veri:sayaç" anahtarı ile ilişkili geçerli değeri döndürür.This code returns the current value that's associated with the key "data:counter" from the previous example. Ardından, bu anahtarın değerini aynı işlemin parçası olarak tekrar sıfırlar:Then it resets the value for this key back to zero, all as part of the same operation:

    ConnectionMultiplexer redisHostConnection = ...;
    IDatabase cache = redisHostConnection.GetDatabase();
    ...
    string oldValue = await cache.StringGetSetAsync("data:counter", 0);
    
  • Bir dize değerleri kümesini tek bir işlem olarak döndürebilen veya değiştirebilen MGET ve MSET.MGET and MSET, which can return or change a set of string values as a single operation. Aşağıdaki örnekte gösterildiği gibi, IDatabase.StringGetAsync ve IDatabase.StringSetAsync yöntemleri bu işlevleri desteklemek için aşırı yüklenmiştir:The IDatabase.StringGetAsync and IDatabase.StringSetAsync methods are overloaded to support this functionality, as shown in the following example:

    ConnectionMultiplexer redisHostConnection = ...;
    IDatabase cache = redisHostConnection.GetDatabase();
    ...
    // Create a list of key-value pairs
    var keysAndValues =
        new List<KeyValuePair<RedisKey, RedisValue>>()
        {
            new KeyValuePair<RedisKey, RedisValue>("data:key1", "value1"),
            new KeyValuePair<RedisKey, RedisValue>("data:key99", "value2"),
            new KeyValuePair<RedisKey, RedisValue>("data:key322", "value3")
        };
    
    // Store the list of key-value pairs in the cache
    cache.StringSet(keysAndValues.ToArray());
    ...
    // Find all values that match a list of keys
    RedisKey[] keys = { "data:key1", "data:key99", "data:key322"};
    // values should contain { "value1", "value2", "value3" }
    RedisValue[] values = cache.StringGet(keys);
    
    

Ayrıca, bu makalenin önceki kısımlarında yer alan Redis ile işlemler ve toplu işler bölümünde açıklanan şekilde birden fazla işlemi tek bir Redis işleminde birleştirebilirsiniz.You can also combine multiple operations into a single Redis transaction as described in the Redis transactions and batches section earlier in this article. StackExchange kitaplığı, ITransaction arabirimi üzerinden işlem desteği sağlar.The StackExchange library provides support for transactions through the ITransaction interface.

IDatabase.CreateTransaction yöntemini kullanarak bir ITransaction nesnesi oluşturabilirsiniz.You create an ITransaction object by using the IDatabase.CreateTransaction method. ITransaction nesnesi tarafından sağlanan yöntemleri kullanarak işleme komut çağırabilirsiniz.You invoke commands to the transaction by using the methods provided by the ITransaction object.

ITransaction arabirimi, tüm yöntemlerin zaman uyumsuz olması dışında IDatabase arabirimi tarafından erişilenlere benzer bir yöntemler kümesine erişim sağlar.The ITransaction interface provides access to a set of methods that's similar to those accessed by the IDatabase interface, except that all the methods are asynchronous. Diğer bir deyişle, işlemler yalnızca ITransaction.Execute yöntemi çağrıldığında gerçekleştirilir.This means that they are only performed when the ITransaction.Execute method is invoked. ITransaction.Execute yöntemi tarafından döndürülen değer, işlemin başarıyla oluşturulduğunu (true) veya başarısız olduğunu (false) gösterir.The value that's returned by the ITransaction.Execute method indicates whether the transaction was created successfully (true) or if it failed (false).

Aşağıdaki kod parçacığı, iki sayacı aynı işlemin parçası olarak artırıp azaltan bir örnek göstermektedir:The following code snippet shows an example that increments and decrements two counters as part of the same transaction:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
ITransaction transaction = cache.CreateTransaction();
var tx1 = transaction.StringIncrementAsync("data:counter1");
var tx2 = transaction.StringDecrementAsync("data:counter2");
bool result = transaction.Execute();
Console.WriteLine("Transaction {0}", result ? "succeeded" : "failed");
Console.WriteLine("Result of increment: {0}", tx1.Result);
Console.WriteLine("Result of decrement: {0}", tx2.Result);

Redis işlemlerinin ilişkisel veritabanlarındaki işlemlerden farklı olduğunu unutmayın.Remember that Redis transactions are unlike transactions in relational databases. Execute yöntemi, çalıştırılacak işlemi oluşturan tüm komutları basitçe kuyruğa alır ve herhangi biri hatalı biçimlendirilmişse işlem durdurulur.The Execute method simply queues all the commands that comprise the transaction to be run, and if any of them is malformed then the transaction is stopped. Tüm komutlar başarıyla kuyruğa alınmışsa her komut zaman uyumsuz olarak çalışır.If all the commands have been queued successfully, each command runs asynchronously.

Herhangi bir komut başarısız olsa bile diğerleri işlenmeye devam eder.If any command fails, the others still continue processing. Bir komutun başarıyla tamamlandığını doğrulamanız gerekirse, yukarıdaki örnekte gösterildiği gibi ilgili görevin Result özelliğini kullanarak komutun sonuçlarını getirmeniz gerekir.If you need to verify that a command has completed successfully, you must fetch the results of the command by using the Result property of the corresponding task, as shown in the example above. Result özelliğinin okunması, görev tamamlanana kadar çağıran iş parçacığını engeller.Reading the Result property will block the calling thread until the task has completed.

Daha fazla bilgi için bkz. redin Içindeki işlemler.For more information, see Transactions in Redis.

Toplu işlemleri gerçekleştirirken StackExchange kitaplığının IBatch arabirimini kullanabilirsiniz.When performing batch operations, you can use the IBatch interface of the StackExchange library. Bu arabirim, tüm yöntemlerin zaman uyumsuz olması dışında IDatabase arabirimi tarafından erişilenlere benzer bir yöntemler kümesine erişim sağlar.This interface provides access to a set of methods similar to those accessed by the IDatabase interface, except that all the methods are asynchronous.

IDatabase.CreateBatch yöntemini kullanarak bir IBatch nesnesi oluşturabilir ve sonra aşağıdaki örnekte gösterildiği gibi IBatch.Execute yöntemini kullanarak toplu işi çalıştırabilirsiniz.You create an IBatch object by using the IDatabase.CreateBatch method, and then run the batch by using the IBatch.Execute method, as shown in the following example. Bu kod yalnızca bir dize değeri ayarlar, önceki örnekte kullanılan sayaçları artırıp azaltır ve sonuçları gösterir:This code simply sets a string value, increments and decrements the same counters used in the previous example, and displays the results:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
IBatch batch = cache.CreateBatch();
batch.StringSetAsync("data:key1", 11);
var t1 = batch.StringIncrementAsync("data:counter1");
var t2 = batch.StringDecrementAsync("data:counter2");
batch.Execute();
Console.WriteLine("{0}", t1.Result);
Console.WriteLine("{0}", t2.Result);

Bir işlemin aksine, toplu işteki bir komut hatalı biçimlendirilmesi nedeniyle başarısız olursa diğer komutlar çalışmaya devam edebilir.It is important to understand that unlike a transaction, if a command in a batch fails because it is malformed, the other commands might still run. IBatch.Execute yöntemi herhangi bir başarı ya da başarısızlık göstergesi döndürmez.The IBatch.Execute method does not return any indication of success or failure.

Başlat ve unut önbellek işlemleri gerçekleştirmePerform fire and forget cache operations

Redis, komut bayrakları kullanarak başlat ve unut işlemlerini destekler.Redis supports fire and forget operations by using command flags. Bu durumda istemci bir işlem başlatır ancak sonuçla ilgilenmediği için komutun tamamlanmasını beklemez.In this situation, the client simply initiates an operation but has no interest in the result and does not wait for the command to be completed. Aşağıdaki örnekte INCR komutunun bir başlat ve unut işlemi olarak gerçekleştirilmesi gösterilmektedir:The example below shows how to perform the INCR command as a fire and forget operation:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
await cache.StringSetAsync("data:key1", 99);
...
cache.StringIncrement("data:key1", flags: CommandFlags.FireAndForget);

Otomatik olarak sona eren anahtarlar belirtmeSpecify automatically expiring keys

Bir öğeyi Redis önbelleğinde depoladığınızda öğenin önbellekten otomatik olarak silineceği bir zaman aşımı süresi belirtebilirsiniz.When you store an item in a Redis cache, you can specify a timeout after which the item will be automatically removed from the cache. Ayrıca, TTL komutunu kullanarak bir anahtarın süre sonuna ne kadar kaldığını sorgulayabilirsiniz.You can also query how much more time a key has before it expires by using the TTL command. Bu komut, IDatabase.KeyTimeToLive yöntemi ile StackExchange uygulamaları tarafından kullanılabilir.This command is available to StackExchange applications by using the IDatabase.KeyTimeToLive method.

Aşağıdaki kod parçacığında, bir anahtar için 20 saniye sona erme süresini ayarlama ve anahtarın kalan kullanım ömrünü sorgulama işlemi gösterilmektedir:The following code snippet shows how to set an expiration time of 20 seconds on a key, and query the remaining lifetime of the key:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
// Add a key with an expiration time of 20 seconds
await cache.StringSetAsync("data:key1", 99, TimeSpan.FromSeconds(20));
...
// Query how much time a key has left to live
// If the key has already expired, the KeyTimeToLive function returns a null
TimeSpan? expiry = cache.KeyTimeToLive("data:key1");

Ayrıca, StackExchange kitaplığında KeyExpireAsync yöntemi olarak mevcut olan EXPIRE komutunu kullanarak sona erme zamanını belirli bir tarih ve saate ayarlayabilirsiniz:You can also set the expiration time to a specific date and time by using the EXPIRE command, which is available in the StackExchange library as the KeyExpireAsync method:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
// Add a key with an expiration date of midnight on 1st January 2015
await cache.StringSetAsync("data:key1", 99);
await cache.KeyExpireAsync("data:key1",
    new DateTime(2015, 1, 1, 0, 0, 0, DateTimeKind.Utc));
...

İpucu

StackExchange kitaplığında IDatabase.KeyDeleteAsync yöntemi olarak mevcut olan DEL komutunu kullanarak bir öğeyi önbellekten el ile kaldırabilirsiniz.You can manually remove an item from the cache by using the DEL command, which is available through the StackExchange library as the IDatabase.KeyDeleteAsync method.

Etiketleri kullanarak önbelleğe alınmış öğeleri çapraz ilişkilendirmeUse tags to cross-correlate cached items

Redis kümesi, tek bir anahtarı paylaşan birden çok öğenin oluşturduğu bir koleksiyondur.A Redis set is a collection of multiple items that share a single key. SADD komutunu kullanarak bir küme oluşturabilirsiniz.You can create a set by using the SADD command. Bir kümedeki öğeleri SMEMBERS komutunu kullanarak alabilirsiniz.You can retrieve the items in a set by using the SMEMBERS command. StackExchange kitaplığı, SADD komutunu IDatabase.SetAddAsync yöntemiyle ve SMEMBERS komutunu IDatabase.SetMembersAsync yöntemiyle uygular.The StackExchange library implements the SADD command with the IDatabase.SetAddAsync method, and the SMEMBERS command with the IDatabase.SetMembersAsync method.

Ayrıca, SDIFF (küme farkı), SINTER (küme kesişimi) ve SUNION (küme birleşimi) komutlarını kullanarak yeni kümeler oluşturmak için var olan kümeleri birleştirebilirsiniz.You can also combine existing sets to create new sets by using the SDIFF (set difference), SINTER (set intersection), and SUNION (set union) commands. StackExchange kitaplığı bu işlemleri IDatabase.SetCombineAsync yönteminde birleştirir.The StackExchange library unifies these operations in the IDatabase.SetCombineAsync method. Bu yöntemin ilk parametresi, gerçekleştirilecek küme işlemini belirtir.The first parameter to this method specifies the set operation to perform.

Aşağıdaki kod parçacıkları, kümelerin ilgili öğelerden oluşan koleksiyonları hızlıca depolamak ve almak için nasıl faydalı olabileceğini gösterir.The following code snippets show how sets can be useful for quickly storing and retrieving collections of related items. Bu kod, bu makalenin önceki kısımlarında yer alan Redis Önbelleği İstemci Uygulamalarını kullanma bölümünde açıklanan BlogPost türünü kullanır.This code uses the BlogPost type that was described in the section Implement Redis Cache Client Applications earlier in this article.

Bir BlogPost nesne, bir kimlik—, başlık, bir derecelendirme puanı ve Etiketler koleksiyonu olmak üzere dört alan içerir.A BlogPost object contains four fields—an ID, a title, a ranking score, and a collection of tags. Aşağıdaki ilk kod parçacığında BlogPost nesnelerinin bir C# listesini doldurmak için kullanılan örnek veriler gösterilmektedir:The first code snippet below shows the sample data that's used for populating a C# list of BlogPost objects:

List<string[]> tags = new List<string[]>
{
    new[] { "iot","csharp" },
    new[] { "iot","azure","csharp" },
    new[] { "csharp","git","big data" },
    new[] { "iot","git","database" },
    new[] { "database","git" },
    new[] { "csharp","database" },
    new[] { "iot" },
    new[] { "iot","database","git" },
    new[] { "azure","database","big data","git","csharp" },
    new[] { "azure" }
};

List<BlogPost> posts = new List<BlogPost>();
int blogKey = 1;
int numberOfPosts = 20;
Random random = new Random();
for (int i = 0; i < numberOfPosts; i++)
{
    blogKey++;
    posts.Add(new BlogPost(
        blogKey,                  // Blog post ID
        string.Format(CultureInfo.InvariantCulture, "Blog Post #{0}",
            blogKey),             // Blog post title
        random.Next(100, 10000),  // Ranking score
        tags[i % tags.Count]));   // Tags--assigned from a collection
                                  // in the tags list
}

Her bir BlogPost nesnesinin etiketlerini bir Redis önbelleğinde küme olarak depolayabilir ve her kümeyi BlogPost kimliği ile ilişkilendirebilirsiniz.You can store the tags for each BlogPost object as a set in a Redis cache and associate each set with the ID of the BlogPost. Bunun yapılması, belirli bir blog gönderisine ait olan tüm etiketleri hızlıca bulmayı sağlar.This enables an application to quickly find all the tags that belong to a specific blog post. Ters yönde aramayı etkinleştirmek ve belirli bir etiketi paylaşan tüm blog gönderilerini bulmak için anahtardaki etiket kimliğine başvuran blog gönderilerini tutan başka bir küme oluşturabilirsiniz:To enable searching in the opposite direction and find all blog posts that share a specific tag, you can create another set that holds the blog posts referencing the tag ID in the key:

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
// Tags are easily represented as Redis Sets
foreach (BlogPost post in posts)
{
    string redisKey = string.Format(CultureInfo.InvariantCulture,
        "blog:posts:{0}:tags", post.Id);
    // Add tags to the blog post in Redis
    await cache.SetAddAsync(
        redisKey, post.Tags.Select(s => (RedisValue)s).ToArray());

    // Now do the inverse so we can figure out which blog posts have a given tag
    foreach (var tag in post.Tags)
    {
        await cache.SetAddAsync(string.Format(CultureInfo.InvariantCulture,
            "tag:{0}:blog:posts", tag), post.Id);
    }
}

Bu yapılar birçok ortak sorguyu çok verimli bir şekilde gerçekleştirmenizi sağlar.These structures enable you to perform many common queries very efficiently. Örneğin, blog gönderisi 1 için tüm etiketleri şu şekilde bulup görüntüleyebilirsiniz:For example, you can find and display all of the tags for blog post 1 like this:

// Show the tags for blog post #1
foreach (var value in await cache.SetMembersAsync("blog:posts:1:tags"))
{
    Console.WriteLine(value);
}

Aşağıdaki gibi bir küme kesişimi işlemi gerçekleştirerek blog gönderisi 1 ve blog gönderisi 2 için ortak olan tüm etiketleri bulabilirsiniz:You can find all tags that are common to blog post 1 and blog post 2 by performing a set intersection operation, as follows:

// Show the tags in common for blog posts #1 and #2
foreach (var value in await cache.SetCombineAsync(SetOperation.Intersect, new RedisKey[]
    { "blog:posts:1:tags", "blog:posts:2:tags" }))
{
    Console.WriteLine(value);
}

Ayrıca, belirli bir etiketi içeren tüm blog gönderilerini bulabilirsiniz:And you can find all blog posts that contain a specific tag:

// Show the ids of the blog posts that have the tag "iot".
foreach (var value in await cache.SetMembersAsync("tag:iot:blog:posts"))
{
    Console.WriteLine(value);
}

Son erişilen öğeleri bulmaFind recently accessed items

Birçok uygulama için gerekli olan genel bir görev, son erişilen öğelerin bulunmasıdır.A common task required of many applications is to find the most recently accessed items. Örneğin, bir blog sitesi en son okunan blog gönderilerine ilişkin bilgileri görüntülemek isteyebilir.For example, a blogging site might want to display information about the most recently read blog posts.

Bir Redis listesi kullanarak bu işlevi uygulayabilirsiniz.You can implement this functionality by using a Redis list. Redis listesi, aynı anahtarı paylaşan birden fazla öğe içerir.A Redis list contains multiple items that share the same key. Liste çift uçlu bir sıra gibi davranır.The list acts as a double-ended queue. LPUSH (sola gönder) ve RPUSH (sağa gönder) komutlarını kullanarak öğeleri listenin herhangi bir ucuna gönderebilirsiniz.You can push items to either end of the list by using the LPUSH (left push) and RPUSH (right push) commands. LPOP ve RPOP komutlarını kullanarak listenin herhangi bir ucundan öğeleri alabilirsiniz.You can retrieve items from either end of the list by using the LPOP and RPOP commands. Ayrıca, LRANGE ve RRANGE komutlarını kullanarak bir öğe kümesi döndürebilirsiniz.You can also return a set of elements by using the LRANGE and RRANGE commands.

Aşağıdaki kod parçacıkları, StackExchange kitaplığını kullanarak bu işlemleri nasıl gerçekleştirebileceğinizi gösterir.The code snippets below show how you can perform these operations by using the StackExchange library. Bu kod, önceki örnekte yer alan BlogPost türünü kullanır.This code uses the BlogPost type from the previous examples. Blog gönderisi bir kullanıcı tarafından okunduğunda IDatabase.ListLeftPushAsync yöntemi, blog gönderisinin başlığını Redis önbelleğinde "blog:recent_posts" anahtarıyla ilişkili olan bir listeye gönderir.As a blog post is read by a user, the IDatabase.ListLeftPushAsync method pushes the title of the blog post onto a list that's associated with the key "blog:recent_posts" in the Redis cache.

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
string redisKey = "blog:recent_posts";
BlogPost blogPost = ...; // Reference to the blog post that has just been read
await cache.ListLeftPushAsync(
    redisKey, blogPost.Title); // Push the blog post onto the list

Daha fazla blog gönderisi okundukça başlıkları aynı listeye gönderilir.As more blog posts are read, their titles are pushed onto the same list. Liste, başlıkların eklendiği sıraya göre düzenlenir.The list is ordered by the sequence in which the titles have been added. En son okunan blog gönderileri listenin sol ucuna doğru.The most recently read blog posts are toward the left end of the list. (Aynı blog gönderisi birden çok kez okunursa listede birden çok girişi olacaktır.)(If the same blog post is read more than once, it will have multiple entries in the list.)

IDatabase.ListRange yöntemini kullanarak en son okunan gönderilerin başlıklarını görüntüleyebilirsiniz.You can display the titles of the most recently read posts by using the IDatabase.ListRange method. Bu yöntem liste, başlangıç noktası ve bitiş noktası içeren anahtarı alır.This method takes the key that contains the list, a starting point, and an ending point. Aşağıdaki kod, listenin en sol ucundaki 10 blog gönderisini (0 ile 9 arasındaki öğeler) alır:The following code retrieves the titles of the 10 blog posts (items from 0 to 9) at the left-most end of the list:

// Show latest ten posts
foreach (string postTitle in await cache.ListRangeAsync(redisKey, 0, 9))
{
    Console.WriteLine(postTitle);
}

ListRangeAsync yönteminin listeden öğe kaldırmadığını unutmayın.Note that the ListRangeAsync method does not remove items from the list. Bunu yapmak için IDatabase.ListLeftPopAsync ve IDatabase.ListRightPopAsync yöntemlerini kullanabilirsiniz.To do this, you can use the IDatabase.ListLeftPopAsync and IDatabase.ListRightPopAsync methods.

Listenin süresiz olarak büyümesini engellemek için listeyi kırparak öğeleri düzenli aralıklarla seçebilirsiniz.To prevent the list from growing indefinitely, you can periodically cull items by trimming the list. Aşağıdaki kod parçacığında listenin en solundaki beş öğe dışında tüm öğelerin nasıl kaldırılacağı gösterilmektedir:The code snippet below shows you how to remove all but the five left-most items from the list:

await cache.ListTrimAsync(redisKey, 0, 5);

Puan tablosu uygulamaImplement a leader board

Bir kümedeki öğeler varsayılan olarak belirli bir sırada tutulmaz.By default, the items in a set are not held in any specific order. ZADD komutunu (StackExchange kitaplığındaki IDatabase.SortedSetAdd yöntemi) kullanarak sıralı bir küme oluşturabilirsiniz.You can create an ordered set by using the ZADD command (the IDatabase.SortedSetAdd method in the StackExchange library). Öğeler, komuta bir parametre olarak sağlanan ve puan adı verilen sayısal bir değer kullanılarak sıralanır.The items are ordered by using a numeric value called a score, which is provided as a parameter to the command.

Aşağıdaki kod parçacığı, bir blog gönderisinin başlığını sıralı bir listeye ekler.The following code snippet adds the title of a blog post to an ordered list. Bu örnekte her blog gönderisi, blog gönderisinin sıralamasını içeren bir puan alanına sahiptir.In this example, each blog post also has a score field that contains the ranking of the blog post.

ConnectionMultiplexer redisHostConnection = ...;
IDatabase cache = redisHostConnection.GetDatabase();
...
string redisKey = "blog:post_rankings";
BlogPost blogPost = ...; // Reference to a blog post that has just been rated
await cache.SortedSetAddAsync(redisKey, blogPost.Title, blogPost.Score);

IDatabase.SortedSetRangeByRankWithScores yöntemini kullanarak blog gönderisi başlıklarını ve puanları artan puan sırasıyla alabilirsiniz:You can retrieve the blog post titles and scores in ascending score order by using the IDatabase.SortedSetRangeByRankWithScores method:

foreach (var post in await cache.SortedSetRangeByRankWithScoresAsync(redisKey))
{
    Console.WriteLine(post);
}

Not

StackExchange kitaplığı ayrıca verileri puan sırasıyla döndüren ancak puanları döndürmeyen IDatabase.SortedSetRangeByRankAsync yöntemini sağlar.The StackExchange library also provides the IDatabase.SortedSetRangeByRankAsync method, which returns the data in score order, but does not return the scores.

Öğeleri ayrıca azalan puan sırasına göre alabilir ve IDatabase.SortedSetRangeByRankWithScoresAsync yöntemine ek parametreler sağlayarak döndürülen öğe sayısını sınırlayabilirsiniz.You can also retrieve items in descending order of scores, and limit the number of items that are returned by providing additional parameters to the IDatabase.SortedSetRangeByRankWithScoresAsync method. Aşağıdaki örnekte ilk 10 sıradaki blog gönderilerinin başlık ve puanları gösterilmektedir:The next example displays the titles and scores of the top 10 ranked blog posts:

foreach (var post in await cache.SortedSetRangeByRankWithScoresAsync(
                               redisKey, 0, 9, Order.Descending))
{
    Console.WriteLine(post);
}

Aşağıdaki örnekte, döndürülen öğeleri belirli bir puan aralığına denk gelen öğelerle sınırlamak için kullanabileceğiniz IDatabase.SortedSetRangeByScoreWithScoresAsync yöntemi kullanılır:The next example uses the IDatabase.SortedSetRangeByScoreWithScoresAsync method, which you can use to limit the items that are returned to those that fall within a given score range:

// Blog posts with scores between 5000 and 100000
foreach (var post in await cache.SortedSetRangeByScoreWithScoresAsync(
                               redisKey, 5000, 100000))
{
    Console.WriteLine(post);
}

Kanalları kullanarak ileti göndermeMessage by using channels

Redis sunucusu bir veri önbelleği olarak hareket etmesinin dışında yüksek performanslı bir yayımcı/abone mekanizması aracılığıyla mesajlaşma sağlar.Apart from acting as a data cache, a Redis server provides messaging through a high-performance publisher/subscriber mechanism. İstemci uygulamalar bir kanala abone olabilir ve diğer uygulama veya hizmetler, kanala ileti yayımlayabilir.Client applications can subscribe to a channel, and other applications or services can publish messages to the channel. Daha sonra, abone olan uygulamalar bu iletileri alıp işleyebilir.Subscribing applications will then receive these messages and can process them.

Redis, istemci uygulamaların kanallara abone olmak üzere kullanması için SUBSCRIBE komutunu sağlar.Redis provides the SUBSCRIBE command for client applications to use to subscribe to channels. Bu komut, uygulamanın iletileri kabul edeceği bir veya daha fazla kanalın adını bekler.This command expects the name of one or more channels on which the application will accept messages. StackExchange kitaplığı, bir .NET Framework uygulamasının kanallara abone olup yayımlamasını sağlayan ISubscription arabirimini içerir.The StackExchange library includes the ISubscription interface, which enables a .NET Framework application to subscribe and publish to channels.

Redis sunucusu ile bağlantı kurmak için GetSubscriber yöntemini kullanarak bir ISubscription nesnesi oluşturabilirsiniz.You create an ISubscription object by using the GetSubscriber method of the connection to the Redis server. Ardından, bu nesnenin SubscribeAsync yöntemini kullanarak bir kanaldaki iletileri dinleyebilirsiniz.Then you listen for messages on a channel by using the SubscribeAsync method of this object. Aşağıdaki kod örneğinde "messages:blogPosts" adlı bir kanala nasıl abone olunacağı gösterilmektedir:The following code example shows how to subscribe to a channel named "messages:blogPosts":

ConnectionMultiplexer redisHostConnection = ...;
ISubscriber subscriber = redisHostConnection.GetSubscriber();
...
await subscriber.SubscribeAsync("messages:blogPosts", (channel, message) => Console.WriteLine("Title is: {0}", message));

Subscribe yönteminin ilk parametresi, kanalın adıdır.The first parameter to the Subscribe method is the name of the channel. Bu ad, önbellekteki anahtarlar tarafından kullanılan kuralların aynısını izler.This name follows the same conventions that are used by keys in the cache. İyi performans ve sürdürülebilirliği sağlamak için oldukça kısa ve anlamlı dizeler kullanılması önerilse de, ad herhangi bir ikili veri içerebilir.The name can contain any binary data, although it is advisable to use relatively short, meaningful strings to help ensure good performance and maintainability.

Ayrıca, kanallar tarafından kullanılan ad alanının, anahtarlar tarafından kullanılan ad alanından ayrı olduğunu unutmayın.Note also that the namespace used by channels is separate from that used by keys. Başka bir deyişle, aynı ada sahip kanallarınız ve anahtarlarınız olabilir, ancak bu durum uygulama kodunuzun sürdürülmesini zorlaştırabilir.This means you can have channels and keys that have the same name, although this may make your application code more difficult to maintain.

İkinci parametre bir Eylem temsilcisidir.The second parameter is an Action delegate. Bu temsilci, kanalda yeni bir iletinin göründüğü her durumda zaman uyumsuz olarak çalışır.This delegate runs asynchronously whenever a new message appears on the channel. Bu örnek yalnızca konsol üzerindeki iletiyi gösterir (ileti bir blog gönderisinin başlığını içerecektir).This example simply displays the message on the console (the message will contain the title of a blog post).

Bir kanalda yayımlamak için uygulama Redis PUBLISH komutunu kullanabilir.To publish to a channel, an application can use the Redis PUBLISH command. StackExchange kitaplığı bu işlemi gerçekleştirmek için IServer.PublishAsync yöntemini sağlar.The StackExchange library provides the IServer.PublishAsync method to perform this operation. Aşağıdaki kod parçacığı, "messages:blogPosts" kanalında nasıl ileti yayımlanacağını gösterir:The next code snippet shows how to publish a message to the "messages:blogPosts" channel:

ConnectionMultiplexer redisHostConnection = ...;
ISubscriber subscriber = redisHostConnection.GetSubscriber();
...
BlogPost blogPost = ...;
subscriber.PublishAsync("messages:blogPosts", blogPost.Title);

Yayımlama/abone olma mekanizması hakkında anlaşılması gereken birkaç nokta mevcuttur:There are several points you should understand about the publish/subscribe mechanism:

  • Birden çok abone aynı kanala abone olabilir ve hepsi bu kanalda yayımlanan tüm iletileri alır.Multiple subscribers can subscribe to the same channel, and they will all receive the messages that are published to that channel.
  • Aboneler yalnızca abone olduktan sonra yayımlanan iletileri alırlar.Subscribers only receive messages that have been published after they have subscribed. Kanallar arabelleğe alınmamıştır ve bir ileti yayımlandıktan sonra Redis altyapısı iletiyi her bir aboneye gönderir ve sonra kaldırır.Channels are not buffered, and once a message is published, the Redis infrastructure pushes the message to each subscriber and then removes it.
  • Varsayılan olarak, iletiler gönderildikleri sırayla aboneler tarafından alınır.By default, messages are received by subscribers in the order in which they are sent. Çok sayıda ileti ve çok sayıda abone ile yayımcı içeren yüksek oranda etkin bir sistemde iletilerin kesin olarak sıralı bir şekilde teslim edilmesi, sistemin performansını yavaşlatabilir.In a highly active system with a large number of messages and many subscribers and publishers, guaranteed sequential delivery of messages can slow performance of the system. Her ileti bağımsız ve sıra önemsizse, Redis sistemi tarafından eşzamanlı işlemeyi etkinleştirebilir ve yanıt hızını iyileştirmeye yardımcı olabilirsiniz.If each message is independent and the order is unimportant, you can enable concurrent processing by the Redis system, which can help to improve responsiveness. Bir StackExchange istemcisinde bunu yapmak için abone tarafından kullanılan bağlantının PreserveAsyncOrder değerini false olarak ayarlayın:You can achieve this in a StackExchange client by setting the PreserveAsyncOrder of the connection used by the subscriber to false:
ConnectionMultiplexer redisHostConnection = ...;
redisHostConnection.PreserveAsyncOrder = false;
ISubscriber subscriber = redisHostConnection.GetSubscriber();

Seri hale getirme konularıSerialization considerations

Bir seri hale getirme biçimi seçtiğinizde performans, birlikte çalışabilirlik, sürüm oluşturma, var olan sistemlerle uyumluluk, veri sıkıştırma ve bellek ek yükü arasındaki dengeleri göz önünde bulundurun.When you choose a serialization format, consider tradeoffs between performance, interoperability, versioning, compatibility with existing systems, data compression, and memory overhead. Performansı değerlendirirken ölçütlerin bağlama yüksek oranda bağımlı olduğunu unutmayın.When you are evaluating performance, remember that benchmarks are highly dependent on context. Bunlar gerçek iş yükünüzü yansıtmayabilir ve yeni kitaplıkları veya sürümleri dikkate almayabilir.They may not reflect your actual workload, and may not consider newer libraries or versions. Tüm senaryolar için tek bir "en hızlı" seri hale getirici yoktur.There is no single "fastest" serializer for all scenarios.

Dikkate alınması gereken bazı seçenekler şunlardır:Some options to consider include:

  • Protokol Arabellekleri (aynı zamanda protobuf olarak adlandırılır), yapılandırılmış verileri verimli bir şekilde serileştirmek amacıyla Google tarafından geliştirilmiş bir serileştirme biçimidir.Protocol Buffers (also called protobuf) is a serialization format developed by Google for serializing structured data efficiently. İleti yapılarını tanımlamak için türü kesin belirlenmiş tanım dosyalarını kullanır.It uses strongly typed definition files to define message structures. Bu tanım dosyaları daha sonra iletileri serileştirmek ve seri durumdan çıkarmak için dile özgü kod halinde derlenir.These definition files are then compiled to language-specific code for serializing and deserializing messages. Protobuf mevcut RPC mekanizmaları üzerinde kullanılabilir veya bir RPC hizmeti oluşturabilir.Protobuf can be used over existing RPC mechanisms, or it can generate an RPC service.

  • Apache Thrift, kesin türü belirtilmiş tanım dosyaları ve serileştirme kodu ile RPC hizmetlerini oluşturmaya yönelik bir derleme adımı ile benzer bir yaklaşım kullanır.Apache Thrift uses a similar approach, with strongly typed definition files and a compilation step to generate the serialization code and RPC services.

  • Apache Avro, Protokol Arabellekleri ve Thrift ile benzer işlevler sağlar, ancak bir derleme adımı içermez.Apache Avro provides similar functionality to Protocol Buffers and Thrift, but there is no compilation step. Bunun yerine, serileştirilmiş veriler her zaman yapıyı tanımlayan bir şema içerir.Instead, serialized data always includes a schema that describes the structure.

  • JSON, okunaklı metin alanları kullanan bir açık standarttır.JSON is an open standard that uses human-readable text fields. Geniş bir platformlar arası desteğe sahiptir.It has broad cross-platform support. JSON, ileti şemaları kullanmaz.JSON does not use message schemas. Metin tabanlı bir biçim olduğu için kablo üzerinde çok verimli değildir.Being a text-based format, it is not very efficient over the wire. Ancak, bazı durumlarda önbelleğe alınmış öğeleri HTTP aracılığıyla doğrudan bir istemciye döndürüyor olabilirsiniz; bu durumda JSON başka bir biçimde seri durumdan çıkarma ve sonra JSON biçiminde serileştirme maliyetinden tasarruf edebilir.In some cases, however, you may be returning cached items directly to a client via HTTP, in which case storing JSON could save the cost of deserializing from another format and then serializing to JSON.

  • BSON, JSON ile benzer bir yapı kullanan, ikili bir serileştirme biçimidir.BSON is a binary serialization format that uses a structure similar to JSON. BSON, JSON’a kıyasla basit, kolay taranabilir ve hızlı serileştirilip seri durumdan çıkarılabilir şekilde tasarlanmıştır.BSON was designed to be lightweight, easy to scan, and fast to serialize and deserialize, relative to JSON. Yükler boyut bakımından JSON ile benzerdir.Payloads are comparable in size to JSON. Verilere bağlı olarak bir BSON yükü, JSON yükünden daha küçük veya daha büyük olabilir.Depending on the data, a BSON payload may be smaller or larger than a JSON payload. BSON, başta BinData (bayt dizileri için) ve Date olmak üzere JSON’da mevcut olmayan bazı ek veri türlerine sahiptir.BSON has some additional data types that are not available in JSON, notably BinData (for byte arrays) and Date.

  • MessagePack, kablo üzerinden aktarım için kompakt şekilde tasarlanmış bir ikili serileştirme biçimidir.MessagePack is a binary serialization format that is designed to be compact for transmission over the wire. İleti şemaları veya ileti türü denetimi yoktur.There are no message schemas or message type checking.

  • Bond, şema haline getirilmiş verilerle çalışmaya yönelik bir platformlar arası çerçevedir.Bond is a cross-platform framework for working with schematized data. Diller arası serileştirme ve seri durumdan çıkarmayı destekler.It supports cross-language serialization and deserialization. Burada listelenen diğer sistemlerle belirgin farklılıkları, devralma, tür diğer adları ve genel türlere yönelik desteğidir.Notable differences from other systems listed here are support for inheritance, type aliases, and generics.

  • GRPC , Google tarafından geliştirilen açık KAYNAKLı bir RPC sistemidir.gRPC is an open-source RPC system developed by Google. Varsayılan olarak, tanım dili ve temel alınan ileti değişim biçimi için Protokol Arabellekleri’ni kullanır.By default, it uses Protocol Buffers as its definition language and underlying message interchange format.

Uygulamalarınızda önbelleğe alma uyguladığınızda aşağıdaki desenler de senaryonuz için uygun olabilir:The following patterns might also be relevant to your scenario when you implement caching in your applications:

  • Önbellek stili: Bu model, verileri bir veri deposundan bir önbelleğe talep üzerine yüklemeyi açıklar.Cache-aside pattern: This pattern describes how to load data on demand into a cache from a data store. Bu düzen ayrıca önbellekte tutulan veriler ile özgün veri deposundaki veriler arasında tutarlılığı sürdürmeye yardımcı olur.This pattern also helps to maintain consistency between data that's held in the cache and the data in the original data store.

  • Parçalama düzeni, büyük miktarlarda verileri depolarken ve böyle verilere erişirken ölçeklenebilirliği artırmaya yardımcı olmak üzere yatay bölümleme uygulama hakkında bilgiler sağlar.The Sharding pattern provides information about implementing horizontal partitioning to help improve scalability when storing and accessing large volumes of data.

Daha fazla bilgiMore information