Forem: Açıklab

Node Exporter ve Prometheus Kurulum Rehberi

Enes Baytekin — Fri, 13 Mar 2026 06:02:27 +0000

Node exporter bir makinedeki bazı metrikleri (cpu, ram, disk vb.) belli bir port üzerinden (default 9100) dışarıya sunar. Daha sonra burada sunulan metrikleri bu porta istek atarak herhangi bir yazılım aracılığıyla izlemek mümkündür. Bu örnekte prometheus ile izlenecektir.

Node exporter çok hafif bir uygulama olduğu için sistemi yormaz ve bu makine üzerinde izleme yapmak isteyen araçlar kendi ajanlarını kurmak zorunda kalmaz, hepsi aynı formattan okuyabilirler.

Genel Mimari

┌─────────────────┐          ┌─────────────────┐
│   Prometheus    │ ───────► │  Node Exporter  │
│   (Ana Sunucu)  │  scrape  │  (Hedef Makine) │
│   Port: 9090    │          │   Port: 9100    │
└─────────────────┘          └─────────────────┘

Hedef Makineye Node Exporter Kurulumu

Adım 1: Node Exporter İndir ve Kur

# Kullanıcı oluştur
sudo useradd --no-create-home --shell /bin/false node_exporter

# Son sürümü indir (sürümü kontrol edin: https://github.com/prometheus/node_exporter/releases)
cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz

# Çıkart ve taşı
tar -zxvf node_exporter-*.tar.gz
sudo cp node_exporter-*/node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Adım 2: Systemd Servisi Oluştur

