Ubuntu 12.04 VPS Üzerinde MongoDB Shard Kümesi Oluşturma Rehberi

Ubuntu 12.04 VPS Üzerinde MongoDB Shard Kümesi Oluşturma Rehberi

Giriş

Günümüzün veri odaklı dünyasında, uygulamaların sürekli büyüyen veri hacimlerini ve yüksek eşzamanlı istekleri sorunsuz bir şekilde işlemesi kritik öneme sahiptir. Geleneksel veritabanı mimarileri, belirli bir noktadan sonra performans ve ölçeklenebilirlik sorunlarıyla karşılaşabilir. MongoDB, esnek belge tabanlı yapısı ve yatay ölçeklenebilirlik yetenekleri sayesinde bu zorlukların üstesinden gelmek için güçlü bir çözüm sunar. Özellikle sharding, MongoDB’nin büyük veri kümelerini ve yüksek yükleri yönetmek için tasarlanmış temel özelliklerinden biridir.

Bu kapsamlı teknik makale, Ubuntu 12.04 işletim sistemine sahip Sanal Özel Sunucular (VPS) üzerinde bir MongoDB shard kümesinin adım adım nasıl oluşturulacağını detaylandırmaktadır. Ubuntu 12.04’ün eski bir sürüm olması nedeniyle, bu rehber belirli sürüm uyumluluklarına ve olası kısıtlamalara dikkat çekerek, bu ortamda shard kümesi kurmak isteyenlere yol gösterecektir. Sharding’in temel prensiplerinden başlayarak, her bir küme bileşeninin kurulumuna, yapılandırmasına ve test edilmesine kadar tüm süreç ayrıntılı bir şekilde ele alınacaktır. Amaç, okuyuculara sağlam, ölçeklenebilir ve yüksek performanslı bir MongoDB altyapısı kurmaları için gerekli bilgi ve becerileri kazandırmaktır.

Sharding Nedir ve Neden Kullanılır?

Sharding, büyük veri kümelerinin birden çok sunucuya (shard) yatay olarak dağıtılması işlemidir. Her bir shard, veri kümesinin bir alt kümesini barındırır ve kendi başına bir veritabanı sistemi gibi çalışır. Bu yaklaşım, tek bir sunucunun depolama kapasitesi, işlem gücü veya I/O performans limitlerine takılmadan veritabanı sistemlerinin ölçeklenmesini sağlar.

Neden Sharding Kullanmalıyız?

* Yatay Ölçeklenebilirlik: Geleneksel dikey ölçeklendirme (daha güçlü bir sunucuya geçiş), belirli bir noktada fiziksel sınırlarla karşılaşır ve maliyetli hale gelir. Sharding, daha fazla sunucu ekleyerek kapasiteyi artırma olanağı sunar.
* Daha Yüksek Performans: Veri birden çok sunucuya dağıtıldığında, sorgular paralel olarak işlenebilir. Bu, özellikle büyük veri kümeleri üzerinde karmaşık sorgular çalıştırılırken önemli performans artışları sağlar. Her shard, kendi verisinin bir alt kümesini işlediği için, her bir sunucunun üzerindeki yük azalır.
* Daha Fazla Depolama Kapasitesi: Tek bir sunucunun disk alanı sınırlamalarını aşarak, terabaytlarca hatta petabaytlarca veriyi depolama imkanı sunar.
* Yüksek Erişilebilirlik: Sharding genellikle replica set’lerle birleştirilir. Bir shard’ın birincil sunucusu (primary) başarısız olduğunda, replica set içindeki ikincil sunuculardan (secondary) biri otomatik olarak birincil hale gelir, bu da hizmet kesintilerini minimize eder.
* Daha Az Ağ Gecikmesi: Veriler coğrafi olarak dağıtıldığında, kullanıcılar kendilerine en yakın shard’dan veri alabilir, bu da ağ gecikmelerini azaltır.

MongoDB Shard Kümesinin Temel Bileşenleri

Bir MongoDB shard kümesi üç ana bileşenden oluşur:

1. Shardlar (Shards): Verilerin tutulduğu ve işlendiği sunuculardır. Her bir shard, yüksek erişilebilirlik ve veri dayanıklılığı sağlamak için genellikle bir replica set olarak yapılandırılır. Bir shard kümesi birden çok shard içerebilir.
2. Config Serverlar (Config Servers): Kümenin meta verilerini (hangi verinin hangi shard’da olduğu, shard key aralıkları, chunk’lar vb.) depolayan özel mongod örnekleridir. Config serverlar da yüksek erişilebilirlik için bir replica set olarak yapılandırılır. MongoDB 3.2 ve sonraki sürümlerde config server’lar zorunlu olarak replica set olarak çalışır. Ubuntu 12.04 için kullanacağımız MongoDB 2.x veya erken 3.x sürümlerinde de bu yaklaşım önerilir.
3. mongos Routerlar (Query Routers): İstemci uygulamaları ile shard kümesi arasındaki arayüzü sağlayan yönlendiricilerdir. Uygulamalar mongos‘a bağlanır ve mongos, sorguları doğru shard’lara yönlendirir, sonuçları toplar ve istemciye geri gönderir. mongos‘lar durum bilgisi tutmaz (stateless) ve kolayca yatay olarak ölçeklenebilir.

Shard Key Seçimi

Sharding’in en kritik kararlarından biri, shard key seçimidir. Shard key, MongoDB’nin verileri shard’lar arasında nasıl dağıtacağını belirleyen bir veya daha fazla alanın birleşimidir. İyi bir shard key:
* Veriyi shard’lar arasında eşit olarak dağıtır (homojen dağılım).
* Sorguların çoğunluğunun belirli bir shard’a yönlendirilmesini sağlar (hedefli sorgular).
* Hotspot’ları (tek bir shard’ın aşırı yüklenmesi) önler.

Yanlış shard key seçimi, sharding’in faydalarını ortadan kaldırabilir ve hatta performansı düşürebilir.

Sistem Gereksinimleri ve Ön Hazırlık

Ubuntu 12.04 üzerinde bir MongoDB shard kümesi kurmak için belirli sistem gereksinimleri ve ön hazırlık adımları bulunmaktadır. Bu adımlar, kurulum sürecinin sorunsuz ilerlemesini ve kümenin istikrarlı çalışmasını sağlar.

VPS Sayısı ve Dağılımı

Bir shard kümesi kurmak için minimum gereksinimler:
* Config Server Replica Set: 3 adet VPS (her biri bir config server için).
Shard Replica Set’leri: Her shard için en az 3 adet VPS. Bu rehberde 2 shard kullanacağımızı varsayarsak, 2 3 = 6 adet VPS.
* mongos Router’lar: En az 1 adet VPS (genellikle yedeklilik için 2 veya daha fazla önerilir).

Toplamda, bu örnek yapılandırma için en az 10 adet Ubuntu 12.04 VPS gerekecektir. Her VPS’in en az 1GB RAM ve 20GB SSD depolama alanına sahip olması önerilir.

Örnek Ağ Topolojisi (IP Adresleri ve Rolleri):

| Rol | VPS IP Adresi | Port Numarası |
| :——————- | :—————– | :———— |
| Config Server 1 | 192.168.1.101 | 27019 |
| Config Server 2 | 192.168.1.102 | 27019 |
| Config Server 3 | 192.168.1.103 | 27019 |
| Shard1-Replica1 | 192.168.1.111 | 27018 |
| Shard1-Replica2 | 192.168.1.112 | 27018 |
| Shard1-Replica3 | 192.168.1.113 | 27018 |
| Shard2-Replica1 | 192.168.1.121 | 27018 |
| Shard2-Replica2 | 192.168.1.122 | 27018 |
| Shard2-Replica3 | 192.168.1.123 | 27018 |
| mongos Router 1 | 192.168.1.131 | 27017 |
| mongos Router 2 (Ops.) | 192.168.1.132 | 27017 |

Not: Bu IP adresleri ve portlar örnek amaçlıdır. Kendi ağ yapılandırmanıza göre bunları ayarlamanız gerekecektir. Tüm VPS’lerin birbirleriyle belirtilen portlar üzerinden iletişim kurabildiğinden emin olun.

MongoDB Sürümü

Ubuntu 12.04 (Precise Pangolin), Nisan 2017’de ömrünü tamamlamış eski bir işletim sistemidir. Bu nedenle, güncel MongoDB sürümleriyle uyumluluk sorunları yaşanabilir. Bu rehber için MongoDB 2.6 veya 3.0 serisi önerilir. MongoDB’nin kendi depoları bu eski sürümleri hala barındırıyor olabilir. Bu rehberde, MongoDB 2.6’yı hedef alacağız, çünkü 12.04 ile en uyumlu ve yaygın kullanılan sürümlerden biridir.

