Welcome to My Blog 👋

Bu yazımda Github'a yüklediğimiz Spring projemizi nasıl Jenkins ile Tomcat üzerine otomatik deploy edeceğimizi anlatacağım. Önceki yazılarımda Ubuntu sunucusunun nasıl kurulacağını ve Tomcat'in nasıl yükleneceğini bulabilirsiniz.

Buradan Jenkins download sayfasına gidiyoruz. “LTS” versiyonu kısmından Ubuntu server kurduğumuz için “Ubuntu/Debian” seçeneğini seçiyoruz.

Yukarıda gösterilen komutlar ile Jenkins’i kurmaya başlayabiliriz.

wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -

Öncelikle Jenkins için key bilgisini sistemimize ekliyoruz.

cd etc
cd apt
vi sources.list

Daha sonra sources.list dosyasını metin editörümüz ile açıyoruz.

deb https://pkg.jenkins.io/debian-stable binary/

Yukarıdaki komutu sources.list dosyamızın içerisine ekliyoruz.

sudo apt-get update
sudo apt-get install jenkins

Yukarıdaki komutları çalıştırarak Jenkins’in kurulumunu gerçekleştiriyoruz.

Yukarıda bu işlemlerdeki tüm komutları ve çıktıları görebilirsiniz.

cd ..
cd default
vi jenkins

Daha sonra yukarıdaki komutları çalıştırarak jenkins dosyasını metin editörü ile açıyoruz ve port kısmını 8081 olarak güncelliyoruz.

sudo service jenkins start
sudo service jenkins stop

Yukarıdaki komutlar ile Jenkins’i başlatıp durdurabiliriz. Jenkins’i balatıyoruz.

AWS konsoldaki sunucumuzun ip adresini kullanarak 8081 portuna bağlanıyoruz. Jenkins’in çalıştığını görebilirsiniz. Kırmızı ile yazan dosyada admin parolamız var. Bu parola ile Jenkins’e giriş yapabiliriz.

sudo vi /var/lib/jenkins/secrets/initialAdminPassword

Yukarıdaki komutu çalıştırıyoruz ve açılan dosyadaki metni kopyalayarak parolamızı giriyoruz.

“Install suggested plugins” seçeneğini seçerek önerilen eklentiler ile devam ediyoruz. Eğer isterseniz diğer seçeneği seçerek seçtiğiniz eklentiler ile devam edebilirsiniz.

Burada kısa bir süre bekliyoruz ve Jenkins gerekli eklentileri kuruyor.

Daha sonra bir admin kullanıcısı oluşturuyoruz.

Daha sonra açılan ekranda Jenkins’in erişim url bilgisini görebilirsiniz. Sizin ip adresiniz farklı olacağı için bu kısım farklılık gösterecektir.

İlerilediğimizde Jenkins’in anasayfası açılacaktır. “Jenkins’i Yönet” diyerek bir kaç ayar yapmamız gerekiyor.

“Global Tool Configuration” seçeneğini seçiyoruz.

Açılan sayfada “JDK” bölümünde sistemimizdeki “JAVA_HOME” parametresini Jenkins’e tanıtıyoruz. Muhtemelen sizin sisteminiz için de aynı değerler olacaktır ancak farklı şekilde yaptıysanız buradan nasıl JAVA_HOME parametresini bulacağınızı öğrenebilirsiniz.

Jenkins’e sistemimizdeki Git’i tanıtıyoruz. Buraya yazacağınız değerler de muhtemelen aynıdır ancak yukarıdaki komutu konsolda çalıştırarak Git’in nerede kurulu olduğunu bulabilirsiniz.

Maven için de benzer ayarlamaları yapıyoruz. “MAVEN_HOME” parametresini yukarıdaki şekilde sisteminizde öğrenebilirsiniz. Bu ayarlamaları yaptıktan sonra kaydediyoruz.

