AI Blogs

Tunahan ÖZCAN


Makine öğrenimi (ML) modellerini geliştirmek ve eğitmek karmaşık bir süreçtir. Bu modelleri güvenilir bir şekilde dağıtmak ve çalıştırmak da ayrı bir zorluktur. İşte bu noktada Docker devreye giriyor. Docker, modellerinizi ve bağımlılıklarını tutarlı bir şekilde paketlemenize, dağıtmanıza ve çalıştırmanıza olanak tanıyan güçlü bir araçtır. Bu makalede, Docker Model Runner'ın ne olduğunu, nasıl kurulduğunu ve örnek kullanımlarını inceleyeceğiz.

## Docker Model Runner Nedir?

Docker Model Runner, makine öğrenimi modellerinizi Docker konteynerleri içinde çalıştırmanıza olanak sağlayan bir yaklaşımdır. Bu yaklaşım, modelin bağımlılıklarını, çalışma zamanı ortamını ve kodu tek bir taşınabilir birimde (Docker imajı) birleştirir. Bu sayede, modelinizin farklı ortamlarda (geliştirme, test, üretim) aynı şekilde çalışmasını garanti edebilirsiniz.

**Docker Model Runner'ın Avantajları:**

*   **Tutarlılık:** Modeliniz her ortamda aynı şekilde çalışır, bağımlılık çatışmalarını ortadan kaldırır.
*   **İzolasyon:** Her model kendi konteynerinde çalışır, diğer modelleri veya sistemleri etkilemez.
*   **Taşınabilirlik:** Docker imajları, herhangi bir Docker destekli platformda (bulut, yerel sunucu, hatta Raspberry Pi) çalıştırılabilir.
*   **Ölçeklenebilirlik:** Docker, modellerinizi kolayca ölçeklendirmenize olanak tanır. Kubernetes gibi konteyner orkestrasyon araçlarıyla entegre edilebilir.
*   **Versiyon Kontrolü:** Modelin ve bağımlılıklarının farklı versiyonlarını kolayca yönetebilirsiniz.
*   **Reproducibility (Yeniden Üretilebilirlik):** Modelin nasıl eğitildiğini ve nasıl çalıştığını tam olarak yeniden üretebilirsiniz.

## Kurulum

Docker Model Runner'ı kullanmak için öncelikle Docker'ın kurulu olması gerekir.

**Docker Kurulumu:**

*   **Linux:** Docker'ın resmi web sitesindeki talimatları izleyin: [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/)
*   **macOS:** Docker Desktop'ı indirin ve kurun: [https://www.docker.com/products/docker-desktop/](https://www.docker.com/products/docker-desktop/)
*   **Windows:** Docker Desktop'ı indirin ve kurun: [https://www.docker.com/products/docker-desktop/](https://www.docker.com/products/docker-desktop/)

Kurulumdan sonra, Docker'ın düzgün çalıştığını doğrulamak için aşağıdaki komutu çalıştırın:

```bash
docker --version
```

Bu komut, Docker'ın kurulu sürümünü göstermelidir.

## Örnek Kullanım

Bu örnekte, basit bir Python Flask uygulamasını ve scikit-learn ile eğitilmiş bir makine öğrenimi modelini Dockerize edeceğiz.

**1. Modelin Oluşturulması (model.py):**

```python
# model.py
import pickle
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
import pandas as pd

# Veri kümesi oluştur veya yükle
data = {'X': [1, 2, 3, 4, 5], 'y': [2, 4, 5, 4, 5]}
df = pd.DataFrame(data)

# Veriyi eğitim ve test kümelerine ayır
X_train, X_test, y_train, y_test = train_test_split(df[['X']], df['y'], test_size=0.2, random_state=42)

# Lineer Regresyon modelini eğit
model = LinearRegression()
model.fit(X_train, y_train)

# Modeli kaydet
pickle.dump(model, open('model.pkl', 'wb'))
```

**2. Flask API'sinin Oluşturulması (app.py):**

