Giriş

Öz yinelemeli fonksiyonlar kendi içerisinde tekrar tekrar kendisini çağıran fonksiyonlardır. Tam da bu yüzden bu algoritmaların analizini yapmak standart fonksiyonlara göre daha zahmetlidir.

Algoritma analizi kapsamında recursive olmayan fonksiyonların analizi standart yöntemlerle kolay bir şekilde gerçekleştirilebilirken recursive fonksiyonlarda işler biraz karışabiliyor. Bu fonksiyonların analizini gerçekleştirmek için birkaç yöntem bulunmaktadır. Bu yazıda bir özyinelemeli algoritmanın analiz analiz yöntemlerinden bahsederek Iteration Methodu ile Hanoi Kuleleri algoritmasının analizini gerçekleştireceğiz.

Temel olarak 2 adım ile bu fonksiyonların analizi gerçekleştirilebilir:

1. Algoritmanın zamana bağlı denkleminin T(n) elde edilmesi.
2. Elde edilen denklemin Substitution, Iterasyon, Recursion Tree veya Master yöntemleriyle çözülmesi.

Birinci adım için daha önce yazmış olduğum Recursive (Özyinelemeli) Fonksiyonlarda Zaman Denklemini Bulma yazımı okuyabilirsiniz.

Bu yazıda ikinci adım olan T(n)‘i bilinen bir algoritmanın Iteration teoremini kullanarak analizini gerçekleştireceğiz.

Iteration (İterasyon-Yineleme) Metodu

Iteration metodu, bir recursive denklemi çözmek için kullanılan tekniklerden biridir. T(n) denklemini ardışık adımlarla açarak, fonksiyonun kapalı formunu (closed form) elde etmeye çalışır. Bu yöntemin temel adımları şu şekilde sıralanabilir:

1. T(n) denkleminin bulunması
2. Bulunan T(n)’in tekrar tekrar açılması
3. Genelleme yapılması, genel bir ifade bulunması
4. Durdurma koşulunun hesaplanması
5. Kapalı formun elde edilmesi

Şimdi bu adımları Hanoi Kuleleri algoritması üzerinde sırayla gerçekleştireceğiz. Analize geçmeden önce kısaca Hanoi Kuleleri algoritmasına değinebiliriz.

Hanoi Kuleleri Algoritması

Kısaca bir çubuk üzerindeki blokları diğer çubuğa en altta en büyük en üstte ise en küçük blok olacak şekilde taşınmasını hedefleyen algoritmadır ve aşağıdaki görsel ile anlatılabilir. Yalnız bu işlemi gerçekleştirmek için 2 kural bulunuyor. Her hamlede yalnızca 1 blok hareket ettirilebilir ve hiçbir hamlede küçük bir bloğun üstünde büyük bir blok olamaz.

Bu algoritmayı koda dökecek olursak aşağıdaki gibi bir recursive fonksiyon yazabiliriz. Blokları A çubuğundan C çubuğuna taşımak istiyoruz.

package main

func main() {
	hanoi(3, "A", "C", "B")
}

func hanoi(n int, from, to, aux string) {
	if n >= 1 {
		hanoi(n-1, from, aux, to)
		move(from, to)
		hanoi(n-1, aux, to, from)
	}
}

func move(from, to string) {
	println("Move disk from", from, "to", to)
}

Şimdi analiz adımlarına geçebiliriz.

1) T(n) denkleminin bulunması

Recursive fonksiyon çağırımlarının ikisi de n-1 kez çalışacaktır. Dolayısıyla ikisine de T(n-1) diyebiliriz. ortadaki move fonksiyonu ise herhangi bir recursive çağırım yapmadığı için O(1) diyebiliriz. Oluşan ifadeleri topladığımızda T(n) denklemini T(n)=2T(n-1)+1 şeklinde elde ederiz.

2) Bulunan T(n)’in Tekrar Tekrar Açılması

Denklemimizde O(1) yerine sabit olarak c yazabiliriz. Ardından n yerine birkaç kez fonksiyonun kendi değerini yazarak tekrar tekrar açtığımızda aşağıdaki gibi 8T(n-3)+7c ifadesini elde edeceğiz.

