IntelliJ IDEA ile Uzak Sunucuda Java Geliştirme

Yazar:komut.io ekibi Java ve JVM Ortamı Kurulumu
0 Yorum

Uzak sunucuda Java geliştirme yapmak, özellikle büyük ekiplerde veya güçlü donanıma ihtiyaç duyulan projelerde oldukça yaygın bir senaryo. Yerel makinende 8 GB RAM ile uğraşırken, sunucudaki 64 GB’lık sistemi kullanabilmek gerçekten oyun değiştirici. IntelliJ IDEA’nın uzak geliştirme özellikleri sayesinde bu iş artık çok daha akıcı hale geldi. Bu yazıda adım adım her şeyi ele alacağız.

Neden Uzak Sunucuda Java Geliştirme?

Önce “neden” sorusunu cevaplayalım. Çünkü herkes için gerekli olmayabilir ama bazı senaryolarda hayat kurtarır.

  • Kaynak yoğun projeler: Büyük Spring Boot uygulamaları, microservice mimarileri veya Kafka entegrasyonlu sistemler yerel makinede derleme yaparken dakikalarca beklemenize neden olabilir.
  • Tutarlı geliştirme ortamı: Takımdaki herkes aynı sunucuya bağlanırsa “bende çalışıyor ama sende çalışmıyor” problemi ortadan kalkar.
  • Güvenlik gereksinimleri: Bazı şirketlerde kod yerel makinelere çekilemiyor, sadece sunucuda çalışılabiliyor.
  • Düşük güçlü istemci makineler: Eski bir laptop veya ince istemci varsa, tüm ağır işi sunucuya yaptırabilirsiniz.

Ortam Gereksinimleri

Başlamadan önce hem istemci hem sunucu tarafında bazı şeylerin hazır olması gerekiyor.

Sunucu tarafında:

  • Linux tabanlı işletim sistemi (Ubuntu 22.04, RHEL 9 veya benzeri)
  • JDK 17 veya üzeri (LTS versiyonu önerilir)
  • SSH erişimi (anahtar tabanlı doğrulama şiddetle tavsiye edilir)
  • En az 4 GB RAM (8 GB ideal)
  • IntelliJ IDEA Remote Development için yeterli disk alanı (en az 5 GB)

İstemci tarafında:

  • IntelliJ IDEA 2022.3 veya üzeri (Gateway özelliği bu versiyondan itibaren kararlı)
  • SSH istemcisi
  • Stabil internet bağlantısı

Sunucuda JDK Kurulumu

Uzak sunucunuza SSH ile bağlandıktan sonra JDK kurulumunu yapın. Ubuntu için:

sudo apt update && sudo apt upgrade -y
sudo apt install -y openjdk-21-jdk openjdk-21-jdk-headless

# Kurulumu doğrula
java -version
javac -version

# JAVA_HOME ayarla
echo 'export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64' >> ~/.bashrc
echo 'export PATH=$JAVA_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

RHEL veya CentOS tabanlı sistemler için:

sudo dnf install -y java-21-openjdk java-21-openjdk-devel

# Alternatif olarak SDKMAN ile
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install java 21.0.3-tem
sdk use java 21.0.3-tem

SDKMAN’i özellikle tavsiye ediyorum çünkü birden fazla JDK versiyonu arasında kolayca geçiş yapmanızı sağlıyor. Özellikle farklı Java versiyonu gerektiren projeler arasında çalışıyorsanız çok işe yarıyor.

SSH Anahtar Tabanlı Doğrulama Kurulumu

Parola ile SSH bağlantısı hem güvensiz hem de IntelliJ IDEA ile çalışırken can sıkıcı olur. Anahtar tabanlı doğrulamayı kuralım:

# İstemci makinede (yerel bilgisayarınızda)
ssh-keygen -t ed25519 -C "intellij-remote-dev" -f ~/.ssh/intellij_remote

# Anahtarı sunucuya kopyala
ssh-copy-id -i ~/.ssh/intellij_remote.pub kullanici@sunucu-ip

# SSH config dosyasına ekle (istemci tarafında)
cat >> ~/.ssh/config << 'EOF'
Host uzak-java-sunucu
    HostName sunucu-ip-adresi
    User kullanici
    IdentityFile ~/.ssh/intellij_remote
    ServerAliveInterval 60
    ServerAliveCountMax 3
    Compression yes
EOF

ServerAliveInterval ve ServerAliveCountMax ayarları özellikle önemli. Uzak geliştirme sırasında bağlantı kopmaları gerçekten sinir bozucu olabiliyor, bu ayarlar bağlantının diri kalmasına yardımcı oluyor.

