Takip et

Next.js, MySQL ve Terraform ile Dinamik Todo Uygulaması Geliştirme Rehberi

Hızla değişen dijital dünyada, projeleri yönetmek için etkili araçlara ihtiyaç duyarız. Bu makale, modern bir Next.js Todo uygulamasını MySQL veritabanı ve Terraform ile nasıl inşa edeceğinizi adım adım açıklıyor. Güçlü bir front-end ile sağlam bir back-end ve otomatize edilmiş altyapıyı bir araya getirerek geliştirme sürecinizi optimize edin.

Günümüz web geliştirme dünyasında geliştiriciler, sadece işlevsel değil, aynı zamanda hızlı, ölçeklenebilir ve kolayca yönetilebilir uygulamalar inşa etme zorunluluğu ile karşı karşıyadır. Kullanıcı beklentileri her geçen gün artarken, performans, SEO uyumluluğu ve geliştirici deneyimi gibi faktörler, bir projenin başarısında kritik rol oynamaktadır. Bu bağlamda, doğru teknoloji yığınını (tech stack) seçmek, projenin geleceğini doğrudan etkiler.

İşte bu noktada Next.js, MySQL ve Terraform üçlüsü devreye giriyor ve modern web geliştirme ihtiyaçlarına kapsamlı çözümler sunuyor:

  • Next.js: Ön Yüzde Güç ve Esneklik
    React tabanlı bir çerçeve olan Next.js, geliştiricilere server-side rendering (SSR), static site generation (SSG) ve incremental static regeneration (ISR) gibi güçlü render yetenekleri sunar. Bu özellikler sayesinde uygulamalarınızın başlangıç performansı artar, arama motorlarında daha iyi sıralanır (SEO dostu) ve kullanıcılar için daha hızlı bir deneyim sunar. Ayrıca, entegre API Routes özelliği, uygulamanızın ön yüzüyle aynı çatı altında basit bir back-end işlevselliği oluşturmanıza olanak tanır, bu da full-stack geliştirme sürecini basitleştirir ve geliştirici deneyimini önemli ölçüde iyileştirir. Next.js, modüler yapısı ve geniş topluluk desteğiyle karmaşık projelerin bile kolayca yönetilmesini sağlar. Özellikle veri çekme (data fetching) mekanizmaları ve otomatik kod bölme (automatic code splitting) gibi özellikleri, web performansını doğrudan etkileyen önemli avantajlardır.
  • MySQL: Güvenilir ve Yaygın İlişkisel Veritabanı
    Yıllardır sektörde kanıtlanmış bir popülerliğe sahip olan MySQL, sağlamlığı, performansı ve geniş ekosistemiyle öne çıkar. İlişkisel veritabanı yönetim sistemleri (RDBMS) arasında lider konumda olan MySQL, yapısal veri depolama için idealdir. ACID özelliklerini (Atomicity, Consistency, Isolation, Durability) desteklemesi, veri bütünlüğünü ve güvenilirliğini garanti eder. Geniş bir araç ve kütüphane desteğine sahip olması, farklı programlama dilleriyle kolayca entegre olabilmesini sağlar. Özellikle Todo uygulamaları gibi görev yönetimi gerektiren projelerde, görevlerin durumunu, açıklamalarını ve diğer meta verilerini tutarlı bir şekilde depolamak için mükemmel bir seçimdir. Yüksek trafikli uygulamalarda bile performansını koruyabilen ve kolayca ölçeklenebilen yapısı, MySQL’i vazgeçilmez kılar.
  • Terraform: Altyapıyı Kod Olarak Yönetme Sanatı (IaC)
    Terraform, HashiCorp tarafından geliştirilen açık kaynaklı bir altyapıyı kod olarak (Infrastructure as Code – IaC) yönetim aracıdır. Geliştiricilerin ve DevOps ekiplerinin bulut veya şirket içi altyapılarını kod dosyaları aracılığıyla tanımlamasına, sağlamasına ve yönetmesine olanak tanır. Terraform kullanarak, bir MySQL veritabanı sunucusu, güvenlik duvarı kuralları, ağ yapılandırması ve diğer tüm bulut kaynakları (örneğin AWS RDS, EC2, VPC) otomatik olarak oluşturulabilir, güncellenebilir ve silinebilir. Bu yaklaşım, insan hatalarını azaltır, altyapı dağıtımını standartlaştırır, versiyon kontrolü sağlar ve tekrarlanabilirliği artırır. Geliştirme, test ve üretim ortamları arasında tutarlılığı sağlamak, büyük projelerde Terraform’un değerini paha biçilmez kılar.

Vaka Analizi: Hızla Büyüyen Bir Startup’ın Geliştirme Süreci

Hızla büyüyen bir lojistik startup’ı olan “HızlıTeslimat”, operasyonlarını yönetmek için eski ve manuel bir süreç kullanıyordu. Proje yöneticileri ve saha ekipleri arasındaki koordinasyon eksikliği, görev takibini zorlaştırıyordu. Yeni bir görev yönetim paneli geliştirmeye karar verdiklerinde, modern bir stack arayışına girdiler. Next.js ile sezgisel ve hızlı bir ön yüz, MySQL ile sağlam ve güvenilir bir görev veritabanı oluşturmayı hedeflediler. Ancak en büyük zorluk, bu altyapıyı hızlı ve hatasız bir şekilde kurmaktı. Terraform’u kullanarak tüm veritabanı sunucularını, güvenlik gruplarını ve ağ yapılandırmalarını dakikalar içinde otomatize ettiler. Sonuç olarak, projenin geliştirme süresi %30 oranında kısaldı ve saha ekipleri yeni paneli kullanmaya başladığında, görevlerin ortalama tamamlama süresi %15 azaldı. Bu vaka, Next.js, MySQL ve Terraform’un birleşimiyle elde edilebilecek operasyonel ve geliştirme verimliliğinin somut bir örneğidir.

Next.js Todo Uygulamasının Temelleri Nasıl Oluşturulur?

Bir Next.js Todo uygulaması geliştirmek, modern web geliştirmenin temel prensiplerini anlamak için harika bir başlangıç noktasıdır. Uygulamanın temel amacı, kullanıcıların görev eklemesini, mevcut görevleri görüntülemesini, tamamlandı olarak işaretlemesini ve silmesini sağlamaktır. Bu bölümde, Next.js projesini nasıl başlatacağımızı, temel kullanıcı arayüzü (UI) bileşenlerini nasıl oluşturacağımızı ve veritabanı ile etkileşim kurmak için Next.js API Routes’ı nasıl kullanacağımızı adım adım inceleyeceğiz.

1. Next.js Projesini Başlatma

Öncelikle, terminalinizde aşağıdaki komutu çalıştırarak yeni bir Next.js projesi oluşturun:


    npx create-next-app todo-app --typescript --eslint --tailwind --app
    cd todo-app
    

Bu komut, todo-app adında yeni bir Next.js projesi oluşturacak ve TypeScript, ESLint ve Tailwind CSS gibi modern geliştirme araçlarını otomatik olarak yapılandıracaktır. --app bayrağı, Next.js 13 ve sonrası için önerilen App Router yapısını kullanacağımız anlamına gelir. Proje dizinine girdikten sonra, geliştirme sunucusunu başlatarak uygulamanızı tarayıcınızda görüntüleyebilirsiniz:


    npm run dev
    

2. Temel React Bileşenlerini Oluşturma

