Docs
⌘ K

4 dakika

Dağıtık Sistemler

The Graph, dağıtık bir sistem olarak uygulanmış bir protokoldür.

Bağlantılar kesilir. İstekler sıralanmamış şekilde ulaşır. Saatleri ve durumları senkronize olmayan farklı bilgisayarlar ilişkili istekleri işler. Sunucular yeniden başlatılır. İstekler arasında yeniden düzenlemeler meydana gelir. Tüm bu sorunlar tüm dağıtık sistemlerin doğasında vardır; ancak küresel ölçekte çalışan sistemlerde bu durumlar daha da şiddetlenir.

Bir istemcinin, bir yeniden düzenleme (re-org) sırasında en güncel veriyi almak için bir Endeksleyici’yi yokladığı (polling) durumda yaşanabilecek aşağıdaki örneği göz önünde bulundurun.

  1. Endeksleyici blok 8’i alır ve işler
  2. İstemciye blok 8 için istek sunulur
  3. Endeksleyici blok 9’i alır ve işler
  4. Endeksleyici blok 10A’yı alır ve işler
  5. İstemciye blok 10A için istek sunulur
  6. Endeksleyici, 10B bloğuna yönelik bir yeniden düzenlemeyi algılar ve 10A’yı geri alır (rollback)
  7. İstemciye blok 9 için istek sunulur
  8. Endeksleyici blok 10B’yi alır ve işler
  9. Endeksleyici blok 11’i alır ve işler
  10. İstemciye blok 11 için istek sunulur

Endeksleyicinin bakış açısından işler mantıklı olarak ilerlemektedir. Zaman ileriye doğru akıyor, her ne kadar bir “uncle” bloğu geri almak ve onun yerine üzerinde konsensüs sağlanan bloku yeniden yürütmek zorunda kalmış olsak da. Bu süreçte, Endeksleyici, o anda bildiği en güncel durumu kullanarak gelen istekleri karşılar.

Ancak istemci bakış açısından işler kaotik görünür. İstemci, yanıtların sırasıyla 8, 10, 9 ve 11 numaralı bloklar için olduğunu gözlemler. Buna “blok dalgalanması” sorunu diyoruz. Bir istemci blok dalgalanması yaşadığında, veri zaman içinde kendisiyle çelişiyormuş gibi görünebilir. Bu durum, tüm Endeksleyicilerin son blokları aynı anda alıp işlememesi ve isteklerinizin birden fazla Endeksleyiciye yönlendirilebilmesi nedeniyle daha da kötüleşir.

Kullanıcıya tutarlı veri sunmak, istemci ve sunucunun ortak sorumluluğundadır ve beraber çalışmalarını gerektirir. Her problem için tek bir doğru program olmadığından, hedeflenen tutarlılık düzeyine göre farklı yaklaşımlar kullanılmalıdır.

Dağıtık sistemlerin sonuçlarını değerlendirmek zor olabilir, ancak çözüm o kadar da karmaşık olmak zorunda değil! Bazı yaygın kullanım senaryolarında yolunuzu bulmanıza yardımcı olmak için API’ler ve kalıplar oluşturduk. Aşağıdaki örnekler bu kalıpları göstermektedir; ancak temel fikirleri gölgelememek adına, hata yönetimi ve iptal gibi üretim ortamında gerekli olan bazı ayrıntılar atlanmıştır.

Güncellenmiş veriler için yoklama yapma

The Graph, yanıtın yalnızca $minBlock değerine eşit veya daha büyük tek bir blok için verilmesini garanti eden block: { number_gte: $minBlock } API’sini sağlar. Eğer istek bir graph-node örneğine yapılırsa ve belirtilen minimum blok henüz senkronize edilmemişse, graph-node bir hata döndürür. Eğer graph-node minimum bloğu senkronize ettiyse, yanıtı en son blok için üretir. İstek bir Edge & Node Gateway üzerinden yapılırsa, Gateway henüz minimum bloku senkronize etmemiş olan Endeksleyicileri filtreler ve isteği Endeksleyicinin senkronize ettiği en son blok için yapar.

Bir döngü içinde veri yoklaması yaparken zamanın asla geriye gitmemesini sağlamak için number_gte ifadesini kullanabiliriz. İşte bir örnek:

/// The Graph kullanarak protocol.paused değişkenini/// döngü içerisinde en son bilinen değere günceller.async function updateProtocolPaused() {  // minBlock = 0 ile başlamak sorun değildir. Sorgu,  // mevcut en güncel blok kullanılarak yanıtlanacaktır.  // minBlock'u 0 olarak ayarlamak, bu argümanı hiç vermemekle aynıdır.  let minBlock = 0  for (;;) {    // Bir sonraki Ethereum blokunun muhtemelen hazır olacağı zamanda    // tetiklenecek bir promise planla.    const nextBlock = new Promise((f) => {      setTimeout(f, 14000)    })    const query = `        query GetProtocol($minBlock: Int!) {            protocol(block: { number_gte: $minBlock }  id: "0") {              paused            }            _meta {                block {                    number                }            }        }`    const variables = { minBlock }    const response = await graphql(query, variables)    minBlock = response._meta.block.number    // TODO: Burada loglamak yerine yanıt verisiyle bir şey yap.    console.log(response.protocol.paused)    // Bir sonraki bloku beklemek için uykuya geç    await nextBlock  }}

İlişkili ögelerden oluşan bir küme getirme

Bir diğer kullanım senaryosu ise büyük bir kümenin ya da daha genel olarak, birden fazla istek üzerinden ilişkili ögelerin getirilmesidir. Yoklama (polling) senaryosundan farklı olarak (orada hedeflenen tutarlılık zaman içinde ileri gitmekti), burada hedeflenen tutarlılık tek bir zaman noktasına aittir.

Burada, tüm sonuçlarımızı aynı bloka sabitlemek için block: { hash: $blockHash } argümanını kullanacağız.

/// Sayfalama kullanarak tek bir bloktan alan adları listesini alırasync function getDomainNames() {  // // Çekilecek en fazla öge sayısına bir sınır koy.  let pages = 5  const perPage = 1000  // İlk sorgu, ilk sayfadaki sonuçları alacak ve aynı zamanda  // kalan sorguların ilk sorguyla tutarlı olabilmesi için blok hash'ini alacak.  const listDomainsQuery = `    query ListDomains($perPage: Int!) {        domains(first: $perPage) {            name            id        }        _meta {            block {                hash            }        }    }`  let data = await graphql(listDomainsQuery, { perPage })  let result = data.domains.map((d) => d.name)  let blockHash = data._meta.block.hash  let query  // Ya toplamda 5 sayfalık sınırı aşana kadar (yukarıda belirtildiği gibi)  // son sayfaya ulaştığımızı görene kadar (sayfada tam sayfadan az varlık varsa)  // ek sayfaları getirmeye devam et.  while (data.domains.length == perPage && --pages) {    let lastID = data.domains[data.domains.length - 1].id    query = `        query ListDomains($perPage: Int!, $lastID: ID!, $blockHash: Bytes!) {            domains(first: $perPage, where: { id_gt: $lastID }, block: { hash: $blockHash }) {                name                id            }        }`    data = await graphql(query, { perPage, lastID, blockHash })    // Alan adlarını sonuca ekle    for (domain of data.domains) {      result.push(domain.name)    }  }  return result}

Bir yeniden düzenleme durumunda, istemcinin blok hash’ini bir “uncle” olmayan blokla güncellemek için ilk isteği baştan tekrar etmesi gerekeceğini unutmayın.