Go Web Uygulamasını Docker ve Nginx ile Ubuntu 22.04 Üzerine Dağıtma Rehberi

Bu makale, Go ile geliştirilmiş bir web uygulamasını Docker konteynerleri kullanarak Ubuntu 22.04 sunucusu üzerinde Nginx ters proxy’si arkasına nasıl dağıtacağınızı adım adım açıklamaktadır. Modern web uygulamalarının dağıtımında sıkça tercih edilen bu güçlü kombinasyon, ölçeklenebilirlik, güvenlik ve yönetim kolaylığı sunar.

Giriş

Günümüzün hızla değişen teknoloji dünyasında, uygulamaları hızlı, güvenli ve ölçeklenebilir bir şekilde dağıtmak kritik öneme sahiptir. Go (Golang), yüksek performans, eşzamanlılık ve derlenmiş yapısı sayesinde web servisleri ve mikroservisler için popüler bir dil haline gelmiştir. Docker, uygulamaları bağımlılıklarıyla birlikte izole edilmiş konteynerler içinde paketleyerek “bir kez yaz, her yerde çalıştır” felsefesini hayata geçirir. Nginx ise yüksek performanslı bir ters proxy, yük dengeleyici ve web sunucusu olarak, gelen trafiği Docker konteynerlerindeki Go uygulamamıza yönlendirirken ek güvenlik ve performans katmanları sağlar. Ubuntu 22.04, kararlı ve yaygın kullanılan bir Linux dağıtımı olarak bu dağıtım için ideal bir temel sunar.

Bu rehberde, basit bir Go web uygulamasını Dockerize edecek, Nginx’i ters proxy olarak yapılandıracak, Let’s Encrypt ile SSL/TLS sertifikaları alacak ve tüm bu bileşenleri Docker Compose ile yönetilebilir bir sistemde bir araya getireceğiz. Amacımız, geliştiricilere ve sistem yöneticilerine sağlam ve güvenilir bir dağıtım süreci sunmaktır.

Ön Koşullar

Bu rehberi takip edebilmek için aşağıdaki ön koşulların yerine getirilmiş olması gerekmektedir:

Ubuntu 22.04 Sunucusu: SSH erişimine sahip, sudo yetkileri olan bir Ubuntu 22.04 sunucusu.
Alan Adı: Uygulamanıza erişmek için yapılandırılmış bir alan adı (örn: ornekuygulama.com). Bu alan adının A kaydının sunucunuzun IP adresine işaret ettiğinden emin olun.
Temel Linux Bilgisi: Komut satırı kullanımı ve temel Linux komutları hakkında bilgi.
Temel Go Bilgisi: Go programlama dili hakkında temel bilgi.
Temel Docker Bilgisi: Docker konteynerleri ve imajları hakkında temel bilgi.
Temel Nginx Bilgisi: Nginx’in temel yapılandırması hakkında bilgi.

Başlamadan önce sunucunuzu güncelleyelim:

sudo apt update
sudo apt upgrade -y

Go Web Uygulaması Oluşturma

İlk adım olarak, dağıtacağımız basit bir Go web uygulaması oluşturalım. Bu uygulama, gelen isteklere “Merhaba, Docker ve Nginx ile Go!” mesajını döndürecektir.

Go Uygulamasının Oluşturulması

Sunucunuzda veya yerel makinenizde (daha sonra sunucuya aktaracağız) projeniz için bir dizin oluşturun:

mkdir go-web-app
cd go-web-app

Şimdi main.go adında bir dosya oluşturun ve içine aşağıdaki kodu yapıştırın:

// main.go
package main

import (
	"fmt"
	"log"
	"net/http"
)

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "Merhaba, Docker ve Nginx ile Go!\n")
	})

	port := ":8080"
	log.Printf("Go uygulaması %s portunda dinliyor...", port)
	log.Fatal(http.ListenAndServe(port, nil))
}

Bu basit uygulama, tüm gelen HTTP isteklerini / yolunda dinler ve sabit bir metin yanıtı döner. Uygulama 8080 portunda çalışacaktır.

Go Modüllerini Başlatma

Go modüllerini başlatarak bağımlılık yönetimini sağlayalım:

