Yapay Zeka ile Kod Yazmak: GitHub Copilot ve Alternatifleri

Yazar:komut.io ekibi
0 Yorum

Geçen ay bir iş arkadaşım bana “Copilot kullanmaya başladım, artık kod yazmıyorum sadece Tab’a basıyorum” dedi. Güldük. Ama sonra düşündüm: bu cümle hem çok doğru hem de çok tehlikeli. Yapay zeka destekli kod yazma araçları artık bir niş teknoloji değil, günlük iş akışımızın bir parçası haline geldi. Sysadmin olarak biz de bu dönüşümün tam ortasındayız. Bash script yazarken, Ansible playbook hazırlarken, Python ile log analizi yaparken yapay zekanın bu araçlarını ne kadar verimli kullanabildiğimiz önemli bir rekabet avantajı haline geliyor.

Bu yazıda GitHub Copilot başta olmak üzere alternatifleri gerçek senaryolar üzerinden ele alacağım. Hangi aracın ne işe yaradığını, sysadmin bakış açısıyla nasıl kullanılabileceğini ve bu araçlara körü körüne güvenmemenin neden kritik olduğunu konuşacağız.

GitHub Copilot: Gerçekten Ne Kadar İşe Yarıyor?

Copilot’u ilk duyduğumda “evet bu da geçer” dedim açıkçası. Ama kullanmaya başlayınca önyargım kırıldı. Özellikle tekrarlayan sistem yönetimi scriptlerinde ciddi zaman kazandırıyor.

Mesela bir log rotasyon scripti yazmam gerektiğinde şöyle bir yorum satırı yazmak yeterli oluyor çoğu zaman:

# /var/log/app dizinindeki 30 günden eski .log dosyalarını sıkıştır ve arşivle

Copilot buradan devam ediyor ve makul bir şey üretiyor. Ama “makul” kelimesinin altını çizmek lazım. Üretilen kodu gözden geçirmeden production’a almak mesleki intihar sayılır.

Copilot’un güçlü olduğu alanlar:

  • Tekrarlayan pattern’ler: Systemd unit dosyaları, cron job yapıları, standart Ansible task blokları
  • API çağrıları: Bulut sağlayıcı SDK’larıyla çalışırken endpoint ve parametre hatırlatma
  • Regex yazımı: Özellikle log parsing için karmaşık regex’leri sıfırdan yazmak yerine hızlıca şekillendirme
  • Dokümantasyon: Fonksiyonlara otomatik yorum ve docstring ekleme

Zayıf kaldığı yerler ise genellikle bağlam gerektiren durumlar. Şirket içi araçlarınızı, özel konfigürasyon yapılarınızı, kurumsal güvenlik gereksinimlerinizi bilmiyor. Bu boşlukları siz dolduracaksınız.

Alternatiflere Bakalım

Tabnine

Tabnine’in en büyük avantajı local model desteği. Eğer çalıştığınız ortamda veri güvenliği hassasiyeti varsa ve kodun dışarı çıkmaması gerekiyorsa, Tabnine’in self-hosted versiyonu makul bir alternatif. Özellikle finans, sağlık veya kamu sektöründe çalışan sysadmin’ler için bu önemli bir faktör.

Kurulum da görece basit:

# Tabnine Enterprise local deployment için Docker ile
docker pull tabnine/tabnine-enterprise:latest
docker run -d 
  --name tabnine-enterprise 
  -p 5555:5555 
  -v /opt/tabnine/data:/data 
  tabnine/tabnine-enterprise:latest

Sonra IDE eklentinizi bu local endpoint’e yönlendiriyorsunuz. Model kalitesi Copilot’a göre biraz geride ama kurumsal ortamlarda bu tradeoff’u kabul edilebilir buluyorum.

Codeium

Ücretsiz katmanı oldukça cömert ve performansı Copilot’a gerçekten yakın. Özellikle bütçe kısıtı olan ekipler veya kişisel projeler için Codeium güçlü bir tercih. VS Code, JetBrains ve hatta Neovim desteği var.

# Neovim için Codeium kurulumu (lazy.nvim ile)
# ~/.config/nvim/lua/plugins/codeium.lua dosyasına ekleyin:
# {
#   "Exafunction/codeium.vim",
#   config = function()
#     vim.keymap.set('i', '<C-g>', function()
#       return vim.fn['codeium#Accept']()
#     end, { expr = true })
#   end
# }

