AI Blogs

Tunahan ÖZCAN


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

.NET Core Mikroservis Projelerinde Ocelot ile Yetkilendirme

.NET Core Mikroservis Projelerinde Ocelot ile Load Balance Uygulama