Todo uygulamamız için ana sayfada bir görev listesi gösterecek ve yeni görev ekleme formu barındıracak bileşenlere ihtiyacımız var. app klasörü altında basit bir yapı kurabiliriz. Örneğin, app/page.tsx dosyasında ana bileşenleri tanımlayabiliriz:


    // app/page.tsx
    import { useState, useEffect } from 'react';

    interface Todo {
      id: number;
      task: string;
      completed: boolean;
    }

    export default function Home() {
      const [todos, setTodos] = useState([]);
      const [newTask, setNewTask] = useState('');

      useEffect(() => {
        fetchTodos();
      }, []);

      const fetchTodos = async () => {
        const res = await fetch('/api/todos');
        const data = await res.json();
        setTodos(data);
      };

      const handleAddTask = async (e: React.FormEvent) => {
        e.preventDefault();
        if (!newTask.trim()) return;

        await fetch('/api/todos', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ task: newTask }),
        });
        setNewTask('');
        fetchTodos(); // Refresh the list
      };

      const handleToggleComplete = async (id: number, completed: boolean) => {
        await fetch(/api/todos/${id}, {
          method: 'PUT',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({ completed: !completed }),
        });
        fetchTodos();
      };

      const handleDeleteTask = async (id: number) => {
        await fetch(/api/todos/${id}, {
          method: 'DELETE',
        });
        fetchTodos();
      };

      return (
        

Next.js Todo Uygulaması

setNewTask(e.target.value)} />
    {todos.map((todo) => (
  • handleToggleComplete(todo.id, todo.completed)} className="form-checkbox h-5 w-5 text-blue-600 rounded" /> text-lg ${todo.completed ? 'line-through text-gray-500' : 'text-gray-800'}}> {todo.task}
  • ))}
); }

Bu kod bloğu, ana sayfa bileşenini (Home) tanımlar. useState ile görev listesini ve yeni görev girdisini yönetiriz. useEffect kancası, sayfa yüklendiğinde fetchTodos fonksiyonunu çağırarak mevcut görevleri getirir. handleAddTask, handleToggleComplete ve handleDeleteTask fonksiyonları, kullanıcı etkileşimlerini işler ve Next.js API rotalarına istek gönderir.

3. Next.js API Rotaları ile Back-end İşlevselliği

Next.js'in en güçlü özelliklerinden biri olan API Routes, sunucusuz fonksiyonlar gibi çalışarak front-end kodunuzla aynı projede bir back-end oluşturmanıza olanak tanır. Veritabanı etkileşimleri ve CRUD (Create, Read, Update, Delete) operasyonları için bu rotaları kullanacağız.

İlk olarak, veritabanı bağlantımızı yönetmek için bir yardımcı modül oluşturalım. Örneğin, lib/db.ts:


    // lib/db.ts
    import mysql from 'mysql2/promise';

    const pool = mysql.createPool({
      host: process.env.DB_HOST,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME,
      waitForConnections: true,
      connectionLimit: 10,
      queueLimit: 0,
    });

    export default pool;
    

Bu dosya, MySQL veritabanına bağlantı havuzu oluşturur. Ortam değişkenlerini (.env dosyası üzerinden) kullanarak veritabanı kimlik bilgilerini güvende tutacağız. Şimdi API rotalarını oluşturalım:

Görevleri Getirme ve Ekleme (app/api/todos/route.ts)

Bu rota, tüm görevleri getirir (GET isteği) ve yeni bir görev ekler (POST isteği).


    // app/api/todos/route.ts
    import { NextResponse } from 'next/server';
    import pool from '@/lib/db';

    export async function GET() {
      try {
        const [rows] = await pool.query('SELECT * FROM todos ORDER BY id DESC');
        return NextResponse.json(rows);
      } catch (error) {
        console.error('Error fetching todos:', error);
        return NextResponse.json({ message: 'Failed to fetch todos' }, { status: 500 });
      }
    }

    export async function POST(request: Request) {
      try {
        const { task } = await request.json();
        if (!task) {
          return NextResponse.json({ message: 'Task is required' }, { status: 400 });
        }
        const [result] = await pool.execute(
          'INSERT INTO todos (task) VALUES (?)',
          [task]
        );
        return NextResponse.json({ id: (result as any).insertId, task, completed: false }, { status: 201 });
      } catch (error) {
        console.error('Error adding todo:', error);
        return NextResponse.json({ message: 'Failed to add todo' }, { status: 500 });
      }
    }
    

Belirli Bir Görevi Güncelleme veya Silme (app/api/todos/[id]/route.ts)

Bu dinamik rota, belirli bir görev kimliğine göre görevi günceller (PUT isteği) veya siler (DELETE isteği).


    // app/api/todos/[id]/route.ts
    import { NextResponse } from 'next/server';
    import pool from '@/lib/db';

    export async function PUT(request: Request, { params }: { params: { id: string } }) {
      try {
        const { id } = params;
        const { completed } = await request.json();

        if (typeof completed !== 'boolean') {
          return NextResponse.json({ message: 'Completed status is required and must be boolean' }, { status: 400 });
        }

        await pool.execute(
          'UPDATE todos SET completed = ? WHERE id = ?',
          [completed, id]
        );
        return NextResponse.json({ message: 'Todo updated successfully' });
      } catch (error) {
        console.error('Error updating todo:', error);
        return NextResponse.json({ message: 'Failed to update todo' }, { status: 500 });
      }
    }

    export async function DELETE(request: Request, { params }: { params: { id: string } }) {
      try {
        const { id } = params;
        await pool.execute('DELETE FROM todos WHERE id = ?', [id]);
        return NextResponse.json({ message: 'Todo deleted successfully' });
      } catch (error) {
        console.error('Error deleting todo:', error);
        return NextResponse.json({ message: 'Failed to delete todo' }, { status: 500 });
      }
    }
    

Bu adımlarla, Next.js uygulamanızın temel iskeletini, kullanıcı arayüzünü ve veritabanı ile etkileşim kuracak API rotalarını oluşturmuş olursunuz. Geliştirici deneyimini optimize etmek ve hızlı prototipleme yapmak için bu yapı oldukça etkilidir. LSI kelimeleri açısından bakıldığında, full-stack geliştirme, veri çekme, state yönetimi ve serverless API gibi kavramlar bu bölümün temelini oluşturur.

MySQL Veritabanı Yapılandırması ve Veri Modeli Nasıl Tasarlanır?

Bir Todo uygulamasının kalbi, görevleri depoladığı veritabanıdır. MySQL, bu tür basit ama kritik veri depolama ihtiyaçları için sağlam ve güvenilir bir çözüm sunar. Doğru veri modeli tasarımı, uygulamanızın performansını ve ölçeklenebilirliğini doğrudan etkiler. Bu bölümde, Todo uygulamamız için gerekli MySQL tablosunu nasıl oluşturacağımızı, temel SQL sorgularını ve veritabanı bağlantı detaylarını nasıl yapılandıracağımızı ele alacağız.

1. todos Tablosu Tasarımı

Todo uygulamamız için ana veri varlığı "görev"dir (todo). Her görevin benzersiz bir kimliği, bir açıklaması (görev metni) ve tamamlanıp tamamlanmadığını gösteren bir durumu olmalıdır. Ayrıca, görevlerin ne zaman oluşturulduğunu takip etmek, sıralama ve analiz için faydalı olacaktır. Bu gereksinimler doğrultusunda, todos adında bir tablo oluşturacağız:

  • id (INT, PRIMARY KEY, AUTO_INCREMENT): Her görevin benzersiz tanımlayıcısı. Otomatik artan bir sayı olmalı.
  • task (VARCHAR(255), NOT NULL): Görev metnini içeren alan. Maksimum 255 karakter uzunluğunda olmalı ve boş bırakılamaz.
  • completed (BOOLEAN, DEFAULT FALSE): Görevin tamamlanıp tamamlanmadığını belirten bir bayrak. Varsayılan olarak FALSE (tamamlanmamış) olmalı.
  • createdAt (TIMESTAMP, DEFAULT CURRENT_TIMESTAMP): Görevin oluşturulma zamanını otomatik olarak kaydeden alan.