3) Genelleme yapılması, genel bir ifade bulunması

Elde ettiğimiz T(n)=8T(n-3)+7c ifadesini biraz düzenleyelim. 8 yerine 2^3 ve 7 yerine 2^3 – 1 yazabiliriz. İfademizin son hali şöyle olur:

Fark edildiği üzere bu ifadede 3 sayısı ortak bir hale geldi. 3 yerine k yazalım. Şu ifadeyi elde ederiz:

Böylelikle ifadeyi genelleştirerek değişkenli bir hale dönüştürdük. Sonraki adıma geçebiliriz.

4) Durdurma koşulunun hesaplanması

Durdurma koşulunun hesaplanması adımı ifadede T içerisini sıfıra eşitlemekten geçer. Yani n-k = 0 ifadesini çözmemiz gerekir. Sonuç olarak n=k elde ederiz. Durdurma koşulumuzu n olarak elde ettik.

5) Kapalı formun elde edilmesi

Son adımda ise bir önceki adıma bulduğumuz durdurma koşulunu denklemde k yerine yazmamız gerekiyor.

Eğer T(0)=0 ise;

Sabitler asimptotik büyüme hızını etkilemeyeceğinden dolayı yaptığımız analiz sonucu algoritmanın çalışma süresi O(2^n) elde edilir.

Recursive (Özyinelemeli) Fonksiyon Analizi #1 Iteration Method (Tekrarlama Yöntemi) yazısı ilk önce Görkem Rıdvan ARIK üzerinde ortaya çıktı.

Recursive (özyinelemeli) algoritmaların analizini gerçekleştirme yöntemleri olan iteration, substition, master ve recurrence yöntemlerini kullanabilmek için öncellikle fonksiyonun zaman denkleminin T(n) cinsinden elde edilmesi gerekmektedir.

Oldukça basit bir işlem olmakla birlikte ana gereksinim analiz edilmek istenen algoritmanın çalışma mantığının kavranmasıdır. Bu makalede Binary Search algoritmasının öz yinelemeli fonksiyonu üzerinden örnekler ile T(n) denklemini elde edeceğiz.

İzlenecek Yol

Örneklere geçmeden önce teorik olarak izleyeceğimiz adımlardan bahsetmek gerekirse fonksiyonumuzu satır satır okuyacağız ve çalışma mantığını anlayacağız. Daha sonra sabitler, döngüler ve kendini çağırmalar için denklem değişkenlerini yerine koyacağız.

Binary Search Algoritmasının Zaman Denklemini Elde Etme

Binary search algoritması bilindiği üzere sıralı elemanlardan oluşan sayı kümesinde bir arama işlemi gerçekleştirir. Önce kümenin tam ortasındaki elemana bakar ve aranan eleman o ise geri döndürülür. Aranan eleman ortadaki elemandan büyükse kümenin ortasından sonuna kadar olan kısmında aynı işlem tekrarlanır. Aranan eleman küçük ise de kümenin başlangıcından ortadaki elemana kadar olan kısım alınarak tekrarlanır.

int binarySearch(int arr[], int left, int right, int x)
{
    if (right >= left) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == x)
            return mid;
        if (arr[mid] > x)
            return binarySearch(arr, left, mid - 1, x);
        return binarySearch(arr, mid + 1, right, x);
    }
    return -1;
}

Algoritmayı anladıktan sonra koda geçecek olursak ilk önce bir if kontrolü yapılıyor. Bu sabite O(1) diyebiliriz. Bu if içerisinde ise bir değişken ataması yapılarak başka bir if kontrolü yapılmış. Bu iki satır da sabit oldukları için kendilerine O(1) diyebiliriz.

Sabit kısımların ardından asıl önemli kısım olan recursive kısım gelmektedir. if (arr[mid] > x) kontrolünün şartı sağlanırsa yani dizinin ortasındaki eleman aranan sayıdan büyükse fonksiyon kendisini çağırıyor ve parametre olarak dizinin ilk elemanından orta elemanına kadar olan kısım veriliyor. Yani artık eleman sayısı yarıya inmiş durumda.