# Terminal üzerinden auth:
# :Codeium Auth

Terminal ağırlıklı çalışan arkadaşlar için Neovim entegrasyonu gerçekten iyi çalışıyor. Bunu bizzat kullandım ve Copilot eklentisinden pek farkını hissetmedim.

Amazon CodeWhisperer (artık Q Developer)

AWS ağırlıklı çalışıyorsanız bu araç dikkat çekiyor. CloudFormation template, CDK kodu, Lambda fonksiyonları yazarken AWS servislerini tanıması ve doğru syntax önermesi güçlü bir özellik. Ayrıca güvenlik taraması da yapıyor, önerdiği kodda bilinen zaafiyetleri işaretleyebiliyor.

# Örnek: S3 bucket listesi çeken Lambda fonksiyonu
# CodeWhisperer bu yorum satırından devam ediyor
import boto3

def lambda_handler(event, context):
    s3_client = boto3.client('s3')
    response = s3_client.list_buckets()
    
    buckets = []
    for bucket in response['Buckets']:
        buckets.append({
            'name': bucket['Name'],
            'creation_date': bucket['CreationDate'].isoformat()
        })
    
    return {
        'statusCode': 200,
        'body': buckets
    }

AWS ekosisteminde yaşıyorsanız bu aracı denemenizi tavsiye ederim. Bireysel kullanım için ücretsiz.

Ollama ile Local LLM Kurulumu

İşte burada işler gerçekten ilginçleşiyor. Eğer internet bağlantısı olmayan bir ortamda çalışıyorsanız veya her şeyin tamamen lokal olmasını istiyorsanız, Ollama ile kendi LLM’inizi ayağa kaldırabilirsiniz.

# Ollama kurulumu
curl -fsSL https://ollama.ai/install.sh | sh

# Kodlama için optimize edilmiş model indirme
ollama pull codellama:13b

# Servis olarak başlatma
sudo systemctl enable ollama
sudo systemctl start ollama

# Test
ollama run codellama:13b "Write a bash script to monitor disk usage"

Sonra Continue (VS Code eklentisi) veya benzer bir araçla bu local endpoint’i IDE’nize bağlayabilirsiniz:

# Continue eklentisi için config.json örneği (~/.continue/config.json)
cat > ~/.continue/config.json << 'EOF'
{
  "models": [
    {
      "title": "CodeLlama Local",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://localhost:11434"
    }
  ]
}
EOF

Donanım gereksinimleri konusunda gerçekçi olmak lazım: 13B model için 16GB RAM minimum, tercihen bir GPU. Daha küçük 7B modellerle 8GB RAM’de de çalışabilirsiniz ama yanıt kalitesi düşüyor.

Sysadmin Senaryolarında Pratik Kullanım

Senaryo 1: Ansible Playbook Yazımı

Büyük bir altyapı değişikliği için Ansible playbook hazırlamak bazen yorucu olabiliyor. Özellikle idempotency’yi doğru sağlamak, hata yönetimini eklemek, değişkenleri düzgün tanımlamak… Yapay zeka burada gerçekten hız kazandırıyor.

# Bu yorum bloğunu yapay zekaya verince makul bir başlangıç üretiyor:
# Nginx kurulumu, konfigürasyonu ve HTTPS sertifika yönetimi

---
- name: Web sunucu kurulumu ve yapılandırması
  hosts: webservers
  become: yes
  vars:
    nginx_version: "1.24"
    domain_name: "{{ lookup('env', 'DOMAIN_NAME') }}"
    
  tasks:
    - name: Nginx paketini kur
      ansible.builtin.package:
        name: nginx
        state: present
      
    - name: Nginx servisini başlat ve otomatik başlatmaya ekle
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: yes
        
    - name: Nginx konfigürasyonunu kopyala
      ansible.builtin.template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
        backup: yes
      notify: nginx_reload
      
  handlers:
    - name: nginx_reload
      ansible.builtin.service:
        name: nginx
        state: reloaded

Tabii üretilen kodu olduğu gibi almıyorum. notify hook’larının doğru çalışıp çalışmadığını kontrol ediyorum, değişken isimlerini standartlarıma uygun değiştiriyorum, become direktifini gerçekten gerekip gerekmediğini düşünüyorum.

Senaryo 2: Log Analizi için Python Scripti