2. Tablo Oluşturma SQL Sorgusu

Yukarıdaki tasarıma uygun olarak todos tablosunu oluşturmak için aşağıdaki SQL sorgusunu kullanabiliriz. Bu sorguyu bir MySQL istemcisinde (örneğin MySQL Workbench, phpMyAdmin veya komut satırı) çalıştırarak veritabanınızda tabloyu oluşturabilirsiniz:


    -- Veritabanını oluşturma (eğer yoksa)
    CREATE DATABASE IF NOT EXISTS todo_app_db;

    -- Veritabanını kullanma
    USE todo_app_db;

    -- todos tablosunu oluşturma
    CREATE TABLE IF NOT EXISTS todos (
        id INT AUTO_INCREMENT PRIMARY KEY,
        task VARCHAR(255) NOT NULL,
        completed BOOLEAN DEFAULT FALSE,
        createdAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    );
    

IF NOT EXISTS ifadesi, tablonun veya veritabanının zaten var olup olmadığını kontrol ederek hata oluşmasını engeller. Bu, dağıtım otomasyonunda oldukça kullanışlı bir yaklaşımdır.

3. Veritabanı Bağlantı Detayları ve Ortam Değişkenleri

Uygulamamızın veritabanına bağlanabilmesi için gerekli kimlik bilgilerini (host, kullanıcı adı, şifre, veritabanı adı) sağlamamız gerekir. Bu bilgileri doğrudan kod içine yazmak yerine, güvenlik ve esneklik açısından ortam değişkenleri aracılığıyla yönetmek en iyi uygulamadır. Next.js projenizin kök dizininde bir .env dosyası oluşturarak bu değişkenleri tanımlayabilirsiniz:


    # .env
    DB_HOST=localhost
    DB_USER=root
    DB_PASSWORD=your_mysql_root_password
    DB_NAME=todo_app_db
    

Üretim ortamında bu değerler, bulut sağlayıcınızın (AWS, Azure, GCP) ortam değişkenleri veya gizli yönetim hizmetleri (örneğin AWS Secrets Manager) aracılığıyla sağlanacaktır.

4. Temel SQL CRUD Operasyonları

API rotalarımızda kullandığımız gibi, temel CRUD operasyonlarını gerçekleştiren SQL sorgularına hızlıca bir göz atalım:

  • Görev Ekleme (CREATE):
    
                INSERT INTO todos (task, completed) VALUES ('Alışveriş yap', FALSE);
                

  • Görevleri Okuma (READ):
    
                SELECT id, task, completed, createdAt FROM todos ORDER BY createdAt DESC;
                

  • Görev Güncelleme (UPDATE):
    
                UPDATE todos SET completed = TRUE WHERE id = 1;
                

  • Görev Silme (DELETE):
    
                DELETE FROM todos WHERE id = 1;
                

5. Şema Tasarımı ve Performans İpuçları

Küçük bir Todo uygulaması için bu basit şema yeterlidir. Ancak daha büyük ve karmaşık uygulamalarda, şema tasarımı kritik hale gelir:

  • İndeksleme: Sık sık arama yaptığınız sütunlara (örneğin id dışındaki task sütununda arama yapıyorsanız) indeks eklemek sorgu performansını artırır. Ancak çok fazla indeks, yazma (INSERT, UPDATE, DELETE) operasyonlarını yavaşlatabilir.
  • Veri Türleri: En uygun veri türlerini kullanmak (örneğin metin için VARCHAR yerine daha uygun bir TEXT veya sayı için INT yerine SMALLINT), depolama alanını optimize eder ve performansı etkileyebilir.
  • Normalizasyon: Veri tekrarını azaltmak ve veri bütünlüğünü sağlamak için tabloları normalleştirmek önemlidir. Todo uygulamamız tek bir tablo ile yönetildiği için bu şimdilik geçerli değil, ancak kullanıcılar veya kategoriler eklediğinizde bu konu önem kazanacaktır.

Bu adımlar, uygulamanızın veritabanı tarafını sağlam bir temel üzerine inşa etmenizi sağlar. Güvenli bağlantılar, optimize edilmiş sorgular ve doğru şema tasarımı, uygulamanızın performanslı ve güvenilir çalışmasında kilit rol oynar. MySQL'in gücünden tam anlamıyla faydalanmak, ilişkisel veritabanı yönetiminin ve veri modellemenin temel prensiplerini anlamaktan geçer.

Terraform ile MySQL Altyapısı Nasıl Otomatize Edilir?

Uygulama kodumuzu geliştirdik, ancak bu kodu çalıştıracak ve verilerini depolayacak bir altyapıya ihtiyacımız var. Terraform, bu altyapıyı kod olarak (Infrastructure as Code - IaC) tanımlamamıza ve otomatik olarak sağlamamıza olanak tanır. Bu bölümde, Terraform kullanarak AWS üzerinde bir MySQL veritabanı (Amazon RDS) örneğini nasıl otomatize edeceğimizi adım adım ele alacağız.

1. Terraform'a Giriş: IaC Prensipleri

Altyapıyı Kod Olarak (IaC), altyapı yönetimi için geleneksel manuel süreçlerin yerini alarak altyapı dağıtımını ve yönetimini otomatikleştiren bir yaklaşımdır. Terraform, bu alanda lider araçlardan biridir. IaC'nin temel avantajları şunlardır:

  • Tekrarlanabilirlik: Ortamlar arasında (geliştirme, test, üretim) tutarlılığı garanti eder.
  • Versiyon Kontrolü: Altyapı değişiklikleri kod olarak kaydedildiği için Git gibi sistemlerle versiyon kontrolü yapılabilir.
  • Hata Azaltma: Manuel yapılandırma hatalarını ortadan kaldırır.
  • Hız: Altyapı hızlı bir şekilde devreye alınabilir veya güncellenebilir.

Terraform, "HashiCorp Configuration Language" (HCL) adlı deklaratif bir dil kullanır. Bu dil, istediğiniz altyapı durumunu tanımlamanıza olanak tanır; Terraform ise bu duruma ulaşmak için gerekli adımları otomatik olarak gerçekleştirir.

2. Geliştirme Ortamını Kurma

Öncelikle, makinenize Terraform CLI'ı yüklemeniz ve AWS kimlik bilgilerinizi yapılandırmanız gerekir. AWS CLI'yi kurup aws configure komutuyla kimlik bilgilerinizi ayarlayabilirsiniz. Terraform, varsayılan olarak bu kimlik bilgilerini kullanacaktır.

3. Terraform Yapılandırma Dosyaları (.tf)

Bir Terraform projesi, genellikle .tf uzantılı bir veya daha fazla dosyadan oluşur. Ana bileşenler şunlardır:

  • main.tf: Ana kaynak tanımlarını içerir (veritabanı, ağ, güvenlik grupları vb.).
  • variables.tf: Değişken tanımlarını içerir, böylece yapılandırmanız dinamik olabilir.
  • outputs.tf: Oluşturulan kaynaklardan önemli çıktıları tanımlar (örneğin veritabanı uç noktası).