IntelliJ IDEA Gateway ile Bağlantı Kurma

IntelliJ IDEA Gateway, JetBrains’in uzak geliştirme için özel olarak geliştirdiği araç. 2022 yılından itibaren oldukça kararlı bir hale geldi.

Adım 1: JetBrains Toolbox uygulamasını açın veya doğrudan IntelliJ IDEA’dan File > Remote Development menüsüne gidin.

Adım 2: “SSH Connection” seçeneğini seçin.

Adım 3: Bağlantı bilgilerini girin:

  • Host: sunucu-ip-adresi veya SSH config’deki alias
  • Port: 22 (varsayılan)
  • Username: sunucudaki kullanıcı adı
  • Authentication type: Key pair seçin ve özel anahtarı gösterin

Adım 4: Bağlantı kurulduktan sonra IntelliJ IDEA Backend’i sunucuya otomatik olarak indirir ve kurar. Bu işlem ilk seferinde birkaç dakika sürebilir.

Sunucu tarafında IntelliJ Backend’in kurulduğu yeri kontrol etmek için:

# Sunucuda
ls -la ~/.cache/JetBrains/RemoteDev/dist/
# veya
ls -la ~/RemoteDev/

Maven ve Gradle Kurulumu

Proje bağımlılık yönetimi için Maven veya Gradle’ı sunucuya kurmanız gerekiyor.

# Maven kurulumu
sudo apt install -y maven
mvn --version

# Gradle kurulumu (SDKMAN ile)
sdk install gradle 8.7

# Gradle wrapper kullanıyorsanız zaten repo içinde geliyor
# Wrapper'ı çalıştırılabilir yapın
chmod +x ./gradlew
./gradlew --version

Maven için özel bir repository proxy (Nexus veya Artifactory) kullanıyorsanız, settings.xml dosyasını sunucuda da yapılandırmanız gerekiyor:

mkdir -p ~/.m2
cat > ~/.m2/settings.xml << 'EOF'
<settings>
  <mirrors>
    <mirror>
      <id>nexus</id>
      <mirrorOf>*</mirrorOf>
      <url>https://nexus.sirketiniz.com/repository/maven-public/</url>
    </mirror>
  </mirrors>
  <servers>
    <server>
      <id>nexus</id>
      <username>kullanici</username>
      <password>sifre</password>
    </server>
  </servers>
</settings>
EOF

İlk Java Projesini Uzaktan Açma

Sunucuda bir Spring Boot projesi oluşturalım ve bunu IntelliJ Gateway ile açalım.

# Sunucuda Spring Boot projesi oluştur (Spring Initializr CLI ile)
curl https://start.spring.io/starter.tgz 
  -d type=gradle-project 
  -d language=java 
  -d bootVersion=3.3.0 
  -d baseDir=demo-app 
  -d groupId=com.example 
  -d artifactId=demo-app 
  -d name=demo-app 
  -d description="Demo project" 
  -d packageName=com.example.demo 
  -d packaging=jar 
  -d javaVersion=21 
  -d dependencies=web,data-jpa,postgresql 
  | tar -xzvf -

cd demo-app
ls -la

Bu projeyi IntelliJ Gateway üzerinden açmak için bağlantı kurulduktan sonra proje dizinini göstermeniz yeterli. IntelliJ otomatik olarak Gradle yapılandırmasını okuyacak ve indexlemeye başlayacak.

Port Yönlendirme ile Yerel Erişim

Uzak sunucuda çalışan uygulamanıza yerel makinenizden erişmek için SSH port yönlendirme kullanabilirsiniz. IntelliJ IDEA Gateway bunu genellikle otomatik yapıyor ama manuel yapılandırma gerektiğinde:

# Yerel makinede - sunucunun 8080 portunu lokale yönlendir
ssh -L 8080:localhost:8080 -N kullanici@sunucu-ip &

# Spring Boot uygulamasını debug moduyla başlat (sunucuda)
./gradlew bootRun --debug-jvm

# Debug portu da ekle
ssh -L 8080:localhost:8080 -L 5005:localhost:5005 -N kullanici@sunucu-ip &

IntelliJ IDEA Gateway kullanırken genellikle bu port yönlendirmesini otomatik olarak hallediyor. Ancak özellikle docker container içinde çalışan uygulamalar için manuel yapılandırma gerekebilir.

Remote Debugging Konfigürasyonu

Uzak sunucuda çalışan bir Java uygulamasını debug etmek için JVM JDWP protokolünü kullanıyoruz.