Jenkins’in anasayfasına dönüyoruz ve “Yeni Item” seçeneği ile yeni bir proje ekliyoruz. Proje adına istediğinizi verebilirsiniz. “Serbest-stil yazılım projesi yapılandır” seçeneğini seçerek “OK” diyoruz.

Daha sonra karşımıza tüm ayarlamaları yapacağımız ekran çıkıyor.

“Kaynak Kodu Yönetimi” bölümüne Github Spring projemizin url’ini veriyoruz.

“Yapılandırma” bölümüne “En üst seviye Maven hedeflerini çalıştır” seçeneğini ekliyoruz.

“Maven Versiyonu” olarak ayarlamalarını yaptığımız Maven’ı seçiyoruz ve “Hedefler” bölümüne “package” yazarak “Kaydet” seçeneğini seçiyoruz.

Açılan ekranda “Şimdi Yapılandır” seçeneğini seçerek oluşturduğumuz projeyi başlatıyoruz ve build alıyoruz.

Sol alt kısma yapılandırmamızın geldiğini görebilirsiniz. Üzerine tıklıyoruz ve açılan ekranda “Console Output” seçeneğini seçiyoruz.

“Finished: SUCCESS” yazısını görene kadar bekliyoruz. Bu yazıyı gördüğümüzde başarılı bir şekilde projemizin build olduğunu anlayabiliriz.

“Projeye Geri Dön” seçeneğini seçerek proje sayfasını açıyoruz.

Proje sayfasında “Çalışma Alanı” seçeneğini seçiyoruz.

Açılan klasör yapısında “target” klasörüne giriyoruz ve “war” dosyamızın oluştuğunu görebiliriz.

Jenkins’in anasayfasına dönüyoruz, “Jenkins’i Yönet” ve ardından “Eklentileri Yönet” seçeneklerini seçiyoruz.

“Kullanılabilir” sekmesine tıklıyoruz ve arama kısmına “deploy” yazıyoruz. “Deploy to container” eklentisini seçerek “Download now and install after restart” seçeneğini seçiyoruz. Bu şekilde build aldığımız war dosyasını kolaylıkla Tomcat üzerine deploy yapabileceğimiz eklentiyi kuruyoruz. Jenkins’in yeniden başlatılmasını bekliyoruz.

Jenkins’in anasayfasından tekrar projemizi açıyoruz ve “Konfigürasyonu Düzenle” seçeneğini seçiyoruz. “Yapılandırma Sonrası Aksiyonlar” bölümüne “Deploy war/ear to a container” seçeneğini ekliyoruz.