Örnek: AWS RDS MySQL Oluşturma

Yeni bir dizin oluşturun (örneğin terraform/mysql) ve içinde aşağıdaki dosyaları oluşturun:

main.tf - AWS Sağlayıcısı ve RDS Tanımları

Bu dosya, AWS sağlayıcısını ve bir Amazon RDS MySQL örneği ile ilgili kaynakları tanımlar.


    # main.tf

    # AWS Sağlayıcısını Yapılandırma
    provider "aws" {
      region = var.aws_region
    }

    # VPC Tanımlama (eğer mevcut bir VPC kullanıyorsanız, burayı güncelleyin)
    resource "aws_vpc" "main" {
      cidr_block = "10.0.0.0/16"
      enable_dns_hostnames = true
      enable_dns_support   = true
      tags = {
        Name = "todo-app-vpc"
      }
    }

    # Alt Ağlar (Subnets)
    resource "aws_subnet" "public" {
      count             = 2
      vpc_id            = aws_vpc.main.id
      cidr_block        = "10.0.${count.index}.0/24"
      availability_zone = "${var.aws_region}${element(["a", "b"], count.index)}"
      map_public_ip_on_launch = true
      tags = {
        Name = "todo-app-public-subnet-${count.index}"
      }
    }

    # İnternet Ağ Geçidi
    resource "aws_internet_gateway" "main" {
      vpc_id = aws_vpc.main.id
      tags = {
        Name = "todo-app-igw"
      }
    }

    # Yönlendirme Tablosu
    resource "aws_route_table" "public" {
      vpc_id = aws_vpc.main.id
      route {
        cidr_block = "0.0.0.0/0"
        gateway_id = aws_internet_gateway.main.id
      }
      tags = {
        Name = "todo-app-public-rt"
      }
    }

    # Yönlendirme Tablosu İlişkilendirmesi
    resource "aws_route_table_association" "public" {
      count          = 2
      subnet_id      = aws_subnet.public[count.index].id
      route_table_id = aws_route_table.public.id
    }

    # RDS Alt Ağ Grubu
    resource "aws_db_subnet_group" "default" {
      subnet_ids = aws_subnet.public.*.id
      tags = {
        Name = "todo-app-db-subnet-group"
      }
    }

    # Güvenlik Grubu (Sadece uygulamanızın IP'sinden veya VPC'den erişime izin verin)
    resource "aws_security_group" "db_sg" {
      name        = "todo-app-db-sg"
      description = "Allow inbound traffic to RDS from application"
      vpc_id      = aws_vpc.main.id

      ingress {
        from_port   = 3306
        to_port     = 3306
        protocol    = "tcp"
        # Bu CIDR bloğunu uygulamanızın çalıştığı sunucunun IP aralığı ile değiştirin.
        # Geliştirme için kendi IP'nizi kullanabilirsiniz: curl ifconfig.me
        # Üretimde, uygulamanızın bulunduğu VPC'nin CIDR bloğunu veya güvenlik grubunu kullanın.
        cidr_blocks = ["0.0.0.0/0"] # Sadece test amaçlıdır, üretimde kısıtlayın!
      }
      egress {
        from_port   = 0
        to_port     = 0
        protocol    = "-1"
        cidr_blocks = ["0.0.0.0/0"]
      }

      tags = {
        Name = "todo-app-db-sg"
      }
    }

    # RDS MySQL Veritabanı Örneği
    resource "aws_db_instance" "todo_mysql_db" {
      engine               = "mysql"
      engine_version       = "8.0.28" # MySQL 8.0.x versiyonunu kullanın
      instance_class       = "db.t3.micro"
      allocated_storage    = 20
      db_name              = var.db_name
      username             = var.db_user
      password             = var.db_password
      parameter_group_name = "default.mysql8.0"
      skip_final_snapshot  = true # Üretimde false yapın
      vpc_security_group_ids = [aws_security_group.db_sg.id]
      db_subnet_group_name = aws_db_subnet_group.default.name
      publicly_accessible  = true # Sadece test amaçlıdır, üretimde false yapın ve private network kullanın
      multi_az             = false # Üretimde true yapın
      storage_type         = "gp2"
      identifier           = "todo-app-mysql-instance"
      # Backup ve Log ayarları burada yapılandırılabilir.
    }
    

variables.tf - Değişken Tanımları

Bu dosya, yapılandırmada kullanılacak değişkenleri tanımlar.


    # variables.tf
    variable "aws_region" {
      description = "AWS Bölgesi"
      type        = string
      default     = "eu-central-1" # Kendi bölgenizi seçin
    }

    variable "db_name" {
      description = "Veritabanı Adı"
      type        = string
      default     = "todo_app_db"
    }

    variable "db_user" {
      description = "Veritabanı Kullanıcı Adı"
      type        = string
      default     = "admin"
    }

    variable "db_password" {
      description = "Veritabanı Şifresi"
      type        = string
      sensitive   = true # Bu değişkenin çıktılarda görünmemesini sağlar
    }
    

outputs.tf - Çıktı Değerleri

Bu dosya, Terraform'un başarıyla oluşturduğu kaynaklardan alınacak önemli bilgileri tanımlar. Bu çıktılar, Next.js uygulamanızın veritabanına bağlanması için kullanılacaktır.


    # outputs.tf
    output "db_endpoint" {
      description = "RDS Veritabanı Uç Noktası"
      value       = aws_db_instance.todo_mysql_db.address
    }

    output "db_name" {
      description = "Veritabanı Adı"
      value       = aws_db_instance.todo_mysql_db.db_name
    }

    output "db_user" {
      description = "Veritabanı Kullanıcı Adı"
      value       = aws_db_instance.todo_mysql_db.username
    }

    output "db_password" {
      description = "Veritabanı Şifresi (sensitive olarak işaretlendiği için konsolda görünmez)"
      value       = aws_db_instance.todo_mysql_db.password
      sensitive   = true
    }
    

4. Terraform Komutlarını Çalıştırma

Oluşturduğunuz terraform/mysql dizininde terminali açın ve aşağıdaki komutları çalıştırın:

  • terraform init: Terraform çalışma dizinini başlatır, sağlayıcı eklentilerini indirir.
  • terraform plan: Uygulanacak değişiklikleri gösteren bir yürütme planı oluşturur. Bu, altyapınızda ne olacağını önizlemenizi sağlar.
  • terraform apply: Oluşturulan planı uygular ve AWS'de kaynakları oluşturur. Sizden onay isteyecektir.
  • terraform destroy: Oluşturulan tüm kaynakları siler. Dikkatli kullanın!

terraform apply komutunu çalıştırırken db_password değişkeni için bir değer girmeniz istenecektir. Bu şifreyi güvenli bir şekilde saklayın.

Vaka Analizi: Büyük Bir Girişimde Terraform'un Rolü

"BulutDepo" adında büyük bir bulut tabanlı depolama hizmeti, her müşterisi için izole ve güvenli bir veritabanı altyapısı sağlamak zorundaydı. Her yeni müşteri eklendiğinde manuel olarak RDS instance'ları, güvenlik grupları ve ağ yapılandırmaları oluşturmak, hem zaman alıcı hem de hataya açıktı. Terraform'u benimseyerek, yeni bir müşteri kaydolduğunda, bir API çağrısı tetikleniyor ve Terraform modülleri, saniyeler içinde yeni, özelleştirilmiş ve tamamen izole bir MySQL RDS instance'ını devreye alıyordu. Bu otomasyon, BulutDepo'nun müşteri onboarding süresini %80 oranında azalttı ve operasyonel maliyetleri düşürürken, altyapının tutarlılığını ve güvenliğini önemli ölçüde artırdı. Bu, Terraform'un altyapı otomasyonu ve bulut altyapısı yönetimindeki gücünü gösteren etkileyici bir örnektir.