Şöyle bir durum düşünün: Yüzlerce sunucudan gelen Apache log’larını analiz edip şüpheli IP’leri çıkarmanız gerekiyor. Regex yazmak, pandas kullanımı, çıktı formatlama… Yapay zekaya şöyle bir prompt vermek yeterli:

# Apache access log'larından son 24 saatte 100'den fazla 
# 404 hatası üreten IP'leri bul ve raporla

import re
import sys
from datetime import datetime, timedelta
from collections import defaultdict

def parse_apache_log(log_file):
    pattern = r'(d+.d+.d+.d+).*[(.+?)].*" (d+) '
    error_counts = defaultdict(int)
    cutoff_time = datetime.now() - timedelta(hours=24)
    
    with open(log_file, 'r') as f:
        for line in f:
            match = re.search(pattern, line)
            if match:
                ip = match.group(1)
                status = match.group(3)
                
                if status == '404':
                    error_counts[ip] += 1
    
    suspicious = {ip: count for ip, count in error_counts.items() 
                  if count > 100}
    return suspicious

def main():
    log_file = sys.argv[1] if len(sys.argv) > 1 else '/var/log/apache2/access.log'
    
    suspicious_ips = parse_apache_log(log_file)
    
    if suspicious_ips:
        print(f"Şüpheli IP'ler ({len(suspicious_ips)} adet):")
        for ip, count in sorted(suspicious_ips.items(), 
                                 key=lambda x: x[1], reverse=True):
            print(f"  {ip}: {count} adet 404 hatası")
    else:
        print("Şüpheli aktivite tespit edilmedi.")

if __name__ == '__main__':
    main()

Bu kodu ürettikten sonra yaptığım şey: tarih bazlı filtrelemeyi düzgün implemente edip etmediğini kontrol etmek, büyük log dosyalarında bellek yönetimini düşünmek (generator kullanmak gerekebilir), edge case’leri test etmek.

Senaryo 3: Terraform ile Altyapı Kodu

# AWS'de çok katmanlı uygulama için VPC ve subnet yapısı
# Copilot bu kısmı oldukça iyi tamamlıyor

