> This is part 1 of 5 of the full documentation (pages 1–100 of 494).
> The content is paginated: fetch every part to see all of it.
> Next part: https://note.onurbolatoglu.com/llms-full.txt/1
> Page index: https://note.onurbolatoglu.com/llms.txt

# Başlarken

Selamlar 👋\
\
Bu sayfada sizlerle eğitimlerden ve araştırmalarımdan edindiğim notları ve faydalı kaynakları paylaşacağım.

* ☕[ Buy Me a Coffee](https://buymeacoffee.com/onurbolatogluu)

📚 **Diğer Platformlarım**:

* ✍️ [Medium - Onur BOLATOĞLU](https://medium.com/@onurbolatoglu)
* 🐙 [GitHub - Onurbolatogluu](https://github.com/Onurbolatogluu)


# Why Linux? | Linux Basics #1

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FGwCjesbuRPyqcmjyVpwn%2FBasic-Linux-Commands.webp?alt=media&amp;token=af2e9a48-dde3-4ac9-9a93-88e1fabf5dd1" alt=""><figcaption></figcaption></figure>

Linux, DevOps dünyasında Docker, Kubernetes, Ansible gibi temel araçlarla uyumluluğu, esnekliği, performansı ve geniş topluluk desteği nedeniyle büyük bir öneme sahiptir. Bu nedenle, DevOps süreçlerinde Linux kullanımı yaygındır.

* **Docker**: Docker, Linux çekirdeğinin özelliklerini (cgroups, namespaces) kullanarak konteyner oluşturur. Bu nedenle, Docker ilk olarak Linux üzerinde geliştirilmiştir ve en iyi performansı burada sağlar.
  * **2013**: Docker'ın ilk sürümü tanıtıldı. O dönemde konteyner teknolojisi yeni bir kavramdı ve Docker, bu teknolojiyi yaygınlaştırarak devrim yarattı.
  * **2016**: Docker for Windows piyasaya sürüldü. Docker for Windows, Windows üzerinde Docker konteynerlerini çalıştırabilmek için bir sanal makine (VM) kullanır. Bu sanal makine genellikle Hyper-V veya WSL 2 (Windows Subsystem for Linux 2) üzerinde çalışır. Bu da Docker'ın altında yine bir Linux çekirdeği kullanıldığı anlamına gelir.

* **Kubernetes**: Kubernetes'in control plane bileşenleri (API server, scheduler, controller manager) Linux üzerinde çalışır.

  * **Windows desteği**: Kubernetes, worker node'larda Windows desteği sunar. Ancak, control plane bileşenleri Linux üzerinde çalışır. Bu, Kubernetes cluster'ının tam anlamıyla çalışabilmesi için bir Linux tabanlı altyapıya ihtiyaç duyduğunu gösterir.

* **Ansible**, Windows host'larını yönetebilir ancak Ansible kendisi bir Linux veya WSL (Windows Subsystem for Linux) üzerinde çalışmalıdır. Bu, Ansible'ın performans ve uyumluluk açısından en iyi Linux üzerinde çalıştığını gösterir.

* **Açık Kaynak ve Topluluk Desteği,** Linux açık kaynaklı bir işletim sistemi olduğundan geniş bir topluluk ve sürekli gelişim desteğine sahiptir. Bu, sürekli güncellenen ve geliştirilen güvenilir bir altyapı sağlar. Açık kaynaklı olması, kullanıcıların ve şirketlerin ihtiyaçlarına göre özelleştirmeler yapabilmesine imkan tanır.

* **Performans ve Güvenilirlik**: Linux yüksek performanslı ve güvenilir bir işletim sistemidir. Sunucu ortamlarında yaygın olarak tercih edilmesinin sebeplerinden biri de budur. Linux'un sağlam mimarisi ve uzun süreli destek sunan sürümleri, onu güvenilir bir seçenek haline getirir.

* **Esneklik ve Özelleştirilebilirlik**: Linux son derece esnek ve özelleştirilebilir bir yapıya sahiptir. Çeşitli dağıtımlar (distributions) ve minimal kurulum seçenekleri ile kullanıcılar, ihtiyaçlarına uygun bir Linux ortamı oluşturabilirler. Bu esneklik, DevOps araçlarının farklı ortamlarda verimli bir şekilde çalışmasını sağlar.

* **CLI (Command Line Interface)**: Linux'un güçlü bir komut satırı arayüzü (CLI) vardır. CLI, sistem yöneticileri ve DevOps mühendisleri için geniş kontrol ve otomasyon imkanları sunar.&#x20;

### Shell Types:

Shell, kullanıcıların işletim sistemi ile etkileşime geçmesini sağlayan bir programdır. Shell, kullanıcının komutlarını alır, bu komutları çalıştırır ve sonuçları kullanıcıya geri döner. Shell, bir komut satırı arayüzü (CLI) sunarak kullanıcıların metin tabanlı komutlar aracılığıyla sistemle etkileşimde bulunmasını sağlar.

#### Linux Shell Türleri

1. **Bourne Shell (Sh Shell)**:
   * **Yer**: /bin/sh
   * **Özellikler**: Bourne Shell, UNIX sistemlerinde kullanılan ilk shell'lerden biridir. Adını geliştiricisi Stephen Bourne'dan alır. Basit ve hızlıdır, özellikle script yazımı için kullanılır.
   * **Kullanım Alanı**: Tarihsel olarak birçok UNIX ve Linux sisteminde varsayılan shell olarak kullanılmıştır.
2. **C Shell (csh veya tcsh)**:
   * **Yer**: /bin/csh veya /bin/tcsh
   * **Özellikler**: C Shell, C programlama diline benzer bir söz dizimi sunar. Tcsh, csh'nin geliştirilmiş bir versiyonudur ve ek özellikler içerir (komut tamamlama gibi).
   * **Kullanım Alanı**: Kullanıcı dostu komut satırı deneyimi sunar ve genellikle programcılar tarafından tercih edilir.
3. **Z Shell (zsh)**:
   * **Yer**: /bin/zsh
   * **Özellikler**: Z Shell, zengin özelliklere sahip bir shell'dir. Bourne Shell ve diğer shell'lerden birçok özelliği bir araya getirir. Gelişmiş komut tamamlama, işlevsellik ve özelleştirme imkanları sunar.
   * **Kullanım Alanı**: Güçlü özellikleri ve geniş özelleştirme imkanları nedeniyle birçok ileri düzey kullanıcı ve sistem yöneticisi tarafından tercih edilir.
4. **Bourne Again Shell (bash)**:
   * **Yer**: /bin/bash
   * **Özellikler**: Bash, GNU Projesi tarafından geliştirilen bir shell'dir ve Bourne Shell'in birçok geliştirilmiş özelliğini içerir. Kapsamlı komut seti ve script yazımı için gelişmiş yetenekler sunar.
   * **Kullanım Alanı**: Linux dağıtımlarında en yaygın kullanılan shell'dir. Hem günlük kullanım hem de script yazımı için idealdir.

#### Neden Farklı Shell Türleri Vardır?

Her shell, farklı kullanıcı ihtiyaçlarını ve kullanım senaryolarını hedefler. Bazıları daha basit ve hızlı iken, bazıları daha gelişmiş özellikler ve özelleştirme imkanları sunar. Kullanıcılar ve sistem yöneticileri, ihtiyaçlarına ve tercihlerine göre uygun shell'i seçebilirler.

{% hint style="info" %}
Terminal, CLI sağlar; shell ise bu CLI'da çalıştırdığınız programdır.
{% endhint %}

### Basic Commands:

```bash
# Ekrana "Hi" yazdırır
echo Hi
# Çıktı: Hi

# Geçerli dizindeki dosya ve klasörleri listeler
ls
# Çıktı: File.txt my_dir1 file2.conf
# (Geçerli dizinde bulunan dosyalar ve klasörler listelenir)

# "my_dir1" adlı dizine geçiş yapar
cd my_dir1

# Geçerli çalışma dizinini görüntüler
pwd
# Çıktı: /home/my_dir1
# (Mevcut dizinin tam yolunu gösterir)

# "new_directory" adında yeni bir dizin oluşturur
mkdir new_directory

# "new_directory" adlı dizine geçiş yapar, "www" adında bir dizin oluşturur ve geçerli çalışma dizinini görüntüler
cd new_directory; mkdir www; pwd
# Çıktı: /home/my_dir1/new_directory
# (Önce "new_directory" dizinine geçilir, ardından bu dizin içinde "www" dizini oluşturulur ve son olarak geçerli dizinin tam yolu görüntülenir)

# ; (noktalı virgül) işareti ile birden fazla komut aynı satırda ardışık olarak çalıştırılır
# Örneğin: cd new_directory; mkdir www; pwd
# Bu komut satırı, önce "new_directory" dizinine geçiş yapar, ardından bu dizin içinde "www" dizinini oluşturur ve son olarak geçerli dizinin tam yolunu gösterir.

# ; işareti, birden fazla komutun ardışık olarak çalıştırılmasını sağlar. Her bir komut bağımsız olarak çalıştırılır. 
# Örneğin, cd new_directory komutu hata verirse, mkdir www ve pwd komutları yine de çalıştırılır.
# Yani ; işareti, önceki komutun başarılı olup olmamasına bakmaksızın sonraki komutları çalıştırır.

```

#### Directory Commands:

```shell
# Tek tek dizin oluşturma
mkdir /tmp/asia
# /tmp dizininde "asia" adında bir dizin oluşturur.

mkdir /tmp/asia/india
# /tmp/asia dizininde "india" adında bir dizin oluşturur.

mkdir /tmp/asia/india/bangalore
# /tmp/asia/india dizininde "bangalore" adında bir dizin oluşturur.

# -p bayrağı ile hiyerarşik dizin oluşturma
mkdir -p /tmp/asia/india/bangalore
# Yukarıdaki tüm dizinleri tek bir komutla oluşturur. Eğer dizinler zaten varsa, hata vermez ve mevcut olanları kullanır.

# Dizin ve içeriğini silme
rm -r /tmp/my_dir1
# /tmp/my_dir1 dizinini ve içindeki tüm dosya ve alt dizinleri siler.
# -r bayrağı "recursive" anlamına gelir ve dizin içeriğini de siler.

# Dizin ve içeriğini kopyalama
cp -r my_dir1 /tmp/my_dir1
# my_dir1 dizinini ve içindeki tüm dosya ve alt dizinleri /tmp dizinine kopyalar.
# -r bayrağı "recursive" anlamına gelir ve dizin içeriğinin tamamını kopyalar.
```

#### File Commands:

```bash
# Boş bir dosya oluşturur (içerik eklemez)
touch new_file.txt
# new_file.txt adlı boş bir dosya oluşturur.

# Dosyaya içerik ekler
cat > new_file.txt
# Bu komut, new_file.txt dosyasına içerik eklemenizi sağlar.
# Yazmaya başladıktan sonra, dosya içeriğini bitirmek için Ctrl+D tuş kombinasyonunu kullanın.
# Örnek İçerik: "This is some sample contents" yazın ve Ctrl+D ile bitirin.

# Dosya içeriğini görüntüler
cat new_file.txt
# new_file.txt dosyasının içeriğini ekrana yazdırır.
# Çıktı: This is some sample contents

# Dosyayı kopyalar
cp new_file.txt copy_file.txt
# new_file.txt dosyasını copy_file.txt adıyla kopyalar.
# Eğer copy_file.txt adında bir dosya zaten varsa, cp komutu new_file.txt dosyasının içeriğini copy_file.txt dosyasının üzerine yazar. Yani, copy_file.txt dosyasının mevcut içeriği silinir ve new_file.txt dosyasının içeriği ile değiştirilir.

# Dosyayı yeniden adlandırır
mv new_file.txt sample_file.txt
# Eğer 'sample_file.txt' mevcut değilse, 'new_file.txt' dosyasını 'sample_file.txt' olarak yeniden adlandırır. 
# Eğer sample_file.txt mevcut bir dosya ise, mv komutu new_file.txt dosyasını sample_file.txt dosyasının üzerine yazar ve sample_file.txt dosyasının önceki içeriği silinir.

# Dosyayı bir dizine taşır
mv new_file.txt /some_directory/
# Eğer '/some_directory/' mevcut bir dizinse, 'new_file.txt' dosyasını bu dizine taşır.
# Eğer belirtilen dizin mevcut değilse, mv komutu hata verir ve dosyayı taşımayı gerçekleştiremez.

# Dosyayı siler
rm new_file.txt
# new_file.txt dosyasını siler.

```


# Vi Editor | Linux Basics #2

VI/Vim editörü, Unix ve Linux sistemlerinde yaygın olarak kullanılan, güçlü ve esnek bir metin editörüdür. VI, iki ana modda çalışır: Komut Modu (Command Mode) ve Ekleme Modu (Insert Mode).

#### VI Editör Modları:

* **Komut Modu (Command Mode):** Bu modda, kullanıcı komutlar vererek metin üzerinde işlem yapabilir.
* **Ekleme Modu (Insert Mode):** Bu modda, kullanıcı doğrudan metin ekleyebilir.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FAv8gvZvGhMerzwHix60F%2Fvimodes.jpg?alt=media&amp;token=feb4962a-bbf7-4728-a4c0-b1558cc58e30" alt=""><figcaption></figcaption></figure>

<pre class="language-vim"><code class="lang-vim"><strong>### Temel Komutlar:
</strong>
1. Hareket Etme (Move Around):
   - h: Sol
   - j: Aşağı
   - k: Yukarı
   - l: Sağ

2. Silme (Delete):
   - x: İmleç altındaki karakteri siler.
   - dd: Bulunduğunuz satırı siler.
   - :5,10d: 5 ile 10 arasındaki satırları siler.

3. Kopyalama ve Yapıştırma (Copy &#x26; Paste):
   - yy: Satırı kopyalar.
   - p: Kopyalanmış içeriği yapıştırır.

4. Kaydırma (Scroll Up/Down):
   - CTRL + u: Yukarı kaydırır.
   - CTRL + d: Aşağı kaydırır.

5. Komutlar (Commands):
   - :: Komut girişi.
   - :w: Dosyayı kaydeder.
   - :q: VI editörden çıkar.
   - :wq: Dosyayı kaydedip çıkar.
   - :q!: Kaydetmeden çıkar.

6. Bulma (Find):
   - /kelime: Metinde kelime arar.
   - n: Bir sonraki eşleşmeye gider.

### Ek Komutlar:

1. Geri Alma ve Yeniden Yapma:
   - u: Son yapılan işlemi geri alır (undo).
   - CTRL + r: Geri alınan işlemi yeniden yapar (redo).

2. Metin Ekleme ve Değiştirme:
   - i: İmleçten önce metin ekler (insert).
   - a: İmleçten sonra metin ekler (append).
   - o: İmleç altına yeni satır açar ve ekleme moduna geçer.
   - c: Metni değiştirir (change).

3. Satırların Başına ve Sonuna Gitme:
   - 0: Satırın başına gider.
   - $: Satırın sonuna gider.

4. Kelime Kelime Hareket:
   - w: Sonraki kelimenin başına gider.
   - b: Önceki kelimenin başına gider.
   - e: Kelimenin sonuna gider.

5. Satıra Gitme:
   - G: Dosyanın son satırına gider.
   - gg: Dosyanın ilk satırına gider.
   - :n: n. satıra gider.

</code></pre>


# Basics Commands | Linux Basics #3

```bash
# Hangi kullanıcı ile oturum açıldığını gösterir
whoami
# Çıktı: matthew
# Bu örnekte, matthew kullanıcısı ile oturum açıldığını gösterir.

# Kullanıcının UID, GID ve grup üyeliklerini gösterir
id
# Çıktı: uid=1001(matthew) gid=1001(matthew) groups=1001(matthew)
# Bu örnekte, matthew kullanıcısının UID'si 1001, GID'si 1001 ve matthew grubunun bir üyesi olduğunu gösterir.

# Belirtilen kullanıcıya geçiş yapar
su aparna
# Şifreyi girdikten sonra kullanıcı aparna'ya geçer.
# Örnek: aparna kullanıcısına geçiş yapılır ve aparna kullanıcısının şifresi girilmelidir.

# Belirtilen kullanıcı adı ve sunucu adresi ile uzak bir sunucuya SSH üzerinden bağlanmayı sağlar
ssh aparna@192.168.1.2
# 192.168.1.2 IP adresindeki sunucuya aparna kullanıcısı olarak bağlanır.
# Örnek: aparna kullanıcısı olarak 192.168.1.2 IP adresindeki sunucuya bağlanılır. SSH bağlantısı yapıldıktan sonra aparna kullanıcısının şifresi girilmelidir.

```

Bir kullanıcının `sudo` komutunu kullanabilmesi için `sudo` grubuna dahil olması gerekmektedir. Kullanıcının `sudo` yetkilerine sahip olması, `sudo` komutunu kullanarak geçici olarak süper kullanıcı yetkilerine sahip olmasını sağlar. Bu yetkiler, `sudo` grubuna üyelik veya `/etc/sudoers` dosyasındaki uygun yetkilendirme ile verilebilir. Ancak, bu durum dağıtıma ve yapılandırmaya göre değişebilir. Genellikle Ubuntu gibi dağıtımlarda, `sudo` grubuna üye kullanıcılar `sudo` komutunu kullanabilir. Diğer bazı dağıtımlarda ise bu grup `wheel` olabilir.

```bash
# Normal kullanıcı olarak /root dizinindeki dosyaları listelemeye çalışır
ls /root
# Çıktı: 
# ls: cannot open directory /root: Permission denied
# Açıklama: Normal bir kullanıcı olarak /root dizinine erişmeye çalışırken "Permission denied" hatası alırsınız. Bu, /root dizininin yalnızca root veya yetkili kullanıcılar tarafından erişilebilir olduğunu gösterir.

# Süper kullanıcı yetkileri ile /root dizinindeki dosyaları listelemeye çalışır
sudo ls /root
# Çıktı:
# anaconda-ks.cfg  initial-setup-ks.cfg
# Açıklama: `sudo` komutunu kullanarak geçici olarak süper kullanıcı yetkilerine sahip olursunuz ve /root dizinindeki dosyaları listeleyebilirsiniz. `sudo` komutu, belirli işlemleri root yetkileri ile gerçekleştirmek için kullanılır ve genellikle şifre gerektirir.
```

```bash
# Dosya İndirme Komutları

# curl komutu ile dosya indirme
curl http://www.some-site.com/some-file.txt -O
# Açıklama: Belirtilen URL'deki dosyayı indirir ve dosyayı aynı isimle (some-file.txt) kaydeder.

# wget komutu ile dosya indirme
wget http://www.some-site.com/some-file.txt -O some-file.txt
# Açıklama: Belirtilen URL'deki dosyayı indirir ve 'some-file.txt' adıyla kaydeder. '-O' seçeneği, indirilen dosyanın adını belirler.

# İşletim Sistemi Sürümünü Kontrol Etme

# /etc dizininde ismi 'release' kelimesini içeren dosyaları listelemek
ls /etc/*release*
# Açıklama: /etc dizininde ismi 'release' kelimesini içeren tüm dosyaları listelemek için kullanılır.
# Örnek Çıktı:
# /etc/centos-release /etc/os-release /etc/system-release
# /etc/centos-release-upstream /etc/redhat-release /etc/system-release-cpe

# /etc dizininde ismi 'release' kelimesini içeren dosyaların içeriğini görüntülemek
cat /etc/*release*
# Açıklama: /etc dizininde ismi 'release' kelimesini içeren tüm dosyaların içeriğini görüntülemek için kullanılır.
# Bu komut, sistemin işletim sistemi sürümünü ve diğer önemli bilgilerini kontrol etmek için kullanılır.
# Örnek Çıktı:
# CentOS Linux release 7.7.1908 (Core)
# Derived from Red Hat Enterprise Linux 7.7 (Source)
# NAME="CentOS Linux"
# VERSION="7 (Core)"
# ID="centos"
# ID_LIKE="rhel fedora"
# VERSION_ID="7"
# PRETTY_NAME="CentOS Linux 7 (Core)"
# ANSI_COLOR="0;31"
# CPE_NAME="cpe:/o:centos:centos:7"
# HOME_URL="https://www.centos.org/"
# BUG_REPORT_URL="https://bugs.centos.org/"

```


# Package Managers | Linux Basics #4

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FNA6zP11P0Ssev7b5AEbd%2F1_WonJ9vjMYFEE0o_-ucZylg.png?alt=media&amp;token=edbeaa67-378a-4951-855d-8d624f380bff" alt=""><figcaption></figcaption></figure>

Paket yöneticileri, Linux sistemlerinde uygulamaların kurulumu, güncellenmesi, kaldırılması ve yönetimi işlemlerini otomatikleştirir. Paket yöneticileri, belirli uygulama paketlerini içeren depolardan (repositories) uygulamaları indirir ve kurar. Her uygulama paketi, bağımlılık bilgilerini ve sistemde nereye yerleştirileceğini içeren meta verilerle birlikte gelir. Paket yöneticisi, uygulamanın bağımlılıklarını kontrol eder ve gerekli diğer paketleri de indirip kurar. Kurulum işlemi sırasında, paket yöneticisi dosyaları doğru yerlere kopyalar, gerekli izinleri ayarlar ve bağımlılıkları çözer.

Güncellemeler sırasında, paket yöneticisi kurulu paketlerin yeni sürümlerini kontrol eder ve indirir. Bu işlem, depo listelerinden güncel paket bilgilerini alarak sistemdeki mevcut paketlerle karşılaştırmak suretiyle yapılır. Paket kaldırma işlemlerinde ise paket yöneticisi, ilgili dosyaları ve bağımlılıkları sistemden kaldırarak temiz bir ortam sağlar.

Örneğin, Debian tabanlı sistemlerde APT (Advanced Package Tool) kullanılır. Kullanıcı `sudo apt update` komutunu çalıştırarak paket listelerini günceller, `sudo apt install package_name` komutuyla da belirli bir uygulama paketini kurar. Benzer şekilde, Red Hat tabanlı sistemlerde YUM veya DNF kullanılır; kullanıcı `sudo yum install package_name` veya `sudo dnf install package_name` komutlarıyla paketleri kurabilir.

### APT (Advanced Package Tool):

**Dağıtımlar**: Debian, Ubuntu ve türevleri

```bash
# Paket listelerini güncelle
sudo apt update

# Tüm sistem paketlerini güncelle
sudo apt upgrade

# curl paketini kur
sudo apt install curl

# curl paketini kaldır
sudo apt remove curl

# Uzak depolarda paket aramak için
apt search curl

# curl paketini güncelle
sudo apt install --only-upgrade curl
```

### RPM (Red Hat Package Manager):

**Dağıtımlar**: Red Hat, Fedora, CentOS

```bash
# Bir RPM paketini kurmak için
sudo rpm -i curl-7.68.0-1.el7.x86_64.rpm
# Açıklama: Belirtilen RPM paketini kurar. -i (install) seçeneği, paketi kurmak için kullanılır.

# Bir RPM paketini kaldırmak için
sudo rpm -e curl
# Açıklama: Belirtilen paketi kaldırır. -e (erase) seçeneği, paketi kaldırmak için kullanılır.

# Bir RPM paketini yükseltmek için
sudo rpm -U curl-7.68.0-2.el7.x86_64.rpm
# Açıklama: Mevcut bir paketi günceller veya yeni bir paketi kurar. -U (upgrade) seçeneği, paketi güncellemek veya kurmak için kullanılır.

# Kurulu paketleri listelemek için
rpm -qa
# Açıklama: Sistemde kurulu olan tüm RPM paketlerinin listesini gösterir. -qa (query all) seçeneği, tüm paketleri sorgulamak için kullanılır.

# Paket aramak için
rpm -qa | grep curl
# Açıklama: Sistemde kurulu olan curl paketini arar ve listeler.

rpm -q telnet
# Açıklama: Telnet paketinin sistemde kurulu olup olmadığını sorgular. -q (query) seçeneği, paketin kurulu olup olmadığını kontrol eder.

```

### YUM (Yellowdog Updater, Modified):

**Dağıtımlar**: CentOS, RHEL (Red Hat Enterprise Linux), Fedora (eski versiyonlar)

```bash
# Paket listelerini güncelle
sudo yum update

# Tüm sistem paketlerini güncelle
sudo yum upgrade

# curl paketini kur
sudo yum install curl

# curl paketini kaldır
sudo yum remove curl

# Uzak depolarda paket aramak için
yum search curl

# Kurulu ve mevcut ansible paketlerini listeler. Kurulu olan sürümleri ve mevcut depolarda bulunan sürümleri gösterir.
# --showduplicates parametresi, YUM kullanırken belirli bir paketin mevcut tüm sürümlerini gösterir. Bu, özellikle bir paketin eski bir sürümünü kurmak veya hangi sürümlerin mevcut olduğunu görmek istediğinizde kolaylık sağlar.
yum --showduplicates list ansible

# curl paketini güncelle
sudo yum update curl
```

{% hint style="info" %}
`yum search` komutu, uzak depolarda belirli bir anahtar kelimeyi arar ve bu kelimeyi paket isimlerinde veya açıklamalarında içeren tüm paketleri listeler. Bu, özellikle bir paket hakkında genel bilgi sahibi olmak veya belirli bir işlevselliğe sahip paketleri keşfetmek istediğinizde kullanışlıdır. Örneğin, "ansible" kelimesini aradığınızda, ansible ile ilgili tüm paketleri ve açıklamalarını görebilirsiniz. Öte yandan, `yum list` komutu, sistemde kurulu olan ve uzak depolarda mevcut bulunan paketlerin listesini sağlar. Bu komut, belirli bir paketin kurulu olup olmadığını veya hangi sürümlerinin mevcut olduğunu görmek için kullanılır. Örneğin, "ansible" paketinin sistemde kurulu olup olmadığını ve hangi sürümlerinin mevcut olduğunu kontrol etmek için `yum list ansible` komutunu kullanabilirsiniz. Bu iki komut arasındaki temel fark, `yum search` komutunun geniş kapsamlı bir arama yaparak paketlerin isimlerini ve açıklamalarını hedef alması, `yum list` komutunun ise kurulu ve mevcut paketleri daha doğrudan listelemesidir.\
\
\
**YUM, arka planda RPM paketlerini kullanır. Yani, YUM ile bir paket kurduğunuzda, aslında RPM paketlerini indirir ve kurar.**
{% endhint %}

```bash
# YUM Komutları

# 1. Kullanılabilir YUM depolarının listesini görüntüleme
yum repolist
# Açıklama: Sistemde etkin olan ve kullanılabilir YUM depolarının listesini gösterir.
# Örnek Çıktı:
# repo id                       repo name                                       status
# base/7/x86_64                 CentOS-7 - Base                                  10097
# extras/7/x86_64               CentOS-7 - Extras                                 341
# mongodb-org-4.2/7/x86_64      MongoDB Repository                                 25
# mysql-connectors-community    MySQL Connectors Community                       141
# mysql-tools-community         MySQL Tools Community                            105
# mysql80-community             MySQL 8.0 Community Server                       161
# updates/7/x86_64              CentOS-7 - Updates                               1787

# 2. YUM repository dosyalarının bulunduğu dizini listeleme
ls /etc/yum.repos.d/
# Açıklama: YUM repository konfigürasyon dosyalarının bulunduğu dizini listeler.
# Örnek Çıktı:
# CentOS-Base.repo      CentOS-Media.repo      mysql-community.repo
# CentOS-CR.repo        CentOS-Sources.repo    mysql-community-source.repo
# CentOS-Debuginfo.repo CentOS-Vault.repo      mongodb-org-4.2.repo
# CentOS-fasttrack.repo

# 3. Belirli bir repository konfigürasyon dosyasının içeriğini görüntüleme
cat /etc/yum.repos.d/CentOS-Base.repo
# Açıklama: Belirtilen repository konfigürasyon dosyasının içeriğini görüntüler.
# Örnek Çıktı:
# [extras]
# name=CentOS-$releasever - Extras
# baseurl=http://mirror.centos.org/centos/$releasever/extras/$basearch/
# ...

# APT Komutları

# 1. Kullanılabilir APT depolarının listesini görüntüleme
sudo apt update
# Açıklama: Sistemde tanımlı olan APT depolarındaki paket listelerini günceller ve mevcut depoları gösterir.
# Not: Bu komut, hem depoları günceller hem de güncellenmiş depo listesini gösterir.

# 2. APT repository dosyalarının bulunduğu dizini listeleme
ls /etc/apt/sources.list.d/
# Açıklama: APT repository konfigürasyon dosyalarının bulunduğu dizini listeler.
# Örnek Çıktı:
# official-package-repositories.list
# ...

# 3. Belirli bir repository konfigürasyon dosyasının içeriğini görüntüleme
cat /etc/apt/sources.list
# Açıklama: Ana APT repository konfigürasyon dosyasının içeriğini görüntüler.
# Örnek Çıktı:
# deb http://archive.ubuntu.com/ubuntu focal main restricted
# deb http://archive.ubuntu.com/ubuntu focal-updates main restricted
# deb http://archive.ubuntu.com/ubuntu focal universe
# ...

```


# Services | Linux Basics #5

Linux Services, sistemin kritik işlevlerini yerine getiren arka plan süreçleridir. `systemd` kullanılarak bu servisler kolayca yönetilebilir. Servislerin başlatılması, durdurulması, yeniden başlatılması ve sistem başlatıldığında otomatik olarak çalışacak şekilde ayarlanması gibi işlemler yapılabilir.

```bash
# HTTPD hizmetini başlatmak için kullanılır. Bu iki komut aynı işi yapar, 
# ancak systemctl daha modern ve tercih edilen yöntemdir.
service httpd start
systemctl start httpd

# HTTPD hizmetini durdurmak için kullanılır.
systemctl stop httpd

# HTTPD hizmetinin durumunu kontrol etmek için kullanılır. 
# Hizmetin çalışıp çalışmadığını ve varsa hata mesajlarını gösterir.
systemctl status httpd

# HTTPD hizmetini sistem başlatıldığında otomatik olarak çalışacak şekilde ayarlamak için kullanılır.
systemctl enable httpd

# HTTPD hizmetini sistem başlatıldığında otomatik olarak çalışmayacak şekilde ayarlamak için kullanılır.
systemctl disable httpd
```

Linux sistemlerinde servisler, eskiden init scripts adı verilen scriptler ile yönetilirdi. Bu scriptler, her servisi başlatmak, durdurmak ve durumunu kontrol etmek için kullanılırdı. Init scripts basit ve shell script olarak yazılırdı, bu da yönetimi kolaylaştırırdı. Ancak, bu yöntem servisleri sıralı olarak başlattığı için sistemin açılış süresi uzar ve servisler arası bağımlılıkları ve hataları yönetmek zor olurdu.

Öte yandan, systemd modern Linux dağıtımları için tasarlanmış bir servis yöneticisidir. Servisleri bağımlılıklarına göre paralel olarak başlatabilir, bu da sistemin daha hızlı açılmasını sağlar. Ayrıca, systemd bağımlılıkları daha iyi yönetir ve Servislerin daha kararlı çalışmasını sağlar. Yapılandırma dosyaları INI formatındadır. Systemd sadece hizmet yönetimiyle kalmaz, aynı zamanda log yönetimi, cihaz yönetimi gibi birçok ek işlev sunar.&#x20;

Sonuç olarak, init scripts basit ve geleneksel bir yöntemken, systemd modern sistemler için daha uygun, hızlı çözümdür. Bu yüzden çoğu modern Linux dağıtımı systemd'yi kullanmaktadır.

#### Python Flask uygulamamızı systemd servisi haline getirelim;

* &#x20;Örneğin, `app.py` adında basit bir Flask uygulamanız olduğunu varsayalım.

```python
# app.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello, World!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

```

* Flask'ı sisteme kurulu hale getirelim.

```bash
pip install flask
```

* `/etc/systemd/system/` dizininde yeni bir servis dosyası oluşturun. Örneğin, `flaskapp.service` adında bir dosya oluşturacağız.

```bash
sudo vi /etc/systemd/system/flaskapp.service
```

* Aşağıdaki örnek içeriği servis dosyasına yapıştırın. Bu içerik, Flask uygulamanızı doğrudan Python kullanarak systemd hizmeti olarak çalıştıracaktır.

{% code title="flaskapp.service" %}

```ini
[Unit]
Description=A simple Flask web application
After=network.target

[Service]
User=your_user
WorkingDirectory=/path/to/your/app
ExecStart=/usr/bin/python3 /path/to/your/app/app.py

[Install]
WantedBy=multi-user.target

```

{% endcode %}

* `User=your_user`: Buraya servisi çalıştıracak kullanıcının adını yazın.
* `WorkingDirectory=/path/to/your/app`: Buraya Flask uygulamanızın bulunduğu dizinin yolunu yazın.
* `ExecStart=/usr/bin/python3 /path/to/your/app/app.py`: Bu komut, Flask uygulamanızı Python kullanarak çalıştırır.

{% hint style="info" %}
"your\_user", Flask uygulamanızı çalıştırmak için kullanılacak kullanıcı adıdır. Bu, sisteminizde mevcut olan bir kullanıcı adı olmalıdır. Genellikle, bu kullanıcı uygulamanın çalıştırıldığı dizin ve dosyalara erişim iznine sahip bir kullanıcı olur.
{% endhint %}

* Servisi etkinleştirin ve başlatın.

```bash
# systemd'yi yeniden yükleyin
sudo systemctl daemon-reload

# Servisi etkinleştirin
sudo systemctl enable flaskapp

# Servisi başlatın
sudo systemctl start flaskapp

# Servisin durumunu kontrol edin
sudo systemctl status flaskapp

```

Bu adımları izleyerek, Python Flask uygulamanızı systemd servisi olarak çalıştırabilirsiniz. Bu yöntemle Flask uygulamanız doğrudan sistem genelinde kurulu Python ile başlatılır ve systemd tarafından yönetilir.

***

#### Sample Systemd File,

```ini
# /lib/systemd/system/docker.service
[Unit]
Description=Docker Application Container Engine
Documentation=https://docs.docker.com
BindsTo=containerd.service
After=network-online.target firewalld.service containerd.service
Wants=network-online.target
Requires=docker.socket

# Unit sekmesi, servisin ne olduğunu, hangi servislere bağlı olduğunu ve hangi servislerden sonra başlatılması gerektiğini belirtir.
# Description: Hizmetin kısa açıklaması.
# Documentation: Hizmetle ilgili dökümantasyonun bulunduğu URL.
# BindsTo: Bu servis containerd.service ile bağlantılıdır. containerd.service durduğunda bu servis de durur.
# After: Bu servis, network-online.target, firewalld.service ve containerd.service servislerinden sonra başlatılmalıdır.
# Wants: Bu servis network-online.target servisini de başlatmak ister.
# Requires: Bu servis, docker.socket servisine ihtiyaç duyar. Bu servis olmadan çalışmaz.

[Service]
Type=notify
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
ExecReload=/bin/kill -s HUP $MAINPID
Restart=always
StartLimitBurst=3
StartLimitInterval=60s
LimitNOFILE=infinity
LimitNPROC=infinity
LimitCORE=infinity

# Service sekmesi, servisin nasıl başlatılacağını, durdurulacağını ve yeniden yükleneceğini belirtir.
# Type: Servisin başlatılma tipini belirtir. "notify" servisin systemd'ye başlatılma durumunu bildireceği anlamına gelir.
# ExecStart: Servisin başlatılacağı komut. Burada Docker daemon (dockerd) başlatılıyor.
# ExecReload: Servisin yeniden yüklenmesi için kullanılacak komut. Burada ana süreç (MAINPID) yeniden başlatılıyor.
# Restart: Servisin her zaman yeniden başlatılmasını sağlar.
# StartLimitBurst: Belirli bir zaman aralığında kaç kez yeniden başlatılabileceğini belirtir.
# StartLimitInterval: Yeniden başlatma sınırının zaman aralığı.
# LimitNOFILE: Bu servis için açık dosya sayısı sınırı.
# LimitNPROC: Bu servis için işlem sayısı sınırı.
# LimitCORE: Bu servis için core dump dosyası sınırı.

[Install]
WantedBy=multi-user.target

# Install sekmesi, servisin hangi hedeflerle (target) birlikte başlatılacağını belirtir.
# WantedBy: Bu servis, multi-user.target ile birlikte başlatılacak. multi-user.target, sistemin çok kullanıcı modunda çalıştığı anlamına gelir.
```


# Networking Basics

### Switch ve Ağ İletişimi:

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FGhWCyIe3LGOLuWhnzYg3%2Fimage.png?alt=media&amp;token=bd3198d2-c8b2-479b-9cb0-46ddd69831ae" alt=""><figcaption></figcaption></figure>

Bir switch, ağdaki cihazların (bilgisayarlar, sunucular vb.) birbirleriyle iletişim kurmasına olanak sağlayan bir ağ cihazıdır. Switch, gelen veri paketlerini doğru hedefe yönlendirir, bu sayede cihazlar arasında iletişim sağlanır.

* **Cihaz A**:
  * IP adresi: 192.168.1.10
  * Ağ arayüzü: eth0
* **Cihaz B**:
  * IP adresi: 192.168.1.11
  * Ağ arayüzü: eth0
* **Switch**:
  * Her iki cihazı (A ve B) birbirine bağlayan bir ağ cihazı.

**Ağ Arayüzünün durumunu kontrol etmek,**

```bash
ip link
# Açıklama: Bu komut, ağ arayüzlerinin durumunu gösterir.
# Çıktı Örneği:
# eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
# Bu çıktı, eth0 arayüzünün aktif (UP) olduğunu gösterir.
```

**IP Adresi Ekleme (Cihaz A)**

```bash
ip addr add 192.168.1.10/24 dev eth0
# Açıklama: Bu komut, eth0 arayüzüne 192.168.1.10 IP adresini ekler.
```

**IP Adresi Ekleme (Cihaz B)**

```bash
ip addr add 192.168.1.11/24 dev eth0
# Açıklama: Bu komut, eth0 arayüzüne 192.168.1.11 IP adresini ekler.
```

**İki Cihaz Arasında Ping Testi**

```bash
ping 192.168.1.11
# Açıklama: Cihaz A'dan Cihaz B'ye ping atarak bağlantının aktif olup olmadığını test eder.
# Çıktı Örneği:
# Reply from 192.168.1.11: bytes=32 time=4ms TTL=117
# Bu çıktı, Cihaz A'dan Cihaz B'ye veri paketlerinin başarıyla ulaştığını gösterir.
```

**Özetle,**

1. `ip link` komutları ile her iki cihazda ağ arayüzlerinin aktif olduğunu kontrol ettik.
2. `ip addr add` komutları ile her iki cihaza IP adresleri atadık.
3. `ping` komutu ile Cihaz A'dan Cihaz B'ye veri göndererek bağlantıyı test ettik.

### Router Nedir?

Router, iki veya daha fazla farklı ağı (subnet) birbirine bağlayan bir ağ cihazıdır. Router, paketleri bir ağdan diğerine yönlendirir ve bu sayede ağlar arasında veri iletişimi sağlar.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FufOcFbWY5Zk3MyOBoyWA%2Fimage.png?alt=media&amp;token=bb416ba6-cfc3-434c-bb6d-bceee853d640" alt=""><figcaption></figcaption></figure>

**Ağ Yapısı:**

* **Ağ A (Subnet 1)**:
  * Cihaz A: IP 192.168.1.10
  * Cihaz B: IP 192.168.1.11
  * Router'ın Ağ A tarafındaki IP'si: 192.168.1.1

* **Ağ B (Subnet 2)**:
  * Cihaz C: IP 192.168.2.10
  * Cihaz D: IP 192.168.2.11
  * Router'ın Ağ B tarafındaki IP'si: 192.168.2.1

* Router, IP adreslerini kullanarak paketlerin hedefe ulaşmasını sağlar. IP paketlerinin hedef adresine bakarak uygun ağ arayüzüne yönlendirir.

* Farklı subnet'ler arasındaki bağlantıyı sağlar ve bu ağlar arasında veri iletimine olanak tanır.

* Router, kendisine gelen veri paketlerini hedef ağın IP adresine göre ilgili ağ arayüzüne iletir.

**Router'ın IP Adreslerini Atama:**

Ağ A tarafı (192.168.1.1)

```bash
ip addr add 192.168.1.1/24 dev eth0
```

Ağ B tarafı (192.168.2.1)

```bash
ip addr add 192.168.2.1/24 dev eth1
```

**Yönlendirme Tablolarını Yapılandırma:**

Cihaz A ve Cihaz B için Router'a Yönlendirme Ekleme

```bash
ip route add 192.168.2.0/24 via 192.168.1.1
```

Cihaz C ve Cihaz D için Router'a Yönlendirme Ekleme

```bash
ip route add 192.168.1.0/24 via 192.168.2.1
```

Bu yapılandırma ile, Ağ A'daki cihazlar (192.168.1.0/24) ve Ağ B'deki cihazlar (192.168.2.0/24) bir router aracılığıyla birbirleriyle iletişim kurabilirler. Router, bu iki ağ arasında veri paketlerini yönlendirir ve doğru hedefe ulaşmalarını sağlar. Bu sayede, iki farklı subnet'teki cihazlar arasında veri alışverişi yapılabilir.

### Gateway Nedir?

**Gateway**, bir ağdan, diğerine veri paketlerinin geçişini sağlayan ağ geçididir. İki farklı ağ arasındaki veri trafiğini yönetir.

### Default Gateway Nedir?

**Default Gateway**, bir cihazın hedefe ulaşamayan veri paketlerini yönlendirdiği varsayılan ağ geçididir. Başka bir deyişle, bir cihaz başka bir ağa veri göndermek istediğinde, IP yönlendirme tablosunda bir yol bulamazsa, veri paketlerini default gateway'e gönderir.&#x20;

**Cihaz A'da Default Gateway Ayarlama:**

```bash
ip route add default via 192.168.1.1
# Açıklama: Cihaz A için default gateway'i 192.168.1.1 olarak ayarlar.
```

**Cihaz B'de Default Gateway Ayarlama:**

```bash
ip route add default via 192.168.2.1
# Açıklama: Cihaz B için default gateway'i 192.168.2.1 olarak ayarlar.
```

* Cihaz A, 192.168.1.0/24 ağında olmayan bir hedefe veri göndermek istediğinde (örneğin, 192.168.2.10), bu veri paketi default gateway (192.168.1.1) üzerinden yönlendirilir.
* Router (192.168.1.1), bu paketi alır ve uygun arayüze (192.168.2.1) yönlendirir.
* Paket, sonunda 192.168.2.10 adresine ulaşır.

#### Routing Examples,

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FHO3IceVHpuuegeFwvcKq%2Fimage.png?alt=media&amp;token=8a3c5581-1eab-4c47-abf7-47a1df7ca801" alt=""><figcaption></figcaption></figure>

**Durum,**

* **Cihaz A**: IP 192.168.1.5
* **Cihaz B**:
  * **eth0**: 192.168.1.6
  * **eth1**: 192.168.2.6
* **Cihaz C**: IP 192.168.2.5

Cihaz A ve C farklı subnet'lerde bulunuyor ve Cihaz B bu iki subnet arasında bir router görevi görüyor.

**Sorun:**

* **Cihaz A'dan Cihaz C'ye Ping**: İlk denemede `Network is unreachable` hatası alınıyor.

```bash
ping 192.168.2.5
# Çıktı: Connect: Network is unreachable
```

**Çözüm:**

* Cihaz A'ya 192.168.2.0/24 ağına nasıl ulaşacağını söyleyen bir route ekliyoruz.

```bash
ip route add 192.168.2.0/24 via 192.168.1.6
```

Cihaz B'nin iki farklı subnet'i (192.168.1.0/24 ve 192.168.2.0/24) birbirine bağlaması ve paket yönlendirmesi için IP forwarding'in etkinleştirilmesi gerekmektedir. IP forwarding, bir cihazın iki farklı ağ arasındaki trafiği yönlendirmesini sağlar. Bu özellik etkinleştirildiğinde, cihaz bir router gibi davranır ve gelen paketleri uygun ağa iletir.

**Cihaz B'de, IP Forwarding Durumunu Kontrol Etme,**

```bash
cat /proc/sys/net/ipv4/ip_forward
# Çıktı: 0 (IP forwarding kapalı)
```

**Cihaz B'de, IP Forwarding Etkinleştirme,**

```bash
echo 1 > /proc/sys/net/ipv4/ip_forward
# IP forwarding etkinleştirilir
```

**Cihaz B'de, Kalıcı Olarak IP Forwarding Ayarlama,**

`/etc/sysctl.conf` dosyasına aşağıdaki satırı ekleyerek IP forwarding'in kalıcı olmasını sağlayabilirsiniz.

```bash
net.ipv4.ip_forward = 1
```

**Cihaz A'dan Cihaz C'ye ping atarak bağlantının başarılı olduğunu kontrol edebiliriz.**

```bash
ping 192.168.2.5
# Çıktı: Reply from 192.168.2.5: bytes=32 time=4ms TTL=117
```

***

Basic Networking Cheat Sheets,

```bash
# Ağ arayüzlerinin durumunu gösterir
ip link
# Çıktı: 
# 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN mode DEFAULT group default qlen 1000
#    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
# 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP mode DEFAULT group default qlen 1000
#    link/ether 00:15:5d:22:25:84 brd ff:ff:ff:ff:ff:ff

# Ağ arayüzlerine atanmış IP adreslerini gösterir
ip addr
# Çıktı:
# 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
#    inet 127.0.0.1/8 scope host lo
#       valid_lft forever preferred_lft forever
#    inet6 ::1/128 scope host
#       valid_lft forever preferred_lft forever
# 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
#    inet 192.168.1.10/24 brd 192.168.1.255 scope global dynamic eth0
#       valid_lft 172737sec preferred_lft 172737sec
#    inet6 fe80::215:5dff:fe22:2584/64 scope link
#       valid_lft forever preferred_lft forever

# eth0 arayüzüne 192.168.1.10/24 IP adresini ekler
ip addr add 192.168.1.10/24 dev eth0

# Yönlendirme tablosunu görüntüler
ip route
# Çıktı:
# default via 192.168.1.1 dev eth0
# 192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.10

# 192.168.1.0/24 ağına erişimi 192.168.2.1 IP adresi üzerinden sağlar
ip route add 192.168.1.0/24 via 192.168.2.1

# IP forwarding'in etkin olup olmadığını kontrol eder
cat /proc/sys/net/ipv4/ip_forward
# Çıktı: 
# 0 (IP forwarding kapalı)

# IP forwarding'i etkinleştirir
echo 1 > /proc/sys/net/ipv4/ip_forward

# IP forwarding'in etkinleştirildiğini kontrol eder
cat /proc/sys/net/ipv4/ip_forward
# Çıktı:
# 1 (IP forwarding etkin)

```


# DNS Basics

**DNS,** internet ve yerel ağlardaki isimleri IP adreslerine çeviren, aynı zamanda çeşitli diğer bilgileri depolayan ve sorgulayan bir sistemdir. DNS, sadece web siteleri için değil, aynı zamanda e-posta sunucuları, ağ hizmetleri ve daha birçok sistem için kullanılır.

**DNS Nasıl Çalışır?**

1. Bir kullanıcı web tarayıcısına [www.google.com](http://www.google.com) yazdığında, tarayıcı DNS sunucusuna bu alan adının IP adresini sorar.
2. DNS sunucusu, bu alan adının IP adresini bulur ve tarayıcıya geri döner.
3. Tarayıcı, aldığı IP adresiyle web sunucusuna bağlanır ve kullanıcıya web sayfasını gösterir.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F4AJBBLlcGKMeE9dEysBk%2Fdomain-names.jpg?alt=media&amp;token=8902be9f-a128-4cf1-8cbc-4a17d681256f" alt=""><figcaption></figcaption></figure>

**Domain Name**, internet üzerindeki web sitelerinin adresleridir. Her alan adı, belirli bir IP adresine karşılık gelir ve bu adresler sayesinde web siteleri bulunabilir ve erişilebilir.

DNS (Domain Name System) sunucuları, internet ve diğer ağlardaki isim çözümleme işlemlerini gerçekleştiren ve yöneten sunuculardır. Bu sunucuların farklı türleri ve işlevleri vardır. Root DNS sunucuları, internetin DNS hiyerarşisinin en üstünde yer alır ve tüm DNS sorgularının başladığı yerdir. Dünyada toplamda 13 root sunucusu bulunur ve bu sunucular TLD (Top-Level Domain) sunucularına işaret eder. TLD DNS sunucuları ise üst düzey alan adlarını (.com, .net, .org gibi) yönetir ve root DNS sunucularından gelen istekleri alarak ilgili TLD'nin yetkili sunucusuna yönlendirir.

Root DNS sunucuları, DNS sisteminin en üst seviyesinde yer alan ve tüm internet trafiğinin yönlendirilmesinde kritik bir rol oynayan sunuculardır. Dünya genelinde 13 root DNS sunucusu bulunur ve bu sunucular çeşitli kuruluşlar tarafından yönetilir. ICANN gibi ana kuruluşlar, root DNS sisteminin operasyonel işlerini yürütür. Root DNS sunucuları, internetin temel yapı taşlarından biri olarak, her gün milyarlarca DNS sorgusunu doğru bir şekilde yönlendirir.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fbx47TDLmIoFAOZ9xSNul%2FnwWZx.png?alt=media&amp;token=63d0e4ca-4a36-4467-a163-54ae6868304c" alt=""><figcaption></figcaption></figure>

"search" direktifi, DNS aramalarında belirli bir domaini varsayılan olarak kullanmayı sağlar. Daha detaylı açıklamak gerekirse, "search" direktifi /etc/resolv.conf dosyasına eklenir ve burada belirtilen domain, kısa isim çözümlemelerinde otomatik olarak eklenir.

**örnek /etc/resolv.conf içeriği**:

```bash
nameserver 192.168.1.100
search mycompany.com
```

* **ping web**:
  * Bu komut çalıştırıldığında, sistem "web" ismini çözmeye çalışır. /etc/resolv.conf dosyasındaki search direktifi nedeniyle, sistem otomatik olarak "web.mycompany.com" ismini arar ve IP adresini bulur.
  * **Sonuç**: PING web.mycompany.com (192.168.1.10): 64 bytes of data...

**NSLookup**

`nslookup` (Name Server Lookup), DNS (Domain Name System) sorguları yapmak için kullanılan bir komut satırı aracıdır. Bu araç, bir alan adı veya IP adresi hakkında DNS kayıtlarını sorgulamak için kullanılır. Hem Windows hem de Unix tabanlı sistemlerde kullanılabilir.

#### NSLookup Kullanımı,

```bash
# Bir alan adının IP adresini öğrenmek için kullanılır.
nslookup example.com

# Çıktı
Server:  dns.example.com
Address:  192.168.1.1

Non-authoritative answer:
Name:    example.com
Address: 93.184.216.34
```

```bash
# Bir IP adresinin hangi alan adına karşılık geldiğini öğrenmek için kullanılır.
nslookup 93.184.216.34

# Çıktı
Server:  dns.example.com
Address:  192.168.1.1

Name:    example.com
Address: 93.184.216.34
```

**Dig**

`dig` (Domain Information Groper), DNS sorguları yapmak için kullanılan daha gelişmiş bir komut satırı aracıdır. `dig`, özellikle ağ yöneticileri ve sistem yöneticileri tarafından DNS sorunlarını teşhis etmek ve çözmek için kullanılır. Unix tabanlı sistemlerde yaygındır ve daha ayrıntılı çıktılar sağlar.

#### Dig Kullanımı,

```bash
# Bir alan adının IP adresini öğrenmek için kullanılır.
dig example.com

# Çıktı
; <<>> DiG 9.11.3-1ubuntu1.11-Ubuntu <<>> example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 31386
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 1

;; QUESTION SECTION:
;example.com.                   IN      A

;; ANSWER SECTION:
example.com.            10368   IN      A       93.184.216.34

;; Query time: 32 msec
;; SERVER: 192.168.1.1#53(192.168.1.1)
;; WHEN: Mon Jan 20 14:55:07 UTC 2024
;; MSG SIZE  rcvd: 56
```

```bash
# Bir IP adresinin hangi alan adına karşılık geldiğini öğrenmek için kullanılır.
dig -x 93.184.216.34

# Çıktı
; <<>> DiG 9.11.3-1ubuntu1.11-Ubuntu <<>> -x 93.184.216.34
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 50852
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; QUESTION SECTION:
;34.216.184.93.in-addr.arpa.    IN      PTR

;; ANSWER SECTION:
34.216.184.93.in-addr.arpa. 300 IN      PTR     example.com.

;; Query time: 35 msec
;; SERVER: 192.168.1.1#53(192.168.1.1)
;; WHEN: Mon Jan 20 14:57:07 UTC 2024
;; MSG SIZE  rcvd: 73

```

* `nslookup` daha basit sorgular için uygunken, `dig` daha ayrıntılı bilgi ve daha fazla esneklik sağlar.
* `dig` genellikle daha ayrıntılı ve düzenli bir çıktı sağlar, bu da özellikle sorun giderme ve analiz için yararlıdır.
* `dig`, çeşitli sorgu türleri ve parametrelerle daha fazla özelleştirilebilir.

Her iki araç da DNS sorguları yapmak, DNS kayıtlarını kontrol etmek ve ağ sorunlarını gidermek için oldukça kullanışlıdır.


# Applications Basics

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fa6DwlLyVWB70RwvMPYK3%2F1_3Iy-ohRRXj3lChmEbQTxIQ.png?alt=media&amp;token=92f76412-252b-44b4-ae7e-f59e60459e05" alt=""><figcaption></figcaption></figure>

### Programlama Dili Türleri,

**Compiled (Derlenen) Diller:**

* **Java, C, C++** gibi diller bu kategoriye girer.
* Derlenen dillerde, kaynak kod önce bir derleyici tarafından makine koduna dönüştürülür ve ardından çalıştırılır.

**Interpreted (Yorumlanan) Diller:**

* **Python, Ruby, Node.js, Perl** gibi diller bu kategoriye girer.
* Yorumlanan dillerde, kaynak kod doğrudan bir yorumlayıcı tarafından satır satır okunur ve çalıştırılır.

***

#### Derleme Süreci,

1 - Develop Source Code (Kaynak Kodu Geliştir):

* Kaynak kod bir dosya da yazılır. Örneğin, MyClass.java dosyası içinde:

```java
public class MyClass {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

```

2 - Compile (Derle):

* Kaynak kod, bir derleyici kullanılarak makine koduna çevrilir. Örneğin:

```bash
javac MyClass.java
```

* Bu komut, MyClass.java dosyasını derleyerek MyClass.class dosyasını oluşturur.

3 - Run (Çalıştır):

* Derlenen kod çalıştırılır. Örneğin:

```bash
java MyClass
```

* Bu komut, derlenmiş MyClass.class dosyasını çalıştırarak "Hello World" çıktısını üretir.

***

#### Yorumlama Süreci,

1 - Develop Source Code (Kaynak Kodu Geliştir):

* Kaynak kod bir dosyada yazılır. Örneğin, main.py dosyası içinde:

```python
def print_message():
    print("Hello World")

if __name__ == '__main__':
    print_message()

```

2 - Run ( Çalıştır ) :&#x20;

* Kaynak kod, bir yorumlayıcı kullanılarak doğrudan çalıştırılır. Örneğin:

```bash
python main.py
```

* Bu komut, main.py dosyasını yorumlayarak "Hello World" çıktısını üretir.

***

### Genel Farklar,

* **Derlenen Diller:**
  * Kaynak kod önce derlenir, ardından çalıştırılır.
  * Genellikle daha hızlı çalışır, çünkü kod makine koduna çevrilmiştir.
  * Hata bulma ve düzeltme süreci daha karmaşıktır, çünkü hatalar derleme sırasında ortaya çıkar.
* **Yorumlanan Diller:**
  * Kaynak kod doğrudan yorumlanır ve çalıştırılır.
  * Daha esnektir, çünkü kod satır satır çalıştırılır.
  * Hata bulma ve düzeltme süreci daha kolaydır, çünkü hatalar anında ortaya çıkar.

***

#### Python Çalışma süreci,

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fjbi6UiOlc02Va1Va9IFW%2F1_uD_HMa0sZUFShMvkXC7hqw.png?alt=media&amp;token=8aa0c6e2-c096-410e-83ad-2157cab13bea" alt=""><figcaption></figcaption></figure>

1 - **Örneğin, `main.py` dosyasındaki Python kodu:**

```python
def print_message():
    print("Hello World")

if __name__ == '__main__':
    print_message()
```

2 - **Derleme (Compilation):**

Python'da kaynak kod, bir derleyici tarafından **ara kod** olarak adlandırılan bir biçime dönüştürülür. Bu ara kod, makine tarafından doğrudan yürütülemez ancak yorumlayıcı tarafından okunabilir. Bu ara kod **bytecode** olarak adlandırılır.

Ara Kod (Intermediary Bytecode),

Bu aşamada, Python kaynak kodu bytecode olarak adlandırılan ara koda dönüştürülür:

```python
main.pyc
```

Bu dosya, `main.py` dosyasının derlenmiş halidir.

3 - **Yorumlama (Interpretation)**

Derlenmiş bytecode, bir yorumlayıcı tarafından makine koduna dönüştürülür ve çalıştırılır. Yorumlayıcı, bytecode'u satır satır okuyarak çalıştırır.

**Makine Kodu (Machine Code)**

Yorumlayıcı, bytecode'u makine koduna çevirir ve yürütür:

```bash
01101000 01100101 01101100 01101100 01101111 00100000 01110111 01101111 01110010 01101100 01100100

```

4 - **Sanal Makine (Virtual Machine)**

Python yorumlayıcısı, bir **Python Sanal Makinesi (Python VM)** üzerinde çalışır. Bu sanal makine, bytecode'u çalıştırarak son çıktıyı üretir.

**Sanal Makine (Python VM)**

Yorumlayıcı, bytecode'u Python VM üzerinde çalıştırır ve sonuç olarak:

```sh
Hello World
```

#### Özet,

Bu diyagram, `python hello-world.py` komutunun Python'daki derleme ve yorumlama sürecini nasıl çalıştığını göstermektedir.

```
+---------------------+     +--------------+     +-----------------+
|                     |     |              |     |                 |
|  Source Code        |---> |  Compiler    |---> |   Bytecode      |
|  (hello-world.py)   |     |  (Python)    |     |  (in memory)    |
+---------------------+     +--------------+     +-----------------+
                                                        |
                                                        |
                                                        v
                                               +-----------------+
                                               |                 |
                                               |  Interpreter    |
                                               |   (Python VM)   |
                                               |                 |
                                               +-----------------+
                                                        |
                                                        |
                                                        v
                                               +-----------------+
                                               |                 |
                                               |  Machine Code   |
                                               | ("Hello World") |
                                               |                 |
                                               +-----------------+
                                               
                                               
                                      ^
                                      |
                                      |                                             
+-----------------------------python hello-world.py-------------------------+
```

1. **Kaynak Kod (Source Code)** yazılır.
2. **Derleme (Compilation)**: Kaynak kod, bytecode'a dönüştürülür.
3. **Yorumlama ve Yürütme (Interpretation and Execution)**: Bytecode, Python VM tarafından yorumlanarak çalıştırılır ve makine koduna dönüştürülür.

***

#### Packages/Modules/Libraries

* **Filesystems**: Dosya sistemleriyle etkileşim kurmayı sağlayan kütüphaneler ve modüller. Örneğin, dosya okuma/yazma işlemleri, dosya ve dizin yönetimi gibi.
* **Math**: Matematiksel işlemleri gerçekleştirmek için kullanılan modüller ve kütüphaneler. Örneğin, Python'da `math` modülü, gelişmiş matematiksel fonksiyonlar sağlar.
* **Operating System**: İşletim sistemi ile etkileşimi kolaylaştıran modüller. Örneğin, `os` modülü ile Python'da dosya sistemine ve işletim sistemi düzeyinde işlevlere erişilebilir.
* **HTTP**: HTTP protokolü üzerinden web istekleri yapmak ve yanıtları işlemek için kullanılan kütüphaneler. Örneğin, Python'da `requests` modülü.
* **Security**: Güvenlik ile ilgili işlemleri gerçekleştiren kütüphaneler. Örneğin, encrypt işlemleri için kullanılan kütüphaneler.
* **Networking**: Ağ ile ilgili işlemleri gerçekleştirmek için kullanılan kütüphaneler. Örneğin, socket programlama için kullanılan modüller.

{% hint style="info" %}

* **Modül**: Tek bir `.py` dosyası, belirli işlevler için fonksiyonlar ve sınıflar içerir.
* **Paket**: İlgili modüllerin bir koleksiyonu, genellikle bir klasör içinde düzenlenir.
* **Kütüphane**: Belirli bir amaca yönelik kapsamlı araçlar sunan birçok modül ve paketin birleşimi.
  {% endhint %}

#### Build

Bir yazılımın derlenmesi, kaynak kodun çalıştırılabilir bir forma dönüştürülmesi sürecidir.

* **Compile**: Kaynak kodun makine diline veya bytecode'a dönüştürülmesi işlemi. Örneğin, Java'da `javac` komutu ile kaynak kod derlenir.
* **Run Tests**: Derlenen kodun çalıştırılarak test edilmesi. Bu aşama, yazılımın beklenildiği gibi çalışıp çalışmadığını kontrol eder.
* **Package**: Derlenen ve test edilen yazılımın paketlenmesi. Paketleme, yazılımın dağıtılabilir bir forma getirilmesidir.
* **Delivery**: Paketlenmiş yazılımın son kullanıcılara veya hedef ortama teslim edilmesi süreci.
* **Check build procedure for different types of applications**: Farklı türdeki uygulamalar için derleme prosedürlerinin kontrol edilmesi.


# Java introduction

Java, 1995 yılında Sun Microsystems (şu anda Oracle Corporation tarafından sahiplenilmiştir) tarafından geliştirilen yüksek seviyeli, sınıf tabanlı, nesne yönelimli bir programlama dilidir.&#x20;

* Java, ücretsiz olarak sunulmaktadır. Geliştiriciler, Java Development Kit (JDK) ve diğer araçları ücretsiz olarak indirip kullanabilirler.
* Java, açık kaynaklı bir dildir. Bu, geliştiricilerin Java'nın kaynak koduna erişebileceği ve kendi ihtiyaçlarına göre değiştirebileceği anlamına gelir. Açık kaynak topluluğu, Java'nın gelişimine aktif olarak katkıda bulunur.
* Java, dünya çapında geniş bir topluluğa sahiptir. Bu topluluk, Java'nın sürekli gelişimine ve desteklenmesine katkıda bulunur. Çeşitli forumlar, kullanıcı grupları ve etkinlikler, Java geliştiricilerinin bilgi ve deneyim paylaşmasını sağlar.

#### Java'nın çeşitli sürümleri,

* Java 13: 2019
* Java 12: 2019
* Java 11: 2018
* Java 10: 2018
* Java 9: 2017
* Java 8: 2014
* Java 7: 2011
* Java 6: 2006
* Java 5: 2004

Bu sürümler, Java'nın sürekli olarak güncellenen ve geliştirilen bir dil olduğunu gösterir. Her yeni sürüm, dildeki iyileştirmeleri, yeni özellikleri ve performans artışlarını içerir. Java'nın sürekli güncellenmesi, onu güvenilir ve sürdürülebilir bir dil yapar.

Java, platform bağımsızlığı (bir kez yaz, her yerde çalıştır), güvenlik ve taşınabilirlik gibi özellikleriyle bilinir. Bu özellikler, Java'nın geniş bir yelpazede uygulamalar geliştirmek için kullanılmasını sağlar, örneğin web uygulamaları, mobil uygulamalar, masaüstü uygulamaları ve büyük ölçekli kurumsal sistemler.

Java Kurulumu hakkında => <https://hostman.com/tutorials/installing-java-on-ubuntu-22-04/>

### Java Development Kit (JDK) Nedir?

JDK, Java uygulamaları geliştirip çalıştırmak için gereken araçları içeren bir yazılım geliştirme kitidir. Üç ana bileşeni vardır: **Develop (Geliştirme)**, **Build (Derleme)** ve **Run (Çalıştırma)**.

**Geliştirme (Develop):**

* **jdb**: Java Debugger, Java programlarını hata ayıklamak için kullanılır.
* **javadoc**: Java kodu için otomatik olarak API dokümantasyonu oluşturur.

**Derleme (Build):**

* **javac**: Java Compiler, Java kaynak kodunu (source code) derleyerek bytecode'a dönüştürür.
* **jar**: Java Archive, bir veya daha fazla dosyayı tek bir dosyada paketler ve sıkıştırır.

**Çalıştırma (Run):**

* **JRE (Java Runtime Environment)**: Java uygulamalarını çalıştırmak için gereken runtime ortamıdır.
* **java**: Java uygulamalarını çalıştırmak için kullanılan komuttur.

#### Ek Araçlar:

JDK'nın içinde birçok ek araç ve komut bulunmaktadır. Örneğin:

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F0wKYiKryb0HoifoorMlb%2Fimage.png?alt=media&amp;token=5c19669a-c4d8-458f-aed8-e000135be67d" alt=""><figcaption></figcaption></figure>

Bu araçlar, Java uygulamaları geliştirirken, derlerken ve çalıştırırken ihtiyaç duyulabilecek çeşitli işlevleri yerine getirir.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FyW9xsuR3XHOQkkDRFrqZ%2Fimage.png?alt=media&amp;token=38f68c95-df69-4b2f-a189-a826e004c86c" alt=""><figcaption></figcaption></figure>

{% hint style="info" %}
Java 9'da yapılan büyük değişikliklerden biri, JDK (Java Development Kit) ve JRE (Java Runtime Environment) ayrımının kaldırılmasıdır. Önceki sürümlerde, JDK ve JRE ayrı paketler olarak sunuluyordu ve kullanıcılar ihtiyacına göre bunlardan birini indirip kurabiliyordu. Ancak Java 9'dan itibaren, JDK indirildiğinde JRE de bu paketin içinde yer alıyor. Bu değişiklik, kullanıcıların daha az dosya indirmesini sağlamakta ve kurulum sürecini basitleştirmektedir.
{% endhint %}

***

### Build,

Java'da "compile" süreci, Java kodlarının çalıştırılabilir hale getirilmesi sürecidir.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FGdM5BUHW2kWxoIpY4b82%2Fimage.png?alt=media&amp;token=4821b5c9-ba2f-4095-b0d7-431bd8341d2d" alt=""><figcaption></figcaption></figure>

**1 - Kaynak Kodun Geliştirilmesi (Develop Source Code)**

* Java programcısı, Java programını yazdığı bir kaynak kod dosyası (örneğin `MyClass.java`) oluşturur.

```java
public class MyClass {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}
```

**2 - Derleme (Compile)**

* Kaynak kod dosyası (`MyClass.java`), Java derleyicisi (`javac`) kullanılarak derlenir. Bu işlem, kaynak kodun makine tarafından çalıştırılabilir bayt kodlarına dönüştürülmesi sürecidir. Derleme sonucunda `.class` uzantılı bir dosya (örneğin `MyClass.class`) oluşturulur.

**3 - Çalıştırma (Run)**

* Oluşturulan bayt kodu dosyası (`MyClass.class`), Java Runtime Environment (JRE) kullanılarak çalıştırılır. Bu işlem, bayt kodlarının Java Sanal Makinesi (JVM) tarafından çalıştırılmasıyla gerçekleştirilir.

```sh
java MyClass
```

* Bu komut, `MyClass.class` dosyasını çalıştırarak "Hello World" mesajını ekrana yazdırır.

Özetle, Java'da bir program yazıldığında, önce kaynak kod dosyası oluşturulur, ardından bu dosya derlenir ve son olarak derlenen dosya çalıştırılarak programın çıktısı alınır. Bu süreç sayesinde, Java kodları farklı platformlarda çalıştırılabilir hale gelir.

### Java Virtual Machine (JVM),

JVM, Java programlarının çalıştırılmasını sağlar. JVM'in temel çalışma adımları:

**Kaynak Kod (Source Code)**:

* İnsan tarafından okunabilir Java kaynak kodu, örneğin `MyClass.java`.

**Ara Kod (Byte Code)**:

* `javac` komutu ile derlenen bytecode, bir ara kod formatıdır ve `.class` uzantılı dosyalarda saklanır. Bu bytecode, JVM tarafından yorumlanarak çalıştırılabilir.

```sh
javac MyClass.java
```

**JVM ve Makine Kodu**:

* JVM, bytecode'u alır ve çalıştırmak için makine koduna çevirir. Bu, JVM'in çalıştığı platforma bağımlıdır ve bytecode'un platformdan bağımsız çalışmasını sağlar.&#x20;

```sh
java MyClass
```

### Package,

Java'da paketleme, bir veya birden fazla sınıf dosyasını (class files) ve bunlara bağlı diğer dosyaları bir araya getirerek, dağıtımı ve kullanımını kolaylaştıran bir dosya oluşturma sürecidir. Bu süreçte, Java Archive (JAR) veya Web Archive (WAR) dosyaları kullanılır.

JAR dosyası, birçok sınıf dosyasını, bağımlılıklarını, resim ve diğer kaynak dosyalarını tek bir arşivde birleştirir. JAR dosyaları, genellikle uygulamaların daha kolay dağıtılmasını ve çalıştırılmasını sağlar. Örneğin, tüm uygulamayı tek bir JAR dosyasına paketleyerek, kullanıcıların uygulamayı çalıştırmak için sadece bu dosyayı kullanması yeterli olur.

WAR dosyası, web uygulamaları için kullanılan bir arşiv formatıdır. Java Servlet, JSP ve ilgili sınıf dosyaları, kaynaklar ve konfigürasyon dosyaları bir WAR dosyasında birleştirilir ve bir Java web sunucusunda dağıtılır.

**META-INF/MANIFEST.MF**

Bu dosya, JAR dosyasının meta bilgilerinin bulunduğu yerdir. Manifest dosyasında, JAR dosyasının versiyonu, yaratıcı bilgileri ve ana sınıf (main class) gibi bilgiler yer alır. Örneğin:

```vbnet
Manifest-Version: 1.0
Created-By: 1.8.0_242 (Private Build)
Main-Class: MyClass
```

#### Paketleme Örneği

1. Gerekli Sınıf Dosyalarının Derlenmesi:

```sh
javac MyClass.java Service1.java Service2.java
```

2. JAR Dosyasının Oluşturulması:

```sh
jar cf MyApp.jar MyClass.class Service1.class Service2.class
```

* Bu komut, `MyApp.jar` adında bir JAR dosyası oluşturur ve içine `MyClass.class`, `Service1.class`, `Service2.class` dosyalarını ekler.

3. JAR Dosyasının Çalıştırılması:

```bash
java -jar MyApp.jar
```

Bu komut, `MyApp.jar` dosyasını çalıştırır ve içindeki ana sınıfın (main class) `main` metodunu başlatır.

* **JAR Dosyası**: Bir JAR dosyası oluşturmak için `jar` komutunu kullanırız. `cf` parametresi, yeni bir arşiv oluşturulacağını (`c`) ve dosya isimlerinin takip ettiğini (`f`) belirtir.
* **Manifest Dosyası**: Eğer `MyApp.jar` içindeki `META-INF/MANIFEST.MF` dosyasını inceleyecek olursak, burada JAR dosyasının versiyon bilgisi, yaratıcı bilgileri ve ana sınıf bilgisi bulunur.
* **Çalıştırma**: `java -jar MyApp.jar` komutu, JAR dosyasının içindeki `Main-Class` olarak belirtilen sınıfın `main` metodunu çalıştırır.

Java projelerinde, çeşitli sınıfları ve kaynakları tek bir dosyada paketlemek için Java Archive (JAR) dosyaları kullanılır. JAR dosyaları, tüm sınıf dosyalarını ve diğer kaynakları içeren sıkıştırılmış bir arşivdir. Bu dosyalar, projeyi dağıtmayı ve çalıştırmayı kolaylaştırır. JAR dosyası oluşturduktan sonra, ana sınıfın main metodunu çalıştırmak için `java -jar` komutu kullanılır. Örneğin:

```shell
java -jar MyApp.jar
```

Ancak, JAR dosyasının içindeki belirli bir sınıfı çalıştırmak için, JAR dosyasını classpath'e ekleyerek `java -cp` komutunu kullanabilirsiniz. Bu yöntemle, ana sınıf olarak belirtilmemiş olan bir sınıfı doğrudan çalıştırabilirsiniz. Örneğin:

```shell
java -cp MyApp.jar Service2
```

Bu komut, MyApp.jar dosyasının içinde bulunan ve main metoduna sahip Service2 sınıfını çalıştırır. Örneğin, `java -cp MyApp.jar Service2` komutu, `Service2.class` dosyasını çalıştırır, eğer bu sınıf bir `main` metoduna sahipse.

```java
public class Service2 {
    public static void main(String[] args) {
        System.out.println("Service2 is running");
    }
}
```

Özetle, `java -jar` komutu JAR dosyasının ana sınıfını çalıştırırken, `java -cp` komutu ile JAR dosyasındaki belirli bir sınıfı çalıştırabilirsiniz. Bu, projedeki farklı sınıfları çalıştırmayı ve test etmeyi kolaylaştırır.

***

### Document,

"javadoc" komutu, Java sınıflarından belgeler oluşturmak için kullanılır.

```bash
javadoc -d doc MyClass.java
```

* **`javadoc`**: Bu komut, Java kaynak kodu dosyalarından API belgeleri oluşturur.
* **`-d doc`**: Bu seçenek, oluşturulan belgelerin hangi dizine kaydedileceğini belirtir. Burada, belgeler "doc" adlı bir dizine kaydedilecek.
* **`MyClass.java`**: Bu, belgelerin oluşturulacağı Java kaynak kodu dosyasıdır.

Bu komut çalıştırıldığında, "MyClass.java" dosyasındaki sınıf ve metodlara ait açıklamalar, HTML formatında belgeler olarak "doc" dizinine oluşturulur. Bu belgeler, geliştiricilere kodun nasıl çalıştığını ve nasıl kullanılacağını anlamalarına yardımcı olur.

***

Java programlama diliyle bir yazılım geliştirme sürecinin ana adımları:

1. **Develop (Geliştirme)**:
   * Bu aşamada, geliştiriciler kaynak kodu yazar. Örneğin, `MyClass.java` dosyası.
2. **Compile (Derleme)**:
   * `javac MyClass.java` komutuyla, Java kaynak kodu derlenir. Derleyici (`javac`), yazılan Java kodunu makine diline daha yakın olan bayt koduna (bytecode) dönüştürür ve bu kod `.class` uzantılı dosyalarda saklanır. Örneğin, `MyClass.class`.
3. **Package (Paketleme)**:
   * `jar cf MyClass.jar MyClass.class` komutuyla, derlenmiş `.class` dosyası veya dosyaları ve gerekli diğer dosyalar tek bir arşiv dosyasında (JAR dosyası) paketlenir. JAR (Java Archive) dosyaları, Java uygulamalarının dağıtımı ve çalıştırılması için kullanılır. Bu aşamada tüm gerekli sınıf dosyaları ve bağımlılıklar bu arşivde toplanır.
4. **Document (Belgelendirme)**:
   * `javadoc MyClass.java` komutuyla, yazılan Java kodu için dokümantasyon oluşturulur. `javadoc`, Java kodu içinde yer alan yorumları kullanarak, HTML formatında dokümanlar oluşturur. Bu dokümanlar, sınıfların, metodların ve alanların ne işe yaradığını açıklar.

Özetle,

* **Develop**: Kod yazma aşaması.
* **Compile**: Yazılan kodun bayt koduna çevrilmesi.
* **Package**: Bayt kodunun bir arşiv dosyasına (JAR) paketlenmesi.
* **Document**: Kodun dokümantasyonunun oluşturulması.

***

**Build Tools**: Build araçları, yazılım projelerinin otomatikleştirilmiş derleme, test, paketleme ve dağıtım süreçlerini yönetmek için kullanılır. Üç popüler build aracı şunlardır:

1. **Maven**: Maven, özellikle Java projeleri için yaygın olarak kullanılan bir build aracıdır. Proje yapılandırma, bağımlılık yönetimi ve proje yönetimi için standart bir yaklaşım sağlar. XML tabanlı POM (Project Object Model) dosyaları kullanılarak yapılandırılır.
2. **Gradle**: Gradle, Maven ve Ant gibi build araçlarının özelliklerini birleştiren modern bir build aracıdır. Groovy veya Kotlin DSL (Domain-Specific Language) kullanılarak yapılandırılır ve yüksek performanslı build süreçleri sağlar.
3. **ANT**: Apache Ant, XML tabanlı yapılandırma dosyaları kullanarak build süreçlerini otomatikleştiren eski bir build aracıdır. Esneklik sağlar ancak daha yeni araçlar kadar yüksek düzeyde bağımlılık yönetimi sunmaz.


# NodeJS Introduction

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FOlsnDm8eU2Vki2TzS0ko%2F1_ptvSdUknyEbemXJOh9wNiw.png?alt=media&amp;token=4a07c43f-3d40-4374-b743-2a88641019ef" alt=""><figcaption></figcaption></figure>

Node.js, sunucu tarafında JavaScript çalıştırmanızı sağlayan açık kaynaklı ve platform bağımsız bir çalışma ortamıdır. İlk olarak 2009 yılında Ryan Dahl tarafından geliştirilen Node.js, asenkron ve olay odaklı yapısı sayesinde yüksek performanslı ve ölçeklenebilir uygulamalar geliştirmeyi kolaylaştırır.

* Node.js, açık kaynaklı bir çalışma ortamıdır ve geniş bir topluluğa sahiptir.
* Windows, macOS ve Linux gibi çeşitli platformlarda çalışabilir.
* Asenkron I/O işlemleri sayesinde yüksek performans sunar.

Ubuntu 22.04 NodeJS kurulumu hakkında: <https://www.cherryservers.com/blog/install-nodejs-on-ubuntu>

#### Basic NodeJS Commands,

```javascript
// Node.js sürümünü kontrol etme komutu
node -v 
// Çıktı: v13.10.1

// Node.js Yardım Menüsünü Gösterme
node --help
// Çıktı: Node.js komut satırı seçeneklerinin listesi

// Bir JavaScript dosyasını çalıştırma
node add.js 
// Çıktı: Addition : 15

// Node.js modüllerinin yolunu gösterme
node -p "require.resolve('module_name')"
// Çıktı: Modül yolunu gösterir

// REPL (Read-Eval-Print Loop) başlatma
node
// Çıktı: Etkileşimli bir Node.js komut satırı başlatılır

// Bir JavaScript dosyasını çalıştırma ve hata ayıklama
node inspect add.js
// Çıktı: add.js dosyasında hata ayıklama başlatılır

// Bir JavaScript dosyasını çalıştırma ve bellek kullanımını izleme
node --trace-gc add.js
// Çıktı: add.js dosyası çalıştırılırken bellek kullanımı izlenir

// Giriş olarak verilen kodu çalıştırma
node -e "console.log('Hello, World!')"
// Çıktı: Hello, World!

// Modül yolu ekleyerek çalıştırma
node -r ./my-module add.js
// Çıktı: add.js dosyası, my-module yüklendikten sonra çalıştırılır

// Node.js versiyonunu yönetme (NVM kullanarak)
nvm use 14
// Çıktı: Node.js'in 14. sürümünü kullanır

// Node.js ortam değişkenlerini görüntüleme
node -p "process.env"
// Çıktı: Ortam değişkenlerinin listesi

```

### NPM,

Npm, Node.js için paket yöneticisidir ve "Node Package Manager" anlamına gelir. Npm, geliştiricilerin projelerinde kullanabilecekleri açık kaynaklı JavaScript paketlerini (modüllerini) kolayca yüklemelerine, paylaşmalarına ve yönetmelerine olanak tanır.

#### Basic NPM Commands,

```bash
# Yaygın olarak kullanılan npm komutları ve açıklamaları

# 1. Proje başlatma ve package.json dosyası oluşturma
npm init -y
# Bu komut, varsayılan ayarlarla yeni bir package.json dosyası oluşturur.

# 2. Paket yükleme (lokal)
npm install <package-name>
# Belirtilen paketi proje dizinine yükler.

# 3. Paket yükleme (global)
npm install -g <package-name>
# Belirtilen paketi global olarak yükler, tüm projelerde kullanılabilir.

# 4. Paket kaldırma
npm uninstall <package-name>
# Belirtilen paketi projeden kaldırır.

# 5. Paket güncelleme
npm update <package-name>
# Belirtilen paketi günceller.

# 6. Tüm bağımlılıkları yükleme
npm install
# package.json dosyasındaki tüm bağımlılıkları yükler.

# 7. Proje bağımlılıklarını listeleme
npm list
# Projede yüklü olan tüm paketleri ve bağımlılıklarını listeler.

# 8. Global olarak yüklü paketleri listeleme
npm list -g --depth=0
# Global olarak yüklü tüm paketleri listeler.

# 9. Paket güncellemelerini kontrol etme
npm outdated
# Projedeki güncellenmesi gereken paketleri listeler.

# 10. Paket betiklerini çalıştırma
npm run <script-name>
# package.json dosyasındaki belirli bir betiği çalıştırır.

# 11. Paket yayınlama
npm publish
# Paketi npm kayıt deposuna yayınlar.

# 12. Paketlerin erişim izinlerini değiştirme
npm access
# Paketin erişim izinlerini ayarlamak için kullanılır.

# 14. Paket arama
npm search <package-name>
# Belirtilen paketi npm kayıt deposunda arar.

```

{% hint style="info" %}
Node.js uygulamasını çalıştırmak için `npm init -y` komutunu çalıştırmanız şart değildir. Bu komut, projenizin kök dizininde bir `package.json` dosyası oluşturur ve projeyi npm (Node Package Manager) ile yönetmenizi kolaylaştırır. Ancak, basit bir Node.js uygulaması çalıştırmak için bu dosyaya ihtiyacınız yoktur.

\
`package.json` dosyası olmadan da Node.js uygulamasını çalıştırabilirsiniz. Ancak, projeler büyüdükçe ve bağımlılıkları yönetmek gerektiğinde, `package.json` dosyası oluşturmak faydalı olur. Bu dosya, proje bilgilerinizi, bağımlılıkları ve npm komutlarını tanımlamanıza olanak tanır. Bu nedenle, projelerinizde genellikle `npm init` veya `npm init -y` komutunu kullanmak faydalı olabilir.
{% endhint %}

`package.json` dosyası, Node.js projelerinin merkezinde yer alan bir yapılandırma dosyasıdır. Bu dosya, projenizin adı, sürümü, yazar bilgileri, lisansı, bağımlılıkları ve betikleri (scripts) gibi çeşitli bilgileri içerir. Bu bilgiler, npm (Node Package Manager) ve diğer araçlar tarafından kullanılarak projenizin yönetimini kolaylaştırır.

{% code title="package.json" %}

```json
{
  // Projenin adı. npm üzerindeki benzersiz bir paket ismi.
  "name": "my-node-app",
  
  // Projenin sürümü. Semantic versioning kurallarına uygun olarak belirtilir.
  "version": "1.0.0",
  
  // Projenin kısa bir açıklaması.
  "description": "A simple Node.js application",
  
  // Uygulamanın ana dosyası. Projenin giriş noktası.
  "main": "app.js",
  
  // npm komutları ile çalıştırılabilecek betikler.
  "scripts": {
    // npm start komutu ile çalıştırılacak betik.
    "start": "node app.js",
    
    // npm test komutu ile çalıştırılacak betik.
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  
  // Projeyi geliştiren kişi veya kurumun bilgileri.
  "author": "Onur",
  
  // Projenin lisansı.
  "license": "MIT",
  
  // Projenin çalışması için gereken bağımlılıklar.
  "dependencies": {
    // Express modülü, versiyon 4.17.1 ve üstü.
    "express": "^4.17.1"
  },
  
  // Geliştirme sırasında ihtiyaç duyulan bağımlılıklar.
  "devDependencies": {
    // Nodemon modülü, versiyon 2.0.7 ve üstü.
    "nodemon": "^2.0.7"
  },
  
  // Projenin kaynak kodunun bulunduğu depo bilgileri.
  "repository": {
    "type": "git",
    // Git deposunun URL'si.
    "url": "git+https://github.com/username/my-node-app.git"
  },
  
  // Projeyi tanımlayan anahtar kelimeler.
  "keywords": [
    "node",
    "express",
    "example"
  ]
}

```

{% endcode %}

* Projenizi başlatmak için `npm init` komutunu kullanarak interaktif olarak `package.json` dosyasını oluşturabilirsiniz.
* `npm install <paket-adı>` komutuyla bağımlılık eklediğinizde, bu bağımlılık otomatik olarak `package.json` dosyasına eklenir.
* `npm run start` komutuyla `scripts` bölümünde tanımladığınız `start` betiğini çalıştırabilirsiniz.

### Modules,

Node.js modülleri, kodunuzu daha yönetilebilir ve modüler hale getiren yapı taşlarıdır. Node.js, hem yerleşik modüller (Built-In Modules) hem de dış modüller (External Modules) sunar.

#### Yerleşik Modüller (Built-In Modules)

* **fs (File System)**: Dosya sistemi işlemlerini yönetmek için kullanılır. Örneğin, dosya okuma, yazma ve silme işlemleri.
* **http**: HTTP sunucusu barındırmak için kullanılır. Sunucu oluşturma ve HTTP isteklerini yönetme işlemlerini gerçekleştirir.
* **os (Operating System)**: İşletim sistemi ile ilgili işlemler yapmak için kullanılır. Sistem bilgileri, kullanıcı bilgileri gibi verilere erişim sağlar.
* **events**: Olayları (events) yönetmek için kullanılır. Olay tabanlı programlama modelini destekler.
* **tls (Transport Layer Security)**: TLS ve SSL uygulamalarını yönetmek için kullanılır. Güvenli bağlantılar kurmayı sağlar.
* **url**: URL dizelerini ayrıştırmak ve işlemek için kullanılır.

#### Dış Modüller (External Modules)

* **express**: Hızlı ve minimal bir web frameworküdür. Web uygulamaları ve API'ler oluşturmak için yaygın olarak kullanılır.
* **react**: Kullanıcı arayüzleri oluşturmak için kullanılır. Özellikle dinamik web uygulamaları için tercih edilir.
* **debug**: Uygulama hatalarını ayıklamak için kullanılır. Detaylı hata raporları ve loglar sağlar.
* **async**: Asenkron JavaScript işlemleri yönetmek için kullanılır. Promise tabanlı yapıların daha kolay yönetilmesini sağlar.
* **lodash**: Diziler, nesneler ve stringlerle çalışmak için geniş bir fonksiyon seti sunar.

#### Komutlar

```sh
# Yerleşik modülleri listeleme
ls /usr/lib/node_modules/npm/node_modules/

# Dış modülleri listeleme
ls /usr/lib/node_modules/
```

Node.js modülleri, çeşitli görevleri kolayca yönetmenize ve uygulamanızı modüler hale getirmenize yardımcı olur. Yerleşik modüller, Node.js tarafından sağlanan temel işlevleri içerirken, dış modüller, topluluk tarafından geliştirilmiş ve belirli işlevleri gerçekleştiren modüllerdir.


# Python Introduction

Python, kullanımı kolay ve oldukça popüler bir programlama dilidir. 1991 yılında Guido van Rossum tarafından yaratılmıştır. Python’un en büyük avantajlarından biri, okunabilirliğe ve basitliğe büyük önem vermesidir. Yani, karmaşık işlemleri bile çok daha az ve anlaşılır kodla gerçekleştirebilirsiniz. Bu nedenle, yeni başlayanlardan deneyimli geliştiricilere kadar herkes tarafından sevilir.

Ubuntu için python ve pip kurulumu: <https://www.cherryservers.com/blog/how-to-install-pip-ubuntu>

#### Sıklıkla kullanılan Python komutları,

```bash
# Python shell başlatmak
python
# Python shell'ini başlatır.

# Belirli bir Python dosyasını çalıştırmak
python script.py
# script.py dosyasını çalıştırır.

# Python versiyonunu kontrol etmek
python --version
# Yüklü olan Python'un versiyonunu gösterir.

# Belirli bir modül hakkında yardım almak
python -m pydoc module_name
# Belirli bir Python modülü hakkında yardım dökümantasyonu sağlar.

# Python'un etkileşimli modunu başlatmak
python -i script.py
# script.py dosyasını çalıştırır ve sonrasında etkileşimli moda geçer.

# Python komutlarını doğrudan komut satırından çalıştırmak
python -c "print('Hello, World!')"
# Komut satırından Python kodu çalıştırır ve "Hello, World!" yazdırır.

# Belirli bir Python modülünü çalıştırmak
python -m module_name
# Belirtilen Python modülünü çalıştırır.

# Bir Python sanal ortamı oluşturmak
python -m venv myenv
# Bir sanal Python ortamı oluşturur.

# Python dosyasını optimize ederek çalıştırmak
python -O script.py
# script.py dosyasını optimize ederek çalıştırır (assertion'ları ve __debug__ bloklarını atlar).

# Python dosyasını derlemek
python -m py_compile script.py
# script.py dosyasını derler ve .pyc bytecode dosyasını oluşturur.

```

### PIP,

Pip, Python'da paket yönetim aracıdır. Python paketlerini ve bağımlılıklarını kolayca yüklemenizi, güncellemenizi ve yönetmenizi sağlar. Pip, Python'un standart kütüphanelerinden biridir ve genellikle Python ile birlikte gelir.

```bash
# Pip versiyonunu kontrol etme
pip --version
# Bu komut, sistemde yüklü olan pip'in versiyonunu gösterir.

# Bir paket yükleme
pip install package_name
# Belirtilen `package_name` adlı paketi PyPI'den indirir ve kurar.

# Belirli bir sürümü yükleme
pip install package_name==1.2.3
# `package_name` adlı paketin 1.2.3 sürümünü indirir ve kurar.

# Paket güncelleme
pip install --upgrade package_name
# `package_name` adlı paketin en son sürümünü indirir ve kurar.

# Yüklü paketleri listeleme
pip list
# Sistemde yüklü olan tüm Python paketlerini listeler.

# Yüklü paketler hakkında daha fazla bilgi edinme
pip show package_name
# `package_name` adlı paketin detaylarını gösterir.

# Bir paketi kaldırma
pip uninstall package_name
# `package_name` adlı paketi sistemden kaldırır.

# Bağımlılıkları belirtilen bir dosyadan yükleme
pip install -r requirements.txt
# `requirements.txt` dosyasında belirtilen tüm paketleri ve sürümleri indirir ve kurar.

# Paketlerin depoda en son sürümlerini listeleme
pip list --outdated
# Güncellenmesi gereken paketleri listeler.

# Bir paket arama
pip search package_name
# `package_name` adlı paketi PyPI'de arar ve eşleşen paketlerin listesini gösterir.

# Kurulu paketlerin yolunu gösterme
pip show --files package_name
# `package_name` adlı paketin sistemde nerede kurulu olduğunu gösterir.

# Tüm bağımlılıkları indirerek paketleri yükleme
pip install package_name[extra]
# `package_name` adlı paketi ve belirtilen ekstra bağımlılıkları indirir ve kurar.

# Pip'i güncelleme
pip install --upgrade pip
# Pip'i en son sürüme günceller.

```

Pip ile kurulan paketler, Python'ın kurulumuna ve işletim sistemine bağlı olarak değişiklik gösterebilir. Paketlerin nereye kurulduğunu kontrol etmek için aşağıdaki komutu kullanabilirsiniz:

`pip show package_name`

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FCnEMwyJE9VohiX5FusCZ%2Fimage.png?alt=media&amp;token=3fdc0eff-a647-449f-999d-8dd273836cd6" alt=""><figcaption></figcaption></figure>

***

***

`sys.path`, Python'un modül aramak için kullandığı dizinlerin bir listesidir. Python bir modülü içe aktardığında, önce bu listede yer alan dizinlerde arar. Bu liste, Python'un hangi dizinlerde modül aradığını ve hangi yolların Python tarafından kullanıldığını gösterir.

```bash
python3 -c "import sys; print(sys.path)"
```

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F1IboCTzLY8dImKdaXTVj%2Fimage.png?alt=media&amp;token=d5105959-7d71-4f27-bbcc-776a1e307bfe" alt=""><figcaption></figcaption></figure>

* **Boş Dize (`''`)**: Geçerli çalışma dizinini temsil eder.
* **`/usr/lib/python310.zip`**: Python modüllerinin sıkıştırılmış bir dosyada bulunduğu yeri temsil eder.
* **`/usr/lib/python3.10`**: Python'un kurulu olduğu dizin ve standart kütüphaneler.
* **`/usr/lib/python3.10/lib-dynload`**: Dinamik olarak yüklenebilir modüller.
* **`/usr/local/lib/python3.10/dist-packages`**: Kullanıcı tarafından yüklenen paketlerin bulunduğu yer.
* **`/usr/lib/python3/dist-packages`**: Sistem paket yöneticisi tarafından yüklenen Python paketleri.

#### requirements.txt,

`requirements.txt` dosyası, Python projelerinde kullanılan ve projeye bağımlı olan tüm paketlerin ve bu paketlerin sürümlerinin listesini içeren bir dosyadır. Bu dosya, projeyi başka bir ortama taşırken veya başka bir geliştiricinin projeyi çalıştırması gerektiğinde, projeye gerekli tüm bağımlılıkların kolayca kurulmasını sağlar.&#x20;

**İçeriği,**

`requirements.txt` dosyasının içeriği basit bir metin formatındadır. Her satır bir paketi ve isteğe bağlı olarak sürümünü belirtir. Örneğin:

```
numpy==1.21.0
pandas>=1.3.0
requests<=2.25.1
flask
```

* `numpy==1.21.0`: NumPy paketinin kesin olarak 1.21.0 sürümünü kurar.
* `pandas>=1.3.0`: Pandas paketinin en az 1.3.0 sürümünü kurar.
* `requests<=2.25.1`: Requests paketinin en fazla 2.25.1 sürümünü kurar.
* `flask`: Flask paketinin en son sürümünü kurar.

**Kurulum,**

`requirements.txt` dosyasındaki bağımlılıkları kurmak için aşağıdaki komutu kullanabilirsiniz:

```bash
pip install -r requirements.txt
```

**Örnek,**

Örneğin, bir Flask uygulamanız varsa ve bu uygulama aşağıdaki paketlere ihtiyaç duyuyorsa:

* Flask
* SQLAlchemy
* Requests

Bu paketleri yükledikten sonra, `pip freeze > requirements.txt` komutunu çalıştırarak aşağıdaki gibi bir `requirements.txt` dosyası oluşturabilirsiniz:

```
Flask==2.0.1
SQLAlchemy==1.4.22
requests==2.25.1
```

Bu dosyayı başka bir geliştiriciye veya sunucuya taşıdığınızda, `pip install -r requirements.txt` komutunu çalıştırarak gerekli tüm bağımlılıkları kolayca kurabilirsiniz.

#### Other Package Managers,

* `easy_install`, Python `setuptools` paketinin bir parçasıdır ve Python Paket Dizini (PyPI) üzerinde barındırılan paketleri indirir ve yükler.
  * İlk olarak, `easy_install` aracının sisteminizde kurulu olduğundan emin olun. `easy_install`, `setuptools` paketi ile birlikte gelir, bu nedenle `setuptools` paketini kurarak `easy_install` aracını da kurabilirsiniz:

    ```bash
    pip install setuptools
    ```
  * **Flask Kurulumu:**

    ```bash
    easy_install Flask
    ```

* `Wheels`, Python'da paket dağıtımı için kullanılan modern bir formattır ve `.whl` dosya uzantısına sahiptir. `pip` aracı ile birlikte çalışır ve önceden derlenmiş paketleri hızlı bir şekilde yükler.
  * Diyelim ki flask wheel dosyasını indirdiniz. İndirdiğiniz dosya adının Flask-2.0.2-py3-none-any.whl olduğunu varsayalım.&#x20;
  * **Flask Wheel Dosyasını İndirin:**

    ```bash
    pip wheel flask
    ```
  * Bu komut, mevcut dizine `flask` için bir wheel dosyası indirir.
  * **Flask Wheel Dosyasını Kurun:**

    ```bash
    pip install Flask-2.0.2-py3-none-any.whl
    ```


# GIT Introduction

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FYpidyCN51Xoxq4HIvj2g%2F1_irvoqLol7t-EPNzZN6CSnA.png?alt=media&amp;token=04e0a831-1dfb-4f6e-a2a5-5d5ecd51de61" alt=""><figcaption></figcaption></figure>

#### What is GIT?

Git, açık kaynaklı bir dağıtık versiyon kontrol sistemidir. Yazılım geliştirme süreçlerinde, geliştiricilerin kod değişikliklerini izlemelerine ve işbirliği yapmalarına olanak tanır.

#### Install GIT

Git'i kurmak oldukça basittir. İşletim sistemine göre farklı adımlar izlenir:

* **Windows**: [Git for Windows](https://gitforwindows.org/) sitesinden indirilebilir ve standart bir kurulum süreciyle kurulabilir.
* **macOS**: Homebrew kullanarak `brew install git` komutuyla kurulabilir.
* **Linux**: Paket yöneticisi kullanılarak kurulabilir. Örneğin, Debian tabanlı sistemlerde `sudo apt-get install git` komutuyla kurulabilir.

#### GIT Repositories

Git repository (depo), bir projenin tüm dosyalarını ve geçmişini içeren bir dizindir. Bir Git reposu, `git init` komutuyla oluşturulabilir ve bu komut mevcut bir dizini bir Git reposuna dönüştürür.

#### Remote Repositories

Remote repository, internette veya ağ üzerinde bulunan bir Git reposudur. Geliştiriciler, projelerini bu repolara göndererek (push) veya bu depolardan çekerek (pull) işbirliği yapabilirler. Örnek olarak GitHub, GitLab ve Bitbucket gibi platformlar remote repository hizmeti sunar.

#### Clone, Pull & Push

* **Clone**: `git clone <repository-url>` komutuyla, uzak bir depo yerel bilgisayara kopyalanır.
* **Pull**: `git pull` komutuyla, uzak depodaki değişiklikler yerel depoya çekilir ve birleştirilir.
* **Push**: `git push` komutuyla, yerel depodaki değişiklikler uzak depoya gönderilir.

#### GIT vs GITHUB

* **Git**: Versiyon kontrol sistemidir. Komut satırı araçlarıyla kullanılan, dağıtık bir sistemdir.
* **GitHub**: Git repolarını barındıran ve projelerin paylaşılmasını sağlayan bir platformdur. GitHub, Git'in üzerine ek özellikler sunar, örneğin, sorun takibi, proje yönetimi araçları ve wiki.

#### Basit Git Komutları

```bash
# Mevcut dizini bir Git deposu olarak başlatır.
git init
# Örnek: git init

# Uzak bir depoyu yerel olarak klonlar.
git clone <repository_url>
# Örnek: git clone https://github.com/user/repo.git

# Dosyaları izleme (staging) alanına ekler.
git add <file>
# Örnek: git add README.md

# Tüm değişiklikleri izleme (staging) alanına ekler.
git add .
# Örnek: git add .

# Yapılan değişiklikleri yerel depoya kaydeder.
git commit -m "Commit mesajı"
# Örnek: git commit -m "Initial commit"

# Değişiklikleri uzak depoya gönderir.
git push <remote> <branch>
# Örnek: git push origin main

# Uzak depodaki değişiklikleri yerel depoya çeker.
git pull <remote> <branch>
# Örnek: git pull origin main

# Yerel deponuzda yeni bir dal (branch) oluşturur.
git branch <branch_name>
# Örnek: git branch feature-branch

# Belirli bir dala geçiş yapar.
git checkout <branch_name>
# Örnek: git checkout feature-branch

# Yeni bir dal (branch) oluşturur ve ona geçiş yapar.
git checkout -b <branch_name>
# Örnek: git checkout -b new-branch

# Mevcut dalları listeler.
git branch
# Örnek: git branch

# Bir dalı (branch) siler.
git branch -d <branch_name>
# Örnek: git branch -d feature-branch

# İki dalı (branch) birleştirir.
git merge <branch_name>
# Örnek: git merge feature-branch

# Uzak depoları ve URL'lerini listeler.
git remote -v
# Örnek: git remote -v

# Bir dosyanın veya dizinin değişikliklerini geri alır.
git checkout -- <file>
# Örnek: git checkout -- README.md

# Son yapılan commit'i geri alır.
git revert <commit_hash>
# Örnek: git revert a1b2c3d4

# Yapılan commit'lerin logunu görüntüler.
git log
# Örnek: git log

# Değişiklikleri karşılaştırır.
git diff
# Örnek: git diff

# Geçici olarak değişiklikleri kenara koyar (stash).
git stash
# Örnek: git stash

# En son kenara konan değişiklikleri geri getirir.
git stash pop
# Örnek: git stash pop

# Depo durumunu gösterir (izlenen, izlenmeyen dosyalar vb.).
git status
# Örnek: git status

```


# Apache Web Server Introduction

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FDFawWWPY1sDDqVcDWVpW%2Fhttps___dev-to-uploads.s3.amazonaws.com_uploads_articles_7dvu3xzvepdcy1919s2q.avif?alt=media&amp;token=2494c237-6051-4ecf-b6b4-6938b2a5dd33" alt=""><figcaption></figcaption></figure>

Apache2, dünya çapında en yaygın kullanılan web sunucularından biridir. Web sitelerini barındırmak ve HTTP protokolü üzerinden web tarayıcılarına içerik sunmak için kullanılır. Açık kaynaklı bir yazılımdır ve Apache Software Foundation tarafından geliştirilir ve desteklenir.&#x20;

* Apache2 tamamen ücretsizdir ve açık kaynak lisansı altında dağıtılır.
* Apache2, Unix, Linux, Windows ve macOS dahil olmak üzere birçok işletim sisteminde çalışabilir.
* Apache2, çeşitli işlevsellikleri eklemek veya çıkarmak için modüller (modules) kullanır. Bu, sunucunun performansını ve yeteneklerini ihtiyaçlara göre uyarlamayı sağlar.
* Apache2,  SSL/TLS desteği, erişim kontrolü ve kullanıcı kimlik doğrulaması gibi güvenlik özelliklerini içerir.
* Apache2, yapılandırma dosyaları aracılığıyla çok esnek bir şekilde yapılandırılabilir. Kullanıcılar, ihtiyaçlarına göre çeşitli modülleri etkinleştirip devre dışı bırakabilirler.

Apache2'nin kurulumu genellikle basittir ve çoğu Linux dağıtımında paket yöneticileri aracılığıyla kolayca yapılabilir. Örneğin, Ubuntu'da Apache2'yi kurmak için şu komutlar kullanılır:

```bash
sudo apt update
sudo apt install apache2
```

#### Temel Yapılandırma Dosyaları

1. **apache2.conf:**
   * Ana yapılandırma dosyasıdır ve genel sunucu ayarlarını içerir.
   * `/etc/apache2/apache2.conf` yolunda bulunur.
   * İçeriğinde genel sunucu ayarları, modül tanımları ve global kurallar bulunur.

```apacheconf
ServerRoot "/etc/apache2"
Mutex file:${APACHE_LOCK_DIR} default
PidFile ${APACHE_PID_FILE}
Timeout 300
KeepAlive On
MaxKeepAliveRequests 100
KeepAliveTimeout 5

User ${APACHE_RUN_USER}
Group ${APACHE_RUN_GROUP}

# LoadModule directives
IncludeOptional mods-enabled/*.load
IncludeOptional mods-enabled/*.conf

# Virtual hosts
IncludeOptional sites-enabled/*.conf
```

2. **sites-available/ ve sites-enabled/:**

{% hint style="info" %}
Virtual host, tek bir sunucu üzerinde birden fazla web sitesini barındırma imkanı sağlayan bir yapılandırma yöntemidir. Apache HTTP Server gibi web sunucuları, virtual host kullanarak farklı alan adlarına veya IP adreslerine göre çeşitli web sitelerini sunabilirler. Virtual host'lar, aynı sunucuda birden fazla web sitesi barındırmak için yaygın olarak kullanılır.
{% endhint %}

* **sites-available/**: Virtual host yapılandırma dosyalarının bulunduğu dizindir.
* **sites-enabled/**: Aktif olan virtual host yapılandırma dosyalarına sembolik linkler içerir.
* Genellikle `/etc/apache2/` dizini altında bulunurlar.

**Örnek Virtual Host Dosyası (sites-available/example.com.conf):**

```apacheconf
<VirtualHost *:80>
    ServerAdmin webmaster@example.com
    ServerName example.com
    ServerAlias www.example.com
    DocumentRoot /var/www/html/example.com/public_html
    ErrorLog ${APACHE_LOG_DIR}/example.com_error.log
    CustomLog ${APACHE_LOG_DIR}/example.com_access.log combined
</VirtualHost>
```

3. **mods-available/ ve mods-enabled/:**
   * **mods-available/**: Yüklenebilir Apache modüllerinin yapılandırma dosyalarını içerir.
   * **mods-enabled/**: Aktif olan modüllere sembolik linkler içerir.
   * Genellikle `/etc/apache2/` dizini altında bulunurlar.

4. **ports.conf:**

* Apache2'nin hangi portlardan dinleyeceğini belirler.
* `/etc/apache2/ports.conf` yolunda bulunur.

```apacheconf
Listen 80
<IfModule ssl_module>
    Listen 443
</IfModule>
<IfModule mod_gnutls.c>
    Listen 443
</IfModule>
```

#### Yapılandırma Dosyalarının Yönetimi;

```bash
# Virtual Hostları Etkinleştirme ve Devre Dışı Bırakma

# Virtual Hostları Etkinleştirme:
sudo a2ensite example.com.conf
# Bu komut, /etc/apache2/sites-available/example.com.conf dosyasına,
# /etc/apache2/sites-enabled/ dizininde bir sembolik link oluşturur.

# Virtual Hostları Devre Dışı Bırakma:
sudo a2dissite example.com.conf
# Bu komut, /etc/apache2/sites-enabled/example.com.conf sembolik linkini kaldırır.

# Modülleri Etkinleştirme ve Devre Dışı Bırakma

# Modül Etkinleştirme:
sudo a2enmod rewrite
# Bu komut, /etc/apache2/mods-available/rewrite.load dosyasına,
# /etc/apache2/mods-enabled/ dizininde bir sembolik link oluşturur.

# Modül Devre Dışı Bırakma:
sudo a2dismod rewrite
# Bu komut, /etc/apache2/mods-enabled/rewrite.load sembolik linkini kaldırır.

# Yapılandırmayı Test Etme ve Yeniden Başlatma

# Yapılandırmayı Test Etme:
sudo apache2ctl configtest
# Bu komut, Apache2 yapılandırma dosyalarını kontrol eder ve yapılandırmanın geçerli olup olmadığını bildirir.

# Apache2'yi Yeniden Başlatma:
sudo systemctl restart apache2
# Bu komut, Apache2 hizmetini yeniden başlatır ve yapılandırma değişikliklerini uygular.
```

### httpd

Red Hat tabanlı sistemlerde (örneğin, RHEL, CentOS, Fedora) Apache HTTP Server genellikle `httpd` adıyla bilinir ve yönetilir.&#x20;

#### Temel Yapılandırma Dosyaları

Red Hat tabanlı sistemlerde Apache HTTP Server yapılandırma dosyaları genellikle `/etc/httpd/` dizini altında bulunur.

1. **httpd.conf:**

* Ana yapılandırma dosyasıdır ve genel sunucu ayarlarını içerir.
* `/etc/httpd/conf/httpd.conf` yolunda bulunur.
* Bu dosya, Apache'nin temel yapılandırma ayarlarını içerir.

```apacheconf
ServerRoot "/etc/httpd"
Listen 80
Include conf.modules.d/*.conf
User apache
Group apache
ServerAdmin root@localhost
DocumentRoot "/var/www/html"
<Directory "/var/www/html">
    AllowOverride None
    Require all granted
</Directory>
ErrorLog "logs/error_log"
CustomLog "logs/access_log" combined
```

2. **conf.d/:**

* Ek yapılandırma dosyalarını içerir.
* Bu dizindeki dosyalar otomatik olarak `httpd.conf` tarafından dahil edilir.
* Genellikle virtual host 'lar ve diğer modül yapılandırmaları için kullanılır.

3. **modules.d/:**

* Modül dosyalarını içerir.
* Hangi modüllerin yükleneceğini belirten `.conf` dosyaları bu dizinde bulunur.

4. **sites-available/ ve sites-enabled/:** (Bu dizinler varsayılan olarak yoktur, ancak el ile oluşturulabilir)


# Apache Tomcat

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FhMR4g96ExQ2B4WQC6JB2%2Fimage.png?alt=media&amp;token=851a3103-27d0-41cc-9e5d-08bd0af35058" alt=""><figcaption></figcaption></figure>

Apache Software Foundation tarafından geliştirilen Tomcat, dinamik Java tabanlı web uygulamalarını çalıştırmak için yaygın olarak kullanılır.

* Tomcat, Java Servlet API'sini destekler ve Java Servlet'lerini çalıştırır.
* JavaServer Pages (JSP) teknolojisini destekler ve JSP sayfalarını çalıştırır.
* Tomcat, Java WebSocket API'sini destekler ve gerçek zamanlı, çift yönlü iletişim sağlar.

Ubuntu 22.04 için kurulum rehberi : <https://www.webhi.com/how-to/how-to-install-tomcat-on-ubuntu/>

#### **Tomcat  Temel Yapılandırma Dosyaları**

1. server.xml: `server.xml`, Tomcat'in ana yapılandırma dosyasıdır ve sunucu yapılandırmasını içerir. Bu dosya `conf/` dizininde bulunur.

```xml
<Server port="8005" shutdown="SHUTDOWN">
    <Service name="Catalina">
        <Connector port="8080" protocol="HTTP/1.1"
                   connectionTimeout="20000"
                   redirectPort="8443" />
        <Engine name="Catalina" defaultHost="localhost">
            <Host name="localhost"  appBase="webapps"
                  unpackWARs="true" autoDeploy="true">
            </Host>
        </Engine>
    </Service>
</Server>
```

2. web.xml: `web.xml` dosyası, uygulama tabanlı yapılandırma ayarlarını içerir. Bu dosya, her web uygulamasının `WEB-INF/` dizininde bulunur.

```xml
<web-app>
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.example.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>
```

#### Diğer Dosyalar:

```bash
# 3. context.xml
# Bireysel web uygulamaları için konteks yapılandırmalarını içerir.
# Her web uygulaması için özel yapılandırmalar bu dosyada belirtilir.
# Dosya yolu: conf/context.xml (global) ve her web uygulaması için META-INF/context.xml

<Context>
    <Resource name="jdbc/MyDB" auth="Container"
              type="javax.sql.DataSource" maxActive="100" maxIdle="30" maxWait="10000"
              username="dbuser" password="dbpassword" driverClassName="com.mysql.jdbc.Driver"
              url="jdbc:mysql://localhost:3306/mydb"/>
</Context>

# 4. tomcat-users.xml
# Tomcat'in kullanıcıları ve rollerini tanımlayan yapılandırma dosyasıdır.
# Yönetici ve diğer kullanıcı hesapları bu dosyada tanımlanır.
# Dosya yolu: conf/tomcat-users.xml

<tomcat-users>
    <role rolename="manager-gui"/>
    <user username="admin" password="admin" roles="manager-gui"/>
</tomcat-users>

# 5. logging.properties
# Tomcat'in loglama yapılandırmalarını belirler.
# Hangi logların, nereye ve nasıl yazılacağını tanımlar.
# Dosya yolu: conf/logging.properties

handlers = java.util.logging.ConsoleHandler
.level = INFO
java.util.logging.ConsoleHandler.level = FINE
java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter

# 6. catalina.properties
# Tomcat'in iç ayarlarını ve çeşitli sistem özelliklerini belirler.
# Dosya yolu: conf/catalina.properties

common.loader="${catalina.base}/lib,${catalina.base}/lib/*.jar"
server.loader=
shared.loader=

# 7. catalina.policy
# Java güvenlik politikalarını belirler.
# Hangi kodun hangi kaynaklara erişebileceğini kontrol eder.
# Dosya yolu: conf/catalina.policy

grant {
    permission java.security.AllPermission;
};

# 8. host-manager.xml
# Tomcat Host Manager web uygulamasının yapılandırma dosyasıdır.
# Dosya yolu: conf/Catalina/localhost/host-manager.xml

<Context privileged="true" antiResourceLocking="false" docBase="${catalina.home}/webapps/host-manager">
    <Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="127\.\d+\.\d+\.\d+|::1"/>
</Context>

# 9. manager.xml
# Tomcat Manager web uygulamasının yapılandırma dosyasıdır.
# Dosya yolu: conf/Catalina/localhost/manager.xml

<Context privileged="true" antiResourceLocking="false" docBase="${catalina.home}/webapps/manager">
    <Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="127\.\d+\.\d+\.\d+|::1"/>
</Context>

```


# Python Flask

Flask, Python programlama dili ile yazılmış sade bir web framework'tür. Basit ve esnek bir yapıya sahip olan Flask, özellikle küçük ve orta ölçekli web uygulamaları geliştirmek için idealdir. Flask, minimal bir çekirdek üzerine inşa edilmiş olup, geliştiricilere istedikleri eklentileri kolayca ekleyebilme esnekliği sağlar.

Flask uygulamalarını prod ortamlarda çalıştırmak için birkaç popüler araç ve teknik kullanılır.

* **Gunicorn**
* **uWSGI**
* **Gevent**
* **Twisted Web**

#### Örnek Flask Uygulaması

Aşağıda basit bir Flask uygulaması örneği bulunmaktadır:

```python
# main.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()
```

#### 1. Flask Uygulamasını Gunicorn ile Çalıştırmak

{% hint style="info" %}
Gunicorn (Green Unicorn), Python programlama dili için bir WSGI HTTP sunucusudur.
{% endhint %}

Flask uygulamasını Gunicorn ile çalıştırmak için aşağıdaki komutu kullanabilirsiniz:

```bash
gunicorn main:app
```

Bu komut, `main.py` dosyasındaki `app` adlı Flask uygulamasını Gunicorn kullanarak çalıştırır. Aşağıdaki gibi bir çıktı alırsınız:

```bash
[2020-03-10 09:53:29 +0000] [2916] [INFO] Starting gunicorn 20.0.4
[2020-03-10 09:53:29 +0000] [2916] [INFO] Listening at: http://127.0.0.1:8000 (2916)
[2020-03-10 09:53:29 +0000] [2916] [INFO] Using worker: sync
[2020-03-10 09:53:29 +0000] [2919] [INFO] Booting worker with pid: 2919
```

#### 2. uWSGI

uWSGI, Python web uygulamalarını prod ortamında çalıştırmak için kullanılan güçlü bir sunucudur. Flask uygulamasını uWSGI ile çalıştırmak için şu komutu kullanabilirsiniz:

```bash
uwsgi --http :8000 --module main:app
```

#### **3. Gevent**

Gevent, Python'da eşzamanlı uygulamalar geliştirmek için kullanılan bir kütüphanedir. Flask uygulamasını Gevent ile çalıştırmak için aşağıdaki komutu kullanabilirsiniz:

```bash
gunicorn main:app -k gevent
```

#### **4. Twisted Web**

```bash
twistd -n web --class=main.app
```


# Node.js Express App

Node.js Express App, Node.js üzerinde çalışan bir web uygulama framework'ü olan Express kullanılarak oluşturulmuş bir uygulamadır. Express, hızlı, minimalist ve esnek bir yapı sunar, bu sayede geliştiriciler HTTP sunucular ve API'lar oluşturabilirler.

Node.js uygulamalarının processlerini yönetmek için, aşağıda yer alan popüler araçları kullanabilirsiniz.

{% code title="app.js" %}

```javascript
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});
```

{% endcode %}

* **supervisord**: Bir process kontrol sistemidir. Express uygulamasını başlatmak ve izlemek için kullanılabilir. Uygulama çökse bile yeniden başlatabilir.

```bash
# 1. Supervisord Kullanım Örneği

# Kurulum
sudo apt-get install supervisor

# Konfigürasyon Dosyası (example.conf)
echo "
[program:example]
command=node /path/to/your/app.js
directory=/path/to/your/
autostart=true
autorestart=true
stderr_logfile=/var/log/example.err.log
stdout_logfile=/var/log/example.out.log
" | sudo tee /etc/supervisor/conf.d/example.conf

# Supervisord'a Konfigürasyon Eklemek
sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start example
```

***

* **forever**: Node.js uygulamalarını sürekli çalışır durumda tutmak için kullanılır. Uygulamanın sürekli izlenmesini ve yeniden başlatılmasını sağlar.

```bash
# 2. Forever Kullanım Örneği

# Kurulum
npm install -g forever

# Uygulamayı Çalıştırma
forever start /path/to/your/app.js

# Uygulamayı Durdurma
forever stop /path/to/your/app.js

# Çalışan Uygulamaları Listeleme
forever list
```

***

* **pm2**: Node.js process yöneticisi olan pm2, uygulamaları başlatmak, durdurmak ve yeniden başlatmak için kullanılır. Ayrıca uygulamaların yük dengelemesini ve otomatik yeniden başlatılmasını sağlar.

```bash
# 3. PM2 Kullanım Örneği

# Kurulum
npm install -g pm2

# Uygulamayı Çalıştırma
pm2 start /path/to/your/app.js --name "example-app"

# Uygulamayı İzleme
pm2 monit

# Uygulamayı Durdurma
pm2 stop example-app

# Uygulamayı Yeniden Başlatma
pm2 restart example-app

# PM2 ile Uygulama Konfigürasyonunu Kaydetme
pm2 save

# PM2'yi Sistem Başlangıcına Eklemek
pm2 startup
```


# Databases

* Veri tabanları, herhangi bir sistem tasarımının ana bileşenlerinden biridir. Birçok uygulama ve sistem, verilerin saklanması, işlenmesi ve geri getirilmesi için veri tabanlarına güvenir. Bu nedenle, veri tabanlarının nasıl çalıştığını anlamak, etkili ve verimli sistemler tasarlamak için kritik önem taşır.
* Sistem sorumluları (ya da DevOps mühendisleri), veri tabanlarının kurulumu ve yönetiminden sorumludur. Bu, veri tabanlarının uygun şekilde çalışmasını sağlamak, performanslarını optimize etmek ve veri güvenliğini korumak anlamına gelir.
* Uygulamalar, veri tabanlarına veri yazar (kaydetme) ve veri okur (sorgulama). Veri tabanları, uygulamaların çalışması için hayati bir rol oynar. Örneğin, bir e-ticaret uygulaması, ürün bilgilerini, müşteri siparişlerini ve kullanıcı verilerini saklamak için veri tabanını kullanır.
* Uygulamaların ve kullanıcıların veri tabanlarına nasıl bağlanacağını anlamak önemlidir. Bu, veri tabanı istemcileri veya programlama dilleri aracılığıyla veri tabanlarına erişmeyi içerir.

### SQL (Structured Query Language)

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FPCdCtYkkocqOi4Nm3cnd%2Fimage.png?alt=media&amp;token=434549be-2db5-4e81-98e6-9ecb085a6b87" alt=""><figcaption></figcaption></figure>

* SQL veritabanları, ilişkisel model üzerinde çalışır. Veriler, satırlar ve sütunlar şeklinde tablolarda organize edilir. Her tablo, belirli bir veri türüne sahip olabilir ve veriler, bu önceden tanımlanmış yapıya uymalıdır.
* Veriler üzerinde işlem yapmak için SQL dilini kullanırız. Örneğin, belirli yaşın üzerindeki kişileri listelemek için `SELECT * FROM persons WHERE AGE > 10` gibi bir sorgu yazılır.
* Genellikle dikey olarak ölçeklendirilir, yani bir sunucunun donanım kapasitesini artırarak performans artırılır.
* Örnek Veritabanları: MySQL, PostgreSQL, Microsoft SQL Server, Oracle.

### NoSQL (Not Only SQL)

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FYsp6nlOZEqmcgvTcMXA4%2Fimage.png?alt=media&amp;token=9af2d62e-08b8-414d-be3a-8c90f61cadb3" alt=""><figcaption></figcaption></figure>

* NoSQL veritabanları, yapılandırılmamış veya yarı yapılandırılmış veri türlerini saklayabilir. JSON, BSON veya XML gibi formatlarda veriler saklanır. Veri yapısı sabit değildir, bu da veri şeması üzerinde daha fazla esneklik sağlar.
* Veriler, tablolardan ziyade belgeler olarak saklanır ve bu belgeler, çeşitli anahtar-değer çiftlerinden oluşur. Örneğin, MongoDB'de veriler JSON benzeri belgeler olarak saklanır.
* Genellikle yatay olarak ölçeklendirilir. Birden fazla sunucuya yayılarak veri depolama ve işleme kapasitesi artırılabilir.
* Big Data, gerçek zamanlı analiz ve çeşitli veri türleriyle çalışma gibi durumlarda tercih edilir. NoSQL veritabanları, yüksek trafik ve esneklik gerektiren uygulamalar için idealdir.
* Örnek Veritabanları: MongoDB, Cassandra, DynamoDB, Couchbase.

### Farklılıklar ve İhtiyaçlar:

* SQL veritabanları, katı yapıya sahip, verilerin bütünlüğünü ve tutarlılığını sağlamak için daha uygundur. Bankacılık sistemleri veya muhasebe uygulamaları gibi veri bütünlüğünün kritik olduğu durumlarda SQL tercih edilir.
* NoSQL veritabanları, hızlı veri erişimi, esnek veri yapıları ve ölçeklenebilirlik sağlamak için daha uygundur. Sosyal medya uygulamaları, büyük veri işleme veya dinamik veri yapılarına sahip projeler için idealdir.
* Yatay ölçeklenebilirlik gerektiren uygulamalarda, NoSQL daha verimli olabilir. Ancak, dikey ölçeklenebilirlik yeterli olduğunda ve veri bütünlüğü kritik olduğunda SQL tercih edilir.


# MySQL

* MySQL, açık kaynaklı bir veritabanı servisidir.
* MySQL, Büyük veri kümeleriyle verimli bir şekilde çalışabilir.
* Yedekleme, geri yükleme ve veri güvenliği özellikleri sunar.
* Yapısal Sorgulama Dili (SQL) kullanan ilişkisel bir veritabanıdır.

### MySQL Edition'lar ve Türleri,

**MySQL Enterprise Edition:** MySQL Enterprise Edition, kurumsal düzeyde ihtiyaçlar için tasarlanmış ve güvenlik, yüksek kullanılabilirlik, yedekleme, denetim ve uyumluluk gibi özellikleri içeren bir sürümdür. İşletmeler için ekstra araçlar ve destek hizmetleri sunar.

**Ayrıca;**

* **MySQL Standard Edition**
* **MySQL Classic Edition**
* **MySQL Cluster CGE (Carrier Grade Edition)**
* **MySQL Embedded (OEM/ISV)**

**MySQL Community Edition:** MySQL Community Edition, MySQL'in ücretsiz ve açık kaynaklı sürümüdür. Geniş bir kullanıcı topluluğu tarafından desteklenir ve katkıda bulunulur.

#### Örnek SQL Sorguları,

```sql
-- Root kullanıcısının şifresini değiştirmek
ALTER USER 'root'@'localhost' IDENTIFIED BY 'MyNewPass4!';

-- Veritabanlarını listelemek
SHOW DATABASES;

-- Yeni bir veritabanı oluşturmak
CREATE DATABASE school;

-- Oluşturduğumuz veritabanını kullanmak
USE school;

-- Yeni bir tablo oluşturmak
CREATE TABLE persons (
    Name varchar(255),
    Age int,
    Location varchar(255)
);

-- Tabloları listelemek
SHOW TABLES;

-- Yeni bir kayıt eklemek
INSERT INTO persons values ("John Doe", 45, "New York");

-- Tablodan veri seçmek
SELECT * FROM persons;

-- Yeni bir kullanıcı oluşturmak
CREATE USER 'john'@'localhost' IDENTIFIED BY 'MyNewPass4!';

-- Belirli bir IP'den bağlanacak bir kullanıcı oluşturmak
CREATE USER 'john'@'192.168.1.10' IDENTIFIED BY 'MyNewPass4!';

-- Tüm IP'lerden bağlanabilecek bir kullanıcı oluşturmak
CREATE USER 'john'@'%' IDENTIFIED BY 'MyNewPass4!';

-- Yeni kullanıcı ile giriş yapmak
mysql -u john -pMyNewPass4!

-- Kullanıcıya belirli bir tabloda yetki vermek
GRANT SELECT ON school.persons TO 'john'@'%';

-- Kullanıcıya birden fazla yetki vermek
GRANT SELECT, UPDATE ON school.persons TO 'john'@'%';

-- Kullanıcıya belirli bir veritabanında tüm tablolarda yetki vermek
GRANT SELECT, UPDATE ON school.* TO 'john'@'%';

-- Kullanıcıya tüm veritabanlarında tüm yetkileri vermek
GRANT ALL PRIVILEGES ON *.* TO 'john'@'%';

-- Kullanıcının sahip olduğu yetkileri görmek
SHOW GRANTS FOR 'john'@'localhost';

```


# MongoDB

MongoDB, açık kaynaklı ve NoSQL türünde bir veritabanıdır. Geleneksel SQL tabanlı veritabanlarından farklı olarak, verileri tablo ve satır formatında değil, JSON document olarak saklar. Bu sayede, veri yapıları zamanla değiştirilebilir ve genişletilebilir.

#### MongoDB'nin Sürüm ve Kullanım Alanları:

* **Community:** MongoDB'nin topluluk sürümüdür. Ücretsizdir ve geliştiriciler tarafından kullanılır. Bu sürüm, temel MongoDB özelliklerini sunar ve daha çok öğrenme, geliştirme ve prototip oluşturma süreçlerinde tercih edilir.
* **Enterprise:** Kurumsal düzeyde kullanım için optimize edilmiş bir sürümdür. Bu sürümde öncelikli güvenlik, performans ve yönetim özellikleri sunulur. Kurumlar için profesyonel destek sağlar.

#### Dağıtım Seçenekleri:

* **Cloud:** MongoDB'nin bulut tabanlı sürümleri, paylaşımlı ya da izole kaynaklarla çalışabilir. İstendiğinde kolayca ölçeklenebilir ve güvenlik açısından gelişmiş özellikler sunar.
* **Server:** MongoDB'nin sunucu tabanlı sürümü, hem topluluk (community) hem de kurumsal (enterprise) sürümlerini içerir. Sunucu tabanlı dağıtımlar, daha geleneksel bir kurulum yöntemi sunar ve kurum içi veritabanı çözümleri için idealdir.

```mongodb
# MongoDB'ye bağlanmak için
mongo

# Veritabanlarını listelemek
show databases

# Bir veritabanı seçmek veya oluşturmak
use myDatabase

# Seçili veritabanındaki koleksiyonları (tabloları) listelemek
show collections

# Bir koleksiyon oluşturmak
db.createCollection("myCollection")

# Bir koleksiyona belge (document) eklemek
db.myCollection.insertOne({ name: "John Doe", age: 30, location: "New York" })

# Bir koleksiyona birden fazla belge eklemek
db.myCollection.insertMany([
  { name: "Jane Doe", age: 25, location: "Los Angeles" },
  { name: "Mark Smith", age: 40, location: "Chicago" }
])

# Tüm belgeleri listelemek (tüm verileri almak)
db.myCollection.find()

# Belirli bir kriterle belge aramak (örneğin, yaşı 30 olan kişileri bulmak)
db.myCollection.find({ age: 30 })

# Belirli alanları göstererek belge aramak (örneğin, sadece isim ve yaşı göster)
db.myCollection.find({ age: 30 }, { name: 1, age: 1, _id: 0 })

# Belgeyi güncellemek (örneğin, "John Doe" yaşını 35 olarak güncellemek)
db.myCollection.updateOne({ name: "John Doe" }, { $set: { age: 35 } })

# Belgeyi silmek (örneğin, "Jane Doe" isimli kişiyi silmek)
db.myCollection.deleteOne({ name: "Jane Doe" })

# Koleksiyonu silmek
db.myCollection.drop()

# Veritabanını silmek
db.dropDatabase()

```


# SSL & TLS

#### Symmetric Encryption:

* Symmetric encryption, yalnızca **bir** anahtarın kullanıldığı bir şifreleme yöntemidir. Bu anahtar, hem veriyi şifrelemek (encrypt) hem de şifrelenmiş veriyi çözmek (decrypt) için kullanılır.
* Symmetric encryption'da "public key" ve "private key" kavramları **yoktur**. Bunun yerine, **aynı anahtar** hem şifreleme hem de şifre çözme işlemlerinde kullanılır.
* Anahtarın güvenli bir şekilde paylaşılması ve saklanması büyük önem taşır. Anahtarın ifşa olması durumunda, tüm şifrelenmiş veri tehlikeye girebilir.

#### Asymmetric Encryption:

* Asymmetric encryption, bir çift anahtar kullanır: bir **public key** (herkese açık anahtar) ve bir **private key** (özel anahtar). Bu iki anahtar birbiriyle matematiksel olarak bağlantılıdır, ancak biriyle şifrelenen veri yalnızca diğeriyle çözülebilir.
* Veriyi şifrelemek için public key kullanılır, ve bu şifrelenmiş veri sadece ilgili private key ile çözülebilir. Benzer şekilde, private key ile şifrelenen veri, public key ile çözülebilir.
* Public key herkese dağıtılabilir, ancak private key gizli tutulmalıdır. Bu yapı, özellikle dijital imzalar ve güvenli anahtar değişimi için kullanılır.

SSH, asymmetric encryption kullanan yaygın bir protokoldür. Bir kullanıcı, sunucuya public key'ini gönderir ve Kullanıcı bu veriyi yalnızca kendisinde bulunan private key ile çözebilir.

***

#### SSL (Secure Sockets Layer):

* SSL, 1990'ların ortasında Netscape tarafından web tarayıcıları ve sunucular arasındaki iletişimi güvenli hale getirmek amacıyla geliştirildi.
* SSL, istemci (genellikle web tarayıcısı) ve sunucu arasında şifreli bir bağlantı kurar. Bu, kullanıcıların web sayfalarına güvenli bir şekilde erişmesini sağlar.
* SSL'nin birkaç sürümü vardır (SSL 2.0, SSL 3.0 vb.), ancak bu sürümler güvenlik açıkları nedeniyle artık kullanılmamaktadır.

#### TLS (Transport Layer Security):

* TLS, SSL'nin daha güvenli bir versiyonu olarak geliştirilmiştir. 1999'da, SSL'nin yerini alacak şekilde geliştirilmiştir.
* TLS, SSL ile benzer şekilde çalışır ancak daha güçlü şifreleme algoritmaları ve güvenlik özellikleri sunar. İstemci ve sunucu arasındaki veriyi şifreler ve veri bütünlüğünü sağlar.
* TLS'nin de çeşitli sürümleri vardır (TLS 1.0, TLS 1.1, TLS 1.2, TLS 1.3). Her yeni sürümde güvenlik geliştirmeleri ve performans iyileştirmeleri yapılmıştır.

#### Farkları:

* TLS, SSL'den daha güçlü şifreleme algoritmaları kullanır ve daha güncel güvenlik standartlarına sahiptir.
* SSL, artık güvenli kabul edilmeyen eski bir protokoldür ve büyük güvenlik açıklarına sahiptir. Bu nedenle, modern internet uygulamalarında SSL yerine TLS kullanılır.
* TLS, SSL'nin bir evrimidir. Teknik olarak, TLS 1.0, SSL 3.1 olarak da düşünülebilir.

#### Günümüzde:

* Web tarayıcıları ve sunucular arasında güvenli iletişim sağlamak için genellikle TLS 1.2 veya TLS 1.3 kullanılır.
* HTTPS, web sayfalarının SSL/TLS ile güvence altına alındığını gösterir. Tarayıcıda bir web sayfasının adres çubuğunda kilit simgesi gördüğünüzde, bu sayfanın SSL/TLS ile korunduğunu anlayabilirsiniz.


# YAML & JSON - JSON Path

### YAML Nedir?

**Y**AML **A**in't **M**arkup **L**anguage'in kısaltmasıdır ve JSON ya da XML gibi veri formatlarını temsil etmek için kullanılan insan tarafından okunabilir bir veri dilidir. "YAML Ain't Markup Language" ifadesi, YAML'ın bir işaret dili olmadığını vurgular. Bunun yerine, veri yapılarını tanımlamak ve saklamak için kullanılır.

* YAML, sade ve anlaşılır bir sözdizimi sunar. Genellikle JSON veya XML'den daha okunabilir ve yazması daha kolaydır.
* YAML, veri yapısını ifade etmek için girintileme (indentation) kullanır. Bu, hiyerarşileri ve iç içe geçmiş yapıları göstermek için kullanılır.
* YAML, genellikle anahtar-değer çiftlerini kullanarak veri yapılarını ifade eder.
* YAML, uygulamaların yapılandırma dosyalarını yazmak için yaygın olarak kullanılır. Örneğin, Docker, Kubernetes, Ansible gibi araçlar YAML formatını kullanır.

```yaml
# YAML'da Temel Sözdizimi ve Yapılar

# 1. Anahtar-Değer Çiftleri:
# Aşağıdaki örnek, basit bir anahtar-değer çiftlerini gösterir.
name: Onur           # 'name' anahtarının değeri 'Onur'
age: 30              # 'age' anahtarının değeri '30'
city: Istanbul       # 'city' anahtarının değeri 'Istanbul'

# 2. Array:
# Bu örnek, bir listeyi nasıl tanımlayacağınızı gösterir.
fruits:
  - Apple           # Listenin ilk elemanı 'Apple'
  - Orange          # Listenin ikinci elemanı 'Orange'
  - Banana          # Listenin üçüncü elemanı 'Banana'

# 3. Dictionaries:
# Sözlükler, iç içe geçmiş veri yapıları oluşturmak için kullanılır.
person:
  name: Onur        # 'name' anahtarının değeri 'Onur'
  age: 30           # 'age' anahtarının değeri '30'
  address:          # 'address' anahtarı, iç içe geçmiş bir sözlük içerir
    city: Istanbul  # 'city' anahtarının değeri 'Istanbul'
    zip: 34000      # 'zip' anahtarının değeri '34000'

# 4. Karmaşık Yapılar:
# Bu örnek, karmaşık yapıların ve birden fazla kişinin bilgilerini içeren bir listeyi gösterir.
employees:
  - name: John Doe  # İlk çalışanın adı 'John Doe'
    age: 25         # Yaşı '25'
    department: IT  # Departmanı 'IT'
  - name: Jane Doe  # İkinci çalışanın adı 'Jane Doe'
    age: 28         # Yaşı '28'
    department: HR  # Departmanı 'HR'

```

### JSON Nedir?

**JSON** (JavaScript Object Notation), veri alışverişi ve veri depolama için kullanılan, insan tarafından okunabilir, yaygın olarak kullanılan bir veri formatıdır. JSON, özellikle web tabanlı uygulamalarda sunucu ile istemci arasında veri iletimi için popülerdir.&#x20;

* JSON, veri yapılarını anahtar-değer çiftleri olarak temsil eder.
* JSON, birden fazla değeri bir dizi olarak saklayabilir.

**JSON Yapısı:**

JSON, iki temel yapı taşına sahiptir:

1. **Nesneler (Objects):** Anahtar-değer çiftlerinden oluşur ve `{}` süslü parantezleri içinde tanımlanır.
2. **Diziler (Arrays):** Birden fazla değeri liste olarak saklar ve `[]` köşeli parantezleri içinde tanımlanır.

```json
{
  "name": "Onur",
  "age": 30,
  "isStudent": false,
  "skills": ["Python", "JavaScript", "Docker"],
  "address": {
    "city": "Istanbul",
    "zip": "34000"
  }
}

```

* `name`, `age`, ve `isStudent` anahtarları scalar değerleri tutar (string, number, boolean).
* `skills` anahtarı bir dizi (array) tutar.
* `address` anahtarı bir nesne (object) tutar ve bu nesne içinde başka anahtar-değer çiftleri bulunur.

#### JSON Path Nedir?

**JSONPath**, JSON verileri içinde belirli veri parçalarını sorgulamak ve çekmek için kullanılan bir sorgulama dilidir. JSON veri yapılarında gezinmek ve belirli öğeleri seçmek için kullanılır.

**JSONPath'in Temel Kullanımı:**

* **(`.`):** JSON objeleri içinde belirli bir anahtarın değerine erişmek için kullanılır.
* **(`[]`):** JSON dizilerinde belirli bir indeksteki öğeye erişmek için kullanılır.
* Belirli koşullara uyan JSON öğelerini seçmek için filtreleme yapılabilir.

```json
# 1. Basit Erişim:
$.name
# Çıktı: "Onur"

# 2. Dizi Öğesine Erişim:
$.skills[0]
# Çıktı: "Python"

# 3. Nesne İçinde Erişim:
$.address.city
# Çıktı: "Istanbul"

# 4. Filtreleme (Dizi İçinde Arama):
$.skills[?(@ == 'Docker')]
# Çıktı: "Docker"

```


# Labs Resources

### Vagrant:

1. <https://github.com/Onurbolatogluu/vagrant-demo>
2. <https://app.vagrantup.com/boxes/search>
3. <https://github.com/iJackUA/awesome-vagrant>

### VirtualBox:

1. <https://onurbolatoglu.medium.com/virtualbox-network-type-7f001335c00c>


# Kubernetes: Nedir ?

Kubernetes, hem beyan temelli yapılandırmayı, hem de otomasyonu kolaylaştıran, container iş yüklerini  ve hizmetlerini yönetmek için oluşturulmuş taşınabilir ve genişletilebilir açık kaynaklı bir platformdur.&#x20;

* Container iş yüklerini yönetmek için tercih edilen en önemli container orchestration platformudur.
* İsteyen herkes tarafından ücretsiz bir şekilde kurulur.
* Tamamen moduler yapıda tasarlanmıştır. istenirse bu modüler yapı genişletilebilir.
* Her kubernetes komponenti ayrı bir major modül olarak ayrılmıştır.
* Kubernetes'den istediklerimizi declarative olarak belirtmemiz yeterlidir. Şunu yap, sonra şunu yap olarak değil de, Şunu istiyorum gibi..
* Kubernetes genel olarak ondan istediklerimizi belirtmemizi sağlıyor.

<table><thead><tr><th width="417.20226843100187">Desired State ( Deklare edilen durum )</th><th>Current State ( Mevcut durum )</th></tr></thead><tbody><tr><td>abcnet/k8s:latest isimli imajı kullan.</td><td>Belirtilen özelliklerde 10 container çalışıyor.</td></tr><tr><td>Sistem genelinde 10 container çalışacak.</td><td></td></tr><tr><td>Eğer bu servisi güncellersem her güncellemede aynı anda 2 task üzerinde yürütülecek ve her güncelleme arasında 10sn bekleyecek.</td><td></td></tr><tr><td>Dış dünyaya 80 portundan yayınlanacak.</td><td></td></tr></tbody></table>

10 yerine 9 containera düşerse kubernetes bunu otomatik olarak algılayıp düzeltecek.


# Bileşenler

Kubernetes ortamını oluşturan bir çok servis mevcuttur.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F18sFzppWTAAbSBX9Ml8Q%2F1_QWJijlj7kwd0hIYk8Wsnow.png?alt=media\&token=b4bce846-fc39-40a9-9b61-bc5e62e49bb0)

### Kube-ApiServer

Kubernetes control plane kısmının, en önemli bileşeni ve giriş noktasıdır. Tüm diğer komponent ve node bileşenlerin direkt iletişim kurduğu tek komponent.&#x20;

* Tüm iletişim api üzerinden gerçekleşir.
* Kullanıcılar kubectl komut satırı client 'ı veya rest api çağrıları arayıcılığıyla api server ile bağlantı kurabilirler.
* Biz kubernetes ile bağlantı kurmak için, api server 'a erişir, authentication işlemlerini tamamlar ve istekleri iletiriz.&#x20;
* Tüm komponentler iletişimi api server arayıcılığıyla gerçekleştirir.

### ETCd

Tüm cluster bilgisi, metadata bilgileri ve kubernetes de oluşturulan tüm objelerin bilgilerinin tutulduğu, key-value veri deposudur.

* Kubernetes çalışması için, gerekli tüm veriler burada tutulur.
* API hariç, diğer komponentler etcd ile direkt haberleşemezler. ETCd ile iletişim kurmaları gerektiğinde, kube-apiserver arayıcılığıyla yaparlar.

### Scheduler

Yeni oluşturulan, veya bir node ataması yapılmamış pod'ları izler ve üzerinde çalışacakları bir node seçer. (POD : container olarak düşünebiliriz) Pod 'un kaynak isteğini, özel gereksinimi, çeşitli parametreleri göz önünde bulundurur. Ve seçme algoritması sayesinde, pod için en uygun node hangisi olduğuna karar verir.

### Controller Manager

Mantıksal olarak, her controller ayrı bir süreçtir. Ancak karmaşıklığı azaltmak için hepsi tek bir binary olarak derlenmiştir. Ve tek bir proccess olarak çalışır. Bu controller'den bazıları şunlardır,

* Node controller
* Job controller
* Service account-Token controller
* Endpoints controller

Controller manager bileşeni, istenilen durum ile mevcut durumu gözlemlerler. API arayıcılığıyla Etcd 'de saklanan, cluster durumunu izler ve eğer mevcut durum ile istenilen durum arasında fark varsa, bu durumu oluşturan kaynakları gerektiği gibi oluşturur, günceller veya silerek bu durumu eşitler.

Control Plane dediğimiz bu kısmı master node dediğimiz sistemler üzerinde çalıştırırız. Tüm bu komponentler tek bir Linux yüklü sisteme kurulup, oradan erişilebildiği gibi, yüksek erişilebilirlik sağlaması adına birden fazla sisteme kurulabilir.

### Worker Node

Container runtime, container'dan sorumlu olan kısımdır. Kubernetes bir kaç container runtime destekler, docker-containerd-CRI-O. Worker node cluster 'a dahildir. Varsayılan olarak container engine containerd 'dir.

### Kubelet

Cluster 'da çalışan her node bir agent'dir. Pod içerisinde tanımlanan container'ların, çalıştırılmasını sağlar. Kubelet çeşitli mekanizmalar arayıclığıyla sağlanan bir dizi pod tanımı alır ve bu pod tanımda belirtilen container 'ların, çalışır durumda ve sağlıklı olmasını sağlar.

* Her worker node üzerinde bulunur.
* API server arayıcılığıyla etcd 'yi kontrol eder ve scheduler tarafından bulunduğu node üzerinde çalışması gereken pod belirtildiyse, kubelet bu pod'u bulunduğu node üzerinde yaratır.&#x20;
* ContainerD 'ye haber gönderir ve belirtilen özelliklerde container'ın, bulunduğu node üzerinde çalıştırılmasını sağlar.

### Kube-Proxy

Node'lar üzerinde ağ kurallarını yönetir. Ve bu ağ kuralları cluster 'ın içindeki veya dışındaki ağ oturumları tarafından pod'larımızla ağ iletişimine izin verir.


# Kubectl ve Versiyon

* Kubernetes semantik olarak versiyonlanır. x(major).y(minor).z(patch).
* Kubernetes sene de 3 minör versiyon yayınlar. Her minör versiyon yayınladığı tarihten itibaren 12 ay boyunca desteklenir. Kısacası 12 ay boyunca, her ay patch versiyonları yayınlanarak, hatalar ve güvenlik açıkları giderilir.
* Kubernetes yönetimi, 3 farklı şekilde yapılır. Rest API,GUI araçları,Kubectl.
* Minikube ve docker desktop 'a kubernetes cluster kurabiliriz.
* kubeadm ve kubespray gibi araçlarla kendi sanal sunucularımıza kubernetes cluster kurabiliriz.
* Amazon AWS,GCP,Azure gibi cloud servis sağlayıcılarının hazır kubernetes araçları ile kubernetes cluster kurabiliriz.

### Kubectl

* Kubectl aracı, bağlanacağı kubernetes cluster bilgilerine config dosyası arayıcılığıyla erişir.
* Config dosyası içerisinde, kubernetes cluster bağlantı bilgilerini ve oraya bağlanırken kullanmak istediğimiz kullanıcıları belirtiriz.
* Daha sonra bu bağlantı bilgileri ve kullanıcıları ve ek olarak namespace bilgilerini de, oluşturularak context'ler yaratırız.
* Kubectl varsayılan olarak $home/.kube/ altındaki config isimli dosyaya bakar. Ama bunu KUBECONFIG environment variable değerini değiştirerek güncelleyebiliriz.
* Kubectl config get-context ile mevcut çalışılan cluster bilgisini öğrenebiliriz.
* Kubectl config use-context {context name} ile, geçmek istediğimiz context 'i yazarak, farklı bir cluster 'a geçiş yapabiliriz.

```
kubectl cluster-info
# cluster hakkında bilgi verir.

kubectl --help
# komutlar ve kullanımları ile alakalı bilgi almak için kullanırız.

kubectl get pods -n kube-system
# komutun çalışmasını istediğimiz cluster namespace bilgisi belirtebiliriz.

kubectl get pods -A -o wide
# Komutların sonuna -0 wide yazarsak, daha detaylı bir çıktı alabiliriz.
# wide yerine, yaml ve json yazabiliriz.

kubectl explain pod
# Pod objesi hakkında bilgi alabiliriz. 
```

{% embed url="<https://kubernetes.io/docs/reference/generated/kubectl/kubectl-commands>" %}


# Pod

* Pod'lar kubernetes de oluşturabileceğimiz ve yönetebileceğimiz en küçük birimlerdir.
* Pod'lar bir veya daha fazla container barındırabilir. Ama çoğu durumda pod tek container barındırır.
* Her pod'un eşsiz bir ID'si bulunur.
* Her pod eşsiz bir IP adresine sahiptir.
* Aynı pod içerisindeki containerlar,  aynı node üstünde çalıştırılır ve bu containerlar birbirleriyle localhost üzerinden haberleşebilirler.

```
# Pod oluşturma
kubectl run firstpod --image nginx --restart never

# Pod hakkında bilgi almak için
kubectl describe pods firstpod

# Pod loglarına bakmak için, dilersek -f parametresi ile logları canlı izleyebiliriz.
kubectl logs firstpod 

# Pod içerisinde komut çalıştırmak
kubectl exec firstpod -- ls

# Pod içerisine bağlanmak
kubectl exec -it firstpod -- /bin/sh

# Pod silmek
kubectl delete pods firstpod
```

{% hint style="info" %}
Bir image registry belirtmezsek, kubernetes default olarak docker image registry kullanır.
{% endhint %}

* Oluşturacağımız pod 'ları yml dosyasında belirtip, pod 'dan istediğimiz özellikleri ve gereksinimlerimizi yml dosyasında belirtip, o dosyadan pod oluştururuz.

#### YML içerisinde bulunması zorunlu olan parametreler,

* api version
* kind
* metadata

**Kind, Oluşturmak istediğimiz objenin ne objesi olduğunu tanımladığımız yerdir. \[pod,service,deployment, vb] Örneğin, pod objesinin API versiyonunu öğrenmek için, "kubectl explain pods" yazıp, versiyon bilgisine ulaşabiliriz.**

**Metadata, Obje ile ilgili uniq bilgileri tanımladığımız alan. Birden çok alt başlık olabilir, name,label vb.**

**Spec, Oluşturmak istediğimiz objenin özelliklerini belirtiriz. Örneğin, container,service objelerinin özellikleri vb. Her obje tipine göre burada tanımlayacağımız bilgiler değişir.**

```
kubectl apply -f pods1.yml
# Komutu ile yml dosyasını kubernetes 'e bildirerek bu yml içerisinde belirttiklerimizi
oluşturmasını isteyebiliriz.

kubectl edit pods firstpod
# Komutu ile pod ayarlarını güncelleyebiliriz.
```

* Pod yaratılırken pod'umuz "pending" kısmında kalıyorsa, kube scheduler servisi pod'umuz için uygun bir node bulamamış olabilir.
* Cluster 'da bulunan tüm node'larda "kubelet" adında bir servis çalışır. Görevi bulunduğu node 'a atanmış görevleri tespit edip, yeni yaratılmış görev,pod vb varsa, bunu tespit edip hemen işlemlere başlar.
* İlk olarak pod tanımında girilmiş container'lara bakar, bu container'ların oluşturulacağı imajları sisteme indirmeye başlar. Eğer bir şekilde bu imajları indiremezse "err image pull" ardından, "image pull backoff" aşamasına geçer.
* Eğer böyle bir hata görürseniz, pod 'un imajı repository'den çekemediği ve bunu tekrar tekrar denediği anlamına gelir.
* Eğer imaj da sorun yoksa, kubelet servisi o node 'da bulunan container engine ile haberleşir ve ilgili container'ın oluşturulmasını sağlar. Container çalışmaya başladığında, pod running duruma geçer. Bu nokta da pod oluşturulmuş olur.

Restart Policy,

Always :  Hangi durum da container kapatılırsa kapatılsın. Kubelet bu container'ı yeniden başlatır.\
Never   :  Hiç bir durum da yeniden başlatılmaz.\
On-failure : Hata kaynaklı kapanırsa, yeniden başlatılır.

Pod 'un altında bulunan container'lar çalışmaya devam ettikçe pod running olarak devam eder. Pod işini bitirip kapandığında restart policy never durum da ise, pod yaşam döngüsü succeded olarak yaşam döngüsünü tamamlar.

Eğer Restart policy never veya on-failure olarak ayarlıysa, container'lardan biri hata verip kapanırsa, bu sefer pod 'un status kısmı failed (error) olarak işaretlenir ve yaşam döngüsünü böyle tamamlar.

Restart policy always olarak seçiliyse, container'lar hatadan dolayı da kapansa, normal bir şekilde de kapansa yeniden başlatılır. Dolayısıyla pod succeded  veya failed durumuna geçmez. Bunun yerine pod 'un içerisinde bulunan container'lar  tekrar başlatılır ve running state devam eder.

{% embed url="<https://stackoverflow.com/a/40534364>" %}

Kubernetes pod'un sürekli yeniden başlatma işini belirli bir sıklıkla yapıyorsa, bazı şeylerin ters gittiğine kanaat getirir ve pod'u "CrashLoopBackOFF" durumuna sokar.&#x20;

Crash Loop BackOff : Pod sürekli fail duruma düşüp veya farklı sebeplerden dolayı yeniden başlatılırsa, bu duruma geçer. Bu duruma geçen container aralıklarla kontrol edilir ve her geçen süre boyunca yeniden başlatma aralıkları uzar. Eğer container tekrar çökmezse running duruma geçer. Eğer halen çalışmayı bırakırsa 5 DK aralıklarla pod 'un içerisinde bulunan container yeniden başlatılmayı dener.

### SideCar Container (Çoklu container pod)

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: mc1
spec:
  volumes:
  - name: html
    emptyDir: {}
  containers:
  - name: 1st
    image: nginx
    volumeMounts:
    - name: html
      mountPath: /usr/share/nginx/html
  - name: 2nd
    image: debian
    volumeMounts:
    - name: html
      mountPath: /html
    command: ["/bin/sh", "-c"]
    args:
      - while true; do
          date >> /html/index.html;
          sleep 1;
        done
```

Kubernetes ana uygulamaya (container) bağlı ve onunla network seviyesinde izolasyon olmadan, ve gerektiği durumda aynı depolama alt yapısını kullanabilecek uygulamaları (container)ları pod içerisinde 2.container olarak çalıştırma imkanı sağlıyor.

Birlikte scale edilmesi gereken, birbirleriyle network ve storage seviyesinde erişmesi gereken container'ları(uygulamalar) aynı pod içerisinde ayrı ayrı container'lar olarak çalıştırabiliyoruz.

Aynı pod içerisinde, tanımlanmış tüm container'lar aynı worker node üzerinde oluşturulur.

Container'lar, ayrı birer ünitedir. Fakat pod'un lifecyle içerisinde yönetilir. Yani pod oluşturulunca 2 container birden oluşturulur. Pod silinince, 2 container birden silinir.

Aynı pod içerisinde bulunan container'lar arasında network lifecyle bulunmaz. Yani aynı pod içerisinde çalışan  A ve B container'ları birbirlerine localhost üzerinden ulaşabilir. Bunlar network bakımından sanki aynı sunucu üzerinde çalışan proccess'ler gibidir.

Tek bir volume yaratılarak, her 2 container'a mount edebiliriz. Böylelikle aynı dosyalar üzerinde çalışılabilir.&#x20;

Sidecar container'lar aynı IP adresine sahip olurlar.

```
# Multi Container pod kullanarak oluşturduğumuz container'lardan birinin shell'ine
bağlanmak
kubectl exec -it mc1 -c 2nd -- /bin/sh
Tek bir container olsaydı, -c ile container ismi vermemize gerek olmazdı.

# Pod içerisinde bulunan 1st container'ın loglarını inceliyoruz.
kubectl logs -f mc1 -c 1st

# Kubectl'i çalıştırdığımız sunucunun 8080'ine gelen istekleri, kubernetes
cluter içerisindeki mc1 isimli pod'un 80 portuna yönlendir diyoruz.
kubectl port-forward pod/mc1 8080:80 --address='0.0.0.0'

```

### Init Container (Multi Container)

Aynı pod içerisinde birden fazla container tanımlamak için kullanılır. Asıl uygulama container başlatılmadan önce ilk olarak init container çalışır.

İnit container yapması gereken işleri tamamlar ve kapanır.

Uygulama container, init container kapatıldıktan sonra çalışmaya başlar. Inıt container işlemleri tamamlamadan uygulama container başlamaz. Ana uygulama başlamadan önce çalışıp, eksik paketler vb varsa init container'ı bu nedenle kullanabiliriz.&#x20;

Uygulama çalışmadan önce, tamamlamamız gereken şeyler varsa, bunları tamamlamadan esas uygulamayı çalıştırmak mantıklı değilse kullanılır.&#x20;

Misal, uygulamamızın bağımlı olduğu, başka bir uygulama veya servis var. Eğer bu ayakta veya hazır değilken uygulamayı başlatırsak uygulamada sıkıntı çıkıyor. Bu durumda pod tanımına bir init container ekler ve bu init container'ın, bu servisi gözlemesi için ayar yaparız. Inıt container içerisinde, bir uygulama çalıştırılır ve bu servisten okey alana kadar bu init container çalışır. ve Okey aldıktan sonra da kapanacak şekilde ayar yapabiliriz. Bu sayede pod oluşturulduğu ilk zaman ilk olarak init container çalışır ve diğer servisi beklemeye başlar. Diğer servis hazır olduğu anda, uygulama kapanır ve init container da kapanır. init container kapatıldığı anda, esas uygulamamızın çalıştığı container ayağa kalkar. Böylece servis hazır olana kadar, uygulamamız beklemiş olur.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FiqKyhyy9FhwQtXyxYDV4%2Finit-containers.png?alt=media\&token=81b45bd2-14ba-458a-a241-a4014a023194)

Misal, ana uygulamamızın ihtiyacı olan bazı config dosyalarının, son güncel halini ana uygulama başlamadan sisteme çekilmesi gerekiyor. Bu durumda, bu çekme işini de init container ile halleder ve esas uygulama başlamadan bunları sisteme indirebiliriz. vb.

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: website
spec:
  initContainers:
    - name: clone-repo
      image: alpine/git
      command:
        - git
        - clone
        - --progress
        - https://github.com/peterj/simple-http-page.git
        - /usr/share/nginx/html
      volumeMounts:
        - name: web
          mountPath: '/usr/share/nginx/html'
  containers:
    - name: nginx
      image: nginx
      ports:
        - name: http
          containerPort: 80
      volumeMounts:
        - name: web
          mountPath: '/usr/share/nginx/html'
  volumes:
    - name: web
      emptyDir: {}

```


# Label ve Selector

Etiketler, yani tag'ler Kubernetes'de her türlü objeye atayabildiğimiz, anahtar-değer eşlenikleridir. Etiketler sayesinde, bizler oluşturduğumuz objelere atabildiğimiz ve bizlerin anlayacağı ve gruplama yaparken kullanabileceğimiz bilgiler eklemiş oluruz. Bu sayede kubernetes tarafından bizlere core özellik olarak sunulmayan objelere belirli bir aidiyet ataması gerçekleştirebiliriz. Obje oluştururken, atanabileceği gibi, obje oluşturulduktan sonra da etiketler atanabilir. Etiketler key-value şeklinde oluşturulur.

```
example.com/tier:frontend
  prefix     Key   Value
  
Prefix kısmı opsiyoneldir.
```

Kubernetes 'de objeler arası bağlantı da etiketler sayesinde kurulur. Servisler ve deployment objeleri, hangi pod'ların kendilerine ait olduğunu ve hangi pod'lar ile ilişki kuracaklarını etiketler sayesinde belirler.&#x20;

Örneğin, bir servis oluşturur ve bu servise şunu deriz; Git ve tier : frontend etiketli podları bul, ve trafiği bunlara yönlendir. vb.

Özetle, Label(etiketler) objeleri gruplama imkanı vermenin yanı sıra, Kubernetes 'de objeler arası bağ kurmak için kullandığı en temel mekanizmadır.&#x20;

{% hint style="info" %}
Bir yml dosyasında, birden çok pod tanımı yapabiliriz. Aralarında (---) olmak şartıyla.
{% endhint %}

<mark style="color:red;">Metadata kısmında, etiket tanımı yaparız. ve istediğimiz kadar bu etiket sayısını arttırabiliriz.</mark>

```
kubectl get pods -L "app"
# app etiketine sahip podları getirir. --show-label parametresini eklersek, mevcut
etiketleride gösterir.

kubectl get pods -L "app:firstapp" --show-labels
# App etiketine sahip ve firstapp değerine sahip podları getirir.

# Daha fazla etikete göre aramak için tırnak arasına , işareti koyup, 2.istediğimiz
etiketide arayabiliriz.
"app:firstapp,tier:frontend" 

"app:firstapp,tier!=frontend"
# Tier etiketi frontend değeri olmayan,değeri bul ve o podları getir.

kubectl get pods -L "app in (firstapp)" --show-label
# App anahtarına firstapp değeri olan podları getir.

"app in (firstapp,secondapp)"
# APP değeri firstapp veya secondapp olan podları listele.

"app notin (firstapp)"
# App anahtarının değeri firstapp olmayan podları listele.

"app in (firstapp),tier notin(frontend)"
# app anahtarının değeri firstapp olacak, tier etiketinin değeri frontend olmayan
podları getir.


kubectl label pods pod9 app=thirdapp
# Pod9 poduna etiket ekledik.
# Etiket güncellemelerini yml dosyasını güncelleyerek yapabiliriz.

kubectl label pods pod9 app -
# Label'i sildik.

kubectl label --overwrite pods pod9 team=teams3
# etkiketi güncelledik.

kubectl label pods -all foo:bar
# Tüm namespace altında bulunan podlara etiket eklemek için.
```

YML dosyasına gireceğimiz node selector parametresi ile bu pod'un çalışmasını istediğimiz, nodeları belirtebiliyoruz. Bunu da label arayıcılığıyla yapıyoruz.

Örneğin,

```
nodeselector:
  hddtype:ssd
```

Kube scheduler 'e şunu diyoruz, bu podu oluştururken,  hddtype:ssd değerine sahip olan bir node bul ve bu podu orada çalıştır. Bu pod objesi ile node objesini eşleştirdik. Labeller bize objeler arası ilişki kurmaya yarar dediğimiz kısım budur.

```
kubectl label nodes worker-2 hddtype:ssd
# node 'a etiket atadık

kubectl delete -f podlabel.yml
# podlabel.yml dosyasından oluşturduğumuz tüm podları siler.
```


# Annotation

* Objelere metadata eklemek için kullanabildiğimiz opsiyon olan label'lerin yanı sıra kullanabileceğimiz bir parametredir.&#x20;
* Label 'da olduğu gibi key-value eşlenikleri şeklinde metadata ekleyebildiğimiz, bir opsiyondur.
* Label'ler gruplama yaparken, ve objeler arası bağ kurmak istediğimiz durumlarda, kullanırız. Bu ilişki kurma durumundan kaynaklı label'ler hassas bilgi sınıfına girer. Yani label eklememiz, veya çıkarmamız kubernetes içerisinde bir şeyleri tetikleyebilir ve etkileyebilir. Dolayısıyla, her türlü bilgiyi label olarak metadata 'ya eklemek doğru değildir. Fakat bazı ek bilgileri, objelere eklememiz gerekebilir.

Misal, oluşturduğumuz objelere, o objenin oluşturma tarihini, kimin oluşturduğu bilgisini eklemek istersek, Bunu label ile yapmak doğru olmayacaktır. Çünkü bu bilgiyi, selector kullanarak seçme isteğimiz yok. Ayrıca bu bilgiyi herhangi bir ilişki kurmak içinde kullanmayacağız. Dolayısıyla, bunu label 'a eklemek yerine, annotation 'a eklemek daha doğru olacaktır.

Bunun dışında, annotation'lar kubernetes 'in ana komponenti olmayan fakat kubernetes ile bağlantısı olan yazılımlar tarafından, ihtiyaç duyulacak bilgilerin, yazıldığı yerdir.

Misal, firmamızın destek ekibinin çağrı kabul yazılımı mevcut,  bu çağrı kabul yazılımının kubernetes'den bilgi çekecek hale getirdik ve şöyle bir sistem kurmak istiyoruz. Bir obje de sorun oluştuğunda, bu çağrı yazılımı, bunu tespit etsin ve objenin destek sorumlusuna mail göndersin. Bu durumda o mail adresi bilgisini objenin metadata kısmına annotation olarak ekleyebiliriz ve destek yazılımı bu bilgiyi çekebilir. Bu sayede, bu insanlara mail gönderebilir.

Annotation bu ve benzeri durumlar için kullanılır. Oluşturma kuralları label'lar ile hemen hemen aynıdır.

```
example.com/notification-email:admin@example.com
  prefix        Key                 Value
  
```

<mark style="color:red;">Objeye onu tanımlayan, fakat label olarak eklememizin sakıncalı olacağı bilgileri Annotation olarak ekleyebiliriz.</mark>

* Prefix zorunlu değildir.
* Key alanı 63 karakter ve daha altı olmalıdır.
* Alfanumaratik bir karakter ile başlamalı veya bitmelidir.
* İçerisinde ( . - \_ ) gibi karakterler içerebilir.
* Value alanında, bu kurallar geçerli değildir. Alfanumaratik olmayan karakterlerde bulunabilir.

```
# kubectl kullanarak annotation oluşturmak ve silmek
kubectl annotate pods pod1 foo:bar

# silmek
kubectl annotate pods pod1 foo-
```

YML;

```
apiVersion: v1
kind: Pod
metadata:
  name: annotationpod
  annotations:
    owner: "mycat"
    notification-email: "admin@example.com"
    releasedate: "01.01.2021"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
spec:
  containers:
  - name: annotationcontainer
    image: nginx
    ports:
    - containerPort: 80
```


# Namespaces

Şöyle bir senaryo düşünelim, Misal, bi firmanın bilgi işlem sorumlusuyuz, ve firmada çalışan tüm ekiplerin ortak çalıştıkları, dosyalar barındırabilecekleri bir yapı tasarlıyoruz. 10 ayrı ekip var ve bu 10 ayrı ekibinde erişip, dosya barındırabileceği bir alt yapı kuracağız. Bu sistemi bir file server yapılandırarak kurabiliriz. Bir file server kurup, bunun altında tüm ekiplerin erişebileceği bir paylaşım alanı yaratıp, sonra tek tek kullanıcı bilgisayarlarının buraya erişmesini sağlarız. Böylece herkes dosyaları buraya koyup, buradan erişebilir. Sistemi böyle kurduğumuzda ilk etapta her şey düzgün çalışır. Hatta file server problem çıkarmadan, bu çözüm sorun çıkarmadan çalışır.  Ama birden fazla ekibin kullanacağı yapıyı, bu yaklaşım ile kurarsak, zaman içerisinde şu tarz problemler meydana gelir;

Öncelikle tüm kullanıcılar dosyalarını buraya yazdıkları için, tek bir paylaşım altında yüzlerce dosya oluşur. Ve bir zaman sonra yönetilemez hal alabilir. Bir diğer sıkıntı da, şu olur diyelim ki ben a.txt adında bir dosya oluşturdum. Başka biri de a.txt adında dosya oluşturup aynı yere atamaz. Dosyaların insanlara görünürlüğünü değiştirmek için, tek tek dosya bazından izinler yazılması gerekir.

Bu tür problemleri gidermek için, bu paylaşım altında ekip ve projeler için ayrı birer klasörler yaratırsak, tüm bu problemleri ortadan kaldırmış oluruz. Örneğin insan kaynakları için ik klasörü yaratırız. Böylece her ekibe özel bir dizin bulunur. Her ekip, kendi dizinlerinde dosyalarını barındırabilir. Bunu daha da genişletip, proje bazlı da klasörler yaratabiliriz.

Örneğin, yeni bir ürün geliştirmesi yapıyoruz. Bu ürün ile ilgili, tüm dosyaların tutulduğu ürün adında bir dizin oluşturup, ve projeye özel dosyaları burada saklayabiliriz. Bu sayede güvenlik\&erişim gibi ayarları klasör bazında yapabiliriz. Misal, şu X klasörüne Y kullanıcısı erişebilsin ancak değiştiremesin vb. Görüldüğü gibi klasörler kullanılarak binlerce dosya içerisinde kaybolmuyoruz. Klasörler bize gruplama imkanı tanır. Her kullanıcı grubu kendi dizinlerinde dosyalarını tutabilir. Dosya bazında tek tek, erişim izni, güvenlik ayarı yapmamıza gerek kalmaz. Çünkü bu ayarları klasör bazında yaparız. Ve yapılan bu ayarlamalar tüm klasör altında ki tüm dosyalar için geçerli olacaktır. Klasör bazında kotalar uygulayabiliriz.&#x20;

Kubernetes 'de namespace 'de tam olarak bu işi yapar.

* Namespace 'ler adlar için bir kapsam sağlar.
* Kaynak adlarının bir namespace içerisinde benzersiz olması gerekir.
* Namespace 'ler birbirlerinin içerisine yerleştirilemez ve her kubernetes kaynağı yalnızca bir namespace içerisinde olabilir.
* Namespace 'ler cluster kaynaklarını, birden çok kullanıcı arasında bölmenin bir yoludur.
* Kubernetes cluster'ı, örnekteki file server olarak düşünürsek, Namespace ise burada tanımladığımız klasörlerdir.
* Kubernetes altında objeleri, sanal klasörler altına oluşturabilir. Sonrasında bu sanal klasörler bazdında erişim ve kota ayarlamalarını yapabiliriz.
* Her kubernetes kurulumda varsayılan olarak 4 namespace oluşturulur.

kube-system : Kubernetes tarafından oluşturulan objelerin tutulduğu namespace 'dir.\
kube-public   : Kimliği doğrulanmamış olanlarda dahil, tüm kullanıcılar tarafından erişilmesine, ihtiyaç duyulan objelerin oluşturulabileceği yerdir.\
kube-nodel-lease : Node hard link işlemleri için gerekli özel bir namespace'dir.<br>

Kısacası kube ile başlayan namespace'ler, kubernetes tarafından oluşturulur. Cluster'ın işleyişi ile alakalı objelerin tutulduğu yerdir. Bunun yanı sıra, default adında namespace daha oluşturulur. Bizler aksini belirtmediğimiz sürece, tüm objeler default olarak burada oluşur.&#x20;

Birden fazla ekip tarafından yönetilen, birden fazla uygulamanın deploy edildiği kubernetes cluster 'ında, namespace bazında objeleri ayırmak sağlıklı olacaktır.

Namespace oluşturulurken, kubectl ve yaml dosyalarıdan yararlanabiliriz.

```
# Mevcut namespace'de çalışır.
kubectl get pods

# namespacecustom namespace 'i içerisinde bulunan podları getirir.
# -n argümanıda kullanılır.
# kubectl get pods --namespace namespacecustom

# app adında namespace oluşturmak.
kubectl create namespaces app

Namespace içerisinde bulunan objeler ile iletişim kurarken objenin namespace'ni 
belirtmemiz gerekir.

# Farklı bir namespace'de bulunan containera bağlandık.
# kubectl exec --it namepod -n development -- /bin/bash

# Mevcut komut satırı namespace değiştirme. Bu komutdan sorna tüm komutlarımız
# development namespace içerisinde çalışacak.
kubectl config set-context --current --namespace:development

# namespace silmek
kubectl delete namespace development
```

YML;

```
apiVersion: v1
kind: Namespace
metadata:
  name: hr
```

```
kubectl apply -f create-namespace.yml
```


# Deployments

Kubernetes 'de container imajına çevirdiğimiz objeleri pod olarak deploy ederiz. En temel obje pod 'dur. Genelde Kubernetes üzerinde singleton (tekil) yönetilmeyen pod 'lar yaratmayız. Pod 'ları yöneten üst seviye objeler yaratırız, pod 'lar bu objeler tarafından, yaratılıp yönetilir.&#x20;

Pod 'ları tek bir worker node üzerinde çalıştırmak, uygulama sağlığı açısından istenmeyen bir durumdur. Worker node 'a fiziksel olarak bir problem meydana geldiğinde, üzerinde bulunan pod 'lara erişim kaybolur. Ve uygulamamıza erişemeyiz.

Ayrı ayrı, yml dosyalarını kullanarak, farklı worker node üzerinde aynı imaj kullanarak pod oluşturduğumuz zaman ise, hem takip edilmesi güç, hem de manuel işlem yapmamız gerekecektir. Her worker node için ayrı bir yml dosyası oluşturup, hepsiyle ayrı ayrı ilgilenmemiz gerekecektir.

Deployment 'da istenilen durumu tanımlarız, ve deployment controller, mevcut durumu, istenilen durum ile karşılaştırıp, gerekli aksiyonları alır.

Deployment bir veya birden fazla pod 'u bizim belirlediğimiz desired(istenilen) state göre oluşturan, sonrasında bu desired state göre mevcut durum ile sürekli karşılaştırıp, gerektiği düzeltmeleri yapan obje tipidir.&#x20;

Deployment obje oluşturmak için tanımı yapar, bu tanımın içinde oluşturmak istediğimiz, pod 'un hangi özelliklere sahip olacağını ve kaç adet olacağını belirtiriz. Deployment objesi oluştuğu zaman tanımladığımız özelliklerde ve adette pod oluşturulur.

Misal, Nginx imajından 3 tane pod oluşturan deployment yaratırız. Deployment bunu desired state olarak alır ve 3 pod oluşturur. Ardından deployment controller devreye girer ve sürekli olarak bu pod 'ları gözler. Bir pod 'da sorun olduğu zaman deployment controller duruma müdahale eder, sorunlu olan pod yerine, yeni bir pod oluşturur. Böylelikle desired state ve current state eşitlenir.

Deployment objeleri kurallar dahilinde pod güncellemeleri yapmamıza da imkan sağlar. Misal Desired state 'e eski imajımız yerine güncel imajımızı yazarsak, Deployment controller istediğimiz imaja göre pod 'ları oluşturacaktır. Bu işlemi kontrollü bir şekilde yapması için, ek parametreler belirtebiliriz.  Misal, yeni imaj 'dan bir pod yarat, eski imaja sahip olan pod 'lardan birini sil ve sorun yoksa, kalan diğerlerini bu sırayla yap.

Böylelikle uygulamamızın yeni versiyonunu kesintisiz geçiş imkanı sağlıyoruz. Sorun olması halinde tek bir komut ile deployment ortamımızı bir komut ile bir önceki duruma alabiliriz.

* Imperative yöntemle Deployment oluşturma.

```
kubectl create deployment firstdeployment --image=nginx:latest --replicas=2
```

* Deployment listeleme.

```
kubectl get deployment
```

* Deployment silme.

```
kubectl delete deployment firstdeployment
```

* Deployment içerisindeki imajı güncelleme.

```
kubectl set image deployment/firstdeployment nginx=httpd:alpine
```

* Deployment replika sayısını değiştirme "Scaling"

```
kubectl scale deployment firstdeployment --replicas=5
```

* Deployment yapılan son değişikliğin geri alınması.

```
kubectl rollout undo deployment firstdeployment
```

* Deployment yapılan değişikliklerin kaydının tutulması için "--record" opsiyonu kullanılır.

```
kubectl set image deployment rolldeployment nginx=httpd:alpine --record=true 
```

* Deployment yapılan değişikliklerin listelenmesi.

```
kubectl rollout history deployment rolldeployment
```

* Deployment yapılan değişikliklerin izlenmesi.

```
kubectl rollout status deployment rolldeployment 
```

* Deployment üstünde yapılan değişikliklerin durdurulması.

```
kubectl rollout pause deployment rolldeployment
```

* Durdurulan rollout'un devam ettirilmesi.

```
kubectl rollout resume deployment rolldeployment
```

* YAML ile deployment oluşturmak;

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: firstdeployment2
  labels:
    team: development
spec:
  replicas: 3
  selector:
    matchLabels:
      app: front-end
  template:
    metadata:
        labels:
          app: front-end
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
```

```
kubectl apply -f deploymentcreate.yml
```

* template argümanı altında oluşturmak istediğimiz pod özelliklerini gireriz.
* selector argümanı girerek şunu söylemiş oluyoruz;
  * Deployment, senin yönetebileceğin pod 'lar, app:front-end etiketine sahip olacak, Bu etiketi görürsen anla ki, bu pod 'lar sana ait.
* Selector ve template altında olan label tanımları mutlaka her deployment obje oluştururken bulunmalıdır. Birden fazla deployment bulunan ortamlarda farklı  farklı label kullanılması karışıklık yaşanmaması için önemlidir.
* Label 'ların objeye özel uniq olması çok önemlidir. Farklı farklı obje 'lerde aynı label tanımının olması karışıklığa yol açacaktır.


# ReplicaSet

Bir ReplicaSet 'in amacı, herhangi bir zaman da, çalışan kararlı bir replica pod setini sürdürmektir. Bu nedenle, belirli sayıda özdeş pod 'un, kullanabilirliğini garanti etmek için kullanılır.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FiG3eLKPi2tR3L8nce1G8%2F8bc2c7ec-a1de-4eb5-b188-6c05d7e80e26.webp?alt=media\&token=2d733328-f19d-464b-83c0-38920bb6d8c0)

Kubernetes 'de belirtilen, template 'deki bilgilere göre X sayıda pod oluşturan, sonrasında mevcut durum ile, istenilen durum arasında fark oluşursa bunu çözen, bu gibi işleri halleden obje Deployment değildir.

ReplicaSet adında bir obje daha mevcuttur. Bu işlerin tamamını ReplicaSet objesi yapar. Biz bir Deployment objesi oluşturduğumuz zaman, bu deployment template altında belirlediğimiz özelliklerde, ReplicaSet objesi oluşturulur. Pod 'lar bu ReplicaSet objesi tarafınan oluşturulur.

Kubernetes ilk çıktığı zaman, replica controller adında bir obje tipi vardı (halen var, aktif olarak yoğun kullanılmasa da) Replication controller birden fazla sayıda aynı tip 'de Pod oluşturmak için kullanılıyordu. Fakat deploy ettiği pod 'lar ile ilgili değişiklik yapmak istediğimiz zaman bazı sıkıntılar çıkarıyordu. Bu sıkıntıları çözmek için, şöyle bir yola gidildi, Replica Controller 'ın sağladığı özellikler  Deployment ve ReplicaSet adında 2 objeye ayrıldı.&#x20;

ReplicaSet objesinin temel görevi, belirlediğimiz özelliklere göre, belirlediğimiz sayıda pod oluşturmak ve bunu desired state 'de kalmasını sağlamak.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FjaXCogcPXqSjFfuRYyK3%2F07751442-deployment.png?alt=media\&token=3372c08b-952e-40fc-9ee1-8ff766691fae)

Deployment objesi, ReplicaSet 'in bir üst seviye objesi olarak dizayn edilmiştir. Ve pod tanımında bir güncelleme yaparsak, Bu güncellemenin, belirlediğimiz kurallara bağlı kalarak ve sırayla uygulanmasını sağlamak gibi düzenli, kesintisiz geçiş yapma imkanı sağlar.

Özetle biz bir deployment objesi oluşturduğumuz zaman, Bu deployment objesi, kendi yönettiği bir ReplicaSet objesi oluşturur ve bu ReplicaSet objesi de pod 'ları yaratır ve yönetir.

Biz deployment objesi tanımında bir değişiklik yaparsak, misal imaj güncellemesi gibi.. Bu yeni tanımla yeni bir ReplicaSet objesi daha yaratılır. İlk yaratılan ReplicaSet objesi yavaş, yavaş kendi oluşturduğu pod 'ları silmeye başlar. Yeni ReplicaSet 'de, yeni pod 'ları oluşturmaya başlar.

Silme, oluşturma vb işlemlerin hangi sırayla olacağını ve ne şekilde olacağını biz belirleyebiliriz. Bu bize bir kesinti olmadan, uygulama güncelleme ve yeni versiyon geçiş yapma imkanı sağlar.&#x20;

Deployment objesi içerisinde tanımladığımız pod 'ları, ReplicaSet yaratır ve yönetir.

* Deployment objesi, pod güncellemeri, imaj güncellemelerini kolayca yapılmasına imkan sağlar. Bu nedenle biz direkt ReplicaSet oluşturmayız, onun yerine daha çok özellik sağlayan Deployment objesinden faydalanırız.
* ReplicaSet objesini manuel olarak kendimiz oluşturursak, bu tarz güncellemeri (imaj vb) manuel olarak yapmamız gerekir. Bu yüzden Deployment objesini oluştururuz, Deployment objesi ReplicaSet objesini oluşturur, ReplicaSet 'de pod 'ları yaratır.
* Bir değişiklik yaptığımız zaman, deployment objesi tüm otomasyonu bizim adımıza sağlar.
* Fakat dilersek biz ReplicaSet objesini kendimiz de oluşturabiliriz. ReplicaSet ve Deployment objesi oluştururken kullandığımız YAML dosyası içeriği bire bir aynıdır. kind kısmında sadece obje isimleri değişiktir.

Tekrarlamak gerekirse, ReplicaSet bize rollout, undo, vb özellikleri sunmadığı için, Deployment objesini kullanmak bir hayli mantıklı bir seçenektir. Deployment objesi oluşturduğumuz zaman zaten kendisi ReplicaSet 'i otomatik olarak oluşturacaktır.

ReplicaSet objesi oluştururken kullandığımız dosyada misal bir imaj güncellemesi/değişikliği yaparsak ve tekrardan yaml dosyasını apply edersek, bir değişiklik olmayacaktır. ReplicaSet bu tarz değişiklikleri mevcut pod 'lara uygulamaz. Ancak yeni bir pod yaratılacaksa o zaman bu pod 'ları güncel imaj 'dan yaratır. Bu nedenle direkt ReplicaSet yaratmıyor Deployment objesi kullanıyoruz.

Örnek bir ReplicaSet oluşturmak için kullanılan YML içeriği;

```yaml
apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: web
  labels:
	env: dev
	role: web
spec:
  replicas: 4
  selector:
	matchLabels:
  	  role: web
  template:
	metadata:
  	  labels:
    	    role: web
	spec:
  	  containers:
  	  - name: nginx
    	    image: nginx

```


# Rollout & Rollback

Deployment yaml dosyalarımızda spec altında, strategy argümanı ile bizler, bu Deployment 'ı güncellediğimiz zaman, rollout işlemlerinin nasıl yapılabileceğini belirleriz. Kullanabileceğimiz 2 tip rollout tipi mevcuttur.

1-Recreate : Deployment 'da bir değişiklik yaptığımızda, öncelikle tüm mevcut pod 'ları siler ve ardından yeni podları oluşturur. Genellikle, uygulamanın, yeni versiyonu ve eski versiyonunun kısa bir süre için bile olsa, bir arada çalışmaması için kullanılır.

2-RollingUpdate : Bu seçenek DEFAULT olarak gelir. Yaml dosyamızda herhangi bir değişiklik yaptığımız zaman, gidip tüm podları silip yenisi oluşturmak yerine, bu işi aşamalı olarak yapar. Bu aşamaların nasıl olacağını belirlediğimiz 2 opsiyonumuz mevcut.

2a : MaxUnavailable : Deployment 'da değişiklik yapıldığında, en fazla burada belirttiğim miktarda pod silinir. Misal 10 pod'lu ortamlarlarda, bir güncelleme yaptığımızı varsayalım. Bir güncelleme yaptığımızda bu güncellemeye başladığı anda, en fazla 2 tanesini siler. sonra yeni podları oluşturur. Ardından 2 eski pod daha siler. Yeni 2 pod daha oluşturur. gibi. Döngü bu şekilde devam eder. Pod sayımız 8 'in altına düşmez.

2b : MaxSurge : Güncelleme sırasında toplam pod sayısının en fazla kaç olacağını belirler. Misal bizim desired state 'imiz 10 pod ama, bu geçiş sırasında 12 pod 'a kadar çıkabilir. Deployment 'ı güncellediğimiz de, kubernetes yeni bir replicaset oluşturacak, yeni tanımda 2 pod ayağa kalkacak, dolayısıyla  eski 10 pod + 2 yeni pod toplamda 12 pod olacak. Sonrasında eski pod'lardan 2 tane silinecek ve ardından yeni replicaset 2 pod daha yaratarak, döngü devam edecek. Toplam pod sayısı 12 'yi geçmeyecek ve 8 'in altına düşmeyecek. Bir değer girmezsek MaxSurge ve Maxunavailable %25 olarak çalışır.

<mark style="color:red;">Deployment objesini düzenlerken "kubectl edit" komutunu da kullanabiliriz.</mark>

\--record  : kullandığımız komutların ardına --record  parametresi eklersek, tüm yapılan işlemleri bir history 'de tutar.

Komutunu kullanarak deployment 'da yaşanan tüm değişiklikleri görebiliriz.

```
kubectl rollout history deployment rolldeployment
```

Liste de bulunan 2. değişikliğin detaylarını göster diyoruz.

```
kubectl rollout history deployment rolldeployment --revision=2
```

Bir önceki değişikliğe dönmek için kullanırız.

```
kubectl rollout undo deployment rolldeployment
```

Deployment 'da yapılan 1. değişikliğe döner. Bir öncekine dönmekle sınırlı değiliz.

```
kubectl rollout undo deployment rolldeployment --to-revision=1
```

Bu sayede deployment üzerinde yaptığımız değişiklikler, kataloglama ve sonrasında geri dönme imkanına kavuşuruz.&#x20;

Bir deployment oluşturur oluşturmaz hangi aşamalardan geçtiğini görmek için,

```
kubectl rollout status rolldeployment -w
```

Deployment ortamında bir güncelleme yapıp, bir sorun gözlemlediğimizde durdurmak istersek;

```
kubectl rollout pause deployment rolldeployment
```

Eğer sorunu tespit edip, giderdikten sonra kaldığı yerden devam etmek istersek,

```
kubectl rollout resume deployment rolldeployment
```


# Networking - 1

Kubernetes kurulumunda pod'lara IP dağıtılması için, bir IP adres aralığı, yada Kubernetes terminolojisinde bilinen adıyla --pod-network-cidr belirlenir. Kubernetes de her pod, bu CIDR bloğundan atacanacak eşsiz IP adresine sahip olur. Aynı cluster içerisindeki tüm pod'lar, Varsayılan olarak, birbirleriyle herhangi bir kısıtlama olmadan ve NAT olmadan haberleşir.

CNI projesi Linux container 'larda, Ağ arabirimlerini yapılandırmak için, Eklentiler yazılabilmesini sağlayan kuralları belirler. CNI yalnızca container 'ların Ağ bağlantısıyla ve container 'lar silindiğinde ayrılan kaynakların kaldırılmasıyla ilgilenir. Bu odak nedeniyle CNI geniş bir desteğe sahiptir.

CNI çözümlerine uygun, yapacağımız işe göre uygun bir plugin seçip, Kubernetes cluster 'ımızda kullanabiliriz. Bu, Worker node 'lar üzerinde bulunan pod 'ların birbirleriyle haberleşmesi ve Cluster network alt yapısının düzgün çalışabilmesi için zorunluluktur.

Bu driver (plugin)ler ortama uygun seçilmelidir. Özetle, Kubernetes ağ altyapımızın düzgün çalışabilmesi, pod 'ların ve diğer komponentlerin birbirleriyle sağlıklı haberleşebilmesi için CNI standartlarına uygun bir plugin seçmeliyiz. Kubernetes burada bize bir plugin sunmaz, sadece standartları belirler.

CNI plugin 'i cluster 'da bulunan node'lara yükleyerek, Kubernetes 'in, bu network yönetimini yüklediğimiz plugin'e devretmesini sağlayabiliyoruz.&#x20;

Örneğin Calico kullandığımızı düşünelim. Bu noktadan itibaren, Pod 'ların, IP adreslerinin atanmasını, IPtables kurallarının oluşturulması ve düzenlenmesi, Node 'lar arası POD cidr bloğunun nat 'siz çalışması için gereken, overlay tanımlarını yaparak, Kubernetes ağ alt yapısının düzgün çalışması için uygulanan tüm görevler calico driver tarafından halledilir.

Kubernetes 'de bir pod oluşturduğumuz zaman, scheduler bu pod'un çalışacağı node 'u seçer. Ve kubelet burada devreye girerek pod 'u oluşturur. Pod için atanacak IP adresinin belirlenmesi, bunun pod 'a atanması, ve alt yapı da ayarlanması gereken tüm işlerin halledilmesi işi ise, seçtiğimiz plugin olan calico tarafından sağlanır. Böylece pod 'lar farklı node üzerinde olsalar bile, birbirleriyle haberleşebilirler. Kubernetes de pod'ların birbirleriyle haberleşmeleri ve dış dünya ile haberleşmeleri , yani igress trafiği bu pluginler sayesinde gerçekleşir.&#x20;


# Service

* Bir dizi pod üzerinde çalışan uygulamayı, ağ hizmeti olarak göstermenin soyut bir yoludur.
* Kubernetes ile, uygulamanızı tanıdık olmayan, bir hizmet bulma mekanizması kullanılacak şekilde, değiştirmeniz gerekmez. Kubernetes pod 'lara, kendi IP adreslerini ve bir dizi pod için, tek bir DNS adı verir. Ve bunlar aralarında yük dengeleyebilir.

4 Tip Service Mevcuttur.

### ClusterIP

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FnsQuhEikLtTC0RfC89fj%2F1_a8lwtd3acs-hiiotbcdf2q.png?alt=media\&token=bd854294-35a7-4395-87ea-942eb476ab9f)

ClusterIP tipinde, service objesi yaratıp, bunu label selector arayıcılığıyla pod 'lar ile ilişkilendirebiliriz. Bu objeyi yarattığımız zaman, bu obje cluster içerisindeki tüm pod 'ların ve kaynakların çözebileceği uniq bir dns ismine sahip olur.

Bunun yanında, bizler her kubernetes kurulumunda  --service-cluster-ip-range ile sanal IP bloğu belirleriz. Misal 10.100.0.0/16

Cluster IP service objesi, yarattığımız zaman, bu objeye, bu IP bloğundan bir sanal IP adresi, Cluster 'ın DNS mekanizmasın da kaydedilir.

Bu IP adresi, Virtual bir IP adresidir. herhangi bir interface 'e map edilmez. kube-proxy servisi tarafından tüm node 'lardaki IPTable 'lara eklenir ve buraya ulaşan trafik, servisin ilişkili olduğu pod 'lara round-robin algoritmasıyla yönlendirilir. Yani Cluster içerisinden, Bu IP adresine gönderilen paketler, bu service ile ilişkilendirilmiş pod 'lardan bir tanesine yönlendirilir.

Şöyle bir senaryo düşünelim, Frontend ve Backend deployment adlarında 2 farklı deployment'ımız var. Ancak frontend altındaki pod 'lar, Backend altındaki podları tanımıyor. bilmiyor.

Bu durumda,

Backend pod 'lar ile ilişki kuracak, backend isimli bir servis yaratıp, Frontend'lere de backend pod 'lara ulaşmak istediğinde, gitmek gereken adres, backend isimli servis(adres) dersem, şu olur. Cluster içerisindeki herhangi bir pod, backend ismini çözmek istediğinde, ona cevap olarak, bu backend servisinin IP adresi döner. Pod o IP adresine ulaşmak istediğinde de, trafik backend pod'lardan birine yönlendirilir.

{% hint style="info" %}
Farklı namespace 'lerden bu service erişmek istenirse, tam isminin yazılması&#x20;

gerekmektedir. Aynı namespace içerisinde bu gerekli değildir.
{% endhint %}

Dolayısıyla tek tek frontend ' pod 'lara bağlanıp, her seferinde yeni eklenen pod 'ların IP adreslerini belirtmemiz gerekmez. Sadece gitmek istediğim yer backend deriz, O trafiği arkada bulunan backend servisine gönderir. Gerisini cluster halleder.  Yeni eklenen pod'lar otomatik olarak bu service altına eklenir. Çıkarılan/Silinen pod'lar otomatik olarak bu servisten çıkarılır.

ClusterIP kubernetes altında, basit de olsa service discovery ve Load Balancing hizmetleri sunan obje tipidir. Böylece cluster içerisinde Frontend-Backend bağlantı sorunlarını çözdük.

```yaml
apiVersion: v1
kind: Service
metadata:
  name: backend
spec:
  type: ClusterIP
  selector:
    app: backend
  ports:
    - protocol: TCP
      port: 5000
      targetPort: 5000
```

### NodePort

2.sorun, frontend pod'lara dışarıdan erişilmesi gerekiyor.

Bu sorunu, nodeport service objesi ile çözeriz. Aynı cluster IP service objesi gibi, nodeport 'da service obje tipidir.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F1d9Hmh0mp1V4MBna7qRr%2F1_vE8I8ee8JBPrM54DksA8cA.png?alt=media\&token=09b934ca-9154-45d6-93a4-730662d8c5c2)

Biz bir nodeport service objesi yaratır. Bunu label selector sayesinde, ihtiyacımız olan pod 'lar ile ilişkilendirebiliriz.

Bu obje yaratıldığı zaman şu olur, 30000-32767 arasında bir port seçilir ve tüm worker node 'larda bu port bizim frontend deployment 'mıza proxy edilir. Ve dışarıdan bu servisi oluşturduğumuz anda bizim uygulamamız için tanımladığı port üzerinden erişebiliriz. Kısacası, worker node 'un, IP adresinin, bu portuna gelen paketler, ilişkilendirdiğimiz pod 'ların publish ettiğimiz portlarına yönlendirilir. Bizlerde worker node 'ların, önüne bir Reverse Proxy veya Load Balancer koyarak, dış dünyadan erişilmesini sağlayabiliriz.  Buraya ulaşacak paketler, worker node'lara, worker node'lara ulaşan paketlerde pod 'lardan birine ulaşarak kullanıcıların uygulamamıza gelmesini sağlayabiliriz.

```yaml
apiVersion: v1
kind: Service
metadata:
  name: frontend
spec:
  type: NodePort
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
```

### Load Balancer

Load Balancer tipi service objelerini, sadece cloud service sağlayıcılar kullandığımızda kullanabiliriz.   Load balancer tipi bir service oluşturduğumuzda, cloud service sağlayıcı, dış dünyadan erişilebilecek bir public IP adresine sahip, bir LB oluşturur, sonrasında bu LB bizim service  objesine ilişkilendirilir. Dolayısıyla bu public adrese ulaşan paketler içeriden pod 'lara yönlendirilir.

```yaml
apiVersion: v1
kind: Service
metadata:
  name: frontendlb
spec:
  type: LoadBalancer
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
```

NodePort ile uygulamızın önüne bir LB ve Proxy koymaktan bahsetmiştik. Cloud service sağlayıcıları bunu otomatik sağlıyor. Buna da Load Balancer Service obje diyoruz.&#x20;

Biz bir servis oluşturduğumuz zaman, bu servis endpoint adında bir obje oluşturur. Ve bu endpoint objesi, bizim belirlediğimiz selector tarafından seçilen pod 'ların, IP adreslerini üstünde barındırır. Service trafiği nereye yönlendireceğini bu listeye göre düzenler Bu liste dinamiktir, pod sildiğimizde o pod bu listeden IP adresi silinir. Yeni pod oluşturduğumuz da o pod 'un IP adresi bu listeye eklenir.

{% embed url="<https://mvallim.github.io/kubernetes-under-the-hood/documentation/kube-metallb.html>" %}
\
BareMetal sunucularda çalışan clusterlarınızda MetalLB kullanabilirsiniz.
{% endembed %}

## **ExternalName** <a href="#b7e0" id="b7e0"></a>

ExternalName türü ile tanımlanan bir Kubernetes Service’i önceki türlerde olduğu gibi selector kullanmak yerine DNS adını kullanacaktır. Bu türde, önceki türlerde olan proxy ya da forward işlemleri kullanılmamaktadır. Yönlendirme işlemi DNS seviyesinde gerçekleşmektedir.

```
Service objelerinin listelenmesi

kubectl get service


Bir deployment'in expose edilmesi "imperative olarak service objesinin oluşturulması"

kubectl expose deployment "deployment_ismi" --type="service_tipi" --name="servis_ismi"

Ör: kubectl expose deployment backend --type=ClusterIP --name=backend


Service objelerinin silinmesi

kubectl delete service "servis_ismi"

Ör: kubectl delete service backend
```


# Liveness Probe & Readiness Probe

### Liveness Probe

Bazı durumlarda, container içerisinde başlatılan uygulama process çalışıyor olsa da, aslında yapması gereken işi yapmıyor olabilir.&#x20;

Örneğin, bir web sayfası yayınlayan podumuz var. İçerisinde httpd tabanlı bir container çalışıyor. Bu pod başlayınca, container içinde ki, httpd deamon ayağa kalkıyor ve web sitemizi sunmaya başlıyor. Fakat bir zaman sonra bu servis takılmaya başlıyor. Bir hatadan dolayı sayfaları sunmaya devam edemiyor. Ama httpd uygulaması, yani servis ayakta. Servis kapanmadı yada çökmedi. Ama esas yapması gereken iş olan, web sitemizi sunma işini yapmıyor.

Bu ve benzeri durumları yaşadığımız zaman ortamda şöyle bir sıkıntı oluşuyor. Eğer uygulama çalışmıyor olsa, yani uygulama kapansa, kubelet bunu tespit ederek, containerı yeniden başlatarak sorunu çözüyor.

Fakat uygulama ayakta olmasına rağmen, yapması gereken işi yapmıyorsa, kubelet bunu, tespit edemiyor. Dolayısıyla containerı yeniden başlatarak, sorunu çözme mekanizması çalışmıyor. Bu problemi Liveness proble ile çözebiliriz.

* Kubelet bir containerın, ne zaman yeniden başlatılacağını bilmek için, Liveness probe kullanır.

Örneğin, Liveness Probe bir uygulamanın çalıştığı ancak ilerleme sağlayamadığı, bir kitlenmeyi yakalayabilir. Böyle bir durumda bir containerı yeniden başlatmak, hatalara rağmen uygulamayı, daha kullanılabilir hale getirmeye yardımcı olabilir.

Liveness probe ile biz container içerisinde, bir komut çalıştırarak, ya da http endpointe istek göndererek ya da bir porta tcp connection açarak uygulamanın doğru çalışıp, çalışmadığını kontrol etme imkanına sahip oluyoruz.&#x20;

Bu sorgulamaların sonucunda, beklediğimiz sonucu alırsak, containerın sağlıklı olduğunu, Eğer cevap beklediğimiz gibi değilse containerın problemli olduğunu tespit edebiliyoruz. Kubelet bu sorgu sonucuna göre aksiyon alabiliyor. Liveness probe tanımlamaları yaml içerisinde LivenessProbe:  parametresi altında tanımlanıyor.

Kullanabileceğimiz 3 Tip Probe mevcut;

1 - httpGet

```yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: liveness-http
spec:
  containers:
  - name: liveness
    image: k8s.gcr.io/liveness
    args:
    - /server
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
        httpHeaders:
        - name: Custom-Header
          value: Awesome
      initialDelaySeconds: 3
      periodSeconds: 3
```

Bu probe seçtiğimizde, şunu diyoruz. Localhost 'a "path" parametresi altında belirlediğimiz path'e, "Port" Parametresinde belirlediğimiz porta httpGet isteği gönder. Cevap olarak,  200-400 arasında bir cevap kodu dönerse, yani cevap alabilirse işler yolundadır. Aksi bir cevap dönerse, hata olduğunu anlayıp, containerı restart et. İsteğimize custom bir http headerı ekleyebiliriz.

InıtıalDelaySeconds ve PeriodSeconds parametreleri, şu işe yarıyor; Bir pod oluşturduğumuzda, container çalışır fakat container içerisindeki, uygulama hemen ayağa kalkmayabilir. Ön hazırlıkları yapması gerekebilir. Bir yerden dosya çekmesi gerekebilir. kısacası uygulama container çalıştıktan sonra, hemen hizmet vermeyebilir. Eğer Liveness probe hemen başlatırsak, daha henüz uygulama hazır olmadığı için hata alacaktır. Ve hemen container restart edilecektir. Dolayısıyla daha tam anlamıyla hizmet sunmadan fail edecek ve sürekli restart olacaktır.

Bunu önlemek adına, initialDelaySeconds parametresini kullanıyoruz. Ve liveness probe 'a şunu diyoruz. Container başladıktan sonra, burada belirttiğimiz süre sonuna kadar bekle ardından sağlık kontrolüne başla.&#x20;

PeriodSeconds ile, bu sağlık kontrolünün kaç saniye aralıklarla yapılacağını belirtiyoruz. Yani container başladı, initialdelaySeconds süresi boyunca bekledi, ardından httpget ile liveness check yapmaya başladı. 1. sorgusunu yaptı cevap olumlu, 2. sorguyu göndermeden Periodseconds da belirlediğimiz süre boyunca bekledi, sonrasında tekrar sorgu yaptı. Bu döngü bu şekilde devam edecek. Sorgular arası kaçar saniye beklemesini istiyorsak, periodSeconds parametresi ile belirtiyoruz.

2 - Exec (Komut yürütme)

```yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: liveness-exec
spec:
  containers:
  - name: liveness
    image: k8s.gcr.io/busybox
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5
```

HTTP uygulamalarımızı httpget ile kontrol edebiliyoruz. Ancak uygulamalarımız http uygulaması değilse, bir konsol uygulaması vb. ise. Bunu httpget ile sorgulamamız mümkün değil.&#x20;

Bunun yerine, bir script yazar, o script içerisinde uygulamamıza uygu sorgulama neyse, misal bir dosyanın olup, olmadığını kontrol edebiliriz. Ya da bir başka process 'in çalışıp, çalışmadığını kontrol edebiliriz. Uygulamamıza uygun sağlık kontrolünü seçeriz.

Liveness Probe altında httpGet dışında kullanabileceğimiz probe olan EXEC bize bu imkanı verir. Exec ile shell 'de, komut yada uygulama çalıştırırız. Bu uygulama(komut) bize 0 kodu dönerse, yani olumlu bir cevap verirse, sağlıklı olduğunu anlar. Bunun dışında bir cevap dönerse, problemli olarak işaretler ve container 'ı restart eder. Yukarıda ki örnekte exec probe ile bir komut çalıştırıyoruz. cat komutu ile /tmp/healty dosyasını kontrol ediyoruz. Eğer, tmp dizininde böyle bir dosya varsa, bize bu komutun sonucu 0 dönecektir ve olumlu olacaktır. Böyle bir dosya yoksa, exit code 1 olacak. Yani burada bir dosyanın olup, olmadığını kontrol ederek, uygulamanın sağlıklı çalışıp, çalışmadığını kontrol ediyoruz.

3 - TCPSocket

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: goproxy
  labels:
    app: goproxy
spec:
  containers:
  - name: goproxy
    image: k8s.gcr.io/goproxy:0.1
    ports:
    - containerPort: 8080
    livenessProbe:
      tcpSocket:
        port: 8080
      initialDelaySeconds: 15
      periodSeconds: 20
```

Bazen httpget isteği ve komut çalıştırmak, bir şeyin sağlıklı olup, olmadığını anlamamıza yardımcı olmaz.

Misal bir mySQL veritabanı container çalıştırıyoruz. mysql process 3306 portundan erişilebilir. Biz de TCPSocket ile bu porta bir istek gönderip, eğer cevap alırsak uygulamanın düzgün çalıştığını varsayabiliriz. Olumsuz cevap alırsak, porta erişemezsek container restart edilecek.

### Readiness Probe

Senaryo ;

3 frontend podumuzu oluşturacak bir deploymentımız, bu podlara dış dünyadan erişilebilmesini sağlayacak Load Balancer tipi bir service mevcut. Biz tüm bunları yaml dosyası arayıcılığıyla oluşturduk ve apply ettik. Ve ortamımız çalışmaya başladı. Load Balancer IP adresi üzerinden kullanıcılar bu frontend podlarımıza erişip, web sitemize gelebiliyorlar.

Şimdi gelin deployment objesinde güncelleme yapalım. Diyelim ki, web sitemizin bulunduğu imajı güncelledik ve deploymentımızı yeniden apply ettik. rolling-update stratejisi ile, podlar sırayla devreden çıkarlıp, yeni podlar devreye alındı.

Burada olanları yakından inceleyelim;

Deployment da yeni bir imaj atadığımız zaman kubernetes hemen bu güncel imaj ile pod oluşturarak, bu yeni podları Load Balancer servisine dahil edecek.

Yani oluşturulup, başlatıldığı anda dış dünyadan bu podlara erişilebilinir olacak. Ya bizim uygulamamız ilk başladığı anda, bir yerlere bağlanıp, bazı dosyaları çekiyor ve sonrasında web sitemizi sunmaya başlıyorsa, Yada başka bir nedenden dolayı container başlatılır, başlatılmaz bu uygulama hizmet veremiyorsa,  aradan belirli bir zaman geçip, bazı işlemler yapması gerekiyorsa, Eğer durum bu ise, bu podları oluşturulduğumuz anda, bu podlar LoadBalancer servisinden trafik almaya başladığı için problem çıkacaktır.

Yani pod ayakta içindeki uygulama çalışıyor ancak, web sitemizi sunmaya hazır değil. Dolayısıyla bu pod, LoadBalancer servisine eklenmek için hazır değil. Peki bu pod 'un Load Balancer servisinden trafik almaya hazır olduğunu nasıl anlayacağız? Burada da, yardımımıza Readiness probe yetişiyor.

Kubelet, bir containerın trafiği kabul etmeye hazır olduğunu bilmek için, readiness probeları kullanır. Bir pod, tüm containerlar hazır olduğunda, hazır kabul edilir. Readiness probe sayesinde, bir pod hazır olana kadar, service arkasına eklenmez.

Readiness probelar, aynen liveness probelar gibi oluşturulur. httpGet, Exec, TCPSocket olarak kurgulanabilir.

Biz bir readiness check tanımlarız. Eğer bu readiness check olumlu sonuç dönüyorsa, Pod Service altına eklenir ve trafik alır. Eğer readiness check fail ediyorsa, bu pod service 'den çıkarılır.

Örneğimize dönersek, yeni imajı tanımladık ve yeni podlar oluşturuldu. Podlar çalışmaya başladı. Ama bu noktada load balancer service altına hemen eklenmedi. Podlar içerisinde readiness check mekanizması çalışmaya başladı initialdelayseconds süresi kadar  bekledi, sonra tanımladığımız probe ile kontrolünü yaptı. Olumlu cevap aldığı anda, bu pod service arkasına eklenir ve trafik almaya başlar.

Readiness Check periodSeconds ile belirlenen süre kadar, sürede bir bu kontrolünü yapmaya devam eder. Fail edene kadar service arkasında trafik alır. Eğer fail ederse, pod service endpoint listesinden çıkarılır.&#x20;

Eski podları direkt kapatmak yerine, kullanıcılara hata göstermemek için. Bir pod terminate edileceği zaman. Bu poda yeni trafik gelmemesi için pod service arkasından çıkarılır. Service ile bağlantısı kesilir. Böylece trafik almaz. Fakat kubernetes hemen bu podu kapatmaz. Çünkü yeni trafik gelmese bile, bu pod halen eski istekleri işlemeye devam ediyor olabilir. Bu nedenle, bu işlemleri beklemesi gerekebilir.&#x20;

Pod tanımlarında, terminationGracePeriodSeconds şeklinde bir parametre bulunur. Ve varsayılan olarak değeri 30 saniyedir.  Aksini belirtmediğimiz sürece bu değer kullanılır. Biz veya kubelet podu terminate istediğimiz zaman podun içerisinde çalışan master process ine hemen sigkill sinyali gönderip hemen öldürmez. Bunun yerine sigturn sinyali gönderir yani, yaptığın bir işlem varsa düzgün bir şekilde tamamla, bitince de kendini kapat sinyalini gönderir. Eğer process bu sinyali aldığında eğer ortasında olduğu bir iş varsa, onu yapmayı bırakmaz. O işlemi tamamlar ve bittikten sonra tüm bağlantıları düzgün bir şekilde kapatıp sonrasında da process de kapatılır.&#x20;

terminationGracePeriodSeconds süresi, bu container a düzgün şekilde kendisini kapatabilmesi için atadığımız bir süredir. Eğer process bu süre içerisinde düzgün bir şekilde kapatılırsa sıkıntı olmayacaktır. Fakat kapanmazsa da, bu süre sonunda sigkill sinyali gönderilip, zorla kapatılır. Dolayısıyla uygulamamızın ne kadar süre içerisinde kapanabildiğini bilmemiz o na göre de terminationGracePeriodSeconds süresini düzenlememiz gerekebilir.

{% embed url="<https://cloud.google.com/blog/products/containers-kubernetes/kubernetes-best-practices-terminating-with-grace>" %}

Readiness Aşamaları,

1 - Deployment dosyası içerisinde imajımızı güncelledik.

2- Yeni imajda, yeni bir pod oluşturuldu.

3- Yeni pod çalışmaya başladı.

4- Readiness check mekanizması çalışmaya başladı. initialdelayseconds süresi kadar bekledi ve ardından ilk kontrolünü yaptı.

5- Kontrol sonucu olumlu olduğu anda, yeni pod service altına eklendi.

6- Eski pod henüz kapatılmadı, Eğer işlemesi gereken istekler varsa, işlemeye devam ediyor. Ve yeni istekler gelmemesi için service altından çıkarıldı.

7- Eski podun kendini düzgün kapatabilmesi için, sigterm sinyali gönderildi.

8- Eski pod üzerindeki işlemleri tamamladıktan sonra, kendini kapadı.

Örnek Readiness Probe Yaml içeriği;

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
  labels:
    team: development
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: frontend
        image: blue
        ports:
        - containerPort: 80
        livenessProbe:
          httpGet:
            path: /healthcheck
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 20
          periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: frontend
spec:
  selector:
    app: frontend
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
```

Readiness ve Liveness Probe 'lar aynı anda kullanılabilir.


# Resource Limits

Containerlar biz aksini belirtmediğimiz sürece varsayılan olarak, üzerinde çalıştıkları hostun CPU ve Memory kaynaklarına sınırsız şekilde erişirler. Yani biz 8 GB memory sahip bir sistem üzerinde container çalıştırdığımız zaman, bu container içerisindeki uygulama 8 GB memory 'nin tamamını kullanabilir. Keza aynı şekilde, tüm CPU çekirdeklerini de kullanabilir.&#x20;

Bu durum özellikle kubernetes gibi yüzlerce container çalıştırdığımız dağıtık yapılarda, bizim için sorun oluşturur. Eğer bir pod koştuğu hostun üzerindeki tüm kaynakları tüketiyorsa, bu diğer podların işlerini düzgün yapmayacağı anlamına gelir. Bu nedenle, bu podların içerisinde çalışan, containerların ne kadar cpu ve memory kullanabileceklerini kısıtlamamız gerekmektedir. Pod tanımlarımızda, kullanabileceğimiz request ve limit opsiyonları bize bu imkanı verir.

Cpu kaynağı, CPU birimleri olarak ölçülür. Kubernetes de bir CPU şuna eşdeğerdir;

* AWS vCPU
* GCP Core
* Azure vCore
* Hyperthread Bare-Metal

Kesirli değerlere izin verilir. 0.5 CPU talep eden, bir container 1 CPU talep eden, bir container 'ın, yarısı kadar CPU alır. Mili alamında M son ekini kullanabiliriz.

Örneğin, 100m CPU, 100Milicpu ve 0.1 CPU aynıdır. 1M'den daha fazla ince hassasiyete izin verilmez. CPU her zaman, mutlak bir miktar olarak talep edilir. Asla göreli olarak talep edilmez.&#x20;

Misal;

1 CPU core kullanmak için,

cpu:"1" = cpu="1000" = cpu:"1000m"

1 CPU 'nun %10nu kullanması için,

cpu:"0.1" = cpu:"100" = cpu:"100m"

Kubernetes de CPU kısıtlamaları şu şekilde ayarlanır;

Her worker node'un belirli CPU kaynakları mevcuttur. Bu kaynaklar cloud üstünde yada sanal olarak çalşan stemlerde vCPU olarak, bare-metal sunucularda hyper thread olarak adlandırılır.

Biz bir pod tanımına cpu:1 tanımı eklersek, O pod 'un çalıştığı node üstünde core'lardan, sadece 1 tanesini kullanacağı anlamına gelir. Başka bir yazım şekli daha vardır. Her core 1000ms yani 1000mili cpu'luk güç demektir. Biz eğer cpu:100m yaparsak, pod çalıştığı host üstünde 1 core'un 10'da 1' gücüne erişebilir anlamına gelecektir. Yani, cpu:1 ile cpu:1000m aynı şeydir. Keza 0.1 cpu ile cpu:100m de aynıdır.

Memory tanımı daha kolaydır;

Cluster da mevcut durumda kullanılabilir bellek varsa, bir container belirlenen bellek isteğini aşabilir. Ancak bir container bellek sınırından fazlasını kullanmasına izin verilmez.  Bir container sınırından daha fazla bellek ayırırsa, container sonlandırma için aday olur. Container limitinin ötesinde, bellek tüketmeye devam ederse, container sonlandırılır. Sonlandırılmış container yeniden başlatılabiliyorsa, diğer herhangi bir runtime hatası türünde, olduğu gibi kubelet onu yeniden başlatır.

Containerın kullanabileceği maksimum memory 'i, byte cinsinden tanımlayabiliriz. Örneğin, memory:64m dersek, bu containerın, en fazla 64megabyte memory kullanmasına izin verdiğimiz anlamına gelir.

Buradaki m: megabyte g:gigabyte k:kilobyte kısaltmasıdır. Bunların yerine memory hesaplamasında kullanılan 2nin katlarını kullanan gösterim şekli olan, kibibyte,mebibyte,gibibyte tanımlarıda desteklenir.

CPU ve Memory kısıtlama tanımlarını, iki ayrı bölümde tanımlayabiliyoruz. \
Bunlar, request ve limit parametreleri.

```yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: requestlimit
  name: requestlimit
spec:
  containers:
  - name: requestlimit
    image: obnet/stress
    resources:
      requests:
        memory: "64M"
        cpu: "250m"
      limits:
        memory: "256M"
        cpu: "0.5"
```

Request altında tanımladığımız değerler şu anlama geliyor, Kubernetes bu pod'u oluşturmaya başladığı zaman, scheduler bu podun oluşturacağı node seçecek. Bu seçme aşamasında kubernetese şunu diyoruz,  Bu podu en az 64megabyte memory, 250m milicpu yani çeyrek cpu core'un erişilebilir olduğu bir node üzerinde oluştur. Kısacası request kısmı bu podun oluşturulabilmesi için, minimum ne kadarlık boş kaynağın olması gerektiğini belirtiyor. Scheduler node seçiminde bu parametreleri de göz önüne alacak ve en az bu kadarlık kaynağın boş olduğu bir node seçecek. Eğer boşta 64mbyte memory ve  250m cpu sahip(çeyrek cpu), bir node bulamazsa, bu pod oluşturulmayacak.

Limit kısmı ise, tahmin edebileceğiniz üzere, bu containerın en fazla kullanabileceği sistem kaynağını belirtiyor. Yukarıdaki örnekte şunu diyoruz,

Bu pod içerisinde oluşturulan container, en falza 256megabyte memory kullanabilsin, en çok da yarım cpu (0.5) core 'na erişebilsin. Gördüğünüz gibi cpu kısmını istersek "0.5"  yada "1" gibi belirtebiliyor, yada "250m" gibi milicpu halinde yazabiliyoruz. Yani buradaki "0.5" yerine "500m" de yazsak aynı olurdu.&#x20;

Bu podu oluşturduğumuz da şu olacak, Öncelikle scheduler üstünde en az 64megabyte memory ve çeyrek cpu core kaynağının boşta olduğu bir node bulacak, ve bu pod o node üzerinde oluşturulacak. Pod oluşturulacak ve container çalışmaya başlayacak. Bu container ise, en fazla yarım cpu (0.5) core 'unun gücüne denk gelecek şekilde bir CPU kullanabilecek ve sistemden en fazla 256mbyte allocate edecek.

Bu Container eğer yarım core 'dan fazla CPU kaynağına erişmek isterse ne olacak?

Bu durum mümkün olmayacak, CPU da belirlediğimiz Limit neyse, bu container en fazla o kadar CPU kaynağına erişebilecek.&#x20;

Memory kısmında belirlediğimiz değer, bu containerın maksimum kullanabileceği memory değeridir. Fakat container bu değere geldiği zaman, daha fazlasını kullanamaz diye bir durum söz konusu değildir. Memory allocation CPU gibi çalışmıyor. teknik olarak farklı şeyler.

Bu nedenle, bu container içerisindeki uygulama sistemden daha fazla ram talebinde bulunabiliyor.  Sistem varsayılan olarak bunu engelleme şansına sahip değil. İşte bu nedenle, eğer container memory limitine geldiğinde daha fazla memory allocate edilmesi için bir mekanizma olmadığından, bu duruma geldiğinde OOMKilled (out off memory) kill durumuna geçerek restart ediliyor. Eğer uygulamamız burada belirttiğimiz, memory kısıtından daha çok memory talep ederse pod restart edilecek. Bu nedenle, bu kısıtları uygulamamızın davranışına göre belirlememizin davranışına göre belirlememiz gerekiyor.

Kubernetes node'lar üstünde cpu ve memory kullanımının kontrol edilmesi.

```bash
kubectl top node 
# kubectl top node "node_ismi" ile tekil bakılabilir 
```

Kubernetes pod'lar üstünde cpu ve memory kullanımının kontrol edilmesi.

```bash
kubectl top pod 
# kubectl top pod "pod_ismi" ile tekil bakılabilir 
```


# Environment Variables

Konuya bir örnekle başlayalım. Misal, biz bir web uygulaması geliştiriyoruz. Ve bu web uygulaması, bir veritabanı uygulamasına bağlanarak verileri burada saklıyor. Bu uygulamanın, bağlandığı veri tabanının, sunucu adresi, kullanıcı adı ve şifre bilgilerini de bu uygulamanın içerisine gömdük diyelim. Daha sonra, bu uygulamayı container imajı haline getirdik ve artık istediğimiz container platformunda bu uygulamayı çalıştırmaya hazırız.

Bu senaryo da 2 sıkıntımız bulunmaktadır.

1 - Biz veritabanı bağlantı bilgilerini, container imajı içerisine hardcoded olarak yazdık. Yani bir şekilde, container imajı istemediğimiz insanların eline geçerse, bu imajın içerisinde bulunan bu bilgiler expose olur. Bu durumu asla istemeyiz.

2 - Bu(web) imajdan, container oluşturmak istediğimiz zaman, bu container her defasında, aynı veritabanına, aynı kullanıcı adı ve şifre ile bağlanmaya çalışacak. Veritabanı adresimiz, test ortamlarında ayrı, prod ortamlarında ayrı olabilir. Biz bu kullanıcı adı ve şifre bilgilerini zaman içerisinde güncellemiş olabiliriz. Bu senaryo da ne yapacağız? Her ortam için, her seferinde, yeni bilgilerle imaj oluşturacağız. yada her seferinde, container oluşturulduktan sonra, container 'a bağlanıp, bu bilgileri güncelleyeceğiz. 2. seçeneği seçtiğimizde bu sefer de, şöyle bir sorunumuz olacak. Kubernetes bir sorun anında, containerı silip, yeniden oluşturabilir. Scale ediyoruz, geri alıyoruz vb. Her seferinde oluşturulan, tüm containerlara bağlanıp, bunu manuel mi düzelteceğiz?

Gördüğünüz gibi, bu tarz ortama göre değişebilen, ve hassas bilgileri container imajı içerisine gömmek, oldukça fazla sorun çıkartır. Fakat bununda bir çözümü var.

Bu tarz, çalıştırdığımız ortama göre değişebilecek bilgileri container imajına hardcoded olarak eklemeyiz. Bunun yerine, uygulamalarımızda bu bilgileri, çalıştırıldıkları sistemden okuyacakları şekilde, bir değişken olarak tanımlarız. Yani Environment variables *'dan okunması için tanım yaparız.*

Yukarıdaki örnekte uygulamamızın bağlanacağı, veritabanının adres ve kullanıcı bilgilerini direkt uygulamaya gömmek yerine veritabanı adresini $database . Kullanıcı adı bilgisini $username . Parola bilgisini de, $password isimli değişkenlerin değerlerine bakacak ve oradan bu değerleri okuyacak şekilde ayarlamasını söyleriz.

Bu sayede, bu hassas bilgileri, bu imajlara gömmemiş oluruz. Ne zaman bu imajdan, container oluşturmak istersek, o an hangi değerlerin atanması gerekiyorsa, bu değerlerin Container da Environment variable olarak tanımlarız. Böylecek Environment variables nedir ve Container ile ne alakası var sorularının cevaplarının üstünden geçmiş olduk.

Şimdi bunları pod tanımına nasıl ekleyeceğimize bakalım.

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: envpod
  labels:
    app: frontend
spec:
  containers:
  - name: envpod
    image: nginx
    ports:
    - containerPort: 80
    env:
      - name: USER
        value: "Onur"
      - name: database
        value: "testdb.example.com"
```

Pod tanımları içerisinde, Environment variable'la&#x72;*, container tanımı altında, env parametresi ile tanımlanıyor. env parametresi altında list şeklinde, tüm* Environment variable 'larımızı tanımlıyoruz.

Öncelikle tanımlamak istediğimiz Environment variable 'ın ismini giriyor ve ardından da, value opsiyonu ile buna atamak istediğimiz değeri giriyoruz.

Yukarıdaki örnek pod tanımında, "USER" isimli Environment variable tanımlayıp, ve buna da, "Onur" değerini atadım.&#x20;

Bir altındaki Environment variable 'da,  "database" isimli Environment variable tanımlayıp, buna da "testdb.example.com" değerini atadım.&#x20;

Bu container oluşturulduğunda, bu 2 Environment variable bu containerda tanımlanacak, Aynen az önceki örnekte belirttiğim gibi bir web uygulaması oluşturdum. Web uygulaması içerisinde, Selamlama yapacağı kişinin kim olacağını, hardcoded olarak eklemek yerine, çalıştığı ortamdaki "USER" isimli  Environment variable değeri ne ise, ondan bu değeri alıp, selamlayacak.

```bash
root@medellin-master:/home/onur# curl 127.0.0.1:8080

<html>
<body style="background-color:gray;">

<center><h1 style="color:magenta;">
    <p>K8S Fundamentals</p>
    <p>Pod: envpod</p>
    <p>Hello Onur</p>
        </h1>
</center>

</body>
```

envpod isimli pod içerisinde bulunan Environment variable'ları listelemek,

```bash
kubectl exec envpod -- printenv
```

Bu bir web uygulaması podu, normal bu pod'a dış dünyadan erişmek için, ya loadbalancer yada nodeport şeklinde bir servis tanımlamamız gerekir. Fakat kubernetes bize, şu imkanıda sunuyor. Biz kubectl kullanarak, herhangi bir pod 'a, deployment'a, service. vb. Kendi bilgisayarımızdan tünel açarak ilgili objenin portuna trafiği yönlendirebiliyoruz. Testlerde hızlı şekilde, objelerimize bağlanmak için, kullanabildiğimiz bu özelliğe "port forward" diyoruz.

Syntax:

```bash
kubectl port-forward {obje tipi/obje adı} hostport:podport
```

Örnek:

Kubectl 'i çalıştırdığımız cihazın, 8080 portuna gelen tüm istekleri, envpod isimli podun 80 portuna gönder/yönlendir.

```bash
kubectl port-forward pod/podenv 8080:80
```

{% hint style="info" %}
Container tanımı altında girdiğimiz, *Environment variable'ları, Bu container içerisinde,*

*farklı yerlerde dilediğimiz şekilde kullanabiliriz.*
{% endhint %}


# Ephemeral Volumes

Containerlar, stateless uygulamalar için oldukça uygundur. Bildiğimiz üzere containerlar, container imajı dediğimiz objelerden oluşturulur. Container içersinde çalışması istenilen uygulama ve bu uygulama bağlılıkları read-only bir paket haline getirilir ve bu pakete container imajı deriz. Bu paketten bir container yaratılır. Container yaratıldığı zaman, bu containera ait tüm veriler, bu containera atanan layer da tutulur. Yani container içerisinde oluşturulan her türlü dosya containera ait ayrı bir layer da durur ve container ayakta olduğu sürece bu veri erişilebilirdir.

Ancak container silinirse, bu veriler de silinir. Aynı imajdan yeni bir container yarattığımız zaman, bu container da, eski container da yazılan dosyalar bulunmayacaktır.

Bu durum stateless veya yazdığı verinin container kapatıldığında, silinmesinin sorun olmadığı uygulamalar için sıkıntı değildir.

Misal, gelen paketi işleyen, sonucu başka bir servise gönderen bir backend uygulaması üstünde bir veri barındırmadığı için ve herhangi bir state tutmadığı için sıkıntı çıkarmaz.&#x20;

Misal, bir frontend uygulamamız, bir web sitemiz olduğunu düşünürsek, kullanıcılarımız buraya browser arayıcılığıyla bağlanıyorlar.  Ve bu frontend uygulamamız da, başka bir servise bağlanıp, çeşitli resim dosyalarını çekip, bunları kullanıcılara gösteriyor. Uygulama bu resim dosyalarını, bir defa çektikten sonra, bunu container içerisinde, bir dizine saklıyor ki, bir daha bu resmi göstermesi gerekirse, diğer servise bağlanıp, tekrar çekmekle zaman kaybetmesin.  Yani bir nevi bu görselleri kendi üzerinde cacheliyor.&#x20;

Bu uygulamayı kubernetes üzerinde deploy etmek için, bir deployment objesi oluşturduk ve bu uygulama bir replika olacak şekilde deploy ettik. Podumuz oluşturuldu ve çalışmaya başladı. Buraya erişebilecek servis objesini de oluşturduk. Böylece bu uygulamaya kullanıcılar bağlanabilir duruma geldi.

Ardından da, backend uygulaması ve servisini de oluşturduk. Kullanıcıları web sitemizi kullanmaya başladılar. Diyelim ki çeşitli resimleri seçtiler ve bizim uygulamamızda, yapması gereken işlemlere başladı. Diğer servise bağlandı ve bu resimleri çekti, işledi ve bağlı kullanıcılara servis etti.&#x20;

Ama aynı zamanda, bu resimlerin, container içinde cache isimli dizine de kaydetti. Bir başka kullanıcı daha aynı resmi istediği zaman, tekrar zahmet edip diğer uygulamaya bağlanmasına gerek kalmadan, resimleri cache dizininden, çekerek gösterebilir duruma geldi. Böylece hız kazanmış olduk.

Misal, pod tanımında, liveness probe da var. Bir problem çıktığını düşünelim ve liveness probe fail etti. Bu durumda kubelet hemen devreye girip, bu container'ı silip, yeniden oluşturdu. Yani "kubectl get pods" kısmında restart olarak gözüken şey aslında container'ın yeniden oluşturulmasıdır.&#x20;

Container silindiği zaman içindeki veriler de siliniyor. Dolayısıyla, yeni container, içerisinde bu cache dizini boş olacaktır. Çok büyük bir sıkıntı değil. Sonuç olarak bunlar cache dosyaları. Tekrar diğer servise bağlanarak resimleri çekebiliriz.

Ama sırf yeni container oluştuğunda cache dosyalarının silinmese, ben bu pod içerisinde tüm containerların erişebileceği ve podun yaşam süresi boyunca ayakta kalabilecek, bir mekanizmaya sahip olsam ve dosyaları bu belirttiğim yere yazabilsem.

Böyle bir senaryom olsa, ben bu cache dizinini, buraya bağlarım ve içerisine yazılan tüm dosyalar buraya yazılır. Yeni bir container oluşturulduğunda da, bu dosyalara erişmeye devam edebiliriz. Böylece cache den mahrum kalmayız.&#x20;

Pod silinirse bu dosyalar da silinebilir. Önemli olan, pod ayakta durduğu sürece erişebileceğim ve containerın yaşam süresinden bağımsız bir şekilde, dosya saklayabileceğim, bir yapıya sahip olalım. Böyle bir yapı, bu senaryo da sorunumuzu çözerdi.

Kubernetes de bu sorunu Ephemeral Volume ile çözüyoruz.

Ephemeral volume sayesinde, bizler bu tarz verileri fiziksel olarak container dışında tutma imkanına sahip oluyoruz. Bu sayede container silindiği zaman, yeni oluşturulan containerında, bu verilere ulaşabilmesini sağlıyoruz. Kubernetes pod tanımlarında kullanabilmemiz adına 2 tip ephemeral volume mevcuttur.

### 1 - EmptyDir

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: emptydir
spec:
  containers:
  - name: frontend
    image: onurbolatoglu/apps1:latest
    ports:
    - containerPort: 80
    livenessProbe:
      httpGet:
        path: /healthcheck
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 5
    volumeMounts:
    - name: cache-vol
      mountPath: /cache
  - name: sidecar
    image: busybox
    command: ["/bin/sh"]
    args: ["-c", "sleep 3600"]
    volumeMounts:
    - name: cache-vol
      mountPath: /tmp/log
  volumes:
  - name: cache-vol
    emptyDir: {}
```

emptyDir volume ilk olarak bir pod, bir node 'a atandığında oluşturulur ve bu pod, o node 'da çalıştığı sürece var olur. Adından da anlaşılacağı gibi emptyDir başlangıçta boştur. Pod içindeki tüm containerlar emptydir volume 'deki  aynı dosyaları okuyabilir ve yazabilir. Bu volume her kapsayıcıda aynı veya farklı path'lere mount edilebilir.&#x20;

Bir pod herhangi bir nedenle silindiğinde, emptyDir içindeki veriler kalıcı olarak silinir. Biz bir emptyDir tipinde volume yaratmak için, Pod tanımında gerekli ayarları yaptığımız zaman, kubernetes bu podun oluşturulduğu node  üzerinde boş bir dizin yaratır.&#x20;

Daha sonra biz bu klasörü container içerisindeki, herhangi bir dizine mount edebiliriz. Bizim örneğimizde ki /cache klasörüne, bu containerın bu mount ettiğimiz pathe yazdığı her türlü dosya, fiziksel olarak node üstünde oluşturulmuş olan, boş dizine yazılır. Dolayısıyla container silinse bile, bu dosyalar silinmez. Yeni container oluşturulduğu zaman tekrar bu volume, container da, aynı pathe mount edilir. Bu sayede yeni oluşturulmuş container da, bu dosyalara erişmeye devam eder.

<mark style="color:red;">Bu dosyalar, POD 'un yaşam süresi boyunca erişilebilir durumdadır. Yani POD silinirse bu volume de silinir. Pod içerisinde bulunan container silinip, yeniden oluşturulabilir. Bu durumda var olan dosyalar etkilenmez ancak POD silinirse bu dosyalar kalıcı olarak silinir.</mark>

İster biz, ister kubernetes bir sorun anında, POD u silip yeniden başka bir pod oluşturursa, volume de silinmiş olur. Bu nedenle bu volume'lere ephemeral volume yani geçici volumeler diyoruz.

Bu volumeler sadece, bir şekilde geçici olarak podun yaşam süresi boyunca, containerın, yaşam süresinden bağımsız olarak saklamamız gereken geçici dosyaları tutmak için kullanırız.

### 2 - Host Path

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: hostpath
spec:
  containers:
  - name: hostpathcontainer
    image: ubuntu:latest
    ports:
    - containerPort: 80
    livenessProbe:
      httpGet:
        path: /healthcheck
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 5
    volumeMounts:
    - name: directory-vol
      mountPath: /dir1
    - name: dircreate-vol
      mountPath: /cache
    - name: file-vol
      mountPath: /cache/config.json       
  volumes:
  - name: directory-vol
    hostPath:
      path: /tmp
      type: Directory
  - name: dircreate-vol
    hostPath:
      path: /cache
      type: DirectoryOrCreate
  - name: file-vol
    hostPath:
      path: /cache/config.json
      type: FileOrCreate
```

Bir hostpath volume, worker node dosya sisteminden podumuza bir dosya veya dizini bağlayabilme imkanı verir. Bu çoğu podun ihtiyaç duyacağı bir şey değildir. Ancak bazı uygulamalar için, güçlü bir kaçış kapısı sunar.&#x20;

Hostpath, temel de emptydir ile mantık olarak aynıdır. Yine biz volume yaratılması için, pod tanımlarımıza gerekli parametreleri gireriz. Fakat bu sefer rastgele boş bir klasör yaratmasını söylemek yerine, podun oluşturulacağı worker node üstündeki, spesifik bir dizini veya dosyayı belirtiriz.&#x20;

Misal, worker node üstündeki /tmp dizinini volume olarak kullanılmasını istediğimizi belirtebiliriz. Daha sonra bu dizini veya dosyayı container içerisindeki herhangi bir dizine mount edebiliriz.&#x20;

Aynı şekilde, containerdan yazılan dosyalar bu mount ettiğimiz dizine yazılır ve container silinse de dosyalar silinmez. Genellikle podların çalıştıkları worker node üzerinde spesifik bir dizin ve dosyalara erişmesi gerektiği durumlarda işimize yarar. Misal bir path de konumlandırılmış bir unix soketine containerın bağlanması gerekirse, bunu hostpath ile containera mount edebiliriz.

Volume oluşturmak için,

* Volume parametresi ile oluşturulmak istenilen volume specs altında tanımlamak gerekiyor. Name anahtarı ile isim verilmeli ve volume tipini girmeliyiz.
* Bu volume containerda belirlediğimiz, ihtiyacımız olan pathe mount etmeliyiz. Volumemount anahtarı kullanarak mount etmek istediğimiz volume ismini ve mountpath ile bu volume bağlamak istediğimiz pathi belirlemeliyiz.

Hostpath için MountPath tipleri,

* directory => Bağlanacak Dosya(Dizin) zaten hali hazırda ilgili worker nodelar üzerinde mevcutsa, ilgili dosyayı veya dizini direkt olarak containera bağla.
* DirectoryOrCreate ve FileOrCreate => Bağlanacak Dosya veya Dizin worker nodelar üzerinde varlığı bilinmiyorsa, kullanılır. Yani ilgili dizin ve ya dosya mevcutsa bağla, mevcut değilse oluştur ve ardından containera bağla.

{% hint style="info" %}
Ephemeral volume bizim depolama sıkıntımızın tamamını çözmez. Bizim bazı durumlarda pod yaşam süresinden bağımsız şekilde,  uzun süreli saklamamız gereken dosyalar da olabiliyor ve bunları ephemeral volume ile çözmemiz mümkün değil. Fakat bunun da kubernetes de farklı bir çözümü var. Bu çözümden de ilerleyen yazılarımda bahsedeceğim.
{% endhint %}


# Secrets

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FoNiuUpX9AD3FHmCzzpZm%2F1628621977-k8s-secrets.png?alt=media\&token=9beb4964-6573-4f8a-a0ee-28c51145e69d)

environment variables konusunda, hassas bilgileri imaja direkt eklemenin doğru olmayacağından bahsetmiştik. Bunları, environment variables olarak pod tanımları içerisine ekliyorduk. Fakat bu senaryoda da imaj içerisine hassas bilgileri eklemedik ancak pod tanımında kullanacağımız yaml dosyası içerisine eklemiş olduk. Bu yaml dosyasına erişebilen herkes, bu bilgilere de erişebiliyor. İlk sıkıntımız bu. 2.problemimiz, bizler bu tarz hassas bilgileri, uygulamanın kodundan ayırdık fakat, bu seferde pod tanımımıza ekledik. Bu verilerin değişmesi gerektiği zaman, misal bir şifrenin güncellenmesi gerektiğinde, bizim bu yeni şifre bilgisini pod tanımı üzerinde yani yaml dosyamızda güncellememiz gerekiyor. Bu da yaml dosyalarının generic olmasını engelliyor.&#x20;

Ayrıca bu hassas bilgilerin yönetimi ile, deploy edilen uygulamanın yönetimi, ayrı ekiplerde olabilir. Bu 2 işi birleştirdiğimiz zaman, bu ayrımı sağlayamıyoruz.

Bu sorunu çözmek için, en mantıklı yöntem bu hassas bilgileri, uygulama deploy ettiğim pod tanımlarından ayırmam ve ayrı yönetebilmemdir. Kubernetes de, secret objesi tam olarak bu işi yapıyor.

Kubernetes secret, parolalar, Oauth Token ve SSH anahtarı gibi hassas bilgileri, depolamamıza ve yönetmemize olanak sağlar. Gizli bilgileri bir secret içinde saklamak, onu bir pod tanımına veya container imajına direkt olarak eklemekten daha güvenli ve esnektir.

Secretler pod ve Deployment gibi bir kubernetes objesidir. Hassas bilgileri secret objelerinde saklar ve sonra bunları çeşitli yöntemlerle pod'un içerisine ekleyebiliriz.

Secretler, aynen pod ve diğer objeler gibi yaratılıp, yönetilir. Yani hem yaml dosyasıyla, hem de kubectl arayıcılığıyla imperative olarak secret objesi oluşturabiliriz.

Örnek bir secret yaml içeriği;

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
stringData:
  db_server: db.example.com
  db_username: admin
  db_password: P@ssw0rd!
```

ApiVersion:v1 ve kind kısmı secret olmalıdır. Metadata kısmında "name" parametresi ile bu secrete isim vermeliyiz.&#x20;

{% hint style="info" %}
Oluşturulan secret ve bu secreti atayacağımız pod aynı namespace içerisinde olmalıdır. Yani biz bu secreti "default" namespace altında oluşturuyorsak, bu secreti atayacağımız pod da, default namespace altında olmalıdır.
{% endhint %}

Secret yaml dosyamızda type kısmını opaque olarak girdik. Ve bunun gibi 8 tane daha secret type mevcuttur. (basic auth, TLS vb..)

Secret objeleri, kullanıcı adı vb, TLS sertifikaları ya da SSH anahtarı gibi hassas verileri saklamamıza yarar, Biz opaque tipinde bir secret oluşturursak, tüm bu belirttiğim veri tiplerini, hiçbir sıkıntı olmadan saklayabiliriz.&#x20;

Secret oluşturduğumuz yaml dosyası içerisinde, ekleyeceğimiz hassas bilgileri "stringData" parametresi içerisine yazıyoruz.

{% hint style="info" %}
stringData yerine, sadece "Data" parametresi kullanılan yerler ve kişiler olabilir. aralarındaki fark, stringData olduğu gibi, plaintext olarak yazılır. "Data" ise, hassas bilginin base64 encode edilmiş hali olarak yazılır.
{% endhint %}

{% hint style="info" %}
"kubectl get secrets" komutunu çalıştırdığımızda "data" kısmında yazan sayı, bizim girdiğimiz hassas veri miktarıdır.
{% endhint %}

Kubectl kullanarak secret oluşturma;

```bash
kubectl create secret generic "secret_ismi" --from-literal="anahtar"="değer" --from-file="anahtar"="değerin_okunacagi_dosya" --from-file="değerin_okunacagi_dosya"

kubectl create secret generic mysecret --from-literal=db_server=db.example.com --from-file=db_server=server.txt --from-file=config.js

kubectl create secre generic mysecret2 --from-literal=db_server=db.example.com --from-literal=db_username=admin --from-literal=db_password=password1
```

\--from-literal yerine --from-file kullanarak, hassas bilgileri shellden yazmak yerine, dosyadan okumasını söyleyebiliriz.

Secretları Pod tanımlarına eklemek için 2 seçeneğimiz mevcuttur. Bu değerleri poda volume arayıcılığıyla ekleyebilir ya da Environment variable olarak aktarırız.

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: secretpodvolume
spec:
  containers:
  - name: secretcontainer
    image: ubuntu
    volumeMounts:
    - name: secret-vol
      mountPath: /secret
  volumes:
  - name: secret-vol
    secret:
      secretName: mysecret3
---
apiVersion: v1
kind: Pod
metadata:
  name: secretpodenv
spec:
  containers:
  - name: secretcontainer
    image: alpine
    env:
      - name: username
        valueFrom:
          secretKeyRef:
            name: mysecret3
            key: db_username
      - name: password
        valueFrom:
          secretKeyRef:
            name: mysecret3
            key: db_password
      - name: server
        valueFrom:
          secretKeyRef:
            name: mysecret3
            key: db_server
---
apiVersion: v1
kind: Pod
metadata:
  name: secretpodenvall
spec:
  containers:
  - name: secretcontainer
    image: ubuntu
    envFrom:
    - secretRef:
        name: mysecret3
```

Yukarıdaki yaml örneğinde secretlerin podlara tanımlanması ile ilgili 3 örnek mevcuttur.

1 - secretpodvolume  pod tanımında volume kullanılarak hassas bilgiler pod a aktarılmıştır. Özetle, secret-vol isimli bir volume yaratıyoruz. İsim herhangi bir şey olabilir. Daha sonra bu volume emptyDir ve ya Hostpath olarak değil, bu sefer secret den oluşturuyoruz. Diyoruz ki, bu volume mysecret3 isimli secret den oluşturulsun. Sonrasında bu volume Containerda bir dizine mount ediyorum. Bu pod oluşturulduğu zaman, Kubernetes secret içerisinde bulunan tüm keyleri birer dosya olarak, bu mount ettiğimiz pathe koyacak. Bu dosyaların içeriğini de, bu keylere atadığımız değerler olacak. Dolayısıyla artık uygulamamıza, misal veri tabanına mı bağlanmak istiyorsun? Kullanıcı adını  /secret/db\_username dosyasından bakarak öğrenebilirsin.

2 - secretpodenv pod tanımında Environment variable kullanarak, hassas bilgiler poda değişken olarak atanmıştır. Bu örnekte, bir username adında, env variable tanımlıyoruz ve bunun value kısmını, mysecret3 isimli secret içerisinde tanımladığım db\_username anahtarının değeri olarak alıyorum. Diğer değişkenleri de bu şekilde mysecret3 içerisinde tanımladığım keylerden okuyarak yeni bir değişkene atıyorum.

3 - secretpodenvall pod tanımında da Environment Variable kullanıyoruz ancak, bütün değerleri tek tek okuyup, yeni bir değişkene atamak yerine, git mysecret3 içeriğine bak ve mysecret3 içerisinde bulunan tüm değerleri env. variable olarak pod'a atamasını söylüyoruz.

Oluşturduğumuz secretlar, etcd de şifrelenmemiş olarak saklanmaktadır. Cloud servis sağlayıcılarında yani yönetilen kubernetes hizmetlerinde bu tür veriler şifrelenmiştir. Ancak kendi kurup, yönettiğimiz kubernetes clusterı için bu durum söz konusu değildir. Kendi oluşturduğumuz secretları şifrelenmiş bir şekilde etcd tutmak için, encrypted secret data and rest dökümanı takip edilerek, secret'ları şifreleyebilirsiniz.

{% embed url="<https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/>" %}

Secret objelerinin silinmesi,

```bash
kubectl delete secret "secret_ismi"

Ör: kubectl delete secret my-secret
```

Secret objelerinin listelenmesi,

```bash
kubectl get secret
```


# ConfigMap

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FMprhVA7BcvJ7iy2mwBEU%2FKubernetes-Secret-and-ConfigMap.webp?alt=media\&token=ffc7f1bc-dd4a-4af3-9eef-3fca5de142af)

ConfigMap, gizli olmayan verileri key/value eşlenikleri şeklinde depolamak için kullanılan bir API nesnesidir. Podlar, ConfigMap'i environment variable, komut satırı argümanları veya yapılandırma dosyaları olarak kullanabilirler.&#x20;

ConfigMap objeleri, secret objeleri ile birebir aynı işe yarar. Key/Value şeklinde veriler tutup, bunları podlara environment variable yada volume olarak aktarabiliriz. Kubelet ve yaml dosyalarıyla oluşturulur. Secret ile aynı şekilde oluşturulur.

ConfigMap de gizli olmayan, fakat yine de pod tanımından ayırmamız gereken konfigürasyon verileri tarzı bilgileri tutarız. Yani gizli olmasını istediğimiz veriyi, secret objesinde tutarız. Gizli olmasına gerek olmayan verileri "configmap" objesinde tutarız.

{% hint style="info" %}
ConfigMap 'de veriler, base64 encode edilmiş şekilde saklanmaz.
{% endhint %}

Imperative olarak ConfigMap objelerinin oluşturulması,

```bash
kubectl create configmap "configmap_ismi" --from-literal="anahtar"="değer" --from-file="anahtar"="değerin_okunacagi_dosya" --from-file="değerin_okunacagi_dosya"

kubectl create configmap myconfigmap--from-literal=db_server=db.example.com --from-file=db_server=server.txt --from-file=config.json
```

ConfigMap objelerinin listelenmesi,

```bash
kubectl get configmap
```

ConfigMap objelerinin silinmesi,

```bash
kubectl delete configmap "configmap_ismi"

kubectl delete configmap my-configmap
```

Örnek, ConfigMap yaml dosyası.

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfigmap
data:
  db_server: "db.example.com"
  database: "mydatabase"
  site.settings: |
    color=blue
    padding:25px
---
apiVersion: v1
kind: Pod
metadata:
  name: configmappod
spec:
  containers:
  - name: configmapcontainer
    image: ubuntu
    env:
      - name: DB_SERVER
        valueFrom:
          configMapKeyRef:
            name: myconfigmap
            key: db_server
      - name: DATABASE
        valueFrom:
          configMapKeyRef:
            name: myconfigmap
            key: database
    volumeMounts:
      - name: config-vol
        mountPath: "/config"
        readOnly: true
  volumes:
    - name: config-vol
      configMap:
        name: myconfigmap
```

![Secret & ConfigMap & Ephemeral Volumes birlikte kullanım örneği.](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F4m5eKLmpGzNoiMPPukcz%2F07fig12_alt.jpg?alt=media\&token=14327a51-ea9d-4239-9eda-d61543deabe4)

{% embed url="<https://www.cozumpark.com/kubernetesde-configmap-kullanmak/>" %}


# Node Affinity

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fx8vaijtq3PsW9qpxjP8O%2Fnode-affinity-kubernetes.png?alt=media\&token=811d321c-f90e-40ee-b234-8af796e646d5)

Node Affinity kavramsal olarak node selector'a benzer ve nodelara atanan etiketlere göre podumuzun hangi node üstünde schedule edilmeye uygun olduğunu kısıtlamamıza olanak tanır.

Podlarımızın, uygun worker nodelar üzerinde oluşturulması için, imkan sunan pod opsiyonlarımızdandır. Node Selector ile çok benzerdir. Aynı şekilde pod tanımına ekleriz. Podumuzun scheduler edileceği node üstünde pod tanımında belirttiğimiz label'in olmasını bekleriz.

Affinity tanımı, pod tanımı içerisinde "affinity" parametresi altında eklenmektedir. Bu parametre altında kullanabileceğimiz 2 seçenek mevcuttur.&#x20;

* requiredDuringSchedulingIgnoredDuringExecution
* preferredDuringSchedulingIgnoredDuringExecution

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: nodeaffinitypod1
spec:
  containers:
  - name: nodeaffinity1
    image: ubuntu
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: app
            operator: In #In, NotIn, Exists, DoesNotExist
            values:
            - blue
---
apiVersion: v1
kind: Pod
metadata:
  name: nodeaffinitypod2
spec:
  containers:
  - name: nodeaffinity2
    image: ubuntu
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        preference:
          matchExpressions:
          - key: app
            operator: In
            values:
            - blue
      - weight: 2
        preference:
          matchExpressions:
          - key: app
            operator: In
            values:
            - red
---
apiVersion: v1
kind: Pod
metadata:
  name: nodeaffinitypod3
spec:
  containers:
  - name: nodeaffinity3
    image: alpine
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: app
            operator: Exists #In, NotIn, Exists, DoesNotExist
```

1. pod tanımında bulunan, requiredDuringSchedulingIgnoredDuringExecution seçeneği, şu demektir. Bu podu oluştururken, mutlaka alta yaptığım eşleşmeye uygun node bul ve bu podu orada oluştur. Uygun bir node bulamazsan, pod oluşturulmasın ve "pending" status da, uygun node bulana kadar beklesin. \
   \
   Bu pod tanımını kubernetes API server'a gönderirsem, şu olacak. Kubernetes tüm worker nodelarda, app=blue şeklinde bir label arayacak. Eğer bu labelin olduğu uygun bir worker node görürse bu podu orada schedule edecek. Tanım required olduğu için, Eğer bu labela sahip bir worker node bulamazsa, schedule edilmeyecek. Pod "pending" de bekleyecek. \
   \
   Kısacası required mutlaka sağlanması gereken eşleşme varsa, onu belirttiğimiz parametredir.&#x20;

Burada operator olarak kullanabileceğimiz birkaç seçenek daha mevcuttur. Bu seçenekler aslında node selector'dan ayrışmasını sağlıyor.\
\
app in blue tanımı yaptığımızda, app anahtarına blue değerinin atanma şartı oluşturuyoruz. Yani pod  app=blue labela sahip, worker node bulursa schedule edilecek.\
\
Fakat burada, "in" yerine "notin" deseydik, Bu sefer pod, üstünde app=blue labeli <mark style="color:red;">tanımlanmamış</mark> bir worker node üstünde oluşturulacaktır.

operator kısmına, "exists" tanımı girseydik, ve değeri silseydik. şu olacaktı; bu podu oluşturmak için, üstünde "app" anahtarı tanımlanmış herhangi bir worker node bul demek olacaktı. Yani value(değeri) kısmı önemli değil.  sadece "app" anahtarı olması yeterli.

DoesNotExists seçeneği ise, tam tersidir.  Üstünde "app" abahtarı olmayan bir worker node bul ve orada çalıştır.

requiredDuringSchedulingIgnoredDuringExecution seçeneğinde, şart sağlanmazsa pod oluşturulmaz.

2\. Pod tanımında bulunan, preferredDuringSchedulingIgnoredDuringExecution seçeneği şu manaya gelir; Buradaki tanıma bak, bu podu, bu tanıma uygun node üstünde oluştur.  Fakat bu tanıma uygun bir node bulamazsanda "pending" olarak bekletme, başka bir node bul ve bu podu orada oluştur. \
\
Preferred tanımında gördüğünüz üzere, "weight"  de girebiliyoruz.  Weight 1 ile 100 arasında bir değer verebiliyoruz.  Ve birden fazla tanım girildiyse, onların hangisinin daha önce değerlendirileceğine bakıyor. Örneğimizde 2 tanım girili durumda, 1. tanımdaki weight :1 seçili, 2.tanımda weight:2 seçili. 2, 1'den daha büyük olduğu için, daha önceliklidir. Biz bu podu oluşturduğumuzda şu olacak;\
\
Scheduler tüm nodelara bakacak ve, app=blue ve app=red labellarına sahip nodeları listeleyecek. Bunlardan app=red weight değeri daha yüksek olduğu için, Eğer bu etikete sahip node varsa, pod buada oluşturulacak. Eğer bu worker node üstünde yer yoksa, veya label yoksa bu seferde app=blue olan node seçilecek. Eğer bu node da yer yoksa veya bu labellere sahip hiçbir node bulamazsa, <mark style="color:red;">uygun olan herhangi bir worker node üstünde, pod oluşturulacak.</mark>&#x20;

Uzun lafın kısası, required olarak girildiyse tanım, mutlaka bu şart yerine getirilmelidir. Fakat preferred olaran girildiyse, bu şartı karşılamayı dener fakat karşılayamazsa, yine de schedule eder.

IgnoredDuringExecution kısmı şu demektir; Biz bir pod oluşturduk, pod buradaki tanıma göre bir worker node buldu ve orada schedule oldu. Ve çalışmaya başladı. Fakat aradan zaman geçti ve biz bu çalıştığı worker nodedan podun node seçiminde kullandığı labeli sildik. Eğer Affinity altında IgnoredDuringExecution seçeneği seçiliyse, pod bir kere schedule edildikten sonra, çalışmaya devam edecek anlamına gelir. Zaten hali hazırda kubernetes de bunun için farklı bir alternatif yok. Yani RequireDuringExecution veya PreferredDuringExecution tanımları yok. Belki ileride bu özellikleri de görebiliriz.

Özetle,

1. pod, app=blue labelini şart koşuyor. Bu labela sahip node yoksa veya label var ama pod için yer yoksa, pod oluşturulmaz. \
   \
   requiredDuringSchedulingIgnoredDuringExecution seçeneğini çok fazla kullanmayı tercih etmeyiz ki, misal SSDli nodelarda pod çalıştırmak için nodelara disk=ssd labeli ekledik. Ancak bir zaman sonra, bu nodelar dolacaktır ve yeni pod schedule etmek için yer kalmayacaktır. Bu durumda podumuz oluşturulmayacaktır.  (En azından bir süre). Uygun node bulana kadar "pendig" status da bekleyecektir. Yer olmasa bile, podumuzun farklı bir node da(misal disk=ssd labelina sahip olmayan) oluşturulmasını isteyebiliriz ki servisimiz, uygulamamız çalışabilsin. Bu nedenle preferred tanımı daha kullanışlı gözüküyor.

\-----------------------------------------------------------------------------------------------------

1. POD app=blue labeli olmasını şart koşuyor.
2. POD app=blue veya app=red labellerinin olmasını istiyor ancak şart koşmuyor.
3. POD app adında, bir anahtar(label) olacak ama değerinin ne olduğu ile ilgilenmiyor. Sadece "app" adında label olup, olmadığına dikkat ediyor.


# Pod Affinity

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FAMMBUohkrlLROuh6OHa8%2Fimg2.jpg?alt=media\&token=6d3ea55d-3d34-4d88-9052-a9a0abf9662a)

Bazı durumlarda, bizler oluşturduğumuz podun schedule edileceği node üstünde çalışan başka podların olmasını veya olmamasını isteyebiliriz.&#x20;

Misal, Azure üstünde koşan kubernetes clusterımız var. Bu kubernete clusterın 4 worker node var. Ve bu 4 worker node da, aynı region içerisinde bulunan 2 farklı availability zone üzerinde dağıtılmıştır.&#x20;

Yani worker node 1 ve worker node 2 availability zone 1 de, worker node 3 ve worker node 4 de availability zone 2 de barınmaktadır.

Farzedelim ki biz frontent , cache ve veritabanından oluşan bir uygulama deploy edeceğiz. İlk olarak veritabanımızı oluşturacak pod tanımını hazırladık ve ve kubernetes api gönderdik ve kubernetes scheduler işini yaptı ve podu çalıştıracağı uygun bir node buldu. Ve varsayalım ki bu node ise, worker node 1, sonrasında frontend uygulamasını deploy ettik ve onu da worker node 3 de schedule etti. Son olarak da, cache podumuzu deploy ettik ve bu pod da son olarak worker node 4 de çalışmaya başladı.

Bu senaryo da bir kaç sıkıntı var,

İlk olarak, frontend podumuz ve veritabanı podumuz ayrı ayrı availability zonelar üzerinde schedule edildiler. Tahmin edebileceğiniz üzere frontend podumuz sürekli olarak veritabanı ile görüşüyor. Sürekli ona veri yazıyor ve ondan veri okuyor. Hemen hemen tüm cloud servis sağlayıcılar 2 availability zone arasında veri transferine ücrete tabi tutulur. Yani biz 2 podu da aynı availability zone üzerinde bulunan worker nodelarda koştursaydık, aynı availability zone üzerinde durdukları için aralarındaki veri transferine para ödemeyecekken, şimdi ayrı availability zone da durdukları için para ödemek zorunda kalacağız. Bunun olmasını engellemek için, node affinity yazarak, podları aynı yere toplayabiliriz. Ama bu seferde her şeyi manuel olarak ayarlamak gerekecek. Fakat bunun yerine şöyle bir şey yapabilseydik, sanırım işleri otomatik olarak kubernetes hallederdi. Eğer ben pod tanımına, bak bu podu oluşturacağın node'u seçerken git veritabanı poduna bak ve o pod hangi  availability zone da oluşturulduysa, bu podu da orada oluştur gibi bir tanım ekleyebilseydim bu sorunu çözebilirdik.

Diğer bir istediğimiz bir durumda şu olabilirdi;

Misal frontend ve cache podları ayrı worker node üzerinde oluşturulmuş. Bunları da keşke aynı worker node üzerinde çalıştırabilseydim. Sonuçta cache ve frontend arasında ne kadar az latency olursa, uygulamam o kadar performanslı çalışır.

Bunun kolay yolu da şu olurdu, cache pod tanımında şunu diyebilseydik, git frontend pod'a bak, o hangi node üstünde oluşturulduysa, bu pod da orada oluşturulsun.&#x20;

Bize tüm bunları sağlayan, Kubernetes özelliği mevcut.

**Pod Affinity podumuzun hangi worker node üzerinde oluşturulmaya uygun olduğunu nodelardaki etiketlere göre değil, hali hazırda node da çalışmakta olan podlardaki etiketlere göre sınırlamamıza olanak tanır.**

Bizlerin bir pod tanımına ekleyerek, o podun oluşturulacağı node seçimini ve o node üzerinde çalışan veya çalışmayan podların varlığına göre yapabilme imkanı veren özelliğe Pod Affinity diyoruz. Nasıl ki, node affinity de bir podun oluşturulacağı node ve o node da bulunan veya bulunmayan labellara göre seçebiliyorsak, Pod Affinity de ise, bunu ilgili node üzerinde çalışan pod olup, olmadığına göre seçebiliyoruz.&#x20;

Bizler daha önceden worker nodelarımıza çeşitli labellar eklemeyi gördük ve ekledik. Fakat nodelar üzerinde önceden de tanımlanmış(default gelen) bir çok label mevcuttur.

Her kubernetes node da,

<mark style="color:orange;">1 -</mark> <mark style="color:red;">kubernetes.io/arch</mark> <mark style="color:orange;">=> İlgili node x64 veya ARM tabanlı bir işlemciye sahip olduğunu belirtir. Değer olarak Amd64 veya ARM değerlerini alabilir.</mark>\
\ <mark style="color:orange;">2 -</mark> <mark style="color:red;">kubernetes.io/hostname</mark> <mark style="color:orange;">=> İlgili node'un, hostname değerini alır.</mark>

<mark style="color:orange;">3 -</mark> <mark style="color:red;">kubernetes.io/os</mark> <mark style="color:orange;">=> İlgili node'un işletim sistemi bilgilerini alır (Linux,Windows)</mark>

Labelları bulunur.

<mark style="color:purple;">Bunun yanında, cloud servis sağlayıcılarının yönetilen Kubernetes hizmetindeki nodelarda ilgili node'un hangi region da bulunduğunu belirten (</mark> <mark style="color:yellow;">topology.kubernetes.io/region</mark> <mark style="color:purple;">) ve hangi availability zone da bulunduğu belirten, (</mark> <mark style="color:yellow;">topology.kubernetes.io/zone</mark> <mark style="color:purple;">) anahtarları ile belirtilir.</mark>&#x20;

Örnek bir Pod Affinity tanımı içeren YAML dosyası içeriği,

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: frontendpod
  labels:
    app: frontend
    deployment: test
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80
---
apiVersion: v1
kind: Pod
metadata:
  name: cachepod
spec:
  affinity:
    podAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
          - key: app
            operator: In
            values:
            - frontend
        topologyKey: kubernetes.io/hostname
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        podAffinityTerm:
          labelSelector:
            matchExpressions:
            - key: color
              operator: In
              values:
              - blue
          topologyKey: kubernetes.io/hostname
    podAntiAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          labelSelector:
            matchExpressions:
            - key: deployment
              operator: In
              values:
              - prod
          topologyKey: topology.kubernetes.io/zone
  containers:
  - name: cachecontainer
    image: redis:6-alpine
```

2\. Pod tanını inceleyelim, Pod affinity tanımlarıda aynen node affinity tanımları gibi requiredDuringScheduling ve preferredDuringScheduling olarak hard ve soft gereksinimlere sahip olabilirler. Node affinity tanımlara oldukça benzer. Tek bir fark vardır. Pod affinity tanımlarıonda topologyKey adında bir daha gireriz. İlk tanımda requiredDuringSecheduling seçeneği girili, yani mecbur kılınmış. Bu tanımda diyoruz ki, schedule edileceği worker node üzerinde app=frontend labelina sahip bir pod olmalı. Yani bu podu bu şartı sağlayan host üstünde schedule et. topologyKey kısmında bunu belirtiyoruz. Burada hostname anahatarını seçersek, aynı hostname yani aynı worker node üzerinde bu pod çalıştırılacak.&#x20;

Misal, diyelim ki hostname yerine "zone" anahtarını seçtik. Bu seferde aynı worker node olmasına gerek yok olmayacaktı. Buraya topology.kubernetes.io/zone yazsaydık, bu podu app=frontend labelli bir podun çalıştığı availability zone daki herhangi bir worker node üzerinde çalıştır. Manasına gelecekti.

Görüldüğü gibi node affinity de çalışacağı worker nodedaki labellara göre seçiyorduk. Pod affinitty de ise, hangi podlarla birlikte çalışacağını seçiyoruz.

Pod Affinity'nin Node Affinity göre bir farkı da anti-affinity tanımlarının ayrı yapılmasıdır. node anti affinity kısmını not-in ile halledebiliyorduk. Fakat pod anti affinity kısmını özel olarak tanımlamamız gerekiyor. Bunu da podAntiAffinity anahtarı ile yapıyoruz.

Örnekte bulunan antiAffinity kısmını  inceleyecek olursak,\
Bu podu deployment=prod tanımına sahip olan bir pod ile, aynı zone da schedule etme diyoruz.

Bu YAML dosyasını deploy edersek şu olur;

* Öncelikle frontend pod adındaki pod schedule edilecek. Gördüğünüz gibi app=frontend labeli eklemişiz. Bu da bizim frontend podumuzu temsil ediyor.
* Sonrasında ise, 2.podumuz olan, cachepod isimli podumuz deploy ederken, kubernetes pod affinity kurallarına bakacak, İlk kural olan RequireDuring kısmından bahsedersek, burada şunu diyoruz, Bu pod mutlaka app=frontend labelina sahip bir pod ile aynı node üzerinde çalıştırılsın. Eğer bu şekilde birden fazla node varsa, git color=blue labelina sahip bir podun çalıştığı worker node varsa, onu seç. Ve mümkünse bu seçtiğin worker node buludunduğu zone içerisinde deployment=prod labelina sahip bir pod bulunmasın.


# Taint and Toleration

![Temsili](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FXJx01AZPe2DaSojY4aCF%2F1_7e0BwxxNBMrx2J4TQGMjuA.png?alt=media\&token=8ef172b8-07fc-4f81-8e83-a5c051430b5f)

3 worker node 'dan oluşan bir cluster yapısı düşünelim. Worker nodelarımızdan birine color=blue diğer node da color=green labelları ekledik. 3. worker node da ise herhangi bir label eklemedik.&#x20;

Bu cluster üzerinde 2 uygulama deploy edeceğiz, blue uygulamamızı, blue olarak etiketlenen worker node da, green uygulamamızı da green olarak etiketlenen worker node da schedule edilmesini istiyoruz.

Bu nedenle gerekli pod affinity ve node affinity tanımlarını yaptık ve uygulamalarımızı deploy ettik. Blue uygulamamız node affinity tanımları gereği color=blue etiketli worker node da, green uygulamamız color=green şeklinde etiketlenen worker node da çalışmaya başladı. Yani istediğimiz gibi oldu.

Şimdi iste, aynı cluster da başka bir ekibin daha, bir uygulama deploy ettiğini düşünelim. Onlarda tanımlarını yaptılar ve kubernetes api'na gönderdiler. Podlar schedule edilmeye başlandı ve bazı podlar blue olarak etiketlenmiş worker node da, bazı podlar green olarak etiketlenmiş worker node da, bazı podlar da sonuncu worker node da çalışmaya başladı.

Bu istediğimiz bir durum ise, bunda bir sıkıntı yok elbette. Kubernetes sıradan en uygun nodeları seçip, yeni iş yüklerini buralarda çalıştırmaya başlayacak.

Fakat biz, color=blue olarak işaretlenmiş worker node üzerinde sadece blue uygulamasının çalışmasını istiyorsak veya green olarak etiketlenmiş node da sadece green uygulaması çalışsın istiyorsak bunu node affinity veya pod affinity ile sağlayamayız. Affinity tanımları bir podun nerede schedule edileceğini belirtir. Yani pod'a göre bir tanımdır.

Bizim ihtiyacımız misal, şu, şu worker nodelarda sadece şu tipte uygulamalar çalışsın ise, affinity bunu sağlamaz.&#x20;

Misal bizim 10 node dan oluşan bir clusterımız var, Bu 10 node dan, 3 tanesi en hızlı işlemcilere, en yüksek ram kapasitesine ve hızlı disklere sahip, diğer 7 node ise bunlara göre daha yavaş, bu durumda şunu isteyebiliriz. Sadece müşterilerimize dönük uygulamalarımız bu hızlı nodelar üzerinde çalışsın, test uygulamalarımız veya düşük öncelikli uygulamalarımız hiç bir zaman bu hızlı worker nodelarda schedule edilip, kaynakları boşuna tüketmesin. Yani uzun lafın kısası, sadece belirli tipte podlar bu hızlı nodelar üzerinde schedule edilebilsin.&#x20;

Bu tür tanımları taint ve toleration tanımlarıyla gerçekleştirebiliyoruz. Biz bir worker node'a anahtar veri eşlenikleri şeklinde bir taint ve bu taint ile birlikte NoSchedule|PreferNoSchedule|NoExecute olmak üzere bir emir ekleriz. Bu aşamadan itibaren, bu node üstünde, sadece bu tainti, yani bozukluğu tolere edecek podlar çalışır.

Örneğin, ben bir worker node a "platform=production:NoSchedule şeklinde bir taint eklersem, bu tainti tolere edecek bir tanım eklenmemiş hiç bir pod, bu node üzerinde schedule edilemez.&#x20;

Aynı şekilde, "platform=production:PreferNoSchedule" şeklinde bir tanım eklersek,  bu seferde mümkünse, bunu tolere edemeyen hiç bir pod bu worker node üzerinde schedule edilemez. Ama ilgili pod için uygun başka bir node bulunamazsa da, Son seçenek olarak bu worker node üstünde pod çalıştırılır.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FVRVg7ZgVQixA8Hu45VnD%2Ftaints-tolerations-kubernetes-security-1.png?alt=media\&token=0a48b9c5-f0fb-4cf7-8376-e44537a3cc5c)

NoExecution ise, dikkatli kullanılması gereken bir seçenektir. Ben bir worker node a "platform=production:NoExecution" şeklinde bir taint tanımı girersem, bu tainti tolere edemeyen hiç bir pod burada schedule edilemez ve mevcut durumda worker node üzerinde bu tainti tolere edemeyen pod ve podlar varsa, ilgili podlar bu worker node üzerinden silinerek, başka uygun worker nodelarda yeniden oluşturulur.

Node'lara taint ekleme.

```bash
kubectl taint node "node_ismi" "anahtar=değer:eylem"

Ör: kubectl taint node worker-1 platform=production:NoSchedule
```

Yukarıdaki komutla şunu diyoruz, eğer bir pod tanımında, "platform=production:NoSchedule" şeklinde bir toleration tanımı yoksa, o pod burada schedule edilemeyecek.

Node'lardan taint kaldırma.

```bash
kubectl taint node "node_ismi" "anahtar-"

Ör: kubectl taint node minikube platform-
```

Örnek bir Toleration kullanımı;

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: toleratedpod1
  labels:
    env: test
spec:
  containers:
  - name: toleratedcontainer1
    image: alpine
  tolerations:
  - key: "platform"
    operator: "Equal"
    value: "production"
    effect: "NoSchedule"
---
apiVersion: v1
kind: Pod
metadata:
  name: toleratedpod2
  labels:
    env: test
spec:
  containers:
  - name: toleratedcontainer2
    image: ubuntu
  tolerations:
  - key: "platform"
    operator: "Exists"
    effect: "NoSchedule"
```

1. pod tanımında gördüğünüz gibi, bu podun tolere edebileceği taint tanımı toleration kısmında aynı taint tanımı ekler gibi eklenmiş. Key kısmına anahtar, operator kısmına Equal yani eşittir. Value kısmınada değeri giriyoruz. Ardından da effect kısmına aynı effecti giriyoruz. Bu podun tainti tolere edebilmesi için, birebir aynı tolerations tanımının yapılması gerekiyor. Biz de bu pod tanımında bunu sağlamış oluyoruz.
2. pod tanımında ise, bu sefer key kısmında anahtar var, fakat value kısmı yok, Onun yerine operator kısmına "Exists" girilmiş.  "Effect" kısmı ise aynı, bu da şu demek, Eğer Platform ve NoSchedule olarak girilmiş bir taint tanımı varsa, bunu tolere et. Yani değeri önemli değil.

Tolerations kısımları bu şeklilde, neyi tolere edeceksek, onun aynısını tolerations kısmına giriyoruz. Taint ve tolerations node affinity'nin yaptığını yapmaz. Bir poda git şu taintin olduğu yerde schedule ol demez, Tolerations sadece şunu der; Eğer scheduler podu schedule etmek için seçtiği node üstünde, bu taint varsa onu tolere edebilirsin. Yani bu pod şurada oluşturulsun node affinity'nin işidir. Worker node üzerinde sadece şu podlar çalışabilsin taint ve tolerations'un işidir.


# DaemonSet

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FR4ukGpimK2rihwFUPOF7%2FDaemonSets.webp?alt=media\&token=a344a845-d6de-4313-98ab-c83c491ea7f4)

Misal 20 worker node'dan oluşan bir kubernetes clusterımız mevcut,  bizim bu worker nodeların tamamında çalışması gereken bir uygulamamız var. Biz bu worker nodelarda oluşan logları merkezi bir log sunucusuna göndermek istiyoruz.

Her bir worker node da bir uygulama çalıştıracağız ve bu uygulama o worker node da oluşan logları toplayacak ve merkezi log sunucusuna gönderecek.

Tek, tek tüm worker loglara bağlanıp, bu uygulamayı buraya kurup ayarlayabiliriz. Ancak bu da fazlasıyla iş yükü çıkartacaktır. 2.seçenek olarak, bu uygulamayı bir container imajı haline getiririz, ardından gerekli ayarların olduğu 20 pod tanımı yaparız, her birine node affinity ekleyip ve bu podları ayrı ayrı worker nodelar üstünde çalışacak şekilde deploy ederiz. Ancak bu senaryoda da yeni worker nodelar eklediğinde tüm bu işlemleri tekrar etmemiz gerekecektir.

Burada bize çözüm için, DaemonSet yardımcı olmaktadır.

DaemonSet, tüm (veya bazı) node'ların bir podun bir kopyasını çalıştırmasını sağlar. Cluster'a yeni node eklendikçe yeni eklenen bu worker nodelara da bu podlar eklenir. Cluster'dan node kaldırıldığında/silindiğinde bu podlarda kaldırılır. Bir daemonset silindiğinde, oluşturduğu podlar da silinecektir.

DaemonSet, Deployment objesine benzer bir kubernetes objesidir. Bir daemonset objesi oluşturulduğumuz zaman DaemonSet sistemdeki tüm nodelar üstünde template altında belirttiğimiz pod tanımına göre bir pod oluşturulur.  Varsayılan olarak, her node üstünde bir pod oluşturulur. Fakat biz bunu değiştirerek sadece belirli tiplerdeki node'lar üstünde oluşturulmasını sağlayabiliriz.

DaemonSet, her node da çalışmasını istediğimiz Log toplama uygulamaları, Storage Provision uygulamaları gibi uygulamaları kolay bir şekilde deploy edilmesini sağlar. Bizlerin bu tarz uygulamaları ayağa kaldırmak için tek, tek tanım yapmamız yerine, Bir daemonset oluşturarak, uygulamaları deploy etmemiz bize şu avantajları sağlar;

\=> İş yükü hafifler ve iş çok basite indirgenir.\
\=> Her yeni eklenen node için tekrar, tekrar ayar yapmamıza gerek kalmayacak. Çünkü daemonset sistemde yeni bir node tespit ettiği zaman, o node içerisinde bir pod oluşturup, uygulamanın orada da çalışmasını otomatize eder.

DaemonSet tanımı Deployment Objesine çok benzer bunu yukarıda da belirtmiştik. DaemonSet oluştururken bir yaml dosyasında istediğimiz özellikleri gireriz. Burada Deployment 'dan önemli bir farkı Deployment objesinde bulunan rollout özelliklerinden faydalanamıyoruz.

{% code title="deamonset.yaml" %}

```yaml
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: logdaemonset
  labels:
    app: fluentd-logging
spec:
  selector:
    matchLabels:
      name: fluentd-elasticsearch
  template:
    metadata:
      labels:
        name: fluentd-elasticsearch
    spec:
      tolerations:
      # this toleration is to have the daemonset runnable on master nodes
      # remove it if your masters can't run pods
      - key: node-role.kubernetes.io/master
        effect: NoSchedule
      containers:
      - name: fluentd-elasticsearch
        image: quay.io/fluentd_elasticsearch/fluentd:v2.5.2
        resources:
          limits:
            memory: 200Mi
          requests:
            cpu: 100m
            memory: 200Mi
        volumeMounts:
        - name: varlog
          mountPath: /var/log
        - name: varlibdockercontainers
          mountPath: /var/lib/docker/containers
          readOnly: true
      terminationGracePeriodSeconds: 30
      volumes:
      - name: varlog
        hostPath:
          path: /var/log
      - name: varlibdockercontainers
        hostPath:
          path: /var/lib/docker/containers
```

{% endcode %}

Yukarıdaki daemonset template yaml dosyasını kubernetes API'na gönderdiğimiz zaman, daemonset objesi oluşturulacak ve daemonset template altında gördüğümüz özelliklerde birer podu nodelar üzerinde çalıştırmaya başlayacak.&#x20;

İlk olarak deployment objesindeki gibi, daemonset 'de label selector tanımı mevcuttur ve daemonset oluşturacağı podları bu selector'e göre seçer. Bu nedenle, aynı label tanımının spec kısmında da olması gerekmektedir.

Bizler kendi kurduğumuz clusterlarda yada cloud servis sağlayıcılarda master nodelarda pod çalıştırmayız.  Master nodelarda "node-role.kubernetes.io/master:NoSchedule" şeklinde bir taint eklidir. Dolayısıyla bunu tolere edecek bir tanım ekli değilse, pod master node üzerinde schedule edilmez.

Biz bir DaemonSet oluşturuyoruz, Eğer biz DaemonSet 'i sadece worker nodelarda pod oluşturmasını istiyorsak, o zaman bir şey eklememize gerek yok. Ama bizim DaemonSet'in, master nodelarda da pod oluşturmasına da ihtiyaç duyuyorsak, o zaman bu tolerations tanımını bu yaml dosyasına eklememiz gerekmektedir.

Yaml dosyasında da gördüğünüz üzere, bu daemonset fluentD isimli imajdan podlar oluşturacak. Bu uygulama kubernetes dünyasında iyi bilinen log toplama aracıdır.&#x20;

Yaml dosyamızdan DaemonSet objesi oluşturacağız, DaemonSet yukarıdaki tanımlara göre tek, tek podları oluşturacak. Tolerations tanımımız olduğu için, master node'larda dahil, sistemdeki tüm node'larda bu podlar oluşturulacak.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FTpuUGzza9C4IJE2wRSHm%2F1_ZHIOWZiEwjhVYilUR0HyTQ.png?alt=media\&token=aba17fcc-ab19-47d6-9cb7-db9da8bf991b)

Fakat bazen biz, sadece bazı tip nodelarda pod oluşturan bir daemonset de oluşturmak isteyebiliriz. Örneğin, log uygulamamızın sadece production için oluşturulan node'larda çalışmasını, test podlarımızın koştuğu ve onlara ayrılmış node'larda çalışmamasını isteyebiliriz. Bu şekilde belirli node'larda kısıtlama yapmak istiyorsak, bu tanıma nodeselector veya node affinity yanında, taint ve tolerations tanımlarıda ekleyerek bunu sağlayabiliriz.

<mark style="color:red;">Varsayılan olarak DaemonSet, her node üzerinde istediğimiz POD'u oluşturacaktır.</mark>


# PV/PVC

persistent volume and persistent volume claim

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fy5YgDxwZZ2IcJ8BWxJnh%2Fgraphic-of-persistent-volume-bond.png?alt=media\&token=ecc94bb0-04d5-4ae0-ae35-14e24e090141)

Ephemeral volume bölümünde, podun yaşam süresi boyunca saklamak ve yeni container oluşturulduğunda kaybetmemek istediğimiz dosyaları tutmak için "emptydir" ve "hostpath" tipinde volumelerin nasıl oluşturulduğunu görmüştük.

Bu yazıda, podun yaşam süresinden bağımsız şekilde oluşturabileceğimiz volumeleri yani persistent volumeleri inceleyeceğiz.

Sorun nedir?

İlk olarak 3 node'lu bir cluster'mız olduğunu düşünelim. 3 node'lu cluster üzerinde mySQL bir veritabanı çalıştırmak istiyoruz. Bunun için tek replika oluşturacak deployment tasarladık. Deployment içerisinde de mysql container'ın veritabanı dosyalarını tutacağı "emptyDir" tipinde bir volume oluşturmak için bir tanım girdik. Bu volume'u container'a mount edecek tanımlarıda ekledikten sonra, Deployment objemizi oluşturduk. mySQL container'dan oluşan podumuz uygun bir worker node üzerinde oluşturuldu ve çalışmaya başladı. Bu nokta da eğer container'da bir sıkıntı olursa, kubelet yeni bir container oluşturacak ve biz volume tanımını da eklediğimiz için sıkıntı çıkmadan çalışmaya devam edecek.

Ancak şöyle bir senaryo düşünelim;

Bu podun çalıştığı worker node da sıkıntı çıktı ve worker node devre dışı kaldı. Podumuz deployment objesinin bir parçası olduğu için, Kubernetes bu durumu düzeltmek için çalışmaya başlayacak ve uygun olan worker node'lardan bir tanesi üzerinde yeni pod yaratılacak. Fakat bu durum ephemeral volume kısmında da belirttiğimiz uygulama için sıkıntı yaratmıyorken, bu sefer mySQL veritabanımız için problem oluşturuyor. Çünkü veritabanı üzerinde geçici, yeniden kolayca üretebileceğimiz dosyaları değil, uzun süre barındırmak zorunda olduğumuz verileri tutuyor.

Pod'a ne olursa olsun, bu verileri kaybetmememiz gerekiyor. Pod'u oluşturduk, mySQL container çalıştı ve verileri "emptyDir" tipindeki volume'e yazmaya başladı. Bu volume fiziksel olarak o container'ın çalıştığı worker node üzerinde duruyor. Artık o worker node'a erişim gittiği için, Dolayısıyla pod başka bir worker node üstünde yeniden oluşturulduğunda, bu dosyalara erişilemeyecek. Ve bu mySQL için fazlasıyla kötü bir senaryodur.

Bunun için tek bir çözüm var, bizim bu volume'leri cluster dışında duran, fakat tüm worker node'lar tarafından ulaşılabilen bir yerde oluşturabiliyor olmamız lazım.

Eğer bunu başarabilirsek, pod hangi node üzerine taşınırsa taşınsın, aynı volume tekrar bağlayarak veri devamlılığı sağlayabiliriz. Bu tarz cluster dışında tutulan çeşitli türde depolama ünitelerinin üzerinde, oluşturabildiğimiz ve pod yaşam süresinden bağımsız ve daha uzun süre saklamamız gereken verileri saklamamıza imkan veren volume'ler mevcut. Biz bunlara Persistent Volume diyoruz.

Persistent Volume nasıl oluşturuyoruz?

Bunun için öncelikle, bir kaç ayar yapmamız gerekiyor. İlk olarak volume oluşturmak istediğimiz depolama birimi ile cluster'mızın konuşabiliyor olması gerekiyor.&#x20;

Bunun içinde cluster üstünde, bu depolama biriminin volume driver'larının yüklenmesi gerekiyor. Kubernetes, NFS-ISCSI gibi unıversal protokollere ait driver'ların yanında, AzureDisk-AzureFile-AWS EBS-Google PD-CEPHFS gibi bir çok bulut servis sağlayıcının özel storage çözümlerine ait driver'ları bünyesinde barındırıyor.

Yani Kubernetes, varsayılan olarak bu tiplerdeki depolama çözümleri ile konuşabiliyor durumdadır. Fakat depolama çözümleri sadece bunlarla sınırlı değildir. Kubernetes bunların yanında farklı depolama çözümleri ile de konuşabilecek yetenekleri, Container Storage Interface (CSI) adlı bir arayüz ile sağlıyor.&#x20;

CSI, isteğe bağlı blok ve dosya depolama sistemlerini Kubernetes gibi Container Orchestration'lar üzerindeki Container iş yüklerine maruz bırakmak için bir standart olarak geliştirmiştir. CSI'ın benimsemesiyle kubernetes volume katmanı genişletilebilir hale geldi. 3. taraf depolama sağlayıcıları, CSI kullanarak çekirdek kubernetes koduna dokunmak zorunda kalmadan Kubernetes'de yeni depolama sistemlerini açığa çıkaran eklentiler yazabilme imkanına kavuştu.

CSI, Kubernetes'in storage altyapısının nasıl ayarlanması gerektiğini belirten bir standarttır. Depolama çözümü üretenler, bu standart'a uygun driver'lar yazarak Kubernetes'in kendi alt yapılarıyla da konuşabilmelerine imkan sağlayabiliyorlar.

Yani özetlersek, bağlanacağımız depolama birimi volume driver kısmında saydıklarımızdan ise, (NFS,Azure,EBS) vb. bunlarla ilgili driver'lar hali hazırda Kubernetes üzerinde mevcut. Ancak bunlardan biri değilse, misal NetAPP firmasının sağladığı depolama cihazını kullanıyorsam da, bu sefer o firmanın(NetAPP misal) bize sağlayacağı CSI driver'nın sisteme yüklememiz gerekecektir.

İlk adım bu şekilde. Öncelikle cluster ile depolama alt yapısını birbirine bağlıyoruz ve bu işi halledip, Kubernetes cluster ile depolama birimini konuşabilecek hale getirdikten sonra, bizler gidip bu depolama birimi üzerinde Kubernetes Cluster'mız altında kullanmak için, depolama birimleri yaratıyoruz. Sonrasında da bu depolama birimini karşılığını Kubernetes Cluster'mız altında, persistent volume isimli bir obje olarak oluşturuyoruz.

Örnekle, Kubernetes Cluster'mızın erişebildiği NFS tabanlı bir depolama çözümümüz olduğunu varsayalım. Kubernetes altında, NFS driver'ları bulunduğu için, ek bir driver yüklememize gerek kalmadan bu 2 ortam birbirleri ile görüşebilir durumda. Sırada ise, bu depolama ünitesi üzerinde, bizlerin erişip kullanabileceği, depolama birimleri oluşturmakta. Bizler gidip NFS cihazımıza bağlanıyor ve örneğin "tmp" adında bir paylaşım yaratıyoruz. Bu işi de hallettikten sonra, sıra geldi bunun Kubernetes tarafında karşılığını yaratmaya. İşte bu nokta da oluşturacağımız objenin adı "Persistent Volume"dir.

![Örnek PV yaml dosyası.](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FF9XNRyptm5g5lvFwPrL0%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-06-15%20122020.png?alt=media\&token=5f1a94d4-14f0-4fa2-b7d7-2bfb867ec695)

Yukarıda gördüğünüz gibi apiVersion: 1 olan, tipi de Persistent Volume olacak şekilde bir obje yaratıyoruz. Spec kısmı bağlanacağımız depolama ünitesine bağlanırken, kullanılacak driver'a göre değişebilir.&#x20;

Burada driver'a göre değişmeyen 3 seçenek mevcut.

Capacity => Bu parametre bize ne kadarlık bir volume yaratmak istediğimizi belirtiyor. Yukarıdaki örnekte 5GB boyutunda bir volume oluşturduğumuz belirtilmiş.

AccessMode => Bu volume'ın aynı anda birden fazla, pod'a bağlandığı zaman, ne şekilde bir davranış sergileyeceğini seçiyoruz. Burada da seçenekler 3'e ayrılıyor.\
&#x20;   1- ReadWriteOnce=> Bu volume aynı anda sadece tek bir pod'a bağlanabilir ve bağlanan pod hem     yazabilir hem de okuyabilir.\
&#x20;   2- ReadOnlyMany => Bu volume aynı anda birden fazla poda bağlanabilir. Fakat podlar sadece bu volume de daha önceden bu volume eklenmiş dosyalar mevcut ise onları okuyabilirler. Dosya yazamazlar ve oluşturamazlar.\
&#x20;   3- ReadWriteMany => Volume aynı anda birden fazla pod'a bağlanarak, hem yazabilir hem okuyabilir.

Burada kullandığımız seçenekler, depolama ünitemizin ve driver'ların yeteneklerine göre değişebilir.

Örneğin, Azure üzerinde AzureDisk kullanılırsa sadece "ReadWriteOnce" desteklenirken, AzureFile tipi bir storage ve driver kullanılırsa, bu sefer yukarıda bahsettiğim 3 seçeneğe de desteği mevcuttur.

PersistentVolumeReclaimPolicy => Burada bizler pod tarafından işi bitip, kullanılmayı bıraktıktan sonra, bu volume'e nasıl davranacağını belirtiyoruz. Burada, retain-recycle-delete seçenekleri mevcuttur.

Retain seçeneği seçildiği durumda, bu persistent volume kullanıldıktan sonra olduğu gibi kalıyor ve bizler buradaki dosyaları manuel olarak kurtarıp, başka bir yere taşıma imkanına kavuşuyoruz.

Recycle seçeneğini seçtiğimiz durumda, bu sefer volume ile işimiz bittiğinde volume silinmiyor, fakat içindeki tüm dosyalar siliniyor. Bizler tekrar boş bir volume elde ederek başka işlerimizde kullanabiliyoruz.

Delete seçeneğini seçtiğimiz durumda, volume ile işimiz bittiğinde volume tamamen siliniyor.

Yukarıdaki örneği ele alırsak, NFS tabanlı erişim sağlayan 172.17.0.2 IP adresi üstünden erişilebilen bir depolama ünitesi üstündeki "TMP" isimli paylaşımı kullanacak. 5GB boyutunda, sadece tek bir pod'a bağlanabilecek ve bu pod tarafından, hem dosya yazmak hem de okumak için kullanılabilen pod'un, işi bittiği zaman içerisindeki dosyaların silineceği app=mySQL labeline sahip bir persistent volume oluşturuyoruz.

Bizler bir volume'ü direkt olarak bir pod ile eşleştirme imkanına sahip değiliz. Biz bir persistent volume'ü bir pod'a bağlamak için öncelikle Persistent Volume Claim tipinde bir obje daha yaratmamız gerekmektedir.

Persistent volume claim, bizlerin sistemde bulunan persistent volume'ler arasında işimize uygun olan bir tanesini seçmemize yani bunu kullanmak adına talep etmemize imkan veren objelerdir.

![Persistent Volume Claim için örnek yaml dosyası](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FJjoz66b2vSzqjUC6SgSE%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-06-15%20124624.png?alt=media\&token=4361f716-7af8-4150-a588-78a6e6449c6d)

Yukarıda gördüğünüz üzere, yine V1 api da bulunan, PersistentVolumeClaim tipinde bir obje yaratılıyor. Spec kısmı Persistent volume'e çok benziyor. Burada da, ne  kadarlık bir volume talep ettiğimizi, hangi mode ile bağlanmak istediğimizi belirtiyoruz. <mark style="color:red;">Son olarak "selector" kısmında, bu persistent volume claim ile persistent volume'ü label üstünden eşleştiriyoruz.</mark>

Persistent volume claim (volume talebi) app:mysql etiketine sahip, persistent volume tarafından sağlansın diyoruz.

Kubernetes neden depolama birimi oluşturma ve bunu talep etme işini 2 farklı obje üzerinden hallediyor?

Bunu şöyle düşünelim, bir developer olarak kullandığım kubernetes cluster'ı biz yönetmiyor olabiliriz. Bizim işimiz olmayabilir ve bu işe bakan ayrı bir ekip olabilir. Dolayısıyla oradaki işlemleri bizim bilmemiz mümkün olmayabilir.&#x20;

A firmasında NFS tabanlı bir depolama ünitesi kullanıyorken, B firmasında ISCSI tabanlı bir depolama ünitesi kullanılabilir. Bu ikisi için "Persistent volume" ayarları değişik olabilir. An önce persistent volume'den bahsederken de belirtmiştik. "Spec" altındaki ayarlar depolama ünitelerine göre değişebilir. Dolayısıyla bu volume oluşturma işini Developer ekibine verirsek, her cihaz için ayrı ayrı ayar yapmayı bilmesi gerekir. Bu da bir hayli zorlayıcı olacaktır.

Kubernetes bu sıkıntıyı volume oluşturma ve oluşturulan volume'ü talep etme işini ayırarak çözmüştür. Persistent volume'ler, kubernetes cluster'ı yöneten ve depolama ünitelerine de erişimi olan sistem yöneticileri veya cluster adminler tarafından oluşturulur.

Bu ekip, ortama uygun depolama ürünlerinde gerekli ayarlamaları yapar, kullanılabilecek volume'leri oluşturur, ardından developer ekibi, kendi podlarında kullanmak adına uygun özelliklerde "persistent volume claim" yaratır. Bu claim'i, ne çeşiit bir depolama çözümü ile karşıladığımız developer ekibinin bilmesine gerek olan bir bilgi değildir.

Developer ekibi talebi oluşturur, bu talep kimi yerlerde NFS depolama üniteleri ile, kimi yerlerde ISCSI ile çözüm sağlanır.&#x20;

Persistent Volume Claim oluşturulur, cluster da ki mevcut "persistent volume"lerden uygun olan bu talebi karşılar. Bu sayede depolama alt yapısının ayarlanması ve talep edilmesi 2 farklı ekip tarafından halledilebilir.

Ayrıca talep ve oluşturma adımları ayrıldığı için, tek bir talep yani "Persistent volume claim" tanımı bir çok cluster da kullanılabilir hale gelir ki, bu da uygulama taşınabilirliğini sağlar.

Elimizde artık persistent volume yani (pv) bir de persistent volume claim (pvc) mevcut. Gelelim bunu pod'a bağlamaya,

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F6TX2NR9WAFkeQERb9ZDb%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-06-15%20130919.png?alt=media\&token=3a2f7872-8e14-4540-a2d0-de232259a75f)

Pod tanımında bizler kullanmak istediğimiz volume'ü talep eden, persistent volume claim ile bir bağ kurarız. Pod tanımlarında, "spec" parametresi altında yeni bir volume oluşturur ve bunun hedefini oluşturduğumuz "persistent volume claim" olarak belirleriz. Sonrasında da bunu pod altında gerekli pathe mount ederiz. Bu pod oluşturulduğu anda bu talep devreye girer ve bu talebi karşılayan Persistent volume" objesindeki tanıma göre, bu podun oluşturulacağı worker node üzerinde ayarlamalar yapılır.

Storage cihazına bağlanılır, arkada driver yapması gerekenleri yapar, sonucunda da bu pod, içerisindeki container'ın ilgili pathine depolama cihazı üstünde duran, bu volume bağlanır.

Bu noktada itibaren, bu pathe yazılan dosyalar aslında bu volume'e yazılır. Eğer bu pod bulunduğu worker node üstünden bir şekilde silinir, başka bir worker node'a taşınırsa, bu sefer aynı işlemler, taşındığı worker node üzerinde gerçekleştirilir. Ve yeni pod, bu volume'e bağlanır. Bu sayede podun yaşam süresinden daha uzun süre boyunca veri saklayabileceğimiz, alt yapıya kavuşmuş oluruz.

{% code title="pv.yaml" %}

```yaml
apiVersion: v1
kind: PersistentVolume
metadata:
   name: mysqlpv
   labels:
     app: mysql
spec:
  capacity:
    storage: 5Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Recycle
  nfs:
    path: /
    server: 10.255.255.10
```

{% endcode %}

{% hint style="info" %}
Persistent volume cluster'dan bağlanabileceğimiz, bir depolama ünitesindeki paylaşımlara veya diskleri kubernetes podlarına mount edebilmemize imkan sağlıyor.
{% endhint %}

pv.yaml => Yukarıdaki örnekte, mysqlpv adında bir persistent volume oluşturuyoruz. Burada bir de label atıyoruz. Label kısmı önemli, çünkü persistent volume claim bu volume'ü bu label'a göre seçecek. 5G alan talep ediyoruz. Volume tipi olarak ReadWriteOnce seçiyoruz. En altta NFS sunucu IP adresi ve paylaşımın pathini belirtiyoruz. Buradaki ayarlar bağlanacağımız depolama ünitesine göre, kullanılacak driver'a göre değişir.

{% hint style="info" %}
Persistent volume talep eden, persistent volume claim oluşturmak gerekiyor. Böylelikle ilgili podlara bu volume'ü bağlayabiliriz.
{% endhint %}

{% code title="pvc.yaml" %}

```yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysqlclaim
spec:
  accessModes:
    - ReadWriteOnce
  volumeMode: Filesystem
  resources:
    requests:
      storage: 5Gi
  storageClassName: ""
  selector:
    matchLabels:
      app: mysql
```

{% endcode %}

pvc.yaml => mysqlclaim adında bir persistent volume claim oluşturuyoruz. Burada belirttiğimiz access moduda persistent volume tanımı ile aynı olmak zorundadır. Storage kısmında talep edilen alan mevcuttur. "selector" kısmı ile "matchLabels" kullanılarak "app:mysql" labeline sahip persistent volume seçiyoruz. Hangi "Persistent Volume"ü talep ettiğimizi burada belirtiyoruz(Label-Selector).

{% code title="deploy.yaml" %}

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: mysqlsecret
type: Opaque
stringData:
  password: P@ssw0rd!
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysqldeployment
  labels:
    app: mysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql
          ports:
            - containerPort: 3306
          volumeMounts:
            - mountPath: "/var/lib/mysql"
              name: mysqlvolume
          env:
            - name: MYSQL_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysqlsecret
                  key: password
      volumes:
        - name: mysqlvolume
          persistentVolumeClaim:
            claimName: mysqlclaim
```

{% endcode %}

deploy.yaml => (Pod tanımı ve volume'ü pod'a mount etmek) "mysqlvolume" adında volume tanımlıyoruz. Bu volume'de "mysqlclaim" isimli "persistent volume claim"den sağlanmasını talep ediyoruz. Ardından, "volumeMounts" parametresi ile pod'un "/var/lib/mysql" pathine mount ediyoruz.


# Storage Class

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FNdG93yJcSP4ZJZXsnXX2%2FStorageclass%20blog%20\(1\)-1.webp?alt=media\&token=9092a48e-f987-47a1-91fd-a3d3adfc85c3)

Manuel olarak persistent volume ve bunu talep edecek podlarımıza bağlamakta kullandığımız persistent volume claim konularını inceledik. Fakat tahmin edeceğiniz üzere, persistent volume'lerin statik olarak yaratılması gerekliliği bizleri oldukça zorlayacak bir durumdur.&#x20;

Örnek,

10 ayrı ekip tarafından kullanılan büyük bir kubernetes cluster'mız olduğunu düşünelim. Onlarca farklı worker node, yüzlerce pod oluşturuluyor. Onlarca değişik uygulama, çeşitli ekipler tarafından yönetiliyor, siliniyor, güncelleniyor.&#x20;

Bizimöm böyle bir ortamda persistent volume ihtiyacımız olduğunda, her seferinde, önce storage cihazına gidip, paylaşım oluşturmamız, ardından onun karşılığı olan PV objesini oluşturmamız zahmetli olacaktır.

Bu zahmeti ortadan kaldırmak için Kubernetes biz PVC oluşturduğumuz anda depolama ünitesi ile haberleşerek, gerekli ayarları yaparak bize bir volume ve PV objesi oluşturan bir obje sunuyor. Bunun adı da "Storage Class"dır.

Storage Class yöneticilerin, sundukları depolama "sınıflarını" tanımlamaları için bir yol sağlar. Farklı sınıflar, hizmet kalitesi düzeylerine veya yedekleme ilkelerine göre, cluster yöneticileri tarafından belirlenen isteğe bağlı ilkelere eşlenebilir. Kubernetes sınıflarının neyi temsil ettiği konusunda bilgi sahibi değildir. Bu kavram bazen de diğer depolama sistemlerinde "profiller" olarak adlandırılır.

Yani uzun lafın kısası, PV objesini manuel oluşturmak yerine, PVC objesine göre dinamik olarak oluşturma imkanı getirir. Bu özellikle Cloud Servis Sağlayıcılarının dinamik ortamlarında, her şeyi otomatize edebilirken, Sırf volume oluşturma işini manuel halletme saçmalığını ortadan kaldırır.

Storage Class objelerini bağlantımız olan depolama üniteleri üzerinde, ne çeşit bir volume yaratabileceğimizi belirleyen template'ler olarak düşünebiliriz.

Misal, üzerinde hem hızlı ssd, hem de yavaş mekanik disk olan storage ünitemiz olduğunu düşünelim. Bu durumda biz yavaş disklerin üstünde de otomatik volume yaratan, "yavas" isimli bir storage class ve hızlı diskler üstünde çalışan volume yaratan "hizli" isimli, storage class'lar oluşturabiliriz.

Developer ekipleri, uygulamalarında kullanmak için, volume talep etmek yerine PVC 'de uygulamalarının ihtiyaçlarına göre bu Storage Class'lardan birini seçerler ve istedikleri boyutta bir volume Storage Class objesi tarafından otomatik olarak oluşturulup, PVC'ye bind edilir.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FCVpEZup88TspmphME5lS%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-06-15%20140448.png?alt=media\&token=762b0802-2eb8-4d8d-93d2-eabf55380ed9)

```bash
kubectl get sc 

# Sistemde bulunan storage class'ları listeler.
```

Yukarıdaki StorageClass özelliklerini inceleyelim,

Provisioner => Bizlere hangi tipte cihaz üstünde, volume oluşturmak istediğimizi belirtiyor.

Reclaim Policy => Bu disk kullanıldıktan sonra, işimiz bittikten sonra ne olacak? Hatırlarsanız bu ayarı PV oluştururken giriyorduk. Şimdi Storage Class tanımlarında giriyoruz. Ek olarak burada "recycle" özelliğini kullanamıyoruz. "retain" ve "delete" seçebiliyoruz.

volumebindingMode => Immediate :  Bir PVC oluşturudulduğu anda, volume'un oluşturulup, hemen PVC'ye bind edilmesi gerektiğini söyler.

volumebindingMode => WaitForfirstConsumer :  Pod oluşturulup, atanana kadar bu volume'un oluşturulmamasını söyler.

Bu 2 seçenek, altyapıda kullanılan storage özelliklerine göre değişiyor.

{% code title="sc.yaml" %}

```yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: standarddisk
parameters:
  cachingmode: ReadOnly
  kind: Managed
  storageaccounttype: StandardSSD_LRS
provisioner: kubernetes.io/azure-disk
reclaimPolicy: Delete
volumeBindingMode: WaitForFirstConsumer
```

{% endcode %}

Yukarıdaki örnekten yola çıkacak olursak, "standarddisk" isimli bir storageclass oluşturuyoruz. Geri kalan ayarlar kullandığımız depolama ünitesine göre değişiyor.&#x20;

AzureDisk üzerinde storage class oluşturmak istediğimiz için, provisioner olarak bunu seçiyoruz. Geri kalan ayarları AzureDisk oluşturacaksak AzureDisk dökümanından, farklı bir storage ünitesi için storage class oluşturacaksak, bunu ilgili cihazın/ürünün dökümanlarından bulup, burayı dökümana göre düzenleyebiliriz.&#x20;

Artık volume oluşturmak için PV oluşturmamıza gerek yok. PVC oluşturduğumuzda, ilgili diski hangi storage class'dan istiyorsak, otomatik/dinamik olarak bize sunuyor.

{% code title="pvc.yaml" %}

```yaml
Version: v1
kind: PersistentVolumeClaim
metadata:
  name: mysqlclaim
spec:
  accessModes:
    - ReadWriteOnce
  volumeMode: Filesystem
  resources:
    requests:
      storage: 5Gi
  storageClassName: "standarddisk"
```

{% endcode %}

Storage Class için PVC oluştururken, artık "selector" kullanarak, hangi PV olacağını ve kullanmak istediğimiz PV objesini seçmiyoruz. Bunun yerine yukarıda örnekte gördüğünüz üzere,  StorageClassName kısmında, kullanmak istediğimiz storage class'ı seçiyoruz(ismini giriyoruz). Bu örnekte yukarıda örneğini paylaştığım "standarddisk" storage class'ı kullanıyoruz.

Bu PVC şu manaya geliyor.

Git "standarddisk" storage class tanımındaki, özelliklere göre "5G" ve erişim modu "ReadWriteOnce" olan bir persistent volume oluştur.

PVC 'yi aynı mantık ile pod'a mount edebiliyoruz. PV-PVC bölümünde mount ettiğimiz gibi.

{% code title="deploy.yaml" %}

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: mysqlsecret
type: Opaque
stringData:
  password: P@ssw0rd!
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysqldeployment
  labels:
    app: mysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql
          ports:
            - containerPort: 3306
          volumeMounts:
            - mountPath: "/var/lib/mysql"
              name: mysqlvolume
          env:
            - name: MYSQL_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysqlsecret
                  key: password
      volumes:
        - name: mysqlvolume
          persistentVolumeClaim:
            claimName: mysqlclaim
```

{% endcode %}

Artık storageclass sayesinde, PV objesini önceden oluşturmamıza gerek kalmıyor. PV objesini nasıl oluşturacağımızı bilmemize gerek kalmıyor.

Yani biz, kullanacağımız disk ünitelerine göre storageclass tanımı yapıp, bunu PVC objesi ile çağırmamız yetiyor. PV objesi, PVC objesini tanımladıktan sonra otomatik olarak oluşacak.

{% hint style="info" %}
Çoğu Bulut servis sağlayıcının birden fazla özel storage class'ları bulunuyor. Eğer bir bulut servis sağlayıcıdan yönetilen Kubernetes hizmeti alıyorsanız, bunları kullanabiliyorsunuz.
{% endhint %}

Hangi storage class'ı kullanmak istiyorsak, bu kullanmak istediğimiz storage class'ı belirttiğimiz bir PVC objesi yaratıp, bu PVC objesini de bir pod'da ihtiyacımız olan pathe mount etmemiz yeterlidir.

PVC yaml dosyasında bulunan, "storageclassname" de belirttiğimiz storage class'a bakarak, bir PV oluşturulur. Yani storage class aslında kullanacağımız disk ünitesine göre değişen, PV objesini otomatik olarak oluşturulmasını sağlayan bir template'dir diyebiliriz.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FjOfIc2tkvSz31knEhyWt%2FRight_Sized_PV.png?alt=media\&token=fa32c4d7-6c9a-4f87-809a-cea7df985fd0)


# StatefulSet

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F99acAibwDIS7bYZLkDgB%2FStatefulSets.webp?alt=media\&token=9f7430de-f928-47d5-b116-d41b7c0c1c17)

Kubernetes'in stateless iş yükleri için, uygun bir platform olduğundan, state tutan iş yükleri için ise bir çok problem ile karşılaştığımızdan önceki bölümlerde söz etmiştik.&#x20;

Ephemeral ve Persistent volume konularında ise, bu sorunları ortadan kaldırmak adına, kullanabileceğimiz objeleri gördük ve işin depolama kısmını çözdük. Ancak stateful uygulamalarda, tek sıkıntımız depolama değil. Bunu çözmüş olsak da, şu ana kadar işlediğimiz obje tipleri diğer sorunlarımızı çözmüyor.&#x20;

İşte bu durum ile başa çıkmamıza yardımcı olacak obje tipi olan, statefulSet objesinden bahsedeceğiz.

Sorun nedir?

İlk olarak kendimize sorun oluşturalım; 3 pod oluşturacak, bir deployment objesi oluşturduğumuzu düşünelim. Bu deployment objesi, bildiğiniz üzere bir replicaset oluşturuyor ve bu replicaset 'de, bizim belirlediğimiz tanıma göre random isimler verilen, birbirinin aynısı podlar oluşturuyor.

Bu replicaset altında oluşturulan podların, birbirinden farkı yok. Ve bu nedenle kubernetes bunlara eşit davranıyor. Biz bu deployment objesini, yukarı doğru scale ettiğimiz zaman, istediğimiz sayıda yeni pod ekleniyor ve aşağı doğru scale edersek de, bu sefer bu podlardan istediğimiz sayıda pod **rastgele** olarak siliniyor.&#x20;

Yani 5 podlu deployment objesini, 3 pod'a indirmek istersek, kubernetes ilk hangisi yaratılmış, hangisi diğerinden önce yaratılmış vb şeylere bakmıyor ve rastgele olarak 2 podu siliyor. Podlar üzerinde herhangi bir state tutulmadığı için bu durum sıkıntı yaratmıyor. &#x20;

Fakat şöyle bir senaryo da,

Misal, yeni nesil noSQL veritabanlarından birini kubernetes üzerinde deploy etmek istiyoruz. Bu veritabanları hemen, hemen hepsi şu şekilde çalışır. Bir adet master instance bulunur ve bunun üzerinden bir cluster oluşturulur. Ardından bu cluster'a yeni instance'lar ekleriz. Yazma işlemlerini master üzerinden yaparken, sorguları herhangi bir instance'a gönderebilirsiniz.

Tüm veri bu istancelar üstünde dağıtık şekilde durur.&#x20;

Böyle bir veritabanı alanı olan, apache cassandra 'yı 3 instance'dan oluşacak, bir cluster olacak şekilde şu ana kadar öğrendiğimiz obje tipleri ile kubernetes'e deploy ettiğimizi düşünün,&#x20;

Bunun için nasıl bir yol izleyeceğiz?

Cassandra master olacak instance'ı deploy edeceğiz, ardından buna bağlanarak yada başlangıç komutları ile cassandra uygulamasını master hale getirecek şekilde, bir cluster oluşturacağız. Sonrasında 2. instance oluşturacağız ve bu 2. instance bağlanıp, 1.instance'daki cassandra cluster'a  2.instance'ı dahil edeceğiz. Ardından 3.instance oluşturup, aynı işlemleri yapacağız. Böylelikle 3. instance ile bir cassandra cluster'mız olacak.

Kubernetes'de nasıl ayağa kaldıracağız?

Bu adımları takip ederek, Kubernetes de nasıl bu uygulamayı ayağa kaldıracağımıza bakalım,

İlk olarak singleton podlar şeklinde deploy etmeyi deneyelim, Master olacak instance oluşturacak pod tanımını yaptık içine PVC tanımı ekledik ki, cassandra verileri tutabilecek, bir  PV'ye sahip olabilsin. Pod ayağa kalktı, bunu master hale getirecek komutları, ya başlangıç komutu olarak yada sonrasında bağlanıp hallettik. Ardından 2. pod tanımı daha yaptık, bunu da, 2.instance olarak ayağa kaldırdık. Ardıdan 3.pod tanımını yapıp, ayağa kaldırdık. Ve böylelikle gerekli ayarları yaptıktan sonra, cluster ayağa kalktı.&#x20;

Ancak burada bir çok sorun var,&#x20;

-İşlemler manuel ve zahmetli\
-Singleton podların fail durumunu kontrol eden bir mekanizma yok.\
-Yeni bir pod eklemek veya çıkarmak istersem, tüm süreci yönetiyorum.

SingletonPod işimize yaramadı, Peki deployment kullansak?

3 adet cassandra podu oluşturacak, deployment objesi oluşturduk ve deploy ettik. Bu deployment objesi 3 adet birbirinin aynısı pod oluşturdu ve hepsine rastgele bir isim verdi.  Problem şu ki, hepsi aynı anda oluşturuldu. Ben ilk oluşanı master olarak ayarlamak istesem de, ayarlayamam. Çünkü hepsi, bu sorun dersek, bu işlemleri manuel olarak yapalım. Bağlanıp, birini master'a çevirelim, Diğerlerine de tek, tek bağlanıp cluster'a kattık. Aradan zaman geçti, worker nodelardan birinde sıkıntı oldu ve cassandra podlarından birine erişilemiyor.&#x20;

Deployment objemiz tarafından yönetildiği için, sıkıntı değil, hemen yeni bir pod oluşturulur. Ama bu yeni pod tamamen rastgele bir isim alacak ve sıfırdan oluşacak. Misal bu bahsettiğimiz pod Master instance olarak ayarladığımız Pod ise ne yapacağız? Cluster bu durumda çökmüş olacak.

Yada şunu düşünün, scale down veya up işlemi yaptığımızda, kubernetes buraya rastgele bir pod ekleyecek veya rastgele olarak içlerinden birini silecek. Bunların hepsi stateless uygulamalar için problem değil, fakat gördüğünüz üzere cluster uygulamaları vb stateful uygulamalardan oluşan clusterlar kurmak istersek, mevcut kubernetes objeleri sıkıntımızı çözmüyor.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FJ7We7YrN5sI3HbxHyGkN%2F1_QrSDTMp-x8AZJYdQNdWacw.jpeg?alt=media\&token=2e31629f-bc23-4a4e-8aeb-12f567c72b44)

Tüm bu sıkıntıları çözmek adına, statefulset adında bir obje mevcuttur.

* Statefulset tarafından oluşturulan her pod, statefulset tanımında belirlediğimiz PVC'ye göre bir PV'ye sahip olur. Yani her podun kendine ait bir PV'si olur.
* Statefulset altında, podlar sırayla oluşturulup, sırayla silinir. Misal 3 podlu bir stateful oluşturduğumuz zaman, öncelikle pod0 oluşturulur. Ve bu pod ayağa kalkıp, readiness ve liveness checklerinden geçip, işlemlerini tamamlamadan bir sonraki pod oluşturulmaz. Ne zaman pod hazır ve running duruma geçer, o zaman bir sonraki pod oluşturulur.  Aynı şekilde 3.podda 2.pod tamamlanmadan oluşturulmaz. Tam tersi durumda da bu geçerlidir. Biz 3 podlu bir statefulseti 2 poda indirirseniz, kubernetes random bir pod seçip, onu silme yoluna gitmez.  En son yaratılan pod hangisi ise, ilk olarak o silinir.&#x20;
* Statefulset tarafından oluşturulan her pod'a statefulsetismi-0 1 2 3 şeklinde devam eden, sabit bir isim verilir. İsimler random seçilmez ve bu isimler aynı zamanda containerların hostname olarak da ayarlandığı için, her uygulama bu isimle ulaşabilir.&#x20;

Statefulset objesi, deployment objesine oldukça benzerdir. Yukarıda bahsettiğim özellikler haricinde aynıdır. Bu özellikler sayesinde, bizlerin stateful uygulamaları deploy etmemiz oldukça kolaylaşır.

Az önceki cassandra örneğini statefulset ile ayağa kaldıracak olursak,  3 pod oluşturacak bir statefulset objesi yaratıp, deploy ettik. Kubernetes hemen ilk podu ayağa kaldırdı. Biz bu poda başlangıç scripti eklemiştik. Bu script ortamda bizim belirlediğimiz isimde cluster var mı? yok mu? bunu kontrol ediyor. Ve yoksa bu isimle bir cluster oluşturuyor. Script çalıştı, ortamda bu isimle cluster olmadığı için, cassandra cluster'ı oluşturuldu. Liveness ve readiness probe tamamlandı ve artık hem cluster, hem de podumuz hazır.

Birinci pod sağlıklı şekilde çalışmaya başladığı anda Kubernetes 2.podu da oluşturmaya başladı, Bu podda da, aynı script var, ama bu sefer ortamda böyle bir cluster mevcut, dolayısıyla yeni bir cluster oluşturmak yerine, bu mevcut cluster'a dahil oldu. Liveness ve readiness probe tamamlandı ve bu pod hazır.&#x20;

Bu pod'da hazır olduğu için 3.pod da oluşturulmaya başlandı, onda da aynı işlemler uygulandı ve cluster ayağa kalktı.&#x20;

Şimdi bu podlardan, cassandra-1 podu silinirse, statefulset objesi, aynı podu, aynı isimle tekrar ayağa kaldırıp, aynı PV bu poda atanacak. ve sorun olmayacak.&#x20;

Yada yeni pod eklersek, yeni identy olacak ve aynı şekilde cluster'a katılacak. Scale down olursa da, herhangi birini seçip, silmek yerine en son oluşturulan silinecek. Gördüğünüz gibi, cassandra cluster oluşturma problemini bu özellikleri sayesinde "statefulset" ile çözebildik.&#x20;

Örnek statefulset objesi yaml içeriği,

```yaml
apiVersion: v1
kind: Service
metadata:
  labels:
    app: cassandra
  name: cassandra
spec:
  clusterIP: None
  ports:
  - port: 9042
  selector:
    app: cassandra
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: cassandra
  labels:
    app: cassandra
spec:
  serviceName: cassandra
  replicas: 3
  selector:
    matchLabels:
      app: cassandra
  template:
    metadata:
      labels:
        app: cassandra
    spec:
      terminationGracePeriodSeconds: 1800
      containers:
      - name: cassandra
        image: gcr.io/google-samples/cassandra:v13
        imagePullPolicy: Always
        ports:
        - containerPort: 7000
          name: intra-node
        - containerPort: 7001
          name: tls-intra-node
        - containerPort: 7199
          name: jmx
        - containerPort: 9042
          name: cql
        resources:
          limits:
            cpu: "500m"
            memory: 1Gi
          requests:
            cpu: "500m"
            memory: 1Gi
        securityContext:
          capabilities:
            add:
              - IPC_LOCK
        lifecycle:
          preStop:
            exec:
              command: 
              - /bin/sh
              - -c
              - nodetool drain
        env:
          - name: MAX_HEAP_SIZE
            value: 512M
          - name: HEAP_NEWSIZE
            value: 100M
          - name: CASSANDRA_SEEDS
            value: "cassandra-0.cassandra.default.svc.cluster.local"
          - name: CASSANDRA_CLUSTER_NAME
            value: "K8Demo"
          - name: CASSANDRA_DC
            value: "DC1-K8Demo"
          - name: CASSANDRA_RACK
            value: "Rack1-K8Demo"
          - name: POD_IP
            valueFrom:
              fieldRef:
                fieldPath: status.podIP
        readinessProbe:
          exec:
            command:
            - /bin/bash
            - -c
            - /ready-probe.sh
          initialDelaySeconds: 15
          timeoutSeconds: 5
        volumeMounts:
        - name: cassandra-data
          mountPath: /cassandra_data
  volumeClaimTemplates:
  - metadata:
      name: cassandra-data
    spec:
      accessModes: [ "ReadWriteOnce" ]
      storageClassName: standard
      resources:
        requests:
          storage: 1Gi
```

Replicas sayımızı belirtiyor ve label selector'a dikkat ediyoruz. Ardından template kısmında ise, oluşturulmasını istediğimiz pod tanımını giriyoruz. template içeriği kullandığımız image'a göre değişir.

Template kısmı haricinde, en altta "VolumeClaimTemplates" kısmı mevcut. Burada her bir pod için, bu özelliklerde bir PVC oluşturulmasını söylüyoruz.  Bu PVClerde standart isimli storage class'ı kullanarak, her bir pod için birer PV oluşturacak.&#x20;

Yani her podun, aynı PV'ye bağlanması yerine, her pod'a ayrı bir PV oluşturulacak. PVCleri VolumeClaimTemplates ile yaratıyoruz. PVCleri dahi kendimiz manuel olarak oluşturmuyoruz. statefulset objesini oluşturduğumuz zaman, PVC oluşturulacak, PVClerde gidecek PVleri oluşturup, podlara tek, tek bağlayacak.

En üst kısımda "service" tanımı mevcut, gördüğünüz gibi şu ana kadar oluşturduğumuz service tanımına oldukça benzer. Fakat tek fark mevcut, clusterIP=none olarak set edilmiş. Buna headless services diyoruz. Bunu oluşturduğumuz anda, ClusterIP tipinde, bir servis oluşturulacak, Fakat ana bir IP adresi atanmayacak. Bu bize şu konuda yardımcı oluyor; Ben ne zaman, bu servis ismine gitmek istersem, o bana bu servis altındaki podlardan bir tanesinin IP adresini dönecek. Bunun yanında her bir podda da, podismi.serviceismi şeklinde erişme imkanı sağlamış olacak.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FgM3Adncxxn5MONavAFEZ%2F1951_XIhmbB_qGimfr.png?alt=media\&token=5a8eb690-487d-42e1-8bf6-ad7924a88b5e)


# Job & Cronjob

Şu ana kadar gördüğümüz tüm kubernetes objelerinin tamamı müdahale edilip, kapatılmadığı sürece çalışmaya devam etmesi gereken uygulamalar ile ilgiliydi. Fakat bazı iş yükleri bu şekilde uzun süre çalışması gereken uygulamalar değildirler. Çalıştırılıp, işini yapıp, kapanması gereken bir çok uygulamalar mevcuttur.&#x20;

Eğer bu uygulamaları, diğer kubernetes objeleri (pod,deployment vb) ile oluşturursak, bunlar her kapandığında yeniden başlatılacak. Misal bir veritabanı uygulamamız var, biz buna bağlanıp "demo" tablosu adında tablo yaratan başka bir uygulama oluşturduk. Bu "demo" tablosunu yaratan uygulamayı gün içerisinde, ihtiyacamız olduğu anda çalıştırarak, bu tabloyu oluşturmak istiyoruz. Bu tablonun oluşup, verilerin set edilmesi yaklaşık 10 dakika sürdüğünü düşünelim. Biz bu uygulamayı container haline getirip, single pod olarak deploy etsek, uygulama çalışıp, işini halledip düzgün bir şekilde kapanırsa sıkıntı olmayacak. Fakat uygulama çakılırsa, single pod bunu tespit edip, yeniden başlamayacak. Bunun yanında, tek pod değilde aynı anda paralel olarak 3-5 pod birden çalıştırmak istesem, bu seferde single pod işimize yaramayacak. Mecburen Deployment objesi oluşturacağız, fakat bu seferde sıkıntı şu ki, benim bu uygulamamın, tek sefer çalışıp, işini düzgün yaparsa kapanması gerekiyor. Fakat deployment container kapandığında yeniden başlatacak. İşte tüm bu sıkıntıları gidermek adına kubernetes job objesi mevcut.

Bir job objesi, bir veya daha fazla pod oluşturur ve belirli bir sayıda, pod başarıyla sonlanana kadar pod yürütmeyi yeniden denemeye devam eder. Job belirtilen sayıda podun başarıyla tamamlanma durumunu izler, belirtilen sayıda podun başarıyla tamamlandığında job tamamlanır. bir job'un silinmesi oluşturduğu podları temizleyecektir.

Pod içersinde uygulama, başarıyla tamamlanıp, kapatılana kadar bekler. Eğer container fail ederse yeniden oluşturulur. job'un bir özelliğide, iş bittiğinde podları silmemesidir. Bu sayede podlar tarafından oluşturulan loglar kontrol edilebilir.

Job temelde 2 senaryo için kullanırız; ilk senaryo yukarıda da bahsettiğimiz senaryodur. Tek seferlik çalışıp, yapması gerekeni yaparak kapanan uygulamalarımızı job olarak deploy ederiz. Misal scriptler vb.

2\. senaryo ise, bir kuyruk veya işlenmesi gerken bir çok işimiz olduğunda, bunları eritmek adına, bu işler eriyene kadar çalışacak uygulamaları job şeklinde deploy ederiz.

Örnek job yaml dosyası içeriği;

```yaml
apiVersion: batch/v1
kind: Job
metadata:
  name: pi
spec:
  parallelism: 2
  completions: 10
  backoffLimit: 5
  activeDeadlineSeconds: 100
  template:
    spec:
      containers:
      - name: pi
        image: perl:5.34
        command: ["perl",  "-Mbignum=bpi", "-wle", "'print bpi(2000)'"]
      restartPolicy: Never
```

apiVersion: batch/v1 olan, Kind:job olan ve ismi de, pi olan bir job oluşturmamıza yarayan yaml dosyası içeriği yukarıdaki gibidir.

Spec kısmında 4 seçenek mevcuttur; Bunlardan ilk ikisi parallelism ve completions buradaki gibi aksini belirtmediğimiz sürece varsayılan değeri "1"dir.&#x20;

completions bu job altında, kaç tane başarılı pod oluşturmasını istediğimizi belirttiğimiz kısımdır. Bu örnekte 10 pod çalıştırmak istediğimizi söylüyoruz.

parallelism ise, adından anlaşılacağı üzere, bu 10 pod oluşturma işini, aynı anda kaçar kaçar yapacağını belirttiğimiz kısımdır.

Biz bu job objesini oluşturduğumuz zaman, "template" parametresi altındaki ayarlara göre "2" adet pod oluşturulacak ve bu podlar çalışacak container oluşacak. Container içerisinde uygulama çalışacak. Ve uygulama işini yapıp kapanacak. Eğer işlem hata almadan, bu şekilde olduysa, Kubernetes hemen "2" pod daha oluşturacak ve aynı şekilde onlarda çalışacak ve kapanacak ki 10 pod bu şekilde tamamlanana kadar devam edecek.&#x20;

backOfflimits değerinin  5 olarak ayarlandığını görüyorsunuz. Bu değer, toplam kaç kere hata oluşursa, tüm işlemleri bırakarak, job'un fail etmesini istediğimizi belirttiğimiz kısımdır. Bu, şu demektir.  podları oluşturmaya başla, düzgün bir şekilde devam ederse sıkıntı yok. Ancak podlar fail ederse, 5 defa daha denemeye devam et, toplamda 5 fail alırsan da, artık job'a devam etme, çünkü belli ki bir şeyler yolunda gitmiyor ve job'u fail et.&#x20;

activeDeadlineSeconds değeri ise aynı mantık fakat, bu sefer fail sayısı yerine, saniye belirtiyoruz. Eğer bu görev 100 saniye içerisinde tamamlanamazsa, anlaki sıkıntı var ve job'u fail et diyoruz.

"template" altında belirttiğimiz değerler ise, bildiğimiz pod oluştururken kullandığımız argümanlardır.

Şu anda bu job ile, pi sayısının ilk "2000" rakamını listeleyen ve ardından da kapanan podlar yaratıyoruz. Bu örnekte toplam 10 pod oluşturulacak ve her pod pi sayısının ilk 2000 rakamını çıkaran bir uygulama çalıştıracak. Uygulama düzgün bir şekilde bu işlemi yaparsa, uygulama kapanacak, dolayısıyla pod da düzgün şekilde tamamlandı olarak işaretlenecek.

Son olarak da, restart policy parametresinin mantıken "never" veya "on failure" olarak set edilmesi gerekmektedir.

Job oluşturulduktan sonra, podlar template parametresi altındaki belirttiğimiz görevleri yapıp, tamamlandı olarak işaretleniyor. Podlar işini bitirince silinmez. Böylelikle podların oluşturduğu logları gözlemleyebiliriz.

### Cronjob

Bir cronjob objesi, bir crontab dosyasının bir satırı gibidir. Belirli bir zamanlamaya göre, cron talimatında yazılmış bir job'u periyodik olarak çalıştırır.

Bir job objesini manuel olarak başlatmak yerine, örneğin istediğim zamanlarda tekrarlayan, istediğim günlerde çalışacak şekilde schedule etmek istersek, cronjob kullanabiliriz. Cronjob objesi, Linux crontab 'ın Kubernetes halidir. Syntax olarak da aynıdır.&#x20;

Kubernetes Job'dan farklı olarak, schedule parametresi mevcuttur. Bu parametreye göre job'un ne zamanlar çalışmasını istediğimizi belirtebiliyoruz. Misal aşağıdaki örnekte, Her dakika da bir çalışacak ve bir pod oluşturacak.

```yaml
apiVersion: batch/v1beta1 # not stable until kubernetes 1.21.
kind: CronJob
metadata:
  name: hello
spec:
  schedule: "*/1 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: hello
            image: busybox
            imagePullPolicy: IfNotPresent
            command:
            - /bin/sh
            - -c
            - date; echo Hello from the Kubernetes cluster
          restartPolicy: OnFailure
```


# Authentication

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FD08F3ijADysoZF7e5X2C%2Fh2uksaoxp1766bygb3h1.png?alt=media\&token=34392b01-4381-4ef2-9950-3e6c2b79ccbc)

Kubernetes kimlik doğrulama eklentileri arayıcılığıyla API isteklerinin kimliğini doğrulamak için, istemci sertifikaları, tarayıcı belirteçleri bir kimlik doğrulama proxy veya HTTP temel kimlik doğrulaması için kullanır.

API 'da bir kullanıcı objesi bulunmamasına rağmen, Cluster 'ın Certificate authority tarafından imzalanmış geçerli bir sertifika sunan herhangi bir kullanıcı (CA) kimliği doğrulanmış olarak kabul edilir. Bu yapılandırmada kubernetes sertifikanın konu kısmındaki ortak ad alanından, kullanıcı adını belirler. Misal, "/CN=bob"&#x20;

Oradan rol tabanlı erişim denetimi (RBAC) alt sistemi, kullanıcının bir kaynak üzerinde, belirli bir işlemi gerçekleştirme yetkisine sahip olup, olmadığını belirler.

Çoğu Enterprise uygulama 'da kullanıcı yönetiminin, uygulama içerisinden yönetildiğine şahit olmuşsunuzdur. Hemen hemen her platformun ayrı bir kullanıcı oluşturma ve yönetme bölümü bulunur. Sistem yönetimi ile uğraşan kişiler de, buradan yeni kullanıcılar oluşturabilir ve her yeni kullanıcı birer obje şeklinde oluşturulur.

Fakat bu iş, Kubernetes de böyle değildir. Kubernetes normal kullanıcı hesaplarının yaratıp, yönetebileceğimiz bir altyapı sunmaz. Yani Kubernetes üstünde gidip, ali,ayse,ahmet vb.. şeklinde kullanıcılar yaratamayız.

Pod gibi yada servis gibi oluşturabileceğimiz bir user objesi de bulunmaz. Kubernetes de kullanıcı oluşturma ve kimlik doğrulama işi, cluster dışında halledilecek şekilde tasarlanmıştır.&#x20;

Kubernetes X509 client certs-Static token file-OpenID connect tokens-webhook token- authentication proxy gibi altyapılardan birini yada birkaçını kullanarak, bu işin dışarıda halledilmesine imkan sağlar.&#x20;

Kubernetes kurulumunda, kube api server ayarlarında, bu altyapılardan hangilerini kullanacağımızı belirleriz ve bu kimlik doğrulama işini, bu altyapılara havale ederiz. Bunun yanında, her kubernetes cluster 'ında bir kök sertifika yetkilisi, yani Root Certificate authority altyapısı da bulunur.&#x20;

Bu Root Certificate authority tarafından imzalanan x509 client sertifika authentication için kullanılır. Kubernetes bu ve diğer altyapılar tarafından kimliği doğrulanmış kullanıcıların kubernetes ile görüşmesine imkan verir.

Fakat iş burada elbette bitmez, kimliğin doğrulanması bir kullanıcının cluster üstünde, her şeyi yapabilmesi-yapabileceği anlamına gelmez. Burada yetkilendirme yani, authorization kavramı devreye girer. İlerleyen yazılarda bahsedeceğiz.&#x20;

Az önce belirttiğim gibi, biz bu kimlik doğrulama altyapısının ne olacağını kubernetes kurulumunda belirlememiz gerekir. Fakat manuel bir kubernetes kurmak yerine, kubernetes dağıtımları yada Cloud servis sağlayıcıların sunduğu yönetilen kubernetes servisleri kullanıyorsanız, bu işlemler bizim adımıza otomatik olarak yapılır.

Örneğin, minikube varsayılan olarak, x509 client sertifikaları ile kimlik doğrulama yapacak şekilde ayarlanır. Biz minikube start dediğimiz zaman, admin yetkisine sahip bir kullanıcı olan minikube kullanıcısı için, sertifikalar hazırlanır ve kubectl config dosyamızın içerisine bu bilgiler girilir. Biz de kubectl command line ile kubernetes cluster 'mızda erişmek istediğimiz zaman, her seferinde bu sertifikalar ile kimliğimizi doğrulanmış olarak istek göndeririz.

Yada Azure üzerinde EKS kurduğumuz zaman, kurulumda seçenekleri belirleyerek, hem x509 client sertifikaları hem de, Azure active directory üzerinden authenticated olma imkanı sunuyor. Uzun lafın kısası, kubernetes kullanıcı oluşturma ve kullanıcı doğrulama işlemlerini, kendi üzerinde barındırmaz. Bunu dışarıda halledebileceğimiz seçenekler olarak sunar. Kendi üzerinde barındırmazdan kasıt şudur; biz gidip bir pod oluşturur gibi, bir servis objesi oluşturur gibi, veya herhangi bir obje oluşturur gibi kullanıcı oluşturamayız.

#### x509 Client sertifika oluşturma örneği;

Yeni bir firmada developer olarak işe başladık ve firmanın kubernetes clusterına bağlanmak istiyoruz. İlk olarak developer rolünü oynuyoruz. Ben ekibe yeni katılmış bir developerım ve Kubernetes cluster'a bağlanarak işlemler yapmak istiyorum.&#x20;

Kubernetes cluster'ı yöneten admine gittim ve bu isteğimi söyledim. O da bana, Kubernetes cluster'ın,  X509 Client sertifikları ile authenticated olacak şekilde çalıştığını söyledi. Ve eğer ben, bir private key ve CSR dosyası oluşturup, admine iletirsem, o Kubernetes Certificate authority kullanarak, bunu imzalayacak ve bana sertifika yaratabileceğini söyledi.

Şimdi bu Key ve CSR dosyamızı oluşturalım;

```bash
#Key ve CSR 'ı saklayacağımız dizini oluşturup, içerisine gidiyoruz.
mkdir auth-certs && cd auth-certs/

#KEY
openssl genrsa -out onrblt.key 2048
# Yukarıda oluşturduğumuz anahtarı kullanarak CSR oluşturmamız gerekiyor.
# CSR bizlerin Certificate authority(sertifika sağlayıcı)ya gönderip, bak bana bu özelliklerde bir dijital sertifika oluştur dememize imkan veren dosyalardır.
# Bu dosyayı oluşturup, ardından bunu kubernetes admine göndereceğiz, o da Kubernetes 'in Certificate authority ile bunu onaylayıp, imzalayarak, bizim sertifikamızı oluşturaracak.
# Ve bize bir sertifika gönderecek işte bizde bu sertifika ile cluster'a bağlanacağız.

#CSR
openssl req -new -key onrblt.key -out onrblt.csr -subj "/CN=onur@onurbolatoglu.com/O=DevTeam" 
# "-subj" opsiyonu ile bizler birnevi sertifika bilgilerini giriyoruz.
# Kubernetes de bu kısım önemli. Çünkü burada CN ile belirlediğimiz değer, kullanıcı adımız olacak. 
# "O" ile belirlediğimiz değer, bu kullanıcının hangi gruplara üye olacağını belirler.
```

-subj : Daha önce söylediğimiz üzere, kubernetes kendi içerisinde bir kullanıcı objesi tutmaz, sizin hangi kullanıcı olduğunuzu x509 sertifikalarında, bu alanlardan algılar. Bu nedenle bizler hangi kullanıcı adına sahip olmak istiyorsak ve bu kullanıcıyı eklemek istediğimiz gruplar varsa, bunları CSR oluşturma aşamasında " -subj " parametresinde belirtiyoruz.

Yukarıdaki komutlarla hem CSR hem de key dosyasını oluşturduk ve artık developer olarak işimiz bitti. Bu oluşturduğumuz CSR dosyasını kubernetes admine göndereceğiz ve sonraki işleri Kubernetes admin halledecek.

#### Kubernetes Admin kısmına geçersek;

Temel olarak, developer'ın ilettiği CSR 'ı kullanarak bir sertifika üreteceğiz. CSR'ı kopyaladığımız dizine geçiyoruz, Bu noktada bir kubernetes objesi yaratacağız. " CertificateSigningRequest " adında bir obje oluşturacağız. Bu obje ile, Developer'ın bize verdiği CSR'ı kubernetes'e göndereceğiz ve kubernetes de bize sertifika oluşturacak.

```bash
cat <<EOF | kubectl apply -f -
apiVersion: certificates.k8s.io/v1
kind: CertificateSigningRequest
metadata:
  name: onrblt
spec:
  groups:
  - system:authenticated
  request: $(cat onrblt.csr | base64 | tr -d "\n")
  signerName: kubernetes.io/kube-apiserver-client
  usages:
  - client auth
EOF
```

```bash
kubectl get csr 
#Yukarıdaki komut ile oluşturduğumuz CSR'ı görüntüleyebiliriz.

kubectl certificate approve onrblt
#Yukarıdaki komut ile görüntülediğimiz CSR'ı kabul edelim ve sertifikayı oluşturalım.

kubectl get csr onrblt -o jsonpath='{.status.certificate}' | base64 -d >> onrblt.crt
#Yukarıdaki komut ile, oluşturduğumuz sertifikayı decode ederek "onrblt.crt" adındaki dosyaya yazdıralım ve developer arkadaşa bu dosyayı verebiliriz.
 
```

Biz bu sertifikayı kullanarak kubectl config'de context oluşturmalıyız.&#x20;

```bash
kubectl config set-credentials onur@onurbolatoglu.com --client-certificate=onrblt.crt --client-key=onrblt.key
#Yukarıdaki komut ile bir kubectl'de bir user ve sertifikalarını tanımlıyoruz.

kubectl config set-context onrblt-context --cluster=kubernetes --user=onur@onurbolatoglu.com
#Yukarıdaki komut ile bir kubectl context'i oluşturuyoruz. (Kullanıcı bilgilerini ve cluster bilgisini vererek)

kubectl config use-context onrblt-context
#Yukarıdaki komut ile mevcut context'i, az önceki oluşturduğumuz context ile değiştiriyoruz.
```

Böylelikle cluster'a yeni context (yeni kullanıcı) bilgileriyle bağlanabiliriz. Fakat bu bilgilerle uzak bir cluster'a bağlanacaksak,

```bash
kubectl config set-cluster kubernetes --server=https://10.90.0.170:6443  
#Yukarıdaki komut ile yeni bir cluster tanımlayıp, kubernetes ismini veriyoruz.

kubectl config set-cluster kubernetes --insecure-skip-tls-verify  
#Yukarıdaki komut ile olası TLS hatalarını görmezden gelmesini istiyoruz.

# Ardından onur@onurbolatoglu.com kullanıcısı ile, 10.90.0.170 üzerinde bulunan 
# kubernetes cluster'ımıza erişebiliriz. Yani artık çalıştırdığımız tüm komutlar 
# onur@onurbolatoglu.com kullanıcısı ile kubernetes takma isimli cluster'da
# çalıştırılmış olacaktır.
```

{% hint style="info" %}
Yeni kullanıcı ile cluster'a bağlandığımızda hiç bir işlem yapamayız. Bunun için yetkilendirme yapılması gerekir. (RBAC)
{% endhint %}

Şu ana kadar yaptığımız işlemler, bir kullanıcının kimlik doğrulaması yapılarak kubernetes 'e bağlanmasını sağlamak ile alakalıydı. Kimliği desteklenen ve ayarlanan yöntemlerle doğrulanan her kullanıcı kubernetes cluster'a erişebilir. Fakat her kullanıcı varsayılan olarak sıfır yetkiyle gelir. Listeleme dahil hiçbir işlem yapamaz.  Kullanıcı authenticated oldu fakat, authorization 'ı kısıtlı. Bir sonraki yazıda buna değineceğiz.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F2SmBBc3Jo9RGqA5oOqhS%2F1_2FUGLdKTfrDlcJIVw2hzxQ.jpeg?alt=media\&token=954a3cab-6f02-4a8c-bfcc-864d131b0ff3)


# Role-based access control (RBAC)

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FALarLgXdmGEpS0Hrk0mN%2FScreenshot-2018-08-02-09.35.47-1.png?alt=media\&token=78040548-05bc-43f4-8255-9ce976f8cbc1)

Bir önceki bölümde, Kubernetes authentication altyapısının nasıl olduğunu ve x509 client sertifikaları oluşturup, kimlik doğrulamanın nasıl olacağını gördük. En son Developer'a sertifika oluşturup ilettikten sonra kubernetes ile konuşturmayı başarmıştık. Fakat Developer herhangi bir işlem yapamamıştı. Çünkü kimlik doğrulama, tek başına yeterli değil. Kubernetes de kullanıcılar varsayılan olarak sıfır yetki ile gelir. Yapabilecekleri işlemler için yetkilendirme gereklidir.

Authentication : Söylediğimiz kişinin doğruluğunun onaylanması ve doğrulanması işlemidir. Fakat kimliğin doğrulanmış olması her istediğimizi yapabileceğimiz anlamına gelmez. Örneğin kartlı giriş sistemlerinde, elimde kart varsa bunu sisteme okutarak orada çalışan birisi olduğumu yani kimliğimi doğrularım. Ama bu doğrulama tek başına bize her kapıyı açabilme imkanı vermez. Bunun yanında, hangi kapılardan geçebileceğimi, nerelere ulaşabileceğimiz de belirlenmiştir.  Misal çalıştığım bölümden geçebilirken, farklı bir bölüme giremeyebilirim. işte buna da yetkilendirme denir.

Authentication : Kimlik doğrulama.

Authorization : Yetki kontrolü.

Kubernetes yetkilendirme işlemlerini "RBAC" metoduna göre gerçekleştirir. RBAC yetki ve rollerin tanımlanması ve bu tanımlanmış yetki ve rollerin kimliğini doğrulanmış şekilde objelere atanması prensibine göre tanımlanır.

RBAC kuruluşunuzdaki bireysel kullanıcıların, rollerine dayalı olarak, bilgisayar veya ağ kaynaklarına erişimi düzenleme yöntemidir. RBAC yetkilendirmesi, yetkilendirme kararlarını, yönlendirmek için rbac.authorization.k8s.io API grubunu kullanır ve kubernetes API arayıcılığıyla ilkeleri dinamik olarak yapılandırmamıza imkan tanır.

RBAC mekanizması, role,rolebinding,clusterRole,ClusterRolebinding objeleri ile çalışır. Yapılabilecek işlemler, yani yetkiler role veya clusterRole objeleri olarak tanımlanır. Daha sonra RoleBinding ve ClusterRolebinding objeleri arayıcılığıyla bu roller servis hesapları, kullanıcılar yada gruplara bind edilir. Yani bağlanır.

Kullanıcılarda bağlı bulundukları rollerde belirlenen yetkilere kavuşurlar. Örneğin, ben default namespaces de pod objesi okuyup, listeleyebilecek yetkiler belirlediğim role yaratırım, daha sonra Rolebinding yaratarak bu rolü örneğin, bir önceki bölümde oluşturduğumuz <onur@onurbolatoglu.com> kullanıcına bind edebiliriz (bağlarız).

Bu noktadan itibaren bu kullanıcı, default isimli namespaces altındaki podları görüntüleyebilir. Eğer bind ettiğimiz tek role bu ise, kullanıcı sadece bir işlem(atadığımız işlemi) yapabilir. Örneğin başka bir namespaces de yer alan podları görüntüleyemez. Veya servis objesi oluşturamaz vb. Kullanıcılar sadece bind edildikleri rollerdeki tanımlanan yetkilere sahip olur.

Örnek role.yaml dosyası içeriği;

```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""] # "" indicates the core API group
  resources: ["pods"] # "services", "endpoints", "pods", "pods/log" etc.
  verbs: ["get", "watch", "list"] # "get", "list", "watch", "post", "put", "create", "update", "patch", "delete"
```

Role,Rolebinding,clusterRole,ClusterRolebinding şu ana kadar gördüğümüz diğer kubernetes objeleri gibi, birer kubernetes objesidir. Bu 4 obje de rbac.authorization.k8s.io/v1 API da bulunur. Tüm objeler gibi oluşturulurken, APIversion,Kind-Metadata kısımlarına sahiptirler.&#x20;

Tanımlar ise, "rules" parametresi altında yapılır. Rules altında bu role atanan yetkiler belirlenir. Bu örnekte tek bir rule oluşturulmuş ancak istersek birden fazla rule oluşturabiliriz. Her rule da 3 ana başlık belirleriz.

İlk olarak, bu kural hangi API grubundaki objeler ile ilgiliyse, bunu APIGroups kısmında belirtiriz. Burası boş bırakılırsa, core api grubundaki, objelerle ilgili olduğunu yani, V1 api'daki objeler ile ilgili yetkilendirme yaptığımızı belirtiriz.

2\. olarak belirlediğimiz argüman "Resources"dir. Bu tanım,  hangi kubernetes kaynakları ile ilgili olacağını belirtiriz. Bu örnekte biz, core API da bulunan, pods objesi ile ilgili bir kural yazdığımızı söylüyoruz. Buraya birden fazla obje eklenebilir. Bunun yanında bu objelerin sub objelerini de, örneğin pods objesinin sub objesi olan, logs objesi şeklinde sub obje de ekleyebiliriz.

Kuralda tanımladığımız 3. argüman "verbs" altında belirlediğimiz  yetkilerdir. Burada http request metotları şeklinde yapılabilecekler belirlenir.

Özetle, yukarıdaki yetkilendirmede Core API'da bulunan pod objesini okuyabilecek bir yetki tanımlıyoruz. Bu role de bu metadata altında namespace "default" olarak gözüküyor. Role ve ClusterRole arasında fark budur.

ClusterRole yaml dosyası içeriği;

```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]
```

Gördüğümüz gibi, role objesi ile neredeyse aynı. 2 farkı mevcut, Obje tipi clusterRole 2.farkı ise, namespace tanımı girilmemiş olmasıdır.&#x20;

Role objesi belirlediğimiz namespace için geçerli olan, namespace çapında yetki vermek için kullanılır. ClusterRole objesi ise, tüm cluster çapında geçerli olacak yetkilendirme için kullanılır.&#x20;

Yani, namespace bazında yetkilendirme istiyorsak, "role" objesini. Tüm cluster da geçerli olacak bir yetkilendirme istiyorsak, "ClusterRole" objesini kullanabiliriz.

Bir namespace bağlı olmayan objeler için, clusterRole objesini kullanmak mantıklı bir seçenek olacaktır.&#x20;

Yetkileri belirlediğimiz objeleri bunlar, "Role" ve "ClusterRole". Ama sadece yetki belirlemek yetmiyor. Bunları kullanıcılara bağlamamız (bind) gerekiyor. İşte burada devreye, RoleBinding ve ClusterRolebinding giriyor. Role objesini bir kullanıcıya bağlamak için Rolebinding objesini kullanabiliriz. ClusterRole objesini ise, bir kullanıcıya bağlamak için ClusterRoleBinding objesini kullanabiliriz.

Örnek roleBinding yaml dosyası içeriği;

```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: onur@onurbolatoglu.com # "name" is case sensitive
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role #this must be Role or ClusterRole
  name: pod-reader # this must match the name of the Role or ClusterRole you wish to bind to
  apiGroup: rbac.authorization.k8s.io
```

Rolebinding de bir kubernetes objesi ve role ile aynı api'da duruyor.&#x20;

Subjects kısmı ise, esas tanımı yaptığımız yer oluyor. subjects kısmında ilk olarak bu roleBinding'in kime bind edileceğini belirliyoruz. Bu örnekte, bir önceki yazımda oluşturduğum kullanıcı olan "<onur@onurbolatoglu.com>" kullanıcısına bağlamak istediğimizi belirtiyoruz.

Neyi bağlamak istediğimizi "roleRef" parametresi ile belirtiyoruz. Bu örnekte pod-reader isimli rolü bağlamak istediğimizi belirtiyoruz. &#x20;

Öncelikle role.yaml dosyamızı deploy edeceğiz ve role yaratılmış olacak. Ardından da bu RoleBinding yaml dosyası arayıcılığıyla Rolebinding objesi yaratacağız. Bu sayede, pod-reader isimli role <onur@onurbolatoglu.com> isimli kullanıcıyla bind edilecek. Bu noktadan itibaren, bu kullanıcı rolde belirlediğimiz yetkileri kullanabilecek.&#x20;

clusterRolebinding yaml dosyası içeriği;

```yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: read-secrets-global
subjects:
- kind: Group
  name: DevTeam # Name is case sensitive
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io
```

Gördüğünüz üzere, roleBinding ile hemen hemen aynıdır. Sadece role yerine ClusterRole bağlıyoruz ve namespace tanımlamıyoruz. Bu örnekte, bu Cluster rolünü, kullanıcıya değil, gruba bind ediyoruz(bağlıyoruz).  Bu sayede bu ClusterRole objesinden bir kullanıcı değil, DevTeam grubuna bağlı olan tüm kullanıcılara yetki verecek.&#x20;

KubeAPI server ile görüşen bir çok komponent mevcuttur. Bu komponentleri API ile görüşebilmesi için Kubernetes tarafından default olarak gelen, ClusterRole ve ClusterRolebinding objeleri mevcuttur.

Bunların dışında admin,cluster-admin,edit,view adına 4 cluster role daha mevcuttur. Bunlar bizim işimizi kolaylaştırmak adına kubernetes tarafından oluşturulup, default olarak gelmektedir.

Eğer biz, bir kullanıcıyı cluster seviyesinde admin yetkileri ile yetkilendirmek istiyorsak, o kullanıcıya kubernetes'in bize sunduğu "cluster-admin" ClusterRole 'nü bind edebiliriz.

Sadece belirli bir namespace altında tüm yetkileri bir kullanıcıya vermek istersek, bu seferde "admin" ClusterRole 'nü bind edebiliriz. Bunun için ClusterRole objesini, ClusterRolebinding ile değilde, Rolebinding objesi ile kullanıp sadece namespace seviyesinde de atama yapabiliyoruz.

Edit: tüm kaynakları düzenleme yetkisi.\
View: tüm kaynakları düzenleme yetkisi.

Bu roller çok genel olduğu için, Kubernetes tarafından önceden tasarlanmıştır.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FzdU4aqJXZTNPaMYazSrn%2Fen-us_image_0000001244261071.png?alt=media\&token=21b60486-3a06-420b-ba47-f3c84fb7e237)


# Service Account

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FPQL4wcnwsZWdsPUnsp6h%2FServices-Account.png?alt=media\&token=e29c52c7-e518-42b8-97d4-8729f9bdaba0)

Authentication kısmında, kullanıcılar olarak sertifikaları kullanarak, kubernetes API server'a authenticated olma yöntemlerini, Authorization kısmında ise, yetkilendirmeyi görmüştük. Fakat, kubernetes API server'a, sadece kullanıcıların erişmesi yeterli değil. Bir çok durumda, bizlerin pod içerisinde deploy ettiğimiz uygulamalarında Kube API server ile görüşerek, cluster üstünde işlemler yapması gerekebilir.

Kullanıcı hesapları insanlar içindir. Service Accounts podlarda çalışan processler tarafından kullanılmak üzere tasarlanmıştır. Misal, kubernetes üstünde uygulamalarınızı, deploy edecek bir uygulama yazdınız, ya da hali hazırda bu işlemleri yapan, bir yazılım kullanacaksınız. Bu uygulamayı bir pod olarak, kubernetes cluster'a deploy ettiniz.  Bu uygulamanın kubernetes API server ile görüşmesi ve ona komutlar ileterek deployment işlemlerini gerçekleştirmesi gerekiyor ve dolayısıyla bu pod içerisinde koşan uygulamanın öncelikle bir şekilde authentication adımını geçerek, kimliğinin doğrulanması sonrasında, bu işlemleri yapabilmesi adına gerekli authorization'a yani yetkiye sahip olması gerekiyor.

Bu ve benzer senaryolarda kullanılabilmesi adına, kubernetes service account isimli bir objeye sahip. 2. önceki yazıda bahsettiğimiz, sertifika tabanlı authentication insanlar içindir. Bizler bu şekilde authenticate oluyoruz. Fakat uygulamaların authenticate olması için, uygun değildir. Uygulamalar için kullanabilecek tek seçenek, service account 'dur.

Örnek service account yaml dosyası;

```yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: testsa
  namespace: default
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: podread
  namespace: default
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: testsarolebinding
  namespace: default
subjects:
- kind: ServiceAccount
  name: testsa
  apiGroup: ""
roleRef:
  kind: Role
  name: podread
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: Pod
metadata:
  name: testpod
  namespace: default
spec:
  serviceAccountName: testsa
  containers:
  - name: testcontainer
    image: alpine:latest
    ports:
    - containerPort: 80
```

Service accountlar kubernetes objesi olarak yaratabildiğimiz, tek hesap türüdür. ekranın en üstünde gördüğümüz üzere, oldukça basit bir objedir.

Bir isim ve namespace tanımlar oluştururuz. Bu örnekte gördüğümüz üzere, "testsa" isimli bir service account oluşturuyoruz. Fakat tahmin edebileceğiniz üzere, ne türde hesap oluşturursak oluşturalım, bu hesap hiçbir yetkiye sahip olmaz. Bu nedenle hemen altta gördüğünüz üzere, Öncelikle "default" namespace da pod okuma yetkilerine sahip, bir role oluşturuyoruz. Ardından da, bu rolü "testsa" isimli bir service account'a bind edecek bir rolebinding oluşturuyoruz. Bu sayede, "testsa" isimli service account 'u default namespace'de podları listeleme,izleme ve özelliklerini görme hakkına sahip oluyor.

&#x20;En alttaki örnekte, pod tanımının spec kısmında, "serviceAccountName" isimli bir parametre mevcut,  bu parametre ile, pod'a hangi service account'u atanacağını belirtiyoruz. Eğer bu anahtara aksi belirtilmezse, default isimli service account atanacak.

Kubernetes her namespace için, bir adet default isimli service account oluşturur. Ve her pod 'a aksi belirtilmezse, bu service account bağlanır. Default service account'un hiç bir yetkisi yoktur. Ama dilersek bunlara role yada, clusterRole bind ederek, gerekli yetkiyi verebiliriz.

Bir service account oluşturduğumuz zaman, bu service account için bir secret oluşturulur. Bu secret da 3 bilgi bulunur; 1. service account'un oluşturulduğu namespaces'ın adı. 2. kubernetes API server ile iletişim kurarken, HTTPS/TLS bağlantısı kurmamız gerektiğinden, bu bağlantının hata vermemesi adına gerekli sertifika bilgisi, 3. kimlik doğrulamasında kullanabileceğimiz bir Json web token(jwt) bilgisi bulunur. Bu bilgiler, service account'un bağlı olduğu pod içerisinde, /var/run/secrets/kubernetes.io/serviceaccount/ dizininde bulunur.

&#x20;Authentication kısmında kubernetes'in bir çok authentication altyapısını desteklediğinden bahsetmiştik.

Sertifika tabanlı authentication yapabildiğimiz gibi, HTTP header bilgisine sahip json web tokenları kullanarak da authenticate olabiliriz. Her service account için, bu 3 bilginin bulunduğu secret yaratılır ve bu secret /var/run/secrets/kubernetes.io/serviceaccount/  klasörüne mount edilir. Böylece podun içerisindeki uygulamaya git buradaki değerleri oku ve kullan diyebiliriz.

Pod içerisinden nasıl kubernetes API erişeceğiz?\
Her kubernetes kurulumunda, kubernetes içerisinden API server'a erişebilmek için, "kubernetes" isimli bir service yaratılır.  "kubectl get svc" dediğimiz zaman "kubernetes" adında bir servis görürüz. Her podun içerisinden bu isme gittiğimiz zaman otomatik olarak kube api server'a erişebiliriz.

Service accountlar bizim pod içerisinde kullanabileceğimiz, JWT tokenlarını otomatik olarak oluşturup, podlara mount etme konusunda kullanabileceğimiz birer kubernetes objesidir.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FJJEmTFjtyVRkK3JgmzRP%2F1_s2OHCGlh-XH87ZT9xW2e0A.png?alt=media\&token=e7c9b75e-fa5d-4a60-a821-e718da3e225c)

Objeleri oluşturduktan sonra, service account'u bir pod'a bağlamış olduk ve Pod içerisinden API server 'a bağlanıp, aldığımız yetkilere göre sorgular çalıştırabiliriz. Misal pod içerisinde token'ı uzun uzun her sorguda yazmak yerine, bir değişken olarak verebiliriz. Misal ;

```bash
TOKEN=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)

ardından,

curl --insecure https://kubernetes/api/v1/namespaces/default/pods --header "Authorization:Bearer $TOKEN"

Sorgusunu çalıştırabilir ve podları listeleyebiliriz.

```

{% embed url="<https://iximiuz.com/en/posts/kubernetes-api-structure-and-terminology/>" %}

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FjJvauNSt5VnA6P6nOFuk%2Fen-us_image_0000001142984374.png?alt=media\&token=f1e89230-6e42-4805-92bb-c8e9ea0fdfb2)


# Ingress

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F80WM1DwfQIYwduMeUyVw%2Fnginx-general.webp?alt=media&amp;token=a4e7f71b-4536-4467-a5c5-2a112b24c38f" alt=""><figcaption></figcaption></figure>

Service bölümünde, uygulamalarımızın dış dünyadan erişilebilmesi için, node port ve Load balancer tipinde servislere sahip olduğumuzu görmüş ve bunların detaylarını işlemiştik. Fakat bu yöntemlerin ikisi de OSI layer 'da yani IP layer' da çalıştıkları için bizlerin bazı sorunlarını çözmüyor.&#x20;

Bu bölümde öncelikle bu sorunları tek, tek tanımlayalım ardından da bu sorunların çözümü olan, Ingress controller ve ingress objelerini görelim. İlk olarak sorunu tanımlayalım;

Azure, Google, AWS gibi bir servis sağlayıcı üstünde yönetilen kubernetes hizmetlerinden, birini kullandığımızı varsayalım. Misal, Azure kubernetes service. Bu kubernetes cluster üstünde, bir uygulama deploy ettik ve uygulamayı da dış dünyadan erişilebilmesi için, Load balancer tipi bir servis ile expose ettik.

Load Balancer tipi bir service oluşturduğumuz zaman ne oluyordu?

Azure bizim için, bir load balancer yaratıp buna public bir IP atıyordu. Ve bu IP adresine gelen tüm istekleri bu servise yönlendiriyordu. Biz de bu IP adresi ile, bu servisin domaini DNS ile eşleştirerek kullanıcıların erişmesini sağlıyoruz.

Aynı kubernetes cluster da 2.bir uygulama deploy ettiğimizi ve aynı şekilde Load Balancer tipi bir servis ile dış dünyaya açtığımızı düşünün, aynı süreç işleyecek Azure bir Load Balancer daha yaratacak, bir tane daha public IP olacak. 3. bir servis yaratmak istersek, yine aynısı olacak. Bu süreç her yeni uygulama yayınlamak istediğimizde aynı şekilde devam edecek. Özetle 30 servisim varsa, 30 tane Load balancer olacak.&#x20;

Her bir load balancer için, ayrı ayrı para ödememiz gerekiyor. Bu ciddi problem. Her servis için ayrı bir servis oluşturursak, belirli bir zaman sonra işin içinden çıkamayız. Bu bizim ilk sorunumuz.

2\. sorunumuz ise, bizim micro servis mimarisinde bir uygulamamızın olduğunu düşünelim. Bu uygulama da şöyle çalışıyor; eğer kullanıcılar "[www.example.com](http://www.example.com)" şeklinde root path'e gelirlerse, "A" uygulamasına tarafından sayfa sunuluyor.&#x20;

Fakat kullanıcı "[www.example.com/about](http://www.example.com/about)" adresine gelirse, bu sayfa "B" uygulaması tarafından, sunuluyor.  Bu durumda, mevcut load balancer servisi ile ile bizim bu ortamı kurgulamamız imkansız çünkü, DNS'de [www.example.com/about](http://www.example.com/about) şeklinde path base olarak tanımlama yapamayız.  DNS 'de bu mümkün değil, bizim bir şekilde kullanıcı isteklerini bir yerde karşılayıp ve kullanıcının gitmek istediği URL anlayıp, buna göre arkada hangi servise gitmesi gerekiyorsa, ona yönlendirmem gerekiyor.

Uzun lafın kısası, bizim standart sadece IP ve port base yönlendirme yapan, L4 load balancer yerine, L7 de çalışan, application based load balancer'a ihtiyacımız var. Anlatıığım bu 2 sorun da, kubernetes dünyasında ingress controller ve ingress objeleri ile çözüyoruz.

Ingress controller, L7 application load balancer kavramının kubernetes spesifikasyonlarına göre çalışan ve kubernetes de deploy ederek kullanabildiğimiz türüdür. Nginx,Haproxy,Trafeik en bilinen ingress controller uygulamalarıdır.&#x20;

Özetle, hepsinin yaptığı iş aynıdır. Biz öncelikle bunlardan bir tanesini seçip ve yönergelerini takip ederek ingress controllerı kubernetes clusterımıza kuruyoruz. Bu kurulumu yaptıktan sonra, eğer cloud üstünde çalışıyorsak, bu ingress controller dış dünyaya bir load balancer servisi ile expose oluyor ve public bir IP adresine sahip oluyoruz. Bu noktadan itibaren, artık dış dünyadan kubernetes'e erişim sadece bu IP üstünden sağlanıyor. Sonrasında ise, bu ingress controller'ın, konfigürasyonunu yani, servislerimize dış dünyadan hangi URL üstünden, nasıl ulaşacak kısmını ise, Ingress objeleri dediğimiz objeler arayıcılığıyla belirliyoruz.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FEdob2CVabyLyGTktFJ6r%2FNginx%20Ingress%20on%20GCP%20-%20Fig%2001.png?alt=media&amp;token=5285ee9f-a75a-45ac-bbf3-22ee9babe904" alt=""><figcaption></figcaption></figure>

Ingress objeleri bizim, ingress controller'ı kubernetes objeleri arayıcılığıyla ayarlamamızı sağlıyor. Genellikle HTTP olarak üzere, bir clusterdaki servislere harici erişimi yöneten bir API nesnesidir.

Yük dengeleme, SSL sonlandırması ve path base routing özelliklerini destekler.

L7 application load balancer 'mız olan ingress controller 'a bağlanarak, "[www.example.com](http://www.example.com)" A uygulamasına ve "[www.example.com/about](http://www.example.com/about)" gelen istekleri B uygulamasına,  [www.example2.com](http://www.example2.com) adresine gelen istekleri C uygulamasına yönlendir şeklinde o uygulamanın menülerine, özelliklerini kullanıp ayar yapmak yerine, tüm bu istekleri ingress objesi şeklinde oluşturuyoruz. Deploy ettiğimiz zaman, ingress controller bu objeyi okuyarak, gerekli düzenlemeyi otomatik olarak yapıyor.

Ingress controller bizlere, L7 application load balancer'ların sunduğu, SSL,Path based routing vb. bir çok özelliği kubernetes objeleri olarak deploy edebilmemize olanak sağlıyor.

Ingress için öncellikle, bir ıngress controller kurulması gerekiyor. Bir çok ıngress controller mevcut. Ama bunların genelde 2 tanesi öne çıkmış durumda,

1 => Nginx\
2 => Trafeik

Biz nginx ile devam edeceğiz, Nginx'i kubernetes cluster'a nasıl kurabiliriz?

Her ingress controller kurulumu farklıdır. Parametreleri kurulduğu yere göre, aldığı opsiyonlara göre değişebilir. O nedenle bu gibi kurulumların detaylarını ingress controller 'ın kendi dökümantasyonundan öğrenebilirsiniz.

Minikube için Nginx ingress controller kurulumu;

{% embed url="<https://kubernetes.io/docs/tasks/access-application-cluster/ingress-minikube/#enable-the-ingress-controller>" %}

Uygulama;

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: blueapp
  labels:
    app: blue
spec:
  replicas: 2
  selector:
    matchLabels:
      app: blue
  template:
    metadata:
      labels:
        app: blue
    spec:
      containers:
      - name: blueapp
        image: ozgurozturknet/k8s:blue
        ports:
        - containerPort: 80
        livenessProbe:
          httpGet:
            path: /healthcheck
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: bluesvc
spec:
  selector:
    app: blue
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: greenapp
  labels:
    app: green
spec:
  replicas: 2
  selector:
    matchLabels:
      app: green
  template:
    metadata:
      labels:
        app: green
    spec:
      containers:
      - name: greenapp
        image: ozgurozturknet/k8s:green
        ports:
        - containerPort: 80
        livenessProbe:
          httpGet:
            path: /healthcheck
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: greensvc
spec:
  selector:
    app: green
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: todoapp
  labels:
    app: todo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: todo
  template:
    metadata:
      labels:
        app: todo
    spec:
      containers:
      - name: todoapp
        image: ozgurozturknet/samplewebapp:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: todosvc
spec:
  selector:
    app: todo
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
```

Bu yaml dosyası içerisinde, 3 uygulama deploy ediyoruz. Bu 3 uygulamanın da cluster içerisinden erişilebilir olması için clusterIP tipinde 3 ayrı service objesi oluşturup, uygulamalara atıyoruz.

Bizim bu uygulamaları L7 APP LB üstünden expose etmemiz gerekecek, bunun için gerekli ilk şey ingress controller'dır. Bu ingress controller 'ı minikube kullanıyorsanız yukarıdaki bağlantıya giderek kurulumunu yapabilirsiniz. İngress controller kurulumundan sonra, ingress objeleri oluşturup işlemleri gerçekleştirebiliriz.

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: appingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$1
spec:
  rules:
    - host: k8sfundamentals.com
      http:
        paths:
          - path: /blue
            pathType: Prefix
            backend:
              service:
                name: bluesvc
                port:
                  number: 80
          - path: /green
            pathType: Prefix
            backend:
              service:
                name: greensvc
                port:
                  number: 80
```

Ingress de aynen pod, service gibi bir kubernetes objesidir. Networking.k8s.io/v1 api da bulunuyor. tipi de ingress 'dir.  Bu objenin spec kısmında, kurallar belirleyerek servisleri ingress üstünden dış dünyaya açıyoruz. Bu örnekte k8sfundamentals.com domainine ait bir servis yayınladığımızı söylüyor ve altında 2 path belirtiyoruz. Eğer bu domaine /blue şeklinde bir istek gelirse, bunun blusvc servisinden cevap vermesini, /green pathine istek gelirse, greensvc servisinden cevap vermesini sağlıyoruz.

Annotations kısmı ise, cluster'a deploy ettiğimiz ingress controller üstünde, herhangi bir ayar yapmak isterseniz bunu hemen, hemen tüm ingress controller için annotations arayıcılığıyla yapıyoruz. Misal bu servis dış dünyaya HTTPS olarak açmak isteseydik kullanmak istediğimiz sertifika bilgilerini annotations arayıcılığıyla girecektik. vb. kullanabileceğimiz annotationslara kullandığımız ingress controller dökümantasyonundan ulaşabiliriz.

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: todoingress
spec:
  rules:
    - host: todoapp.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: todosvc
                port:
                  number: 80
```

Bu ingress dosyasında da, todoapp.com adresine gelen bütün istekleri todosvc isimli servise gönder diyoruz.

Biz bu ingress objelerini deploy ettiğimiz zaman, Kubernetes tüm bu bilgileri bizim ingress controller'ımıza gönderecek ve orada tüm veriler birleştirilip ilgili ingress controller üzerinde gerekli ayarlamalar yapılacak.

Ek not, eğer sistemde birden fazla ingress controller varsa, '--ingress-class=" argümanı ile kullanmak istediğiniz ingress controller 'ın "ingress-class" değerini öğrenip, bunu ingress objesi dosyasında özellikle belirtip, istediğiniz ingress controller'ı kullanabilirsiniz. Kaynak ve örnek;

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FN8awQAqJbjKwsBuhoiOB%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-08-23%20231608.png?alt=media&amp;token=160f4ea8-a997-44de-a822-a73bd4e4d312" alt=""><figcaption></figcaption></figure>

```yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: todoingresstestv1
  annotations:
    kubernetes.io/ingress.class: "k8s.io/internal-nginx"
spec:
  rules:
    - host: todoappv1.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: todosvc
                port:
                  number: 80
```

{% embed url="<https://kubernetes.github.io/ingress-nginx/user-guide/multiple-ingress/>" %}

{% embed url="<https://kubernetes.io/docs/concepts/services-networking/ingress/>" %}

{% embed url="<https://devopscube.com/kubernetes-ingress-tutorial/>" %}


# ImagePullPolicy & ImageSecret

Bildiğiniz üzere bizler sıklıkla dockerhub gibi public registryler ile çalıştık. İmajları buralardan indirip, kullandık. Gerçek hayatta sadece public registryler ile uğraşmıyoruz. Kendimize ait bir private registry kullanıyor olabiliriz.&#x20;

Private registry olduğu zamanda, tahmin edebileceğiniz üzere, bunlardan imaj çekebilmek için authentication olmamız gerekmektedir. Bu authentication işlemini yapmadan, kubernetes cluster bu private registrylerden image çekemeyecek. Dolayısıyla da, containerlarımızı çalıştıramayacağız.

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: imagesecrettest1
  labels:
    app: imagesecret
spec:
  containers:
  - name: imagesecretcontainer
    image: registry.gitlab.com/onurbolatoglu/images:nginx
    ports:
    - containerPort: 80
```

* Yukarıda basit bir pod tanımımız mevcut. Bir adet pod oluşturmak istiyoruz. Bu pod'a bir isim veriyoruz ve bir label atıyoruz.
* Spec kısmında, container'a bir isim veriyoruz. Ardından da, container'ın hangi imajdan oluşmasını istediğimizi söylüyoruz.  Ancak bu haliyle pod''u oluşturamayız. Çünkü bu pod tanımında, ilgili registry'e erişmek için kullandığımız bir authentication bilgisi yer almıyor.

Private registrylere bağlanıp, imaj çekebilmek için, registry urli, username ve password bilgisine ihtiyacımız bulunuyor. Bu bilgileri  edindikten sonra, bu bilgileri bir secret olarak kubernetes'e gönderiyoruz, kubernetes de bir secret oluşturuyoruz. Daha sonra bu secret'ı da kullanmak istediğimiz, pod tanımlarında özel bir parametre ile set ediyoruz.&#x20;

Bu sayede bizim oluşturduğumuz secret içerisinde, kullanıcı adı,parola,url bilgilerini kullanarak, kubernetes; private registry'e authentication olabiliyor ve imajı lokaline indirebiliyor.

Örnek secret oluşturma;

```bash
kubectl create secret docker-registry "secret_ismi" --docker-server="registry_url" --docker-username="kullanıcı_adı" --docker-password="şifre"

Misal,

kubectl create secret docker-registry regcred --docker-server=registry.gitlab.com --docker-username=onrblt --docker-password=glpatdasd

```

* docker-registry tipinde bir secret oluşturuyoruz.&#x20;
* Secret oluştururken, ilgili private registry'de yetkili olan, kullanıcı ve parolası yanı sıra, url bilgisi de gereklidir.

Private registry 'e erişmek için, oluşturduğumuz secret'ı aşağıdaki örnekteki gibi kullanabiliyoruz;

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: imagesecrettest2
  labels:
    app: imagesecret
spec:
  containers:
  - name: imagesecretcontainer
    image: registry.gitlab.com/onurbolatoglu/images:nginx
    imagePullPolicy: Always # IfNotPresent, Never
    # If the tag is latest, k8s defaults imagePullPolicy to Always. Otherwise k8s defaults imagePullPolicy to IfNotPresent
    ports:
    - containerPort: 80
  imagePullSecrets:
  - name: regcred
```

Hangi pod için bu registry kullanılacaksa, pod yaml dosyası içerisine "ImagePullSecrets" parametresi ile oluşturduğumuz secret'in ismini giriyoruz. Pod imajı indirmek için, "regcred" secret'ını kullanarak authentication olabilecek ve imajı kullanabilecek.

Diğer bir kısım ise, imagePullPolicy parametresidir;

Kubernetes nodelara imaj indirmek için, 3 farklı seçeneği kullanabiliriz.  Bu seçenekleri "imagePullPolicy" parametresi ile tanımlıyoruz.

imagePullPolicy parametresi eğer Always olarak seçili ise, her container oluşturulmaya çalışıldığında, her pod oluşturulmaya çalışıldığında, bu imaj tekrardan registry'den çekilecek. Node'da olup, olmaması önemli değil. Her pod oluşturulma esnasında, bu imaj ilgili registry'den indirilecek.&#x20;

Never seçili ise, bu sefer registry'e gidip, ilgili imajı çekmeye çalışmayacak. Kendi lokalindeki imajı kullanacak. Eğer ilgili imaj yoksa hata verecek. Hiçbir şekilde imajı gidip registry'den indirmeye çalışmaz, her zaman lokalindeki imajları kullanır.

IfNotPresent seçili ise, İlk önce lokale bakacak, kendi üzerinde bu imaj var mı, yok mu kontrol edecek. Yani pod'un schedule edileceği node, üzerinde ilgili imajı arayacak. Varsa kendi lokalindeki imajı kullanacak, eğer yoksa gidip registry'den ilgili imajı indirecek.

{% hint style="info" %}
Pod tanımlarında "latest" tanımlı bir imaj kullanıyorsanız, kubernetes varsayılan olarak "imagePullPolicy" parametresini, "Always" olarak set etmektedir. imagePullPolicy parametresini pod tanımı içerisinde eklemesek dahi, eğer kullandığımız imajın tag i "latest" ise, her zaman "Always" değeri kubernetes tarafından set edilir.

Misal olarak, "latest" tag i yerine, "v1" vb.. tagler kullanıyorsak, kubernetes, biz pod tanımına "imagePullPolicy" parametresini eklemesek bile, "IfNotPresent" değerini seçer.
{% endhint %}

{% embed url="<https://juju.is/tutorials/using-gitlab-as-a-container-registry#7-pull-your-container>" %}

{% embed url="<https://kubernetes.io/docs/concepts/containers/images/>" %}


# Static Pods

Bizler sürekli "kubectl" arayıcılığıyla, kubernetes api server'a komutlar vererek, pod oluşturma işlemlerini yaptık. Fakat kubernetes üstünde, bir tane daha pod oluşturma yöntemimiz daha var. Buna da "static pods" diyoruz.&#x20;

Bu özelliği bize sağlayan "kubelet" komponentidir. Kubelet kendi üzerinde, yani çalıştığı node üzerinde, bir klasör belirleyebiliyoruz. Bu klasörün içerisinde, biz yaml dosyaları şeklinde pod tanımımızı koyarsak, kubelet bu dosyayı ( podu ), bulunduğu node üzerinde ayağa kaldırır.

Yani direkt olarak, kubernetes api 'ya gidip, yeni bir pod talebi oluşturmak yerine, kubelet ile direkt haberleşip, yani kubelet 'in belirlediğimiz dizinine veya default dizinine oluşturulmasını istediğimiz pod tanımını yaptığımız "yaml" dosyasını koyarak kubelet'in podlar yaratmasını söyleyebiliyoruz. Bu duruma da Kubernetes ortamında "static pods" diyoruz.

Kubernetes cluster'ın, kendisi de static podlar ile ayağa kalkar ve cluster haline gelir. Kubelet master sunucu olacak node'un, /etc/kubernetes/manifest dizinine bakar ve kubernetes cluster için gerekli olan yaml dosyalarını okur ve oluşturur.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FzM3U0lXKYR6GLgkM5vW7%2Fimage.png?alt=media&amp;token=30d83aed-907e-4bea-9152-3394208e95b8" alt=""><figcaption></figcaption></figure>

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FHtgSkT7uTazWK4pQt92V%2Fimage.png?alt=media&amp;token=e9e80740-29aa-4b0f-8841-6861e9dd51b8" alt=""><figcaption></figcaption></figure>

Özetle, kubelet varsayılan olarak kendi üzerinde bulunduğu host 'da bir tane dizine bakar. Varsayılan olarak bu path "/etc/kubernetes/manifest/" dizinidir. Bu dizin içerisinde, yaml dosyası şeklinde pod tanımlarımızı koyarsak, kubelet yaml dosyasında tanımını yaptığımız podu bulunduğu node üzerinde ayağa kaldırır ve daha sonrasında bu podu, api server üzerinde "kubectl get pods" şeklinde komut çalıştırarak görüntüleyebiliriz. Bu static pod üzerinde değişiklik yapmak istediğimizde, ilgili node'un "manifest" dizinine gidip, yaml dosyası üzerinde istediğimiz değişikliği yapabiliriz. Bu podu api server üzerinden değiştiremeyiz. Ek olarak, Pod'u silmek istediğimizde, ilgili dosyayı dizinden sildiğimizde static pod silinir.

{% embed url="<https://kubernetes.io/docs/tasks/configure-pod-container/static-pod/>" %}


# Network Policy

Bölüm öncesi notlar;<br>

{% hint style="info" %}

> Kubernetes cluster altında, her podun uniq kendine ait bir IP adresi bulunmaktadır.

> Podlar birbirleri aralarında "nat" olmadan, haberleşebilirler.

> Podlar üzerinde barındığı "worker node'un" erişebildiği her hedefe erişebilir.
>
> Kubernetes cluster'ı altına koyduğumuz, bütün podlar varsayılan olarak, diğer bütün podlar ile haberleşebiliyorlar. IP olarak herhangi bir kısıtlama yok. Podları namespace olarak ayırabiliriz, fiziksel sunucu olarak ayırabiliriz(worker node olarak) fakat gene de varsayılan olarak podlar birbirlerine iletişim kurabilirler. Herhangi bir kısıtlama yok.
>
> Dış dünyadan da, ingress veya LB, NodePort gibi komponentler ile dış dünyadan erişim sağlanabiliyor.&#x20;
> {% endhint %}

Bazı durumlarda, biz bunları kısıtlamak isteyebiliriz. Misal, frontend podu, sadece backend podu ile haberleşebilsin. Frontend podu başka podlar ile konuşamasın veya başka podlardan frontend poduna istek gönderilemesin gibi ayarlamalar yapmamız gerekiyor.

<figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FnmDBwGQ3a6Z5UM8yxL0f%2Fslide_22.jpg?alt=media&amp;token=837b7ebb-2d8c-40f8-9e2e-7ba9a1edbdfc" alt=""><figcaption></figcaption></figure>

Network policy objesi, bu problemleri ortadan kaldırmak için, bize yardımcı olacak bir kubernetes objesidir. Yani podun başka bir pod ile konuşabilmesi veya başka birinin dışarıdan bu poda erişebilmesi gibi varsayılan durumu, biz "network policy'ler" ile değiştirebiliyoruz. Şöyle örneklendirebiliriz; Bu pod sadece "x" namespace'indeki "y" poduna erişebilsin. Bu pod sadece "z" IP aralığındaki IPlere erişebilsin. Bu poda sadece "abc=def" labelina sahip, podlar erişebilsin gibi kurallar ekleyebiliyoruz. Bu kuralları "network policy" objeleri sayesinde oluşturabiliyoruz.

Network policy olmadan, herhangi bir network policy yaratmadıysak, varsayılan olarak;\
\=> Her pod, diğer podlar ile konuşabilir.\
\=> Her pod, dış dünya ile konuşabilir. (Eğer üzerinde bulunduğu worker node konuşabiliyorsa)\
\=> Herkes dış dünyadan, ingress,Load Balancer,NodePort ile açtıysak, bu podlara dışarıdan erişebilirler. Varsayılan olarak kubernetes'in davranışı budur. Biz bu davranışı değiştirmek istersek yani kısıtlamak istersek, Network policy'lere başvuruyoruz. Varsayılan olarak bir kısıtlama söz konusu değil.

Örnek policy yaml dosyası;

```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: networkpolicy-example
  namespace: ns-a
spec:
  podSelector:
    matchLabels:
      team: a
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - ipBlock:
        cidr: 10.11.0.0/16
        except:
        - 10.11.1.0/24
    - namespaceSelector:
        matchLabels:
          team: b
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 80
  egress:
  - to:
    - ipBlock:
        cidr: 1.1.1.1/32
    ports:
    - protocol: TCP
      port: 80
```

Bu dosya da, bir network policy tanımlıyoruz ve network policy objemize bir isim veriyoruz. Spec kısmında ise, biz bu network policy objesi ile ilgili ayarları tanımlıyoruz.

Biz bir network policy yaratırız, daha sonrada bu network policy'nin hangi podlar üzerinde etkili olacağını "podSelector" ile seçeriz. Yani ilk olarak network policy'de tanımlamamız gereken, podSelector ayarıdır. Bu selector ayarı sayesinde biz bu oluşturduğumuz network policy'nin, hangi podlar üzerinde etkili olacağını belirtiriz. Hangi podlara bu network policy objesinin atanacağı "podSelector" anahtarı ile belirleriz.

Yukarıdaki örnekte, "ns-a" isimli namespace üzerinde, bir tane network policy oluşturuyoruz. Bu network policy de, bu namespace de bulunan "team=a" isimli label'a sahip olan, bütün podlara atamak istiyoruz. Dolayısıyla biz bu network policy'i, yarattığımız anda bu namespace içerisinde, bu labela(team=a) sahip olan bir pod var ise, bu podu bulacak ve bu network policy'i atayacak.

Network policy içerisinde, policy type belirlemeliyiz. 2 adet policy type mevcut. Bunlar;

1:Ingress, içeriye doğru gelen trafik anlamına gelir. Yani bizim yukarıda podSelector ile seçtiğimiz podlara doğru gelen trafik ile ilgili ayarlar Ingress de yapılır.

2:Egress, yukarıda podSelector ile seçtiğimiz podlardan dış dünyaya gidecek trafik ile ilgilidir.

2 tip policy seçebiliyoruz. ingress ve egress. Yukarıdaki örnekte iki policy type 'da seçtik. Ama sadece ingress veya sadece egress 'de seçebiliriz.

Ingress içeriye gelen trafik, egress dışarıya doğru giden trafik içindir.&#x20;

Daha sonra ingress tanımını yapıyoruz. Bunun için "ingress" şeklinde bir anahtar açıyoruz. Ardından bunun altında, "from" parametresini giriyoruz. Yani nereden biz bu ingress üzerinde izinler oluşturacağız. Bizim burada kullanabileceğimiz 3 parametre mevcut. Örnekte 3 ünüde kullandık fakat hepsini birlikte kullanmak zorunda değiliz.

```yaml
    - ipBlock:
        cidr: 10.11.0.0/16
        except:
        - 10.11.1.0/24
```

İlk tanımda, bizim bu ingress trafiğine hangi IP blokları üzerinden izin vermek istediğimizi belirlediğimiz IPBlock tanımı. yukarıdaki örnekte biz şunu diyoruz. Oluşturduğumuz network policy'nin atandığı podlara bu IP adresi üzerinden(IP bloğu üzerinden) gelen ingress trafiğine port 80 üzerinden izin ver. Yani bu policy oluşturduğumuz zaman,  pod selector ile seçtiğimiz podlara, 10.11.0.0/16 subneti üzerinden 80 portu ile gelinirse, bu trafik bu podlara erişebilecek. Gördüğünüz gibi IP block (cidr) kısmında, IP tanımları yapabiliyoruz. "except" parametresi ile, bu bloğun tamamına izin ver, ama şuna izin verme gibi ayarlar yapmak istersek except ile bunu belirtebiliriz. Yani. 10.11.0.0/16 subnetine izin verirken, 10.11.1.0/24 subnetini dahil etmiyoruz. Böylelikle, 10.11.1.0/24 subnetine izin vermiyoruz. 10.11.1.0/24 haricinde tüm bloklar (10.11.0.0/16 içerisinde bulunan) 80 portu üzerinden, podSelector ile seçtiğimiz podlara erişebilecek. Yani bu seçeneğimizin adı "ipBlock"dur.

```yaml
    - namespaceSelector:
        matchLabels:
          team: b
```

2\. kullanacağımız tanım şekli, namespace üzerindeki labellar üzerinden tanımlayabildiğimiz "Namespace Selector"dür. Yani burada şunu diyoruz; bu oluşturduğumuz network policy'e, git podSelector ile seçtiğimiz podlara ata ve bu podlara "team=b" isimli labela sahip, namespace'deki bütün podlar 80 portu üzerinden erişebilsin.

Yani, "namespaceSelector" ile namespace üzerindeki labellara göre, namespaceleri seçiyoruz. Yani biz network policy'nin atanacağı podlara, namespace  b'den, namespace c'den, namespace d'den, herhangi bir podun erişmesini istiyorsak, tek tek oradaki podları belirtmek, oradaki podların IP adreslerini belirtmek yerine şunu diyebiliriz; Git team=b isimli labela sahip, namespaceleri bul, bu namespaceler içerisinde, bütün podlara bizim network policy'i atadığımız podların veya podun 80 portuna erişebilsin. Şeklinde belirtebiliyoruz. Bunu da 2.seçeneğimiz olan, namespaceSelector ile yapabiliyoruz.

```yaml
- podSelector:
        matchLabels:
          app: frontend
```

3.seçeneğimiz pod selector, bu sefer de spesifik olarak pod seçebiliriz. Yani diyebiliriz ki; app:frontend  labelına sahip,  pod(lar) bu network policy'nin atandığı pod(lar)a 80 portu üzerinden erişebilsin diyebiliyoruz.

Hem ingress, hem egress'de kullanabileceğimiz tanım şekilleri, bu şekilde 3 adettir. Yani biz podSelector ile pod seçeriz, namespaceSelector ile namespace seçeriz. Ya da, IPblock ile erişebilecek IP bloklarını seçeriz.

```yaml
   ports:
    - protocol: TCP
      port: 80
```

Örnekte, ingress 'de "from" tanımı altında, nerelerden erişilebileceğini seçtik ve daha sonra ports kısmında hangi portların açık olacağını seçiyoruz. Dilersek ports kısmında, endport tanımı girersek port aralığı da verebiliyoruz.

Kısacası, ingress anahtarı ile gelen trafiği kısıtlamak için "from" anahtarı kısmında IPblock-namespaceSelector ve podSelector ile, gerekli select işlemlerini yaparak, kime izin vereceğimizi belirtiyoruz. Ardından port kısmında, hangi portlar üzerinden trafik geleceğini belirtiyoruz.

```yaml
egress:
  - to:
    - ipBlock:
        cidr: 1.1.1.1/32
    ports:
    - protocol: TCP
      port: 80
```

Engress kısmında da, yine aynı mantık, yine yukarıda belirttiğim 3 seçeneği de kullanabiliriz. Fakat bu sefer podların dış dünyaya, yani dışa gönderdikleri trafiği kısıtlıyoruz.&#x20;

Bu örnekte, egress olarak network policy'nin atandığı podlardan sadece 1.1.1.1/32 IP adresine 80 portundan erişilebilsin, bunun dışında hiç bir yere erişim izni olmasın şeklinde bir policy oluşturmuş oluyoruz.

Network policy'ler bu şekilde oluşturuluyor. Bu örnekleri kendi ihtiyaçlarımıza göre belirtebiliriz.

Birden fazla policy, bir poda atanabilir. Bir poda yada podlara, birden fazla network policy atanmış ise, bu policylerde oluşturulmuş ingress ve egress kurallarının birleşimi şeklinde atanır. Yani her oluşturulan rule, onun üzerine eklenerek atanır.

```yaml
egress:
  - to:
    - ipBlock:
        cidr: 1.1.1.1/32
    ports:
    - protocol: TCP
      port: 80
```

Network policy kısmında, belirlediğimiz kurallar izin vermek mantığındadır. Yani yukarıdaki örnekte diyoruz ki, 1.1.1.1'e izin ver. Bunun dışında buraya yazılmayan bütün egress trafiği kapatılır.

```yaml
    - ipBlock:
        cidr: 10.11.0.0/16
        except:
        - 10.11.1.0/24
    - namespaceSelector:
        matchLabels:
          team: b
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 80
```

Aynı şekilde, ingress'de de diyoruz ki, bu IP bloğuna, bu namespace'e, bu poda izin ver. Bunun dışındaki bütün trafiği kapat. Varsayılan olarak network policy atanmamış pod veya podlar, her yerden ve her yere erişilebilir ve erişir. Pod'a network policy atandığı anda, sadece yazılan kurallarda yazılı source ve destination'lar geçerli olur.

{% embed url="<https://kubernetes.io/docs/concepts/services-networking/network-policies/>" %}


# Helm Nedir?

Helm bize kubernetes üzerinde paket yükleme imkanı sağlıyor. brew, chocolatey gibi bir paket yöneticisidir. helm bu paket yöneticilerinin kubernetes için kullanılan bir paket yöneticisidir. Biz uygulamalarımızı paketler haline getirmemizi veya hazır paketleri tek bir komut ile kubernetes'e yüklememizi sağlıyor.

```bash
helm version

# komutu ile sistemde yüklü olan helm'in sürümünü öğrenebiliyoruz.
```

Helm 'de bilmemiz gereken ilk kavram; chart 'dır. Chart bizim kubernetes üzerine kurabileceğimiz uygulamanın paketlenmiş haline denir. Helm de chartlar yaratırız veya yaratılmış olan chartları alırız.&#x20;

Herhangi bir Chart 'ı alıp, kubernetes üzerine yüklersek, buna da "Release" denilir. Yani Chart paketin kendi adıdır. Release ise, bunu biz kubernetes cluster'a yüklediğimiz zaman, buna verilen isimdir.

Diğer bilinmesi gereken kavram Repository'dir.  Helm 'i şöyle düşünün, helm bir client-side uygulamadır. Yani bizim kendi cihazlarımıza yükleyip, çalıştırdığımız bir uygulamadır. Bu uygulamaya biz repository eklemek zorundayız. Repository dediğimiz şey ise, helm chart 'larının bir arada tutulduğu çeşitli yerlerdir.

Misal biz bir repository oluşturuyoruz ve bu repository altına çeşitli helm chart 'lar ekleyebiliyoruz. Daha sonra, biz bu helm chart'ları kendi cihazlarımıza kurmak istiyorsak; öncelikle kurmak istediğimiz chart'ın bulunduğu repository'i kendi helm 'mize ekliyoruz. Yani helm'in chartları arayacağı listelere bu repository adresini ekliyoruz. Bu listelere repository ekledikten sonra, bu repository altında ilgili chartları kendi kubernetes cluster'mızda kurabiliyoruz. Kurduğumuz zaman da, bunlara release diyoruz.

Özetle, helm chartlarının bir arada tutulduğu repository'ler mevcut. Bu repository'leri helm'mize ekliyoruz. Onun üzerinden helm releaseler oluşturabiliyoruz.

Geçtiğimiz senelerde, artifacthub adında bir kubernetes projesi yapıldı. Artifacthub'da şu sorunu çözmeye yarıyor; Biz kubernetes üzerine bir çok şey kuruyoruz. Misal, helm chartlar, prometheus paketleri, kubectl pluginleri vb.. Bir çok artifact'i, bizim kubernetes üzerinde kullanmamız gerekebiliyor.  Fakat bu artifactler hep farklı farklı yerlerde duruyor. Misal helm repositoryleri her uygulama için farklı yerlerde, kubectl pluginleri kurmak istediğimizde zaman, zaman bunları çeşitli yerlerde github vs. aramak durumunda kalıyoruduk. Bu paketleri ortak arayabileceğimiz bir çözüm yoktu. ArtifactHub bu sorunu çözmek için, ortaya çıkmış bir projedir. Helm chart'ları dahil, artifacthub üzerinden kubernetes için paketleri arattırabiliyoruz.

Tıpkı dockerhub gibi, artifacthub ise helm chartlar ve diğer kubernetes artifactleri için kullanabiliyoruz.&#x20;

Helm üzerinden paketleri yani chartları arayabileceğimiz komutlar:

```bash
helm search hub wordpress 
# Artifacthub üzerinde ihtiyacımız olan chartı arattırabiliriz.

helm search repo wordpress
# Sistem de mevcut olan, repository listeleri üzerinde ihtiyacımız olan chartı arattırabiliriz.
```

Kuracağımız chart'ın bulunduğu repository adresini helm'mize ekliyoruz, helm böylelikle chart'ı nerede arayacağını anlıyor. Eğer repository mevcut değilse, chart bulunamaz ve chartı kuramayız.

Repository adresini helm'e ekledikten sonra;

```bash
helm install "release adi" "chart ismi" 
# Yukarıdaki komut ile chart'ı kurabiliriz.

helm install wordpress-example bitnami/wordpress

helm status wordpress-example
# Komutu ile, kurulan release hakkında bilgi edinebiliriz.
```

Misal chart kullanarak release oluşturmak istiyoruz.  Hiç bir ek parametre girmezsek chart sistemimize default hali ile kurulur. Yani varsayılan şekli ile oluşturulacak. Fakat bazen biz chart üzerindeki değişkenleri değiştirmek isteyebiliriz.

Misal kullanılacak olan mysql versiyonunu değiştirebiliriz, wordpress bilgilerini kendimiz belirleyebiliriz. vb.. Bunları bu tarz değişkenleri eğer chartı oluşturan bize değiştirme imkanı veriyorsa, bu değişkenleri değiştirebilir ve kendi istediğimiz şekilde düzenleyebiliriz. Bu değişkenleri values.yaml adında bir dosya oluşturarak ve helm'e göstererek release'in bu şekilde kurulmasını sağlayabiliriz.

```bash
helm show values bitnami/wordpress
# Komutu ile, bitnami/wordpress chartı içerisinde, hangi değerleri değiştirebileceğimizi ve kullanabileceğimizi görebiliyoruz.
```

```bash
echo '{mariadb.auth.database: user0db, mariadb.auth.username: user0}' > values.yaml
helm install -f values.yaml bitnami/wordpress --generate-name
```

Yukarıdaki örnekte şunu diyoruz, values.yaml isimli bir dosya oluştur. Mariadb'nin database ismini, mariadb'nin username ismini belirttiğim şekilde values.yaml dosyası içerisine ekle. Böylelikle 2.komut da görüleceği üzere, values.yaml dosyasını helm'e gösterek mariadb.auth.database ve mariadb.auth.username değerleri bizim values.yaml dosyasında belirttiğimiz şekilde baz alınarak release kurulacaktır.

Bizler bu şekilde, varsayılan değerleri kullanmak yerine kullanabileceğimiz değerleri "helm show values "chart ismi" komutu ile gözlemleyip, ardından bu değerler içerisinde değiştirmek istediğimiz kısımlar var ise, values.yaml isimli dosya oluşturup içerisine yazıyoruz.

Yukarıdaki örneği tekrarlamak gerekirse;

mariadb.auth.database  ve mariadb.auth.username  değerlerini kendimize göre özelleştirip, values.yaml dosyası içerisine ekliyoruz.  Ardından helm install -f values.yaml  ile özelleştirdiğimiz değişkenleri helm'e söylüyoruz ve release bu şekilde kuruluyor. -f values.yaml şeklinde belirtmezsek, default hali ile kurulur.

```bash
helm uninstall wordpress-example
# Komutu ile sisteme kurmuş olduğumuz wordpress-example release kaldırılır.
```

Bizler helm üzerinde upgrade işlemleri yapabiliyoruz. Misal biz bitanami'nin bize sağladığı wordpress chartını sisteme release olarak kurduk. Fakat zaman sonra bu release üzerinde bir takım değişiklikler yapma ihtiyacı duyduk.  Değiştirmek istediğimiz değerleri bildirdiğimiz bir dosya yaratıp, daha sonra, (Değiştirebileceğimiz değerleri show values ile görebildiğimizden yukarıda bahsettik)

```bash
helm upgrade -f yenienv.yaml wordpress-example bitnami/wordpress
```

Komutu ile, bizim değiştirdiğimiz/güncellediğimiz değerler ile belirttiğimiz release 'in upgrade edilmesini sağlayabiliyoruz. Böylelikle güncellemek istediğimiz release'i silip, tekrardan kurmak yerine veya release üzerinde kullanılan bir imajın yeni bir versiyonu çıktığı zaman o release'i silmek yerine, yeni istediğimiz değişkenleri/özellikleri bir dosya da belirtip, helm upgrade komutu ile yeni belirlediğimiz değişkenlerin bulunduğu dosyayı göstererek release'in bizim istediğimiz şekilde güncellenmesini sağlayabiliriz.&#x20;

Yapılan upgrade işlemi işimize yaramadıysa veya bazı şeyleri bozmasına neden olduysa, rollback ile bu değişiklikleri geri alabiliriz.

```bash
helm history wordpress-example
# Komutu ile wordpress-example isimli release'in revizyonlarını görebiliriz.

helm rollback wordpress-example 1
# Komutu ile wordpress-example release'in 1 numaralı revizyona döndürülmesini sağlayabiliriz.
```

Chart oluşturmak için;

{% embed url="<https://helm.sh/docs/topics/charts/>" %}

{% embed url="<https://phoenixnap.com/kb/create-helm-chart>" %}

Helm Docs;

{% embed url="<https://helm.sh/docs/>" %}

Artifacthub;

{% embed url="<https://artifacthub.io/>" %}


# Prometheus Stack - Monitoring

<div><figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FMtWqmxHwQXbSkSEZNYVb%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-10-06%20175945.png?alt=media&amp;token=ee4b49b9-426b-4ecc-b416-4ef4c06e4957" alt=""><figcaption></figcaption></figure> <figure><img src="https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FFJhRl3jMtSKB8lKKTMkp%2FEkran%20g%C3%B6r%C3%BCnt%C3%BCs%C3%BC%202022-10-06%20175931.png?alt=media&amp;token=280110e8-756a-4293-b334-c2ce63cc330c" alt=""><figcaption></figcaption></figure></div>

Production ortamlarda, kubernetes cluster durumunu ve benzeri şeyleri kontrol etmemiz ve olası sorunlarda alertler oluşturmamız önemli bir konudur. Monitoring konusunu aşağıdaki maddelere ayırabiliriz;

\=> Kubernetes Cluster'ın durumunu gözlemlememiz gerekiyor. Objelerin durumu, deploy edilen obje miktarını vb. ( Bunu promethues ile monitor edeceğiz )

\=> Objelerin mevcut durumu nedir? İstenilen şekilde çalışıyor mu? Podlar ne kadarlık bir kaynak tüketiyor gibi soruların cevaplarını öğrenmemiz gerekiyor. ( Bunu prometheus ile monitor edeceğiz )

\=> Worker, Manager nodeları izlememiz ve anlık kaynak kullanımlarını gözlemlememiz gerekiyor. ( Bunu prometheus ile monitor edeceğiz )

\=> Pod içerisinde çalışan uygulamalarımıza ait logları incelememiz gerekiyor. ( Prometheus ile yapabiliriz fakat, bunu daha efektif bir şekilde arama yapabileceğimiz EFK stack ile monitor edeceğiz, bir sonraki bölümde )

Prometheus 'a geçmeden, kubectl ile bilgi toplama;

```bash
kubectl get pods 
# çalışan podların listesini getirir.

kubectl get All -A 
# Sistemde bulunan tüm objelerin listesini getirir.

kubectl describe pods pod1 
# Pod1 hakkında detaylı bilgi alırız.

kubectl get events
# Cluster da oluşan tüm logları gösterir.

kubectl top node node1 
# Node1 isimli node hakkında kaynak tüketim miktarını getirir.

kubectl top pods pod1
# pod1 isimli podun kaynak tüketim miktarını getirir.

kubectl logs pod1
# pod1 isimli podun içerisinde çalışan uygulamanın loglarını getirir.
```

Yukarıdaki komutlar ile gerekli tüm bilgilere/loglara ulaşabiliriz fakat, production ortamlarda bu komutlar ile tek, tek toplamak uğraştırıcı ve zaman kaybı olacaktır ve yönetilemez hale gelecektir.

Misal çok fazla objenin bulunduğu Kubernetes cluster ortamlarında, bu şekilde kubectl ile manuel olarak log toplamaya çalışmak tavsiye etmeyeceğimiz bir davranış olacaktır.

Bunun yerine merkezi bir loglama sunucusu veya merkezi bir metric sunucusuna, kubernetes cluster'dan edindiğimiz loglar ve metricleri göndermemiz daha mantıklı bir çözüm olacaktır.  Böylelikle, edindiğimiz loglardan ve metric'leri görselleştirip, alertler oluşturabiliriz. Misal, node1 down olursa, mail gönder vb. gibi alertler oluşturabiliriz.

&#x20;Kısacası, Kubernetes üzerinde monitoring altyapısı sağlayabilecek bir servise ihtiyacımız var. Bu ihtiyacımızı Prometeus stack ile çözeceğiz. Prometheus stack ile uygulamala logları hariç, geriye kalan tüm metricleri alabileceğiz. Metricleri prometheus ile alıp, Grafana ile prometheus'u konuşturup, aldığımız metricleri Grafana ile görselleştirebiliriz.

Prometheus stack kurulumu;

```bash
kubectl create namespace monitoring
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install kubeprostack --namespace monitoring prometheus-community/kube-prometheus-stack
kubectl --namespace monitoring get pods -l "release=kubeprostack"
```

Prometheus, Grafana, Alertmanager 'a dışarıdan erişmek için nodePort dosyası.

```yaml
apiVersion: v1
kind: Service
metadata:
  name: prometheus-service
  namespace: monitoring
spec:
  selector:
    app.kubernetes.io/name: prometheus
    prometheus: kubeprostack-kube-promethe-prometheus
  type: NodePort
  ports:
  - nodePort: 32079
    port: 9090
    protocol: TCP
    targetPort: 9090
    
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus-grafana-service
  namespace: monitoring
spec:
  selector:
    app.kubernetes.io/instance: kubeprostack
    app.kubernetes.io/name: grafana
  type: NodePort
  ports:
  - nodePort: 32078
    port: 80
    protocol: TCP
    targetPort: 3000
    
---
apiVersion: v1
kind: Service
metadata:
  name: prometheus-alertmanager-service
  namespace: monitoring
spec:
  selector:
    app.kubernetes.io/name: alertmanager
  type: NodePort
  ports:
  - nodePort: 32084
    port: 9093
    protocol: TCP
    targetPort: 9093
```

{% embed url="<https://github.com/aytitech/k8sfundamentals/blob/main/monitoring/kube-prometheus-stack.md>" %}

Prometheus ile grafana'yı konuşturmak 'dan bahsettik yukarıda, bunu nasıl yapıyoruz? Bunu biz değil, bizim yerimize bu stack'i yöneten kubernetes operator yapıyor.

Kubernetes üzerine prometeus'u kurduk ve kurduktan sonra bir çok ayarın yapılması gerekiyor. Misal, ruleların oluşturulması; gerekli tanımların yapılması vb. Özetle prometheus stack 'i kurup,yapılandırıp,yönetmemiz gerekiyor.  Kubernetes 'de operator dediğimiz bir yöntem mevcut; Bizler operatorler oluşturabiliyoruz ve kubernetes de operatorler oluşturduğumuz zaman, bizim admin olarak yapacağımız tüm manuel ve uzun sürecek işlemleri otomatik hale getirilmesini sağlıyoruz operator ile.&#x20;

Prometheus'u kurarken, yani helm chart'ı sisteme release olarak yükledikten sonra, operator prometheus 'un çalışması için gereken tüm ayarlamaları yapıyor. Tıpkı bir admin gibi, bu stack'in yönetiminden sorumlu oluyor.


# EFK Stack - Monitoring

Kubernetes üzerinde çalışan uygulamalarımızın loglarını toplamak için EFK stack kullanıyoruz.

Elastic Search, logların toplandığı ve kaydedildiği yer.\
Kibana, Logların Elastic Search'den alınıp, grafik arayüz de görüntülememizi sağlar.\
FluentD veya logstash, logları uygulamalardan toplamamızı sağlar.

{% embed url="<https://github.com/aytitech/k8sfundamentals/tree/main/monitoring>" %}


# CRD & Operator

CRD ile bizler kubernetes'in default objeleri gibi kendimiz custom objeler yaratabiliyoruz. Yani aynen bir pod,deployment vb obje tipleri gibi kendimiz bir custom obje tipinin tanımını kubernetes'e gönderip, kendi oluşturduğumuz obje tipine göre objeler oluşturabiliyoruz.

```yaml
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  # name must match the spec fields below, and be in the form: <plural>.<group>
  name: crontabs.stable.example.com
spec:
  # group name to use for REST API: /apis/<group>/<version>
  group: stable.example.com
  # list of versions supported by this CustomResourceDefinition
  versions:
    - name: v1
      # Each version can be enabled/disabled by Served flag.
      served: true
      # One and only one version must be marked as the storage version.
      storage: true
      schema:
        openAPIV3Schema:
          type: object
          properties:
            spec:
              type: object
              properties:
                cronSpec:
                  type: string
                image:
                  type: string
                replicas:
                  type: integer
  # either Namespaced or Cluster
  scope: Namespaced
  names:
    # plural name to be used in the URL: /apis/<group>/<version>/<plural>
    plural: crontabs
    # singular name to be used as an alias on the CLI and for display
    singular: crontab
    # kind is normally the CamelCased singular type. Your resource manifests use this.
    kind: CronTab
    # shortNames allow shorter string to match your resource on the CLI
    shortNames:
    - ct
```

Yukarıdaki örnekteki yaml dosyasını biz kubernetes'e gönderirsek, crontabs.stable.example.com isminde bir obje tipi oluşturmuş oluyoruz.&#x20;

Operator ise, cluster admin'in veya developer'ın cluster'da yapacağı işlerin otomatize hale getirilmesinde yardımcı olmaktadır.&#x20;

Misal bir database oluşturmak için, gerekli tanımları yaml dosyasına girer ve bunu kubernetes'e göndeririz. Ardından gerekirse database uygulaması için gerekli tanımları vb girmemiz gerekebilir. Yani süreç burada manuel işliyor. Bizler bunun yerine bir operator oluşturup, CRD'leri kullanarak tüm bu manuel süreçleri otomatik hale getiriyoruz.&#x20;

Yani şunu diyebiliyoruz; Bir adet DB adında CRD oluşturuyoruz, bu DB CRD'inden DB objesi oluşturuyoruz, daha sonra yazdığımız operator ile ne zaman bir DB objesi yaratılırsa, kubernetes de git bir mysql deployment yarat şeklinde bir workflow kurabiliyoruz. Yani işin obje kısmını CRD ile halledip, otomatize etme kısmını da operator ile hallediyoruz. Kubernetes operator konusunda bize default bir SDK sağlamıyor. Fakat operator desteği sunan bir çok SDK mevcut. Aşağıdaki linkten bunları inceleyebilirsiniz.

{% embed url="<https://kubernetes.io/docs/concepts/extend-kubernetes/operator/>" %}

### Service Mesh

Kubernetes üzerinde bir çok servisi ayrı, ayrı podlar olarak çalıştırıyoruz. Bu kubernetes podları üzerinde çalışan servislerin birbirleri olan iletişiminin durumu, servislerin sorunlarının debug edilebilmesi gibi bir çok kolaylığı sağlayan uygulamalar service mesh uygulamalarıdır. Service mesh uygulamalarının servislerin durumu hakkında bilgi edinebilmesi ve proxy olarak görev alan kısım ise servislerimiz ile aynı pod içerisinde çalışan sidecar containerlardır. Proxy görevi gören sidecar containerlar asıl servisimize gelen tüm trafiği üzerinden geçirir.

{% embed url="<https://linkerd.io/2.12/getting-started/>" %}

{% embed url="<https://istio.io/>" %}


# Girizgah

* Dağıtık bir versiyon kontrol sistemidir.
* Açık kaynak kodlu ve ücretsiz.
* Hızlı kontrol sistemi.
* Versiyonlama, değişikliklerin takibini sağlayabildiğimiz bir yöntem.

{% hint style="info" %}
Misal bir uygulamanın, 2.versiyonu 1.versiyonuna göre bazı değişikliklere sahip olabilir.
{% endhint %}

* Takım çalışması için kullanışlı.
* Dosyaların üzerinde yapılan değişiklikler görüntülenebilir.

#### Diğer Kavramlar

* Repository : Kod deposu, veri deposudur. Projelerimizin versiyon kontrolünü yapabilmek adına oluşturulmaktadır. Tüm dosyalarımızın üzerinde yapılan değişiklikleri görebileceğiz. Repo oluşturmak için "git init" komutunu kullanıyoruz.
* Working Directory : Çalışmakta olduğumuz dizindir. Hangi dizinde çalışılacaksa, repo oluşturulmalıdır.
* Staging Area : Güncelleme yaptığımız, dosyaların bulunduğu yer. Dosyalar üzerinde güncelleme yaptıktan sonra, working directory 'den Staging area 'ya taşıyoruz.
* Commit : Yapılan değişikliklerin tarafımızca onaylanması.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fc29PrxCiWhyvER8Hr22g%2Fgit-index.png?alt=media\&token=83bd44cc-da91-4640-aeee-fa53494926cb)

* Working Directory 'de çalıştığımız dosyaları güncelledikten sonra, staging arae 'ya alıyoruz. Buradan da repository 'e gönderiyoruz.

### Staging Area

GIT 'de değişikliklerin, kayıt altına alındığı alandır. Staging area, proje dosyalarımızda bir dizi değişikliği yeni bir versiyon olarak işaretlemeden önce kayıt altında tuttuğumuz veri tabanı olarak tanımlayabiliriz. GIT status ile proje dosyalarımızın durumunu görebiliriz. Git status ile üzerinde çalışılan repository 'nin,  O anki durumu görüntülenir. Üzerinde değişiklik yapılan dosyalar, yeni eklenmiş dosyalar ve commit komutu uygulanmamış konsol üzerinde listelenir. Git add ile değişiklik yapılan/yeni eklenen dosyaları eklersek dosyalar/dizinler staging area 'ya taşınacaktır.

{% hint style="info" %}
git add .  > Bulunduğumuz dizindeki dosyaları tamamını staging area aktaracaktır.
{% endhint %}

### Git Commit

Git 'de eklediğimiz dosyaları kalıcı olarak git veri tabanına işlemeye commit denilmektedir. Proje 'de belli başlı işlemler yapıldıktan sonra dosyaları commit etmek gerekir. Yapılan değişiklikleri kimlerin tarafından yapıldığını anlamak için git config ile username ve mail adresini tanımlamak gerekmektedir. &#x20;

{% hint style="info" %}
git commit -m \[message]&#x20;
{% endhint %}

### Git add

Git ile versiyon kontrolü altına aldığımız projemize, dosya eklediğimizde, dosya sildiğimizde veya var olan dosyanın içeriğini değiştirdiğimizde bu değişiklikler, git tarafından otomatik olarak kontrol - takip edilmez. Git 'in bu dosyaları takip etmesi için git add komutu ile bu dosyaları önce git 'e tanımlamamız gerekir.

* git config global : Geçerli olan kullanıcının, tüm projeler için genel yapılandırmalar. .gitconfig dosyası içerisinde saklanır.
* git config system : Bilgisayardaki tüm kullanıcılar, tüm repoların ayarlarının kontrol edilip, bulunduğu kısımdır.

{% embed url="<https://www.atlassian.com/git/tutorials/setting-up-a-repository/git-config>" %}


# Branch

* Branch'ler projemize dallara ayırmamızı sağlar.

Misal, Projemize yeni bir özellik eklemek istiyoruz. Ama projenin yaşamaması, yeni özelliği bu projeyi etkilememesini istiyoruz. Ama bu özelliği de test etmek istiyoruz. Gibi durumlarda kullanabilir. Projemizin bütünlüğünü bozmadan değişiklikler yapmak istersek. Branch bu konuda bize yardımcı olacaktır.

git init komutunu verdiğimizde bizim için master adında branch oluşuyor. Eğer biz ayarlarımızda bir değişiklik yapmazsak, bütün geliştirmeyi master branch üzerinde yapıyoruz. Geliştirmeler farklı bir branch üzerinde yapılır, bir problem olmazsa master branch ile merge edilebilir (birleştirir)

{% hint style="info" %}
Bir branch içerisinde, farklı branch 'ler oluşturulabilir.
{% endhint %}

<mark style="color:red;">Bir branch oluşturduğumuzda mevcut projemizin, en son halini bu branch 'e kopyalanır.</mark>

```
git branch -l # Var olan branch listesini gösterir.
git branch database # Database branch oluşturur.
git checkout -b web # Web branch yoksa oluşturur, mevcutsa o branch 'e geçer.
git checkout [branch adı] # Belirttiğimiz branch 'e geçeriz.
```

{% hint style="info" %}
Üzerinde bulunduğumuz branch 'deki en son alınan commit 'e head denir.
{% endhint %}

![Example branch](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FQiBNTZwt56OiKQ3pWqA2%2Fimage-7.webp?alt=media\&token=95070e41-7a63-4eae-82b1-30c047d0ebf9)


# Merge

Branch 'imizi hangi branch ile birleştirmek istiyorsak, o branch 'e geçiyoruz. Örneğin, Web branch 'imizi master'i ile birleştirmek istiyorsak, master branch 'ine geçip,

```
master$> git merge web # Web kısmına, birleştirmek istediğimiz farklı bir branch 'ide yazabiliriz.
```

![Örnek MERGE işlemi ](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fr7zp8UZTymuuuwLwnQcR%2F1.png?alt=media\&token=7eaffdee-3ee0-47b4-a8cb-adffea199cd8)

```
git branch -d web # Web branch 'ini silmek istersek. Bu komutu kullanıyoruz.
```

* Head : Bulunduğumuz branch 'de en son commit 'i gösterir. Ve bu commit 'in hangi branch'lerde olduğunu gösterir.

### fast forward merge

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FfOyUMjkKXNcMRwLcDx82%2Ffast-forward-vs-3-way-merge-62739.png?alt=media\&token=eed99b93-747e-4c6b-8cac-5d5e6dc2b4de)

Feature branch 'iniz master 'a merge olacağı anda, eğer master üzerinde bir değişiklik (commit) olmamışsa git varsayılan olarak master hattının son commit hash 'i olarak, feature branch'inin hash 'ini alır. Bu duruma fast forward merge denir. Bu işlem sonrasında, sanki değişiklikler master branch de yapılmış gibi history oluşur. Merge işlemi sırasında --no-ff parametresi verilirse merge işlemini daha anlaşılabilir history (log) tutar.


# Conflict - Rebase

2 farklı branch de, aynı dosyada, aynı satırda yapılan değişiklikler merge edildiğinde, conflict oluşur.

```
git commit -am "file.txt eklendi" # git add yapmadan, aynı komut ile hem staged
hem de commit atabiliriz.
```

### Rebase

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FnFdoc12A6DEYE9kkIYwn%2Fyb0g5PRxr.avif?alt=media\&token=c56784c7-e77c-486d-95c9-1d03a41b404d)

Git 'de merge ve rebase komutları benzer işlevleri yerine getirmek için kullanılıyor. Her komut da bir branch 'deki değişiklikleri başka bir branch 'e birleştirmek için kullanılır. Ancak iki komut arasında proje tarihçesi oluşturulması ile ilgili ciddi bir farklılık vardır.

* Merge komutu ile A branch 'indeki değişiklikler, B branch 'i ile birleştiğinde, B branch 'inin commit tarihçesinde, merge işleminden kaynaklanan ve merge commit adı verilen otomatik oluşturulmuş bir commit yer alır. Bu commit A ve B branch 'i tarihçelerini birbiriyle ilişkilendirir.
* Rebase kullandığımızda, A branch'inin her bir commit B branch'ine sanki commit işlemi B branch'inde yapılmış gibi davranır. (yeniden yazılır)
* Bu sayede, B branch 'inin, commit tarihçesi, sanki tüm değişiklikler bu branch 'de yapılmış gibi, düz ve kesintisidir.

Birleştirilecek branch içerisinde rebase işlemi yapılmalı.

Master branch 'ine geçip,

```
git rebase test # Test branch'ini master branch ile birleştiriyor.
```

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FOeA8CbtqhdRb3H2gSTrP%2Frebase.png?alt=media\&token=c45055a6-2ef6-46d6-ad28-47a3800a936f)


# Alias

* Git üzerinde bulunan bazı uzun komutlara kısa-kısa alias tanımlayabiliriz. Böylelikle akılda kalıcı ve kolay bir kullanımı olur.
* Projeye özel bir alias vb. ayarlamalar yapılırsa, proje klasörü içerisinde bulunan .git>config içerisinde tutulur. Bu tanımlamalar sistem genelinde yapılırsa, /etc/ ve Windows için /users/ içerisinde bulunur.

```
git log --all --decorate --oneline --graph # Bu komuta alias tanımlamak için.
git config --global alias.dog "log --all --decorate --oneline --graph" # Komutunu
kullanabiliriz.

git dog # şeklinde çalıştırabiliriz.
```


# Gitignore

gitignore dosyası, git reposundan hariç tutulacak dosyaların listesinin bulunduğu repo ana dizinde  bulunan bir ayar dosyasıdır. Ana dizinde oluşturduğumuz .gitignore dosyasını git okuyup, belirten kriterleri es geçecektir. Her bir satır bir kural tanımlar. (# ile başlayan satırlar yorum satırlardır)

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F9MH1VtVMd8wSxK0KYqvN%2Fscreenshot-gitignore-contents.png?alt=media\&token=70969a1b-fd62-4004-abfe-46f552db1d94)

* [x] Repomuza tüm çalışma klasörlerimizi atmak istemediğimizde kullanırız.
* [x] Staged area 'ya aktarmak istemediğimiz dosyaları burada belirtebiliriz.


# Diff

Git 'de iki versiyon arasındaki farkları görmek için kullanılır. Karşılaştırılan dosyalar A/B diff komutu iki dosyayı birbiriyle karşılaştırır. A dosyası ve B dosyası, Bu A ve B dosyası genelde aynı dosyanın farklı versiyonlarıdır. Çok sık olmasa da, diff işlemi ile tamamen farklı olan dosyaları da karşılaştırabiliriz.  Hangi dosyanın karşılaştırıldığını açıkca belirtmek için için Diff komutunun çıktısı her zaman hangi dosyanın da B olduğunu belirterek bakar.

```
git diff 1234 5678 dosya1.txt
# Dosya1.txt 'nin 1234 ve 5678 hashlerindeki commitlerin farkını alıyoruz.
```

Dosya içerisinde hangi kısmın A, hangi kısmın B dosyasına ait olduğunu belirtmek için kullanılan - ve  + işaretleri vardır. Diff komutu ile sadece  iki dosya arasındaki (versiyon) farkların olduğu satırları gösterir. Dosyanın tamamını değişmeyen satırları göstermez. @@ ile başlayan semboller A ve B versiyonları arasındaki  farklı satırların, hangi satırdan başlayıp, kaç satır olduğunun bilgisini verir.

@@-1.4 +1.2@@ bize, - simgesi ile tanımlanan A dosyasından 1.satırdan başlayarak 4 satır. + simgesi ile tanımlanan B dosyasından 1.satırdan başlayarak  2 satır birbirinden farklı olduğunu söyler.

Değişen her satırın başına - veya + simgeler yer alır. Bu simgeler A ve B versiyonlarının içeriğinin ne olduğunu anlamamıza yardımcı olur.&#x20;

```
git diff --staged
staged bölgedeki dosyaların farklarını inceleriz.
```

```
git diff master tester
iki farklı branch'i inceleyebiliriz.
```

Hangi commitleri, hangi versiyonları karşılaştıracaksak, git log üzerinden ilgili commit bulup, hash Id 'sini öğrenmemiz gerekir.

```
git diff 1234 5678
1234 versiyonunun 5678 versiyonundan farkı
```

### Restore

```
git restore --staged a.txt 
a.txt dosyasını staged alandan çıkarır.
```

```
git restore a.txt
Son commit üzerine dosyada yapılan değişikleri geri alır.
```


# Checkout

```
git checkout [commit id] 
belirtilen commit id 'ye geri döneriz. (commitler silinmez).

Bunun üzerine geçmişte gidip commit atarsak,yeni bir branch oluşturmamızı
isteyecektir. Önceki commitler silinmeyecektir.
```

### RESET

```
git reset --hard [commit id] 
belirtilen commit ıd 'ye geri döneriz. (öncekiler silinmez)

git reset --soft [commit id]
belirtilen commite geri döneriz. ancak dosyalar silinmez stage area 'da durur.
git restore --staged [file name] ile dosyayı staged alandan çıkarabiliriz.

git reset --mixed [commit id]
Dosyaları belirtilen commit haline döndürür. dosyalar silinmez staged alandan
kendisi çıkarır. Önceki dosyalar repoda tutulur. commitler silinir.
```


# Stash

Commit işlemi ile dosyalarda yapılan değişiklikler kalıcı olarak repo da kayıt altına alınır. Ancak günlük çalışmamızda bazen tam olarak bitmeyen değişiklikleri de kayıt altına almak isteyebiliriz. Örneğin bir değişiklik üzerine çalışırken, başka bir konu ile ilgili kritik bir sorun bildirildiğinde yapmakta olduğumuz işi yarım bırakıp, yeni soruna odaklanmak zorunda kalabiliriz. Bu gibi durumlarda, yeni bir sorun ile ilgilenmeye başlamak için önceki değişiklikleri kaybetmeden yeni ve temiz branch oluşturmalıyız.  Yarım kalan değişikliklerin kayıt altına almak için, git stash komutunu kullanabiliriz. Git stash ile üzerinde çalıştığımız, ancak commit etmediğimiz değişikliklerin, geçici olarak git tarafından kayıt altına alınmasını ve aktif branch 'imizin, herhangi bir değişikliğin olmadığı temiz bir duruma getirilmesini sağlayabiliriz. Git stash komutu çalıştırıldıktan sonra, tekrar git status çalıştırırsak,  önceki bölümden commit edilmemiş dosya olarak gözükmek. Çünkü master branch 'i git stash sonrası temiz duruma geldi. Git stash list ile aktif branch 'de geçici olarak kayıt altına aldığımız değişikliklerin listelenmesini sağlayabiliriz. Stash 'de yer alan değişikliği geri yüklemek için iki seçeneğimiz var.&#x20;

```
git stash pop
komutu ile yukarıdaki (listenin en üstünde) yer alan değişiklik yüklenecek
ve bu değişiklik listeden silinecek.

git stash apply
komutu ile istediğiniz değişiklikleri geri yükleyebiliriz. Ancak bu işlem
sonrasında yüklediğimiz değişiklik listeden silinmeyecek. Listeden silmek için
git stash drop komutunu kullanabiliriz.
```

Üzerinde çalıştığımız, aktif branch 'imizi temiz bir duruma getirmek için kullanabiliriz. Farklı bir branch 'i aktif hale getirmeden önce kullanabiliriz. Remote repo 'da değişiklilerimizi lokale indirmeden kullanabiliriz. Branch merge etmeden kullanabiliriz.

```
git stash > çalışmanın yapıldığı dosyayı çalışma alanına sakla.
git stash apply [stash id] > geri dön
git stash save "yarım kalan" > stash 'a isim verebiliriz.
```

### Cherry

Bir branch'deki commit 'i (değişikliği) farklı bir branch 'e kopyalamaya denir.

```
git cherry-pick [commit id] 
Commit 'i kopyalamak istediğimiz branch 'e geçip, hangi commit 'i kopyalamak
istiyorsak commit id belirtmemiz gerekiyor. Kopyalandıktan sonra farklı bir
commit id 'ye sahip olarak branch 'imize kopyalanır.
```

{% embed url="<https://www.youtube.com/watch?ab_channel=KadirKas%C4%B1m&v=dt7ALS6NksI>" %}


# Other

push : projemizi uzak repoya göndermek için kullanırız.\
pull   : projemizi uzak repodan çekmek için kullanırız.

```
git push [repo url] [branch ismi]

git remote add [origin (takma ad)] [repo url]

git push origin master => Origin takma adına sahip repomuza değişikleri gönderiyoruzz.

git fetch : Remote repodan değişiklileri çek.
```

Pull Request : Fark ettiğimiz bir projenin üzerinde çalışıp, Proje 'de yaptığımız değişiklerin, projenin sahibine pull request olarak gönderebiliriz. Pull request aslında, farklı bir kullacının reposunda bulunan bir projeye geliştirmesinde yardımcı olmaktadır.

Patch : Hata düzeltmeleri, bugfix ile alakalıdır.\
Minor : Küçük,yeni özellikler. Eski kullanıcılar etkilenmez.\
Major : Büyük yeni özelliklerin bulunduğu sürüm.

```
git tag -a v1.0.0 "first tag1" > bulunduğumuz commit'i tagler(-a ile yorum ekledik).

git tag v1.2.3 [commit id] > belirttiğimiz commit id ye sahip commit'e tag ekledik.

```

* Git 'e bir commit gönderirken, tag vermek istersek,

```
git push origin master [tag ismi]
```

### Amend

Son kaydedilen işlemdeki mesajı son commit mesajını değiştirir. Yeni bir kayıt oluşturmak yerine aşamalı değişiklikler bir önceki işleme eklenecektir. Varsayılan düzenleyici açılarak bir önceki commit mesajının değiştirmemizi ister.

```
git commit --amend -m "test" 
son commit mesajını test olarak değiştirdik.

git push origin master --force
commit mesajının güncel halini repoya gönderdik.
```


# S3

Bir S3 bucket'ında neleri özelleştirebiliriz?

Versioning : \
\
Enable : Bucket üzerinde versiyonlama açılır.\
Suspend : Versiyonlama durdurulur.\
\
Örnek : İş yerimizde bir dosya üzerinde 15 kişi çalışıyor ve herkes bu dosyayı işi bitince s3'e upload ediyor. S3 versioning burada bu dosya için her yapılan değişik için, bir versiyonlama yürütülür. Bir dosyada yapılan her değişiklikten sonra S3 bucket'a upload ettiğinizde yeni bir versiyon oluşturulacak. Versioning açık olan bir bucket'da bir dosyayı sildiğinizde AWS bu dosyayı tamamen silmez (delete marker) etiketi ile versions show dediğinizde sildiğiniz dosyayı görebilirsiniz. Silme işlemini geri almak için (delete marker) yazan versiyonu silmeniz gerekmektedir.

Server Access Logging : S3 bucket üzerinde bulunan bir obje için gelen isteklerin loglamasını yapar. Örnek olarak bir resim dosyasını X kişi istek yaptığında, server access logging istek ile alakalı log yazar (oluşturur) . Logları (log) adında bir bucket oluşturup, o bucket'a yazmasını da sağlayabiliriz.

Object Level Logging : Tüm objelerin loglarını tutmaktadır. CloudTrail servisi üzerine logları yazabilmektedir. Objelere gelen API isteklerinin loglarını tutabilmektedir.

Static Web Hosting : Statik web sitelerini bu servis sayesinde bucket üzerinde host edebiliyoruz.

Default Encryption : Bucket içerisinde olan tüm dosyaların şifrelenmesini istiyorsak, ayarlamalarını buradan yapabiliyoruz. Desteklediği algoritmalardan: AES-256 - AWS-KMS

#### Advanced Settings

Object Lock : Bucket içerisinde silinmemesi gereken dosyalar varsa, bu ayar ile seçebiliyoruz. Bu sayede dosyaların silinme ihtimali ortadan kalkacaktır. <mark style="color:red;">Bu seçenek mevcut bucket üzerinde aktifleştirilemez. Yani bucket oluşturulurken aktif edilmelidir.</mark>

Tags : Objelerin ayrıştırılmasını ve ya bucket'ın ayrıştırılması için tag (etiketler) ekleyebiliriz.

Transfer Acceleration : Misal, Elimizde 2 TB dosya var, ve bucket'a upload edilmesi gerekiyor. Normal bir şekilde upload ettiğimizde bu çok uzun sürecektir. Fakat biz daha hızlı upload etmek istersek, bu özelliği açıp bu servisin bize verdiği URL üzerinden upload işlemimizi yapabiliriz. (AWS burada bize CDN ağı sunmaktadır) Böylelikle bize en yakın sunucuyu kullanarak bucket'ımıza dosyalarımızı hızlı bir şekilde yüklemiş olacağız.

Events : AWS bucket üzerinde yapılan bir işlemin, bir başka işlemi tetiklemesini istiyorsak bu seçeneği kullanabiliriz.

Requester Pays : Enable dediğimiz zaman, bucket'ımızda bir obje çağıran farklı bir kullanıcıya download ücretini yansıtır. Fakat enable durumda objeler public durumda olmayacaktır.

#### S3 Bucket Permissions

Access Control List : Bucket'a kimlerin erişmesi gerekiyorsa buradan ilgili ayarları yapabiliyoruz.

Bucket Policy : Bucket erişiminde IP kısıtlaması yapabiliriz. Kullanıcı bazlı erişim izinleri oluşturabiliriz.

Cors Configuration : Örnek olarak bir web sitemiz var, ve bu web sitemiz bir dosyayı AWS bucket üzerinde barındırıyoruz. İstek AWS bucket'a geldiğinde bu isteğin izin verilip, verilmeyeceğine bu seçenek ile karar veririz.

Public Access Settings : Bucket policy ve Access control list'de eklediğimiz kuralların aktif etmek istersek burayı seçmiyoruz. Kuralların devre dışı kalmasını istiyorsak seçmemiz gerekiyor. Bucket'ı dış dünyaya erişimi ile ilgili ayarı buradan yapıyoruz.

#### S3 Management

Lifecyle : Burada dosyaların barındığı storage class'ların belirttiğimiz zamanlarda değişmesini istersek, buradan kurallar oluşturabiliyoruz. Dilersek eski ve ya yeni versiyonların silinmesi için kurallarda yazabiliriz.

Replication : Örnek olarak iki bucket'ımız var, biz dosyaları birine upload ediyoruz. Fakat eğer istersek bu bucket'da olan dosyaları diğer bucket'ımızla replike edebiliriz.\
Avantajları ; Yedeklilik, Yüksek erişim hızı: kullanıcı hangi bucket'a daha yakın ise o bucket üzerinden dosyaları indirip, yükleyebilir.

Analytics :  Binlerce dosyamızın analizini yapabiliriz. Storage class'larını hangileri olduğunu vb..

Metrics : Bucket içerisinde bulunan ne kadar objemiz ve boyutların ne kadar olduğunu görebiliriz. Ne kadar istek geldiğini ve dışarı aktarılan dosya boyutunu görebiliriz.

Intentory : Dosyalarımızın detaylı bir listesini çıkarmamızı sağlıyor.

<mark style="color:red;background-color:purple;"><mark style="color:orange;background-color:blue;">aws-cli : Arayüzden yapabildiğimiz her işi komut satırı arayıcılığıyla yapmamızı sağlar. aws-cli ile hesabımıza bağlanmak için kullanıcının access key id ve secret access key dosyaları gereklidir.<mark style="color:orange;background-color:blue;"></mark>

Glacier : Çok nadir eriştiğimiz dosyaların saklamak için en uygun storage class'dır. Dosyaları saklayıp, arşivleyebiliriz.

{% embed url="<https://aws.amazon.com/tr/s3/storage-classes>" %}

### Update

* Bucket yaratılırken, (Copy Settings from existing bucket) seçeneği ile daha önce yaratılmış bir bucket ayarlarını kullanabiliyoruz.
* Bucket oluştururken Advanced Settings altında, object lock özelliği mevcut, bu özellik objelerimizin silinmesini engelleyen bir özelliktir.
* Bucket URL yapısı güncellendi.
* Bucket özelliklerine ek, intellgnt-tiering archive configurations özelliği geldi, (Tier) bu tier, standart ve standart AI arasında bir köprü olarak düşünebiliriz. Bu tier seçer dosyamızı yükleriz. Dosya erişim isteklerine göre, AWS bu bucket üzerindeki objelerimizi standart ve standart IA arasına otomatik olarak saklar.  (Ne kadar çok istek varsa standart 'a atar, az istek varsa Standart IA 'ya alır) Dilersek bucket properties 'de bu dosyaları istek sayısı azaldıkça glacier 'gibi düzük ücretli bir tier 'a geçirilmesini isteyebiliriz.
* Archive Access tier : 90 gün erişilmeyen dosyaları arşive gönder. vb. Günü kendimiz belirileyebiliriz.
* Deep Arcihe Access Tier : Daha uygun bir tier.
* Event noti. ile bucket ile ilgili işlemleri (aksiyon olduğunda) başka bir işlemi tetikletmesi gibi kurallar yazabiliriz.
* Storage class analys ile bucket ilgili tüm analizi çıkarıp farklı bir bucket 'a gönderebiliriz.
* Inventory configuration, bucket içerisinde bulunan dosyaların bulunduğu ve özelliklerin bulunduğu csv dosyasını görüntüleyebiliriz.
* Acces-point, Bucket'ımıza erişen her uygulama, kullanıcı adı vb, durumlar için yeni arn oluşturup. Ayrı ayrı policyler tanımlayabiliriz. istersek sadece vpc'den erişimi seçebiliriz.
* Object Lambda Access Point : Bucket'a istek gönderdiğimizde yani bucket'dan bir obje çağırdığımızda obje'ye göre bir lambda fonksiyonu tetikleyebiliriz. (yeni bir arn oluşturabiliriz)
* Örneğin, istenilen bir objeyi ziplenmiş olarak çekebiliriz.
* Batch Operations : Bucket üzerinde bulunan tüm objeler için ortak bir işlem yapmamızı sağlar. örn, kopyala,restore vb.
* Access Analyzer S3 : Erişim ile ilgili logları IAM 'de yapılandırdıktan sonra burada görüntüleyebiliriz.
* Storage Lens: S3 üzerinde bulunan tüm dosyaların, tüm bucketların grafiksel istatisliğini sunuyor. (ne kadar kullanım vb var)


# EC2

Elastic Compute Cloud

On-Demand : Kullandığın kadar öde, taahhütsüz.

Reserved Instance : Önceden anlaşılmış rezerve edilmiş 1 yıl ve 3 yıl taahhütlü.

Spot Instance : Teklif üzerine edinilen cloud sunucular.

Dedicated Host : Kişiye özel sunucu, kaynakları paylaşımsız.

Sunucu oluştururken;

* [x] İşimize uygun sunucu türünü seçmek.
* [x] Bu sunucu ailesi içerisinden işimize uygun modeli bulmalıyız.
* [x] Bu modelin hangi versiyonunu kullanmalıyız. Bunu seçmeliyiz.
* [x] Kaynak boyutlarını seçmeliyiz.

EC2 Storage Tipleri;

| Instance Storage (ephemeral)           | Elatic Block Storage (EBS)                 |
| -------------------------------------- | ------------------------------------------ |
| Instance fiziksel olarak bağlı.        | Kalıcı veri deposu, instance'dan bağımsız. |
| Veriler başka bir yere replike değil.  | Block base depolama.                       |
| Snapshot desteği yok.                  | %99 erişim garantisi                       |
| SSD ve ya HDD.                         | Snapshot desteği                           |
| Sunucunun bulunduğu fiziksel üzerinde. | Replike                                    |
|                                        | Ortak storage üzerinde.                    |

Diskte iops değeri ne kadar yüksekse okuma-yazma hızı yüksektir. Bu değer saniyede ne kadar verinin okunup, yazılacağı değerini belirtir.&#x20;

Throughput bir diskte saniyede kaç mb veri geçişine izin verildiğini belirten değerdir.

Misal, IOPS'u bir arabanın 0-100KMH kaç saniyede çıkabildiğini gösteren bir değer olduğunu düşünürsek, throughput ise o arabanın maksimum ne kadar hıza çıkabildiğini gösterir.

#### AMI - Amazon Machine Image

Daha önceden tanıtılmamış işletim sistemi ve uygulamalarını barındıran sanal makine şablonlarının bulunduğu yer.

Community Ami (Public) : Çeşitli topluluklar ve Amazon tarafından yönetilen AMI

Aws Marketplace (Paid) : Çeşitli kişilerin kendi sunucularında kurduğu yazılım, servislerin, imajını alarak imajını satışa sunduğu kısım.

Private : Kendi sunucularımızı kendimiz yaratıp, kendimiz AMI yarattığımız seçenek.

#### EC2 Sunucu kurulumu esnasında dikkat edilmesi gereken kısımlar,

Number of instance : Yaptığımız ayarlarla kaç adet sunucu kurulacaksa bunu belirtiyoruz.

Purchasing Option :  Spot teklifi vererek, sunucu talep edebiliriz. (opsiyonel)

Auto Assing Public IP : Otomatik olarak sunucuya public bir IP adresi atar.

Capaticy Reservation : Kaynak rezerve edebiliriz.

IAM Role : Burada kural ekleyebiliyoruz. Örneğin EC2 sunucularımızın S3 depolama alanına erişmesini istiyorsak, ilgili kuralı bulup ekleyebiliriz.

Shutdown Behavior : Sanal sunucuya kapama komutu geldiğinde,  sunucu için  AWS'nin ne yapacağını belirtebiliriz. \
\*Stop : Sunucuyu sadece kapat.\
\*Terminate : Sunucu kapandıktan sonra herşeyi sil.

Enable Termination Protection : Bu seçili olduğu zaman api ve management console üzerinden sunucuyu terminate edemeyiz. Bu koruma kalkana kadar sunucu silinmez.

Monitoring : Normalde AWS 5 dakika da bir sunucuyu izler ve biz istersek bu seçeneği aktif edip, bu  süre 1 dakikaya düşer.

Tenancy : Dedike bir host mu, yoksa shared bir host mu kullanacağız bunu seçiyoruz.

#### Advanced Details

Sanal sunucu ilk defa açıldığında çalışmasını istediğimiz komutları buradan yazabiliriz.

Disk,Security group,tag ekleyebiliriz.

Sanal sunucumuza erişmek için key-pair oluşturmalıyız.&#x20;

{% embed url="<https://www.youtube.com/watch?ab_channel=Telusko&v=yPdmy--Uh50>" %}

Actions kısmından image seçersek, bir ami yaratabiliriz.

Status Check hypervisor'da sorun olursa bunu status check üzerinde "system status checks" de görebiliriz. Sunucu da bir sorun olursa bunu instance status check üzerinde görebiliriz.

#### EC2 altında bulunan diğer özellikler;

Elastic Load Balancing : Yük dağıtım servisi, haproxy gibi düşünebiliriz.\
Aplication Load Balancing : Web sitesi uygulamalarımızın yük dağıtımını yapabiliriz.\
Network Load Balancing : TCP, ağ isteklerinin yük dağıtımını yapabiliriz.

Autoscaling : Sistem kaynaklarını optimize eder, yeni sunucuları devreye alır. Sistemin ihtiyacı olan kaynağı sağlar. Örneğin sanal sunucuların 5 dakika boyunca %90 CPU kullanımı yapıyorsa, git ve ortama sanal sunucu ekle ve bu sunucular diğer sunucular cpu kaynak kullanımı %30'un altına düşerse, yeni eklenen sanal sunucuyu sil gibi kurallar oluşturabiliriz. Ve tüm süreci otomatize edebiliriz.

Placement Group : EC2 üzerinde 2 sanal sunucu yarattık diyelim, bu sunuculardan biri X fiziksel hostu üzerinde oluşturulurken, diğer ise farklı fiziksel host üzerinde oluşturuluyor. AWS isterseniz sunucuları aynı host üzerinde çalışsın diyorsanız, Sunucuları placement group'a dahil edebilirsiniz. Placement gruba alınacak sunucular instance tipleri aynı olmalı yani m4 x1 ve c5 x1 tipleri kullanılmaz. Hepsi örneğin, m4=m4 olmalı. Tüm sunucuları tek seferde placement gruba alabiliriz. Örnek olarak, placement grubunda bir sunucuyu kapatıp açarsak düşük bir ihtimal hata alabiliriz. Hata alırsak tüm placement grubunda bulunan sunucuları kapat-aç yapmalıyız.

Cluster menüsü altında bulunan sunucular aynı cluster altındaki sunuculardır.

Spread  Placement Group : Tüm sunucuları ve ya önemli 2 sunucun var ve fiziksel host üzerinde sorun olduğunda 2 sunucunun da down olmasını istemiyorsan spread grup ile bunu sağlayabiliriz.

EC2 sunuculara dışarıdan erişim kapalıdır. Security group içerisinden bunu değiştirebilir ve izinler yazabiliriz.

Volumes kısmından yeni bir disk eklemek istediğimizde availability zone diski ekleyeceğimiz sunucu ile disk volume'ı aynı az(availability zone) da kullanılmalıdır.

Oluşturduğumuz volume seçip "actions" kısmından "attatch volume" olarak seçebiliriz. Burada instance kısmında bağlayacağımız sunucuyu seçiyoruz. Ve diskimizi sunucuya bağlıyoruz. OS içerisinde diski genişletebiliriz. Ve ya yeni bir volume oluşturabilirsiniz.

Ek olarak diski genişletmek için, "Actions" kısmından modify volume diyerek mevcut volume genişletebiliriz.

AMİ oluşturmak;&#x20;

{% embed url="<https://www.youtube.com/watch?ab_channel=AOSNotes&v=eqGwgjcgZ2o>" %}

Sunucuyu kapatıyoruz, Snapshot menüsünden snapshot oluşturuyoruz. volume ve sunucu adını seçiyoruz. Create diyerek ilerliyoruz. Snapshot datası s3 üzerinde tutulur. Snapshot 'u seçip actions diyoruz create volume diyerek, bir volume yaratıp başka bir sunucuya disk olarak bağlayabiliriz. Create image diyerek, AMI imajı oluşturabiliriz. Copy diyerek farklı bir region'a kopyalayabiliriz.&#x20;

### EC2 Metada

* EC2 sunucumuz ile ilgili bir çok bilgiyi tutan HTTPs API servisidir. Böylelikle sunucumuzdan API sorgusu atarak, hangi AMI kullandığını öğrenebiliriz vb... sunucu hakkında bir çok konu da bilgi alma şansımız olur.&#x20;
  * metadata v1 : API any açık. Token yok.
  * metadata v2 : Tokenli api çağrısı.


# ELB

Elastic Load Balancer

ELB kullanmak için, Load Balancers > create > Application Load Balancer > İsim giriyoruz.

internet-facing : Dış dünyadan gelen trafiği sunucularımıza aktarır.\
internal : Sadece iç ağ'da (VPC) load balancing işlemini yapar.\
\
Dış ağ üzerinden trafiği iç ağımıza dağıtmak için internet-facing seçeneğini seçiyoruz. Dualstack seçeneğini seçersek IPv6 desteğini de aktif etmiş oluruz. Protocol olarak HTTP ve HTTPS (web site için) seçiyoruz. Availability zone seçeğini LB istekleri hangi VPC 'lere dağıtacaksa bunu seçiyoruz. Security gruplarımızı dahil edebiliriz.\
Routing seçeneği ile gelen trafiği içeride nasıl dağıtacağımızın ayarlarını yapabiliyoruz. İlk önce target grup oluşturmalıyız. Target type kısmında instance kısmına ec2 sunucuları seçebiliyoruz. Eğer istersek IP olarak da ekleyebiliriz. Sunucular farklı bir cloud ortamında olsa dahi Load Balancing yapabiliriz. Lambda seçeneği ile lambda servislerini balancing edebiliriz.

Protocol : Dış dünyadan aldığımız trafiği içeride sunucuların hangi portuna, hangi protokol ile trafiği göndereceğimizi seçiyoruz.

Health Checks : Trafiğin gönderildiği web sunucuların düzgün çalışıp çalışmadığını kontrol edebiliriz. Düzgün çalışıyorsa trafiği o sunucuya gönderebiliriz. Sorunluysa eğer, trafiği o sunucuya göndermeyecektir.

Path : Sunucular da sağlık kontrolü yaparken istekler hangi path'e gitmeliyse bunu seçiyoruz. Siteye erişimi direkt IP üzerinden yapabiliyorsak /index.html yazıp gitmiyorsak, Default olarak / kalabilir.

Advanced Health Check settings : Health check için kontrol kuralları uygulayabiliriz.

Port : Trafiğin yönlendirileceği port.

Health Threshold :  Kaç defa istek gönderilip, sunucunun sağlıklı olduğuna karar verilecekse buradan belirtebiliyoruz.

Unhealty Threshold : Gönderilen isteklerden kaç tane, fail, hata alırsak sunucunun problemli olduğuna karar vereceksek bunu burada belirtmemiz gerekmektedir.

Timeout : Bağlantı kurmaya çalışırken, kaç saniye de bağlantı kurmasına izin verilecekse, burada belirtmemiz gerekmektedir.

Interval : Her deneme arasında kaç saniye beklememiz gerekiyorsa burada belirtmeliyiz.

Success Codes : Arkada bulunan web sunucular hangi http kodunu döndürüyorsa sağlıklı kabul edeceğimizi burada belirtiyoruz. 200 durum kodunu yazabiliriz.

Register Targets : İstekleri dağıtacağımız sunucular ( add to registered ) seçiyoruz.  Ve LB hazır durumdadır.


# Auto Scaling

Sunucularımızda problem olduğunda bunun önüne geçebiliriz.

Launch Config : Sunucu kaynakları ve özelliklerini belirttiğimiz bir dosya yaratıp, sunucular otomatik oluşturulurken bu dosya üzerinden baz alınarak kurulacaktır.

Auto Scaling > Launch conf > create > Sunucu kurarken yapılan adımları giriyoruz > AMI seçiyoruz > Sunucu tipi > Launch ismi giriyoruz > IAM rolü seçiyoruz > Disk seçiyoruz. > Security group seçiyoruz > Create  > İlk launch configuration oluşturuldu.

Autoscaling group > Create > Launch configuration > yukarıda yarattığımız Launch configuration dosyasını seçiyoruz >grup ismini giriyoruz > grup size =auto scaling ile kaç tane sunucu yaratmak istiyoruz bunu belirtmeliyiz. > VPC  'mizin tüm subnetlerini seçiyoruz.

#### Advanced Details

Load Balancing : Eğer bu sunucurı Load balancer arkasına alıp yük dağıtımı yapmak istiyorsak burayı işaretleyip, oluşturduğumuz target grubunu seçiyoruz.

Health Checks : Sağlık kontrolünü ELB mi, yoksa EC2 üzerinden mi yapacağız. Bunu seçiyoruz. ELB üzerinden sağlık kontrolü yapıyorsak ELB seçeneğini seçiyoruz. Geri kalanlar default kalabilir.

#### Configure Scaling Policies

Keep this group at its initial size : Bunu seçersek autoscaling yapılandırmasında kaç adet sunucu oluşturmasını istediysek, onları oluşturur. Bu sunucuları silersek tekrar oluşturur. Birinde bir problem olursa silip yenisi oluşturacak.

Use scaling policies to adjust the capacity of this group : Bu seçeneği seçiyoruz çünkü ihtiyaç halinde sunucuları yaratıp auto-scaling yapmış olacağız.

Scale beetwen : 2 > Burada her türlü 2 sunucu bulunabilir şekilde ayarla demiş oluyoruz.\
And 4 instance : Aşağıda gireceğimiz ayara göre aşağıdaki belirttiğimiz durum oluşursa 4 sunucuya kadar sunucu ekle. Aşağıdaki durum sona ererse yaptığın değişiklikleri geri al demektedir.

#### Scale Group Size

Metric type : Application LB request count per target : LBye gelen istek sayısına göre ayarla.

Avarage Cpu util : Cpu değerine göre ayarla.

Target value : 30 > cpu 30un üstüne çıkarsa kuralı uygula, Ortamdaki sunucuların ortalama cpu değerlerini baz alır.

#### Configure Notifications

Auto scaling servisi hakkında bilgilendirme maili almak istiyorsak, buradan bildirimleri açabiliriz.

Tag ekleyebiliriz. Next diyip autoscaling grubunu oluşturabiliriz.

Mevcut sunucuları seçip, actions kısmından autoscaling grubuna dahil edebiliriz. Fakat autoscaling grubunda 2 sunucu istediğimiz söylemiştik. Fakat autoscaling ayarlarında yeni sunucularımızı dahil ettiğimizde bu ayar değişecektir. Kaç sunucuyu sonradan eklediysek o kadar sayı artacaktır. Bunu değiştirip 2ye alabiliriz. ve autoscaling fazla sunucuları cpu %30un altındaysa sunucularımızın fazlalarını kapatacaktır.&#x20;

{% embed url="<https://www.youtube.com/watch?ab_channel=Simplilearn&v=4EOaAkY4pNE>" %}


# EFS

Elastic File Storage (NFS Protokolü)

NFS bazlı dosya depolama servisi. EFS de diskler oluşturulur sunucuya bağlanır. EFS de bir dosya sistemi yaratıp, bunu bir sunucuya, bir klasöre bağlayabiliyoruz. İçerisine dosyaları upload edebiliyoruz. EBS de disk tek bir sunucuya bağlıdır. Tek diski birden fazla sunucuya mount edemeyiz. EFS bir disk değildir. Bir sunucuya bağlayıp üzerine işletim sistemi kuramayız. EFS NFS tabanlı bir dosya deposudur. Dosya ekledikçe otomatik olarak büyür. Dosya silindikçe otomatik olarak küçülür. Aynı anda birden fazla sunucu erişebilir.

#### EFS için Security Group işlemleri;

* EFS 'in sunuculara erişimi için "Security Group" kısmından kural yazmalıyız.
* Create Security group kısmından, bir isim belirliyoruz.
* SG içerisinde inbound rule kısmına gelip, type kısmını NFS Protocol kısmını TCP seçiyoruz.
* TCP Port Range kısmını 2049 yazıyoruz. Source kısmı Custom olarak seçip,
* EFS'e bağlanacak olan sunucularımızın bulunduğu SG seçiyoruz. ve SG grubunu oluşturuyoruz.

#### EFS Oluştururken;

* EFS servisine girip, Create file system diyoruz.
* VPC ve AZ seçiyoruz. ve yukarıda oluşturduğumuz SG seçiyoruz.
* Default gelen SG kaldırabiliriz. Next.
* Key kısmına bir isim giriyoruz. Value kısmına EFS olarak belirtiyoruz. Farklı bir şey de yazabiliriz.
* Diğer seçenekler default kalabilir.&#x20;
* Next. Ve EFS oluşturulur.
* Sunuculara mount edebiliriz.

{% embed url="<https://www.youtube.com/watch?ab_channel=AmazonWebServices&v=Aux37Nwe5nc>" %}

### UPDATE

* S3 gibi tier sistemi eklendi (Storage tier sistemi)
* EFS yapılandırılırken, dosyalarımızı yedeklemek istersek, enable automatic backups seçiyoruz.
* Dosyalarımızı artık tek bir zone üzerinde saklayabiliyoruz.
* EFS oluştururken File system policy ile dosyalarımıza erişim izinlerini düzenleyebiliriz.
* Farklı IAM kullanıcılarına grant additional permissions ile yetki düzenleme yapabiliriz.
* S3 gibi farklı farklı policyler ile farklı access pointler oluşturabiliriz.


# VPC

Virtual Private Cloud

Kendi özel ağ alt yapımızı oluşturmamızı sağlayan, sanal ağ katmanıdır. Tamamen kullanıcıya özel ve paylaşımlı değil.&#x20;

Her AWS hesabında, her region da bir adet varsayılan VPC ile gelmektedir. Biz istersek her region için 5 tane daha VPC yaratabiliriz.  5 soft bir limittir. 5den fazla VPC ihtiyacımız olduğunda AWS den bunu talep edebiliriz.

Her VPC bizim önceden tanımladığımız IP aralığına sahip olur. Yani VPC içerisinde kullanabileceğimiz IP bloğu tanımlıyoruz.&#x20;

Örneğin 10.0.0.0/16lı bir blok ekleyip, bunları alt subnetlere ayırabiliyoruz.&#x20;

Subnetler public ve private olarak 2 çeşitle ayrılabiliyor.

Public : Dış dünyadan erişimin yapılacağı subnet.

Private : VPC içerisindeki sunucuların birbirine erişim yaparken kullanılır.

VPC altında tüm trafik yönlendirmesini "routing table" dediğimiz servisle yaparız.

Örnek olarak, X subnetinden Y subnetine ya da Z subnetinden internete nasıl gidileceğini ya da, hangi yolun kullanılacağını anlatan ayarlama (konfigürasyon) dosyaları arayıcılığıyla yapılır.

Tüm bu karmaşık yapının, güvenliğini sağlamak adına da, ağ alt yapısında hangi subnet'e, hangi trafik gidebilsin, ve ya hangi subnet'den hangi trafik dışarıya çıkabilsin gibi kuralları belirlediğimiz Network access list ya da network ACL ayarlamaları yapabiliyoruz.

Buna ek olarak VPC de oluşturduğumuz kaynaklara, direkt atayarak da bu kaynaklara ne tarz bir trafik erişimine izin verebileceğimizi belirlediğimiz EC2 kısmında da gördüğümüz SGlar yaratabiliyoruz.

Public subnetlerin internet erişimini sağlayan ve aynen evimizde bulunan internete girmemizi sağlayan modem,router larla aynı mantığa sahip olan, internet gateway hizmetini de VPC altında kullanabiliyoruz.

Bunun yanı sıra kendi şirket ağ altyapısı ile bu VPC arasındaki direkt bir bağlantı olacak olan VPN   bağlantısını sonlandırmak için VPN gateway tanımı yapılabiliyor.

S3 ya da dynomoDB gibi diğer AWS servislerine bu vpc'den direkt ulaşmak adına private endpoint linkleri yaratabiliyoruz. Ayrıca hem kendi hesabımızda bulunan diğer VPC'ler, hem başka hesapta bulunan VPCler ile pear dediğimiz ayarlamalar yaparak bu VPCler arasında direkt bağlantı kurulabiliyor. Ve bu VPClerde bulunan kaynakların birbirine erişebilmelerini sağlayabiliyoruz.

Internet Gateway, Dış dünyaya çıkış ve dış dünyadan gelişi sağlar.

Nat Gateway, Private subnetlerde bulunan sunucular internete çıkması için kullanılacak. Public subnetlerin birinde bulunması gerekmektedir.

Private subnet'de bulunan sunucularımızın S3 servisi gibi servislerle iletişime geçebilmesi için bir private link oluşturmalıyız.

#### VPC Oluştururken,

* VPC konsoluna girip, create diyoruz. IP bloğu ne olacaksa onu giriyoruz.
* IPv6 istiyorsak VPC oluştururken seçiyoruz.

Her region'da default bir VPC bulunur.

İlk VPC yaratıldıktan sonra VPC'ye tıklayıp actions kısmından DNS hostname açmamız gerekiyor. Bunu seçmezsek VPC altında bulunan sunucular VPC DNS'i üzerinden haberleşemez.

Route tables, her VPC yaratıldığında otomatik olarak bir route table oluşur. Route table VPCnin nereye nasıl erişeceğini belirlediğimiz kısımdır.

Internet Gateway, İnternet gw oluşturup, yapımızı internete çıkarmalıyız. oluşturup, üzerine çift tıklayıp VPCmize mount ediyoruz. Böylelikle dışarıdan da kaynaklarımıza erişim olacak.

Route table, 0.0.0.0/0 a giderken internet gw kullan diyerek. İnternet çıkışımız aktif oluyor.

Subnets kısmından yeni bir subnet yaratabiliriz.

* Create subnet
* İsim giriyoruz.
* Yeni yarattığımız VPCyi seçiyoruz.
* Hangi AZ olacağını seçiyoruz. Hangi blokta olacaksa bunu seçiyoruz.

Private subnetler için yeni bir route table yaratıyoruz.  subnet associations kısmından edit diyerek private bloklarımızı seçiyoruz private ve public ayrımını bu şekilde yapıyoruz. Subnets kısmına gelip, public subnetleri tek tek seçip, Actions kısmından Auto-assingn IP setting enable diyoruz. Ve böylelikle public subnetlere otomatik olarak public IP adresi tanımlanacak.

Dış dünyadan içeride private subnet' de bulunan sunuculara erişmek istersek, public subnet bloğuna jump box sunucusu kurup ilk bu sunucuya bağlanıp, daha sonra private blokta bulunan sunuculara erişebiliriz.

Sunucu kurulumu esnasında oluşturduğumuz VPC seçebiliriz. Auto-assingn public IP kısmını eğer public subnetler auto assingn IP olarak seçmediysek enable diyoruz. Fakat biz public subnetlerde enable etmiştik. O yüzden default kalabilir.

Sunucu kurulumunda VPC seçtiğimizde bu VPC için yeni bir SG oluşturmalıyız. Çünkü her VPC nin SG kuralları farklıdır. Ek olarak private blokta sunucu oluşturuyoruz. Jump box sunucudan private subnet de bulunan sunucuya erişmek için AWS nin bize verdiği pem dosyasını JUMP box sunucuna import ediyoruz.

Network Access list, atandığı subnetin hangi originden hangi türden trafiği kabul edeceğini,hangi destination hangi türde trafik göndermesine izin verileceğini belirlediğimiz kural bölümü. Her subnet de en azından bir ACL atanmak zorundadır. Her subnet için  ayrı ayrı ACL yaratılabilir. Tek bir ACL yaratılıp birden fazla subnete atanabilir. Bir nevi subnet bazında SGlardır.

Network ACL : Subnetlere atanıp, subnet bazında kurallar oluşturulur.

Security Group : Sunuculara atanıp, sunucu bazında kurallar oluşturulur.

Network ACL de kurallar baştan sona bakılır. Kurallar ACL de yoksa paket (istek) deny olur.

**NACL, alt ağ düzeyinde çalışır ve bu nedenle önce trafiğe erişim sağlar. Bu, trafiği bir sonraki seviyeye, yani Güvenlik grubuna ulaşmadan önce filtrelemesine izin verir. NACL tarafından herhangi bir trafik reddedilirse, güvenlik grubu bunu asla görmez. Güvenlik grubu, NACL tarafından izin verilen trafiği yine de reddedebilir.**

Normal de Public bir blokta bulunan sunucular her restart ettiğimizde IP adresleri değişiyor. Sunucularımızın da sabit bir IP adresi olmasını istersek aşağıda bulunan adımları yapmalıyı&#x7A;**.**

* Elastic IPs
* Allocate new address
* Allocate

Böylelikle AWS bize sabit bir IP adresi verdi. Bu IP adresinin üzerine tıklayıp,

* Actions
* Associate address
* instance (IP adresini kullanacağımız sunucuyu seçiyoruz)
* Associate

Sabit IP adresimizi yukarıda belirttiğimiz sunucuya tanımlamış olduk. Ve ilgili sunucu sürekli olarak bu IP adresini kullanıyor olacak.

Subnetlerin, private ve public olmasını belirleyen etken route table'dır. Route table üzerinde private blok kendi içerisinde haberleşebiliyor. Public ise internet GW kullanarak dışarı çıkabiliyor.

Private blokta bulunan sunucuların (lokal IP 'ye sahip olan) internete çıkmasını istersek nat gw yaratıp, public subnet'in içerisine konumlandırıyoruz. (herhangi bir public subnet'e konumlandırabiliriz) daha sonra private subnetlerin bulunduğu route table'na diyoruz ki, sen internete giderken bu nat gw servisine paketleri teslim et. Dolayısıyla  private sunucular internete bu şekilde erişebilir. Ama nat gw bir internet gw olmadığı için dış dünyadan burada bulunan sunuculara erişilemiyor.

#### NATGW VS INTERNETGW

> Bu şekilde düşünebilirsiniz, diyelim ki iki alt ağınız var. sunucuları her iki alt ağda da başlatırsınız. Şimdi IGW'yi alt ağlara eklerseniz, bu alt ağ herkese açık hale gelir. Bu, dış dünyanın bu alt ağa bağlanabileceği anlamına gelir. Bulut sunucunuza dışarıdan erişilebildiği ve bulut sunucunuzun dış dünyaya bağlanabileceği anlamına gelir.
>
> Ancak dış dünyanın sizin bulut sunucunuza bağlanamaması gibi bir gereksiniminiz varsa, o zaman alt ağınızda NAT kullanmanız gerekir ve alt ağınız özel alt ağ olur. Böylece, bu alt ağdaki her örnek dış dünyaya bağlanabilir, ancak dış dünya sizin bulut sunucularınıza bağlanamaz.
>
> \---------------------------------------------------------------------------------------------------
>
> Bir İnternet Ağ Geçidi (IGW), VPC'nizdeki kaynakların internete erişmesine izin verir ve bunun tersi de geçerlidir. Bunun olması için, bir alt ağın IGW'ye erişmesine izin veren bir yönlendirme tablosu girişi olması gerekir.
>
> Yani - bir IGW, genel alt ağınızdaki kaynakların internete erişmesine ve internetin söz konusu kaynaklara erişmesine izin verir.
>
> Bir NAT Ağ Geçidi benzer bir şey yapar, ancak iki ana fark vardır:
>
> 1. Özel bir alt ağdaki kaynakların internete erişmesine izin verir (yum güncellemelerini, harici veritabanı bağlantılarını, wget çağrılarını vb. düşünün) ve
> 2. sadece tek yönlü çalışır. Siz açıkça izin vermedikçe, internet genel olarak NAT'ınızdan özel kaynaklarınıza ulaşamaz.

#### Nat Gateway Oluşturmak;

* Create Nat Gateway
* Subnet (Hangi public subnet de olacağını seçiyoruz)
* Elastic IP allocation ( Nat gw için bir IP adresi ayırıyoruz )
* Create Nat GW

Ardından private subnet için yarattığımız route table geliyoruz. 0.0.0.0/0 a giderken NAT GW  'kullanmasını söyleyen route ekliyoruz.&#x20;

Private sunucuların internete çıkmasını sağlayan bir diğer yolu nat instance kurmaktır. Bunun için yeni sunucu kuruyoruz. Ami olarak arama kısmına "NAT" yazıp, amazonun nat ami 'ını seçiyoruz. Eğer ki yapımız büyük ise, nat instance olarak kuracağımız sunucunun instance type'ını daha uygun yüksek paketler seçmeliyiz. Bu sunucuyu da Public Subnetlerin birine kuruyoruz. Mevcut yarattığımız SG seçiyoruz. Böylelikle nat instance oluşturuluyor. Ardından nat instance olarak oluşturduğumuz sunucuyu seçip, Actions kısmından source/destination check kısmını disable ediyoruz.&#x20;

Private subnetlerin route tablolarına gidip 0.0.0.0/0 a giderken bu sunucuyu kullan diyebiliyoruz.

Nat GW : AWS kontrolü altındadır.\
Nat Instance : Bizim kontrolümüz altındadır.

Endpoints, sunucuların internete çıkmadan (zaman harcamadan) AWS servislerine erişmesini sağlar.

#### Endpoints Oluşturmak için;

* Create endpoints
* AWS services (AWS servislerine erişmek için kullanacağız) Örnek olarak S3 servisini seçebiliriz.
* Service Name : S3
* VPC ( kullanacağımız, yarattığımız VPC'yi seçmeliyiz)
* Route tables, Hangi subnetler endpoint üzerinden AWS servislerine ulaşabilsin? Burada bunu seçmeliyiz. Hepsini seçiyoruz.
* Policy, Erişimleri vs kısıtlamak istersek custom bir policy yaratabiliriz. Biz full access seçebiliriz.
* Create endpoint

Route tablolarına bu endpoint için ilgili rule'lar otomatik olarak eklendi.

VPC Peering, Farklı VPCler internete çıkmadan kendi aralarında  haberleşmelerini sağlar. Örnek olarak A VPC'si B VPC'si arasında peering yaparsak kendi aralarında irtibatı olur.

{% embed url="<https://www.middlewareinventory.com/blog/aws-vpc-peering-tutorial>" %}

Peering connections, örnek olarak varsayılan VPC'miz ile sonradan yarattığımız VPCyi peering yaparak birbirleri ile haberleştirebiliriz.&#x20;

Peering connections name : isim giriyoruz.

VPC (requester) : Bağlantı kurmayı kim talep ediyor? Bunu seçmeliyiz.

Select Another VPC to peer with : Neredeki VPC ile iletişim kuracağız bunu seçiyoruz. Kendi hesabımızdaki mi? Başka bir hesapta bulunan VPC mi?

VPC (accepter) : Bağlantıyı hangi VPC ye göndereceğiz bunu seçmeliyiz. Create diyerek ilerleyebiliriz.

Farklı bir hesapta bulunan VPC ile de bağlantı kurabiliriz. Ayrıca farklı bir region da bulunan VPCler içinde peering yapabiliriz. Peering yaparken, VPClerin IP blokları (lokal) birbirinden farklı olmalıdır.

Farklı bir hesap ile peering yaparsak o hesaba bir onay gidecektir. O hesap onay verirse, bağlantı sorunsuz sağlanacaktır. Kendi hesabımızda bulunan VPCler için peering 'imizi seçip actions kısmından Accept VPC peering connections request diyoruz. Ardından route tablolarını güncellememiz gerekiyor. Sayfada çıkan modify my route tables now seçeneğine tıklıyoruz. Öncelikle isteği gönderen VPCnin route tablosuna gelip, edit diyoruz.

Her 2 VPC nin route tablolarına gidip, birbilerinin subnetlerini destination olarak belirtip, Peering connections'  servisini kullanmalarını söyledik.

Yani her 2 VPCnin de birbirine erişebilmeleri için route tablolarını güncelledik. 2 VPC birbirleri ile iletişim kurabilir.

#### Direct Connect ve VPN

VPN şirket ağımızdan VPC arasında internet üzerinden bağlantı kurmamızı sağlar.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FpGr0ScOKpmHO0hVme41r%2FRedundancy-Higher.cf97732b85470f0b3616f025f8a3534f95bb1940.png?alt=media\&token=e7ac8bb8-5e38-4da1-82b0-993eeb382466)

Direct Connect, Örnek olarak AWS Türkiye de Turk Telekom ile kendi arasında kapalı devre yüksek hızlarda bağlantı kuruyor. Biz de Turk Telekom tarafına hat çekerek AWS ile iletişimi sağlıyoruz.


# CloudFront

AWS dünyasının CDN hizmeti

AWS yüzlerce lokasyona yayılmış CDN hizmet noktalarına edge locations deniliyor. Hizmeti devreye aldığımız zaman kullanıcıların statik veriye kendilerine en yakın edge lokasyonundan erişmeye başlıyor.&#x20;

#### Hizmetleri

* Statik dosyaların önbelleklenmesi (caching)
* Web formları, yorum ve giriş kutuları (sepete ekle) düğmelerini ve ya son kullanıcılardan veri yükleyen diğer özelliklere sahip dinamik içerikleri de cacheler.
* Canlı yayınları, talebe bağlı videoları, cache yapabiliriz.
* HTTP get-head-post-put-delete-options-patch- metotlarını destekler.
* Api isteklerini hızlandırır. SSL-TLS desteği vardır.
* AWS Shield ile entegre layer 3-4 ddos mitigation ve AWS waf ile entegre layer 7 koruması mevcuttur.
* Lambda desteği mevcuttur.

#### CloudFront Oluştururken,

* Create distribution
* Web ve ya, RTMP tabanlı mı olacak? Burada bunu seçiyoruz.

#### Origin Settings

Origin Domain Name : CDN ' hangi sunucudan(servisten) verileri alacak. Örnek bir LB sunucusu vb.

Origin Path : Sunucuya direkt / path 'ine mi gidilsin? Yoksa örnek olarak /image klasörü vb alt klasöre mi gidilsin? Bunu burada belirtiyoruz.

Origin ID : Bu CDN ağının unic adı, istersek değiştirebiliriz.

Origin SSL Protocols : Cloudfront ile kaynak sunucu eğer ssl protokolü kullanacaksa, hangi protokole izin vereceksek bunu seçiyoruz. Buna göre trafik edge ve origin arasında belirttiğimiz protokol ile gerçekleşecek.

Origin Protocol Policy : Cloudfront ile kaynak sunucu arasındaki bağlantının, http mi, https mi bunu seçiyoruz. Match viewer seçeneği, misal kullanıcı websitemize https geliyorsa, cloudfront'da origine https olarak gidecektir.

Origin Response Timeout : Cloudfront ile origin sunucudan kaç saniye boyunca cevap bekleyeceğini belirtiyoruz. Buraya 30 yazarsak, cloudfront bir veri için origine gider 30 saniye boyunca cevap alamazsa timeout alır.

Origin Keep-alive Timeout : Kaç saniye haberleşme olmasa da bağlantının korunacağını belirliyoruz.

HTTP Port : Origin sunucumuz 80'den değilde 8080den cevap veriyorsa, bunu belirtiyoruz.&#x20;

Origin Custom Headers : Kaynak sunucuya her istek gönderildiğinde eklemek istediğimiz bir HTTP header bilgisi olup olmadığını belirtiyoruz. Özellikle birden fazla CDN kullanırken paketin nereden geldiğini HTTP loglarında görmek için önemli bir durumdur.

Buraya kadar bahsettiklerimiz Cloudfront ile origin sunucunun nasıl haberleştiği ile alakalıdır.

#### CloudFront (Cache behavior settings)

Buradaki ayarlar, cloudfront servisinin caching ile ilgili ayarlarıdır.

Path Pattern : Nelerin cache'leneceğini belirtiyoruz. "\*" seçili ise tüm statik içerikler cachelenecek.

Viewer Protocol Policy : Cloudfront 'un dış dünyadan gelen isteklere göre nasıl davranması gerektiğini söylüyoruz. \
\
HTTP and HTTPS > İki protokole de izin ver.\
Redirect HTTP to HTTPS > HTTP'den gelen istekleri HTTPS'e yönlendir.\
HTTPS only : Sadece HTTPS çalışır.

Allowed HTTP Methods : Örnek olarak kullanıcılar origin sunucu ile hangi HTTP metotlarıyla iletişim kurmasını istiyorsak bunu seçiyoruz.

Cached HTTP Methods : Hangi HTTP metotlarının cachelenmesini istiyorsak burada belirtiyoruz.

Cache based on Selected Request Headers : İstek headerlarına göre cacheleme yapmak istiyorsak, bir alt sütunda bunu seçebiliriz.

Object Caching : Cloudfront cache yaparken dosyaların, ne kadar zaman tutulacağına 2 şekilde karar veriyor.

1 - Cache ayarlarını origin sunucu üzerinden yapabiliriz. Sunucumuz bu değerleri cache-control header bilgisi ile cloudfront a gönderiyor. Cloudfront buradaki değerlere göre bir objeyi ne kadar cache'de tutacağını buna göre karar veriyor.

2 - Cache süresi vb ayarları cloudfront'un karar vermesini sağlayabiliriz. (customize)

Minimum TTL : Bir objenin cache'de kalabileceği minimum süreyi belirtir.

Maximum TTL : Bir objenin cache'de kalabileceği maksimum süreyi belirtir.\
\
Origin sunucu header bilgilerinde belirterek header bilgisinde yer alan süre zarfında cacheleme isteği gönderebiliyor.\
Origin bir değer belirtmediyse Default TTL de belirtilen süre boyunca obje cachelenebiliyor.\
Time To Live yani TTL süresi boyunca obje için origin sunucuya aynı obje için istek gönderilmiyor.

Smooth Streaming : Canlı bir yayın dağıtıyorsak seçebiliriz.

Restrict viewer access(signed URL or Signed cookies) : Diyelim ki bir eğitim firmasıyız, Müşterilere eğitim videoları satıyoruz. Ve ya bir yazılım firmasıyız,  müşterilere yazılım paketleri satıyoruz. Bir uygulama yazdık ve müşterilere bu paketleri ya da videoları, geçici URLler üzerinden gönderiyor. URL her seferinde yeniden oluşturuluyor ve sadece URL li alan kullanıcı belirli bir zaman aralığında buna erişebiliyor. Yani biz müşterilerimize, URLler arayıcılığıyla sadece onun erişebileceği içerik gönderip, işin bitince de bu içeriği expried edebiliyoruz. Bunu signed URL or Signed cookies ile yapıyoruz. Bu işlemleri uygulamanın içine gömer, Buradaki seçeneği de aktif edersek,  Cloudfront bu tarz dağıtımlar yapmamıza izin verir.

{% embed url="<https://www.youtube.com/watch?ab_channel=Bitfumes&v=oPKuRsemap0>" %}

{% embed url="<https://www.youtube.com/watch?ab_channel=visualskyman&v=5RELL2nhY_Q>" %}

Compress objects Automatically :  Cache'lenen obje sıkıştırılmaya izin veriyorsa, Cloudfront bu objeleri sıkıştırılmasını sağlıyor.

Lambda Function Associations : Lambda fonksiyonunu tetiklememizi sağlar. Bir web sitemiz var diyelim, bu web sitesinin yenisini yaptık test etmek için de kullanıcıların %90nını eski siteye, %10nunu yeni siteye gitsin. Buna uygun bir kod yazıp lambdaya yükleriz. Her gelen isteğin bu kodun tetiklenmesini sağlayabiliriz.

#### Ana Ayarlar,

Price Class : Cloudfront'un dünyada hangi edge bölgelerine yayılacağını belirtiyoruz.

AWS WAF web ACL : Cloudfront'un waf hizmetini kullanabiliriz.

Alternate Domain names (cnames) : Cloudfront da kullanacağmız domain ismini giriyoruz. web sitemiz [www.test.com](http://www.test.com) ise bunu belirtiyoruz.

SSL cert : Eğer biz sitemizi HTTPS protokolü ile yayınlamak istersek, sertifika seçmemizi istiyor. Cloudfront bunu bize kendisi de sağlıyor.

#### Distribution Settings

Restrictions  : geo restrictions : Ülke bazlı engelleme yapabiliriz.

invalidations : Cachelenen bir içeriği cache'ini temizleyebiliriz. Örnek olarak origin sunucuda bir resim dosyası var ve sonradan bunu sildik. Fakat cloudfront bu resmi halen cache'inde tutuyor. İlgili resmin path'ini (yolunu) girip cache'ini temizleyebiliriz. /images/deneme.jpg gibi..


# Route53

AWS tarafından sunulan, yönetilebilen DNS hizmeti. Aynı zaman da domain register edebiliyoruz.

Tüm AWS servisleri ile entegre durumdadır. Api desteğine sahip, uygulamalarımız otomatik olarak ihtiyacı olan kayıtları oluşturabilir.

Route policy ve healthcheck servisi arayıcılığıyla load balancing işlemi yapabiliyoruz. Gelen istekler coğrafi olarak yönlendirilebilir. Healthcheck servise gelen istek'de sorun varsa failover senaryoları kurabiliriz.

#### Route53 de iki çeşit zone mevcuttur;

Public Zone,

* Tüm dünyadan erişim yapılabilir.
* Alan adının gerçekten var olması gerekmektedir.
* Böyleye tüm dünyadan domainimizin IP adresini öğrenmek isteyenlere bu zone cevap verecektir.

Private Zone,

* Lokalde sadece VPC üzerinden erişim yapılır.
* Alan adı gerekmez, herhangi bir isimlendirme seçilebilir.
* VPC de kaynakların IP adresleri yerine, isimlerle haberleşme imkanı verir.

#### Private zone oluşturmak için;

* Hosted zone
* Create hosted zone
* onur.local > Kullanacağımız lokal domainimizi yazıyoruz.
* Type, Private
* Hangi VPC için bu zone oluşturulacaksa seçmeliyiz.

Böylelikle VPC içerisinde bulunan sunucular private kayıtları çözerler.

Private zone sadece seçtiğimiz VPC içerisinde bulunan sunucular erişebilecekler.&#x20;

SOA : Domain için temel kayıtları barındırır.

NS : DNS sunucuların listesidir. Domainimiz burada yazan NS'ler tarafından yönetilecektir.

TTL : Kayıtlar kaç saniye, kaç dakika boyunca tekrar istemcilere iletildiğini belirtiyoruz. Örneğin 60 dakika TTL süresi olan bir kayıt değiştirilmişse bile 60 dakika sonra kullanıcılar bunu yeni kayda göre işleyebileceklerdir.

Alias : Alias kaydı ile bir kaydı, AWS servislerine / kaynaklarına bağlayabiliyoruz.

#### Health Check Yaratmak,

* Create Health check
* Name, misal irlweb1-abdweb1
* What to Monitor : Endpoint
* IP address : IP adresi giriyoruz. Misal irlweb1 IP adresini. ve abdweb1 IP adresini.
* Port : 80
* Next : Böylelikle irlanda ve ABD de de bulunan sunucumuz için healthcheck yarattık.

#### Public Zone Eklemek,

* websitesi - domain.com
* Create record set
* name  : domain.com
* Type : A - IPv4
* Value : 1.2.3.4 - 5.6.7.8 > Birden çok IP eklenebilir.

Route Policy : DNS üzerinde basit bir load balancing yapabiliriz.\
Weighted  : Gelen istekleri böler.&#x20;

Örnek olarak, domain.com için farklı IPlere sahip 2 kayıt yaratalım, Kayıtları oluştururken weight kısmını birini 10 diğerine 90 yazalım. Böylelikle 10 isteğin 9'u 90 yazdığımız host'a gidecek. 1 istek istek ise 10 yazdığımız host'a gidecek. (Değerler %liktir)

Letancy : Route53 dns sorgusu atan kişi, hangi lokasyona daha kısa sürede eriştiğine karar verip, ona göre uygun sunucuya yönlendirdiği routing şeklidir.

#### Letancy yapılandırma,

* Create record set
* Name : domain.com
* value   : 1.1.1.1 > avrupada ki sunucumuzun IP adresi.
* Routing policy : latency
* Region : Sunucu hangi region da bunu seçiyoruz. Çoğu durumda bunu otomatik seçer.
* Set ID : webserverEU
* Create

#### ABD için,

* Name : domain.com
* Value : 2.2.2.2 > ABDde de bulunan sunucunun IP adresi.
* Routing Policy : Latency&#x20;
* Set ID : webserverUS
* Region : us-east-1 > kaydını eklediğimiz sunucunun region'nunu belirtiyoruz.

Örnek olarak, bir kullanıcı Belçika'dan istek yaparsa Route53 bu isteği Avrupa da bulunan sunucumuza iletecek.

#### Geolocation Oluşturmak,

Geolocation : Örneğin ABD den, istek gönderen kişi bu sunucuya.. Avrupa'dan istek gönderen kişi şu sunucuya gitsin diyebiliyoruz.

#### 1.Kayıt

* Create record set
* Name : domainx.com
* Value : 1.1.1.1 > Avrupa da bulunan sunucumuzun IP adresi.
* Routing Policy : Geolocation
* Location : Europe, Eklediğimiz  kayıt hangi ülkede ki ve kıtadaki kullanıcılara etki edecekse bunu belirtiyoruz.
* SET ID : webserverEU

#### 2. Kayıt

* Name : domainx.com
* Value : 2.2.2.2 > ABD'de de bulunan sunucunun IP adresi.
* Routing Policy : geolocation
* Location : North America
* SET ID : webserverUS

#### 3.Kayıt

* Name : domainx.com
* Value : 1.2.3.5 > İrlanda da bulunan sunucunun IP adresi.
* Routing Policy : Geolocation
* Location : Default
* SET ID  : webserverEU2

1. kayıt da kullanıcılar  Avrupa'dan istek atarsa 1.1.1.1 'e gidecek.
2. kayıt da kullanıcılar Amerika 'dan istek gelirse, 2.2.2.2'ye gidecek.
3. kayıt da diğer tüm bölgelerden gelen istekleri 1.2.3.5'e gidecek.

Failover, birden fazla IP girerek eğer 1. sunucuya erişilemezse 2.IP adresine yönlendir diyebiliriz. Burada ilk yarattığımız Health check'ler işe yarıyor.

#### Failover oluşturma,

* Name : domaina.com
* Value : 1.1.1.1 > İrlanda da bulunan sunucunun IP adresini yazıyoruz.
* Routing Policy : Failover
* Failover Record Type : Bu kayıt primary kayıt mı olacak? secondary kayıt mı olacak? Bunu yazıyoruz.
* SET ID : domaina-primary
* Associate With health check : Yes > Primary sunucuyu seçiyoruz. Burada isteklerde bu sunucuyu kontrol et sunucuda problem yoksa, ilk IP yani bu IP adresine istekleri ilet. Eğer problem varsa, secondary sunucuya yönlendir.

#### 2.Kayıt

* Name : domaina.com
* Value : 2.2.2.2 > Secondary sunucu IP adresi
* Routing Policy : Failover
* Failover Record Type : Secondary > Bu kayıt secondary sunucuya ait.
* SET ID : domaina-secondary
* Associate with health check : yes > Secondary sunucuyu seç.
* Create

Failover oluşturmuş olduk.

#### Trafik Policy Oluşturmak,

* Policy name : deneme
* Version desc : boş bırakabiliriz.
* Ardından hangi tip dns kaydı yaratmak istediğimizi seçiyoruz.
* A kaydı
* Connect to : A kaydını nereye bağlamak istiyoruz.
* Geolocation seçiyoruz.  Location : Europe . Avrupa'dan gelenleri connect to 1.1.1.1 'e yönlendir. Location : North America connect to 2.2.2.2 'ye yönlendir.

#### Ve ya,

* Location  : Europe
* Connect to : weight
* 10 weight : connect to : 1.1.1.1 endpoint
* 90 weight : connect to : 2.2.2.2 endpoint
* Location : North America
* Connect to : New Endpoint
* Endpoint type : value 2.2.2.2

{% embed url="<https://docs.gitlab.com/ee/administration/geo/replication/location_aware_git_url.html>" %}

{% embed url="<https://www.ictshore.com/cloud/dns-geolocation-tutorial-aws>" %}


# RDS

AWS Database

Veritabanı, Temelde içerisinde bir ve ya binlerce yapısal tablolar yapıp, içerisine veri doldurduğumuz uygulamalardır. Belirli bir formatta veriyi saklamaya ve kendi özel dilinde yapılan sorgularla bu saklanan veriden cevaplar çıkarmaya ve aynı zamanda bu veriye yeni eklemeler yapmaya yarayan uygulamaların ortak adıdır.

Veritabanları 2'ye ayrılır.&#x20;

1- Relational database (ilişkisel)

* Tablo tabanlıdır.
* Hiyerarşik ve ilişkisel veriler için uygun.
* Ön tanımlı şema gerektirir.
* Dikey genişler.
* SQL dilini destekler.
* Karmaşık sorguları destekler.
* Join işlemine imkan verir.
* Yüksek işlem kapasitesi sağlar.
* En eski ve en çok kullanılan database tipidir. Verileri kolonlar ve satırlar halinde tablolar içerisinde barındırıyor.
* Bu SQL tipine ilişkisel denilmesinin sebebi tabloların kendi aralarında ilişki-bağlantı kurup,  ortak sonuçlar çıkarabilmesidir.
* İki ve ya daha fazla tablodaki satırları aralarında ilgili bir sütuna göre birleştirmek işlemine join denilmektedir.

2- *Non*-*relational database*

* Döküman tabanlı.
* Dağıtık ve büyük veri setlerine uygun.
* Şema dinamiktir.
* Yatay genişler.
* SQL dilini desteklemez.
* Daha temel ve basit sorguları destekler.
* Join işlemine imkan sağlamaz.
* Tek dize işlem kapasitesi sağlar.
* Veriler tablolarda değil, dökümanlarda anahtar-veri eşlikleri halinde tutuluyor.
* Tablo yok, koleksiyon denilen içerisinde json formatında veri tutan dökümanlar mevcut.
* Dinamik olarak, kodun içerisinde istediğin veriyi, istediğin veri tipini bir ortalama yazabiliyoruz.
* Join işlemi yok, karmaşık sorgu yok.

AWS hem SQL hem de NoSQL yönetilebilen veri tabanı hizmeti sunmaktadır. Yönetilen veri tabanı hizmeti olarak RDS :&#x20;

* MSSQL
* Oracle
* MYSQL
* MariaDB
* PostgreSQL
* Amazon Aurora

Gibi servisleri kullanma imkanı sunmaktadır.

NoSQL tarafında ise, DynamoDB hizmetini AWS bize sunuyor.&#x20;

RDS AWS tarafında yönetilen DB servisi hizmetidir. Yönetilen kısmı, veritabanının kurulumu, kaynak yönetimi, bakım işlemlerinin AWS tarafından yapılıyor olmasıdır. Veritabanı dizayn ve veri manipülasyon işlemleri bize aittir. Ek olarak Aurora mysql ve postgresql veritabanı moturunu destekliyor.

RDS Kullanmak için,

* Hangi DB uygulamasını kullanacaksak bunu seçiyoruz.
* Ardından DB servisimizin kaynaklarını seçiyoruz.
* Disk tipini seçiyoruz (disk i/o önemli)

RDS Özellikleri,

* Instance start-stop desteği var. 7 gün sonra instance terminate olur.
* Tek butona tıklayıp, instance boyutunu büyütüp ve ya küçültebiliriz.
* Kesintisiz depolama imkanı.
* Otomatik bakım ve güncelleme.
* Otomatik yedekleme, manuel yedekleme, snapshot ve snapshot'dan yeni database oluşturmak.
* Günün istenilen anına yedekten dönme imkanı.

Multi AZ,

* Veri tabanının aynı region içerisindeki senkron bir kopyası.
* Aktif-Pasif cluster.
* Otomatik failover imkanına sahip.
* Kesintisiz çalışma ve felaketten kurtarma senaryoları için.
* Performans artışı sağlamıyor.

Read Replica,

* Veritabanının aynı ve ya farklı region'da oluşturabileceğimiz bir ve ya birden fazla asenkron kopyası.
* Bu bir cluster değil.
* Read only bir kopya.
* Performans artışı sağlamak için.

Eğer amacımız performans ise, Read replica mantıklı seçenektir. Amacımız kesintisiz - sağlam altyapı ise, multi AZ mantıklı bir seçenektir.

#### RDS Servisi Oluşturmak,

* RDS > Create Database
* Hangi DB kullanacaksak, bunu seçiyoruz. Misal Mysql.
* Next
* DB Engine versiyonunu seçiyoruz.
* DB instance class seçiyoruz. Hangi tip kaynaklarda DB istediğimizi soruyor.
* Allocate Storage. Disk Alanı seçiyoruz.
* Storage Type, Disk tipini seçiyoruz.

#### Settings,

* DB instance idenfier : Oluşturacağımız DB'nin isimini giriyoruz.
* Storage Type, Disk tipini seçiyoruz.
* Master username, Database yetkili kullanıcısının oluşturulmasını istiyor. Buraya DB kullanıcı ismini giriyoruz. Misal : admin
* Master password, Kullanıcımızın şifresini oluşturuyoruz.
* Next

#### VPC Ayarları,

* Public Accesibilty : Yes, Tüm dünyadan erişme açık. Böylelikle public bir IP alacak. No, seçersek eğer, sadece bulunduğu VPCden erişlebilir.
* VPC Sec Group, ister mevcut, istersek yeni bir sec grup yaratabiliriz.

#### Database Options,

* Dbname, database ismini giriyoruz.
* Port, Dilersek farklı bir port yazabilir, dilersek boş bırakıp default kullanabiliriz.
* DB Parameter group : Default
* IAM DB Auth : Disable, Normal mysql kullanıcısı ve şifre ile dbye bağlanabiliriz. Enable ettiğimiz de, IAM de yaratılan kullanıcılar bu db üzerinde yetkilendirebiliriz.

#### Backup,

* Kaç gün geriye dönük backup alacaksak, bunu belirtiyoruz.
* Backup Window, yedek ne zamanlar alınmalı? Select windows diyerek bir zaman seçebiliriz.
* Duration , Kaç saate kadar işini bitirmeli?

#### Monitoring,

* İzlemeyi açıp, kapatabiliriz.

#### Log Exports,

* Hangi log tipini cloudwatch servisine göndereceğimizi soruyor.&#x20;

#### Maintenance,

* Otomatik minör updateler yapılsın mı?
* Maintenance Window, Ne zaman minör updateler kontrol edilsin?
* Deletion Protection, Enable dersek, RDS'i manuel olarak silemeyiz.
* Create

DB oluşturulması 5 dakikayı bulabilir. Yaratılan instance SSH ile bağlanamayız. Bu instance AWS'ye aittir Sadece SQL client ile bağlantı kurabiliriz. DB Sec Group üzerinden bu DB için gerekli izinleri inbound rule'da görebiliriz. Databases sekmesinde "endpoint" kısmında yazan dns name ile DBye bağlanabiliriz. Bağlanırken SQL client ugulamarından yararlanabiliriz.

#### RDS Yapılandırma Sekmeleri,

Performance insights : DB performasına yönelik istatisliklerini görebiliriz.

Snapshots : Alınan yedekleri görebileceğimiz kısım. Otomatik backup yanı sıra manuel olarak da yedekleme işlemini başlatabiliriz.

Automated Backups : Backupların nasıl hangi zamanlarda alındığını görüyoruz.

Reserved Instance : Rezerve edilmiş kaynaklar alabiliyoruz.&#x20;

Subnet Groups : DB'mizin kayıtlı olduğu subnet grubu.

Parameter groups : DB mizin, ekleyebileceğimiz modülleri, ayarlamalarını seçebiliyoruz.

Option Group : DB için seçebileceğimiz ek özellikler.

Events : DBnin geçmişe ait loglarını görebiliriz.

Events Subs : Önemli olayları mail göndermesini istiyorsak, buradan ayarlayabiliriz.

Recommendations : AWS nin DBmiz için bize sunduğu öneriler bu kısımda bulunuyor.

#### Actions Kısmı,

* Create Read Replica : Read replika yaratabiliriz.
* Create Aurora Read Replika : Aurora DB kullanıyorsak, read replika oluşturabiliriz.
* Migrate snapshots : Mevcut DBmizi seçtiğimiz farklı bir DB engine çevirmemize yarıyor.

Restore işlemi ile yeni bir DB instance yaratılarak olmaktadır. Mevcut DBnin üzerine yedek yazılmaz.&#x20;

Latest restoreble tpye : son alınan yedeğe geri dönmek.

Custom  : İstediğimiz bir zaman dilimine dönebiliriz.

RDS veritabanlarına IP adreslerinden erişilemez. DNSname kullanarak erişilir. Bu dns ismine databases altında instance'nın üzerine tıklayıp "endpoint" kısmından görebiliyoruz.

Modify > Multi AZ deployment > Yes > Contiune > Apply immendatly > modifydb instance : Böylelikle veritabanımızı multi az olarak ayarladık.&#x20;

Multi AZ : DB'mizin bir kopyasını başka bir AZye alıyor. Ana sunucuda sorun olduğunda, diğeri devreye girecek. Aktif-pasif çalışacaktır. Böylelikle ana sunucuda yapılan her değişiklik pasif sunucuya da yansır.

#### Read Replica oluşturmak,

* DB seç > Actions > Create read replika
* Destination Region > DB mizin, nerede hangi region'da aynısını oluşturmak istiyoruz?
* DB instance identifiler : veritabanımızı seçiyoruz. misal, calisanlar\_db
* Diğer ayarlar default kalabilir.
* Create read replika

Read replika sunucumuza erişmek için sec-group ayarı yapılmalı. Read replika sunuculardan okuma yapılır. Veri girilmez. DBmizi sildiğimiz zaman otomatik backupların tamamı silinir. Manuel olarak bizim aldıklarımız (snaphot) silinmez. Dilersek ileride manuel aldığımız snapshotları kullanarak yeni bir DB yaratabiliriz.

### Redshift - Veri Ambarı

Veri ambarında bulunan tüm verileri analiz etmemize yarar. Mevcut veri analizi yapabildiği gibi, S3de de bulunan verileri de analiz etmemize yarar.

#### Online transaction processing,

* Veri tabanı.
* Veri giriş ve veri manipülasyonu.
* Operasyonel günlük veri işlemleri için.
* Veri analiz sorgularını çalıştırmak, veri tabanının performansını düşürüyor ve mevcut iş akışının yavaşlamasına neden oluyor. Mevcut verileri saklamak için bu seçeneği kullanabiliriz.

#### Online analytical processing,

* Veri ambarı (redshift)
* Veri analizi.
* Konsolide edilmiş birden fazla kaynaktan gelen veri ile çalışabilir.
* Oluşan verileri analiz etmek için kullanabiliriz.

Analiz isteğini SQL sorgusu halinde master node'a gönderir. Master node compute node'lara gönderir, gelen cevabı iş zekası yazılımı ile görsel bir grafiğe dönüştürür ve kullanıcıya sunar.

{% hint style="info" %}
Maneger node ücretsizdir.
{% endhint %}

### DynamoDB

* İlişkisel olmayan veri tabanı (noSQL)
* Key-value şeklinde kodlanan verileri json formatında dökümanlar halinde saklayan noSQL veri tabanı türüdür.
* Temelde noSQL veri tabanları tek anahtar üzerinden index'lemeye izin verirken, DynamoDB birden fazla anahtarın birleşmesinden 2.index yaratılmasına izin verir.
* <10ms gecikme süresi sağlayan, yönetiken no-SQL veri tabanı hizmetidir. Alt yapı AWS'ye aittir.
* Veriler key-value eşlenikler şeklinde json dosyalarında saklanır.
* Multi key indexleme imkanı sağlar.
* SSD tabanlı 3 farklı veri merkezinde 3 farklı kopya halinde tutularak, yüksek erişilebilirlik ve tutarlılık sağlar.
* Autoscaling imkanı bulunur.
* Read-write capacity üstünden scaling sağlar.
* İhtiyaca göre read-write kapasitemizi genişletebiliriz.
* Global tables özelliği ile multi region hem okuma, hem yazma imkanı sağlar.
* Streams özelliği devreye alınır. Streams ile yapılan her işlemin kaydı tutulur. Streamsler başka olayları da tetiklememizi sağlayabilir.
* Stream servisi aktif hale getirirsek, multi region özelliğini kullanabiliriz.
* Streams, öğe bazında yapılan her değişikliğin kaydının tutulmasını sağlar.

#### Global Tables,

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FNzvimqtrKvYncrZ9urq4%2FDynamoDB_Global-Tables-01.dad2508b80e8b7c544fe1a94a2abd3f770b789da.png?alt=media\&token=27ea3665-ea50-4e4b-87f6-d6b37dc275e7)

Kullanıcılar dünyanın farklı bölgelerinde replike çalışan dynamoDB nosql veritabanından okuma yazma yapabilir.

DynamoDB accelerator,

DynamoDB accelerator ile in-memory caching imkanı sağlanır. 35 güne kadaar otomatik yedeklemenin yanı sıra manuel yedekleme imkanı da vardır. Öğelere TTL değerleri atanabilir.

#### DynamoDB Oluşturmak,

* Services > DynamoDB > Create table
* Table Name : calisanlar\_db
* Primary Key : personelno - number (text değer olarak ekleseydik "string" seçmeliyiz.
* Add Sort Key : Ad (string) İkincil key ekleyebiliyoruz.
* Use Default Settings : Ayarları otomatik yapmak için.
* Secondary indexes : İkincil bir index girebiliriz.
* Read-Write Capacity mode : On-demand, Her hangi bir kapasite belirtmiyoruz. O andaki yüke göre otomatik olarak AWS ayarlıyor.
* Provisioned Capacity : İstediğimiz, ihtiyacımız olan, Read-Write değerlerini girebiliyoruz.
* AutoScaling : İhtiyaca göre read-write kapasitesini DynamoDB burada belirlediğimiz seçeneklere göre bize sağlıyor.
* Target utilization : Kapasitesinin %70ini doldurursa, otomatik olarak aşağıdaki kapasiteler eklenecek.
* Minimum Provisioned : En az vereceği kapasite.
* Maximum Provisioned : En fazla vereceği kapasite
* Encryption At rest : Default
* Create

DynamoDB oluşturuldu, Streams devreye almak için,

* Overview > Manage Stream > New and old images > Enable. Böylelikle ileride global table yaratabiliriz.

DynamoDB RDS de olduğu gibi, Bağlantı için DNS ve IP adresi yoktur. Dynamo ile bağlantı kurmak için tek seçenek, AWS SDK kullanarak, kendi yarattığımız uygulamaları direkt dynamoDB ile bağlantı kurdurabiliriz. Bunu DynamoDB Api kullanarak yapabiliriz.

Point in time Recovery : Günün istediğimiz anına bu tabloyu geri döndürebiliriz.

TTL attributes : Manage TTL > TTL Attribute > TTL yazarsak, artık tablonun içinde bir ttl değeri atayabiliyorum. Örnek olarak tabloya ttl kalonu ekleyip, bir tarih yazabiliriz. O tarihten sonra da TTL eklenmiş olduğu o kolondaki kayıt silinecektir. TTL yazmamızın sebebi, hangi kolonda bu değeri tutacağımızı söyledik.

Global Tables Oluşturmak için, Add region > Frankfurt > Tablomuzun bir kopyasını da frankfurt region'da mevcut.&#x20;

Stream : Yaptığımız tüm değişikliklerin saklanmasını sağlıyor.

İtems > Create items > yeni bir kayıt(döküman) yaratabiliriz.

* No SQL de daha sonradan bir tablo (kayıt) yaratıp farklı kolonlar ekleyebiliriz. Örneğin her dökümanda dogumtarihi ekleme zorunluluğumuz yok.
* Alarms : Dynamodb için alarmları bilgilendirme maili ve ya SMS gönderebilmemizi sağlar.
* Dynamo 'ya çoğu çalışan manuel kayıt girmez. Bu kayıtarı uygulamarımız dynamodb'ye otomatik olarak yazar.
* Backups : Manuel backup alabilir, ve ya otomatik backup 'lar başlatabiliriz. Günün her saniyesine yeni bir restore başlatabiliriz.
* Trigger : Tablona veri ekleyip, lambda fonksiyonunu çalışmasını(tetiklemesini) söyleyebiliriz.
* Access Control : Misal, kullanıcılar yarattığımız uygulamaya facebook bilgileri ile girebilmelerini ve DynamoDB de okuyup, yazabilmeleri için buradan izinler oluşturabilir. Sosyal ağlara izinler verebiliriz (Twitter-Instagram-Facebook-Reddit vb)

#### DynamoDB Accelerator(DAX),

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Ffgcj2kfACC5lItpFe7BG%2Fdax_high_level.e4af7cc27485497eff5699cdf22a9502496cba38.png?alt=media\&token=eccc446e-ff04-42b6-a728-364b26f15bfd)

* <10ms civarında uygulamalarımız veri okuyabilir ve yazabilir.
* Caching Cluster, istekler (uygulama istekleri) Dax'a geliyor. Dax bu istekleri dynamodb'ye yönlendiriyor.
* Dax cluster sayesinde in-memory-cache özelliğini kullanarak uygulamalarımız, DynamoDB tablosundan okuma yapabiliyoruz.
* Böylelikle cluster'ı ayarlayıp devreye alırsak, dynamodb yerine dax'a bağlanıp, uygulamalarımız dax 'a istekleri iletecek ve dax arkada dynamodb' ile iletişim kuracak.


# ElastiCache

in-memory-caching-service

![Misal, Elasticache arkasında DB var diyelim, İlk istekte DB'ye sorar, belirlediğimiz süre boyuna aynı istek için tekrar DB'ye gitmez. Kullanıcı Sessions bilgilerini tutar.](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FNWjNddR932pYtuzokImc%2F1631110522081.png?alt=media\&token=53823c34-a8de-4023-af8d-b8d214d8aa21)

* DB'den aldığı cevapları, cache de tutup cevaplar.
* Kullanıcı oturum bilgilerini saklayabiliriz ( Sessions )
* AWS 'nin in-memory-caching servisidir.
* En popüler 2 in-memory-caching servisi olan, memcache ve redis desteğine sahiptir.
* Tamamen yönetilen servis.

#### Memcache

* Sadece string data tipinde veri tutabiliyor.
* Basit ve hızlı in-memory-cache ihtiyaçlarını karşılamak içindir.
* Multi thread yapısı sayesinde dikey genişlemeye imkan tanır.

#### Redis

* String dışında list,dizin, veri tiplerini de barındırabiliyor.
* Konteks in-memory-cache ihtiyaçlarını karşılamak içindir.
* Single thread yapısı sayesinde yatay genişlmeye imkan tanır.
* Multi AZ / master-slave yapıları kurulabilir.

#### ElastiCache Yapılandırma,

* Services > Elaticache > Get started now
* Cluster engine > Redis - Memcache
* Name : Elaticache 'e vereceğimiz bir isim.
* Engine version comp : Engine sürüm seçebiliriz.
* Port : Default port kalabilir.
* Parameter Group : Default
* Node Type : Node kaynaklarını değiştirebiliriz.
* Number of nodes : Kaç node olacağını seçebiliriz.
* Subnet Group : istersek yeni bir subnet oluşturabilir ve ya mevcut subnetleri kullanabiliriz.
* Maintanance Window : Bakım,patch, işlemlerinin ne zaman olabileceğini seçiyoruz.
* Create

Parameters Group, memcache için parametre değişikliği yapabiliriz.&#x20;

Configuration Endpoint, Node'lara bağlanıp konfigürasyon değişikliği yapabiliriz.

Node Endpoints,  Bağlanıp veri girip, veri tutmak için. Memcache  ve ya Redis 'e sec-group kuralları oluşturup, telnet ile veri oluşturabiliriz.

Böylelikle DB ile memcache-redis ayarlarımızı yapıp, iletişim kurmalarını sağlarsak, istekler memcache-redis e gelir. Memcache-Redis ilk isteği DB'ye sorup, aynı istek gelirse kullanıcıya ram'de sakladığı bilgi üzerinden döner.

{% embed url="<https://www.youtube.com/watch?ab_channel=TechnologyHub&v=E_PuOTmfRJY>" %}


# CloudWatch

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FloYL5Gr8CimZCrJ99BWv%2Fproduct-page-diagram_Cloudwatch_v4.55c15d1cc086395cbd5ad279a2f1fc37e8452e77.png?alt=media\&token=e2a1b3d8-001a-4791-b28a-f3ccf9b8010a)

* AWS dünyasının monitoring hizmeti.
* Sunucu kaynak kullanımlarını izler ve raporlar. Buna ek olarak uygulamalarımızı kısıtlı da olsa izler.
* S3 bucketlarımızın boyutunu içerisinde kaç tane obje olduğunu raporlar.
* Cloudwatch izlenilen servisler, sunucular için dashboard'lar yaratmamıza izin verir.
* Kaynak kullanımı gibi tuaf bir durum farketmesi halinde bizi bilgilendirebilir.
* Önceden belirlediğimiz bir durum gerçekleşirse, SNS ile bize bilgi verebilir.
* CloudWatch ile işlemleri tetikleyebiliriz. Misal kaynak kullanımı %70 in üzerine çıkarsa yeni sunucu kur vb. gibi taleplerde bulunabiliriz.

Yeni bir sunucu oluştururken, enable cloudwatch detailed monitoring kısmını işaretliyoruz. Ve 1 DK içerisinde sunucudan toplanan veriler cloudwatch'e yansıyacak. Panelden cloudwatch'e geçip, Dashboard'dan kendimiz için bir grafik oluşturabiliriz. S3 bucket da bulunan obje sayısını öğrenmek için number widget ekleyebiliriz. All metrics kısmından, hangi servis için grafiği ekleyeceksek, bunu seçiyoruz.

#### Alarm oluşturmak için,

* Create alarm
* metrics  : EC2  - Per instance > Tek sunucu. ve ya, Access All instance > Tüm sunucular.
* Name : İlkalarm
* whenever : Alarm ne zaman tetiklenecek?
* is : >=80 > Cpu kullanımı %80ni geçerse.
* for : 1 datapoint : 1 defa tekrarlarsa. (datapoint 5dk)
* Thread Missing Data as : cloudwatch servisi veriye erişemezse, bunu nasıl uygulayıp, cevap versin. Örn, sanal sunucu kapandı.
* Missing : Veriyi alamadım olarak işaretle.
* ignore : Bunu önemseme.
* Bad : Sunucuya ulaşamazsan alarm üret.
* Good : Alarm'a gerek yok.
* Missing seçebiliriz.
* Actions kısmında,
* Whenever this alarm : State is alarm.
* Send Notification to : Nereye alarm gönderilsin? > New list > Topic Name = Alarmlar > <alarm@onurbolatoglu.com> ' a alarm gönder.
* AutoScaling : %80ni geçtiğinde, yeni sunucu oluştur gibi kurallar oluşturabiliriz.
* EC2 Action kısmına gelip,
* Whenever this alarm : state is alarm
* Take this action : reboot this instance
* Sunucuda böylelikle %80den fazla cpu kullanımı olduğu zaman mail gönderecek.&#x20;
* Alarm : Belirlediğimiz kriterlere göre bize haber verir.

#### Events,

Bir durum tetiklenirse, o duruma göre git başka bir şey yap dediğimiz kısımdır.

#### Misal,

* Events > Event pattern
* Service Name : EC2
* Event Type :  EC2 instance state-change notification > Spescific state > Stopped.&#x20;
* Any instance > Herhangi bir sunucu.&#x20;
* Specific instance > Burada bir sunucu seçebiliriz.
* Any olarak devam edebiliriz.
* Eğer bir sunucum power-off olursa,
* Targets > SNS topic ile alarm gönder. Diyebiliyoruz.
* Events > Belirlediğimiz bir olay olursa, o olay ile ilgili belirlediğimiz Targets işlemini uygula.

#### Configure Details,

* Name : ilkrule
* Create rule
* Sunucu kapandığında alarm oluşacak.

Dashboard yaratmadan, metrics kısmından hızlıca grafikleri görebiliriz. Cloudwatch üzerinde, ram kullanımı göremeyiz. Örnek olarak sunucuda gerekli ayarları yapıp biz bunu cloudwatch 'a iletebiliriz.

#### Logs,

Sunucularımız içerisinde çalışan (nginx vb) uygulamaları servislerin access - error vs loglarını buradan görüntüleyebiliriz. Burada kendimize bir log grubu yaratıp, sunucuya giriş yapıp logların bulunduğu dosyayı, cloudwatch 'a düzenli olarak gönderebiliriz.

* Sunucuların, cloudwatch servisine log gönderebilmeleri için, IAM rolü yaratmamız gerekiyor.
* IAM
* Roles
* Create Role
* AWS Service > EC2
* Next
* CloudWatch Agent Admin policy
* Next
* Tag girebiliriz.
* Role Name: cwagent
* Create role
* EC2 bölümüne girip, Kuralı atayacağımız sunucuya "actions" kısmından attach/replace IAM role seçiyoruz. Oluşturduğumuz "role" seçiyoruz. Bu sayede CW servisine dosya gönderebileceğiz.

#### Logs Grubu oluşturmak,

* Cloudwatch > logs > get started > create log grup.
* Log group name : ilkgroup

Log göndereceğimiz sunucuya bağlanıp, cw agent kuruyoruz. Gerekli yapılandırmadan sonra sunucu loglarını "cw-logs" a iletilecektir.


# CloudTrail

AWS Kayıt Defteri

{% hint style="info" %}
API : Uygulamaların ve ya servislerin diğer uygulamalar ya da servisler ile konuşmasına\
olanak sağlayan giriş-çıkış kapısı olarak özetleyebiliriz.
{% endhint %}

AWS servislerini, hesabımızı yönetmek için, Web console, aws-cli, aws development kit gibi araçları kullanırız. 3 aracında arka tarafta yaptığı aslında api çağrılarıdır. Örnek bir sunucu kurduğumuzda finish dediğimizde, EC2 servisine API çağrısı yapılır.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FOr0BFSIh37VnkksyUPu6%2Fproduct-page-diagram_AWS-CloudTrail_HIW%402x.d314033178a16dbbd99111038789685e42f23278.png?alt=media\&token=9f1c4166-cfbb-4bef-a8d7-7c64cce02aef)

#### CloudTrail,

* Hesabımızda yapılan her işlemin hangi kullanıcı tarafından, hangi tarihte, hangi IP adresinden yapıldığının kaydını tutar.
* Çoklu AWS hesabı olan X firmasında, hangi işin, kimin tarafından yapıldığını öğrenmek için çok kullanışlı bir servistir.
* AWS hesabımızın, yönetim, uyumluluk ve operasyonel risk denetimi sağlar.

Cloudtrail dashboard bize 90 günlük işlemleri gösterir. Event history geçmiş işlemleri görüntülememizi sağlar. Daha uzun süre loglar oluşturmak ve görüntülemek için yeni bir trail oluşturabiliriz.

* Trails > Create Trail
* Trail Name: Deneme
* Apply Trail to All regions : Bu trail tüm regionlara iletilsin mi? Yes. Böylelikle tüm regionlarda bulunan işlemlerin kaydını tutacak.
* Management Events : Yönetimsel olayların nasıl tutulmasını istiyoruz? All.
* Data Events : S3, bucket da bulunan, objelerin değişikliklerinin kaydı tutulsun mu?
* Storage Location : Yaratılan loglar nerede tutulsun? Yeni bucket yaratabiliriz. Dilersek mevcut bir bucket a gönderebiliriz.
* Create.

Loglar oluştukça, seçtiğimiz bucket'a yazılacaktır. Logları S3 üzerinden görebiliriz.


# CloudFormation

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FPhgjG2Ulb2K15HsjYa2V%2Faws-cloudformation-index.png?alt=media\&token=3d6139da-4653-4d8d-bb88-db6eed75085d)

Kurmak istediğimiz alt yapıyı adım adım kurulum aşamaları ve kurmak istediğimiz servisler şeklinde yazabileceğimiz bir template dosyası yaratmamıza imkan sağlıyor. Daha sonrasında, template dosyasında belirlediğimiz servisi tek bir tıklama ile kurmamızı sağlıyor.

Cloudformation temel de 2 ana bölüme sahip,

Template : JSON/YAML formatında template 'ler oluşturabiliriz. Misal, x isimli bir sec-group yarat 80 portunu dışarıya aç. Ve ya, 1 adet t2micro sunucu yarat şeklinde template oluşturabiliriz. Daha sonra bu template dosyasını, cloudfront 'a aktarıp bana bu template 'den adımları takip ederek bir stack yarat diyebiliyoruz.

Stack : Template ile yaratılmasını istediğimiz yapıdır. Örneğin template 'de bir sanal sunucu daha ekle şeklinde güncelleme yaptığımız zamani bunu güncelle komutu vererek, mevcut yapıya bir sunucu eklenmesini sağlayabiliyoruz. Ayrıca stack 'e sil komutu verdiğimiz zaman yapı silinebiliyor.

#### Örnek Bir Template dosyası içerisinde,

Template 4 farklı alt kısım içerir. Ayrıca 8 alt kısımdan oluşabilir.

* Version : Template versiyon numarası atayarak, gelişimini takip etmemize ve birden fazla versiyon yaratmamıza imkan sağlıyor.
* Description : Template ile ilgili bir açıklama girmek istediğimiz zaman kullanılır. Örneğin bu template neden oluşturuldu, amacı nedir ve sonucunda ne olacak tarzı yazılı bir açıklama girilmesi sonradan takip etmek açısından çok mantıklı olacaktır.
* Metadata : Template'in temel özelliklerini ve template hakkında ek bilgiler tutabiliriz. Örn: aws: cloudformation:  Designer attribute ile bu template kim oluşturuldu bilgisi tutulabilir.
* Parameters : Yaratılacak kaynaklar ile ilgili seçilmesi gereken seçenekleri, bu kısımda belirtiyoruz. Misal, ec2 sunucu yaratan bir template'e parameters kısmında key-pair seçimi parametresini girersek, daha sonra bu template'den yaratılacak bir stack'in yaratım aşamasında kullanıcıya hangi key-pair kullanmak istediğini soracak ve kullanıcının girdiği değer o sanal sunucu yaratılırken kullanılacak.
* Mappings : Yaratılan kaynakların diğer AWS kaynakları ve özellikleri ile eşleştirilmesini sağlayabiliriz. Misal, kullanıcıya hangi sunucu yaratmak istediğini sorduğumuz zaman onun seçtiği sanal sunucu türüne göre hangi AMI kullanılacağı bilgisini Mappings kısmında belirleyebiliriz.
* Conditions : Şartlar bu kısımda belirlenir. Eğer, şu seçildiyse bunu yap. Ama seçilmediyse, şunu yap şeklinde koşullayabiliriz.
* Outputs : Stack yaratımı sunucuda kullanıcıya geri bildirmek istediğimiz bilgileri bu kısımda bildiriyoruz. Örneğin yaratılan EC2 sunucu IP adresi bilgilerini ekranda kullanıcıya göstermek istersek bunu outputs kısmında seçmemiz gerekir.
* Resources : Her template 'de mutlaka bulunması şart olan tek alandır. Template ile yaratılmasını istediğimiz kaynakları belirtiyoruz.

#### Stack oluşturmak,

* Create a stack : Template 'den stack yarat.
* Create stack set : Birden fazla account ve region'a kurabildiğimiz türü.
* Desing a template : Gui arayüzünden template oluşturabiliriz.
* Create template from your resources : Mevcut kaynağımızı template haline çevirebiliriz.

İstersek template dosyasında her şeyi belirleriz. Stack yaratan kişi hiç bir şey seçmez, ya da bazı şeyleri son kullanıcıya sorarız. Örn, kaç ec2 sunucu olsun vb. Parameters kısmında bu tür soruları sorabiliyoruz. Kaç sunucu, vpc hangisi olacak vb..

* Create new stack : Yeni bir stack yaratıyoruz. örnek bir aws template bulup deneyebiliriz.
* Stack Name : ilk-stack
* Options : Kaynaklara tag girebiliriz.
* Permissions : Cloudform stack yaratırken yetkili olmasını istediğimiz IAM role varsa bu rolü atayabiliyoruz.&#x20;
* Rollback Triggers : Buraya 90 yazıp, ARN kısmına cloudwatch 'dan eğer yarattıysak, X bir alarmın ARN bilgisini giriyoruz. Bu da stack yaratılırken o alarm tetiklenirse stack oluşturmayı durdur. 90 dakika boyunca alarmı gözleyecek.

#### Advanced,

* Notification : Stack yaratılınca bildirim atmak istiyor muyuz? SNS olarak gönderebilir. Önceden oluşturulmuş bir alarm varsa seçebiliriz. Topic ARN girebiliriz.
* Termination Protection : Stack silinebilir durumda olsun mu?
* Timeout : Bu stack buraya yazdığımız süre boyunca oluşturulmazsa, oluşturulan kaynakları sil. Örneğin, bazı parametreler yanlış girilmiş olabilir. O ana kadar oluşturulan kaynakları sil.
* Rollback on failure : Stack yaratılırken, bir sorun olduğunda cloudformation bir sonraki adım ile devam etmesini ister miyiz? Örneğin 10 sunucu kurulmasını istediğimizde, 6.sunucuda, hata verdi. Cloudformation 7 sunucuya geçsin mi? Yoksa tüm işlemleri alıp her şeyin silinmesini mi isteriz?&#x20;
* Stack Policy : Stack yaratıldıktan sonra kimin, ne işlem yapıp, yapamayacağını burada belirleriz. (Bu stack ile ilgili)
* Next

Stack yaratıldıktan sonra, kaynak template üzerinde bir değişiklik yapıp, (misal bir sec-group daha yarat ve ya bir sunucu kur) gibi güncellemeleri stack üzerine çift tıklayıp update stack diyerek, güncel template dosyasını gösterirsek, güncelleyebiliriz.


# SNS

Simple Notification Service

AWS Duyuru servisi, SNS 3 temel yapıdan oluşur.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FiZO6WyigvK325kkv7YcC%2FProduct-page-diagram-Amazon-SNS_event-driven-SNS-compute%402X_.4b9c0a75aa40bda9cdb12f0176930a12da2872bf.png?alt=media\&token=a0e77be0-bd62-4d4d-9289-07f7207bba7a)

Publisher : Mesaj gönderen ya da mesaj gönderimini tetikleyen kaynaktır. Örn: cloudwatch\
Publisher yayınlamak istediği mesajı TOPIC 'e iletir.

Topic : Yayınlamak istediğimiz mesajın hedef kitlesini bir arada topladığımız basit klasörlerdir. Publisher mesajı yazar, bu mesajı topic üzerinden publish eder yani yayınlar. Daha sonra SNS mesaj bildirimlerine abone olmuş kişilere mesajı iletir. Topic 'lere abone olmuş çeşitli kaynaklar vardır. Örn, Bir email adresi ile topic 'e abone olunabilir. Bu mesaj e-mail adresine iletilebilir.

Subscriber : SQS Amazon - Lambda - SMS - Email - HTTP/HTTPS vb duyuru servis üyeleri olabilir. Örneğin kullanıcılar telefonlara yaptığımız uygulamayı yüklerse bildirim gönderebiliriz.

#### SNS Oluşturmak,

* Topics : Create topic
* Name : Alarm
* Display Name : Mail de, bildirimde buraya yazdığımız isim gözükecek.
* Encryption : Bu topic'i şifrelemek istiyor muyuz?
* Access Policy :&#x20;
* Advanced : Topic mesajlarını json dilinde kendimiz yazabiliyoruz.
* Basic

Topic Bildirimini kim gönderecek?

* Only the topic owner : Sadece topic'i yaratan kişiler, bu topic'e mesaj gönderebilir.
* Everyone : Herhangi bir kimse mesaj gönderebilir.
* Only the specifed AWS accounts : Sadece seçtiğimiz AWS hesapları mesaj gönderebilir.

Topic kime mesaj iletecek?

* Only the topic owner
* Everyone
* Only the specified AWS accounts
* Only requester with certain endpoints : @domain.com > domainine sahip kullanıcılar.

Delivery retry policy (HTTPs) : HTTPs endpointlere kaç defa bildirim göndermeyi denemesi gerekmektedir?

Delivery status logging : Bildirimleri karşı tarafa ulaşıp, ulaşmadığını izleyip, izlemediğimiz sorulmaktadır. "SMS ve Email mesajları buradan takip edilmiyor." Lambda-SQS-HTTPs-Platform Endpoint (app)

#### Topic oluşturmak,

* Create Topic
* Topics > Alarm > Create subscription
* Protocol : Hangi yöntem ile abone olmak istiyoruz. Email vb. Abone olacak mail adresine öncelikle onay maili gitmektedir ve bu mail onaylanmalıdır.
* Publish Message : Test mesajı gönderebiliriz.
* TTL : 100 yazarsak, 100 saniye boyunca mesaj iletilmediyse mesajı iptal et.
* Message Attributes : Genelde application bildirimleri için kullanılır. Api key vs.
* Publish Messages

Böylelikle cloudwatch'da rule yaratıp, örneğin sunucuların durumu değişirse (reboot vb) hedef (target) olarak SNS Topic kullanıp, oluşturduğumuz Topic'e üye olan kişilere bildirim ilet diyebiliriz.

#### Mobile,

Push Notification : Google,Apple,Microsoft vb push notification servisleri gibidir. Misal gönderinizi 5 kişi beğendi bildirimi gibi. Uygulamamızı yükleyen insanlara topic'imize üye yapabiliriz ve bildirim gönderebiliriz.

Text Messaging :&#x20;

* Prometonel : Promosyon mesajları için.
* Trasactional : Onay mesajlarıdır. (Gelen kodu gir vb)
* Phone number : SMS'in iletileceği numara.
* Sender ID : Karşı tarafın, yani SMS'in iletileceği kişinin gördüğü isim. (From kısmında gözükür)

Buraya eklediğimiz numaraları da topic'e üye yapabiliriz ve toplu mesaj gönderebiliriz.


# SQS

Simple Queue Service

Tamamen yönetilen mesaj kuyruk servisidir. İki tip SQS kuyruk tipi mevcuttur.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F9GnhRwIIxkl2NVKfTdak%2Famazon-sqs-standard-queue-and-fifo-queue.jpeg?alt=media\&token=1a66933a-0a91-4ffc-ab5b-14e32407f5c9)

#### Standart

Saniye de sınırsıza yakın işlem kapasitesi, mesajın tek bir defa iletilmesi ve giriş çıkış sırası garanti değildir.

#### Fifo

Saniye de 300 mesaj kapasitesi, batch request ile bu 3000 mesaja kadar çıkabilir. Kuyruğa ilk giren mesaj işlenir. Mesajın tek seferde işleneceği garanti edilir.

#### SQS Oluşturmak,

* Queue Name : ilkSQS > Kuyruk tipi seç.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FuQepWqV8n628yN2qQT5k%2Fproduct-page-diagram_Amazon-SQS%402x.6df419be87198e0f8b0c8151eceac65584db78ea.png?alt=media\&token=acbb6c95-6ebb-4e27-ae2b-a38de959b3c0)

#### Configure Queue

* Default visbilty Timeout : Servisin kuyruğu çekip, işlemin kuyrukta gizli bekletilmesi için belirtilen süre.
* Default Retention Period : Bir mesajın kuyrukta ne kadar zaman bekleyebileceğini belirtiyoruz. Bu süre boyunca, bu mesaj servisler tarafından çekilmezse mesaj silinir.
* Maximum Message Size : Bir mesajın maksimum boyutunu belirtiyoruz.
* Delivery Delay : Mesajın kuyruğa eklenip, ne kadar süre erişilemez olacağını belirtiyoruz.
* Receive Message Wait time : Bir isteğin kuyrukta ne kadar süre yeni bir mesaj bekleyeceğini belirtiyor. Servis mesaj çekmek için queue 'da ne kadar beklemelidir.
* Dead Letter Queue Settings : Bazı durumlarda mesajlar bir sebepten işlenemezse, Bu mesajların belirli bir deneme sayısı sonrasında incelemek üzere başka bir kuyruğa aktarılmasına imkan sağlar.
* Server Side Encryption (SSE) Settings : Kuyrukların şifrelenmesi için ayarlar yapılır.
* Create Queue

Text mesajı göndermek için "Actions" kısmından send a message kısmını seçebiliriz. SQS kullanımı genelde SDK'ler arayıcılığıyla bir programın içine gömdüğümüz kodlar ile yapılmaktadır. Daha sonrasında servis gelir bu mesajı çekip işler ve siler.


# SWF

Simple Workflow Service

Yazılım geliştirme işleriyle ilgilenen kişiler için üretilmiş bir servistir. SWF yapılan bir işin düzgün bir şekilde yapılıp, yapılmadığını kontrol etmektedir. Temel de 3 bölümden oluşur.

Workflow Starter : İş akışı yürütmelerini başlatabilecek herhangi bir uygulamadır. Örn, sipariş verdiğimiz X bir web sitesi.

Workflow Decider : Karar verici, tüm bu iş akışının kordinasyonunu sağlayıp, işlerin olumlu,olumsuz bilgisine göre işleri bir sonraki adımı ya da farklı adımı tetiklemeye yarıyor.

Workflow worker : Esas işi yapıp, belirlediğimiz işi yapıp sonucu veren programlar. Örnek siparişe göre ürünün stoklarda olup, olmadığını kontrol eden, geriye olumlu ya da olumsuz sonuç dönen sipariş onayı backend worker programına gönderiliyor. Yönetilen iş akışı hizmeti sunuyor.

#### Süreç,

Müşteri => Sipariş => Tahsilat => Paketleme => Gönderim => Kayıt => Sipariş onayı.


# SES

Simple Email Services

E posta gönderim servisidir. Uygulamalar arayıcılığıyla mail göndermemizi sağlıyor. Örneğin EC2 üzerinde çalışan bir uygulamamız var, ve bir web mağazamız var. Bu web mağazasından alışveriş yapan her kullanıcıya bu alışveriş bilgilerini, bunun yanında da teslimat bilgilerini mail ile göndermek istiyoruz. Bunun SES ile yapabiliriz. Ek olarak pazarlama ve kampanya mailleri gönderebiliriz.

#### Servis Oluşturmak,

* identity management : Mail adreslerimizi ya da domainlerimizi ses servisine tanıtabiliriz. domain.com gibi. Örneğin buraya  (email adresini) <onur@onurbolatoglu.com> yazarak, ekleyerek from kısmı bu kullanıcı olur. Ayrıca domain olarak da ekleyebiliriz.
* Email statistics : Mail istatislikleri, üste bulunan sending limit incrase kısmını seçiyoruz. Böylelikle AWS spamı önlemek için mailleri incelemeye alıyor.
* Reputation Dashboard : Domain email gönderimi sağlığını görüntüleyebiliriz.
* Dedicated IP : Normal de maillerimiz paylaşımlı bir mail sunucudan gönderilir. Kendimize ait bir IP adresi talep edebiliriz.
* Configuration Sets : Gönderdiğimiz maillerin durumunu görmek için burayı kullanabiliriz. Cloudwatch,sns,kinesis gibi servisler de tutmak ve buna göre aksiyon alabiliriz.
* SMTP Settings : Uygulamalarımız mail gönderimi yapmak için, bu ayarlamaları yapabiliriz. Böylelikle (SES) servisini SMTP sunucu olarak da kullanabiliriz.
* suppression list Removal : Bounce (hata) olarak geri dönen mailleri gönderdiğimiz kişileri buraya ekler ve tekrar mail göndermemizi (hata aldığımızı kişi ve domainler) engeller. Bu ekran, bu adresleri listeden çıkarmamızı sağlar.
* Cross Account : Başka bir hesap adına gönderdiğimiz maillerle ilgili bilgi almak için kullanırız.
* Email Temp : Göndereceğimiz mailler standart aynı ise, sadece gönderdiğimiz kişilerin adı değişiyorsa bunları değişken olarak atıyoruz ve template oluşturuyoruz. Json tarzında bir template dosyası yaratıyoruz. Bu template cli arayıcılığıyla ses(upload) edebiliriz. Göndereceğimiz mailin json template oluşturulup gerekli bilgilerini girerek mail gönderebiliriz. ve bunu cli kullanarak yapabiliriz. From,to gibi gerekli bilgiler girmemiz şartıyla.

{% embed url="<https://www.youtube.com/watch?ab_channel=KGPTalkie&v=qPSj9VPfd5c>" %}


# Kinesis

Veri üretici ve veri tüketici arasında mesajları yayınlamak için kanal görevi gören akışkan gerçek zamanlı veri toplama ve dağıtma sistemidir.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FtM38Iz8tdMdUgaYAH4I6%2Farchitecture.png?alt=media\&token=e3fc3360-d1f8-4667-83bd-6ef650c8171e)

Kinesis sistem ve ya web günlüklerini sosyal ağ verileri finansal ticaret bilgileri, cografi veriler, mobil uygulama verileri ve ya bağlı IOT cihazlarından telemetri verileri gibi verileri gerçek zamanlı olarak toplayarak belirli bir süre üzerinde barındırmaya ve daha sonra bunu veri tüketicilere ulaştırmaya yarıyor.

#### Kinesis Özellikleri,

#### Amazon Kinesis Data Streams,

* Veriler shard adı verilen kümelerde tutuluyor.
* Shard'da tutulan benzersiz verilere record (kayıt) denir.
* Her kayıt sequence number yani shard 'da giriş sırasını belirleyen değer, partition key, yani basitçe hangi shard 'da bulunduğunu belirten değer ve data blob yani gerçek içerikleri oluşturur.
* Record maksimum 1mb boyutunda olabilir.
* 1 shard 1 saniye de 1mb 'a ve ya 1000 put işlemine kadar depolama ve saniyede 2mb hızında okunma kapasitesine sahiptir.
* Shard'lar otomatik olarak büyüyüp küçülmez ve kaç shard kullanılacağını başlangıçta bizim belirtmemiz gerekir.&#x20;
* Sonuçları da veri depolama ambarımıza yazar.

Belirli bir anahtar kullanarak kayıtların yönlendirilmesini, kayıtların sıralanmasını, birden fazla istemcinin iletileri aynı anda okumasını, geçmiş 7 güne kadar mesajların tekrarlanmasını sağlıyor. Kinesis de mesajlar birden fazla tüketici (istemci) tarafından okunabilir.

#### Kinesis Firehose;

* Akışlı verileri düzenleyip, s3 yada redshift gibi hedeflere kaydeder.
* Otomatik genişleyebilir.

#### *Kinesis* *Analytics*

* *Firehose ve streams servislerine bundle edilmiştir.*
* *Akışlı veriler üstünde standart SQL sorguları çalıştırma imkanı verir.*

#### *Kinesis Video Streams*

* *Video ve ses akışlarını AWS bulutuna aktararak, daha sonra makine öğrenimi uygulamaları gibi uygulamalar tarafından işlenmesine imkan tanır.*


# AWSConfig

AWS config aws kaynaklarımızın, konfigürasyonlarını denetlememizi ve değerlendirmemizi sağlayan bir hizmettir. Config, AWS kaynak konfigürasyonlarımızı sürekli olarak izler ve kaydeder. İstenen konfigürasyonlara karşı izlenen konfigürasyonların değerlendirilmesini otomatikleştirmemizi sağlar.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FSdfnIfmQkBc6A8XTiVNC%2Fproduct-page-diagram-Config_how-it-works.bd28728a9066c55d7ee69c0a655109001462e25b.png?alt=media\&token=6516d4c4-bb4a-4463-badf-26550d70ec32)

&#x20;

Bütünlük ve uyumluluk denetimi sağlar. Örneğin, dün çalışan sunucu/servis bugün çalışmıyorsa, config servisine giderek dünden-bugüne bu kaynakta hangi değişiklikler olmuş görebiliriz. Sec-Group değişikliği dahi not edilir ve kaydedilir. Misal yaratılmış tüm EBS volume'lerini bir sanal sunucuya takılı olması kuralı yaratır ve config servisinin sanal sunucuya mount olmayan ve boşta duran bir EBS volume var ise, uyumsuzluk vermesini sağlayabiliriz.

#### Uygulama,

* Bir sunucu yaratalım, ardından elastic IP rezerve edelim.  Sonrasında bu IP adresini sunucuya atayalım.
* Config servisine geçelim.
* Resource type to record : Neleri izlemek istiyoruz?
* Amazon S3 Bucket : İzlemeleri nereye depolamak istiyoruz?
* Amazon SNS Topic : Değişiklikler bildirim olarak iletilsin mi?
* AWS Config Role : Config servsinin kaynaklara erişmesi için, role yaratılabilir ve ya mevcut role kullanılabilir.
* Next
* Config Rules : Burada kontrol edilmesini istediğimiz servisleri seçiyoruz.
  * örn, eip elastic ıp - eip attach
  * Böylelikle hesabımızda bulunan Elastic IP adresleri bir sunucu da bağlı değilse uyarı oluşturulacak.
* Next.

Sunucu da test için bir kaç değişiklik yapıp, volume ekleme vb.. Ardından tüm bu değişiklikleri ve elastic IP adresi mount değilse 1 saat içerisinde AWS config dashboard da görebileceğiz.


# OpsWork

Manuel işlemleri otomatize eder. Alt yapı yönetimini kod haline getirir (infra as code) Sistemi belirtilen durumda tutar.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FyOcPnlCFUfKK5GyYrgjS%2FOpsWorks-Stacks.png?alt=media\&token=70e30489-83a7-477e-9028-0f57905667b4)

Conf management araçları sunucu yapılandırması/servis yapılandırma'yı tek bir merkezden, yapılmasına imkan tanır.  Sonrasında sunucuların bizim belirlediğimiz ayarlarla çalışmasını garanti altına alır. Öncelikle ortamda tüm ayarları yönettiğimiz, conf management yönetim sunucusu yer almaktadır. Daha sonra bu sunucunun (Agent) dediğimiz, yazılımını yönetmek istediğimiz sunuculara kuruyoruz.  Ve sunucuları ana konfigürasyon sunucusuyla konuşur hale getiriyoruz. Sonrasında ana sunucuda çeşitli template'ler (Reçete)ler oluşturuyoruz. Örneğin Frontend diye bir reçete yazıyor ve bu reçete içerisinde frontend sunucularımız da olmasını istediğimiz servisleri vb kod halinde belirtiyoruz. Örneğin Nginx kur, xyz ayarlarını yap vb. Ve reçeteyi hazırlayıp sunuculara gönderiyoruz.&#x20;

İstenilmeyen (Reçete de olmayan) servis manuel olarak başlatılırsa, ana sunucu tekrardan bu durumu reçeteye göre ayarlar.&#x20;

{% hint style="info" %}
Chef ve puppet günümüzde bu işi yapan servislerdir.
{% endhint %}

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FZEngbeEgQhBEZ6w0ejyW%2FOpsWorks-Blue-Green-Deployment.png?alt=media\&token=eab1eeb8-c812-4dfc-9390-f94ab8fee354)

Opswork, chef ve puppet'ın yönetilen örneklerini sağlayan bir yönetim hizmetidir. Chef ve puppet sunucuların konfigürasyonlarını ayarlamamıza izin veren araçlardır. (kod kullanarak servis yönetimi yapmamızı sağlar) Opswork Amazon EC2 ve kendi veri merkezimizde barınan sunucular için, nasıl yapılandırıldığını, dağıtıldığını, yönetildiğini otomatikleştirmek için chef ve puppet 'i kullanmamızı sağlar. Opswork gücünü chef 'den alarak, tamamen yönetilen AWS servisidir. Yük dengeleme,db gibi farklı katmanları içeren bir yığın olarak modelleyebiliriz. Her katmanda EC2 sunucuları hazırlayabilir otomatik olarak ölçeklendirmeyi etkinleştirebiliriz. Örnekleri chefsolo kullanarak chef tarifleriyle yapılandırabiliriz.


# Lambda - Api Gateway

Lambda, Sunucu yönetmek zahmetine girmeden, kod çalıştırmanıza izin verir. Yalnızca tükettiğiniz hesaplama zamanı için ödeme yapılır. Kod çalışmadığında ücret alınmaz.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FU6RmCe846ouNNlHjWA1H%2F0_hxjzck3fCwXMy83L.png?alt=media\&token=391acf0f-d5cd-41b9-90bb-612e0fddb2b7)

FAAS (serverless) : Developer 'lar için yarattıkları kod bloğunu, bloklarını atarak çeşitli yöntemlerle bu kodları tetikleleterek, kodun çalışması sağlanarak, sonucun alındığı bir konsept. Geliştiriciler için bir çok sorunu ortadan kaldırır. Ortamda bir sunucu olmadığından, sunucu yönetim problemi kalmıyor. Ayrıca kod çalışıp sonuç alındığında faturalandırma yapılıyor. Kullandığımız kadar ödeme yapıyoruz. Servis arka planda, ihtiyaca göre büyüyebiliyor. Yani EC2 'da autoscaling ile sağladığımız durumu burada otomatik olarak sağlıyoruz.

Kullanıcılar bir sunucu yönetmeden, uygulama geliştirmelerine ve işlevleri dağıtmalarına olanak sağlayan ve işlem verimliliğini arttıran bir bulut bilişim modelidir.  FAAS(Function as a Service) temelindeki konsept serverless(sunucusuz) olarak bilinen konsepttir. Bu konsept tüm bilişim alt yapısı bulut bilişim sağlayıcısı tarafından yönetilir ve bizler sadece kod ile ilgileniriz. Kodun çalışması ve sonucun gönderilmesi için gereken tüm alt yapı servis sağlayıcının görevidir.

Lambda, ile hemen hemen her türlü uygulama ve ya arka uç (backend) hizmeti için kod çalıştırabiliriz. Sadece kodumuzu yükleriz ve gerisini lambda'ya bırakırız. Kodumuzun diğer AWS hizmetlerinden otomatik olarak tetikletmek ve ya doğrudan her hangi bir web ve ya mobil uygulamadan çağırmak için ayarlayabiliriz. Python,Java,C#,NodeJS,Go dillerinde kodları çalıştırarak bize işlem sonucunu çıkaran AWS'nin FAAS servisidir.

Api Gateway, Ortamda birden fazla mikro servis bulunan ortamlarda tüm bu servislere erişimin, servislerin birbiriyle konuşmalarının dış dünyadan diğer uygulamaların bu servise hizmetlerine erişebilecek bir ortam oluşturulmasını sağlar. Tüm bu karışık servislerin giriş noktasıdır. Lambda ile mikro servisler hatta tek bir fonksiyon çalıştıran nano servisler yaratabiliriz. Ve bu servislere bir giriş noktası Auth alt yapısı kurmamız gerekebilir. İşte bize bunu Api GW servisi sağlıyor.&#x20;

Api Gateway, Geliştiricilerin, her hangi bir ölçekte API oluşturmasını,yayınlamasını,sürdürmesini ve izlemesini ve güvenliğini sağlamasını kolaylaştıran tamamen yönetilen servistir. AWS yönetim konusunda bir kaç tıklamayla Amazon Elastic Compute Cloud üzerinde çalışan iş yükleri AWS lambda üzerinde çalışan kod blokları ve ya herhangi bir web uygulması gibi arka uç hizmetlere erişmek için ön kapı olarak işlev gören bir API oluşturulabilir.

#### Lambda Fonksiyonu oluşturmak,

* Create Lambda function
* Autor from scratch : Sıfırdan kodu kendimiz mi yazıp mı kullanacağız?
* Use a blueprint : Blueprint kullanabiliriz. Blueprint aws 'nin hazırladığı, hazır lambda fonksiyonlarıdır.
* Browse serverless app repository : Marketplace olarak düşünebiliriz. İnsanlar yazdıkları kodu buraya yükler. Biz buradan kullanabiliyoruz.
* autor from scratch seçeneği ile devam edebiliriz.
* Function Name: Fonksiyon adı
* Runtime : Kodumuz hangi dil'de yazıldıysa buradan seçmeliyiz.
* Permission : Bu fonksiyonu hangi permission (aws haklarıyla) çalıştırmak istediğimizi soruyor.
* Function code : Bu ekrana kodumuzu yapıştırabiliriz.&#x20;
* Policy Template : Hazır bir template'den  permission seçiyoruz.&#x20;
  * Role Name giriyoruz.
* Create Function

Dilersek bu kodu tetikletebiliriz, örneğin s3'e dosya atıldığında bu kodu çalıştır vb. Dilersek manuel olarak çalıştırabiliriz.

* \=> Test
* \=> Create new test event
* \=> Event Name
* \=> Diğer ayarlar varsayılan kalabilir.
* \=> Save
* \=> Test

Böylelikle oluşturduğumuz kodumuz çalışmış olacak.

\=> Basic Settings, kodumuzun çalışması için gerekli memory miktarını seçebiliriz.

\=> Timeout : Kod çalışırken kaç saniye içerisinde timeout 'a düşsün. Uzun sonuçlar çıkaran, fonksiyonlar için gerekli timeout seçeneğini ayarlayabiliriz.

\=> Execution Role : Daha önceden atadığımız rolleri değiştirebiliyoruz.&#x20;

\=> Network : Bir VPC içerisinden erişilebilir hale getirebiliyoruz.

\=> Debug - Error Handling :  Logları SNS ve ya SQS e gönderebiliriz.&#x20;

\=> Concurrency : Kodun arka arkaya çalışma limitini belirleyebiliriz.

Kodumuzu tetikletmek ve dış dünyadan erişmek için API GW servisine geçiyoruz.

Api GW, rest-api yaratmamzı sağlar. Bu servis sayesinde HTTP protokolü üzerinden çalışan API yaratabiliriz ve bu API yarattığımız, mikro servislere bağlayabiliriz. Ayrıca lambda üzerinde yarattığımız birer mikro servis görevi gördüğünden yaratacağımız API bu fonksiyona bağlanabilir.

API ile her /get isteği gönderildiğinde bunun lambda servisinde az önceki oluşturduğumuz fonksiyonu tetikletecek şekilde ayarlayacağız. Ve sonucu geri döndüreceğiz.

* Choose the Protocol : Hangi tip API yaratacağız?
  * Rest

* Create New API : Yeni API oluşturabilir ve ya örnek bir API kullanabiliriz.
  * New API

* Name : ilkapi

* Endpoint : Regional (Lambda fonksiyonu bu region'da)

* Create API

* Resources => Actions : Fonksiyonumuzu tetikletmek için metot yaratalım.
  * Create Method => Get => Okey

* Bu metot çağrıldığında ne tetiklenecek?
  * Integration Type : Lambda Function

* Lambda Region : Lamdayı oluşturduğumuz region?

* Lambda Function : Fonksiyonumuzun adı?

* Use Default Timeout : Seçili.

* Böylelikle işlemler tamamlandı.

Deploy API => Stage Name : Misal, " Prod " yazıyoruz.  İlk api yaratmış olduk.


# ECS - EKS

## EKS - Elastic Container Services

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FiUzDX1nYn92YvwhGzWUg%2Fproduct-page-diagram_Amazon-ECS%402x.0d872eb6fb782ddc733a27d2bb9db795fed71185.png?alt=media\&token=d4f26f3d-4370-46d6-8c0c-98624805ccea)

ECS container yönetim servisidir. Ancak bu servisi bir sunucuya kurmuyoruz. Yönetim konsoluna gidip, ECS seçeriz. Ardından ECS bize 2 seçenek sunar.

1 - EC2 : Container yönetim servisi olan ECS çalışma esnasında, container'ların çalışacağı container engine yüklü sunucu olduğu sunucuların özellikleri nasıl olmalı? Hangi tip EC2 sunucuları istenilmekte? Tüm bu soruların cevaplarına göre seçimleri yapmalıyız.  AWS gerekli sunucuları oluşturur Daha sonra ECS üzerinden container çalıştırmaya başlarız. Containerlar bizim seçtiğimiz adet ve tipteki EC2 sunucuları üzerinde çalışır.

2 - Fargate : Alt yapıda bulunan sunucuların yönetim işini bizden almaktadır. ECS servisine gidip, Fargate seçeriz, alt yapı olarak Fargate kullanılır. Buna göre ram-cpu ihtiyacımızı belirleriz.  Alt yapı ile işimiz olmaz. Container Engine tamamıyla AWS tarafından yönetilir.

## EKS - Elastic Kubernetes Service

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FmWg5ATul06kAOIfXiYr9%2Fproduct-page-diagram_Amazon-EKS%402x.ddc48a43756bff3baead68406d3cac88b4151a7e.ddc48a43756bff3baead68406d3cac88b4151a7e.png?alt=media\&token=55227b0c-0837-4c51-a74d-55cdd1829684)

Aslında temel olarak ECS'den farklı bir şey değildir. Aynen ECS gibi container yönetimi servisidir. ECS gibi yönetilen bir servistir. Ana farkı ise ECS AWS 'nin kendi container yönetim servisidir. EKS ise Kubernetes ile oluşturulan bir servistir. EKS 'de ECS gibi ECS2 detaylarını sorar ve buna uygun bir cluster oluşturur.

Tüm bunların yanında destekleyici servis olan Elastic Container Registry var. Docker Hub benzeridir. Ama AWS dünyasına özgüdür. Yarattığımız imajları güvenli bir şekilde  saklayabileceğimiz kayıt deposudur. ECS servisi ile tamamen entegre durumdadır.


# KMS

Key Management Service

Encryption : Bir veriyi sadece yetkili kişilerin anlayabileceği deşifre edebileceği şekilde orjinal halinden farklı bir hale getirme işlemine denir.

Decryption : Şifrelenen verinin yetkili kişiler tarafından şifresinin açılması. Deşifre ederken kullandığımız yönteme key diyoruz.&#x20;

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F3dl5cNY5kgIIugv7moF5%2Fdecrypt-with-data-key-pair.png?alt=media\&token=66e818b2-1014-4e34-9284-9c3fa69bd9b2)

Bilgisayar sistemleri encryption işlemlerini 2 farklı şekilde sağlıyorlar.

* Symmetric : Encryption ve Decryption işlemleri için tek anahtar kullanır. Oldukça hızlıdır. Taraflar arasında  key değişimi sırasında key açığa çıkabilir. Göreceli olarak daha güvensiz.
* Asymmetric : Encryption ve Decryption işlemleri için çift anahtar kullanır. Public ve Private key. Symmetric 'e göre daha yavaş. Key exhange işlemleri de güvence altındadır.

AWS çoğu veri barındırma servisinde bize şifreleme imkanını sunuyor.

KMS : Anahtar oluşturmamızı, yönetmemizi ve çok çeşitli AWS hizmetleri ve Uygulamalarımızda şifreleme kullanımı kontrol etmemizi sağlayan servistir. AWS tarafından yaratılan ve var olan kullanılan anahtarları yönetmemizi hem de tamamen kendimizin yaratabileceği mevcut anahtarlarımızı aktarıp, onların saklayıp kullanabileceğimiz bir ortam sunmaktadır.&#x20;

AWS KMS anahtarlarımızı korumak için FIPS-140-2 onaylı donanım güvenlik modülünü kullanıyor. AWS KMS düzenleme ve uyumluluk gereksinimi karşılamak ve yardımcı olmak için tüm anahtar kullanım günlüklerini bize sunmak için AWS CloudTrail ile entegre etmiştir.

#### KMS Paneli,

AWS Managed Key, AWS tarafından yaratılan tamamen AWS tarafından yönetilen anahtarlar.

Customer Managed Keys, Kendimiz anahtarlar yaratabiliriz ve anahtarlarımızı kendimiz yönetebiliriz.

Custom Key Store, Güvenliği bir adım daha ileriye götürmek istiyorsak, CloudHSM cluster kurarak bize dedike bir hardware modül oluşturuluyor. Böylelikle yarattığımız keyleri burada tutabiliyoruz.

#### Örnek bir key yaratma aşaması,

* Create key
* Alias : ilkkey
* Advanced Options : Anahtarın nasıl yaratılacağını sormaktadır.
  * KMS : KMS üzerinde yaratılır.
  * External : Var olan anahtarlarımızı buraya upload edebiliriz.
  * Custom Key Store : HSM cluster 'mız varsa anahtarı oradan yaratılmasını söyleyebiliriz.
* KMS seçiyoruz. Dilersek TAG girebiliriz.
* Key Administrators : Hangi kullanıcılar bu keyleri yönetebilsin?
* This Account : Bu anahtarı kim kullanabilecek?

Json dosyası halinde bizim için anahtar yaratılabilecek.

Misal, EC2 EBS üzerinde bir volume yaratalım. Encryption kısmında oluşturduğumuz keyi seçebiliriz. Böylelikle diskimizi oluşturabildik ve bu diski bir sunucuya attach edebiliriz. Normal bir şekilde kullanabiliriz. Bu diske yazılan veriler şifrelenmiş olarak yazılacaktır. Bu şifrelenmiş disk şifrelediğimiz için normal bir şekilde kullanabiliriz. Birileri bizim verimizi alırsa onlarda (bizde bulunan) anahtar olmadığı için diski okuyamayacak ve yazamayacaktır.


# Directory Service

Popüler AD hizmetleri desteği mevcuttur. Samba (Linux) - Active Directory (Windows)

Alt yapı tamamen AWS tarafından yönetiliyor. AWS 4 farklı hizmet sunuyor.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FtJ5VEd1VouB91KHPFIlD%2Fms_ad_use_cases2.png?alt=media\&token=c6b5bd6d-9c38-4c6e-910c-c72d3f678dc5)

* AWS Microsoft AD : Bu hizmet ile AWS ortamımızda bir Microsoft Active Directory yaratmamıza imkan tanıyor. Standart ve enterprise olarak 2 sürümü vardır.
  * Standart : Orta ölçekli işletmeler. 30k obje.
  * Enterprise : Büyük ölçekli işletmeler. 500k obje.
* Her 2 sürüm çift AD ile gelmektedir. Otomatik yedekleme gibi tüm yönetilen servislere sahip olmaktadır.
* 2 DC yanına dilersek ek ADC ekleyebiliriz. Microsoft AD özelliklerine sahip. Kurulum yaparken çalışmasını istediğimiz VPC'yi seçiyoruz kurulum 2 temel DC farklı AZ üzerinde yaratılıyor. Daha sonra direct connect ve ya VPN kullanarak bu VPC yi kendi şirket ağımıza bağlanarak buradaki sistemlerin oluşturduğumuz dizin hizmeti ile konuşmasını sağlayabiliriz.

<table><thead><tr><th width="272">AWS Managed Microsoft AD</th><th width="442.0491092922484">AD Connector</th></tr></thead><tbody><tr><td>Std-Ent sürümleri mevcut.</td><td>AD Proxy hizmeti.</td></tr><tr><td>STD 30 B obje, ENT 500k obje limitli.</td><td>Small ve large 2 seçenek olarak mevcut. Small  500 kullanıcıya, Large 500 kullanıcıya, large  5000 kullanıcıya kadar uygundur.</td></tr><tr><td>Trust oluşturma özellikleri dahil, tüm ad özellikleri mevcut.</td><td>Mevcut on-prem Active Directory kurulumu  VPC içerisinde genişletme imkanı tanıyor.</td></tr><tr><td>Kurulu bulunan region içerisinde 2 ayrı AZ'de birer DC ile geliyor. Ve Ek olarak DC eklenebiliyor.</td><td></td></tr></tbody></table>

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FyVLZwCHcOkzIPJmZAQyR%2FSlide3.png?alt=media\&token=e959b471-2cc5-4172-af42-3989b47c0ad3)

AD Connector : Bulut da her hangi bir bilgiyi ön belleğe almadan mevcut microsoft AD 'mize dizin isteklerini yeniden yönlendirmek için kullanılan proxy'dir.  Yani zaten bir AD hizmetimiz varsa, ve bizim amacımız VPC içerisinde kaynaklara, kaynaklarında bu dizin hizmetine ulaşmasını sağlamak ise boş yere konfigürasyon ile uğraşmak yerine, bir sürü ayarlama ile VPC içerisinde mevcut AD'nin uzantısı olacak bir ek DC kurmak yerine. AWS bize bu hizmeti sunuyor. Bu hizmet sayesinde VPC'mizde bulunan tüm kaynaklar her hangi bir dizin sorgusu yaptığında bunu kendi lokasyonumuzda kurduğumuz//var olan Active Directory'e yönlendirebiliriz.

Simple AD: Yönetilen Linux Samba4 hizmetidir. Small ve Large olarak 2 hizmeti mevcut. Small 2k objeye Large 20k obje desteği sunar. Trust vb. gelişmiş AD özelliklerini desteklemez.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FzQFzeEsjoFrciJeaZFGh%2F1_rUvwuOT0CbaRwDS6A3mdGg.png?alt=media\&token=ed86c19f-be6b-4d74-a2e1-580968e289f1)

Amazon Cognito Your user Pools : AWS de cognito bir kullanıcı dizinidir. Bir kullanıcı havuzuyla kullanıcılarımız web ve ya mobil uygulamamızda Amazon Cognito kullanarak oturum açar. Uygulamalara kullanıcı kaydı ve oturum açma özellikleri eklememize imkan tanır. Kullanıcı havuzdan SAML kimlik sağlayıcıları ile birlikte Facebook,Google,Amazon ile giriş yapma imkanı verir.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FUh3XVf71IRCbItevMdYC%2F04_05.webp?alt=media\&token=7e92266d-7f73-43d8-ab20-ddc1a37ee5ff)

Cognito, Bir uygulama yazdığınızı düşünün. (mobil ve ya web) uygulamayı kullanan kullanıcıların kayıt olmasını istiyoruz. Ve bir form yarattık. isim,soyisim vb bilgileri istiyoruz. Cognito servisi ile bu bilgileri saklayarak daha sonra uygulamamızda kullanabilecek temel bir dizin hizmeti yaratabiliyoruz. Cognito uygularımıza kullanıcı kaydı, oturum açma özellikleri ekleyebiliyor. Kullanıcılar sosyal medya hesapları ile oturum açma zorunlulukları kalmıyor.

AWS Cloud Directory, Diğer dizin hizmetlerinden biraz farklı. Şirket çalışan bilgisini ve organizasyon şeması tutmak için bir dizin yaratmamız gerekiyor.  Yani bizim bir yerde objeler yaratıp aynı zamanda da o yarattığımız  yerde bu objeler arasında ilişkilere ait verileri de saklamamız gerekiyor. Normal de bu işler için veritabanı kullanabiliyoruz fakat AWS sırf bu iş için özelleştirilmiş bir dizin hizmeti sunuyor. Örn, IOT cihazları, o cihazların yer bilgisi ile o cihaza bağlı sensörlerin bir hiyerarşi halinde tutmak istersek bu servis çok işimize yarıyor.  Bir geliştirici olarak uygulamamız içerisinden erişmek için hiyerarşik veri tutabileceğimiz bir dizin hizmetidir.


# Snowball

Fiziksel bir veri depolama aleti, alet içerisinde bir mini pc ve birden çok disk bulunmaktadır. Aynı zamanda 256 bit şifreleme desteği sunmaktadır. Biz AWS 'ye veri merkezimizden veri göndermek istediğimizde aws bize bu fiziksel aleti göndermektedir. Bu aleti veri merkezimize bağlıyor ve AWS 'ye göndermek istediğimiz verileri bu diske yüklüyoruz. Daha sonra bu veri şifrelenmektedir. Ve cihaza verileri yükledikten sonra,  Cihazı tekrar AWS 'ye gönderiyoruz. AWS bu veriyi sistemlerine aktarıyor. Şifreleme için kullandığımız anahtar ile verimize erişebiliyoruz.


# Storage Gateway

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FgctSOAupqDxz6cyghA7Y%2Fproduct-page-diagram_AWS-Storage-Gateway_HIW%402x.6df96d96cdbaa61ed3ce935262431aabcfb9e52d.png?alt=media\&token=4ae1fd8d-79ba-4cc7-973d-604086bacb8a)

* Kurum içi uygulamaları AWS bulut depolama alanını sorunsuz bir şekilde kullanmasını sağlayan bir karma depolama hizmetidir.
* Servisi yedekleme, arşivleme, felaket kurtarma, bulut veri işleme, depolama katmanları ve geçiş için kullanabilirsiniz.
* Servis, bant genişliği yönetimi otomatik ağ esnekliği ve etkin veri aktarımı ile birlikte, en etkin verilerinize düşük gecikme süresi içerisinde kurum içi erişim için yüksek öneme sahip veri aktarım mekanizması içerir.
* Uygulamalarımız, NFS, SMB, ISCSI, gibi standart depolama protokolü kullanarak bir sanal sunucu ve ya donanım ağ geçidi arayıcılığıyla servise bağlanır.
* Ağ geçidi S3,Glacier,EBS gibi AWS depolama hizmetlerine bağlanır. AWS 'de dosyalar birimler ve sanal bantlar için depolama sağlar.
* Servis bant genişliği yönetimi otomatik ağ esnekliği ve etkin veri aktarımı ile birlikte kurum içi yüksek erişim hızı sağlar.
* Verilerimize buluta sürekli aktarmamızı sağlar. Bu sayede bir felaket durumunda, mevcut ortamımızın bir benzerini buluta kurmamızı ya da buluttan mevcut ortamımıza yedeklerimizi dönmemizi sağlayan bir servistir.
* Storage GW içinde Storage-Gateway yazılımın kurulu olduğu bir sanal sunucu imajıdır.
* Bunu alıp ister, vmware esxi, Hyper V, AWS EC2 sanal sunucu olarak kurabiliyoruz.&#x20;

Storage Gateway altında 3 temel hizmet mevcuttur.

* File Gateway
* Volume Gateway
* Tape Gateway

#### File Gateway

Temel NFS hizmetidir. Veri merkezinde bulunan sunucu ve istemciler SMB ya da NFS vb protokolünü kullanarak burada oluşturduğumuz  paylaşılan klasörleri mount edebiliyoruz. Tüm veriler S3 servisinde tutuluyor. File Gateway hizmeti sık kullanılan dosyaları ön bellekleyerek hızlı erişimi sağlıyor.

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2Fv46WeREHDT1YZQiO1UFH%2Fa0xrj6oodv66qjoucxwa.png?alt=media\&token=0e2d53dc-37a2-4e46-84d1-5c50f5beff7c)


# Volume Gateway

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FdYggNHdi95X9WDpPn9BE%2Fvolume-gateway-diagram.eedd58ab3fb8a5dcae088622b5c1595dac21a04b.png?alt=media\&token=e99275d4-044a-4216-9cb4-3acce1e50cab)

#### Stored

* Volume GW on-prem sunucularımıza ISCSI olarak bağlayabileceğimiz blok base disk birimleri yaratmamızı sağlar.&#x20;
* Yaratılan stored volume'ler lokal veri merkezinde depolanır.&#x20;
* Her volume asenkron olarak AWS 'e EBS snapshot 'lar olarak gönderilir.
* Volume GW yarattığımız volume 'un belirlediğimiz aralıklarla bir snapshot 'ını yaratır ve sıkıştırma uygulayarak küçülttükten sonra bunu S3 e gönderir. Daha sonra periyodik olarak olarak incremental olarak büyümeye devam eder.&#x20;
* Storage GW başına toplamda 32 storaged volume yaratma imkanımız olur. Her volume 16TB kadar büyüklükte olabilir. Toplamda 522TB boyutunda Storaged volumes yaratabiliriz.

#### Cached

* Yaratılan cached volumeler AWS 'de depolanır.
* Volumeler lokal veri merkezinde hızlı erişim için önbelleklenir.
* Toplam da 32 Cache volume yaratabilme imkanımız vardır. Ve volume 32TB kadar büyüklükte olabilir. Topam 1 petabyte boyutunda cached volume gw yaratabiliriz.


# Tape Gateway

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2F7CF8V5W4BrcnHyAYV17K%2FReplace_Tape_Backup_Diagram.8e2372fac68648f79dd0684026244d50fbd1a10d.png?alt=media\&token=c991d1ba-85d1-44cc-b766-899b513854c0)

* ISCSI VTI protokolü ile bağlanabileceğimiz sanal tape kütüphanesi sunar. ve Fiziksel olarak lTO kartuşlar yerine bulut da oluşturacağınız sanal kartuşlara yedekleme yapmaya imkan tanır.
* Sanal kartuşlar S3 de tutulur.
* Glacier desteği sayesinde daha uzun süre saklamamız gereken sanal kartuşları uygun maliyet de saklayabiliriz.
* Storage GW başına 1 PB kadar sıkıştırılmış yedekleme dosyası saklayabiliriz.


# Organizations

![](https://4292351715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-MbaWe7--NyAIbXm2ywy%2Fuploads%2FCZ8GUncioabCZJaCw9Ih%2FAWS-Firewall-Manager-Deploy-Protection-Figure-1r.png?alt=media\&token=c858d30d-f84c-4402-8d71-3486e04e46e0)

Birden fazla AWS hesabını yönetmek için, politikalar oluşturmayı kolaylaştıran bir servistir. Hesap grupları oluşturmak için kullanılır. Gruplara policy ekleyebiliriz. Hesap yaratma ve silme işlemlerini otomatikleştirir. Servis control policies dediğimiz policy 'ler yaratarak AWS hesapları üzerinde yapılabilecek işlemlerin kısıtlanabilmesine imkan tanır.  OU 'lar (GRUPLAR) tanımlayarak benzer yetki seviyesindeki hesaplar bir araya toplanır. Consolidated biling özelliği devreye alma imkanı tanır. Tüm hesaplara tek fatura özelliği, EC2 gibi bazı servislerde toplu indirim sağlar.

#### Uygulama,

* Create Organizations
* Organizations eklendi.
* Diğer AWS hesaplarımıza invite gönderebiliriz.&#x20;
* Organize Account : Gruplar (OU) yaratabilir, hesapları bu gruplara ekleyebiliriz.
* Policies : Gruplara policy oluşturup, atayabiliriz. Root dizinine gelip services control policies devreye alıyoruz. İlgili ou ya gelip, yarattığımız policy sağ ekrandan attach ediyoruz. Böylelikle policy atadığımız gruplara bağlı olan kullanıcılar policy 'de atadığımız kurallara göre servislere erişebilir.  Condition sayesinde policy'leri saat bazında vb. bir çok seçeneklerle özelleştirebiliriz.


# Backup-Transfer-CloudShell

### AWS Backup

* Desteklenen tüm aws servislerinin backuplarını merkezi olarak yönetmemizi sağlıyor.
* Assing Resources ile yedeklemek istediğimiz servisleri seçebiliriz.

### AWS Transfer

* SFTP,FTP,FTPS yönetebilir servis hizmeti sağlıyor. Bu servisleri kurup, kullanabiliriz.
* Authentication kısımlarını kendimiz oluşturabilir ya da API GW ile bu erişimi sağlayabiliriz.
* Dış erişimi kendimiz ayarlayabiliyoruz.
* Hostname üzerinden erişmek istersek bunu özel olarak tanımlayabiliriz. ftp.example.com gibi.
* Cloudwatch ile loglama yapabiliriz.

### CloudShell

* Browser üzerinden kullanabileceğimiz shell özelliği, AWS Cli kullanmıyorsak tarayıcı üzerinden cli aracını kullanabiliriz.
* Tüm cli tool'ları mevcut.
* Çok yetenekli bir shell ekranı sunmaktadır.




---

[Next Page](https://note.onurbolatoglu.com/llms-full.txt/1)