Next.js Uygulamasının Terraform ile Dağıtımı ve Entegrasyonu

Artık hem Next.js Todo uygulamamız hem de Terraform ile yönetilen MySQL veritabanımız hazır. Sıradaki adım, bu iki bileşeni bir araya getirmek ve uygulamamızı bulut ortamına dağıtmaktır. Bu entegrasyon, uygulamanın veritabanına erişmesini ve verileri kullanmasını sağlayarak tam işlevsellik kazanmasına olanak tanır. Genellikle Next.js uygulamalarını Vercel gibi platformlara dağıtırız, ancak Terraform ile altyapı otomasyonunun entegrasyonunu göstermek için AWS EC2 üzerinde kendi sunucumuzu kurma senaryosunu ele alalım. Bu, CI/CD entegrasyonu ve dağıtım stratejileri konularında daha fazla kontrol sağlar.

1. Terraform Outputlarını Next.js Uygulamasına Aktarma

Önceki bölümde Terraform ile MySQL RDS örneğimizi oluşturduğumuzda, outputs.tf dosyasında veritabanı uç noktası, kullanıcı adı ve şifre gibi önemli bilgileri tanımlamıştık. Bu bilgilere Next.js uygulamamızın erişmesi gerekiyor. En güvenli yol, bu bilgileri doğrudan .env dosyasına yazmak yerine, bulut sağlayıcımızın gizli yönetim hizmetleri aracılığıyla sağlamaktır. AWS için Systems Manager (SSM) Parameter Store'u kullanabiliriz.

Terraform ile SSM Parametrelerini Oluşturma (main.tf dosyanıza ekleyin)


    # main.tf (outputs.tf dosyasındaki db_password çıktısını kaldırıp buraya ekleyebilirsiniz)

    # AWS Systems Manager Parameter Store'a veritabanı bilgilerini kaydetme
    resource "aws_ssm_parameter" "db_endpoint" {
      name        = "/todo-app/db/endpoint"
      type        = "String"
      value       = aws_db_instance.todo_mysql_db.address
      description = "Todo App MySQL Database Endpoint"
    }

    resource "aws_ssm_parameter" "db_name" {
      name        = "/todo-app/db/name"
      type        = "String"
      value       = aws_db_instance.todo_mysql_db.db_name
      description = "Todo App MySQL Database Name"
    }

    resource "aws_ssm_parameter" "db_user" {
      name        = "/todo-app/db/user"
      type        = "String"
      value       = aws_db_instance.todo_mysql_db.username
      description = "Todo App MySQL Database User"
    }

    resource "aws_ssm_parameter" "db_password" {
      name        = "/todo-app/db/password"
      type        = "SecureString" # Hassas veriler için SecureString kullanın
      value       = var.db_password
      description = "Todo App MySQL Database Password"
    }
    

terraform apply komutunu tekrar çalıştırarak bu parametreleri AWS SSM'e kaydedin. SecureString tipi, şifrelerin şifreli olarak saklanmasını sağlar.

2. Next.js Uygulamasını AWS EC2'ye Dağıtma

Next.js uygulamasını AWS EC2'ye dağıtmak için aşağıdaki adımları izleyebiliriz:

  1. EC2 Instance Oluşturma (Terraform ile veya manuel):

    Terraform ile bir EC2 instance'ı da otomatik olarak oluşturabilirsiniz. main.tf dosyanıza aşağıdaki bloğu ekleyin (örneğin bir Ubuntu sunucusu):

    
                # main.tf - EC2 Instance Tanımı
    
                resource "aws_instance" "todo_app_server" {
                  ami           = "ami-0abcdef1234567890" # Uygun bir Ubuntu AMI ID'si ile değiştirin
                  instance_type = "t3.micro"
                  key_name      = "my-ssh-key" # Mevcut bir SSH key çiftinizin adı
                  vpc_security_group_ids = [aws_security_group.app_sg.id] # Uygulama güvenlik grubunuz
                  subnet_id     = aws_subnet.public[0].id # Public subnetlerden birini seçin
                  user_data     = file("setup_script.sh") # Başlangıç scripti
                  tags = {
                    Name = "todo-app-server"
                  }
                }
    
                resource "aws_security_group" "app_sg" {
                  name        = "todo-app-sg"
                  description = "Allow HTTP/HTTPS traffic to Next.js app"
                  vpc_id      = aws_vpc.main.id
    
                  ingress {
                    from_port   = 80
                    to_port     = 80
                    protocol    = "tcp"
                    cidr_blocks = ["0.0.0.0/0"]
                  }
                  ingress {
                    from_port   = 443
                    to_port     = 443
                    protocol    = "tcp"
                    cidr_blocks = ["0.0.0.0/0"]
                  }
                  egress {
                    from_port   = 0
                    to_port     = 0
                    protocol    = "-1"
                    cidr_blocks = ["0.0.0.0/0"]
                  }
                }
                

    setup_script.sh dosyasında, Node.js, npm, Nginx gibi bağımlılıkları yükleyebilir ve uygulamayı başlatmak için gerekli adımları tanımlayabilirsiniz.

  2. Ortam Değişkenlerini Çekme:

    EC2 sunucunuzda, AWS CLI'yi kullanarak SSM Parameter Store'dan veritabanı kimlik bilgilerini çekebilirsiniz:

    
                # EC2 sunucusu üzerinde
                export DB_HOST=$(aws ssm get-parameter --name "/todo-app/db/endpoint" --query "Parameter.Value" --output text --with-decryption)
                export DB_USER=$(aws ssm get-parameter --name "/todo-app/db/user" --query "Parameter.Value" --output text --with-decryption)
                export DB_PASSWORD=$(aws ssm get-parameter --name "/todo-app/db/password" --query "Parameter.Value" --output text --with-decryption)
                export DB_NAME=$(aws ssm get-parameter --name "/todo-app/db/name" --query "Parameter.Value" --output text --with-decryption)
    
                # Bu değişkenleri Next.js uygulaması çalıştırılmadan önce ortamda bulunduğundan emin olun.
                

    Uygulamanız bu ortam değişkenlerini kullanarak veritabanına bağlanacaktır.

  3. Next.js Uygulamasını Derleme ve Çalıştırma:

    EC2 sunucunuza SSH ile bağlandıktan sonra, Git ile uygulama kodunuzu çekin, bağımlılıkları yükleyin ve uygulamayı derleyin:

    
                git clone 
                cd todo-app
                npm install
                npm run build
                npm start
                

    npm start komutu genellikle uygulamanızı varsayılan olarak 3000 numaralı portta çalıştırır. Nginx gibi bir ters proxy (reverse proxy) kullanarak 80 veya 443 numaralı portlardan erişimi sağlayabilirsiniz.

3. Sürekli Entegrasyon ve Sürekli Teslimat (CI/CD) Entegrasyonu