Bu if şartı sağlanmıyor ise dizinin ortasındaki eleman aranan sayıdan küçük veya eşit demektir. Böylelikle kümenin ortasından sonuna kadar olan kısım parametre olarak verilerek aynı işlemler tekrarlanıyor.

İki recursive çağırım da şarta bağlı olduğundan aslında yalnızca bir kez recursive çağırım yapılıyor. Ayrıca iki çağırımda da eleman sayısı yarıya iniyor. Dolayı koddaki işaretlenmiş recursive kısmına T(n/2) diyebiliriz.

En sonda ise elemanın bulunmama durumunda -1 sayısı döndürülüyor. Buna da O(1) diyebiliriz.

Bu adımların ardından zaman denklemimizi aslında yazdık. Toparlayacak olursak toplamda 4 kez O(1) sonucuna ve 1 kere T(n/2) sonucuna ulaştık. Buna göre T(n) denklemimiz:

T(n) = T(n/2) + 4O(1)

Elde ederiz. O(1)’ler sabit olduğu için direkt c dersek denklemin son hali:

T(n) = T(n/2) + c

Elde etmiş oluruz.

Sonuç

Bu yazıda Binary Search algoritmasının recurisve fonksiyonu için zaman fonksiyonunu yazdık. Özet olarak algoritmanın çalışma prensibini tespit ettikten sonra recursive çağırımların kaç kez çalıştığını saptamak denklemi yazmanın büyük bir kısmını oluşturmaktadır. Sabitler de eklenerek denklem kolayca elde edilmektedir.

Sonraki yazılarda bu elde ettiğimiz denklemi çeşitli yöntemler kullanarak çözerek algoritma analizini gerçekleştireceğiz.

Recursive (Özyinelemeli) Fonksiyonlarda Zaman Denklemini Bulma yazısı ilk önce Görkem Rıdvan ARIK üzerinde ortaya çıktı.

Dil Değişiklikleri

Go 1.21 sürümü ile min, max ve clear olmak üzere 3 yeni yerleşik (built-in) fonksiyon eklendi. İsimlerinden de anlaşılacağı üzere min fonksiyonu kendisine parametre olarak verilen değerler arasından en küçük olanı döndürürken max fonksiyonu kendisine verilen parametreler arasından en büyük değeri döndürmektedir. clear fonksiyonu ise parametre olarak map, slice ve type parameter alarak bunların tüm öğelerini siler veya sıfırlar. Bu fonksiyonlara birer örnek verecek olursak;

x := min(1, -5, 3, 2, 0)
fmt.Println(x)
// Output: -5

y := max(1, -5, 3, 2, 0)
fmt.Println(y)
// Output: 3

cities := map[string]int{
 "Adana":  1,
 "Ankara": 6,
 "Istanbul": 34,
}
fmt.Println(cities)
clear(cities)
fmt.Println(cities)
// Output: 
// map[Adana:1 Ankara:6 Istanbul:34]
// map[]

Go Komutu ve Flag Güncellemeleri

• -pgo derleme flag’i varsayılan olarak -pgo=auto olarak ayarlandı.
• Komut satırında yalnızca tek bir ana paketi belirtme kısıtlaması kaldırıldı.
• Ana paketin dizininde default.pgo adında bir dosya bulunuyorsa bu dosya otomatik olarak optimizasyonu etkinleştirmek için kullanılacak.
• go test komutu için -fullpath parametresi eklendi. Bu sayede log mesajlarında tam yolun yazdırılma opsiyonu eklendi.

Derleyici

• Go 1.20 sürümünde önizleme olarak eklenen profile-guide optimization (PGO) 1.21.0 sürümü ile birlikte genel kullanıma hazır hale getirildi. Bununla birlikte temsili bir Go programında PGO etkinleştirilirse %2 ile %7 arasında iyileşme görülebileceği belirtiliyor. PGO hakkında daha detaylı bilgi için bağlantıdan dokümanlara ulaşabilirsiniz.
• Ayrıca Go 1.21.0 sürümü ile derleyicinin kendisini PGO ile oluşturması sayesinde build alma hızının %6’ya kadar arttığı belirtiliyor.