resource "aws_vpc" "main" {
  cidr_block           = var.vpc_cidr
  enable_dns_hostnames = true
  enable_dns_support   = true
  
  tags = {
    Name        = "${var.project_name}-vpc"
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

resource "aws_subnet" "private" {
  count             = length(var.availability_zones)
  vpc_id            = aws_vpc.main.id
  cidr_block        = cidrsubnet(var.vpc_cidr, 4, count.index)
  availability_zone = var.availability_zones[count.index]
  
  tags = {
    Name = "${var.project_name}-private-${count.index + 1}"
    Tier = "private"
  }
}

Terraform önerileri genellikle syntax açısından doğru geliyor ama provider versiyonuna göre deprecated özellikler önerebiliyor. Daima terraform validate ve terraform plan çalıştırın.

Güvenlik ve Dikkat Edilmesi Gerekenler

Bu araçların yarattığı en büyük risk, üretilen koda körü körüne güven duymak. Birkaç somut risk:

Gizli bilgi sızıntısı: Copilot ve benzeri cloud tabanlı araçlar yazdığınız kodu analiz ederek öneri üretiyor. Eğer kod editörünüzde açık bir dosyada API anahtarı, şifre veya connection string varsa bu bilgi servis sağlayıcısına gönderiliyor olabilir. Her zaman .env dosyalarını ve gizli bilgi içeren config dosyalarını editörünüzde açık tutmayın.

# .gitignore gibi bir .copilotignore veya IDE'nin exclude ayarları
# Hassas dosyaları kapsam dışında tutun

# VS Code settings.json
{
  "github.copilot.enable": {
    "*": true,
    "plaintext": false,
    "markdown": false
  },
  "files.exclude": {
    "**/.env": true,
    "**/secrets.yml": true
  }
}

Eski veya güvensiz pattern’ler: Yapay zeka modelleri belirli bir tarihe kadar olan veriyle eğitildi. Güncel güvenlik açıkları veya yeni deprecation’lar hakkında bilgisi olmayabilir. Ürettiği shell scriptlerde eval kullanımı, Python’da pickle.loads() ile güvensiz deserialization veya eski TLS konfigürasyonları görebilirsiniz.

İdempotency yanılsaması: Özellikle Ansible ve Terraform önerilerinde görüyorum bunu. Araç syntactically doğru bir şey üretiyor ama idempotent değil. İkinci çalıştırmada farklı sonuç veriyor.

# Yapay zekanın önerebileceği (idempotent DEĞİL):
echo "export PATH=$PATH:/opt/myapp/bin" >> /etc/profile

# Doğru yaklaşım (idempotent):
grep -qxF 'export PATH=$PATH:/opt/myapp/bin' /etc/profile || 
  echo 'export PATH=$PATH:/opt/myapp/bin' >> /etc/profile

Bu farkı görmek için kodu çalıştırmadan önce “bu kodu iki kez çalıştırsam ne olur?” sorusunu sormayı alışkanlık haline getirin.

Araç Seçim Kriterleri

Hangi aracı kullanacağınıza karar verirken şu faktörleri değerlendirin:

  • Veri gizliliği gereksinimleri: Kodun cloud’a gönderilmesi sorun mu? Eğer öyleyse Tabnine Enterprise veya local LLM
  • Bütçe: Bireysel kullanım için Codeium ücretsiz ve yeterince iyi. Takım için Copilot Business veya Tabnine Pro değerlendirilebilir
  • Ekosistem: AWS ağırlıklıysanız Q Developer, genel kullanım için Copilot öne çıkıyor
  • İnternet bağlantısı: Air-gapped ortamlar için tek gerçekçi seçenek local LLM
  • IDE uyumluluğu: Vim/Neovim kullanıyorsanız tüm araçların eşit desteği sunmadığını bilin

Verimliliği Artıran Kullanım Alışkanlıkları

Yapay zeka kod araçlarından maksimum verim almak için bazı pratikler geliştirdim:

Yorum satırlarını Türkçe değil İngilizce yazın. Modeller İngilizce komutlarda çok daha iyi sonuç üretiyor. Türkçe yorum yazıp Türkçe öneri almaya çalışmak hayal kırıklığı yaratıyor.

Spesifik olun. “Disk kontrolü yap” yerine “Check disk usage for all mounted filesystems, alert if any exceeds 80%, log to syslog” gibi detaylı açıklamalar çok daha kullanılabilir kod üretiyor.

# Zayıf prompt:
# Check disk

# Güçlü prompt:
# Check disk usage for all mounted filesystems
# If usage exceeds THRESHOLD (default 80%), send alert via logger
# Skip tmpfs and devtmpfs mounts
# Accept threshold as first argument

#!/bin/bash
THRESHOLD=${1:-80}

df -H | grep -vE '^Filesystem|tmpfs|devtmpfs|udev' | awk '{print $5 " " $6}' | 
while read output; do
    usage=$(echo "$output" | awk '{print $1}' | sed 's/%//')
    mount=$(echo "$output" | awk '{print $2}')
    
    if [ "$usage" -ge "$THRESHOLD" ]; then
        logger -t disk_monitor "WARNING: $mount kullanimi %$usage (esik: %$THRESHOLD)"
        echo "UYARI: $mount - %$usage dolu"
    fi
done

Üretilen kodu kabul etmeden önce mentalize olun. “Bu kodu production’a almadan önce ne test ederim?” sorusunu sorun. Genellikle edge case’ler, hata durumları ve güvenlik kontrolleri eksik olur.

Sonuç

Yapay zeka kod araçları, sysadmin ve DevOps dünyasında gerçek bir verimlilik artışı sunuyor. Bunu inkâr etmek mesleki gelişimi reddetmek gibi bir şey. Ama bu araçların “kod yazar, ben onaylayıp geçerim” modunda kullanılması tehlikeli bir yanılsama.

En doğru zihinsel model şu: yapay zeka araçları sizi iyi bir sysadmin yapmıyor, iyi bir sysadmin’i daha hızlı yapıyor. Temel kavramları anlamadan, kodu neden o şekilde yazıldığını bilmeden, güvenlik ve operasyonel riskleri değerlendirmeden bu araçları kullanmak ciddi sorunlara kapı aralıyor.

Hangi araçla başlayacaksınız sorusunun cevabı pratikte çok önemli değil. Codeium ile başlayın, Copilot deneyin, local LLM kurun ve karşılaştırın. Önemli olan bu araçları iş akışınıza entegre ederken eleştirel bakışı kaybetmemek. Tab’a basarken ne kabul ettiğinizi bilin.

Bir yanıt yazın

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