# Uygulamayı debug modunda başlat (sunucuda)
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 
     -jar target/demo-app-0.0.1-SNAPSHOT.jar

# Gradle ile
./gradlew bootRun 
  --args='--spring.profiles.active=dev' 
  -Dorg.gradle.jvmargs='-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005'

IntelliJ IDEA’da Remote Debug konfigürasyonu oluşturmak için:

  • Run > Edit Configurations menüsüne gidin
  • + butonuna tıklayıp Remote JVM Debug seçin
  • Host: localhost (port yönlendirme kullanıyorsanız) veya sunucu IP
  • Port: 5005
  • Command line arguments for remote JVM kısmındaki değeri kopyalayıp uygulamanızı başlatırken kullanın

Gateway kullanırken bu debug bağlantısı genellikle tünel üzerinden otomatik kurulur, ayrıca bir şey yapmanıza gerek kalmaz.

Performans Optimizasyonu

Uzak geliştirmede en büyük sorun gecikme ve performans. Birkaç önemli ayar var:

# Sunucuda JVM heap ayarlarını optimize et (IntelliJ Backend için)
# ~/.config/JetBrains/RemoteDev-IU/idea.vmoptions dosyasını düzenle
cat >> ~/.config/JetBrains/RemoteDev-IU/idea.vmoptions << 'EOF'
-Xms512m
-Xmx4g
-XX:ReservedCodeCacheSize=512m
-XX:+UseG1GC
-XX:SoftRefLRUPolicyMSPerMB=50
EOF

IntelliJ IDEA ayarlarında:

  • Settings > Appearance & Behavior > System Settings > Project altında Power Save Mode’u kapatın
  • Settings > Editor > General > Code Folding altında gereksiz folding’leri devre dışı bırakın
  • Indexing sırasında CPU kullanımını sınırlamak için Settings > Advanced Settings > Maximum number of indexing threads değerini ayarlayın

Ağ gecikmesini azaltmak için:

  • Mümkünse sunucuya yakın bir coğrafi konumda çalışın
  • VPN kullanıyorsanız split tunneling’i etkinleştirin (sadece sunucu trafiği VPN’den geçsin)
  • SSH compression’ı etkinleştirin (zaten SSH config’e ekledik)

Docker ile Geliştirme Ortamı İzolasyonu

Birden fazla geliştirici aynı sunucuyu kullanıyorsa, Docker ile izole ortamlar oluşturmak mantıklı:

# Sunucuda Dockerfile oluştur
cat > Dockerfile.dev << 'EOF'
FROM eclipse-temurin:21-jdk-jammy