Tüm VPS’lerde Ortak Adımlar

Her bir VPS’ye SSH ile bağlanarak aşağıdaki ön hazırlık adımlarını uygulayın:

1. Sistem Güncellemesi:

sudo apt-get update
    sudo apt-get upgrade -y

2. MongoDB Deposu Ekleme (MongoDB 2.6 için):
MongoDB’nin resmi deposunu sisteminize ekleyin.

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10
    echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list
    sudo apt-get update

Not: 10gen deposu MongoDB 2.x sürümleri için geçerlidir. Daha yeni sürümler için depo adresi farklı olabilir.

3. MongoDB Kurulumu:

sudo apt-get install -y mongodb-org=2.6.12 mongodb-org-server=2.6.12 mongodb-org-shell=2.6.12 mongodb-org-mongos=2.6.12 mongodb-org-tools=2.6.12

Not: Belirli bir sürümü (örneğin 2.6.12) yüklemek, uyumluluk sorunlarını önlemek için önemlidir.

4. Güvenlik Duvarı Ayarları (UFW Kullanılıyorsa):
Gerekli portlara (27017, 27018, 27019) erişime izin verin.

sudo ufw allow 27017/tcp
    sudo ufw allow 27018/tcp
    sudo ufw allow 27019/tcp
    sudo ufw enable

Not: Kendi güvenlik politikalarınıza göre sadece gerekli IP adreslerinden erişime izin vermeniz daha güvenlidir.

5. Veri ve Log Dizinleri Oluşturma:
Her MongoDB örneği için ayrı veri ve log dizinleri oluşturmak iyi bir uygulamadır.

sudo mkdir -p /var/lib/mongodb/configdb
    sudo mkdir -p /var/lib/mongodb/shard1
    sudo mkdir -p /var/lib/mongodb/shard2
    sudo mkdir -p /var/log/mongodb
    sudo chown -R mongodb:mongodb /var/lib/mongodb
    sudo chown -R mongodb:mongodb /var/log/mongodb

Bu dizinler, MongoDB instance’larının türüne göre kullanılacaktır.

Shard Kümesi Bileşenlerinin Kurulumu

Şimdi sıra, kümenin temel bileşenlerini tek tek kurmaya geldi. Her bir bileşen için ayrı VPS’lerde kurulum adımlarını takip edeceğiz.

Config Server Replica Set Kurulumu

Config server’lar, shard kümesinin meta verilerini tutar. Yüksek erişilebilirlik için üç config server’dan oluşan bir replica set kuracağız.

Adım 1: Her bir Config Server VPS’sinde mongod‘u Başlatma
(192.168.1.101, 192.168.1.102, 192.168.1.103 IP’leri için)

Her VPS’ye SSH ile bağlanın ve aşağıdaki komutu çalıştırın. -port parametresi ile 27019 portunu kullanıyoruz ve --configsvr parametresi ile bu instance’ın bir config server olduğunu belirtiyoruz. --replSet ile replica set adını belirliyoruz (örneğin cs_rs).

# Config Server 1 (192.168.1.101)
sudo mongod --port 27019 --dbpath /var/lib/mongodb/configdb --logpath /var/log/mongodb/configsvr.log --fork --configsvr --replSet cs_rs --bind_ip 192.168.1.101

Config Server 2 (192.168.1.102)
sudo mongod --port 27019 --dbpath /var/lib/mongodb/configdb --logpath /var/log/mongodb/configsvr.log --fork --configsvr --replSet cs_rs --bind_ip 192.168.1.102

Config Server 3 (192.168.1.103)
sudo mongod --port 27019 --dbpath /var/lib/mongodb/configdb --logpath /var/log/mongodb/configsvr.log --fork --configsvr --replSet cs_rs --bind_ip 192.168.1.103

--fork komutu, mongod‘u arka planda bir süreç olarak çalıştırmasını sağlar.
--bind_ip ile sadece belirtilen IP adresinden erişime izin verilir. Bu, güvenlik için iyi bir uygulamadır.

Adım 2: Config Server Replica Set’i Başlatma
Üç config server mongod süreci başladıktan sonra, herhangi bir config server’a (örneğin 192.168.1.101) mongo kabuğu ile bağlanın ve replica set’i başlatın.

mongo --port 27019 --host 192.168.1.101

