Bu yazı, çalışanlarımızın müşterilerle Kubernetes'te uygulama geliştirme ve OpenShift'te bu tür geliştirmelerin ayrıntıları hakkında oldukça fazla konuşma yapması nedeniyle yazıldı.
Genellikle Kubernetes'in yalnızca Kubernetes olduğu ve OpenShift'in zaten Microsoft AKS veya Amazon EKS gibi bir Kubernetes platformu olduğu teziyle başlıyoruz. Bu platformların her birinin belirli bir hedef kitleye yönelik kendi avantajları vardır. Bundan sonra konuşma belirli platformların güçlü ve zayıf yönlerini karşılaştırmaya dönüyor.
Genel olarak bu yazıyı şöyle bir sonuçla yazmayı düşündük: “Dinleyin, kodun nerede çalıştırılacağı önemli değil; OpenShift'te veya AKS'de, EKS'de, bazı özel Kubernet'lerde veya herhangi bir Kubernetes'te. (kısaca KUK diyelim) “Hem orada hem de orada gerçekten çok basit.”
Daha sonra en basit "Merhaba Dünya"yı alıp KUC ile Red Hat OpenShift Konteyner Platformu (bundan sonra OCP veya kısaca OpenShift olarak anılacaktır) arasındaki ortak ve farkın ne olduğunu göstermek için bu örneği kullanmayı planladık.
Ancak bu yazıyı yazarken, OpenShift'i o kadar uzun zamandır kullanmaya alıştığımızı fark ettik ki, onun nasıl büyüdüğünü ve bir Kubernetes dağıtımından çok daha fazlası haline gelen muhteşem bir platforma dönüştüğünü fark edemedik. OpenShift'in olgunluğunu ve basitliğini hafife alma ve onun parlaklığını gözden kaçırma eğilimindeyiz.
Genel olarak, aktif tövbenin zamanı geldi ve şimdi "Merhaba Dünya"mızın KUK ve OpenShift'te devreye alınmasını adım adım karşılaştıracağız ve bunu mümkün olduğunca objektif bir şekilde yapacağız (bazen bir konuya kişisel tutum). Bu konuyla ilgili tamamen öznel bir görüşle ilgileniyorsanız, okuyabilirsiniz. . Ve bu yazıda gerçeklere ve yalnızca gerçeklere sadık kalacağız.
kümeler
Yani “Merhaba Dünyamız” kümelere ihtiyaç duyuyor. Sunucular, kayıtlar, ağlar, veri aktarımı vb. için ödeme yapmamak için herhangi bir genel buluta hemen "hayır" diyeceğiz. Buna göre basit tek düğümlü bir küme seçiyoruz. (KUK için) ve (OpenShift kümesi için). Bu seçeneklerin her ikisinin de kurulumu gerçekten kolaydır, ancak dizüstü bilgisayarınızda oldukça fazla kaynak gerektirecektir.
KUK-e'de montaj
Hadi, gidelim.
Adım 1 – konteyner imajımızı oluşturmak
“Merhaba Dünya”mızı minikube'e dağıtarak başlayalım. Bunu yapmak için ihtiyacınız olacak:
- 1. Docker kuruldu.
- 2. Git kuruldu.
- 3. Maven kuruldu (aslında bu proje mvnw ikili dosyasını kullanıyor, yani onsuz da yapabilirsiniz).
- 4. Aslında kaynağın kendisi yani. depo klonu
İlk adım bir Quarkus projesi oluşturmaktır. Quarkus.io ile hiç çalışmadıysanız paniğe kapılmayın; bu kolaydır. Siz sadece projede kullanmak istediğiniz bileşenleri (RestEasy, Hibernate, Amazon SQS, Camel, vb.) seçersiniz ve ardından Quarkus, sizin katılımınız olmadan maven arketipini yapılandırır ve her şeyi github'a koyar. Yani, kelimenin tam anlamıyla fareye tek bir tıklamayla işiniz bitti. İşte bu yüzden Quarkus'u seviyoruz.
“Merhaba Dünya”mızı bir konteyner görüntüsüne oluşturmanın en kolay yolu, gerekli tüm işleri yapacak olan Docker için quarkus-maven uzantılarını kullanmaktır. Quarkus'un gelişiyle bu gerçekten kolay ve basit hale geldi: Container-image-docker uzantısını ekleyin ve maven komutlarını kullanarak görüntüler oluşturabilirsiniz.
./mvnw quarkus:add-extension -Dextensions=”container-image-docker”
Son olarak Maven kullanarak imajımızı oluşturuyoruz. Sonuç olarak kaynak kodumuz, konteyner çalışma zamanı ortamında zaten çalıştırılabilen hazır bir konteyner görüntüsüne dönüşür.
./mvnw -X clean package -Dquarkus.container-image.build=true
Hepsi bu kadar, artık konteyneri docker run komutuyla başlatabilir, hizmetimizi erişilebilmesi için 8080 numaralı bağlantı noktasına eşleyebilirsiniz.
docker run -i — rm -p 8080:8080 gcolman/quarkus-hello-world
Konteyner örneği başladıktan sonra geriye kalan tek şey, hizmetimizin çalıştığını curl komutuyla kontrol etmektir:
Yani her şey işe yarıyor ve gerçekten kolay ve basitti.
Adım 2 – kapsayıcımızı kapsayıcı görüntü deposuna gönderin
Şimdilik oluşturduğumuz imaj yerel olarak, yerel konteyner depomuzda saklanıyor. Bu görüntüyü COOK ortamımızda kullanmak istiyorsak, başka bir depoya yerleştirilmesi gerekir. Kubernetes'te bu tür özellikler bulunmadığından dockerhub kullanacağız. Çünkü birincisi ücretsizdir ve ikincisi (neredeyse) herkes bunu yapar.
Bu da çok basit ve ihtiyacınız olan tek şey bir dockerhub hesabı.
Böylece dockerhub kuruyoruz ve imajımızı oraya gönderiyoruz.
3. Adım – Kubernetes'i başlatın
“Merhaba Dünya”mızı çalıştırmak için Kubernetes yapılandırmasını birleştirmenin birçok yolu vardır, ancak biz bunların en basitini kullanacağız, biz bu şekildeyiz...
Öncelikle minikube kümesini başlatalım:
minikube start
Adım 4 – konteyner imajımızı dağıtın
Artık kodumuzu ve konteyner imajımızı kubernetes konfigürasyonlarına dönüştürmemiz gerekiyor. Yani dockerhub üzerinde konteyner imajımızı işaret eden bir pod ve dağıtım tanımına ihtiyacımız var. Bunu yapmanın en kolay yollarından biri, imajımızı işaret eden create dağıtım komutunu çalıştırmaktır:
kubectl create deployment hello-quarkus — image =gcolman/quarkus-hello-world:1.0.0-SNAPSHOT
Bu komutla COO'muza, konteyner imajımız için pod spesifikasyonunu içermesi gereken bir dağıtım konfigürasyonu oluşturmasını söyledik. Bu komut aynı zamanda bu konfigürasyonu minikube kümemize de uygulayacak ve konteyner imajımızı indirecek ve kümedeki pod'u başlatacak bir dağıtım oluşturacaktır.
Adım 5 – Hizmetimize açık erişim
Artık konuşlandırılmış bir konteyner imajımız olduğuna göre, aslında kodumuzda programlanan bu Restful hizmetine harici erişimin nasıl yapılandırılacağını düşünmenin zamanı geldi.
Burada birçok yol var. Örneğin, hizmetler ve uç noktalar gibi uygun Kubernetes bileşenlerini otomatik olarak oluşturmak için maruz bırakma komutunu kullanabilirsiniz. Aslında dağıtım nesnemiz için Expose komutunu çalıştırarak yapacağımız şey budur:
kubectl expose deployment hello-quarkus — type=NodePort — port=8080
Expose komutunun "-type" seçeneğine bakmak için biraz zaman ayıralım.
Hizmetimizi çalıştırmak için gerekli bileşenleri ortaya çıkardığımızda ve oluşturduğumuzda, diğer şeylerin yanı sıra, yazılım tanımlı ağımızın içinde yer alan hello-quarkus hizmetine dışarıdan bağlanabilmemiz gerekir. Ve parametre tip trafiği bu ağa yönlendirmek için yük dengeleyiciler gibi şeyler oluşturmamıza ve bağlamamıza olanak tanır.
Örneğin yazarak tür=Yük Dengeleyici, Kubernetes kümemize bağlanmak için genel bulutta otomatik olarak bir yük dengeleyici sağlıyoruz. Bu elbette harika, ancak böyle bir yapılandırmanın belirli bir genel buluta sıkı sıkıya bağlı olacağını ve farklı ortamlardaki Kubernetes örnekleri arasında aktarımın daha zor olacağını anlamalısınız.
Örneğimizde tür=NodePortyani hizmetimize düğümün IP adresi ve port numarası ile erişilmektedir. Bu seçenek herhangi bir genel bulutu kullanmamanıza olanak tanır ancak bir dizi ek adım gerektirir. Öncelikle kendi yük dengeleyicinize ihtiyacınız var, bu yüzden NGINX yük dengeleyiciyi kümemizde konuşlandıracağız.
Adım 6 – bir yük dengeleyici yükleyin
minikube, giriş denetleyicileri gibi dışarıdan erişilebilen bileşenler oluşturmayı kolaylaştıran bir dizi platform işlevine sahiptir. Minikube, Nginx giriş denetleyicisiyle birlikte gelir ve tek yapmamız gereken onu etkinleştirmek ve yapılandırmak.
minikube addons enable ingress
Şimdi minikube kümemizin içinde çalışacak tek komutla bir Nginx giriş denetleyicisi oluşturacağız:
ingress-nginx-controller-69ccf5d9d8-j5gs9 1/1 Running 1 33m
Adım 7 – Girişin ayarlanması
Şimdi Nginx giriş denetleyicisini hello-quarkus isteklerini kabul edecek şekilde yapılandırmamız gerekiyor.
Ve son olarak bu konfigürasyonu uygulamamız gerekiyor.
kubectl apply -f ingress.yml
Tüm bunları kendi bilgisayarımızda yaptığımız için, http isteklerini minikube'ümüze NGINX yük dengeleyicisine yönlendirmek için /etc/hosts dosyasına düğümümüzün IP adresini eklemeniz yeterlidir.
192.168.99.100 hello-quarkus.info
İşte bu, artık minikube hizmetimize Nginx giriş denetleyicisi aracılığıyla harici olarak erişilebiliyor.
Bu kolaydı, değil mi? Yoksa o kadar da değil mi?
OpenShift'te Çalıştırma (Kod Hazır Konteynerler)
Şimdi tüm bunların Red Hat OpenShift Konteyner Platformunda (OCP) nasıl yapıldığını görelim.
Minikube'de olduğu gibi Code Ready Containers (CRC) formunda tek düğümlü OpenShift küme tasarımını seçiyoruz. Daha önce minishift olarak adlandırılıyordu ve OpenShift Origin projesini temel alıyordu, ancak şimdi CRC olup Red Hat'in OpenShift Konteyner Platformu üzerine inşa edildi.
Burada kusura bakmayın ama şunu söylemeden edemiyoruz: "OpenShift harika!"
Başlangıçta OpenShift üzerindeki geliştirmenin Kubernetes üzerindeki geliştirmeden hiçbir farkı olmadığını yazmayı düşündük. Ve özünde bu böyledir. Ancak bu yazıyı yazma sürecinde, OpenShift'e sahip olmadığınızda ne kadar fazladan hareket yapmanız gerektiğini hatırladık ve yine bu yüzden harika. Her şeyin kolayca yapılmasını seviyoruz ve örneğimizin Minikube'e kıyasla OpenShift'te konuşlandırılması ve çalıştırılmasının ne kadar kolay olduğu bizi bu yazıyı yazmaya iten şeydi.
Süreci gözden geçirelim ve ne yapmamız gerektiğine bakalım.
Yani minikube örneğinde Docker ile başladık... Durun, artık makinede Docker'ın kurulu olmasına ihtiyacımız yok.
Ve yerel git'e ihtiyacımız yok.
Ve Maven'e ihtiyaç yok.
Ayrıca elle bir kapsayıcı görüntüsü oluşturmanıza gerek yoktur.
Ayrıca herhangi bir konteyner görseli deposu aramanıza da gerek yok.
Ayrıca bir giriş denetleyicisi kurmaya gerek yoktur.
Ayrıca girişi yapılandırmanıza da gerek yoktur.
Anladın değil mi? Uygulamamızı OpenShift'te dağıtmak ve çalıştırmak için yukarıdakilerin hiçbirine ihtiyacınız yoktur. Ve sürecin kendisi buna benziyor.
Adım 1 – OpenShift kümenizi başlatın
Aslında aynı Minikube olan, ancak yalnızca tam teşekküllü tek düğümlü Openshift kümesine sahip olan Red Hat'in Code Ready Container'larını kullanıyoruz.
crc start
Adım 2 – Uygulamayı oluşturun ve OpenShift kümesine dağıtın
OpenShift'in sadeliği ve rahatlığı işte bu adımda tüm görkemiyle ortaya çıkıyor. Tüm Kubernetes dağıtımlarında olduğu gibi, bir uygulamayı kümede çalıştırmanın birçok yolu vardır. Ve KUK örneğinde olduğu gibi, özellikle en basitini seçiyoruz.
OpenShift her zaman kapsayıcılı uygulamalar oluşturmaya ve çalıştırmaya yönelik bir platform olarak oluşturulmuştur. Konteyner oluşturma her zaman bu platformun ayrılmaz bir parçası olmuştur, dolayısıyla ilgili görevler için tonlarca ek Kubernetes kaynağı bulunmaktadır.
Kaynağımızı (kod veya ikili dosyalar) almanın ve onu bir OpenShift kümesinde çalışan konteynerleştirilmiş bir görüntüye dönüştürmenin birkaç farklı yoluna sahip olan OpenShift'in Kaynak 2 Görüntüsü (S2I) işlemini kullanacağız.
Bunu yapmak için iki şeye ihtiyacımız var:
- Kaynak kodumuz git deposunda
- Yapının gerçekleştirileceği temel alınarak oluşturucu görüntüsü.
Hem Red Hat tarafından hem de topluluk düzeyinde tutulan buna benzer pek çok görüntü var ve ben bir Java uygulaması oluşturduğum için OpenJDK görüntüsünü kullanacağız.
S2I yapısını hem OpenShift Developer grafik konsolundan hem de komut satırından çalıştırabilirsiniz. Oluşturucu görüntüsünü ve kaynak kodumuzu nereden alacağını söyleyerek new-app komutunu kullanacağız.
oc new-app registry.access.redhat.com/ubi8/openjdk-11:latest~https://github.com/gcolman/quarkus-hello-world.git
İşte bu kadar, uygulamamız oluşturuldu. Bunu yaparken S2I süreci aşağıdakileri yaptı:
- Uygulamanın oluşturulmasıyla ilgili her türlü şey için bir hizmet oluşturma bölmesi oluşturuldu.
- OpenShift Build yapılandırması oluşturuldu.
- Oluşturucu görüntüsünü dahili OpenShift liman işçisi kayıt defterine indirdim.
- "Merhaba Dünya" yerel depoya kopyalandı.
- Orada bir maven pom olduğunu gördüm ve uygulamayı maven kullanarak derledim.
- Derlenmiş Java uygulamasını içeren yeni bir kapsayıcı görüntüsü oluşturuldu ve bu görüntüyü dahili kapsayıcı kayıt defterine yerleştirildi.
- Kapsül, hizmet vb. spesifikasyonlarla Kubernetes Dağıtımı oluşturuldu.
- Konteyner görüntüsünü dağıtmaya başladım.
- Hizmet derleme bölmesi kaldırıldı.
Bu listede pek çok şey var, ancak asıl önemli olan, tüm yapının yalnızca OpenShift içinde gerçekleşmesi, dahili Docker kayıt defterinin OpenShift'in içinde olması ve derleme sürecinin tüm Kubernetes bileşenlerini oluşturup bunları kümede çalıştırmasıdır.
Konsolda S2I'nin başlatılmasını görsel olarak izlerseniz, derleme tamamlandığında derleme bölmesinin nasıl başlatıldığını görebilirsiniz.
Şimdi oluşturucu pod günlüklerine bir göz atalım: ilk olarak, maven'in işini nasıl yaptığını ve java uygulamamızı oluşturmak için bağımlılıkları nasıl indirdiğini gösterir.
Maven yapısı tamamlandıktan sonra konteyner görüntüsünün oluşturulması başlatılır ve ardından bu oluşturulan görüntü dahili depoya gönderilir.
İşte bu, yapım süreci tamamlandı. Şimdi uygulamamızın pod ve servislerinin Cluster’da çalıştığından emin olalım.
oc get service
Bu kadar. Ve sadece bir takım. Tek yapmamız gereken bu hizmeti dışarıdan erişime açmak.
Adım 3 – hizmeti dışarıdan erişime açık hale getirin
KUC örneğinde olduğu gibi, OpenShift platformunda da "Merhaba Dünyamız"ın harici trafiği küme içindeki hizmete yönlendirmek için bir yönlendiriciye ihtiyacı vardır. OpenShift bunu çok kolaylaştırıyor. Öncelikle HAProxy yönlendirme bileşeni varsayılan olarak kümeye kurulur (aynı NGINX olarak değiştirilebilir). İkinci olarak, Routes adı verilen ve eski güzel Kubernetes'teki Ingress nesnelerini anımsatan özel ve oldukça yapılandırılabilir kaynaklar vardır (aslında OpenShift'in Routes'ı, artık OpenShift'te kullanılabilen Ingress nesnelerinin tasarımını büyük ölçüde etkilemiştir), ancak "Merhaba Dünyamız" için ve hemen hemen tüm diğer durumlarda, ek yapılandırma olmadan standart Rota bizim için yeterlidir.
“Merhaba Dünya” için yönlendirilebilir bir FQDN oluşturmak için (evet, OpenShiift'in hizmet adlarına göre yönlendirme için kendi DNS'si vardır), hizmetimizi basitçe ortaya çıkaracağız:
oc expose service quarkus-hello-world
Yeni oluşturulan Rotaya bakarsanız, FQDN'yi ve diğer yönlendirme bilgilerini burada bulabilirsiniz:
oc get route
Ve son olarak hizmetimize tarayıcıdan erişiyoruz:
Ama şimdi gerçekten kolaydı!
Kubernetes'i ve bu teknolojinin bize sağladığı her şeyi seviyoruz, aynı zamanda basitliği ve kolaylığı da seviyoruz. Kubernetes, dağıtılmış, ölçeklenebilir konteynerlerin çalışmasını inanılmaz derecede basitleştirmek için yaratıldı ancak basitliği, günümüzde uygulamaları üretime geçirmek için artık yeterli değil. İşte bu noktada zamana ayak uyduran ve öncelikli olarak geliştiriciyi hedefleyen Kubernetes'i sunan OpenShift devreye giriyor. OpenShift platformunu geliştiriciye özel olarak uyarlamak için S2I, ODI, Geliştirici Portalı, OpenShift Operatör Çerçevesi, IDE entegrasyonu, Geliştirici Katalogları, Helm entegrasyonu, izleme ve diğerleri gibi araçların oluşturulması da dahil olmak üzere çok fazla çaba harcandı.
Bu makalenin sizin için ilginç ve yararlı olduğunu umuyoruz. Portaldaki OpenShift platformunda geliştirme için yararlı ek kaynaklar, materyaller ve diğer şeyleri bulabilirsiniz. .
Kaynak: habr.com