RUN apt-get update && apt-get install -y 
    git 
    curl 
    vim 
    && rm -rf /var/lib/apt/lists/*

# Maven kur
RUN curl -fsSL https://archive.apache.org/dist/maven/maven-3/3.9.6/binaries/apache-maven-3.9.6-bin.tar.gz 
    | tar -xzf - -C /opt/ 
    && ln -s /opt/apache-maven-3.9.6 /opt/maven

ENV MAVEN_HOME=/opt/maven
ENV PATH=$MAVEN_HOME/bin:$PATH

WORKDIR /workspace
EXPOSE 8080 5005

CMD ["/bin/bash"]
EOF

# Container'ı başlat
docker run -it --rm 
  -p 8080:8080 
  -p 5005:5005 
  -v $(pwd)/demo-app:/workspace 
  -v ~/.m2:/root/.m2 
  --name java-dev 
  java-dev-image

IntelliJ IDEA Gateway aynı zamanda Docker container’lara da doğrudan bağlanabilir. Remote Development > Docker seçeneğinden container’ı seçip bağlanabilirsiniz.

Gerçek Dünya Senaryosu: Takım Ortamında Çalışma

Bir fintech projesinde karşılaştığım senaryo şuydu: 6 kişilik geliştirici ekibi, aynı Kafka cluster ve PostgreSQL veritabanına bağlı microservice’ler geliştiriyordu. Yerel makinelerde her servis için ayrı ayrı docker-compose çalıştırmak kaosa yol açıyordu.

Çözüm: Paylaşımlı bir geliştirme sunucusu üzerinde her geliştirici için izole namespace’ler.

# Her geliştirici için ayrı port aralığı ve dizin
# /etc/profile.d/dev-ports.sh
DEV_USER=$(whoami)
case $DEV_USER in
    ahmet) export APP_PORT=8081; export DEBUG_PORT=5006 ;;
    mehmet) export APP_PORT=8082; export DEBUG_PORT=5007 ;;
    ayse) export APP_PORT=8083; export DEBUG_PORT=5008 ;;
    *) export APP_PORT=8080; export DEBUG_PORT=5005 ;;
esac

echo "Gelistirici: $DEV_USER | App Port: $APP_PORT | Debug Port: $DEBUG_PORT"

Bu yaklaşımla herkes kendi portunu kullanıyor, çakışma olmuyor. SSH port yönlendirme ile herkes kendi portlarına yerel makinesinden erişiyor.

Yaygın Sorunlar ve Çözümleri

Sorun 1: IntelliJ Backend indirmiyor veya kurulum başarısız

# Sunucuda manuel temizlik yapıp tekrar dene
rm -rf ~/.cache/JetBrains/RemoteDev/
rm -rf ~/RemoteDev/

# Disk alanını kontrol et
df -h ~
# Boş alan en az 5 GB olmalı

Sorun 2: Indexing çok uzun süriyor

# Gereksiz dizinleri exclude et
# .idea/misc.xml veya IntelliJ Settings > Project Structure > Modules
# Build output, node_modules, .gradle dizinlerini excluded olarak işaretle

# Inotify limiti artır (büyük projeler için)
echo "fs.inotify.max_user_watches=524288" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Sorun 3: Bağlantı kopmaları

# SSH config'i güncelle
cat >> ~/.ssh/config << 'EOF'
Host uzak-java-sunucu
    TCPKeepAlive yes
    ServerAliveInterval 30
    ServerAliveCountMax 10
EOF

# Sunucuda sshd_config'i de kontrol et
sudo grep -E "ClientAlive|TCPKeepAlive" /etc/ssh/sshd_config
# ClientAliveInterval 300 ve ClientAliveCountMax 3 olmalı

Sorun 4: Maven/Gradle bağımlılıkları indirilemiyor

# Proxy arkasındaysanız
export JAVA_TOOL_OPTIONS="-Dhttp.proxyHost=proxy.sirket.com -Dhttp.proxyPort=8080 -Dhttps.proxyHost=proxy.sirket.com -Dhttps.proxyPort=8080"

# Maven için
mvn -Dhttp.proxyHost=proxy.sirket.com -Dhttp.proxyPort=8080 dependency:resolve

Güvenlik Önlemleri

Uzak geliştirme ortamı güvenliğini ihmal etmeyin:

  • SSH anahtarlarını passphrase ile koruyun: ssh-keygen -p -f ~/.ssh/intellij_remote
  • Root ile bağlanmayın: Ayrı bir geliştirici kullanıcısı oluşturun
  • Debug portlarını firewall ile kısıtlayın: JDWP portları (5005 vb.) sadece SSH tüneli üzerinden erişilebilir olmalı
  • IntelliJ lisansını sunucu üzerinde saklamamaya dikkat edin: Gateway modelinde lisans istemcide kalır
  • fail2ban kurun: Brute force denemelerine karşı
sudo apt install -y fail2ban
sudo systemctl enable --now fail2ban

# /etc/fail2ban/jail.local
sudo tee /etc/fail2ban/jail.local << 'EOF'
[sshd]
enabled = true
port = ssh
maxretry = 5
bantime = 3600
findtime = 600
EOF

sudo systemctl restart fail2ban

Sonuç

IntelliJ IDEA Gateway ile uzak sunucuda Java geliştirme, başlangıçta biraz kurulum gerektiriyor ama bir kez düzgün çalışır hale getirdiğinizde yerel geliştirmeden neredeyse fark edilmiyor. Özellikle büyük mikro servis projeleri, kaynak yoğun derleme süreçleri ve takım tutarlılığı açısından ciddi avantajlar sunuyor.

En kritik nokta şu: SSH tünelleme, anahtar tabanlı doğrulama ve performans optimizasyonlarını doğru yapmak. Bu üç şeyi sağlamlıkla kurduğunuzda geri kalanı oldukça akıcı işliyor. SDKMAN ile JDK versiyonu yönetimi, Docker ile izolasyon ve fail2ban ile güvenlik önlemlerini de ekleyince production-grade bir geliştirme ortamına kavuşmuş oluyorsunuz.

Eğer bu yazıda anlatılan konulardan herhangi birinde takılırsanız, sunucunuzun özelliklerine göre ayarları biraz tweaking yapmanız gerekebilir. Her ortam biraz farklı davranıyor, ama temel mantık değişmiyor. İyi kodlamalar!

Bir yanıt yazın

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