Geliştirme sürecini daha verimli hale getirmek için CI/CD pipeline'ları kritik öneme sahiptir. GitHub Actions, GitLab CI veya Jenkins gibi araçları kullanarak otomatik test ve dağıtım iş akışları oluşturabilirsiniz:

  • Kod Değişikliği (GitHub Push): Geliştirici kodu GitHub'a push eder.
  • CI Aşaması: GitHub Actions, kodun testlerini çalıştırır, lint kontrolü yapar.
  • Terraform Plan: Terraform planı oluşturulur ve altyapıda yapılacak değişiklikler gözden geçirilir.
  • Terraform Apply (Manuel Onay ile): Altyapı değişiklikleri uygulanır (üretim ortamında genellikle manuel onay gereklidir).
  • Next.js Build: Next.js uygulaması derlenir.
  • Dağıtım: Derlenmiş Next.js uygulaması EC2 sunucusuna (SCP, Rsync veya CodeDeploy ile) kopyalanır ve uygulama yeniden başlatılır.

    # Örnek GitHub Actions Workflow (.github/workflows/deploy.yml)
    name: Deploy Next.js Todo App

    on:
      push:
        branches:
          - main

    jobs:
      deploy:
        runs-on: ubuntu-latest
        steps:
          - name: Checkout Code
            uses: actions/checkout@v3

          - name: Set up Node.js
            uses: actions/setup-node@v3
            with:
              node-version: '18'

          - name: Install Dependencies
            run: npm install

          - name: Build Next.js App
            run: npm run build

          - name: Configure AWS Credentials
            uses: aws-actions/configure-aws-credentials@v1
            with:
              aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
              aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
              aws-region: eu-central-1

          - name: Install Terraform
            uses: hashicorp/setup-terraform@v2
            with:
              terraform_version: 1.5.0

          - name: Terraform Init
            run: terraform init
            working-directory: ./terraform/mysql # Terraform yapılandırma dosyanızın yolu

          - name: Terraform Apply (Auto Approve for demo, use manual approval in prod)
            run: terraform apply -auto-approve -var="db_password=${{ secrets.DB_PASSWORD }}"
            working-directory: ./terraform/mysql

          - name: Get DB Endpoint from SSM
            id: get-db-endpoint
            run: echo "DB_ENDPOINT=$(aws ssm get-parameter --name "/todo-app/db/endpoint" --query "Parameter.Value" --output text --with-decryption)" >> $GITHUB_ENV

          - name: Get DB Name from SSM
            id: get-db-name
            run: echo "DB_NAME=$(aws ssm get-parameter --name "/todo-app/db/name" --query "Parameter.Value" --output text --with-decryption)" >> $GITHUB_ENV

          - name: Get DB User from SSM
            id: get-db-user
            run: echo "DB_USER=$(aws ssm get-parameter --name "/todo-app/db/user" --query "Parameter.Value" --output text --with-decryption)" >> $GITHUB_ENV

          - name: Get DB Password from SSM
            id: get-db-password
            run: echo "DB_PASSWORD=$(aws ssm get-parameter --name "/todo-app/db/password" --query "Parameter.Value" --output text --with-decryption)" >> $GITHUB_ENV

          - name: Deploy to EC2
            uses: easingthemes/ssh-deploy@main
            with:
              ssh_private_key: ${{ secrets.SSH_PRIVATE_KEY }}
              source: ./out/ # Next.js build output (e.g. for static export, or if bundling server files)
              target: /var/www/todo-app/
              host: ${{ secrets.EC2_HOST }}
              user: ubuntu
              script: |
                # Ortam değişkenlerini ayarlayın
                echo "DB_HOST=${{ env.DB_ENDPOINT }}" > /var/www/todo-app/.env.production
                echo "DB_NAME=${{ env.DB_NAME }}" >> /var/www/todo-app/.env.production
                echo "DB_USER=${{ env.DB_USER }}" >> /var/www/todo-app/.env.production
                echo "DB_PASSWORD=${{ env.DB_PASSWORD }}" >> /var/www/todo-app/.env.production
                # Uygulamayı yeniden başlatın (örneğin PM2 kullanıyorsanız)
                pm2 restart todo-app || pm2 start npm --name "todo-app" -- start

    

Bu bölüm, Next.js uygulamanızı Terraform ile oluşturduğunuz MySQL altyapısıyla entegre etme ve buluta dağıtma sürecini kapsar. Sürekli entegrasyon, sürekli teslimat, AWS IAM ve secrets manager gibi kavramlar, modern DevOps uygulamalarının vazgeçilmez bir parçasıdır. Bu entegrasyon, geliştiricilere daha hızlı, daha güvenilir ve daha yönetilebilir bir dağıtım süreci sunar.

İleri Düzey Optimizasyonlar ve Güvenlik İpuçları

Bir Todo uygulamasını temel seviyede çalıştırmak yeterli olsa da, gerçek dünya senaryolarında uygulamanızın performansını, güvenliğini ve ölçeklenebilirliğini optimize etmek kritik öneme sahiptir. Bu bölümde, deneyimli geliştiriciler ve DevOps mühendisleri için uygulamalarınızı bir sonraki seviyeye taşıyacak ileri düzey ipuçları ve en iyi uygulamaları ele alacağız. Web güvenliği, performans iyileştirme, izleme ve log yönetimi gibi konulara odaklanacağız.

1. Performans Optimizasyonları