Yeni Kütüphane Paketleri

log/slog Paketi

Yeni paketin popüler log analiz araçları ve servisler ile entegre desteği olmasıyla beraber Go’da loglama işlemleri için kullanılan 3. parti kütüphanelerin kullanımı azalacak gibi görünüyor. Yapısal loglama (structured logging) anahtar/değer çiftleri ile gerçekleştirildiğinden dolayı büyük miktardaki log kayıtlarının hızlı ve doğru bir şekilde işlenmesi sağlanıyor.

Paket için ufak bir örnek yapacak olursak aşağıdaki kullanılan Info fonksiyonunun imzası slog.Info(msg string, args …any) şeklindedir. Görüldüğü üzere ilk parametre log mesajıdır. diğer parametreler ise anahtar-değer çiftlerini temsil eder.

package main

import "log/slog"

func main() {
	slog.Info("Yetkisiz erişim", "Ad", "John", "Soyad", "Doe")
}
// Output: 
// 2023/09/05 21:07:14 INFO Yetkisiz erişim Ad=John Soyad=Doe

Ayrıca çıktı formatında daha çok hakimiyet için slog.New(h handler) *Logger imzalı bir fonksiyon da bulunuyor. Bu fonksiyon ile ihtiyaç duyulan handler belirtilerek logger örneği oluşturulabiliyor. Örneğin alttaki örnekte JSONHandler kullanarak bir logger örneği bulunuyor.

package main

import (
	"log/slog"
	"os"
)

func main() {
	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
	logger.Info("Yetkisiz erişim", "Ad", "John", "Soyad", "Doe")
}

// Output:
// {"time":"2023-09-05T21:10:29.2848066+03:00","level":"INFO","msg":"Yetkisiz erişim","Ad":"John","Soyad":"Doe"}

Örnekler ve slog paketi hakkında detaylı bilgi için dokümanları inceleyebilirsiniz.

testing/slogtest Paketi

Bu paketin slog.Handler implementasyonlarını doğrulamaya yardımcı olabilmesi amacıyla eklendiği belirtiliyor. Paketin içerisinde func TestHandler(h slog.Handler, results func() []map[string]any) error imzasına sahip bir fonksiyon bulunuyor. Bu fonksiyon kullanıldığı takdirde yanlış giden bir durum olduğunda oluşan hataların her birini error.Join ile birleştirerek döndürülür.

Yalnızca TestHandler fonksiyonu bulunan bu paket için detayları ve örnekleri incelemek isterseniz paket dokümanlarını inceleyebilirsiniz.

slices Paketi

Adından da anlaşılacağı üzere yeni slices paketi slice yapısı için birçok yeni fonksiyon içermektedir. Bu fonksiyonlardan başlıcalarından birkaç tane örnek vereceğim.

package main

import (
	"fmt"
	"slices"
)

func main() {
	numbers := []int{0, 42, -10, 8}

	// Min: Parametre olarak verilen slice içerisindeki
	// en küçük elemanı döndürür.
	fmt.Println(slices.Min(numbers))
	//Output: -10

	// Max: Parametre olarak verilen slice içerisindeki
	// en büyük elemanı döndürür.
	fmt.Println(slices.Max(numbers))
	// Output: 42

	// Insert: İlk parametrede verilen slice içerisine
	// ikinci parametrede verilen index değerine 3. ve
	// diğer parametrelerdeki sayıları sırası ile ekler.
	fmt.Println(slices.Insert(numbers, 1, 1, 2))
	// Output: [0 1 2 42 -10 8]

	// Index: 2. parametrede verilen değer ilk parametrede verilen
	// slice içinde bulunuyorsa index'i döndürür.
	// Bulunmuyorsa -1 değerini döndürür.
	fmt.Println(slices.Index(numbers, -5))
	// Output: -1

	// Sort: Parametre olarak verilen slice'ı küçükten büyüğe sıralar
	slices.Sort(numbers)
	fmt.Println(numbers)
	// Output: [-10 0 8 42]

	// Reverse: Parametre olarak verilen slice'ı tersine çevirir
	slices.Reverse(numbers)
	fmt.Println(numbers)
	// Output: [42 8 0 -10]

	// Delete: İlk parametrede verilen slice içerisinden
	// [1:3] elemanlarını siler. (1 dahil, 3 dahil değil)
	fmt.Println(slices.Delete(numbers, 1, 3))
	// Output: [42 -10]
}