sudo tee /etc/systemd/system/node_exporter.service > /dev/null <<EOF
[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target
EOF

Adım 3: Servisi Başlat

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter
sudo systemctl status node_exporter

Adım 4: Firewall Ayarı (Gerekirse)

sudo firewall-cmd --permanent --add-port=9100/tcp
sudo firewall-cmd --reload

# ya da

sudo ufw allow 9100/tcp

Doğrulama

curl http://localhost:9100/metrics

Prometheus Kurulumu

Adım 1: Prometheus İndir ve Kur

# Kullanıcı ve dizinler oluştur
sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus /var/lib/prometheus

# İndir
cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz

# Çıkart ve kopyala
tar -zxvf prometheus-*.tar.gz
cd prometheus-*/
sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo chown -R prometheus:prometheus /etc/prometheus

Adım 2: Prometheus Yapılandırması

sudo tee /etc/prometheus/prometheus.yml > /dev/null <<EOF
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  # Prometheus kendisini izler
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  # Hedef makineler (Node Exporter)
  - job_name: 'node-exporter'
    static_configs:
      - targets:
        - '192.168.1.10:9100'   # Hedef makine 1
        - '192.168.1.11:9100'   # Hedef makine 2
        - '192.168.1.12:9100'   # Hedef makine 3
        labels:
          env: 'production'
EOF

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml

Adım 3: Systemd Servisi

sudo tee /etc/systemd/system/prometheus.service > /dev/null <<EOF
[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
    --config.file=/etc/prometheus/prometheus.yml \
    --storage.tsdb.path=/var/lib/prometheus/ \
    --web.console.templates=/etc/prometheus/consoles \
    --web.console.libraries=/etc/prometheus/console_libraries \
    --web.enable-lifecycle

[Install]
WantedBy=multi-user.target
EOF

Adım 4: Başlat

sudo systemctl daemon-reload
sudo systemctl enable prometheus
sudo systemctl start prometheus
sudo systemctl status prometheus

Erişim ve Doğrulama

Servis         URL                                 Açıklama
-------------------------------------------------------------------
Prometheus UI  http://PROMETHEUS_IP:9090           Ana dashboard
Targets        http://PROMETHEUS_IP:9090/targets   Hedef durumları
Node Exporter  http://HEDEF_IP:9100/metrics        Ham metrikler

Yeni Hedef Ekleme

/etc/prometheus/prometheus.yml dosyasına yeni target ekleyin:

- targets:
  - '192.168.1.10:9100'
  - '192.168.1.11:9100'
  - 'yeni-sunucu.example.com:9100'  # Yeni eklenen

Sonra yapılandırmayı yeniden yükleyin:

# Yöntem 1: API ile (web.enable-lifecycle aktifse)
curl -X POST http://localhost:9090/-/reload

# Yöntem 2: Servisi yeniden başlat
sudo systemctl restart prometheus

Faydalı PromQL Sorguları

CPU kullanımı (%)

100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

RAM kullanımı (%)

(1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100

Disk kullanımı (%)

100 - (node_filesystem_avail_bytes / node_filesystem_size_bytes * 100)

Ağ trafiği (bytes/s)

rate(node_network_receive_bytes_total[5m])

SysMonitor

Enes Baytekin — Mon, 09 Mar 2026 11:46:22 +0000

SysMonitor, netex üzerinde izleme yapabilmek için geliştirilmiş bir araçtır.
Çalışması için iki farklı pakete ihtiyaç var:

sysmonitor
sysmonitor-worker

Bunlar server-client mantığı ile çalışır.
Sysmonitor bir makine'ye kurulur ve netex veritabanı ile haberleşir.
Worker ise asıl izlemeyi yaparak sysmonitor ile haberleşir.
Böylece izlenen veriler netex db'sinde tutulur.

Kurulum

Sysmonitor kullanabilmek için öncelikle bir netex ortamının bulunması gerekir.
Netex, sysmonitor ve sysmonitor-worker paketleri aynı makinede de olabilir veya farklı makinelerde de bulunabilir.

Sysmonitor Kurulumu

Bir makineye sysmonitor paketi kurulur. Environment değişkeni olarak netex db bilgileri verilir.

apt install ./sysmonitor-24-x64.deb

/opt/sysmonitor/.env örneği:

DB_DRIVER=postgres
DB_HOST=127.0.0.1
DB_NAME=netex
DB_PASS=password
DB_PORT=5432
DB_USER=netex

NOT: Netex veritabanı başka bir makinedeyse, sysmon'un buna erişebilmesi için netex db'sinin dışarıdan erişime açılması gerekir. pg_hba.conf ve postgresql.conf dosyaları kontrol edilebilir.

Kurulum sonrasında şu servislerin çalışıyor olması gerekir:

sysmonitor@admin
sysmonitor@client
sysmonitor@admintest

NOT: Sysmon api'sine istek atmak için 6520 portu kullanılır, eğer bu port açılmamışsa sysmonitor@admintest servisi başlatılmalıdır.

Port kontrol için:

ss -tlnp | grep 6520

Servisi başlatmak için:

systemctl enable --now sysmonitor@admintest

Sysmonitor Worker Kurulumu

Sensor'ler, worker'lar üzerinde çalıştığı için en az bir tane worker kurulup sysmon'a bağlanması gerekir.
Bir makineye sysmonitor-worker paketi kurulur. Environment değişkeni olarak sysmonitor makinesinin adresi verilir.

apt install ./sysmonitor-worker-setup-x64.deb

Kurulum sırasında server adresi istendiğinde https://<sysmonitor-ip>:6521 şeklinde girilir.
Daha sonradan .env dosyası düzenlenerek de değiştirilebilir.

/opt/sysmonitor-worker/.env örneği:

SERVER_URL=https://127.0.0.1:6521
FETCH_INTERVAL=3600

Nasıl çalışır?

Öncelikle bir template oluşturulur.
Bu template içinde, izlenilmesi istenen metrikler belirtilir.
Bir template içinde aynı türde birden fazla metrik izlenebilir.

Bu template'ı kullanan bir sensor oluşturulur.
Aynı template birden fazla sensor ile tekrar tekrar kullanılabilir.
Her sensor aynı zamanda bir varlığa bağlıdır ve bu varlığın o template'ta belirtilen metriklerini izler.

Sensor'ler worker'lar üzerinde çalışır.
İzlenen metrik değerleri sysmon'a gönderilir ve sysmon netex db'sine kaydeder.

Daha sonra bu metrikler db'den okunarak izlenebilir.

Birden fazla worker kurulabilir.
Her bir sensor için hangi worker üzerinde çalışacağı belirtilir.

Yani özetle;

Metrik, izlenecek değeri belirtir.
Template, hangi metriklerin izleneceğini belirten kuraldır.
Sensor, asıl izlemeyi yapandır.
Sysmonitor Worker, izlemenin nerede yapılacağıdır.
Sysmonitor, sensor ve netex db arasındaki bağlantıyı sağlayan backend server'dır.

                                        .---------.
.-----------.        .---------.        |         |
| Template1 |--------| Sensor1 |--------| Varlık1 |
|           |        '---------'        |         |
| -metrik1  |        .---------.        '---------'
| -metrik2  |--------| Sensor2 |----.
'-----------'        '---------'    |   .---------.
                                    '---|         |
.-----------.        .---------.        | Varlık2 |
| Template2 |--------| Sensor3 |--------|         |
|           |        '---------'        '---------'
| -metrik3  |
'-----------'

Bu örnekte;

Varlık1'in metrik1 ve metrik2 değerleri
Varlık2'nin metrik1, metrik2 ve metrik3 değerleri

izlenir.

Proxmox'ta io-error

Enes Baytekin — Mon, 29 Dec 2025 08:35:23 +0000

Eğer proxmoxta bu şekilde bir hata alıyor ve makinenizle etkileşemiyorsanız bunun sebebi büyük ihtimalle bu sanal makinenin diskinin proxmox'ta kullandığı storage alanının dolmuş olmasıdır. Bu yüzden sanal makineniz daha fazla okuma yazma işlemi yapamamaktadır.

Disk alanını kontrol etmek

Öncelikle, makinenizin Hardware sekmesindeki Hard Disk kısmından, diskin hangi storage üzerinde olduğunu kontrol edin. Örneğimizde local-lvm adlı alanı kullanıyor.

Daha sonra bu storage'ın Summary sekmesinden doluluğunu kontrol edin.

Eğer burdaki Usage kısmı 100% olarak görünüyorsa hata bundan kaynaklıdır. Bunu çözmek için;

ya bu diski kullanan ve artık ihtiyaç duyulmayan makineleri veya diskleri silerek bu storage üzerinde yer açmanız
ya da bu makineyi daha geniş boş alana sahip başka bir storage'a taşımanız

gerekir.

NOT: Eğer makinenizi cloudinit ile oluşturduysanız burda Cloudinit Drive şeklinde bir disk daha görürsünüz. Bu da aynı storage'da bulunur ve bunu taşıyamazsınız. Ancak zaten boyutu çok küçük olduğu için taşımamış olmanız çok da bir şeyi etkilemez. Asıl sıkıntı çıkaran kısım makinenin ana diskidir.

Makineyi farklı bir storage alanına taşımak

NOT: Her şeyden önce makinenizin kapalı olduğundan emin olun.

Makinenin Hardware kısmından ilgili diski seçtikten sonra yukarıdaki Disk Action kısmından Move Storage seçeneğini seçin.

Açılan pencerede Target Storage kısmından taşımak istediğiniz hedef storage'ı seçin ve taşıma işlemini başlatın.

Taşıma işlemi bittikten sonra artık Hard Disk kısmında yeni storage alanının ismini göreceksiniz.

Şu an aslında makinenizi başlatarak kullanmaya devam edebilirsiniz. Bunda hiçbir engel yok.

Ancak bu taşıma işlemi makinenin diskini doğrudan taşımak yerine yeni storage üzerinde bir kopyasını oluşturup ona bağlıyor. Yani eski storage alanında, kullanılmayan bir kopya o diski işgal etmeye devam ediyor.

Bu kopya Hardware kısmında en altta Unused Disk olarak görünür. Bu kopyayı da silerek eski storage alanında da yer açmak isterseniz önce, eğer varsa makinenize ait snapshotları silmeniz lazım. Çünkü snapshotlar bu eski diski işaret etmeye devam ediyorlar ve ona bağımlılar.

Makinenize ait bir snapshot bulunmuyorsa bu Unused Disk'i seçerek yukardan Remove seçeneği ile silebilirsiniz.

Eğer dolu storage üzerinde biraz yer açtıysanız o storage'daki bu hatayı veren diğer makineleri yeniden başlatmanız onlar için yeterlidir.

Liman MYS Eklentisi ile Elasticsearch API'sine Bağlanma Rehberi

İsa Sarıoğlan — Thu, 04 Dec 2025 10:51:31 +0000

Bu yazı, Liman MYS eklenti şablonunu kullanarak, Basic Authentication (Kullanıcı Adı/Şifre) ile korunan bir Elasticsearch API'sine bağlanmayı ve veri çekmeyi adım adım anlatır.

Bu rehber, zaten çalışan bir Liman MYS geliştirme ortamınız olduğunu varsayar.

Eğer henüz sunucunuza SSH ile bağlanmadıysanız, liman kullanıcısı için yetkilendirme yapmadıysanız, VS Code Remote - SSH eklentisini kurmadıysanız veya Node.js/pnpm kurulumunu tamamlamadıysanız, lütfen öncelikle aşağıdaki rehberi okuyun:

➡️ Referans: Liman MYS Eklentisi Geliştirme Ortamı Sorun Rehberi

Bu rehberdeki adımları tamamladıktan sonra buradan devam edebilirsiniz.

Adım 1: Eklenti Ayarlarını Yapılandırma (db.json)

Amacımız Eklentimizin, bağlanacağı API'nin adresini, kullanıcı adını ve şifresini Liman arayüzünden güvenli bir şekilde almasını sağlamak.

db.json dosyası, Liman'ın "Eklenti Ayarları" menüsüne hangi ayar alanlarını ekleyeceğimizi tanımlar.

Eklentinizin ana dizininde bulunan db.json dosyasını açın.
database isimli JSON dizisini bulun.
Bu dizinin içine, API URL'si, kullanıcı adı ve şifre için aşağıdaki üç JSON objesini ekleyin.

{
  "name": "elasti",
  "publisher": "...",
  "version": "...",
  "database": [
    {
      "variable": "api_url",
      "type": "text",
      "name": "API URL (ex. https://10.67.67.202:30936)",
      "required": true,
      "global": true,
      "writable": false
    },
    {
      "variable": "Username",
      "type": "text",
      "name": "Elasticsearch Username",
      "required": true,
      "global": true,
      "writable": false
    },
    {
      "variable": "Password",
      "type": "password",
      "name": "Elasticsearch Password",
      "required": true,
      "global": true,
      "writable": false
    }
  ],
  "language": "php",
  "vite": true,
  "...": "..."
}

Detaylı Açıklama:

"variable": "api_url": Bu, PHP kodumuzun içinden extensionDb('api_url') fonksiyonunu kullanarak bu değere erişmesini sağlayan anahtar isimdir.
"type": "password": Bu ayar, Liman arayüzündeki bu metin kutusuna girilen değerin **** şeklinde maskelenmesini sağlar. Güvenlik için kritik bir adımdır.
"global": true: Ayarın eklenti bazında global olmasını sağlar.

Önemli: Bu değişikliği yaptıktan sonra eklentinizi Liman arayüzünden Yeniden Yükle yapın ve Eklenti Ayarları'na giderek API URL,Elasticsearch Username ve Elasticsearch Password olmak üzere aşşağıdaki görselde bulunan üç alanı da doldurun

Adım 2: helpers.php Dosyasını Güncelleme (Yetkilendirme)

Bu adımda amacımız PHP backend'imizin, Adım 1'de kaydettiğimiz ayarları okuyup Elasticsearch'e Basic Authentication başlığını (header) göndermesini sağlamak.

helpers.php dosyası, backend kodumuzun her yerinden çağırabileceğimiz yardımcı fonksiyonları barındırır. getDefaults() fonksiyonu, eklentimizden dışarı giden her API isteği için varsayılan ayarları belirler.

/views klasörünün (veya ana dizinin) yanındaki helpers.php dosyasını açın.
getDefaults() fonksiyonunu bulun.
Bu fonksiyonun tamamını, db.json'dan Username ve Password değişkenlerini okuyacak ve Authorization başlığını oluşturacak şekilde aşağıdaki gibi güncelleyin.

if (!function_exists('getDefaults')) {
    function getDefaults()
    {
        // 1. ADIM: db.json'dan kullanıcı adı ve şifreyi al
        $username = extensionDb('Username');
        $password = extensionDb('Password');

        // 2. ADIM: Basic Auth için kullanıcı adı ve şifreyi "kullanıcı:şifre" formatında
        // base64 algoritmasıyla kodla
        $auth = base64_encode($username . ':' . $password);

        // 3. ADIM: Guzzle (PHP HTTP istemcisi) için ayar dizisini oluştur
        return [
            'headers' => [
                'Content-Type' => 'application/json',

                // Oluşturduğumuz kodu "Authorization" başlığına "Basic " ön ekiyle ekle
                'Authorization' => 'Basic ' . $auth,
            ],

            // 4. ADIM: SSL Sertifika Doğrulamasını Kapat
            // Eğer API'niz (https://...) kendinden imzalı (self-signed)
            // bir sertifika kullanıyorsa bu gereklidir. Aksi halde bağlantı hatası alırsınız.
            'verify' => false 
        ];
    }
}

Adım 3: CORS ve HMR Hatalarını Önleme (vite.config.ts)

Amacımız localhost sorununu çözdükten sonra ortaya çıkan CORS policy (farklı port) ve WebSocket (HMR) bağlantı hatalarını en baştan engellemek.

Sorun: Liman arayüzü (örn: https_://10.68.68.249) ile Vite sunucusu (örn: https_://10.68.68.249:5173) farklı portlarda çalıştığı için tarayıcı bunu "güvenliksiz" bir işlem olarak görür ve CORS hatası verir.

frontend/vite.config.ts dosyasını açın.
defineConfig objesine, plugins ve resolve gibi anahtarların yanına, server adında yeni bir yapılandırma bloğu ekleyin.

// CORS VE HMR HATALARINI ÖNLEMEK İÇİN BU BLOĞU EKLEYİN
  // ###############################################################
  server: {
    // 1. Sunucunun tüm IP'lerden gelen isteklere yanıt vermesini sağlar
    // (Sadece localhost'tan değil)
    host: '0.0.0.0', 

    // 2. CORS HATASININ ÇÖZÜMÜ:
    // Bu ayar, tarayıcıya "Access-Control-Allow-Origin: *" başlığını gönderir
    // ve farklı portlardan (örn: Liman'ın 443 portu) gelen isteklere izin verir.
    cors: true, 

    // 3. HMR (WebSocket) HATASININ ÇÖZÜMÜ:
    // Kodda değişiklik yaptığınızda sayfanın otomatik yenilenmesi (HMR)
    // için Vite bir WebSocket bağlantısı kullanır. Bu ayar,
    // WebSocket'in hangi IP'ye bağlanacağını söyler.
    hmr: {
      host: '10.68.68.249' // Buraya Vite sunucunuzun IP'sini yazın
    }
  }
  // ###############################################################

Adım 4: Geliştirme Sunucusu Sertifika (SSL) Uyarısını Geçme

Amacımız Tarayıcınızın, Vite geliştirme sunucusunun "kendinden imzalı" (self-signed) SSL sertifikasına güvenmesini sağlamak.

Adım 3 ve 4'ü yapsanız bile, pnpm run dev komutunu çalıştırdıktan sonra eklentiyi açtığınızda konsolda net::ERR_TIMED_OUT veya net::ERR_CERT_AUTHORITY_INVALID hatası alabilirsiniz.

Vite sunucusu (https://10.68.68.249:5173) https kullanır ancak resmi olmayan bir sertifikaya sahiptir. Tarayıcınız, sizden onay almadan bu "güvenli olmayan" adresten script (main.ts) yüklemeyi reddeder.

Çözüm: Tarayıcınıza bu adrese güvenmesini manuel olarak öğretmeniz gerekir.

Vite sunucunuzun adresini (örn: https://10.68.68.249:5173) kopyalayın.
Tarayıcınızda yeni bir sekme açın.
Bu adresi yapıştırın ve Enter'a basın.
Karşınıza "Bağlantınız gizli değil" (Your connection is not private) uyarısı çıkacaktır.
"Gelişmiş" (Advanced) butonuna tıklayın.
"10.68.68.249 sitesine ilerle (güvenli değil)" (Proceed to 10.68.68.249 (unsafe)) linkine tıklayın.
Ekrana beyaz bir sayfa veya "Vite" logosu gelirse, işlem başarılıdır. Bu sekmeyi kapatabilirsiniz.

Bu işlemi yaptığınızda, tarayıcınız bu sertifikayı geçici olarak kabul etmiş olur ve Liman arayüzü artık main.ts dosyasını yükleyebilir.

Adım 5: Frontend Veri Katmanını Oluşturma (elastic.ts)

data.ts dosyasını kopyalayıp elastic.ts adında yeni bir dosya oluşturmanızı ve içeriğini aşağıdaki gibi düzenlemenizi istiyorum.

Bu dosyada, data.ts içindeki tüm CRUD (create, update, delete) fonksiyonlarını kaldıracağız. Sadece bizim Elastic API'mizden veri çekecek fetchStats adında tek bir fonksiyon bırakacağız. Bu fonksiyon, RequestController.php dosyanızdaki apiProxy fonksiyonunu tetikleyecek.

Komut parametrelerini URL'den (GET) gönderdiğimiz takdirde RequestController.php'deki apiProxy fonksiyonu, GET isteğiyle gelen URL parametrelerini (örn: ?type=...) hedef API'ye (Elasticsearch) "taşıma" eğilimindedir. Elasticsearch bu type ve endpoint parametrelerini tanımadığı için hata verir.

bu yüzden komut parametrelerini URL'den (GET) göndermek yerine bir POST isteğinin gövdesinde (body) göndereceğiz. RequestController bu verileri gövdeden okuyacak ve Elasticsearch'e "temiz" bir GET isteği atacaktır.

src/stores/data.ts dosyasını kopyalayıp src/stores/elastic.ts adında yeni bir dosya oluşturun.
İçeriğini aşağıdaki gibi (hatayı en baştan önleyecek şekilde) düzenleyin:

import http from "@/utils/http-common"
import { i18n } from "@/utils/i18n"
import { defineStore } from "pinia"

// Store adını useElasticStore olarak değiştiriyoruz
export const useElasticStore = defineStore({
  id: "elastic",
  state: () => ({
    elasticData: {} as any, // Gelen veriyi tutmak için
  }),
  getters: {
    getStats: (state) => state.elasticData,
  },
  actions: {
    // Veri çekme fonksiyonumuz
    async fetchStats() {

      // Parametreleri POST gövdesinde göndermek için hazırlıyoruz
      const payload = {
        // Backend'e "get" isteği yapmasını söylüyoruz
        type: "get",
        // Backend'e hangi uca gitmesini istediğimizi söylüyoruz
        endpoint: "_nodes/stats/fs?pretty=true" 
      }

      // Hata almamak için http.get yerine http.post kullanıyoruz.
      // RequestController bu POST gövdesini okur
      // ve Elastic'e temiz bir GET isteği atar.
      // İlk parametre olan URL'e sadece "?" koymamız, 
      // apiProxy'nin kök dizine gitmesini sağlar.
      return http.post(`?`, payload).then((res) => {
        if (res.status == 200) {
          if (res.data) {
            this.elasticData = res.data
            console.log("Elastic verisi başarıyla alındı:", res.data)
          }
        } else {
          window.$notification.error({
            duration: 5000,
            title: i18n.t("common.error"),
            content: "Elastic verisi alınırken bir hata oluştu.",
          })
        }
      })
    },
  },
})

Adım 6: RequestController.php Debug (Hata Ayıklama)

Lütfen RequestController.php dosyanızı açın ve apiProxy fonksiyonunu bulun.

Bu fonksiyonun içine, validate([...]); satırından hemen sonra, aşağıdaki dd() satırlarını ekleyin. Bu sayede frontend'den gelen isteği yakalayıp, API'ye gitmeden önce tam olarak hangi URL'i ve hangi ayarları kullandığımızı göreceğiz.

// --- DEBUG BAŞLANGIÇ ---
        // Bu iki satırı ekleyin:

        // 1. Doğru URL'i oluşturup oluşturmadığımızı kontrol edelim
        dd(extensionDb('api_url') . '/' . request("endpoint"));

        // 2. helpers.php'den doğru ayarların (Auth Header) gelip gelmediğini kontrol edelim
        // (Eğer ilk dd çalışırsa, tarayıcıda sonucu gördükten sonra bu satırı açıp ilkini silebilirsiniz)
        // dd(getDefaults()); 

        // --- DEBUG BİTİŞ ---

Adım 7: Home.vue Dosyasını Düzenleme ve Debug'ı Tetikleme

Bu adımda, Home.vue dosyanızı, oluşturduğumuz elastic.ts store'unu kullanacak şekilde düzenleyeceğiz.

Yeni useElasticStore'u import edeceğiz.
onMounted (sayfa yüklendiğinde) store.fetchStats() fonksiyonunu çağıracağız.
Gelen veriyi basit bir <pre> etiketi içinde ekrana basacağız.

Lütfen src/views/Home.vue dosyanızın içeriğini tamamen aşağıdaki kodla değiştirin:

<script lang="ts" setup>
import { onMounted } from "vue"
// 1. Oluşturduğumuz elastic store'u import et
import { useElasticStore } from "@/stores/elastic"

// 2. Store'u kur
const store = useElasticStore()

// 3. Sayfa yüklendiğinde fetchStats fonksiyonunu çalıştır
onMounted(() => {
  store.fetchStats()
})
</script>

<template>
  <div>
    <h2>Elasticsearch FS İstatistikleri</h2>
    <pre>{{ store.elasticData }}</pre>
  </div>
</template>

<style scoped>
pre {
  background-color: #f4f4f4;
  border: 1px solid #ddd;
  padding: 10px;
  white-space: pre-wrap; /* Uzun satırların kaydırmasını sağlar */
  word-wrap: break-word;
}
</style>

Şimdi Test Edelim:

Bu değişikliği kaydedin.
Projenizin derlendiğinden emin olun (genellikle pnpm run dev veya pnpm run serve).
Tarayıcınızı açın ve Liman arayüzünden eklentinize gidin.
Tarayıcınızın Geliştirici Araçları'nı açın (F12) ve "Ağ (Network)" sekmesine tıklayın.
Eklentinizin ana sayfasını (Home.vue) açın veya yenileyin.

Beklenen Sonuç:

Sayfanız büyük ihtimalle yüklenmeyecek (veya "500 Sunucu Hatası" gibi bir hata gösterecek).

Ağ (Network) sekmesinde, apiProxy?type=get&endpoint=... ile başlayan kırmızı bir istek görmelisiniz. Bu isteğe tıklayın ve "Önizleme (Preview)" veya "Yanıt (Response)" sekmesine bakın.

Orada, RequestController.php içine yazdığımız ilk dd() komutunun çıktısını görmeniz gerekiyor. Çıktı, bir string (metin) olarak şunu içermeli:

"https://10.67.67.202:30936/_nodes/stats/fs?pretty=true" (Eğer db.json'a IP'yi 10.67.67.202 olarak girdiyseniz)

ilk debug komutunda istediğimiz sonuçlara ulaştıktan sonra ikinci debug komutunu tetikleyelim.

Lütfen RequestController.php dosyasını açın.
validate([...]); satırından hemen sonra, dd(getDefaults()); satırını aşşağıdaki gibi yorum satırı olmaktan çıkarıp ilk debug komutunu yorum satırına alalım.

// --- DEBUG BAŞLANGIÇ ---
        // Bu iki satırı ekleyin:

        // 1. Doğru URL'i oluşturup oluşturmadığımızı kontrol edelim
        // dd(extensionDb('api_url') . '/' . request("endpoint"));

        // 2. helpers.php'den doğru ayarların (Auth Header) gelip gelmediğini kontrol edelim
        // (Eğer ilk dd çalışırsa, tarayıcıda sonucu gördükten sonra bu satırı açıp ilkini silebilirsiniz)
         dd(getDefaults()); 

        // --- DEBUG BİTİŞ ---

Şimdi Test Edin:

Dosyayı bu şekilde kaydedin.
Tarayıcıda Geliştirici Araçları (F12) açıkken sayfayı yenileyin (F5).
Network sekmesinde yine kırmızı bir apiProxy isteği göreceksiniz.
Bu isteğe tıklayın ve "Önizleme (Preview)" sekmesine bakın.

Beklenen Sonuç: Bu kez, ekranda o URL'i görmemelisiniz. Onun yerine "Önizleme (Preview)" sekmesinde, Authorization başlığını içeren şu JSON objesini görmelisiniz:

Bu çıktıyı gördüğünüzde kimlik doğrulama adımını başarıyla geçtiğimiz anlamına gelecek.
Artık tüm testlerimiz (debug) bitti. Backend'imiz (PHP) isteği göndermeye hazır.

Şimdi son adıma geçiyoruz: Yola koyduğumuz tüm bu "tuzakları" (yani dd() komutlarını) kaldıracağız ve isteğin Elastic API'sine gerçekten gitmesine izin vereceğiz.

Adım 8: Eklentiyi Çalıştırma ve Son Test

Tüm dosyaları doğru şekilde yapılandırdık. Artık eklentiyi çalıştırabiliriz.

Önemli: Geliştirme (Dev) ve Üretim (Build) Modu Farkı

Geliştirme (Dev) Modu:
pnpm run dev ile çalışır. Kodunuzda yaptığınız her değişiklik anında tarayıcıya yansır (vite: true ve HMR sayesinde). Bu mod, eklentiyi aktif olarak geliştirirken kullanılır.
Üretim (Build) Modu:
pnpm run build ile çalışır. Tüm Vue/TS kodunuzu derleyip optimize edilmiş, tek bir statik JavaScript dosyası haline getirir. Eklentiyi bitirip son kullanıcıya sunacağınız zaman bu modu kullanırsınız ve db.json'daki vite: true ayarını vite: false yaparsınız.
Terminalde frontend klasörüne gidin (/liman/extensions/elasti/frontend).
Gerekli paketlerin yüklü olduğundan emin olun:

pnpm install

Vite geliştirme sunucusunu (tüm ayarlarıyla beraber) başlatın:

pnpm run dev --host 0.0.0.0

Liman arayüzüne gidin (tarayıcıdan).
Sol menüden eklentinizi açın.
KRİTİK ADIM: Geliştirme sunucusunu görmek için, eklentinizin normal URL'inin sonuna /development eklemeniz gerekir.

Yanlış Adres: https://.../l/e/elasti (Bu, üretim modunu (build) açar)

Doğru Adres: https://.../l/e/elasti/development (Bu, pnpm run dev sunucusuna bağlanır)

Nihai Sonuç: .../development adresini açtığınızda, ekrandaElasticsearch FS İstat istikleri başlığının altında, API'den gelen (içinde _nodes, cluster_name vb. bulunan) JSON verisinin tamamını hatasız bir şekilde aşşağdaki şekilde arayüzde görmelisiniz.

Liman MYS için Eklenti Geliştirme Ortamı Kurulum Rehberi

İsa Sarıoğlan — Thu, 04 Dec 2025 10:43:34 +0000

Liman MYS, sunucu yönetimini kolaylaştıran güçlü bir platform olmasının yanı sıra, esnek eklenti altyapısıyla da öne çıkar. Bu rehberde, "Liman Extension Template" adını vereceğimiz hazır bir eklenti şablonunu kullanarak, kod değişikliklerimizi anında Liman arayüzünde görebileceğimiz profesyonel bir geliştirme ortamını nasıl kuracağımızı adım adım inceleyeceğiz.

Bölüm 1: Eklenti Şablonunu Liman'a Yükleme

Geliştirme ortamını kurmadan önce, üzerinde çalışacağımız eklentinin Liman tarafından tanınması gerekir. Bu nedenle, hazır eklenti şablonumuzu sisteme yüklüyoruz.

Liman MYS web arayüzünde oturum açın ve sağ üst köşedeki Ayarlar simgesine tıklayın.
Açılan menüden Sistem Ayarları seçeneğine ve ardından sol menüden Eklentiler sekmesine gidin.
Yükle butonuna tıklayarak bilgisayarınızdaki .zip uzantılı eklenti şablonu dosyasını seçin ve yüklemeyi tamamlayın.
Yükleme başarılı olduğunda, eklentiniz listede görünecektir.

Bu adımdan sonra artık eklentimizi arayüzden silip yüklemeyeceğiz. Tüm süreci sunucu tarafında yöneteceğiz.Bu ksımla ılgili detaylı bilgi aşşağıdaki linkten erişebilirsiniz.

Limana Eklenti Yükleme

Bölüm 2: Sunucuya Bağlantı ve Yetkilendirme Hazırlıkları

Bu bölümde, geliştirme yapacağımız sunucuya SSH üzerinden bağlanacak ve VS Code ile sorunsuz bir bağlantı kurmak için gerekli yapılandırmaları yapacağız.

Adım 1: Sunucuya İlk Bağlantı

Öncelikle sunucunuza standart kullanıcınız ile (genellikle ubuntu, centos, debian vb.) bağlanın.

ssh kullanici_adiniz@<SUNUCU_IP_ADRESINIZ>

<SUNUCU_IP_ADRESINIZ>kısmını Liman'ın kurulu olduğu sunucunun IP adresi ile değiştirin.

Bu aşamada sizden sunucu şifreniz istenecektir.

Adım 2: liman Kullanıcısını Geliştirmeye Hazırlama

Liman, sistem üzerinde kendi işlemlerini yönetmek için genellikle liman adında bir kullanıcı oluşturur. Geliştirme yaparken yetki ve sahiplik sorunları yaşamamak adına işlemlerimizi bu kullanıcı üzerinden yürütmek en sağlıklı yöntemdir.

liman Kullanıcısına Şifre Atama:

liman kullanıcısının varsayılan olarak bir şifresi olmayabilir. SSH bağlantısı için bir şifre belirlememiz gerekiyor.

sudo passwd liman

Bu komutu çalıştırdıktan sonra liman kullanıcısı için yeni bir şifre belirlemeniz istenir.Şifre belirledikten sonra terminale aşağıdaki formatta bağlantı komutunu girin:

ssh liman@<SUNUCU_IP_ADRESINIZ>

Bu komut,liman adlı kullanıcıya bağlanmamızı sağlar.

liman Kullanıcısının Kabuğunu (Shell) Değiştirme:

Güvenlik nedeniyle liman kullanıcısının kabuğu interaktif olmayan bir kabuk (/usr/bin/login gibi) olabilir. Etkileşimli bir terminal deneyimi için bu kabuğu bash olarak değiştirmeliyiz.

sudo usermod --shell /bin/bash liman

Bu komut, liman kullanıcısının oturum açtığında standart bir Bash terminali kullanmasını sağlar.

Adım 3: Şifresiz ve Güvenli Bağlantı için SSH Anahtarı Oluşturma

Her seferinde şifre girmek yerine, SSH anahtar tabanlı kimlik doğrulama kullanarak süreci otomatikleştirebiliriz.

SSH Anahtar Çifti Oluşturma (Lokal Makinenizde):

Eğer daha önce oluşturmadıysanız, kendi bilgisayarınızın terminalinde aşağıdaki komutu çalıştırın:

ssh-keygen

"Enter file in which to save the key...": Bu soruya Enter'a basarak varsayılan konumu onaylayın.

"Enter passphrase...": Daha fazla güvenlik için bir parola belirleyebilirsiniz, ancak geliştirme kolaylığı için bu adımı Enter'a basarak boş geçebilirsiniz.

Public Anahtarı Sunucuya Kopyalama:

Oluşturduğunuz public anahtarı (.pub uzantılı olan) Liman sunucusundaki liman kullanıcısının yetkilendirilmiş anahtarlar listesine ekleyeceğiz.

ssh-copy-id liman@<SUNUCU_IP_ADRESINIZ>

Bu komut sizden son bir kez liman kullanıcısının şifresini isteyecektir. Şifreyi girdikten sonra, artık ssh liman@<SUNUCU_IP_ADRESINIZ> komutuyla şifresiz bir şekilde sunucuya bağlanabilirsiniz.

Bölüm 3: Visual Studio Code ile Geliştirme Ortamını Yapılandırma

Artık sunucu tarafı hazır olduğuna göre, kodlarımızı doğrudan sunucu üzerinde düzenlemek için VS Code'u yapılandıracağız. Her seferinde IP adresi ve kullanıcı adı yazmak yerine, SSH yapılandırma dosyasına kalıcı bir kayıt ekleyerek bağlantı sürecini otomatikleştireceğiz.

Adım 1:"Remote - SSH" Eklentisini Yükleyin

VS Code'u açın, sol taraftaki Eklentiler (Extensions) sekmesine gidin, arama çubuğuna Remote - SSH yazın ve Microsoft tarafından geliştirilen eklentiyi yükleyin.

Adım 2: Kalıcı Bir SSH Bağlantısı Oluşturma (Config Dosyası)

Bu adım, sunucu bağlantı bilgilerimizi config adında özel bir dosyaya kaydederek, bu bağlantıya kolayca hatırlanabilir bir isim vermemizi sağlar.

SSH Yapılandırma Dosyasını Açın:

Kendi lokal bilgisayarınızda, bir terminal veya komut istemi açın. SSH yapılandırma dosyasını bir metin editörü ile açın. Bu dosya genellikle aşağıdaki konumlarda bulunur:

Linux veya macOS: ~/.ssh/config
Windows: C:\Users\KULLANICI_ADINIZ\.ssh\config

Not:
Eğer .ssh klasörü veya config dosyası mevcut değilse, kendiniz oluşturabilirsiniz.

Kendi lokal bilgisayarınızda bir terminal açın. nano gibi kullanımı kolay bir terminal editörü ile yapılandırma dosyasını doğrudan açmak için aşağıdaki komutu çalıştırın:


nano ~/.ssh/config

Not: nano editöründe dosyayı kaydetmek için Ctrl+O (Write Out) ve ardından Enter'a, çıkmak için ise Ctrl+X tuş kombinasyonunu kullanabilirsiniz.

Eğer Windows kullanıyorsanız ve terminal kullanmak istemiyorsanız, dosyayı C:\Users\KULLANICI_ADINIZ.ssh\config konumunda bulup Not Defteri (Notepad) gibi bir metin editörü ile de açabilirsiniz.

(Eğer .ssh klasörü veya config dosyası mevcut değilse, komut dosyayı sizin için oluşturacaktır.)

Yeni host bilgilerini eklemek için aşşağıdaki işlemleri gerçekleştirin.

Açtığınız config dosyasına aşağıdaki bloğu ekleyin ve kendi bilgilerinizle doldurun:

# Liman MYS Geliştirme Sunucusu
Host liman-dev-sunucusu
    HostName <SUNUCU_IP_ADRESINIZ>
    User liman
    IdentityFile ~/.ssh/id_rsa

Host: Bağlantınızın kısa adıdır. VS Code'da görünecek ve kullanacağınız isim budur.
HostName: Liman sunucusunun gerçek IP adresi.
User: Bağlanacağınız kullanıcı adı, yani liman.
IdentityFile: Şifresiz bağlantı için oluşturduğunuz SSH özel anahtarınızın yolu (~/.ssh/id_rsa genellikle varsayılandır).
Dosyayı kaydedip kapatın.

Adım 3: VS Code ile Yapılandırılmış Host'a Bağlanma

Ctrl+Shift+P (veya F1) tuş kombinasyonu ile komut paletini açın.

Remote-SSH: Connect to Host... yazıp seçin.

Karşınıza çıkan listede, config dosyasına eklediğiniz Host isminin (liman-dev-sunucusu gibi) doğrudan göründüğünü göreceksiniz.Bu isme tıklayarak bağlantıyı başlatın.

VS Code yeni bir pencere açacaktır. Sol alt köşede "SSH: liman-dev-sunucusu" yazdığını gördüğünüzde, bağlantı başarıyla kurulmuş demektir.

Adım 4:Eklenti Klasörünü Açma

VS Code'da File > Open Folder... (veya Dosya > Klasör Aç...) seçeneğine tıklayın.

Açılan diyalog kutusuna eklentilerin bulunduğu yolu girin: /liman/extensions/

OK butonuna tıklayın.

Artık sol taraftaki dosya gezgininde, sunucudaki tüm eklenti dosyalarınızı görebilirsiniz. Yaptığınız her değişiklik anında sunucuya kaydedilecektir.

Bölüm 4: Eklentiyi Derleme ve Geliştirme Modunu Aktif Etme

Son aşamada, kodumuzun canlı olarak derlenmesini ve Liman arayüzünde görüntülenmesini sağlayacağız.

Adım 1 :Node.js ve pnpm Kurulumu (Gerekliyse)

Eklenti bağımlılıklarını yönetmek ve derleme işlemlerini yapmak için pnpm paket yöneticisine ihtiyacımız var. pnpm'in çalışabilmesi için de öncelikle sunucunuzda Node.js'in kurulu olması gerekmektedir.

Node.js Kurulumu:

Eğer sunucunuzda Node.js kurulu değilse veya çok eski bir sürüm varsa, aşağıdaki komutlarla güncel bir LTS (Uzun Süreli Destek) sürümünü kurabilirsiniz.

# Terminalde aşağıdaki komutları sırasıyla çalıştırın:

# Node.js 22.x LTS sürümü için kurulum betiğini indirip çalıştırın
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -

# Node.js ve beraberinde gelen npm'i yükleyin
sudo apt-get install -y nodejs

# Kurulumun başarılı olduğunu kontrol edin
node -v
npm -v

Bu komutlar sonunda v22.x.x ve v10.x.x gibi sürüm numaraları görmelisiniz.

PNPM Kurulumu:

Node.js ve npm'i kurduktan sonra, npm'i kullanarak pnpm'i global olarak (sistemin her yerinden erişilebilir şekilde) kurabiliriz.

# npm kullanarak pnpm'i global olarak yükleyin
sudo npm install -g pnpm

# pnpm kurulumunu kontrol edin
pnpm -v

Bu komut sonunda pnpm'in sürüm numarasını (9.x.x gibi) görüyorsanız, kurulum tamamlanmıştır.

Adım 2: Bağımlılıkları Yükleme

Artık pnpm kurulu olduğuna göre, eklentimizin ihtiyaç duyduğu kütüphaneleri ve paketleri yükleyebiliriz.
VS Code içerisinde Terminal > New Terminal (veya Terminal > Yeni Terminal) menüsünden yeni bir terminal açın. Bu terminalin doğrudan sunucunuzda, açtığınız klasör yolunda (/liman/extensions/) açıldığına dikkat edin.

Üzerinde çalıştığınız eklentinin klasörüne girin (örneğin: cd eklenti-adiniz).

Proje bağımlılıklarını yüklemek için aşağıdaki komutu çalıştırın:

pnpm install

Bu komut, package.json dosyasını okur ve projenin ihtiyaç duyduğu tüm kütüphaneleri node_modules klasörü altına indirir.

Geliştirme Sunucusunu Başlatma:

Aynı terminalde, projenin canlı olarak derlenmesini ve dosya değişikliklerini izlemesini sağlayacak komutu çalıştırın:

pnpm run dev

Bu komut, genellikle arkaplanda bir geliştirme sunucusu başlatır ve dosyalarınızda yaptığınız her değişikliği otomatik olarak algılayıp yeniden derler.

Adım 3 :Liman Arayüzünde Geliştirme Modunu Aktif Etme

Öncelikle Liman arayüzünden, geliştirdiğiniz eklentiyi bir sunucu gerekir. Bu işlem hakkında detaylı bilgi için resmi Liman dokümantasyonunu inceleyebilirsiniz: Liman Sunucu Yönetimi

Eklentiyi sunucuya atadıktan sonra, ilgili sunucu üzerinden eklentinizi açın.

Tarayıcınızın adres çubuğundaki URL'nin sonuna /development ekleyin ve Enter'a basın.

Bu işlemi yaptığınızda, Liman artık eklentinin derlenmiş statik dosyalarını değil, pnpm run dev komutunun çalıştırdığı geliştirme sunucusundan gelen canlı verileri kullanacaktır.

Ek Bölüm: Geliştirme Sürecinde Sık Karşılaşılan Sorunlar ve Çözümleri

Aşağıda, ana rehberi takip ederken veya geliştirme yaparken karşılaşabileceğiniz en yaygın dört sorun ve bu sorunları çözmek için izlemeniz gereken adımlar detaylandırılmıştır.

1. Eklenti Panelde Görünmüyor veya "Undefined" Olarak Gözüküyor

Eklentiyi Liman'a yükledikten sonra, panelde hiç görünmemesi veya isminin "Undefined" olarak listelenmesi.
Bu sorunun neredeyse her zaman tek bir nedeni vardır: Eklentinin .zip dosyasının hatalı bir klasör yapısıyla sıkıştırılması. Liman MYS, eklentiyi tanımak için hayati bir dosya olan extension.json'ın doğrudan zip dosyasının kök dizininde olmasını bekler.

Çözüm Yolları:

Doğru Zip Yapısı: Eklenti dosyalarınızın bulunduğu klasörün içine girin, tüm dosyaları (extension.json, views, public vb.) seçin ve bunları doğrudan zipleyin.

my-extension.zip
-> extension.json
-> views/

-> public/

-> ...diğer dosyalar

Yanlış Zip Yapısı (Kaçınılması Gereken): Eklenti dosyalarını içeren ana klasöre sağ tıklayıp onu zip'lemek. Bu durumda extension.json kök dizinde olmaz.

my-extension.zip

-> my-extension/ (Hatalı alt klasör)

-> extension.json
-> views/

-> ...

2. Port Çakışması (EADDRINUSE) Hatası
pnpm run dev komutunu çalıştırdığınızda, terminalde "EADDRINUSE" (Error: address already in use) hatası almanız.

Temel Nedeni Geliştirme sunucusunun kullanmaya çalıştığı portun (genellikle 5173) başka bir uygulama veya arka planda unutulmuş eski bir geliştirme süreci tarafından zaten kullanılıyor olması.

Çözüm Yolları:

Yöntem A: Alternatif Bir Port Kullanmak (En Hızlı Çözüm)
pnpm run dev komutunu, boş olduğundan emin olduğunuz farklı bir port numarası ile çalıştırın:

pnpm run dev -- --port 5174

Yöntem B: Portu Kullanan İşlemi Sonlandırmak
Mevcut portu meşgul eden işlemi bulup sonlandırın:

# Örnek olarak 5173 portunu kullanan işlemi bulalım
sudo lsof -i :5173
# Komut çıktısındaki PID (Process ID) numarasını kullanarak işlemi sonlandıralım
# Örneğin PID 12345 ise:
sudo kill -9 12345

Bu işlemden sonra pnpm run dev komutunu tekrar çalıştırabilirsiniz.

3. 404 - Not Found (/development) Hatası
Liman arayüzünde eklentiyi açıp URL sonuna /development eklediğinizde "404 - Not Found" hatası almanız.

Temel Nedeni Tarayıcınız, geliştirme sunucusuyla iletişim kuramıyor. Bunun birkaç sebebi olabilir.

Çözüm Yolları (Sırasıyla Kontrol Edin):

Geliştirme Sunucusu Çalışıyor mu?
VS Code'daki terminalinize geri dönün. pnpm run dev komutunun hala çalıştığından ve bir hata vermediğinden emin olun. Eğer durmuşsa, yeniden başlatın.

Doğru Portu mu Kullanıyorsunuz?
pnpm run dev komutunun çıktısını kontrol edin. Geliştirme sunucusu hangi portta (5173, 5174 vb.) çalıştığını size söyleyecektir. Liman'ın bu porta erişebildiğinden emin olun.

Güvenlik Duvarı (Firewall) Engelliyor mu?
Sunucunuzun güvenlik duvarı, geliştirme portuna dışarıdan erişimi engelliyor olabilir. Ubuntu'da ufw kullanılıyorsa, ilgili porta izin verin:

# Vite'ın varsayılan portu 5173 için izin verelim
sudo ufw allow 5173
sudo ufw reload

Liman Mail Ayarları

Enes Baytekin — Mon, 17 Nov 2025 09:07:37 +0000

Mock mail sunucusu kurmak

Mailhog

Mailhog, gönderilen e-postaları yakalayıp kendi web arayüzünde gösteren bir servistir. Gerçek bir mail sunucusu değildir. Test ortamlarında kullanılan geçici bir mail sunucusu gibi düşünülebilir.

Kurulum

Mailhog indirilir ve çalıştırma izni verilir.

sudo wget -O /usr/local/bin/mailhog https://github.com/mailhog/MailHog/releases/download/v1.0.0/MailHog_linux_amd64
sudo chmod +x /usr/local/bin/mailhog

/etc/systemd/system/mailhog.service servis dosyası oluşturulur ve içi şu şekilde doldurulur.

[Unit]
Description=Mailhog
After=network.target
[Service]
ExecStart=/usr/bin/env /usr/local/bin/mailhog > /dev/null 2>&1 &
[Install]
WantedBy=multi-user.target

Sistemin, servisi görmesi sağlanır ve servis başlatılır.

sudo systemctl daemon-reload
sudo systemctl enable --now mailhog

Mailhog iki port açar:

8025: web arayüzü için
1025: mail gönderilmesi için

Tarayıcıdan http://<server-ip>:8025 adresi ile mailhog arayüzüne gidilebilir.

Liman Mail Ayarları

Liman arayüzünden Ayarlar / E-Posta sayfasına gelinir.

Sunucu Adresi ve Sunucu Portu kısmına mail sunucusunun adresi ve mail servisinin çalıştığı port yazılır.

Kullanıcı Adı ve Parola kısmına test mailinin gelmesi istenilen mail adresi ve parolası yazılır.

Şifreleme Türü seçilir ve E-posta gönderimini aktifleştir seçeneği işaretlenir.

Bu ayarlar yapıldıktan sonra liman üzerinde yapılan işlemler (kullanıcı oluşturma / şifresini değiştirme, sunucu ekleme / silme...) ilgili kullanıcıların mail adreslerine gönderilir.

Eğer mailhog kullanılıyorsa gelen bu mailler, web arayüzü üzerinden kontrol edilebilir.

RKE2'de Liman MYS & Keycloak Kurulumu: Longhorn ve Docker Hub Hata Çözümleri Dahil Tam Rehber

Yunus Emre Dere — Fri, 24 Oct 2025 10:37:05 +0000

Kubernetes (K8s) dünyasında, Liman MYS gibi, envanter yönetiminden servis takibine kadar pek çok işlevi eklentilerle yürüten platformlar kullanırız. Bu farklı bileşenler ve yetkiler için merkezi bir kimlik doğrulama (Authentication) yönetimi hızla karmaşıklaşabilir. İşte bu noktada Keycloak devreye giriyor.

Bu rehberde, RKE2 (hafifletilmiş bir K8s dağıtımı) üzerinde Liman MYS ve Keycloak'u sıfırdan kuracak, bu iki güçlü sistemi birbirine bağlayacak (SSO) ve bu süreçte kesinlikle karşılaşacağınız en yaygın iki hatayı (Longhorn Pending ve Docker Hub TooManyRequests) adım adım çözeceğiz.

Faz 1: Gerekli Altyapı (Bizim "Sandbox" Ortamımız)

Başlamadan önce, RKE2 sunucumuzun uygulamaları barındırmaya hazır olması gerekir.

RKE2: Zaten kurulu olduğunu varsayıyoruz.
Helm: Kubernetes için bir paket yöneticisidir.
```
sudo snap install helm --classic
```
StorageClass (Longhorn): Liman ve Keycloak'un veritabanları gibi 'stateful' (durum bilgisi tutan) uygulamaları, verilerini kalıcı olarak saklamak zorundadır. Bunun için bir StorageClass (Depolama Sınıfı) sağlayıcısına ihtiyacımız var. Biz burada popüler ve RKE2 ile uyumlu olan Longhorn'u kullanacağız.

Aşağıdaki kod Longhorn'u ve onun 'longhorn' adlı StorageClass'ını kurar

kubectl apply -f https://raw.githubusercontent.com/longhorn/longhorn/v1.9.0/deploy/longhorn.yaml

Longhorn'un longhorn-system namespace'inde kurulup pod'larının Running duruma gelmesini bekleyin.

Faz 2: Keycloak Kurulumu ve Erişimi

Artık altyapımız hazır olduğuna göre, kimlik sunucumuz olan Keycloak'u kuralım.

Adım 1: Keycloak'u Kurma

Topluluk tarafından sağlanan resmi YAML dosyası, hem Keycloak'u (bir StatefulSet olarak) hem de veritabanı için bir PostgreSQL'i (bir Deployment olarak) kurar.

kubectl apply -f https://raw.githubusercontent.com/keycloak/keycloak-quickstarts/refs/heads/main/kubernetes/keycloak.yaml

Adım 2: Pod Kontrolü

Kurulumun tamamlandığını görmek için pod'ları kontrol edin.

kubectl get pods

NAME                       READY   STATUS    RESTARTS   AGE
keycloak-0                 1/1     Running   0          39h
keycloak-1                 1/1     Running   0          39h
postgres-65cf55dbf-nv5kx   1/1     Running   0          40h
redis-58f44d957b-6gzmw     1/1     Running   0          24h

Pod'ların Running durumuna geçmesi, Docker Hub limitlerine takılmazsanız birkaç dakika sürebilir. (Eğer ErrImagePull hatası alırsanız, Faz 4'teki çözüme atlayın).

Adım 3: Keycloak Ingress Yapılandırması

Keycloak'a tarayıcıdan temiz bir adresle (keycloak.test.local gibi) erişmek için bir Ingress oluşturacağız.

Önce, Keycloak servisinin hangi portu kullandığını öğrenelim:

kubectl get svc

NAME                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
keycloak             ClusterIP   10.43.158.36   <none>        8080/TCP   40h
keycloak-discovery   ClusterIP   None           <none>        <none>     40h
kubernetes           ClusterIP   10.43.0.1      <none>        443/TCP    42h
postgres             ClusterIP   10.43.32.41    <none>        5432/TCP   40h

Gördüğümüz gibi, keycloak servisi 8080 portunu kullanıyor. Şimdi keycloak-ingress.yaml dosyamızı oluşturalım:

nano keycloak-ingress.yaml

Dosyanın içeriği:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: keycloak-ingress
spec:
  # RKE2'nin varsayılan nginx controller'ını kullan
  ingressClassName: nginx  
  rules:
  - host: "keycloak.test.local" # Keycloak'a bu adresle erişeceğiz
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: keycloak   # Yukarıda öğrendiğimiz servis adı
            port:
              number: 8080 # Yukarıda öğrendiğimiz port

Ingress kuralını uygulayalım:

kubectl apply -f keycloak-ingress.yaml

Adım 4: Hosts Dosyası

keycloak.test.local adresinin RKE2 sunucumuzun IP'sine yönlenmesi için, tarayıcıyı kullandığımız kendi bilgisayarımızda (sunucuda değil!) /etc/hosts dosyasını düzenlememiz gerekiyor.

sudo nano /etc/hosts

Dosyanın en altına RKE2 sunucunuzun IP'sini ve host adını ekleyin:

<kubernetes-kurulu-server-ip-adresi>   keycloak.test.local

Artık tarayıcıdan http://keycloak.test.local adresine giderek Keycloak arayüzüne erişebilirsiniz.

Varsayılan hızlı başlangıç bilgileri:

Kullanıcı Adı: admin
Şifre: admin

Faz 3: Keycloak'u Liman için Yapılandırma

Liman'a "Bana güvenebilirsin" demek için Keycloak'ta bir "Client" (istemci) ve "Realm" (Bölge) oluşturmalıyız.

Realm Oluşturun: admin olarak giriş yaptıktan sonra, sol üstteki "master" yazan yerden "Manage realms" > "Create Realm" deyin. Realm adınızı Liman-Realm gibi bir şey yapın ve "Create"e tıklayın.
Client Oluşturun: Sol üstten Liman-Realm'i seçtiğinizden emin olun. Sol menüden "Clients" sekmesine ve ardından "Create Client"a tıklayın. "Client ID" kısmına liman-client gibi hatırlayacağınız bir isim verin. Gelen ekranda "Client authentication" ve "Authorization" seçeneklerini ON (Açık) konuma getirin. Aşağıdaki "Valid redirect URIs" alanına, Liman arayüzünde bizden istenen adresi girmeliyiz. Bu, Liman'ın Ingress host adına bağlı olacaktır. Şimdilik https://liman.test.local/keycloak/callback yazabilirsiniz. (Liman Ingress'ini oluştururken liman.test.local kullanacağız). Web origins kısmına da https://liman.test.local yazın ve kaydedin.
Client Secret'ı Alın: Kaydettikten sonra açılan "Credentials" sekmesine tıklayın ve "Client Secret" değerini kopyalayın. Bu, Liman'daki forma yapıştıracağımız "şifre" olacak.
Rolleri Token'a Ekleyin (Çok Önemli Adım!): Liman'ın, giriş yapan kullanıcının yetkilerini anlaması için bu rollerin Keycloak tarafından oluşturulan token'a eklenmesi gerekir.
- Sol menüden "Client Scopes"a tıklayın.
- roles adlı scope'u seçin.
- Açılan ekranda "Mappers" (Eşleyiciler) sekmesine tıklayın.
- realm-roles'e girin, "Add to access token" seçeneğini aktifleştirip kaydedin.
- Aynı işlemi client-roles için de yapın.
Test Kullanıcısı Oluşturun:
- Sol menüden "Users"a gidin ve "Add User" deyin.
- Kullanıcı bilgilerinizi girin, "Email verified" seçeneğini açın ve Create'e tıklayın.
- Kullanıcıyı oluşturduktan sonra, "Credentials" sekmesine giderek ona kalıcı bir şifre belirleyin (Temporary'i kapatarak).

Keycloak tarafı artık Liman'ı kabul etmeye hazır.

Faz 4: Liman MYS Kurulumu ve Hata Ayıklama

Şimdi Liman MYS'yi kuralım ve bu süreçte karşılaşacağımız iki yaygın hatayı çözelim.

git clone https://github.com/limanmys/core.git
cd core/k8s/helm
kubectl create namespace liman
helm install limancore . --namespace liman

kubectl get pods -n liman komutunu çalıştırdığınızda, pod'ların Pending (Beklemede) veya ErrImagePull durumunda takıldığını göreceksiniz. Panik yapmayın, bu normal.

HATA 1 ÇÖZÜMÜ: Pending (Beklemede) Pod'lar

db- ve limancore- pod'larının Pending kalmasının nedeni, Longhorn'un varsayılan olarak 3 replica (kopya) disk oluşturmaya çalışmasıdır. Bizim RKE2 kurulumumuz tek bir sunucudan (Node) oluştuğu için Longhorn "Verinin 3 kopyasını oluşturamam" diyerek diski (Volume) oluşturmayı reddeder.

Bunu düzeltmek için Longhorn arayüzüne erişip replica sayısını 1'e düşüreceğiz:

Longhorn Arayüzünü Erişime Açın:
```
kubectl edit svc longhorn-frontend -n longhorn-system
```
Açılan vi editöründe, spec: altındaki type: ClusterIP satırını type: NodePort olarak değiştirin ve kaydedip çıkın (Esc > :wq > Enter).

Portu Öğrenin:

kubectl get svc -n longhorn-system
NAME                          TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
longhorn-admission-webhook    ClusterIP   10.43.130.170   <none>        9502/TCP       23h
longhorn-backend              ClusterIP   10.43.171.127   <none>        9500/TCP       23h
longhorn-conversion-webhook   ClusterIP   10.43.234.16    <none>        9501/TCP       23h
longhorn-frontend             NodePort    10.43.84.222    <none>        80:31248/TCP   23h
longhorn-recovery-backend     ClusterIP   10.43.60.100    <none>        9503/TCP       23h

longhorn-frontend servisinin NodePort değerini (örn: 80:31248/TCP) göreceksiniz. Bize 31248 portu lazım.

Replica Sayısını Düşürün: Tarayıcınızdan http://<sunucu-ip-adresi>:<port-sayısı> (örn: http://xx.xx.xx.xx:31248) adresine gidin. "Volume" sekmesine gidin. Faulted (Hatalı) durumda olan volüm'leri (liman db ve core için) göreceksiniz. Sağ taraftaki üç noktaya tıklayın ve "Update Replicas" (Replica'ları Güncelle) deyin. Değeri 3'ten 1'e düşürün ve OK'e basın.

Bunu hatalı olan tüm Liman volüm'leri için yaptığınızda, durumları "Healthy" (Sağlıklı) olacaktır ve pod'lar Pending durumundan çıkacaktır.

HATA 2 ÇÖZÜMÜ: ErrImagePull / TooManyRequests

Pending sorununu çözseniz bile, pod'ların bu kez ErrImagePull veya ImagePullBackOff hatası verdiğini göreceksiniz. Bunun nedeni, Docker Hub'ın anonim (giriş yapmamış) kullanıcılara çok düşük bir imaj indirme limiti koymasıdır.

Çözüm, RKE2 sunucumuza Docker Hub'a nasıl giriş yapacağını öğretmektir.

Docker Hub Access Token Oluşturun:
- Docker Hub'a giriş yapın.
- Ayarlar > Security > Personal Access Tokens sayfasına gidin.
- "Generate New Token" diyerek bir token oluşturun ve bu token'ı güvenli bir yere kopyalayın.

Kubernetes Secret Oluşturun: Terminalde, kopyaladığınız o token'ı kullanarak bir Kubernetes "giriş kartı" (secret) oluşturun:

kubectl create secret docker-registry dockerhub-auth \
  --docker-username="SizinDockerHubKullanıcıAdınız" \
  --docker-password="YENİ_OLUŞTURDUĞUNUZ_TOKEN" \
  --docker-email="SizinEmailAdresiniz" \
  -n liman

Secret'ı Pod'lara Tanıtın: liman namespace'indeki default (varsayılan) hizmet hesabını (Service Account) yamalayarak, bu namespace'de oluşturulan her pod'un imaj çekerken bu "giriş kartını" kullanmasını sağlayacağız:
```
kubectl patch serviceaccount default -n liman -p '{"imagePullSecrets": [{"name": "dockerhub-auth"}]}'
```
Pod'ları Yeniden Başlatın: Hatalı pod'ları silerek Kubernetes'in onları yeni ayarla (giriş yapmış olarak) yeniden başlatmasını sağlayın:
```
kubectl delete pods --all -n liman
```
Tekrar kubectl get pods -n liman -w komutuyla izlediğinizde, bu kez tüm pod'ların imajları başarıyla çektiğini ve Running durumuna geçtiğini göreceksiniz.

Faz 5: Liman Ingress ve Son Ayarlar

Artık çalışan bir Liman'ımız var. Ona da Keycloak gibi temiz bir adresle erişelim.

Liman Ingress Dosyası:

sudo nano liman-ingress.yaml

Dosyanın içeriği:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: liman
  namespace: liman
  annotations:
    # Arka uç (Liman) HTTPS (443) kullandığı için Nginx'e HTTPS konuşmasını söylüyoruz
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
    # Liman'ın kendi imzaladığı sertifikayı Nginx'in dert etmemesini söylüyoruz
    nginx.ingress.kubernetes.io/proxy-ssl-verify: "off"
spec:
  ingressClassName: nginx
  rules:
  - host: "liman.test.local" # Liman'a bu adresle erişeceğiz
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: limancore # Liman'ın ana servis adı
            port:
              number: 443    # Liman'ın servis portu

Dosyayı kaydedin ve uygulayın:

kubectl apply -f liman-ingress.yaml -n liman

Hosts Dosyasını Güncelleyin: Tekrar kendi bilgisayarınızda sudo nano /etc/hosts dosyasını açın ve liman.test.local adresini de ekleyin:
```
<kubernetes-kurulu-server-ip-adresi>   keycloak.test.local
<kubernetes-kurulu-server-ip-adresi>   liman.test.local
```

Liman Admin Şifresini Alın: Liman'a ilk giriş için tek kullanımlık bir şifre almamız gerekiyor:

# Önce limancore pod'unun tam adını bulalım:
LIMAN_POD_NAME=$(kubectl get pods -n liman -l service=limancore -o jsonpath='{.items[0].metadata.name}')
echo "Liman Pod Adı: $LIMAN_POD_NAME"

# Şimdi o pod'dan şifreyi isteyelim:
kubectl exec -it $LIMAN_POD_NAME -n liman -- limanctl administrator

Size administrator kullanıcısı için bir şifre verecektir.

Liman'ı Keycloak'a Bağlayın:
- Tarayıcınızdan http://liman.test.local adresine gidin. (Ingress, isteğinizi otomatik olarak HTTPS'e yönlendirecektir).
- Aldığınız administrator şifresiyle giriş yapın.
- Ayarlar > Erişim > Keycloak sekmesine gidin.
- Buradaki alanları, Faz 3'te Keycloak'ta oluşturduğunuz bilgilerle doldurun:
  - Client ID: liman-client (veya ne isim verdiyseniz)
  - Client Secret: Keycloak'tan kopyaladığınız gizli şifre.
  - Redirect URL: https://liman.test.local/keycloak/callback (Keycloak'a girdiğiniz adresin aynısı)
  - Base URL: http://keycloak.default.svc.cluster.local:8080 (Keycloak adresiniz)
  - Realm: Liman-Realm (veya ne isim verdiyseniz)
- "Entegrasyonu aktifleştir" butonunu AÇIK hale getirin ve kaydedin.

Son Adım: Liman'ı Yeniden Başlatın

Liman'ın bu yeni ayarları çekmesi için limancore pod'unu yeniden başlatmamız gerekiyor:

# Pod'un tam adını tekrar bulup silin
kubectl delete pod $LIMAN_POD_NAME -n liman

Pod yeniden başladığında, Liman giriş ekranına geri dönün.

Artık "Giriş Yöntemi" olarak Keycloak'u seçebilir, Faz 3'te oluşturduğunuz test kullanıcısıyla giriş yapabilir ve Keycloak üzerinden Liman'a başarıyla bağlandığınızı görebilirsiniz.

Tebrikler! Artık RKE2 üzerinde çalışan, Longhorn ile kalıcı depolamaya sahip ve Keycloak ile SSO entegrasyonu tamamlanmış bir Liman MYS kurulumunuz var.

Liman Zabbix Bildirimleri

Enes Baytekin — Fri, 24 Oct 2025 07:35:33 +0000

Media type oluşturmak

Zabbix'te Alerts / Media types kısmında gelinir ve yeni bir media type oluşturulur.

Oluştururken;

Medya tipine bir isim verilir.
Tip olarak webhook seçilir.
Scriptte kullanılacak parametreler, değerleri zabbixten gelen değerler olacak şekilde tanımlanır.
Script kısmına javascript dilinde yazılır. Burada istenilen endpointlere istenilen şekilde istek atılablir.

Şu şekilde limana istek gönderilebilir:

var payload = JSON.stringify({
    "token": "<limandan-alinan-token>",
    "title": {
        "tr": "<mesaj-basligi>",
        "en": "<mesaj-basligi>",
        "de": "<mesaj-basligi>"
    },
    "content": {
        "tr": "<mesaj-icerigi>",
        "en": "<mesaj-icerigi>",
        "de": "<mesaj-icerigi>"
    },
    "level": "<trivial|low|medium|high|critical>",
    "mail": <true|false>,
    "send_to": <"admins"|liman-user-id-lstesi>
});

var request = new HttpRequest();
request.addHeader('Content-Type: application/json');
var response = request.post('https://' + liman_address + '/api/notifications/send', payload);
if (request.getStatus() !== 200) {
    throw "API request (443) failed: " + response;
}

Process tags seçeneği işaretlenir.
Bir açıklama girilir.

Not: Limana bildirim gönderebilmek için gönderilecek için bir liman token alınması lazım. Yani zabbix makinesinin ip'si için liman arayüzünden Ayarlar / Dış Bildirimler kısmından bir token oluşturmak ve burdaki script içinde istek atarken body'de bu tokeni de kullanmak gerekli.

Trigger action oluşturmak

Zabbix'te Alerts / Actions / Trigger actions kısmına gelinir ve yeni bir action oluşturulur.

Oluştururken;

Action için bir isim verilir.
Conditions kısmına bu aksiyonun ne zaman tetikleneceği ile ilgili kriterler girilir.

Örnek:

(Event name contains En az 3 dakika) AND ((Host Group equals A Host Grubu) OR (Host Group equals B Host Grubu))

A veya B host grubuna sahip olan varlıklarda oluşan bir problemin isminde 'En az 3 dakika' geçiyorsa bu action tetiklenecek.

Operations sekmesinde, Default operation step duration bu aksiyonun ne sıklıkla tetikleneceği belirtilir. (1h = 1 saat, 1m = 1 dakika, ...)
Operation eklerkenki Steps kısmında problem başladıktan sonraki hangi aralıklarda bu aksiyonun tetikleneceği belirtilir. İlk kısım kaçıncı aralıktan başlayacağı, ikinci kısım ise kaçıncı aralıkta biteceğini belirtir. Step duration da bu aralıkların süresini belirtir. (0 olarak bırakıp default action duration'ı kullanabilirsiniz.)

Örnekler:
1    2    3    4    5
|....|....|....|....|...  . . .
  1h   1h   1h   1h
Step duraiton: 1h

1 - 1 --> Problem oluştuğu anda bir kere tetiklensin.

2 - 2 --> Problem oluştuktan 1 saat sonra (2. intervalde) bir kere tetiklensin.

4 - 0 --> Problem oluştuktan 3 saat sonra (4. intervalde) tetiklensin ve sonsuza kadar (problem çözülene kadar) her saat başı bir kez daha tetiklensin.

Send to users ya da Send to user groups kısımlarında bu aksiyon tetiklendiğinde hangi zabbix kullanıcıları için geçerli olacağı seçilir. Admin seçilebilir.
Send to media type kısmında daha önce liman için oluşturulmuş olan medya tipi seçilir.
Her bir operatör için custom mesaj eklemek de mümkün. Ancak Liman'a bildirim atarken gönderilen isteğin body'sinde mesaj içeriği de belirtildiği için mesaj içeriğini medya tipinin script kısmında javascript ile belirleyerek daha dinamik mesajlar ('şu kadar saat önce' gibi) elde edilebillir.
Recovery operations kısmında ise yine aynı mantık ile problem çözüldüğünde bu aksiyonun tetiklenmesi sağlanabilir.

Zabbix'te Users / Users sayfasına actionları oluştururken seçilen zabbix user'ı seçilir ve Media sekmesine gelinir.

Media alanına bir media eklenir;

Type kısmında, daha önce oluşturmuş olan medya tipi seçilir.
Send to kısmına herhangi bir şey yazılabilir.
Use if severity kısmında bu kullanıcı için, seçili olan severity'lere sahip problemlerin actionları tetiklenir.
Update'e tıklanarak kaydedilir.

Netex Server ve Netex Sensör kurulumu

Emine Nur Arıcı — Wed, 08 Oct 2025 10:23:12 +0000

NETEX SERVER KURMA ADIMLARI

not: zabbixin LTS sürümünün kurulu olduğu varsayılmıştır. Zabbix kurulumu için: zabbix kurulumu

Postgresql kurulumu:

sudo apt update
sudo apt install postgresql postgresql-contrib

veritabanı sunucusuna bağlanma:

sudo -u postgres psql

Kullanıcı ve veritabanımızı oluşturalım

CREATE USER netex WITH PASSWORD '1';
CREATE DATABASE netex WITH OWNER netex;

Daha sonrasında \q ile çıkış yapabiliriz

NETEX server kurulumu:

kurulumu size verilen deb dosyası ile yapabilirsiniz.

sudo apt install ./netex-sensor-455-x64.deb -y

Sonra düzenleme yapabilmek için sudo suile root kullanıcısına geçiyoruz, oradan
cd /opt/netex
komutu ile netex klasörüne geçip env.example içindeki içeriği .env içerisine kopyalıyoruz.

cp env.example .env

nano .env ile .env dosyasını açıp içini düzenliyoruz:

storage configuration kısmında farklı isimlerde DB ve USER oluşturulmadıysa değişiklik yapnmaya gerek yoktur.
Zabbix ayarlarını yaparken zabbix kurarken kullandığınız kullanıcı adı ve passwordu giriyoruz. URL kısmındaki ip adresi kısmına da zabbixin kurulu olduğu serverın ipsini giriyoruz.
JWT KEY ‘i bulmak için Liman'ın kurulu olduğu makineye gidip

 sudo su
cd /liman
cd server
cat .env

diyoruz ve çıkan .env dosyasının içeriğinde en altta JWT_SECRET’ı buluyoruz. Sonrasında .env dosyasında JWT kısmına yapıştırıyoruz.

.env dosyasının aşağıdaki kısımlarını yukarıdaki bilgilere göre düzenliyoruz.

# Storage Configuration @required
DB_HOST=127.0.0.1
DB_NAME=netex
DB_PASS=netex
DB_PORT=5432
DB_USER=netex

ZABBIX_USERNAME="<zabbix_username>"
ZABBIX_PASSWORD="<zabbix_password>"
ZABBIX_URL="<http://zabbix_ip_adresi/zabbix/api_jsonrpc.php>"
ZABBIX_SYNC="ON"

# Liman JWT Secret for http admin service usage @not-required
JWT_SECRET= <yukarıda nasıl bulunacağı belirtildi.>

Daha sonrasında bu iki komutla restart edip netex server'daki tüm servisleri kontrol edelim:


sudo systemctl restart netex@*
sudo systemctl status netex@*

NETEX SENSÖR KURMA ADIMLARI

netex kurulu makinede şunları yapalım:

sudo su
cd /opt/netex/clients
ls

burada sensör için gerekli kurulum dosyaları sıralanır. Ubuntu cihaza deb dosyası şu şekilde kurulur:

apt install ./netex-sensor-455-x64.deb -y

opt/netex-sensor/.env dosyasının içeriğini düzenleyelim.

SERVER_URL="https://<netex_server_ip>:7782"
SENSOR_IP="<netex_server_ip>"
DNS_SERVER_URL="<DNS_server_ip>:53"
DEBUG_MODE="OFF"
PORT_MIRRORING_INTERFACE="ens18"

SOURCE_IP_KEY=8
DEST_IP_KEY=12
SOURCE_MAC_KEY=56
DEST_MAC_KEY=57

Not: Lisans olmadığında netex-sensör çalışmayacaktır.

** NETEX’İ LİMAN ARAYÜZÜNE EKLEME**

Limanı kurduğumuz ip adresindeki Liman arayüzüne gidelim.
Öncelikle sunucular ekranına gelelim ve sunucu ekle diyelim.
Bu kısımda portu kendimiz ekliyoruz bu portu bulmak için terminalde netex'i restart ettikten sonra journalctl -u netex@* -fçalıştırdığımda şöyle bir çıktı alıyoruz ve orada port numarası yazıyor. Onu resimdeki belirtilen alana giriyoruz.

bu durımda bu port 7781

Anahatar Türü kısmında anahtarsız giriş seçelim.
Netex kurulu sunucumuzu ekleyelim ve sol panelden sunucumuza tıklayalım . eklentiler kısmına basalım. buradan da eklenti ekle diyelim.
Ekle diyerek ağ keşif seçelim ve böylelikle eklentiyi eklemiş olduk.
Arayüzde sol panelden eklentiye tıkladığımızda lisanslanmamış olsa da anasayfa açılır:

Python ile basit bir MCP Sunucu-İstemci örneği

Ali Orhun Akkirman — Tue, 02 Sep 2025 21:04:17 +0000

LLM'lerin araçlarla etkileşimi konusunda önemli bir adım olan MCP için python üzerinde en temelde FastMCP aracı kullanılmakta. Tabi ki bu araçlar sürekli güncellenip gelişmekte fakat yine de bu tarih için en geniş kullanıma sahip kütüphanesi olarak düşünülebilir.

MCP Sunucu Kurulum

Öncelikle mimarideki MCP sunucu kurulumu için aşağıdaki komutla fastmcp modülünün kurulması gerekmektedir.

pip instal fastmcp

Bu komutla birlikte sistemde Python üzerinde fastmcp modülü kullanılabilir duruma gelinmekte.

MCP Sunucu Yapılandırma

Bu adımdan sonra bir de basit bir sunucu uygulaması hazırlayalım. Uygulamanın test açısından son hali aşağıdaki gibi düşünebiliriz. Buradaki örnekte basit bir mcp fonksiyon aracı ile başka bir REST API'yi çağıran farklı bir fonksiyon aracının da bulunduğunu göreceğiz.

from fastmcp import FastMCP
import requests
from starlette.applications import Starlette
from starlette.routing import Route, Mount
from mcp.server.sse import SseServerTransport

mcp = FastMCP("Test MCP Sunucusu")

@mcp.tool()
def hello(name: str) -> str:
    return f"Merhaba {name}!"


@mcp.tool()
def exTool1(user: str) -> str:
    return f"Kullanıcı {user} !"

transport = SseServerTransport("/messages/")

async def handle_sse(request):
    async with transport.connect_sse(
        request.scope,
        request.receive,
        request._send
    ) as (in_stream, out_stream):
        await mcp._mcp_server.run(
            in_stream,
            out_stream,
            mcp._mcp_server.create_initialization_options()
        )

@mcp.tool()
def getirHavaDurumu(sehir: str) -> dict:
    url = f"https://api.open-meteo.com/v1/forecast?latitude=41.01&longitude=28.97&current_weather=true"
    response = requests.get(url)
    data = response.json()
    return {"sehir": sehir, "sonuc": data["current_weather"]}

#Build a small Starlette app for the two MCP endpoints
sse_app = Starlette(
    routes=[
        Route("/sse", handle_sse, methods=["GET"]),
        # Note the trailing slash to avoid 307 redirects
        Mount("/messages/", app=transport.handle_post_message)
    ]
)


if __name__ == "__main__":
    mcp.run(transport="http")

Bu uygulamadaki en önemli parça @mcp.tool() ile başlayan kısımlar. Bu kısımlar istemci (client) üzerinde kullanılabilir araç olarak görülebilecektir. Örneğin yukarıdaki uygulamada hello, exTool1 ve getirHavaDurumu şeklinde 3 tane araç bulunmakta.

Her araç için fonksiyon içerisindeki parametreler aldığını görmekteyiz. Örneğin hello'da name, exTool1'de user ve getirHavaDurumu'nda ise sehir olacak şekilde. Bu parametrelerin kullanımı fonksiyon içerisinde net bir şekilde anlaşıldığını düşünüyorum. Bir örnek açısından yukarıdaki uygulamada sehir parametresi requests modülü ile open-meteo API'sine sorgu atararak sıcaklık ve rüzgar değerlerini çekebilmekte.

Diğer kısımlara şuan için girmiyorum.

Bu adımdan sonra hangi isimle dosyayı kaydederseniz bu şekilde çağırmanız yeterli.

python3 server.py

Bu komutun çıktısı aşağıdaki gibi olması beklenmekte.

╭────────────────────────────────────────────────────────────────────────────╮
│                                                                            │
│        _ __ ___  _____           __  __  _____________    ____    ____     │
│       _ __ ___ .'____/___ ______/ /_/  |/  / ____/ __ \  |___ \  / __ \    │
│      _ __ ___ / /_  / __ `/ ___/ __/ /|_/ / /   / /_/ /  ___/ / / / / /    │
│     _ __ ___ / __/ / /_/ (__  ) /_/ /  / / /___/ ____/  /  __/_/ /_/ /     │
│    _ __ ___ /_/    \____/____/\__/_/  /_/\____/_/      /_____(*)____/      │
│                                                                            
│                                FastMCP  2.0                                │
│               🖥️  Server name:     Test MCP Sunucusu                          │
│               📦 Transport:       Streamable-HTTP                          │
│               🔗 Server URL:      http://127.0.0.1:8000/mcp                │
│               🏎️  FastMCP version: 2.12.0                                   │
│               🤝 MCP SDK version: 1.13.1                                   │
│               📚 Docs:            https://gofastmcp.com                    │
│               🚀 Deploy:          https://fastmcp.cloud                    │
╰────────────────────────────────────────────────────────────────────────────╯


[09/02/25 23:45:24] INFO     Starting MCP server 'Test MCP Server'    server.py:1571
                             with transport 'http' on                               
                             http://127.0.0.1:8000/mcp                              
INFO:     Started server process [281559]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

Bu çıktı ile MCP sunucumuzun 8000 portu üzerinden ayağa kalktığını söyleyebiliriz.

Sıra geldi MCP İstemciye

İstemci yapılandırılması için ise aşağıdaki uygulamayı kullanacağız.

Öncelikle kurulum için aşağıdaki komutu kullanabiliriz:

pip install "mcp[cli]"

Sonrasında sunucuyu kullanacak olan örnek bir istemci uygulaması aşağıdaki gibi kurgulanabilir.

import ast
import asyncio
import pprint

from fastmcp import Client
from fastmcp.client.transports import StreamableHttpTransport

# --- Configuration ---
SERVER_URL = "http://localhost:8000/mcp"
pp = pprint.PrettyPrinter(indent=2, width=100)


def unwrap_tool_result(resp):
    """
    Safely unwraps the content from a FastMCP tool call result object.
    """
    if hasattr(resp, "content") and resp.content:
        # The content is a list containing a single content object
        content_object = resp.content[0]
        # It could be JSON or plain text
        if hasattr(content_object, "json"):
            return content_object.json
        if hasattr(content_object, "text"):
            try:
                # Use ast.literal_eval for safely evaluating a string containing a Python literal
                return ast.literal_eval(content_object.text)
            except (ValueError, SyntaxError):
                # If it's not a literal, return the raw text
                return content_object.text
    return resp


async def main():
    transport = StreamableHttpTransport(url=SERVER_URL)
    client = Client(transport)
    print("\nConnecting to FastMCP server at:", SERVER_URL)
    async with client:
        # 1. Ping to test connectivity
        print("\nTesting server connectivity...")
        await client.ping()
        print("✅ Server is reachable!\n")

        # 2. Discover server capabilities
        print("🛠️   Available tools:")
        pp.pprint(await client.list_tools())
        print("\n📚 Available resources:")
        pp.pprint(await client.list_resources())
        print("\n💬 Available prompts:")
        pp.pprint(await client.list_prompts())

       # 3. Test tool
        print("\n\n🔍 Testing tool: havadurumu")
        raw_search = await client.call_tool(
            "getirHavaDurumu",
            {"sehir": "zonguldak",},
        )
        search_results = unwrap_tool_result(raw_search)
        pp.pprint(search_results)

if __name__ == "__main__":
    asyncio.run(main())

Bu uygulamadaki en önemli kısım ise yapılandırma kısmındaki SERVER_URL olarak sunucunun adres ve portunun yazılması gerekliliği olacak.

Sonrasında FastMCP araç çağrısını okunabilir noktaya getirecek unwrap_tool_result fonksiyonunu görüyoruz.

Ama asıl önemli kısım main fonksiyonunda yer alan kısımlar.

İlk adımda sunucuya sağlıklı erişip erişmediğinin kontrolü, sonrasında da sunucuda yer alan araç, kaynak ve prompt değerlerini göstermekte. Şuan için sadece araç kullandığımız için diğerleri boş gelecektir.

Araçlar içerisinde de hava durumunu sorguladığımız ve örnekte "zonguldak" ili için hava durumunu sorguladığımızı gösterecek.

Dolayısıyla aşağıdaki komut ile istemci uygulaması çalıştırılabilir.

python3 client.py

Bu komutun çıktısı da aşağıdaki gibi olacağı öngörülmekte.

Connecting to FastMCP server at: http://localhost:8000/mcp

Testing server connectivity...
✅ Server is reachable!

🛠️  Available tools:
[ Tool(name='hello', title=None, description=None, inputSchema={'properties': {'name': {'title': 'Name', 'type': 'string'}}, 'required': ['name'], 'type': 'object'}, outputSchema={'properties': {'result': {'title': 'Result', 'type': 'string'}}, 'required': ['result'], 'title': '_WrappedResult', 'type': 'object', 'x-fastmcp-wrap-result': True}, annotations=None, meta={'_fastmcp': {'tags': []}}),
  Tool(name='exTool1', title=None, description=None, inputSchema={'properties': {'user': {'title': 'User', 'type': 'string'}}, 'required': ['user'], 'type': 'object'}, outputSchema={'properties': {'result': {'title': 'Result', 'type': 'string'}}, 'required': ['result'], 'title': '_WrappedResult', 'type': 'object', 'x-fastmcp-wrap-result': True}, annotations=None, meta={'_fastmcp': {'tags': []}}),
  Tool(name='getirHavaDurumu', title=None, description=None, inputSchema={'properties': {'sehir': {'title': 'Sehir', 'type': 'string'}}, 'required': ['sehir'], 'type': 'object'}, outputSchema={'additionalProperties': True, 'type': 'object'}, annotations=None, meta={'_fastmcp': {'tags': []}})]

📚 Available resources:
[]

💬 Available prompts:
[]


🔍 Testing tool: havadurumu
<bound method BaseModel.json of TextContent(type='text', text='{"sehir":"zonguldak","sonuc":{"time":"2025-09-02T20:45","interval":900,"temperature":22.8,"windspeed":3.0,"winddirection":14,"is_day":0,"weathercode":1}}', annotations=None, meta=None)>

Tüm bu adımlarla birlikte aslında basitçe bir MCP sunucu-istemci uygulamasını ayağa kaldırıp kullanmış oluyoruz.

Tabi ki bu yazıda MCP uygulamasının detaylarına, LLM'lerle ilişkisine veya farklı detaylı konulara girmeden basitçe kullanımını derli toplu hazırlamak istedim. Umarım yeni başlayanlar için faydalı bir yazı olur.

Kaynak olarak kullandığım adres.

~~~~~~~~~~~~~~~~~~

"Her yeni başlangıç, başka bir başlangıcın sonundan gelir." Seneca

Eve-ng NAT Network Yapılandırması

Erenalp Tekşen — Fri, 04 Jul 2025 12:41:31 +0000

Başlıklara Hızlı Erişim

NAT Network Nedir?
Eve-ng'de NAT Ağ Yapısı İşleyişi
NAT Network Yapılandırması
DHCP Server Kurulumu ve Yapılandırılması
Eve-ng Ağ Bağlantı Testleri

NAT Network Nedir

NAT (Network Address Translation), lokal ağdaki özel IP adreslerini internet üzerinde geçerli olan genel IP adreslerine dönüştürerek ağ trafiğinin yönetilmesini sağlar. Bu sayede birden fazla cihaz tek bir genel IP adresi kullanarak internete çıkabilir. NAT, hem IP adreslerini korumak hem de ekstra güvenlik katmanı sağlamak için kullanılır.

Eve-ng'de NAT Ağ Yapısı İşleyişi

Eve-ng platformunda NAT (Network Address Translation) Network, farklı sanal ağ cihazlarının birbiriyle ve internet ile etkili bir şekilde iletişim kurmasını sağlayan bir yapılandırmadır. Bu yapılandırma, belirlenen bir ağ arayüzü üzerinden diğer sanal cihazlara IP adresi tahsis etmek ve bu cihazların internete çıkışını yönetmek için kullanılır.

Görselde görüldüğü üzere, "EVE NG VM" içerisinde birden fazla Pnet arayüzü bulunmaktadır. Özellikle "Pnet1" arayüzüne bağlı cihazlar için, internete çıkış talepleri "Pnet0" arayüzü üzerinden yönlendirilir. Burada, Pnet0 arayüzü NAT işlevi görerek, Pnet1 ve diğer arayüzlerden gelen tüm dış ağ trafiğini masquerade eder. Masquerade, iç ağdaki özel IP adreslerini tek bir halka açık IP adresi altında toplayarak dış ağlara sunar. Bu işlem, sanal cihazların internete erişimini güvenli ve kontrol edilebilir bir şekilde sağlar.

NAT Network Yapılandırması

Köprü Yönetimi

Eve-ng ortamında, fiziksel ve sanal arayüzler arasındaki bağlantıları yönetmek ve izlemek için brctl show komutu kullanılır. Bu komut, ağ köprülerinin nasıl yapılandırıldığını ve hangi arayüzlerin birbirine bağlı olduğunu gösterir

Komutun Kullanımı

Köprüleme durumunu görüntülemek için terminalinize brctl show yazın ve enter tuşuna basın.

Köprü Bağlantılarının Eşleşmesi

brctl show komutu ile elde edilen çıktıda görülen pnet0, pnet1, pnet2 gibi arayüzler, Eve-ng içerisinde network node eklerken seçilebilen cloud1, cloud2 gibi seçeneklerle doğrudan eşleşmektedir.

IP Adresi Atama ve Network Servisini Yeniden Başlatma

NAT yapılandırmasına başlamadan önce, seçilen ağ arayüzüne statik bir IP adresi atamanız gerekmektedir. Bunun için aşağıdaki adımları izleyin:

Ağ konfigürasyon dosyasını açın:

sudo nano /etc/network/interfaces

Arayüze statik IP adresi atayın:

# Cloud devices
iface eth1 inet manual
auto pnet1
iface pnet1 inet static
    address 192.168.125.1
    netmask 255.255.255.0
    bridge_ports eth1
    bridge_stp off

Networking servisini yeniden başlatarak ayarların devreye girmesini sağlayın:

systemctl restart networking

Ayarların doğru uygulandığını kontrol edin:

less | ip address

IPV4 Forwarding Aktivasyonu

IPV4 paketlerinin yönlendirilmesini etkinleştirmek için:

Sisteminizdeki ilgili yapılandırma dosyasını açın:

nano /etc/sysctl.conf

Yorum satırını kaldırarak IP forwarding'i aktif hale getirin ve değişiklikleri uygulayın:

Değişiklikleri kontrol edin

sysctl -p /etc/sysctl.conf

IPTables ile MASQUERADE Ayarı

Ağınızdaki cihazların internete çıkışını sağlamak için MASQUERADE kurallarını IPTables üzerinden ayarlayın:

192.168.125.0 subnet'inden gelenleri pnet0 interface'ini kullanarak internete çıkar demektir.
iptables -t nat -A POSTROUTING -s 192.168.125.0/24 -o pnet0 -j MASQUERADE

IPTables kurallarının doğru bir şekilde uygulanıp uygulanmadığını kontrol edin:

iptables -L -nv -t nat

IPTables kurallarını kalıcı hale getirmek için aşağıdaki komutu kullanın:

netfilter-persistent save

DHCP Server Kurulumu ve Yapılandırılması

DHCP sunucusunu yükleyin:

apt-get install isc-dhcp-server

DHCP sunucusunun hangi arayüzde çalışacağını belirleyin:

nano /etc/default/isc-dhcp-server

DHCP yapılandırma dosyasını düzenleyin:

/etc/dhcp/dhcpd.conf

DHCP sunucusu için aşağıdaki konfigürasyonları kendi ağ yapılandırmanıza uyacak şekilde düzenleyip, dhcpd.conf dosyasına ekleyin:

authoritative;

subnet 192.168.125.0 netmask 255.255.255.0 {
  range 192.168.125.20 192.168.125.254;
  interface pnet1;
  default-lease-time 600;
  max-lease-time 7200;
  option domain-name-servers 8.8.8.8, 1.1.1.1;
  option broadcast-address 192.168.125.255;
  option subnet-mask 255.255.255.0;
  option routers 192.168.125.1;}

"dhcpd -t" komutu ile yapılandırma dosyasında herhangi bir syntax hatası var mı kontrol edin

DHCP sunucusunu başlatın:

systemctl start isc-dhcp-server

DHCP sunucusunu sistem başladığında otomatik olarak çalışacak şekilde etkinleştirin:

systemctl enable isc-dhcp-server

DHCP sunucusunun durumunu kontrol edin:

systemctl isc-dhcp-server status

Eve-ng Ağ Bağlantı Testleri

EVE-ng arayüzünde sağ tıklayarak 'Network' sekmesini seçin ve yapılandırdığınız arayüzü aktif edin.

EVE-ng'nin Network sekmesinde "Type" kısmından, önceden yapılandırdığınız arayüzü seçin. Bu rehberde, pnet1 üzerinde çalışıldığı için "Cloud1" seçeneği seçilmiştir.

Ubuntu sanal makinesini doğrudan Cloud yapılandırmasına bağlayarak ağ bağlantısını kurun.

Ubuntu sanal makinesinde terminal açın ve aşağıdaki komutu kullanarak DHCP sunucusundan IP adresi alın:

sudo dhclient

Alınan IP adresi ile internet erişimini kontrol edin

NOT: Bu rehber, temel bir NAT Network yapılandırması üzerine kurulmuştur. Eğer farklı bir topolojide çalışmayı planlıyorsanız, ağınızı daha etkin yönetmek için ek yapılandırmalar yapmanız gerekebilir. Bunlar arasında statik ve dinamik yönlendirme, IP NAT inside ve outside konfigürasyonları veya ACL (Erişim Kontrol Listesi) kullanımı yer alabilir.

Sonuç

Bu rehber, Eve-ng platformunda NAT Network kullanarak sanal ağ cihazları arasındaki etkileşim ve internet bağlantısının nasıl yapılandırılacağını detaylı bir şekilde anlatmaktadır. NAT'ın ağ güvenliğini ve IP adres yönetimini nasıl iyileştirdiğini öğrendik. Ayrıca, DHCP server kurulumu ve yapılandırılması gibi ileri düzey ağ operasyonlarına da değindik. IP forwarding ve MASQUERADE ayarlarının önemi, ağ trafiğinin yönetilmesi ve internet erişiminin sağlanmasında kritik rol oynamaktadır.

Keystone Keycloak Entegrasyonu

Erenalp Tekşen — Fri, 04 Jul 2025 12:40:03 +0000

Giriş

Bu doküman, bir kimlik sağlayıcı olan Keycloak ile bulut yönetim platformu OpenStack Keystone arasında OpenID Connect (OIDC) protokolü kullanılarak federated authentication (federasyon tabanlı kimlik doğrulama) entegrasyonunu anlatır.

Temel Kavramlar:

Keycloak: Açık kaynaklı bir kimlik ve erişim yönetimi çözümüdür. Kullanıcı kimlik doğrulama, yetkilendirme, kullanıcı profili yönetimi gibi işlemleri sağlar.
OpenStack Keystone: OpenStack’in kimlik yönetimi servisidir. Kullanıcıların, projelerin ve rollerin doğrulanmasından sorumludur.
OpenID Connect (OIDC): OAuth 2.0 protokolünün kimlik doğrulama katmanıdır. Keycloak gibi OIDC sağlayıcıları, OpenStack gibi uygulamalara kullanıcı kimlik doğrulama imkanı sunar.

Keycloak – OpenStack Keystone OpenID Connect Entegrasyonu Rehberi

Genel Bilgilendirme

Bu dökümanda geçen örnek domain adresleri:

auth.keycloak.local: Keycloak sunucusunun HTTPS üzerinden erişilebilir alan adıdır. Gerçek ortamda bu adres, sizin Keycloak kurulumunuzun erişilebilir FQDN (tam nitelikli alan adı) olmalıdır.
dlp.srv.world: OpenStack Keystone ve Horizon servislerinin HTTPS ile sunulduğu alan adıdır. Bu da sizin ortamınıza uygun bir şekilde DNS ile çözülmelidir. Eğer DNS yoksa /etc/hosts ile eşleştirme yapılabilir.

Her iki servis de HTTPS ile çalışmalı ve geçerli sertifikalarla (self-signed ya da CA imzalı) yapılandırılmış olmalıdır.

Bu döküman, Keycloak kimlik sağlayıcısını kullanarak OpenStack Keystone ile OpenID Connect (OIDC) tabanlı federated authentication yapılandırmasını anlatır. Bu sayede kullanıcılar, Horizon arayüzü veya CLI üzerinden Keycloak ile OpenStack'e giriş yapabilir.

Ön Gereksinimler

HTTPS yapılandırılmış bir Keycloak sunucusu

(Self-signed veya geçerli bir SSL sertifikası ile)
HTTPS yapılandırılmış bir OpenStack Horizon servisi

(Sadece CLI kullanılacaksa Horizon gerekmez)

1. Adım: Keycloak Yapılandırması

Client Oluşturma

Keycloak arayüzünde aşağıdaki şekilde keystone adlı bir client oluşturulmalıdır:

Protocol: openid-connect
Client Authentication: Açık
Etkin Flowlar:
- Standard Flow
- Implicit Flow
- Direct Access Grants
Root URL: https://dlp.srv.world:5000
Valid Redirect URIs: https://dlp.srv.world:5000/*
Web Origins: +
Admin URL: https://dlp.srv.world:5000

PKCE Ayarı

Code Challenge Method: S256

User Attribute Tanımları

Keycloak > Realm Settings > User Profile alanından aşağıdaki attribute'lar eklenmelidir:

openstack-user-domain
openstack-default-project

Client Scope ve Mapper

keystone adlı bir Client Scope oluşturun
Mapper olarak aşağıdaki iki alan tanımlanmalı:
- openstack-user-domain
- openstack-default-project

Kullanıcı Attribute'leri

Her kullanıcı için yukarıdaki attribütler manuel olarak doldurulmalıdır:

2. Adım: Keystone Yapılandırması

Identity Provider Tanımı

openstack identity provider create --remote-id https://auth.keycloak.local/realms/master keycloak

Mapping Tanımı (mapping.json)

[
  {
    "local": [
      {
        "user": {
          "name": "{0}",
          "email": "{1}",
          "domain": {
            "name": "{2}"
          }
        },
        "domain": {
          "name": "{2}"
        },
        "projects": [
          {
            "name": "{3}",
            "roles": [
              {
                "name": "member"
              }
            ]
          }
        ]
      }
    ],
    "remote": [
      { "type": "OIDC-preferred_username" },
      { "type": "OIDC-email" },
      { "type": "OIDC-openstack-user-domain" },
      { "type": "OIDC-openstack-default-project" }
    ]
  }
]

Mapping Oluşturma

openstack mapping create --rules mapping.json mymapping

Protocol Oluşturma

openstack federation protocol create openid --mapping mymapping --identity-provider keycloak

3. Adım: Apache OIDC Konfigürasyonu

Apache sunucusundaki uygun .conf dosyasına aşağıdaki satırlar eklenmelidir:

OIDCSSLValidateServer Off
OIDCOAuthSSLValidateServer Off
OIDCCookieSameSite Off
WSGIPassAuthorization On

OIDCStateTimeout 300
OIDCClaimPrefix "OIDC-"
OIDCResponseType "id_token token"
OIDCScope "openid email profile"
OIDCProviderMetadataURL "https://auth.keycloak.local/realms/master/.well-known/openid-configuration"
OIDCClientID "keystone"
OIDCClientSecret "<KEYCLOAK_CLIENT_SECRET>"

OIDCPKCEMethod "S256"
OIDCCryptoPassphrase "openstack"
OIDCRedirectURI "https://dlp.srv.world:5000/v3/auth/OS-FEDERATION/websso/openid"
OIDCOAuthVerifyJwksUri "https://auth.keycloak.local/realms/master/protocol/openid-connect/certs"

<Location "/v3/auth/OS-FEDERATION/websso/openid">
    AuthType "openid-connect"
    Require valid-user
</Location>

<Location "/v3/auth/OS-FEDERATION/identity_providers/keycloak/protocols/openid/websso">
    AuthType "openid-connect"
    Require claim preferred_username
</Location>

<Location "/v3/auth/OS-FEDERATION/identity_providers/keycloak/protocols/openid/auth">
    AuthType "openid-connect"
    Require valid-user
</Location>

LogLevel auth_openidc:debug

4. Adım: Keystone Konfigürasyonu

/etc/keystone/keystone.conf içerisine aşağıdakiler eklenmelidir:

[auth]
methods = password,token,openid

[federation]
remote_id_attribute = HTTP_OIDC_ISS
trusted_dashboard = https://dlp.srv.world/horizon/auth/websso/

systemctl restart apache2

5. Adım: Horizon Entegrasyonu

/etc/openstack-dashboard/local_settings.py dosyasının sonuna ekleyin:

WEBSSO_ENABLED = True
WEBSSO_INITIAL_CHOICE = "OIDC"

WEBSSO_CHOICES = (
    ("OIDC", "Login with Keycloak"),
    ("credentials", "Keystone Credentials"),
)

WEBSSO_IDP_MAPPING = {
    "OIDC": ("keycloak", "openid")
}

OPENSTACK_KEYSTONE_MULTIDOMAIN_SUPPORT = True
OPENSTACK_KEYSTONE_DEFAULT_DOMAIN = "Default"

OPENSTACK_API_VERSIONS = {
    "identity": 3,
}

REMOTE_USER_CLAIM = "OIDC-preferred_username"

systemctl restart apache2

Horizon arayüzünde "Login with Keycloak" ile giriş yapılabilir.

Sonuç

Bu yapılandırma sayesinde kullanıcılar, OpenStack Horizon arayüzünden Keycloak hesabı ile giriş yapabilir. Aynı zamanda CLI üzerinden federated token kullanarak OpenStack kaynaklarına erişim sağlanabilir.

Resource Owner Password Credentials Grant (CLI Üzerinden Erişim)

Eğer Horizon yerine CLI ile erişim tercih edilecekse v3oidcpassword yöntemi kullanılabilir. Bunun için aşağıdaki örnekteki gibi bir clouds.yaml dosyası oluşturulmalıdır:

clouds:
  federated:
    auth_type: v3oidcpassword
    auth:
      auth_url: https://dlp.srv.world:5000
      username: admin
      password: admin
      identity_provider: keycloak
      protocol: openid
      client_id: keystone
      client_secret: cbFMos3ehMrxvOg0MYEA8gomVdCWj5wR
      discovery_endpoint: https://auth.keycloak.local/realms/master/.well-known/openid-configuration
      project_name: demo
      project_domain_name: Default
    verify: false

CLI Komutu ile Giriş:

openstack --os-cloud federated token issue

Bu komut başarılı olursa Keycloak üzerinden federated kullanıcı ile kimlik doğrulama sağlanmış olacaktır.