go mod init go-web-app

Bu komut, go.mod dosyasını oluşturacaktır. Uygulamamız harici bir bağımlılık kullanmadığı için başka bir işlem yapmamıza gerek yok.

Dockerize Etme

Şimdi Go uygulamamızı bir Docker konteyneri içinde çalıştırılabilir hale getirelim. Bunun için bir Dockerfile oluşturacağız.

Dockerfile Oluşturma

Proje dizininizde Dockerfile adında bir dosya oluşturun ve içine aşağıdaki içeriği ekleyin:

# Multi-stage build kullanarak küçük bir nihai imaj elde ediyoruz.

Aşama 1: Builder imajı - Go uygulamasını derlemek için
FROM golang:1.22-alpine AS builder

WORKDIR /app

Bağımlılıkları indirmek için go.mod ve go.sum dosyalarını kopyala
COPY go.mod ./
COPY go.sum ./
RUN go mod download

Uygulama kaynak kodunu kopyala
COPY . .

Uygulamayı derle
CGO_ENABLED=0 statik olarak bağlı bir ikili dosya oluşturur
-a bayrağı tüm paketleri yeniden derler
-installsuffix cgo ek CGO kütüphanelerinin kurulumunu engeller
-ldflags "-s -w" ikili dosyanın boyutunu azaltır (sembol tablolarını ve hata ayıklama bilgilerini kaldırır)
RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags "-s -w" -o go-web-app .

Aşama 2: Çalışma zamanı imajı - Derlenmiş uygulamayı çalıştırmak için
FROM alpine:latest

Güvenlik için non-root kullanıcı oluşturma
RUN adduser -D appuser
USER appuser

WORKDIR /app

Builder aşamasından derlenmiş ikili dosyayı kopyala
COPY --from=builder /app/go-web-app .

Uygulamanın dinleyeceği portu belirt
EXPOSE 8080

Uygulamayı başlat
CMD ["./go-web-app"]

Bu Dockerfile, multi-stage build (çok aşamalı derleme) kullanarak nihai Docker imajının boyutunu minimize eder. İlk aşamada Go uygulaması derlenir, ikinci aşamada ise sadece derlenmiş ikili dosya ve Alpine Linux’un minimum bileşenleri içeren küçük bir imaj oluşturulur. Ayrıca, güvenlik için uygulamayı non-root bir kullanıcı olarak çalıştırırız.

.dockerignore Dosyası Oluşturma

Docker imajınızın boyutunu daha da optimize etmek ve gereksiz dosyaların kopyalanmasını engellemek için .dockerignore adında bir dosya oluşturun ve içine aşağıdaki içeriği ekleyin:

# Git ile ilgili dosyaları yoksay
.git
.gitignore

Go modül önbelleğini ve derlenmiş ikili dosyayı yoksay
*.mod
*.sum
go-web-app

Docker İmajını Oluşturma

Şimdi Docker imajımızı oluşturalım. Proje dizininizdeyken aşağıdaki komutu çalıştırın:

docker build -t go-web-app:latest .

Bu komut, mevcut dizindeki Dockerfile‘ı kullanarak go-web-app adında ve latest etiketli bir Docker imajı oluşturacaktır.

Docker İmajını Test Etme (İsteğe Bağlı)

İmajın doğru çalıştığından emin olmak için yerel olarak test edebilirsiniz:

docker run -p 8080:8080 go-web-app:latest

Tarayıcınızda http://localhost:8080 adresine giderek “Merhaba, Docker ve Nginx ile Go!” mesajını görmelisiniz. Testi bitirdiğinizde Ctrl+C ile konteyneri durdurabilirsiniz.

Nginx Kurulumu ve Yapılandırması

Nginx, gelen HTTP isteklerini Go uygulamamızın konteynerine yönlendirecek bir ters proxy görevi görecektir. Ayrıca SSL sonlandırması ve yük dengeleme gibi görevleri de üstlenebilir.

Nginx Kurulumu

Ubuntu sunucunuzda Nginx’i kuralım:

sudo apt install nginx -y
sudo systemctl enable nginx
sudo systemctl start nginx