```python
# app.py
from flask import Flask, request, jsonify
import pickle

app = Flask(__name__)

# Modeli yükle
model = pickle.load(open('model.pkl', 'rb'))

@app.route('/predict', methods=['POST'])
def predict():
    data = request.get_json(force=True)
    prediction = model.predict([[data['X']]])
    return jsonify(prediction[0])

if __name__ == '__main__':
    app.run(port=5000, debug=True)
```

**3. Gereksinimlerin Belirtilmesi (requirements.txt):**

```
Flask
scikit-learn
pandas
gunicorn
```

**4. Dockerfile Oluşturulması (Dockerfile):**

```dockerfile
FROM python:3.9-slim-buster

WORKDIR /app

COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt

COPY . .

EXPOSE 5000

CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:5000"]
```

**Dockerfile Açıklaması:**

*   `FROM python:3.9-slim-buster`: Python 3.9'un hafif bir sürümünü temel alır.
*   `WORKDIR /app`: Çalışma dizinini /app olarak ayarlar.
*   `COPY requirements.txt requirements.txt`: Gereksinimler dosyasını kopyalar.
*   `RUN pip install -r requirements.txt`: Bağımlılıkları yükler.
*   `COPY . .`: Tüm kaynak kodunu kopyalar.
*   `EXPOSE 5000`: 5000 portunu dışarıya açar.
*   `CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:5000"]`: Uygulamayı Gunicorn ile başlatır.  Gunicorn, üretim ortamları için daha uygun bir WSGI sunucusudur.

**5. Docker İmajının Oluşturulması:**

Terminalde Dockerfile'ın bulunduğu dizine gidin ve aşağıdaki komutu çalıştırın:

```bash
docker build -t ml-model-runner .
```

Bu komut, "ml-model-runner" adında bir Docker imajı oluşturur.

**6. Docker Konteynerinin Çalıştırılması:**

Aşağıdaki komutu kullanarak konteyneri çalıştırın:

```bash
docker run -p 5000:5000 ml-model-runner
```

Bu komut, 5000 portunu host makinenizdeki 5000 portuna eşler.

**7. Modeli Test Etme:**

Artık modelinizi test edebilirsiniz. Başka bir terminal penceresinde aşağıdaki curl komutunu çalıştırın:

```bash
curl -X POST -H "Content-Type: application/json" -d '{"X": 6}' http://localhost:5000/predict
```

Bu komut, modele `X` değeri 6 olan bir istek gönderir ve modelin tahminini döndürür.

**Ek Paketler:**

Modelinizin ihtiyaçlarına göre ek paketler yüklemeniz gerekebilir. Örneğin, TensorFlow veya PyTorch kullanıyorsanız, ilgili paketleri `requirements.txt` dosyasına eklemelisiniz.  Resmi paketlere ait dokümantasyonlara aşağıdaki linklerden ulaşabilirsiniz:

*   **TensorFlow:** [https://www.tensorflow.org/install](https://www.tensorflow.org/install)
*   **PyTorch:** [https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)

**Örnek Kod Blogları:**

*   **Logging:** Modelinizin performansını ve hatalarını izlemek için logging mekanizması ekleyin. Python'ın `logging` modülünü kullanabilirsiniz.
*   **Health Check Endpoint:** Konteynerinizin sağlıklı olup olmadığını kontrol etmek için bir health check endpoint'i oluşturun.
*   **Model Versiyonlama:** Modelin farklı versiyonlarını yönetmek için bir versiyonlama stratejisi uygulayın. Git etiketlerini veya Docker imaj etiketlerini kullanabilirsiniz.
*   **Güvenlik:** Konteynerinizi güvenlik açıklarına karşı korumak için güvenlik en iyi uygulamalarını izleyin.

Bu makalede, Docker Model Runner'ın ne olduğunu, nasıl kurulduğunu ve örnek kullanımlarını inceledik. Docker, makine öğrenimi modellerinizi dağıtmak ve çalıştırmak için güçlü bir araçtır. Bu rehberdeki adımları izleyerek, modellerinizi Dockerize etmeye ve avantajlarından yararlanmaya başlayabilirsiniz.


Makine öğrenimi modellerinizi Docker konteynerleri içinde çalıştırmanın avantajları, kurulumu ve örnek kullanımları hakkında kapsamlı bir rehber.

Docker Model Runner, Modellerinizi Dockerize Etme ve Çalıştırma Rehberi


Mikroservis mimarisi, uygulamaları bağımsız, küçük, dağıtılabilir ve ölçeklenebilir hizmetlere bölmeyi amaçlar. Bu yaklaşımın getirdiği karmaşıklıklardan biri de yetkilendirme ve kimlik doğrulama (Authentication & Authorization) işlemlerinin yönetimidir. Ocelot, .NET Core tabanlı mikroservis projelerinde API Gateway olarak kullanılarak bu karmaşıklığı basitleştirir ve merkezi bir yetkilendirme noktası sunar.

### Ocelot Nedir?

Ocelot, .NET Core tabanlı, açık kaynaklı bir API Gateway'dir. Temel olarak gelen istekleri alır, rotalarını belirler, yetkilendirme işlemlerini gerçekleştirir ve ilgili mikroservise yönlendirir. Bu sayede mikroservislerin kendileri kimlik doğrulama ve yetkilendirme mantığıyla uğraşmak zorunda kalmazlar.

### Neden Ocelot Kullanmalıyız?

*   **Merkezi Yetkilendirme:** Yetkilendirme işlemlerini tek bir noktada yöneterek mikroservislerin karmaşıklığını azaltır.
*   **Rota Yönetimi:** Gelen istekleri doğru mikroservise yönlendirerek yük dengeleme ve yönlendirme işlemlerini kolaylaştırır.
*   **Güvenlik:** API'lerinizi yetkisiz erişime karşı korur.
*   **Ölçeklenebilirlik:** Yüksek trafikli ortamlarda performansı artırır.

### Temel Kavramlar

*   **Authentication (Kimlik Doğrulama):** Kullanıcının kimliğini doğrulama işlemidir. Genellikle kullanıcı adı ve şifre veya token tabanlı yöntemlerle yapılır.
*   **Authorization (Yetkilendirme):** Kullanıcının belirli bir kaynağa erişim yetkisinin olup olmadığını kontrol etme işlemidir.
*   **API Gateway:** Mikroservisler önünde duran, gelen istekleri yöneten ve yönlendiren bir ara katmandır.

### Ocelot ile Yetkilendirme Adımları

1.  **Ocelot Projesi Oluşturma:** Yeni bir .NET Core Web API projesi oluşturun ve gerekli Ocelot paketlerini yükleyin.
2.  **Ocelot Konfigürasyonu:** `ocelot.json` dosyası ile rotaları ve yetkilendirme kurallarını tanımlayın.
3.  **Yetkilendirme Middleware'i:** Ocelot middleware'ini kullanarak yetkilendirme işlemlerini gerçekleştirin.
4.  **Mikroservis Entegrasyonu:** Mikroservislerinizi Ocelot üzerinden erişilebilir hale getirin.

### Gerekli Paketler

Aşağıdaki NuGet paketlerini projenize eklemeniz gerekmektedir:

*   **Ocelot:** API Gateway işlevselliğini sağlar.  [https://www.nuget.org/packages/Ocelot](https://www.nuget.org/packages/Ocelot)
*   **Microsoft.AspNetCore.Authentication.JwtBearer:** JWT tabanlı kimlik doğrulama için gereklidir (eğer JWT kullanıyorsanız). [https://www.nuget.org/packages/Microsoft.AspNetCore.Authentication.JwtBearer](https://www.nuget.org/packages/Microsoft.AspNetCore.Authentication.JwtBearer)

### Örnek Kod Blokları

**1. Ocelot Projesi Oluşturma ve Paketleri Yükleme:**

```bash
dotnet new webapi -n OcelotGateway
cd OcelotGateway
dotnet add package Ocelot
dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
```

**2. `Program.cs` Dosyası:**

```csharp
using Ocelot.DependencyInjection;
using Ocelot.Middleware;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

var builder = WebApplication.CreateBuilder(args);

//Ocelot.json dosyasını konfigürasyon dosyasına ekleme
builder.Configuration.AddJsonFile("ocelot.json", optional: false, reloadOnChange: true);

//JWT Bearer kimlik doğrulamasını yapılandırma
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
        };
    });

//Ocelot servislerini ekleme
builder.Services.AddOcelot(builder.Configuration);

var app = builder.Build();

app.UseAuthentication(); // Authentication'ı aktifleştir
app.UseAuthorization(); // Authorization'ı aktifleştir

//Ocelot middleware'ini ekleme
app.UseOcelot().Wait();

app.Run();
```

**3. `ocelot.json` Konfigürasyon Dosyası:**

```json
{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/products",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5001 //Product Service portu
        }
      ],
      "UpstreamPathTemplate": "/products",
      "UpstreamHttpMethod": [ "Get", "Post" ],
      "AuthenticationOptions": {
        "AuthenticationProviderKey": "Bearer",
        "AllowedScopes": []
      },
      "RateLimitOptions": {
        "EnableRateLimiting": true,
        "Period": "1s",
        "PeriodTimespan": 1,
        "Limit": 10
      }
    },
     {
      "DownstreamPathTemplate": "/api/users",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "localhost",
          "Port": 5002 //User Service portu
        }
      ],
      "UpstreamPathTemplate": "/users",
      "UpstreamHttpMethod": [ "Get", "Post" ] ,
       "AuthenticationOptions": {
        "AuthenticationProviderKey": "Bearer",
        "AllowedScopes": []
      },
      "RateLimitOptions": {
        "EnableRateLimiting": true,
        "Period": "1s",
        "PeriodTimespan": 1,
        "Limit": 10
      }
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:5000" //Ocelot Gateway'in adresi
  }
}
```

**Açıklama:**

*   **Routes:** Rotaların tanımlandığı bölümdür.
    *   **DownstreamPathTemplate:** Mikroservisin endpoint'i.
    *   **DownstreamScheme:** Protokol (http/https).
    *   **DownstreamHostAndPorts:** Mikroservisin çalıştığı adres ve port.
    *   **UpstreamPathTemplate:** API Gateway üzerinden erişilecek endpoint.
    *   **UpstreamHttpMethod:** İzin verilen HTTP metotları.
    *   **AuthenticationOptions:** Yetkilendirme ayarları. `AuthenticationProviderKey` ile hangi kimlik doğrulama şemasının kullanılacağı belirtilir.
    *   **RateLimitOptions:** İstek sınırlama ayarları.
*   **GlobalConfiguration:** Genel ayarlar.
    *   **BaseUrl:** Ocelot Gateway'in çalıştığı adres.

**4. Mikroservislerde Kimlik Doğrulama (Örnek):**

Mikroservislerinizde de JWT kimlik doğrulamasını yapılandırmanız gerekir.  Bu kısım mikroservislerin kendi sorumluluğundadır ve Ocelot bu kimlik doğrulama işlemini tetiklemez, sadece gelen token'ı doğrular.  Örnek bir Product servis yapılandırması:

```csharp
//Product Service Program.cs
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

var builder = WebApplication.CreateBuilder(args);

//JWT Bearer kimlik doğrulamasını yapılandırma
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
        };
    });

builder.Services.AddControllers(); // Controller'ları ekleme

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

app.MapControllers(); // Controller'ları route'lara eşleme

app.Run();
```

**5.  JWT Token Üretimi (Örnek):**

Kimlik doğrulama servisinizde JWT token üretimi yapmanız gerekecektir. Bu örnek, bir JWT token oluşturma işlemini gösterir:

```csharp
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

public string GenerateJwtToken(string userId)
{
    var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]!));
    var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

    var claims = new[] {
        new Claim(ClaimTypes.NameIdentifier, userId),
        new Claim(ClaimTypes.Role, "User") //Örnek rol
    };

    var token = new JwtSecurityToken(_configuration["Jwt:Issuer"],
        _configuration["Jwt:Audience"],
        claims,
        expires: DateTime.Now.AddMinutes(120), //Token geçerlilik süresi
        signingCredentials: credentials);

    return new JwtSecurityTokenHandler().WriteToken(token);
}
```

**6.  Yetkilendirme (Roles & Policies):**

Daha detaylı yetkilendirme senaryoları için (örneğin, belirli rollere sahip kullanıcıların belirli endpoint'lere erişebilmesi), `[Authorize]` attribute'unu ve policy'leri kullanabilirsiniz.

```csharp
[Authorize(Roles = "Admin")] //Sadece Admin rolüne sahip kullanıcılar erişebilir.
[HttpGet]
public IActionResult GetAdminData()
{
    return Ok("Admin data");
}
```

Veya policy bazlı yetkilendirme:

```csharp
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("RequireAdminRole", policy =>
        policy.RequireRole("Admin"));
});

//...

[Authorize(Policy = "RequireAdminRole")]
[HttpGet]
public IActionResult GetAdminData()
{
    return Ok("Admin data");
}
```

**Sonuç:**

Ocelot, .NET Core mikroservis projelerinde yetkilendirme ve kimlik doğrulama işlemlerini merkezi bir şekilde yönetmek için güçlü bir araçtır. Yukarıdaki adımları izleyerek ve örnek kodları adapte ederek mikroservislerinizi güvenli bir şekilde Ocelot üzerinden erişilebilir hale getirebilirsiniz. Unutmayın, JWT token üretimi ve yönetimi kimlik doğrulama servisinizin sorumluluğundadır. Ocelot ise sadece gelen token'ın geçerliliğini doğrular ve rotalama işlemini gerçekleştirir. Bu örnekler temel bir rehber niteliğindedir.  Gerçek dünya senaryolarında, güvenlik ve ölçeklenebilirlik gereksinimlerinize göre daha karmaşık konfigürasyonlar gerekebilir.

.NET Core mikroservis mimarisinde Ocelot kullanarak yetkilendirme işlemlerinin nasıl yapıldığına dair temel bilgiler ve örnek kodlar.

.NET Core Mikroservis Projelerinde Ocelot ile Yetkilendirme


Mikroservis mimarisi, uygulamaları küçük, bağımsız ve ölçeklenebilir parçalara ayırarak geliştirme, dağıtım ve yönetim süreçlerini kolaylaştırır. Ancak, bu mimari ile birlikte gelen karmaşıklıkları yönetmek için API Gateway gibi araçlara ihtiyaç duyulur. Ocelot, .NET Core tabanlı bir API Gateway çözümüdür ve yük dengeleme (load balancing) gibi birçok özelliği bünyesinde barındırır. Bu makalede, .NET Core mikroservis projelerinde Ocelot ile nasıl yük dengeleme uygulayacağımızı adım adım inceleyeceğiz.

### Temel Kavramlar

*   **Mikroservis:** Uygulamanın bağımsız, küçük parçalara ayrılmış halidir. Her bir servis, belirli bir işlevselliği yerine getirir ve kendi veritabanına sahip olabilir.
*   **API Gateway:** Mikroservisler önünde duran ve istemcilerden gelen istekleri uygun servislere yönlendiren bir katmandır. Ocelot, popüler bir .NET Core API Gateway çözümüdür.
*   **Load Balance (Yük Dengeleme):** Gelen istekleri birden fazla sunucuya dağıtarak, tek bir sunucunun aşırı yüklenmesini önler ve uygulamanın performansını artırır.

### Ocelot'un Avantajları

*   **Yönlendirme:** İstekleri belirli kurallara göre mikroservislere yönlendirir.
*   **Kimlik Doğrulama ve Yetkilendirme:** İstekleri doğrular ve yetkilendirme işlemlerini gerçekleştirir.
*   **Yük Dengeleme:** İstekleri birden fazla sunucuya dağıtır.
*   **Rate Limiting (Hız Sınırlandırma):** İstek sayısını belirli bir süre içinde sınırlar.
*   **Caching (Önbellekleme):** Sık erişilen verileri önbelleğe alarak performansı artırır.

### Proje Yapısı

Bu makalede, basit bir e-ticaret uygulamasının mikroservis mimarisini örnek olarak kullanacağız.

*   **Ürün Servisi (Product Service):** Ürün bilgilerini yöneten servis.
*   **Sipariş Servisi (Order Service):** Sipariş işlemlerini yöneten servis.
*   **Ocelot API Gateway:** İstemcilerden gelen istekleri uygun servislere yönlendiren API Gateway.

### Adım 1: .NET Core Projelerini Oluşturma

İlk olarak, gerekli .NET Core projelerini oluşturalım.

1.  **Ürün Servisi (ProductService):**

    ```bash
    dotnet new webapi -n ProductService
    ```

2.  **Sipariş Servisi (OrderService):**

    ```bash
    dotnet new webapi -n OrderService
    ```

3.  **Ocelot API Gateway (ApiGateway):**

    ```bash
    dotnet new webapi -n ApiGateway
    ```

### Adım 2: Ocelot Paketini Kurma

ApiGateway projesine Ocelot paketini kuralım.

```bash
dotnet add package Ocelot
```

[Ocelot NuGet Paketi](https://www.nuget.org/packages/Ocelot/)

### Adım 3: Ocelot Yapılandırma Dosyasını Oluşturma (ocelot.json)

ApiGateway projesinde `ocelot.json` adında bir yapılandırma dosyası oluşturalım. Bu dosya, yönlendirme ve yük dengeleme kurallarını tanımlayacaktır.

```json
{
  "Routes": [
    {
      "UpstreamPathTemplate": "/products/{everything}",
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ],
      "DownstreamPathTemplate": "/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "productservice",
          "Port": 5001
        },
        {
          "Host": "productservice2",
          "Port": 5001
        }
      ],
      "LoadBalancerOptions": {
        "Type": "LeastConnection"
      }
    },
    {
      "UpstreamPathTemplate": "/orders/{everything}",
      "UpstreamHttpMethod": [ "Get", "Post", "Put", "Delete" ],
      "DownstreamPathTemplate": "/{everything}",
      "DownstreamScheme": "http",
      "DownstreamHostAndPorts": [
        {
          "Host": "orderservice",
          "Port": 5002
        }
      ]
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:5000"
  }
}
```

*   **Routes:** Yönlendirme kurallarını tanımlar.
    *   **UpstreamPathTemplate:** İstemcinin erişeceği URL şablonu.
    *   **UpstreamHttpMethod:** İzin verilen HTTP metotları.
    *   **DownstreamPathTemplate:** Mikroservise yönlendirilecek URL şablonu.
    *   **DownstreamScheme:** Kullanılacak protokol (http veya https).
    *   **DownstreamHostAndPorts:** Mikroservislerin adresleri ve portları.  Birden fazla tanımlama olduğunda load balance devreye girer.
    *   **LoadBalancerOptions:** Yük dengeleme seçenekleri.
        *   **Type:** Yük dengeleme algoritması (örn. `LeastConnection`, `RoundRobin`).

### Adım 4: Ocelot'u Başlatma

`Program.cs` dosyasında Ocelot'u yapılandıralım.

```csharp
using Ocelot.DependencyInjection;
using Ocelot.Middleware;

var builder = WebApplication.CreateBuilder(args);

builder.Configuration.AddJsonFile("ocelot.json", optional: false, reloadOnChange: true);

builder.Services.AddOcelot();

var app = builder.Build();

await app.UseOcelot();

app.Run();
```

Bu kod bloğu şunları yapar:

1.  `ocelot.json` dosyasını yapılandırmaya ekler.
2.  `AddOcelot()` metodu ile Ocelot servislerini ekler.
3.  `UseOcelot()` metodu ile Ocelot middleware'ini pipeline'a ekler.

### Adım 5: Mikroservisleri Çalıştırma

ProductService ve OrderService projelerini ayrı portlarda (örneğin, 5001 ve 5002) çalıştıralım.  ApiGateway projesini de 5000 portunda çalıştıralım.  Yukarıdaki `ocelot.json` dosyasında ProductService için iki adet instance tanımladık: `productservice` ve `productservice2`.  Bu iki instance'ı temsil eden iki farklı ProductService projesini farklı portlarda çalıştırmanız (örneğin, 5003 ve 5004) ve hostname'lerini (productservice ve productservice2) host dosyanıza eklemeniz gerekecektir.

**Önemli Not:** Windows'ta host dosyasını düzenlemek için yönetici ayrıcalıklarına sahip bir metin editörü kullanmanız gerekir.  Host dosyası genellikle şu konumdadır: `C:\Windows\System32\drivers\etc\hosts`.

Host dosyasına şu satırları ekleyin:

```
127.0.0.1   productservice
127.0.0.1   productservice2
```

Bu, `productservice` ve `productservice2` hostname'lerinin yerel makineye (127.0.0.1) çözümlenmesini sağlar.  Bu sayede Ocelot, ProductService'in farklı instance'larına erişebilir.  Şimdi ProductService projelerinizden birini 5003 portunda, diğerini ise 5004 portunda çalıştırabilirsiniz.  `ocelot.json` dosyasında ise ProductService instance'larının portlarını 5001 olarak tutmaya devam edebilirsiniz.  Bu, Ocelot'un, ProductService instance'larına aynı port üzerinden eriştiği yanılgısını yaratır, ancak aslında trafik farklı portlarda çalışan instance'lara yönlendirilir.

### Adım 6: Test Etme

Şimdi tarayıcınızda `http://localhost:5000/products/123` adresine giderek ProductService'e erişmeyi deneyebilirsiniz. Ocelot, isteği ProductService'e yönlendirecek ve yanıtı size geri gönderecektir. Eğer birden fazla ProductService instance'ı çalışıyorsa (örneğin 5003 ve 5004 portlarında), Ocelot yük dengeleme algoritmasına göre istekleri bu instance'lar arasında dağıtacaktır.  Aynı şekilde `http://localhost:5000/orders/456` adresine giderek OrderService'e erişebilirsiniz.

### Load Balance Algoritmaları

Ocelot, farklı yük dengeleme algoritmalarını destekler. `LoadBalancerOptions` bölümünde `Type` özelliğini değiştirerek farklı algoritmaları kullanabilirsiniz.

*   **LeastConnection:** En az bağlantısı olan sunucuya isteği yönlendirir.
*   **RoundRobin:** İstekleri sunucular arasında sırayla dağıtır.
*   **NoLoadBalance:** Yük dengeleme yapmaz, ilk sunucuya tüm istekleri gönderir.

### Sonuç

Bu makalede, .NET Core mikroservis projelerinde Ocelot kullanarak yük dengeleme uygulamasının temel adımlarını inceledik. Ocelot, mikroservis mimarisinde API Gateway olarak kullanıldığında birçok avantaj sağlar ve uygulamanın ölçeklenebilirliğini ve performansını artırır. Farklı yük dengeleme algoritmalarını kullanarak uygulamanızın ihtiyaçlarına en uygun çözümü bulabilirsiniz.

.NET Core mikroservis mimarisinde Ocelot kullanarak load balance (yük dengeleme) uygulamasını adım adım anlatan bir rehber.

AI Blogs

Docker Model Runner, Modellerinizi Dockerize Etme ve Çalıştırma Rehberi

.NET Core Mikroservis Projelerinde Ocelot ile Yetkilendirme

.NET Core Mikroservis Projelerinde Ocelot ile Load Balance Uygulama