Performans, kullanıcı deneyiminin temelidir. Yavaş bir uygulama, kullanıcıları hızla kaybetmenize neden olabilir:

  • Veritabanı Bağlantı Havuzlama (Connection Pooling): Her istek için yeni bir veritabanı bağlantısı açmak yerine, önceden oluşturulmuş ve yeniden kullanılabilir bağlantılardan oluşan bir havuz kullanın. mysql2/promise kütüphanesini kullanırken createPool ile bu zaten sağlanmıştır. Bu, bağlantı açma/kapama maliyetini azaltarak API yanıt sürelerini düşürür.
  • Sorgu Optimizasyonu ve İndeksleme: Karmaşık sorguları analiz edin (EXPLAIN komutu ile) ve yavaş sorguları iyileştirin. Sıkça kullanılan sütunlara doğru indeksler eklemek (özellikle WHERE ve ORDER BY clause'larında kullanılanlara) sorgu hızını önemli ölçüde artırır. Ancak aşırı indeksleme, yazma performansını düşürebilir.
  • Next.js Görüntü Optimizasyonu: Next.js'in bileşenini kullanarak görselleri otomatik olarak optimize edin (doğru boyutlandırma, modern formatlara dönüştürme, lazy loading). Bu, özellikle uygulamanızda görseller kullanıyorsanız (örneğin profil resimleri, ekler) kritik öneme sahiptir.
  • Veri Önbellekleme (Caching): Sık değişmeyen veya sıkça erişilen verileri önbelleğe alın (örneğin Redis veya Memory Cache ile). API rotalarınızda bu verileri doğrudan veritabanından çekmek yerine önbellekten servis etmek, veritabanı yükünü azaltır ve yanıt sürelerini hızlandırır. Next.js'in kendi veri önbellekleme mekanizmaları da vardır.
  • Kod Bölme (Code Splitting) ve Lazy Loading: Next.js, otomatik olarak kod bölme yapar. Ancak kendi bileşenleriniz için React.lazy ve Suspense kullanarak veya dinamik importlar ile daha ince taneli lazy loading uygulayabilirsiniz. Bu, ilk yükleme boyutunu küçülterek uygulamanızın daha hızlı açılmasını sağlar.

Vaka Analizi: Global Bir Medya Şirketinin Performans Mücadelesi

Global bir medya şirketi olan "HaberAkışı", anlık haber güncellemelerini milyonlarca kullanıcıya ulaştıran bir Next.js uygulamasına sahipti. Yüksek trafik zamanlarında veritabanı yavaşlamaları ve API yanıt sürelerinde artışlar yaşanıyordu. Geliştirme ekibi, öncelikle veritabanı bağlantı havuzunu optimize etti ve en sık sorgulanan tablolar için indeksleme stratejilerini gözden geçirdi. Ayrıca, Next.js uygulamasında statik olarak üretilebilecek sayfaları (örneğin kategori sayfaları) getStaticProps ile önbelleğe alarak sunucu yükünü azalttılar. Bu iyileştirmeler sayesinde, yoğun trafik anlarında bile API yanıt sürelerinde %50'ye varan iyileşme kaydettiler ve kullanıcı deneyimini önemli ölçüde artırdılar. Bu durum, performans iyileştirmenin sadece kod değil, aynı zamanda altyapı ve mimari düzeyinde de yapılması gerektiğini gösterir.

2. Güvenlik İpuçları

Uygulamanızın ve verilerinizin güvenliği her zaman en öncelikli konulardan biri olmalıdır:

  • SQL Enjeksiyonu Önleme: Veritabanı sorgularında parametreli sorgular veya ORM'ler (Prisma, Knex.js) kullanarak SQL enjeksiyon saldırılarını engelleyin. mysql2/promise kütüphanesi, pool.execute() metodunda parametreleri otomatik olarak güvenli bir şekilde işler. Asla kullanıcı girdilerini doğrudan SQL sorgularına katmayın.
  • Girdi Doğrulama (Input Validation): Kullanıcıdan gelen tüm girdileri (hem ön yüzde hem de API rotalarında) sunucu tarafında mutlaka doğrulayın. Yanlış veya kötü niyetli verilerin veritabanına girmesini engelleyin. Örneğin, görev metni boş bırakılmamalı veya belirli bir karakter uzunluğunu aşmamalıdır.
  • CORS (Cross-Origin Resource Sharing): Next.js API rotalarınızın yalnızca yetkili alan adlarından istek kabul ettiğinden emin olun. Genellikle aynı origin'den istek yapıldığı için bu varsayılan olarak korunur, ancak ayrı bir front-end/back-end dağıtımı yapıyorsanız dikkat etmek gerekir.
  • HTTPS Kullanımı: Tüm ağ iletişimini (hem ön yüz hem de API rotaları için) TLS/SSL ile şifreleyin (HTTPS). Bu, verilerin ağ üzerinde şifresiz iletilmesini engelleyerek ortadaki adam (Man-in-the-Middle) saldırılarına karşı koruma sağlar. Bir ters proxy (Nginx) veya bir CDN (CloudFront) kullanarak kolayca HTTPS uygulayabilirsiniz.
  • Terraform State Yönetimi: Terraform state dosyası (.tfstate), altyapınızın mevcut durumunu ve hassas bilgileri (örneğin veritabanı şifreleri) içerebilir. Bu dosyayı asla yerel olarak veya versiyon kontrolünde saklamayın. Uzak bir backend (örneğin AWS S3 kovası ve DynamoDB kilitlemesi ile) kullanarak güvenli bir şekilde depolayın.
  • Kimlik ve Erişim Yönetimi (IAM): AWS'de, Next.js uygulamanızın veya CI/CD boru hattınızın yalnızca ihtiyaç duyduğu minimum yetkilere sahip olmasını sağlayın (Least Privilege Principle). Örneğin, EC2 instance'ınızın yalnızca SSM parametrelerine okuma izni ve RDS'e bağlanma izni olmalıdır.

3. Ölçeklenebilirlik

Uygulamanız büyüdükçe, daha fazla kullanıcıyı ve veriyi yönetebilmelidir:

  • Veritabanı Okuma Replikaları: Yoğun okuma trafiği olan uygulamalarda, MySQL veritabanınızdan okuma replikaları oluşturarak okuma yükünü dağıtabilirsiniz. Yazma işlemleri ana veritabanına giderken, okuma işlemleri replikalara yönlendirilir.
  • Yatay Ölçekleme (Next.js Serverless Functions): Next.js API rotaları, varsayılan olarak sunucusuz fonksiyonlar olarak ölçeklenebilir bir yapıya sahiptir. Eğer kendi EC2 sunucunuzda çalıştırıyorsanız, uygulamanızın birden fazla örneğini aynı yük dengeleyicinin arkasında çalıştırarak yatay ölçekleme yapabilirsiniz.
  • Terraform Modülleri: Altyapı kodunuzu tekrar kullanılabilir modüllere ayırarak karmaşık altyapıların yönetimini basitleştirin ve tutarlılığı artırın. Örneğin, bir "MySQL modülü" veya bir "Next.js uygulama sunucusu modülü" oluşturabilirsiniz.

4. İzleme ve Günlükleme (Monitoring & Logging)

Uygulamanızın sağlıklı çalıştığından emin olmak ve sorunları hızlıca tespit etmek için izleme ve günlükleme hayati öneme sahiptir:

  • AWS CloudWatch: RDS ve EC2 instance'larınızın CPU kullanımı, bellek, disk I/O gibi metriklerini CloudWatch ile izleyin. Anormallikler veya eşikler aşıldığında alarmlar kurun.
  • Uygulama Günlükleri: Next.js uygulamanızın API rotalarındaki hataları ve önemli olayları günlükleyin (console.error, console.log). Bu günlükleri merkezi bir günlük yönetim sistemine (örneğin AWS CloudWatch Logs, ELK Stack, Grafana Loki) göndererek kolayca analiz edilebilir hale getirin.
  • Performans İzleme (APM): New Relic, Datadog veya AWS X-Ray gibi Uygulama Performans Yönetimi (APM) araçlarını kullanarak uygulamanızdaki darboğazları tespit edin.

Mobil Uyumlu HTML ve CSS Yaklaşımı (Konsept Örneği)

Makale formatı HTML olsa da, Next.js uygulamanızın mobil uyumlu olmasını sağlamak için CSS media query'lerini kullanmak önemlidir. Örneğin, Tailwind CSS zaten mobil öncelikli bir yaklaşıma sahiptir, ancak özelleştirilmiş CSS kullanıyorsanız:


    /* styles/globals.css veya bir bileşen CSS dosyası */

    .container {
      max-width: 1200px;
      margin: 0 auto;
      padding: 1rem;
    }

    /* Mobil cihazlar için stil */
    @media (max-width: 768px) {
      .container {
        padding: 0.5rem; /* Küçük ekranlarda daha az dolgu */
      }

      .flex-wrapper { /* Örneğin form veya liste elemanları */
        flex-direction: column; /* Mobil görünümde dikey hizalama */
        gap: 1rem;
      }

      .text-4xl {
        font-size: 2.5rem; /* Başlık boyutunu küçült */
      }
    }
    

Bu, Next.js uygulamanızın çeşitli ekran boyutlarında iyi görünmesini sağlar ve mobil uyumlu HTML prensiplerine uygun bir kullanıcı deneyimi sunar.

Bu ileri düzey optimizasyonlar ve güvenlik ipuçları, uygulamanızın sadece çalışmasını değil, aynı zamanda performanslı, güvenli ve sürdürülebilir olmasını sağlar. DevOps mühendisliği ve güvenlik mühendisliği prensipleri, bu süreçte size yol gösterir.

Sonuç ve Gelecek Adımlar

Bu kapsamlı rehberde, modern bir Next.js Todo uygulamasını MySQL veritabanı ve Terraform kullanarak nasıl geliştireceğinizi, dağıtacağınızı ve optimize edeceğinizi adım adım inceledik. Gördüğümüz gibi, bu teknoloji yığını, hızlı geliştirme, otomatik altyapı yönetimi, yüksek performans ve sağlam güvenlik prensiplerini bir araya getirerek güçlü ve ölçeklenebilir web uygulamaları oluşturmak için mükemmel bir temel sunar.

Next.js'in sunucu taraflı renderlama ve API rotaları gibi özellikleri, ön yüz ve arka yüz geliştirmeyi entegre ederek geliştirici verimliliğini artırırken, MySQL'in kanıtlanmış güvenilirliği ve performansı, verilerinizin güvende ve erişilebilir olmasını sağlar. Terraform ise, altyapıyı kod olarak yönetme (IaC) felsefesiyle, altyapı dağıtımını otomatize ederek insan hatasını minimize eder, maliyetleri düşürür ve tutarlılığı garanti eder. Bu üçlünün entegrasyonu, geliştirme ve operasyon ekipleri arasında köprü kurarak, projenin yaşam döngüsü boyunca verimliliği ve güvenilirliği maksimize eder.

Elde ettiğimiz temel faydalar:

  • Hızlı Geliştirme: Next.js'in geliştirici dostu ortamı ve entegre API yetenekleri sayesinde uygulama özellikleri hızla hayata geçirilebilir.
  • Otomatize Altyapı: Terraform ile veritabanı ve uygulama sunucusu gibi altyapı bileşenleri hızlı, tekrarlanabilir ve hatasız bir şekilde sağlanır.
  • Ölçeklenebilirlik: Modern mimariler ve optimize edilmiş yaklaşımlar sayesinde uygulama, artan kullanıcı yüküne kolayca adapte olabilir.
  • Güvenilirlik ve Güvenlik: MySQL'in sağlamlığı, Terraform'un güvenli yapılandırmaları ve ileri düzey güvenlik ipuçları, uygulamanın uzun vadeli başarısını destekler.

Gelecek Adımlar

Bu projenin üzerine inşa edebileceğiniz birçok geliştirme alanı bulunmaktadır:

  • TypeScript Benimsenmesi: Zaten projeyi TypeScript ile başlattık. Daha fazla tip güvenliği ve geliştirici deneyimi için tüm kod tabanında TypeScript'i daha etkin kullanın.
  • GraphQL Entegrasyonu: REST API'leri yerine GraphQL kullanarak veri çekme esnekliğini artırabilir ve istemci tarafında veri yönetimi karmaşıklığını azaltabilirsiniz.
  • Sunucusuz Mimarilere Geçiş: Next.js'in kendisi Vercel üzerinde sunucusuz (serverless) çalışabilir. Veritabanı hariç tüm uygulama mantığını AWS Lambda gibi sunucusuz fonksiyonlara taşıyarak operasyonel yükü daha da azaltabilirsiniz.
  • Docker ve Kapsayıcılaştırma: Uygulamanızı Docker kapsayıcılarına paketleyerek dağıtım ortamından bağımsızlığını artırabilir ve Kubernetes gibi kapsayıcı düzenleme araçlarıyla yönetebilirsiniz.
  • Daha Kapsamlı CI/CD: GitHub Actions veya GitLab CI/CD pipeline'larınızı daha gelişmiş testler, güvenlik taramaları ve otomatik dağıtım stratejileri (Blue/Green, Canary) içerecek şekilde genişletin.
  • Gelişmiş İzleme ve Alarm Sistemleri: Uygulama ve altyapı metriklerini daha detaylı izlemek için Prometheus/Grafana gibi açık kaynaklı araçları entegre edin ve proaktif uyarı sistemleri kurun.

Bu makale, modern web geliştirme dünyasında Next.js, MySQL ve Terraform üçlüsünün nasıl entegre edilebileceğine dair kapsamlı bir yol haritası sunmaktadır. Bu bilgilerle, kendi dinamik ve ölçeklenebilir uygulamalarınızı güvenle inşa edebilir, full-stack geliştirici veya DevOps mühendisi olarak yetkinliklerinizi bir üst seviyeye taşıyabilirsiniz. Başarılar dileriz!

Sıkça Sorulan Sorular

  • Next.js neden Todo uygulamaları için iyi bir seçimdir?

    Next.js, hızlı geliştirme süreçleri, güçlü performans optimizasyonları (SSR, SSG), entegre API rotaları ve otomatik kod bölme gibi özellikleriyle modern web uygulamaları için mükemmel bir seçimdir. Todo uygulamaları gibi etkileşimli kullanıcı arayüzleri gerektiren projelerde, Next.js'in React tabanlı yapısı ve geliştirici deneyimi odaklı yaklaşımı, hem ön yüz hem de basit arka yüz ihtiyaçlarını aynı çatı altında karşılayarak geliştirme verimliliğini artırır.

  • Terraform kullanmak ne gibi avantajlar sağlar?

    Terraform, altyapıyı kod olarak (IaC) yönetme prensibini benimseyerek, altyapı dağıtımını otomatize eder, insan hatalarını azaltır ve tekrarlanabilirliği artırır. Geliştirme, test ve üretim ortamları arasında tutarlılık sağlar, altyapı değişikliklerini versiyon kontrolüne tabi tutar ve karmaşık bulut altyapılarının yönetimini basitleştirir. Bu, DevOps süreçlerini hızlandırır ve operasyonel maliyetleri düşürür.

  • MySQL yerine başka bir veritabanı kullanabilir miyim?

    Kesinlikle! Bu makalede MySQL kullanıldı, ancak Next.js API rotaları aracılığıyla PostgreSQL, MongoDB, SQLite veya diğer NoSQL veritabanları gibi farklı veritabanlarını da entegre edebilirsiniz. Seçiminiz projenizin özel gereksinimlerine (veri yapısı, ölçeklenebilirlik ihtiyacı, ekosistem tercihi) bağlı olacaktır. Terraform da bu veritabanlarının bulut hizmetlerini (örneğin AWS DynamoDB, Azure Cosmos DB) oluşturmak için ilgili sağlayıcıları ve kaynakları destekler.

  • Uygulamayı Vercel'e dağıtırken Terraform kullanmak mantıklı mı?

    Evet, mantıklıdır. Vercel, Next.js uygulamalarının front-end ve API rotalarının dağıtımını büyük ölçüde otomatize etse de, genellikle veritabanı gibi kalıcı kaynakların yönetimini kapsamaz. Terraform, bu durumda veritabanı (örneğin AWS RDS MySQL), cache (örneğin Redis) veya diğer harici servisler gibi altyapı bileşenlerini sağlamak ve yönetmek için hala kullanılabilir. Vercel, uygulama kodunuzu dağıtırken, Terraform da uygulamanızın bağlı olduğu arka uç altyapısını yönetir.

  • Veritabanı bağlantı bilgilerini nasıl güvende tutarım?

    Veritabanı bağlantı bilgileri (şifreler gibi) hassas verilerdir ve asla doğrudan kod deposuna (Git) yüklenmemelidir. En iyi uygulama, bu bilgileri ortam değişkenleri aracılığıyla veya bulut sağlayıcılarının gizli yönetim hizmetleri (örneğin AWS Secrets Manager, Azure Key Vault, Google Secret Manager) kullanarak yönetmektir. Terraform ile bu bilgileri güvenli bir şekilde oluşturabilir ve SSM Parameter Store gibi hizmetlere kaydedebilirsiniz, böylece uygulamanızın çalıştığı sunucular bu bilgilere yetkilendirilmiş bir şekilde erişebilir.

Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.