mongo kabuğunda aşağıdaki komutları çalıştırın:

config = {
   _id : "cs_rs",
   members: [
      { _id : 0, host : "192.168.1.101:27019" },
      { _id : 1, host : "192.168.1.102:27019" },
      { _id : 2, host : "192.168.1.103:27019" }
   ]
}
rs.initiate(config)

rs.initiate() komutu başarılı olduğunda, birincil (primary) sunucuyu belirleyecek ve diğerlerini ikincil (secondary) olarak yapılandıracaktır. Durumu rs.status() ile kontrol edebilirsiniz.

Shard Replica Set’lerinin Kurulumu

Her bir shard, kendi başına bir replica set olarak yapılandırılacaktır. Bu rehberde iki shard kullanacağız: shard1_rs ve shard2_rs. Her biri üç üyeden oluşacaktır.

Adım 1: Shard1 Replica Set Üyelerini Başlatma
(192.168.1.111, 192.168.1.112, 192.168.1.113 IP’leri için)

Her VPS’ye SSH ile bağlanın ve aşağıdaki komutu çalıştırın. -port parametresi ile 27018 portunu kullanıyoruz ve --shardsvr parametresi ile bu instance’ın bir shard olduğunu belirtiyoruz. --replSet ile replica set adını belirliyoruz (örneğin shard1_rs).

# Shard1-Replica1 (192.168.1.111)
sudo mongod --port 27018 --dbpath /var/lib/mongodb/shard1 --logpath /var/log/mongodb/shard1.log --fork --shardsvr --replSet shard1_rs --bind_ip 192.168.1.111

Shard1-Replica2 (192.168.1.112)
sudo mongod --port 27018 --dbpath /var/lib/mongodb/shard1 --logpath /var/log/mongodb/shard1.log --fork --shardsvr --replSet shard1_rs --bind_ip 192.168.1.112

Shard1-Replica3 (192.168.1.113)
sudo mongod --port 27018 --dbpath /var/lib/mongodb/shard1 --logpath /var/log/mongodb/shard1.log --fork --shardsvr --replSet shard1_rs --bind_ip 192.168.1.113

Adım 2: Shard1 Replica Set’i Başlatma
Herhangi bir Shard1 üyesine (örneğin 192.168.1.111) mongo kabuğu ile bağlanın:

mongo --port 27018 --host 192.168.1.111

mongo kabuğunda:

config = {
   _id : "shard1_rs",
   members: [
      { _id : 0, host : "192.168.1.111:27018" },
      { _id : 1, host : "192.168.1.112:27018" },
      { _id : 2, host : "192.168.1.113:27018" }
   ]
}
rs.initiate(config)

rs.status() ile durumu kontrol edin.

Adım 3: Shard2 Replica Set Üyelerini Başlatma
(192.168.1.121, 192.168.1.122, 192.168.1.123 IP’leri için)

# Shard2-Replica1 (192.168.1.121)
sudo mongod --port 27018 --dbpath /var/lib/mongodb/shard2 --logpath /var/log/mongodb/shard2.log --fork --shardsvr --replSet shard2_rs --bind_ip 192.168.1.121

Shard2-Replica2 (192.168.1.122)
sudo mongod --port 27018 --dbpath /var/lib/mongodb/shard2 --logpath /var/log/mongodb/shard2.log --fork --shardsvr --replSet shard2_rs --bind_ip 192.168.1.122

Shard2-Replica3 (192.168.1.123)
sudo mongod --port 27018 --dbpath /var/lib/mongodb/shard2 --logpath /var/log/mongodb/shard2.log --fork --shardsvr --replSet shard2_rs --bind_ip 192.168.1.123

Adım 4: Shard2 Replica Set’i Başlatma
Herhangi bir Shard2 üyesine (örneğin 192.168.1.121) mongo kabuğu ile bağlanın:

mongo --port 27018 --host 192.168.1.121

mongo kabuğunda:

config = {
   _id : "shard2_rs",
   members: [
      { _id : 0, host : "192.168.1.121:27018" },
      { _id : 1, host : "192.168.1.122:27018" },
      { _id : 2, host : "192.168.1.123:27018" }
   ]
}
rs.initiate(config)

rs.status() ile durumu kontrol edin.

mongos Router Kurulumu

mongos router’lar, istemci uygulamalarından gelen sorguları alır ve bunları doğru shard’lara yönlendirir.