slices paketindeki diğer örnekleri, fonksiyonları ve detayları incelemek için lütfen dokümanları inceleyin.

maps Paketi

Bu paket de adından anlaşılacağı üzere map yapısı üzerinde birtakım operasyonlar olan Clone, Copy, DeleteFunc, Equal ve EqualFunc fonksiyonlarını içerir. Birkaç kullanım örneği vermek gerekirse:

package main

import (
	"fmt"
	"maps"
)

func main() {
	m := map[string]int{
		"one":   1,
		"two":   2,
		"three": 3,
		"four":  4,
	}

	// Clone: Parametre olarak verilen map'in bir kopyasını döndürür.
	fmt.Println(maps.Clone(m))
	// Output: map[four:4 one:1 three:3 two:2]

	// Copy: 2. parametrede verilen map'in anahtar/değer eşlerini
	// 1. parametrede verilen map'e eşitler. Kopyalanan map içerisinde
	// çakışma varsa yeni değerler eski değerlerin üzerine yazılır.
	copied := map[string]int{}
	maps.Copy(copied, m)
	fmt.Println(copied)
	// Output: map[four:4 one:1 three:3 two:2]

	// Equal: Parametre olarak verilen 2 map'in değerlerinin aynı
	// olup olmadığını karşılaştırır.
	fmt.Println(maps.Equal(m, map[string]int{"İstanbul": 34}))
	// Output: false

	// DeleteFunc: map için silme kurallarını belirleyeceğimiz
	// fonksiyonlar tanımlamamızı sağlar. Dokümanda verilen örnekte
	// tek değerleri silmek için aşağıdaki şekilde fonksiyon yazılabilir.
	maps.DeleteFunc(m, func(k string, v int) bool {
		return v%2 != 0
	})
	fmt.Println(m)
	// Output: map[four:4 two:2]
}

cmp Paketi

Bu paket Ordered (sıralı) değerler arasında karşılaştırma yapılabilmesini sağlayan Ordered type’ı ile Compare, Less fonksiyonlarını içerir. Dokümanlara göre Ordered type’ı <, <=, >= ve > operatörlerini destekleyen tipleri içeren türdür.

Compare fonksiyonu ilk parametre ikinciden azsa -1, eşitse 0 ve fazlaysa 1 değerlerini döndürür.

Less fonksiyonu ilk parametre ikinci parametreden azsa true değerini döndürür.

Birer örnek vermek gerekirse:

package main

import (
	"cmp"
	"fmt"
)

func main() {
	fmt.Print(cmp.Compare(1, 2))
	fmt.Print(cmp.Compare(1, 1))
	fmt.Print(cmp.Compare(2, 1))
	// Output:-101
}

Web Assembly

Ayrıca Go 1.21.0 sürümü ile WebAssembly ortamında Go dilini daha işlevsel ve esnek kullanmak için ilk adımlar atıldı. Dokümana göre özellikle asenkron olaylarda sık sık bloke olan uygulamalarda etkileşim daha verimli hale gelerek WebAssembly ortamında çalışan uygulamalar için performans artabilir.

Eklenen deneysel port ile (GOOS=wasip1, GOARCH=wasm) WebAssembly ortamında WASI (WebAssembly System Interface) kullanılabilir.

Go 1.21 Yenilikleri yazısı ilk önce Görkem Rıdvan ARIK üzerinde ortaya çıktı.

İçindekiler

• 1) Web Sunucusu Nedir?
• 2) NGINX Nedir?
• 3) Neden NGINX’e İhtiyaç Duyarız?
• 4) NGINX Nasıl Kurulur?
• 4.1) Ubuntu’ya NGINX Kurulumu
• 4.2) Docker Compose ile NGINX Kurulumu
• 5) Temel NGINX Konfigürasyonları