Kurulumdan sonra, tarayıcınızdan sunucunuzun IP adresine giderek Nginx’in varsayılan karşılama sayfasını görmelisiniz.

Nginx Yapılandırma Dosyası Oluşturma

Uygulamamız için yeni bir Nginx sunucu bloğu yapılandırma dosyası oluşturalım. your_domain yerine kendi alan adınızı kullanın:

sudo nano /etc/nginx/sites-available/your_domain

Dosyanın içine aşağıdaki içeriği ekleyin:

server {
    listen 80;
    listen [::]:80;
    server_name your_domain www.your_domain;

    location / {
        proxy_pass http://go-web-app:8080; # Docker Compose içindeki servis adı ve portu
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Bu yapılandırma, Nginx’in your_domain ve www.your_domain adreslerine gelen HTTP isteklerini dinlemesini ve tüm istekleri http://go-web-app:8080 adresine yönlendirmesini sağlar. go-web-app burada Docker Compose ağındaki servisimizin adı olacaktır. proxy_set_header direktifleri, orijinal istemci bilgilerinin Go uygulamasına iletilmesini sağlar.

Yapılandırmayı Etkinleştirme ve Test Etme

Yeni yapılandırmayı etkinleştirmek için sites-enabled dizinine sembolik bir bağlantı oluşturalım:

sudo ln -s /etc/nginx/sites-available/your_domain /etc/nginx/sites-enabled/

Varsayılan Nginx yapılandırmasını devre dışı bırakmak iyi bir uygulamadır:

sudo unlink /etc/nginx/sites-enabled/default

Nginx yapılandırmanızın sözdizimini kontrol edin:

sudo nginx -t

Eğer “syntax is ok” ve “test is successful” mesajlarını görüyorsanız, Nginx’i yeniden başlatın:

sudo systemctl restart nginx

Sertifika Yönetimi (Let’s Encrypt ile SSL/TLS)

Web uygulamalarının güvenliği için HTTPS kullanımı olmazsa olmazdır. Let’s Encrypt, ücretsiz SSL/TLS sertifikaları sağlayarak bu süreci kolaylaştırır. Certbot aracı ile Nginx yapılandırmamızı otomatik olarak güncelleyebiliriz.

Certbot Kurulumu

Certbot’u ve Nginx eklentisini kuralım:

sudo snap install core
sudo snap refresh core
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot

SSL Sertifikası Alma

Şimdi Certbot’u kullanarak Nginx için SSL sertifikalarını alalım. Certbot, Nginx yapılandırmanızı otomatik olarak algılayacak ve güncelleyecektir:

sudo certbot --nginx -d your_domain -d www.your_domain

Bu komutu çalıştırdığınızda, Certbot size birkaç soru soracaktır (e-posta adresi, hizmet şartlarını kabul etme vb.). Başarılı olursa, Nginx yapılandırma dosyanız otomatik olarak HTTPS için güncellenecek ve HTTP istekleri HTTPS’ye yönlendirilecektir.

Certbot’un otomatik olarak eklediği Nginx yapılandırması yaklaşık olarak şöyle görünecektir:

server {
    listen 80;
    listen [::]:80;
    server_name your_domain www.your_domain;

    location / {
        return 301 https://$host$request_uri;
    }

    # Certbot tarafından eklenenler
    # include /etc/letsencrypt/options-ssl-nginx.conf;
    # ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name your_domain www.your_domain;

    ssl_certificate /etc/letsencrypt/live/your_domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your_domain/privkey.pem;

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location / {
        proxy_pass http://go-web-app:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Certbot ayrıca sertifikaların otomatik olarak yenilenmesini sağlayan bir cron job veya systemd timer da kuracaktır. Yenilemenin çalıştığından emin olmak için test edebilirsiniz:

sudo certbot renew --dry-run

Docker Compose ile Dağıtım

Uygulamamızı ve Nginx’i ayrı Docker konteynerleri olarak çalıştıracağız ve bu konteynerlerin birbirleriyle iletişim kurmasını sağlamak için Docker Compose kullanacağız. Docker Compose, çoklu konteyner Docker uygulamalarını tanımlamak ve çalıştırmak için bir araçtır.

Docker ve Docker Compose Kurulumu

Eğer henüz kurulu değilse, Ubuntu sunucunuzda Docker ve Docker Compose’u kuralım:

# Docker Kurulumu
sudo apt update
sudo apt install ca-certificates curl gnupg -y
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Mevcut kullanıcıyı docker grubuna ekleyerek sudo kullanmadan docker komutlarını çalıştırmayı sağlar
sudo usermod -aG docker $USER
newgrp docker # Değişikliğin hemen etkili olması için (veya oturumu kapatıp açın)

Kurulumu test edin:

docker run hello-world
docker compose version

Docker Compose Dosyası Oluşturma

Go uygulama projenizin kök dizininde (go-web-app dizini) docker-compose.yml adında bir dosya oluşturun:

cd go-web-app # Eğer farklı bir dizindeyseniz
nano docker-compose.yml

İçine aşağıdaki içeriği yapıştırın:

version: '3.8'

services:
  go-app:
    build:
      context: .
      dockerfile: Dockerfile
    image: go-web-app:latest
    container_name: go-web-app
    restart: always
    environment:
      - PORT=8080 # Go uygulamamızın dinlediği port
    expose:
      - "8080" # Sadece Docker içindeki diğer servisler erişebilir

  nginx:
    image: nginx:latest
    container_name: nginx-proxy
    restart: always
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d:ro # Nginx yapılandırma dosyası
      - /etc/letsencrypt:/etc/letsencrypt:ro # Let's Encrypt sertifikaları
      - /var/log/nginx:/var/log/nginx # Nginx logları için
    depends_on:
      - go-app
    networks:
      - webapp-network

networks:
  webapp-network:
    driver: bridge

Bu docker-compose.yml dosyası iki servis tanımlar:

go-app: Daha önce oluşturduğumuz Dockerfile‘ı kullanarak Go uygulamamızın imajını oluşturur ve çalıştırır. expose ile sadece Docker ağı içinde 8080 portunu açar.
nginx: Nginx’in resmi Docker imajını kullanır. Sunucunun 80 ve 443 portlarını konteynerin 80 ve 443 portlarına eşler. Nginx yapılandırma dosyamızı (nginx/conf.d/default.conf olarak belirtilecek), Let’s Encrypt sertifikalarını ve Nginx loglarını sunucudaki dizinlerden konteynere bağlar (volume mount). depends_on: go-app, Nginx servisinin Go uygulaması servisinden sonra başlatılmasını sağlar.

Nginx Yapılandırmasını Docker Compose İçin Ayarlama

Nginx konteynerinin yapılandırma dosyasını sunucudan almak yerine, Docker Compose ile yönetmek için projemiz içinde bir Nginx yapılandırma dizini oluşturalım. Go uygulama projenizin kök dizininde (go-web-app) aşağıdaki dizin yapısını oluşturun:

mkdir -p nginx/conf.d

Şimdi nginx/conf.d/default.conf adında bir dosya oluşturun:

nano nginx/conf.d/default.conf

İçine daha önce Certbot tarafından güncellenen Nginx yapılandırmasını yapıştırın. Önemli: Nginx konteyneri, Go uygulamasını go-web-app servis adı üzerinden bulacaktır, bu yüzden proxy_pass içindeki IP adresini veya localhost‘u http://go-web-app:8080 olarak değiştirdiğinizden emin olun.

server {
    listen 80;
    listen [::]:80;
    server_name your_domain www.your_domain;

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name your_domain www.your_domain;

    ssl_certificate /etc/letsencrypt/live/your_domain/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/your_domain/privkey.pem;

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location / {
        proxy_pass http://go-web-app:8080; # Burası önemli! go-web-app servis adını kullanıyoruz.
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Not: Certbot’u sunucunuzda doğrudan Nginx ile çalıştırdığımız için /etc/letsencrypt dizini zaten sunucunuzda mevcuttur. docker-compose.yml dosyasındaki - /etc/letsencrypt:/etc/letsencrypt:ro satırı bu dizini Nginx konteynerine salt okunur olarak bağlar, böylece sertifikalara erişebilir. Bu yaklaşım, Certbot’u ayrı bir konteynerde çalıştırmaktan daha basit ve çoğu senaryo için yeterlidir.

Uygulamayı Docker Compose ile Başlatma

Go uygulama projenizin kök dizininde (go-web-app dizini) aşağıdaki komutu çalıştırın:

docker compose up -d

docker compose up: docker-compose.yml dosyasındaki servisleri başlatır.
-d: Servisleri arka planda (detached mode) çalıştırır.

İlk çalıştırmada Docker imajları indirilecek/oluşturulacak ve konteynerler başlayacaktır. Kontrol etmek için:

docker compose ps

Çıktıda hem go-web-app hem de nginx-proxy servislerinin running durumda olduğunu görmelisiniz.

Logları Kontrol Etme

Konteynerlerin loglarını takip etmek için:

docker compose logs -f

Belirli bir servisin loglarını görmek için (örn. Go uygulaması):

docker compose logs -f go-app

Uygulamayı Test Etme

Her şeyin doğru çalıştığından emin olmak için uygulamanızı test edin.

Tarayıcıdan Erişim: Web tarayıcınızı açın ve https://your_domain adresine gidin. “Merhaba, Docker ve Nginx ile Go!” mesajını görmelisiniz. Ayrıca tarayıcınızın adres çubuğunda bir kilit simgesi veya “Güvenli” ibaresi ile HTTPS bağlantısının aktif olduğunu kontrol edin.
curl ile Test: Sunucunuzdan veya yerel makinenizden curl komutunu kullanarak test yapabilirsiniz:
```
curl -I https://your_domain
curl https://your_domain
```
-I bayrağı sadece HTTP başlıklarını gösterir ve HTTP/2 200 gibi bir durum kodu ile SSL’in çalıştığını teyit eder. İkinci komut ise sayfanın içeriğini gösterir.

Sonuç

Bu rehberde, Go ile geliştirilmiş basit bir web uygulamasını Docker kullanarak konteynerleştirdik, Nginx’i ters proxy olarak yapılandırdık ve Let’s Encrypt ile güvenli HTTPS bağlantısı sağladık. Son olarak, tüm bu bileşenleri Docker Compose ile bir araya getirerek kolayca yönetilebilir bir dağıtım ortamı oluşturduk. Bu yaklaşım, modern web uygulamalarının hızlı, güvenli ve ölçeklenebilir bir şekilde dağıtılması için sağlam bir temel sunar.

Bu kurulum, uygulamanızı üretim ortamında çalıştırmak için harika bir başlangıç noktasıdır. Ancak, daha büyük ölçekli veya daha kritik uygulamalar için aşağıdaki ek adımları ve konuları göz önünde bulundurmak isteyebilirsiniz:

Veritabanı Entegrasyonu: Uygulamanız bir veritabanı kullanıyorsa, veritabanı servisini de Docker Compose dosyasına ekleyebilir veya harici bir yönetilen veritabanı hizmeti kullanabilirsiniz.
Ortam Değişkenleri: Hassas bilgiler (API anahtarları, veritabanı kimlik bilgileri) için .env dosyaları veya Docker Secret’ları kullanın.
Log Yönetimi: Uygulama ve Nginx loglarını merkezi bir log yönetim sistemine (örn. ELK Stack, Grafana Loki) göndermeyi düşünün.
İzleme ve Gözetim: Prometheus ve Grafana gibi araçlarla uygulamanızın ve sunucunuzun performansını izleyin.
CI/CD Boru Hattı: Uygulama güncellemelerini otomatik hale getirmek için bir Sürekli Entegrasyon/Sürekli Dağıtım (CI/CD) boru hattı kurun.
Güvenlik Duvarı: Sunucunuzun güvenlik duvarını (UFW) sadece gerekli portları (80, 443, 22) açacak şekilde yapılandırın.
Yedekleme: Uygulama verilerinizin ve yapılandırmalarınızın düzenli yedeklerini alın.

Bu rehberin, Go web uygulamalarınızı Docker ve Nginx ile Ubuntu 22.04 üzerinde başarıyla dağıtmanıza yardımcı olduğunu umuyoruz. İyi geliştirmeler ve dağıtımlar dileriz!

Go Web Uygulamasını Docker ve Nginx ile Ubuntu 22.04 Üzerine Dağıtma Rehberi