Adım 1: mongos Router’ı Başlatma
(192.168.1.131 IP’si için)

mongos‘u başlatırken, --configdb parametresi ile config server replica set’inin adını ve üyelerini belirtmelisiniz.

# mongos Router 1 (192.168.1.131)
sudo mongos --port 27017 --logpath /var/log/mongodb/mongos.log --fork --configdb cs_rs/192.168.1.101:27019,192.168.1.102:27019,192.168.1.103:27019 --bind_ip 192.168.1.131

Birden fazla mongos router’ınız varsa, her biri için aynı komutu farklı bir VPS’de çalıştırın.

Shard Kümesinin Yapılandırılması

Tüm bileşenler çalışır durumda olduğunda, mongos router üzerinden küme yapılandırmasını tamamlamamız gerekir.

Adım 1: mongos’a Bağlanma
Herhangi bir mongos router’a (örneğin 192.168.1.131) mongo kabuğu ile bağlanın:

mongo --port 27017 --host 192.168.1.131

Adım 2: Shard’ları Küme’ye Ekleme
mongos kabuğunda, her bir shard replica set’ini sh.addShard() komutu ile kümeye ekleyin:

sh.addShard( "shard1_rs/192.168.1.111:27018,192.168.1.112:27018,192.168.1.113:27018" )
sh.addShard( "shard2_rs/192.168.1.121:27018,192.168.1.122:27018,192.168.1.123:27018" )

Başarılı bir ekleme sonrası { "shardAdded" : "shard1_rs", "ok" : 1 } gibi bir çıktı almalısınız.

Adım 3: Veritabanı İçin Sharding’i Etkinleştirme
Hangi veritabanında sharding kullanmak istediğinizi belirtin. Örneğin, mydb adında bir veritabanı için:

sh.enableSharding("mydb")

Bu komut, mydb veritabanı için sharding’i etkinleştirir ancak verileri henüz dağıtmaz.

Adım 4: Koleksiyon İçin Sharding’i Etkinleştirme ve Shard Key Belirleme
Şimdi, mydb veritabanındaki belirli bir koleksiyon (örneğin mycollection) için sharding’i etkinleştirmeli ve bir shard key belirlemelisiniz. Shard key seçimi kritik öneme sahiptir. Bu örnekte username alanını shard key olarak kullanalım ve bir indeks oluşturarak başlayalım:

use mydb
db.mycollection.ensureIndex( { username: 1 } ) // Shard key için indeks oluşturma
sh.shardCollection( "mydb.mycollection", { "username": 1 } )

Eğer shard key olarak _id alanını kullanmak isterseniz ve bu alanda homojen dağılım bekliyorsanız, hashed sharding kullanabilirsiniz:

db.mycollection.ensureIndex( { _id: "hashed" } )
sh.shardCollection( "mydb.mycollection", { "_id": "hashed" } )

sh.shardCollection() komutu başarılı olduğunda, MongoDB belirtilen koleksiyonu shard’lar arasında dağıtmaya başlayacaktır. Ancak, koleksiyon boşsa veya az veri içeriyorsa, dağıtım hemen başlamayabilir. Veri eklendikçe balancer devreye girecek ve chunk’ları shard’lar arasında taşıyacaktır.

Sharding Doğrulama ve Test Etme

Küme kurulduktan ve yapılandırıldıktan sonra, her şeyin beklendiği gibi çalıştığından emin olmak için doğrulama ve test adımları atmak önemlidir.

Adım 1: Küme Durumunu Kontrol Etme
mongos kabuğunda sh.status() komutunu kullanarak kümenin genel durumunu kontrol edin:

sh.status()

Bu komut, config server’ları, shard’ları ve her bir shard’daki replica set üyelerini gösterir. Ayrıca, sharding’in etkinleştirildiği veritabanlarını ve koleksiyonları, shard key’lerini ve chunk dağılımını da listeler. Tüm bileşenlerin OK veya PRIMARY/SECONDARY durumunda olduğunu doğrulayın.

Adım 2: Veri Ekleme ve Dağılımını Gözlemleme
Sharding’in doğru çalıştığını test etmek için mydb.mycollection koleksiyonuna biraz veri ekleyin:

use mydb
for (var i = 0; i < 1000; i++) {
   db.mycollection.insert( { username: "user" + i, value: i, timestamp: new Date() } )
}

Şimdi verilerin shard'lar arasında nasıl dağıldığını kontrol edebilirsiniz:

db.mycollection.getShardDistribution()

Bu komut, her bir shard'da kaç belge olduğunu ve veri boyutunu gösterir. Eğer veriler eşit şekilde dağılmadıysa, bu normaldir çünkü MongoDB'nin balancer'ı chunk'ları taşımak için biraz zamana ihtiyaç duyar. Balancer'ın durumu sh.getBalancerState() ile kontrol edilebilir.

Adım 3: Sorguları Test Etme
mongos üzerinden sorgular çalıştırarak verilerin doğru şekilde getirildiğinden emin olun:

db.mycollection.find({ username: "user500" })
db.mycollection.find({ value: { $gt: 500 } }).explain("executionStats")

explain() çıktısı, sorgunun hangi shard'lara gittiğini ve nasıl işlendiğini gösterir. İyi bir shard key ile yapılan sorguların çoğu, sadece ilgili shard'lara yönlendirilmelidir.

Sharding İpuçları ve En İyi Uygulamalar

Bir MongoDB shard kümesini kurmak sadece başlangıçtır. Optimum performans ve kararlılık için bazı en iyi uygulamaları takip etmek önemlidir.

1. Shard Key Seçimi: Kümenin performansı için en kritik faktördür.
* Kardinalite: Shard key'in benzersiz değer sayısı yüksek olmalıdır.
* Sorgu Dağılımı: Uygulamanızın çoğu sorgusu shard key'i içermelidir.
* Yazma Dağılımı: Shard key, yazma işlemlerini küme genelinde eşit olarak dağıtmalıdır (hotspot'ları önlemek için). Zaman serisi verileri için artan bir _id kullanmak yerine _id: "hashed" veya zaman damgası + başka bir alan kullanmak daha iyidir.
* Chunk Boyutu: Varsayılan chunk boyutu 64MB'dir. İş yükünüze göre bu boyutu ayarlamanız gerekebilir. Çok küçük chunk'lar meta veri yükünü artırırken, çok büyük chunk'lar balancer'ın etkinliğini azaltabilir.

2. Balancer Yönetimi: Balancer, chunk'ları shard'lar arasında otomatik olarak taşıyarak verinin eşit dağılımını sağlar.
* Yoğun saatlerde balancer'ı duraklatmak, performans düşüşlerini önleyebilir.
* Balancer'ın ne zaman çalıştığını ve ne kadar agresif olduğunu izleyin.

3. Kaynak Tahsisi: Her shard ve config server için yeterli RAM, CPU ve I/O kapasitesi sağlayın. Özellikle I/O performansı, veritabanı işlemleri için hayati öneme sahiptir. SSD'ler şiddetle tavsiye edilir.

4. Monitoring ve Alerting: Kümenin sağlığını, performansını ve kaynak kullanımını sürekli olarak izleyin. MongoDB Cloud Manager veya Prometheus/Grafana gibi araçlar kullanılabilir. Anormal durumlar için uyarı sistemleri kurun.

5. Güvenlik:
* Kimlik Doğrulama ve Yetkilendirme: Kullanıcı tabanlı kimlik doğrulama (SCRAM-SHA-1 veya X.509) ve rol tabanlı yetkilendirme kullanın.
* Ağ Güvenliği: Tüm MongoDB bileşenleri arasında güvenli iletişim sağlamak için SSL/TLS kullanın. Güvenlik duvarlarını doğru yapılandırarak sadece gerekli portlardan ve IP adreslerinden erişime izin verin.
* Kilit Dosyaları (Keyfiles): Replica set'ler ve sharded cluster'lar arasında dahili kimlik doğrulama için keyfile kullanın.

6. Yedekleme ve Kurtarma: Düzenli yedekleme stratejileri uygulayın. Replica set'ler, birincil sunucu başarısız olduğunda otomatik failover sağlasa da, veri kaybını önlemek için yedekleme kritik öneme sahiptir. Point-in-time recovery gibi gelişmiş yedekleme yöntemlerini değerlendirin.

7. Sürüm Yönetimi: MongoDB'nin güncel ve desteklenen bir sürümünü kullanmaya özen gösterin. Ubuntu 12.04'ün eski olması nedeniyle bu durum daha da önemlidir.

Ubuntu 12.04 Özel Notlar

Bu rehber, Ubuntu 12.04 üzerinde bir MongoDB shard kümesi oluşturmayı hedeflese de, bu işletim sisteminin eski olması nedeniyle bazı önemli noktalara dikkat çekmek gerekmektedir.

* Destek Sonu (End of Life - EOL): Ubuntu 12.04 (Precise Pangolin) LTS sürümü, Nisan 2017'de destek sonuna ulaşmıştır. Bu, artık güvenlik güncellemeleri veya hata düzeltmeleri almadığı anlamına gelir. Bu durum, sunucularınızı ciddi güvenlik risklerine maruz bırakır.
* Güvenlik Riskleri: Üretim ortamlarında EOL bir işletim sistemi kullanmak kesinlikle önerilmez. Bilinen güvenlik açıkları düzeltilmediği için sisteminiz saldırılara karşı savunmasız kalabilir.
* MongoDB Sürüm Uyumluluğu: Ubuntu 12.04 için en kararlı ve uyumlu MongoDB sürümleri genellikle 2.x veya 3.0/3.2 serisinin ilk sürümleridir. Daha yeni MongoDB sürümleri (örneğin 3.4 ve üzeri), daha modern çekirdek özelliklerine ve sistem kütüphanelerine ihtiyaç duyabilir ve bu da 12.04 üzerinde kurulumu zorlaştırabilir veya imkansız hale getirebilir. Bu rehberde 2.6 sürümünü hedeflememizin nedeni budur.
* Performans Optimizasyonları: Eski çekirdek ve sistem araçları, modern performans optimizasyonlarından (örneğin daha iyi I/O zamanlayıcıları, ağ yığını iyileştirmeleri) yoksun olabilir. Bu, kümenizin genel performansını sınırlayabilir.
* Mümkünse Yükseltme: Şiddetle tavsiye edilen yaklaşım, mümkün olan en kısa sürede daha yeni ve desteklenen bir Ubuntu sürümüne (örneğin Ubuntu 20.04 LTS veya 22.04 LTS) geçmektir. Bu, hem güvenlik hem de performans açısından önemli faydalar sağlayacaktır. Eğer bir yükseltme mümkün değilse, bu kümenin sadece test veya geliştirme ortamlarında kullanılması ve internete doğrudan açık olmaması gibi sıkı güvenlik önlemleri alınması gerekir.

Bu kısıtlamalara rağmen, yukarıdaki adımlar Ubuntu 12.04 üzerinde bir MongoDB shard kümesi kurmak için teknik olarak doğru yolu göstermektedir. Ancak, güvenlik ve sürdürülebilirlik açısından modern bir işletim sistemi kullanmanın önemi göz ardı edilmemelidir.

Sonuç

Bu makalede, Ubuntu 12.04 VPS'ler üzerinde bir MongoDB shard kümesinin nasıl kurulacağını adım adım detaylı bir şekilde inceledik. Sharding'in temel prensiplerinden, küme bileşenlerinin (config server'lar, shard'lar ve mongos router'lar) kurulumuna, yapılandırmasına ve test edilmesine kadar tüm süreçleri ele aldık. Ayrıca, başarılı bir shard kümesi yönetimi için kritik ipuçları ve en iyi uygulamalar hakkında bilgi verdik.

MongoDB sharding, büyük veri kümeleri ve yüksek trafik yükleri karşısında yatay ölçeklenebilirlik, yüksek performans ve erişilebilirlik sağlayan güçlü bir özelliktir. Doğru bir planlama ve uygulama ile, uygulamanızın gelecekteki büyüme ihtiyaçlarını karşılayabilecek sağlam bir veritabanı altyapısı oluşturabilirsiniz.

Ancak, Ubuntu 12.04 gibi eski ve desteklenmeyen bir işletim sistemi kullanmanın getirdiği güvenlik riskleri ve uyumluluk sınırlamaları göz ardı edilmemelidir. Üretim ortamlarında her zaman güncel ve desteklenen yazılım sürümlerini kullanmak, sistemlerinizin güvenliğini ve istikrarını sağlamanın anahtarıdır. Bu rehber, eski bir ortamda çalışmak zorunda kalanlar için bir yol haritası sunarken, modern bir yaklaşımla daha güvenli ve verimli çözümlere geçişin önemini de vurgulamaktadır. Sharding dünyasına adım atarken, sürekli öğrenmeye ve en iyi uygulamaları takip etmeye devam etmek, MongoDB'nin sunduğu tüm potansiyeli kullanmanızı sağlayacaktır.