2) NGINX Nedir?

NGINX, bir HTTP sunucusu olmakla beraber ters vekil sunucusu (reverse proxy server), HTTP önbelleği, yük dengeleyici (load balancer) ve daha birçok amaç için kullanılabilmektedir. Igor Sysoev tarafından 2002 yılında açık kaynak olarak yazılmıştır ve açık kaynak versiyonunun yanı sıra ek özelliklere sahip olan ücretli versiyonu da bulunmaktadır. Günümüzde en çok kullanılan web sunucuları arasında ilk sıralarda yer almaktadır.

Ağır yük altında yüksek performans, düşük bellek kullanımı ve yüksek eş zamanlı çalışma kabiliyetlerine sahiptir. Linux, Unix, Windows ve Mac OS gibi ortamlarda çalışabilmektedir. Ayrıca Docker gibi sanallaştırma teknolojileri ile birlikte de kullanabilirsiniz.

3) Neden NGINX’e İhtiyaç Duyarız?

NGINX’e alternatif olarak Apache ve IIS gibi farklı birçok web sunucusu bulunmaktadır. Bunlar arasında seçim yaparken ihtiyaçlarınız doğrultusunda karar vererek seçim yapmanız en doğrusu olmakla beraber yüksek performans, yük dengelemesi, ters proxy, düşük kaynak tüketimi ve esneklik-güvenlik gibi avantajlarından dolayı NGINX sizin için uygun seçenek olabilir.

4) NGINX Nasıl Kurulur?

İhtiyaçlarınız doğrultusunda yukarıda bahsedilen herhangi bir ortamı seçebilirsiniz. Bu anlatımda NGINX’in Linux/Ubuntu 22.04 ve Docker Compose olmak üzere 2 farklı ortama kurulumu anlatılacaktır.

4.1) Ubuntu’ya NGINX Kurulumu

Öncelikle aşağıdaki Linux komutu ile Ubuntu kütüphane bilgisini güncelleyin.

sudo apt-get update

Sonra NGINX kurmak için aşağıdaki komutu çalıştırın.

sudo apt-get install nginx

Bu komutu çalıştırdıktan sonra size paket bilgilerini sunarak onay isteyecektir. “Y” yazıp enter ile ilerleyebilirsiniz.

Komut tamamlandıktan sonra kurulumu doğrulamak için aşağıdaki komutu çalıştırabilirsiniz.

nginx -v

Aşağıdaki şekilde versiyon bilgisini görebiliyorsanız kurulum başarılı bir şekilde gerçekleşmiş anlamına gelmektedir.

nginx version: nginx/1.18.0 (Ubuntu)

Tarayıcınızda sunucunuzun ip adresini girdiğinizde veya yerel kurulum gerçekleştiriyorsanız locahost adresine gittiğinizde aşağıdaki nginx karşılama ekranını görebilirsiniz.

4.2) Docker Compose ile NGINX Kurulumu

Sunucunuzda Docker’ın yüklü olduğunu varsayarak direkt Docker Compose dosyasının hazırlanma ve ayağa kaldırma konularını anlatıyor olacağım.

İlk adım olarak istediğiniz dizinde docker-compose.yml adında bir dosya oluşturun.

Oluşturmuş olduğunuz dosyayı düzenlemek için açın ve içine aşağıdaki konfigürasyonu ekleyin.

version: '3.8'
services:
  nginx:
    container_name: webserver
    image: nginx:latest
    ports:
      - "80:80"
    volumes:
      - ./conf.d:/etc/nginx/conf.d
      - ./logs:/var/log/nginx

Bu yml dosyası ile 80 portunu ana makinamızdaki 80 portu ile port mapping gerçekleştirerek iliştirdik. Ayrıca nginx konfigürasyonunu gerçekleştireceğimiz conf.d klasörünü docker-compose.yml dosyamızın bulunduğu konuma; log’ları kaydedeceğimiz klasörü de yine aynı konuma volume mapping işlemi ile iliştirdik.