“WAR/EAR files” bölümüne “**/*.war” ekliyoruz. Bu şekilde build aldığımızda oluşan war dosyasının ismi ne olursa olsun direkt olarak deploy edilmek üzere bulunabiliyor.

“Context path” bölümüne url kısmında gözükecek path bilgisini veriyoruz.

“Containers” bölümünde, Tomcat 8 kurduğumuz için bu seçeneği seçiyoruz. Bu bölümdeki “Add” seçeneğini seçtiğimizde yukarıdaki gibi bir pop-up açılıyor. Buraya “tomcat-users.xml” dosyasına eklediğimiz kullanıcı bilgilerini giriyoruz. Burada dikkat edilmesi gereken nokta bu kullanıcıya “manager-script” rolü tanımlı olması gerekiyor.

“Tomcat URL” kısmına ip adresimizi ve 8080 portunu giriyoruz. Ben örneği yaparken sunucuyu restart etmem gerektiği için ip adresim değişti, bu yüzden tekrar AWS konsolun “IPv4 Public IP” alanındaki ip adresini alarak buraya girdim. Buraya girmeniz gereken ip adresi AWS konsolda bulunan ip adresidir. Sizin de sunucunuz restart olursa veya bir şekilde ip adresiniz değişirse buradaki ip adresini güncellemeniz gerekiyor.

Değişikliklerimizi kaydediyoruz ve projenin sayfasından “Şimdi Yapılandır” seçeneği ile tekrar projemizi yapılandırıyoruz. Yapılandırmanın detaylarını açarak “Console Output” seçeneği ile konsol çıktısını görüntülüyoruz. “Finished: SUCCESS” yazısını gördüğümüzde build ve deploy işleminin başarılı bir şekilde gerçekleştiğini anlayabiliriz.

Tomcat url’imizin sonuna yapılandırma ayarlarına eklediğimiz “Context Path” parametresini ekleyerek açtığımız bağlantı bizim projemizin path’i oluyor. Daha sonra buna Spring Boot ile oluşturduğum rest api endpoint’ini ekleyerek bağlantıyı açıyorum. Spring Boot ile oluşturduğum rest api’nin çalıştığını görebilirsiniz. Sizin oluşturduğunuz Spring Boot projenizin endpoint'i farklı olabileceği için o endpoint'i açabilirsiniz.

Artık Github’a push’ladığımız her commit’ten sonra Jenkins’indeki projemizi yapılandırarak otomatik olarak Tomcat’i güncelleyebiliriz ve sunucumuza değişiklikleri yansıtabiliriz.

Buradaki yazıdan AWS EC2 ile nasıl Ubuntu sunucusu oluşturulacağını okuyabilirsiniz. Bu yazı o yazının devam niteliğindedir.

Sunucumuza bağlanmak için makinelerimizin listelendiği Instances ekranından Action ardından Connect seçeneklerini seçiyoruz.

Açılan pop-up’ta SSH ile sunucuya nasıl bağlantı kuracağımız gösteriliyor. Example kısmındaki komutu kopyalayarak daha önce key pair dosyasını indirdiğimiz dizinde bir terminal başlatıyoruz.

Bu terminalde kopyaladığımız komutu çalıştırıyoruz ve sunucumuza SSH bağlantısını kurmuş oluyoruz.

sudo apt update 
sudo apt install git 
git --version

Yukarıdaki komutlar ile terminal üzerinden git’i kuruyoruz ve kurulduğunu kontrol ediyoruz.

sudo apt install openjdk-11-jdk
java -version

Yukarıdaki komutlar ile Java’yı kuruyoruz ve versiyon kontrolü yapıyoruz. Ben OpenJDK ve Java 11 kullanıyorum. Siz istediğiniz jdk’yı kullanabilirsiniz.

sudo apt install maven 
mvn --version

Yukarıdaki komutlar ile Maven’ı kuruyoruz ve versiyon kontrolü yapıyoruz.

Buradan Tomcat’in sitesine gidiyoruz ve “tar.gz” olan indirme linkini kopyalıyoruz. Ben Tomcat 8 indiriyorum siz isterseniz diğer sürümleri de kullanabilirsiniz.

sudo su -
cd /opt
sudo wget https://ftp.itu.edu.tr/Mirror/Apache/tomcat/tomcat-8/v8.5.64/bin/apache-tomcat-8.5.64.tar.gz
tar -xvzf /opt/apache-tomcat-8.5.64.tar.gz

Yukarıdaki komutları sırası ile çalıştırarak önce Tomcat’i indiriyoruz ve ardından kurulumu gerçekleştiriyoruz. “wget” ile indirdiğim link yerine siz kopyaladığınız linki yapıştırmalısınız çünkü link ve sürüm sürekli güncelleniyor. Bununla birlikte klasörün ismi de sürüm ismi ile aynı olacak şekilde güncellenmelidir.

mv apache-tomcat-8.5.64 tomcat
cd tomcat
cd bin
ls

Yukarıdaki komutları sırası ile uygulayarak önce “apache-tomcat-8.5.63” klasörünün adını “tomcat” olarak güncelliyoruz ve daha sonra Tomcat’i başlatıp durdurabileceğimiz dizine giderek “ls” komutu ile dosyaları listeliyoruz.

Yukarıda gördüğünüz dosyalardan “startup.sh” dosyasını çalıştırarak Tomcat’i başlatabilirsiniz veya “shutdown.sh” dosyasını çalıştırarak Tomcat’i durdurabilirsiniz. Tomcat’i başlatmadan önce bir kaç konfigürasyon yapalım.

cd ..
cd conf
vi tomcat-users.xml

Yukarıdaki komutları çalıştırarak “conf” dizinine gidiyoruz ve “tomcat-users.xml” dosyasını açıyoruz. Bu dosyada Tomcat’i kullanacak hesapları ve rolleri tanımlayabiliyoruz.

“tomcat-users.xml” dosyasının içeriğini yukarıdaki gibi güncelliyoruz.

“manager-gui” rolü kullanıcıya Tomcat arayüzünün yönetim ekranına giriş yetkisi verir. “manager-script” rolü ise kullanıcıya Tomcat üzerinde işlem yapabilme yetkisini verir.

Ben burada iki farklı kullanıcı oluşturdum. Birini sadece Jenkins üzerinde Tomcat’i çalıştırmak için kullanacağım, diğerini ise genel olarak Tomcat üzerindeki işlemlerim için kullanıyor olacağım. Jenkins kurulumunu sonraki yazılarda anlatacağım.

Burada “vi” metin editörünü kullanmayı bilmiyorsanız farklı bir editör kullanabilirsiniz veya internetten çok kolay bir şekilde nasıl kullanılacağını öğrenebilirsiniz.

find / -name context.xml

Tomcat arayüzündeki yönetim ekranına erişmek için bir kaç değişiklik yapmamız gerekiyor. Yukarıdaki komut ile “context.xml” dosyalarını sunucumuzda arıyoruz.

vi /opt/tomcat/webapps/host-manager/META-INF/context.xml

Öncelikle yukarıdaki komut ile “host-manager” dizini altındaki “context.xml” dosyasını açıyoruz.

vi /opt/tomcat/webapps/manager/META-INF/context.xml

Yukarıdaki komut ile “manager” dizini altındaki “context.xml” dosyasını açarak aynı şekilde düzenliyoruz.

cd ..
cd bin
ls

Yukarıdaki komutlar ile “bin” dizinine gidiyoruz.

./startup.sh

Yukarıdaki komut ile “bin” dizinindeyken Tomcat’i başlatabiliriz.

./shutdown.sh

Yukarıdaki komut ile “bin” dizinindeyken açık olan Tomcat’i durdurabiliriz.

“startup.sh” dosyasını çalıştırdığımızda yukarıdaki gibi Tomcat’in başlatıldığını görebiliriz. Şimdi sunucumuzun “8080” portunu remote olarak erişebilecek şekilde ayarlayalım.

AWS konsolda sunucumuzun “Security Groups” kısmındaki linke tıklıyoruz.

Açılan sayfada “Inbound” kısmını açıyoruz. Burada “Edit” seçeneğini seçiyoruz.

Yukarıdaki gibi “8080” ve “8081” port’ları için kurallar ekliyoruz. “8080” port’unu Tomcat, “8081” port’unu bir sonraki bölümde kuracağımız Jenkins için ekliyoruz. Eklediğimiz kurallar, sunucuya herhangi bir IP ile bu port’lar üzerinden erişilmesine izin veriyor.

AWS konsolda sunucumuz seçiliyken “IPv4 Public IP” alanındaki IP’yi kopyalıyoruz. “8080” port’unu ekleyerek tarayıcımızda açıyoruz.

Tomcat arayüzünün yukarıdaki gibi açıldığını görebiliriz. “Manager App” seçeneğini seçerek yönetim ekranına gidiyoruz. Buradan tarayıcı bizden kullanıcı adı ve parola girmemizi isteyecek. “tomcat-users.xml” dosyasına eklediğimiz genel işlemleri yapacağımız kullanıcı bilgilerini buraya giriyoruz.

Karşımıza Tomcat yönetim ekranı çıkacak. Bu ekran ile Tomcat üzerine uygulamamızı deploy edebiliriz.