Aşağıdaki Docker komutunu çalıştırınca tıpkı Ubuntu kurulumundaki gibi sunucu ip adresinize veya localhost adresinize tarayıcıdan eriştiğinizde NGINX varsayılan karşılama sayfasını göreceksiniz.

docker compose up

5) Temel NGINX Konfigürasyonları

Bu örnekte temel olarak Docker container’da 8081 portunda çalışan bir uygulama olduğunu varsayarak adrese gelen istekleri bu uygulamaya yönlendiriyor olacağım.

Ubuntu sunucu için /etc/nginx/conf.d konumuna; Docker’a kurduysanız ./conf.d konumuna nginx.conf adında bir dosya oluşturun. Ardından dosyayı düzenleyerek aşağıdaki şekile getirin.

server {
	listen 80;
	server_name localhost; #alan adı
	
	access_log /var/log/nginx/access.log;
	error_log /var/log/nginx/error.log;
	location / {
          proxy_set_header Client-IP $remote_addr;
          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
          proxy_set_header Host $host;
	  proxy_pass http://127.01.0.1:8081;
	}
}

Bu konfigürasyon dosyasında listen 80; satırı ile 80 portunu dinliyoruz. server_name değerine alan adını yazmalısınız (Örn: my_domain.com). access_log ve error_log kısımları ile log dosyalarının konumlarını belirttik. acces_log istekte bulunanların kullanıcı aracısı metni (user agent) ile beraber sunucunun döndüğü yanıt gibi bilgileri tutarken error_log gelen isteklerde oluşan hataları tutar.

location bloğu içerisinde proxy_pass ile my_domain.com adresine gelen istekleri Docker container’ındaki 8081 portunda çalışan uygulamaya yönlendiriyoruz. Böylece kullanıcı tarayıcıdan my_domain.com adresine istekte bulunduğunda sunucuda çalışan Docker container’ına yönlendirme yapılacaktır.

Örneğin burada location /api {… şeklinde bir yol izleseydik my_domain.com/api adresine gelen istekleri Docker container’ına yönlendirmiş olacaktık.

İşlemleri gerçekleştirdikten sonra dosyayı kaydettiğinizden emin olun ve konfigürasyon dosyasının hatasız olup olmadığını kontrol etmek için linux terminalinde aşağıdaki komutu çalıştırın.

nginx -t

Yukarıdaki komutun çıktısı aşağıdaki gibi ise her şey yolunda demektir:

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Konfigürasyon dosyamızın hatasız olduğundan emin olduktan sonra yaptığımız değişikliklerin geçerli olması için nginx servisini yeniden başlatmamız gerekiyor. Bunu aşağıdaki linux komutu ile gerçekleştirebiliriz.

systemctl restart nginx

Bu koddan herhangi bir çıktı beklemiyoruz. Yeniden başlatma sırasında bir hata çıkarsa tek çıktı o olacaktır. Son olarak NGINX servisinin durumunu sorgulamak için aşağıdaki komutu kullanabiliriz.

systemctl status nginx

Bu komutun çıktısında Active: active (running) satırı yer alıyorsa tüm işlemler başarılı bir şekilde gerçekleşmiş demektir. Bununla birlikte reverse proxy işlemimizi tamamlamış olduk ve alan adına atılan istekler konfigürasyon dosyası içerisinde tanımladığımız 8081 portuna yönlendirilecektir. Daha detaylı bilgi için NGINX Resmi Dokümanlarını inceleyebilirsiniz.

Bu makalede web sunucusunun ne olduğuna, bir web sunucusu olan NGINX’e neden ihtiyacımız olduğuna, bize ne gibi avantajlar sağladığına, Ubuntu sunucu ve Docker container olmak üzere 2 farklı ortama kurulum aşamalarına ve temel olarak bir örnek üzerinden kullanımının nasıl olduğuna değindim. Faydalı olması dileği ile.

NGINX Nedir ve Nasıl Kullanılır? yazısı ilk önce Görkem Rıdvan ARIK üzerinde ortaya çıktı.